diff --git a/examples/src/bin/decodebin.rs b/examples/src/bin/decodebin.rs
index d8bc68988..cc018b006 100644
--- a/examples/src/bin/decodebin.rs
+++ b/examples/src/bin/decodebin.rs
@@ -173,16 +173,14 @@ fn example_main() -> Result<(), Error> {
                             })
                             .map(Result::Err)
                             .expect("error-details message without actual error"),
-                        _ => Err(
-                            ErrorMessage {
-                                src: msg.get_src()
-                                    .map(|s| s.get_path_string())
-                                    .unwrap_or_else(|| String::from("None")),
-                                error: err.get_error().description().into(),
-                                debug: err.get_debug(),
-                                cause: err.get_error(),
-                            }.into(),
-                        ),
+                        _ => Err(ErrorMessage {
+                            src: msg.get_src()
+                                .map(|s| s.get_path_string())
+                                .unwrap_or_else(|| String::from("None")),
+                            error: err.get_error().description().into(),
+                            debug: err.get_debug(),
+                            cause: err.get_error(),
+                        }.into()),
                     }?;
                 }
                 #[cfg(not(feature = "v1_10"))]
diff --git a/gstreamer-app/src/app_src.rs b/gstreamer-app/src/app_src.rs
index e1644f326..1ab72359a 100644
--- a/gstreamer-app/src/app_src.rs
+++ b/gstreamer-app/src/app_src.rs
@@ -186,7 +186,6 @@ impl AppSrc {
         }
     }
 
-
     pub fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) {
         unsafe {
             let mut min = mem::uninitialized();
diff --git a/gstreamer-audio/src/audio_channel_position.rs b/gstreamer-audio/src/audio_channel_position.rs
index 882c843b7..310b45d04 100644
--- a/gstreamer-audio/src/audio_channel_position.rs
+++ b/gstreamer-audio/src/audio_channel_position.rs
@@ -101,13 +101,14 @@ impl AudioChannelPosition {
         }
 
         let len = positions.len();
-        let mut positions_raw: [ffi::GstAudioChannelPosition; 64] = array_init::array_init_copy(
-            |i| if i >= len as usize {
-                ffi::GST_AUDIO_CHANNEL_POSITION_INVALID
-            } else {
-                positions[i].to_glib()
-            },
-        );
+        let mut positions_raw: [ffi::GstAudioChannelPosition; 64] =
+            array_init::array_init_copy(|i| {
+                if i >= len as usize {
+                    ffi::GST_AUDIO_CHANNEL_POSITION_INVALID
+                } else {
+                    positions[i].to_glib()
+                }
+            });
 
         let valid: bool = unsafe {
             from_glib(ffi::gst_audio_channel_positions_to_valid_order(
diff --git a/gstreamer-audio/src/audio_format_info.rs b/gstreamer-audio/src/audio_format_info.rs
index 7c6b0a7d8..bad1c1f5e 100644
--- a/gstreamer-audio/src/audio_format_info.rs
+++ b/gstreamer-audio/src/audio_format_info.rs
@@ -194,7 +194,6 @@ impl AudioFormatInfo {
         self.flags().contains(::AudioFormatFlags::SIGNED)
     }
 
-
     pub fn is_little_endian(&self) -> bool {
         self.endianness() == AudioEndianness::LittleEndian
     }
@@ -253,9 +252,9 @@ impl glib::types::StaticType for AudioFormatInfo {
 #[doc(hidden)]
 impl<'a> glib::value::FromValueOptional<'a> for AudioFormatInfo {
     unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
-        Option::<AudioFormatInfo>::from_glib_none(
-            gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *mut ffi::GstAudioFormatInfo,
-        )
+        Option::<AudioFormatInfo>::from_glib_none(gobject_ffi::g_value_get_boxed(
+            value.to_glib_none().0,
+        ) as *mut ffi::GstAudioFormatInfo)
     }
 }
 
diff --git a/gstreamer-audio/src/audio_info.rs b/gstreamer-audio/src/audio_info.rs
index 01abfb1a2..df0d5df48 100644
--- a/gstreamer-audio/src/audio_info.rs
+++ b/gstreamer-audio/src/audio_info.rs
@@ -42,13 +42,14 @@ impl<'a> AudioInfoBuilder<'a> {
                     return None;
                 }
 
-                let positions: [ffi::GstAudioChannelPosition; 64] = array_init::array_init_copy(
-                    |i| if i >= self.channels as usize {
-                        ffi::GST_AUDIO_CHANNEL_POSITION_INVALID
-                    } else {
-                        p[i].to_glib()
-                    },
-                );
+                let positions: [ffi::GstAudioChannelPosition; 64] =
+                    array_init::array_init_copy(|i| {
+                        if i >= self.channels as usize {
+                            ffi::GST_AUDIO_CHANNEL_POSITION_INVALID
+                        } else {
+                            p[i].to_glib()
+                        }
+                    });
 
                 let valid: bool = from_glib(ffi::gst_audio_check_valid_channel_positions(
                     positions.as_ptr() as *mut _,
diff --git a/gstreamer-player/src/config.rs b/gstreamer-player/src/config.rs
index a71e59584..60a64c3d9 100644
--- a/gstreamer-player/src/config.rs
+++ b/gstreamer-player/src/config.rs
@@ -46,7 +46,9 @@ impl AsMut<gst::StructureRef> for PlayerConfig {
 impl PlayerConfig {
     pub fn get_position_update_interval(&self) -> u32 {
         assert_initialized_main_thread!();
-        unsafe { ffi::gst_player_config_get_position_update_interval(self.0.to_glib_none().0) }
+        unsafe {
+            ffi::gst_player_config_get_position_update_interval(self.0.to_glib_none().0)
+        }
     }
 
     pub fn get_seek_accurate(&self) -> bool {
diff --git a/gstreamer-player/src/player.rs b/gstreamer-player/src/player.rs
index 6cff2bf79..8ac8d155f 100644
--- a/gstreamer-player/src/player.rs
+++ b/gstreamer-player/src/player.rs
@@ -83,7 +83,6 @@ impl Player {
         }
     }
 
-
     pub fn connect_seek_done<F: Fn(&Player, gst::ClockTime) + Send + 'static>(
         &self,
         f: F,
diff --git a/gstreamer-player/src/player_g_main_context_signal_dispatcher.rs b/gstreamer-player/src/player_g_main_context_signal_dispatcher.rs
index 52249a976..48e87339f 100644
--- a/gstreamer-player/src/player_g_main_context_signal_dispatcher.rs
+++ b/gstreamer-player/src/player_g_main_context_signal_dispatcher.rs
@@ -19,10 +19,10 @@ impl PlayerGMainContextSignalDispatcher {
         let application_context = application_context.into();
         let application_context = application_context.to_glib_none();
         unsafe {
-            from_glib_full(
-                ffi::gst_player_g_main_context_signal_dispatcher_new(application_context.0)
-                    as *mut ffi::GstPlayerGMainContextSignalDispatcher,
+            from_glib_full(ffi::gst_player_g_main_context_signal_dispatcher_new(
+                application_context.0,
             )
+                as *mut ffi::GstPlayerGMainContextSignalDispatcher)
         }
     }
 }
diff --git a/gstreamer-video/src/video_event.rs b/gstreamer-video/src/video_event.rs
index cf41ba205..72b7c9d5d 100644
--- a/gstreamer-video/src/video_event.rs
+++ b/gstreamer-video/src/video_event.rs
@@ -237,13 +237,13 @@ impl<'a> UpstreamForceKeyUnitEventBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &mut Self| {
-        ffi::gst_video_event_new_upstream_force_key_unit(
+    event_builder_generic_impl!(
+        |s: &mut Self| ffi::gst_video_event_new_upstream_force_key_unit(
             s.running_time.to_glib(),
             s.all_headers.to_glib(),
             s.count,
         )
-    });
+    );
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -315,9 +315,9 @@ impl<'a> StillFrameEventBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &mut Self| {
-        ffi::gst_video_event_new_still_frame(s.in_still.to_glib())
-    });
+    event_builder_generic_impl!(|s: &mut Self| ffi::gst_video_event_new_still_frame(
+        s.in_still.to_glib()
+    ));
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/gstreamer-video/src/video_frame.rs b/gstreamer-video/src/video_frame.rs
index 865781dd0..89312f89a 100644
--- a/gstreamer-video/src/video_frame.rs
+++ b/gstreamer-video/src/video_frame.rs
@@ -334,7 +334,6 @@ mod tests {
         assert!(frame.info() == &info);
     }
 
-
     #[test]
     fn test_map_write() {
         gst::init().unwrap();
diff --git a/gstreamer-video/src/video_info.rs b/gstreamer-video/src/video_info.rs
index 4d4b93552..c12873421 100644
--- a/gstreamer-video/src/video_info.rs
+++ b/gstreamer-video/src/video_info.rs
@@ -521,9 +521,9 @@ impl VideoInfo {
     pub fn multiview_flags(&self) -> ::VideoMultiviewFlags {
         unsafe {
             let ptr = &self.0._gst_reserved as *const _ as *const u32;
-            from_glib(ffi::GstVideoMultiviewFlags::from_bits_truncate(
-                ptr::read(ptr.offset(1)),
-            ))
+            from_glib(ffi::GstVideoMultiviewFlags::from_bits_truncate(ptr::read(
+                ptr.offset(1),
+            )))
         }
     }
 
diff --git a/gstreamer/src/buffer.rs b/gstreamer/src/buffer.rs
index 19c7d4154..7e41bf8de 100644
--- a/gstreamer/src/buffer.rs
+++ b/gstreamer/src/buffer.rs
@@ -157,7 +157,9 @@ impl GstRc<BufferRef> {
 
     pub fn append(buffer: Self, other: Self) -> Self {
         skip_assert_initialized!();
-        unsafe { from_glib_full(ffi::gst_buffer_append(buffer.into_ptr(), other.into_ptr())) }
+        unsafe {
+            from_glib_full(ffi::gst_buffer_append(buffer.into_ptr(), other.into_ptr()))
+        }
     }
 }
 
@@ -170,8 +172,9 @@ impl Default for GstRc<BufferRef> {
 impl BufferRef {
     pub fn map_readable(&self) -> Option<BufferMap<Readable>> {
         let mut map_info: ffi::GstMapInfo = unsafe { mem::zeroed() };
-        let res =
-            unsafe { ffi::gst_buffer_map(self.as_mut_ptr(), &mut map_info, ffi::GST_MAP_READ) };
+        let res = unsafe {
+            ffi::gst_buffer_map(self.as_mut_ptr(), &mut map_info, ffi::GST_MAP_READ)
+        };
         if res == glib_ffi::GTRUE {
             Some(BufferMap {
                 buffer: self,
@@ -437,7 +440,9 @@ impl<'a, T> BufferMap<'a, T> {
 
 impl<'a> BufferMap<'a, Writable> {
     pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size) }
+        unsafe {
+            slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size)
+        }
     }
 }
 
@@ -516,7 +521,9 @@ impl<T> MappedBuffer<T> {
 
 impl MappedBuffer<Writable> {
     pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size) }
+        unsafe {
+            slice::from_raw_parts_mut(self.map_info.data as *mut u8, self.map_info.size)
+        }
     }
 }
 
diff --git a/gstreamer/src/bus.rs b/gstreamer/src/bus.rs
index 1a3848fb4..c06e4779a 100644
--- a/gstreamer/src/bus.rs
+++ b/gstreamer/src/bus.rs
@@ -136,7 +136,9 @@ impl Bus {
     }
 
     pub fn unset_sync_handler(&self) {
-        unsafe { ffi::gst_bus_set_sync_handler(self.to_glib_none().0, None, ptr::null_mut(), None) }
+        unsafe {
+            ffi::gst_bus_set_sync_handler(self.to_glib_none().0, None, ptr::null_mut(), None)
+        }
     }
 }
 
diff --git a/gstreamer/src/context.rs b/gstreamer/src/context.rs
index 7c3ab2ac1..ed1a0fe75 100644
--- a/gstreamer/src/context.rs
+++ b/gstreamer/src/context.rs
@@ -59,14 +59,16 @@ impl ContextRef {
     }
 
     pub fn get_structure(&self) -> &StructureRef {
-        unsafe { StructureRef::from_glib_borrow(ffi::gst_context_get_structure(self.as_mut_ptr())) }
+        unsafe {
+            StructureRef::from_glib_borrow(ffi::gst_context_get_structure(self.as_mut_ptr()))
+        }
     }
 
     pub fn get_mut_structure(&mut self) -> &mut StructureRef {
         unsafe {
-            StructureRef::from_glib_borrow_mut(
-                ffi::gst_context_writable_structure(self.as_mut_ptr()),
-            )
+            StructureRef::from_glib_borrow_mut(ffi::gst_context_writable_structure(
+                self.as_mut_ptr(),
+            ))
         }
     }
 }
diff --git a/gstreamer/src/element.rs b/gstreamer/src/element.rs
index 1d5e31c55..fb6cfe6c4 100644
--- a/gstreamer/src/element.rs
+++ b/gstreamer/src/element.rs
@@ -224,9 +224,9 @@ impl<O: IsA<Element>> ElementExtManual for O {
             let klass = (*(self.to_glib_none().0 as *mut gobject_ffi::GTypeInstance)).g_class
                 as *mut ffi::GstElementClass;
 
-            FromGlibPtrContainer::from_glib_none(
-                ffi::gst_element_class_get_pad_template_list(klass),
-            )
+            FromGlibPtrContainer::from_glib_none(ffi::gst_element_class_get_pad_template_list(
+                klass,
+            ))
         }
     }
 
diff --git a/gstreamer/src/enums.rs b/gstreamer/src/enums.rs
index 3c40de9fe..4ab4b35d7 100644
--- a/gstreamer/src/enums.rs
+++ b/gstreamer/src/enums.rs
@@ -218,7 +218,6 @@ impl Error for PadLinkError {
     }
 }
 
-
 impl ClockReturn {
     pub fn into_result(self) -> Result<ClockSuccess, ClockError> {
         match self {
@@ -299,7 +298,6 @@ impl Ord for ::TypeFindProbability {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.to_glib().cmp(&other.to_glib())
     }
-
 }
 
 impl PartialOrd for ::Rank {
@@ -312,5 +310,4 @@ impl Ord for ::Rank {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.to_glib().cmp(&other.to_glib())
     }
-
 }
diff --git a/gstreamer/src/event.rs b/gstreamer/src/event.rs
index 0cb4e523b..dfe820138 100644
--- a/gstreamer/src/event.rs
+++ b/gstreamer/src/event.rs
@@ -734,7 +734,6 @@ impl<'a> Qos<'a> {
     }
 }
 
-
 pub struct Seek<'a>(&'a EventRef);
 impl<'a> Seek<'a> {
     pub fn get(
@@ -947,9 +946,7 @@ impl<'a> FlushStopBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_flush_stop(s.reset_time.to_glib())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_flush_stop(s.reset_time.to_glib()));
 }
 
 pub struct StreamStartBuilder<'a> {
@@ -1036,9 +1033,7 @@ impl<'a> SegmentBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_segment(s.segment.to_glib_none().0)
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_segment(s.segment.to_glib_none().0));
 }
 
 #[cfg(any(feature = "v1_10", feature = "dox"))]
@@ -1060,9 +1055,9 @@ impl<'a> StreamCollectionBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_stream_collection(s.stream_collection.to_glib_none().0)
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_stream_collection(
+        s.stream_collection.to_glib_none().0
+    ));
 }
 
 pub struct TagBuilder<'a> {
@@ -1109,14 +1104,12 @@ impl<'a> BufferSizeBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_buffer_size(
-            s.minsize.get_format().to_glib(),
-            s.minsize.get_value(),
-            s.maxsize.get_value(),
-            s.async.to_glib(),
-        )
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_buffer_size(
+        s.minsize.get_format().to_glib(),
+        s.minsize.get_value(),
+        s.maxsize.get_value(),
+        s.async.to_glib(),
+    ));
 }
 
 pub struct SinkMessageBuilder<'a> {
@@ -1138,9 +1131,10 @@ impl<'a> SinkMessageBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_sink_message(s.name.to_glib_none().0, s.msg.as_mut_ptr())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_sink_message(
+        s.name.to_glib_none().0,
+        s.msg.as_mut_ptr()
+    ));
 }
 
 #[cfg(any(feature = "v1_10", feature = "dox"))]
@@ -1162,9 +1156,9 @@ impl<'a> StreamGroupDoneBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_stream_group_done(s.group_id.to_glib())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_stream_group_done(
+        s.group_id.to_glib()
+    ));
 }
 
 pub struct EosBuilder<'a> {
@@ -1204,9 +1198,10 @@ impl<'a> TocBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_toc(s.toc.to_glib_none().0, s.updated.to_glib())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_toc(
+        s.toc.to_glib_none().0,
+        s.updated.to_glib()
+    ));
 }
 
 pub struct ProtectionBuilder<'a> {
@@ -1237,13 +1232,11 @@ impl<'a> ProtectionBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_protection(
-            s.system_id.to_glib_none().0,
-            s.data.as_mut_ptr(),
-            s.origin.to_glib_none().0,
-        )
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_protection(
+        s.system_id.to_glib_none().0,
+        s.data.as_mut_ptr(),
+        s.origin.to_glib_none().0,
+    ));
 }
 
 pub struct SegmentDoneBuilder<'a> {
@@ -1263,9 +1256,10 @@ impl<'a> SegmentDoneBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_segment_done(s.position.get_format().to_glib(), s.position.get_value())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_segment_done(
+        s.position.get_format().to_glib(),
+        s.position.get_value()
+    ));
 }
 
 pub struct GapBuilder<'a> {
@@ -1287,9 +1281,10 @@ impl<'a> GapBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_gap(s.timestamp.to_glib(), s.duration.to_glib())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_gap(
+        s.timestamp.to_glib(),
+        s.duration.to_glib()
+    ));
 }
 
 pub struct QosBuilder<'a> {
@@ -1315,14 +1310,12 @@ impl<'a> QosBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_qos(
-            s.type_.to_glib(),
-            s.proportion,
-            s.diff,
-            s.timestamp.to_glib(),
-        )
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_qos(
+        s.type_.to_glib(),
+        s.proportion,
+        s.diff,
+        s.timestamp.to_glib(),
+    ));
 }
 
 pub struct SeekBuilder<'a> {
@@ -1359,17 +1352,15 @@ impl<'a> SeekBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_seek(
-            s.rate,
-            s.start.get_format().to_glib(),
-            s.flags.to_glib(),
-            s.start_type.to_glib(),
-            s.start.get_value(),
-            s.stop_type.to_glib(),
-            s.stop.get_value(),
-        )
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_seek(
+        s.rate,
+        s.start.get_format().to_glib(),
+        s.flags.to_glib(),
+        s.start_type.to_glib(),
+        s.start.get_value(),
+        s.stop_type.to_glib(),
+        s.stop.get_value(),
+    ));
 }
 
 pub struct NavigationBuilder<'a> {
@@ -1441,15 +1432,13 @@ impl<'a> StepBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_step(
-            s.amount.get_format().to_glib(),
-            s.amount.get_value() as u64,
-            s.rate,
-            s.flush.to_glib(),
-            s.intermediate.to_glib(),
-        )
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_step(
+        s.amount.get_format().to_glib(),
+        s.amount.get_value() as u64,
+        s.rate,
+        s.flush.to_glib(),
+        s.intermediate.to_glib(),
+    ));
 }
 
 pub struct ReconfigureBuilder<'a> {
@@ -1487,9 +1476,7 @@ impl<'a> TocSelectBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_toc_select(s.uid.to_glib_none().0)
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_toc_select(s.uid.to_glib_none().0));
 }
 
 #[cfg(any(feature = "v1_10", feature = "dox"))]
@@ -1511,9 +1498,9 @@ impl<'a> SelectStreamsBuilder<'a> {
         }
     }
 
-    event_builder_generic_impl!(|s: &Self| {
-        ffi::gst_event_new_select_streams(s.streams.to_glib_full())
-    });
+    event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_select_streams(
+        s.streams.to_glib_full()
+    ));
 }
 
 pub struct CustomUpstreamBuilder<'a> {
diff --git a/gstreamer/src/format.rs b/gstreamer/src/format.rs
index 2149d0116..3ff18fcc2 100644
--- a/gstreamer/src/format.rs
+++ b/gstreamer/src/format.rs
@@ -153,9 +153,7 @@ impl GenericFormattedValue {
         if F::get_default_format() == self.get_format()
             || F::get_default_format() == Format::Undefined
         {
-            Ok(unsafe {
-                F::from_raw(self.get_format(), self.to_raw_value())
-            })
+            Ok(unsafe { F::from_raw(self.get_format(), self.to_raw_value()) })
         } else {
             Err(self)
         }
diff --git a/gstreamer/src/lib.rs b/gstreamer/src/lib.rs
index c1268a9dc..5d937e176 100644
--- a/gstreamer/src/lib.rs
+++ b/gstreamer/src/lib.rs
@@ -74,7 +74,7 @@ pub use caps::{Caps, CapsRef};
 pub mod tags;
 pub use tags::{Tag, TagList, TagListRef};
 pub mod buffer;
-pub use buffer::{Buffer, BufferMap, BufferRef, MappedBuffer, BUFFER_COPY_METADATA, BUFFER_COPY_ALL};
+pub use buffer::{Buffer, BufferMap, BufferRef, MappedBuffer, BUFFER_COPY_ALL, BUFFER_COPY_METADATA};
 pub mod sample;
 pub use sample::{Sample, SampleRef};
 pub mod bufferlist;
diff --git a/gstreamer/src/message.rs b/gstreamer/src/message.rs
index 11b6e284f..fd310ae72 100644
--- a/gstreamer/src/message.rs
+++ b/gstreamer/src/message.rs
@@ -671,7 +671,6 @@ impl<'a> StepDone<'a> {
     }
 }
 
-
 pub struct ClockProvide<'a>(&'a MessageRef);
 impl<'a> ClockProvide<'a> {
     pub fn get_clock(&self) -> Option<::Clock> {
@@ -1446,9 +1445,10 @@ impl<'a> TagBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &Self, src| {
-        ffi::gst_message_new_tag(src, s.tags.to_glib_full())
-    });
+    message_builder_generic_impl!(|s: &Self, src| ffi::gst_message_new_tag(
+        src,
+        s.tags.to_glib_full()
+    ));
 }
 
 pub struct BufferingBuilder<'a> {
@@ -1522,14 +1522,12 @@ impl<'a> StateChangedBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_state_changed(
-            src,
-            s.old.to_glib(),
-            s.new.to_glib(),
-            s.pending.to_glib(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_state_changed(
+        src,
+        s.old.to_glib(),
+        s.new.to_glib(),
+        s.pending.to_glib(),
+    ));
 }
 
 pub struct StateDirtyBuilder<'a> {
@@ -1585,18 +1583,16 @@ impl<'a> StepDoneBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_step_done(
-            src,
-            s.amount.get_format().to_glib(),
-            s.amount.get_value() as u64,
-            s.rate,
-            s.flush.to_glib(),
-            s.intermediate.to_glib(),
-            s.duration.get_value() as u64,
-            s.eos.to_glib(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_done(
+        src,
+        s.amount.get_format().to_glib(),
+        s.amount.get_value() as u64,
+        s.rate,
+        s.flush.to_glib(),
+        s.intermediate.to_glib(),
+        s.duration.get_value() as u64,
+        s.eos.to_glib(),
+    ));
 }
 
 pub struct ClockProvideBuilder<'a> {
@@ -1618,9 +1614,11 @@ impl<'a> ClockProvideBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_clock_provide(src, s.clock.to_glib_none().0, s.ready.to_glib())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_provide(
+        src,
+        s.clock.to_glib_none().0,
+        s.ready.to_glib()
+    ));
 }
 
 pub struct ClockLostBuilder<'a> {
@@ -1640,9 +1638,10 @@ impl<'a> ClockLostBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_clock_lost(src, s.clock.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_lost(
+        src,
+        s.clock.to_glib_none().0
+    ));
 }
 
 pub struct NewClockBuilder<'a> {
@@ -1662,9 +1661,10 @@ impl<'a> NewClockBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_new_clock(src, s.clock.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_new_clock(
+        src,
+        s.clock.to_glib_none().0
+    ));
 }
 
 pub struct StructureChangeBuilder<'a> {
@@ -1688,14 +1688,12 @@ impl<'a> StructureChangeBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_structure_change(
-            src,
-            s.type_.to_glib(),
-            s.owner.to_glib_none().0,
-            s.busy.to_glib(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_structure_change(
+        src,
+        s.type_.to_glib(),
+        s.owner.to_glib_none().0,
+        s.busy.to_glib(),
+    ));
 }
 
 pub struct StreamStatusBuilder<'a> {
@@ -1756,9 +1754,10 @@ impl<'a> ApplicationBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_application(src, s.structure.take().unwrap().into_ptr())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_application(
+        src,
+        s.structure.take().unwrap().into_ptr()
+    ));
 }
 
 pub struct ElementBuilder<'a> {
@@ -1778,9 +1777,10 @@ impl<'a> ElementBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_element(src, s.structure.take().unwrap().into_ptr())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_element(
+        src,
+        s.structure.take().unwrap().into_ptr()
+    ));
 }
 
 pub struct SegmentStartBuilder<'a> {
@@ -1800,13 +1800,11 @@ impl<'a> SegmentStartBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_segment_start(
-            src,
-            s.position.get_format().to_glib(),
-            s.position.get_value(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_start(
+        src,
+        s.position.get_format().to_glib(),
+        s.position.get_value(),
+    ));
 }
 
 pub struct SegmentDoneBuilder<'a> {
@@ -1826,13 +1824,11 @@ impl<'a> SegmentDoneBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_segment_done(
-            src,
-            s.position.get_format().to_glib(),
-            s.position.get_value(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_done(
+        src,
+        s.position.get_format().to_glib(),
+        s.position.get_value(),
+    ));
 }
 
 pub struct DurationChangedBuilder<'a> {
@@ -1906,9 +1902,10 @@ impl<'a> AsyncDoneBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_async_done(src, s.running_time.to_glib())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_async_done(
+        src,
+        s.running_time.to_glib()
+    ));
 }
 
 pub struct RequestStateBuilder<'a> {
@@ -1928,9 +1925,10 @@ impl<'a> RequestStateBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_request_state(src, s.state.to_glib())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_request_state(
+        src,
+        s.state.to_glib()
+    ));
 }
 
 pub struct StepStartBuilder<'a> {
@@ -1964,17 +1962,15 @@ impl<'a> StepStartBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_step_start(
-            src,
-            s.active.to_glib(),
-            s.amount.get_format().to_glib(),
-            s.amount.get_value() as u64,
-            s.rate,
-            s.flush.to_glib(),
-            s.intermediate.to_glib(),
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_start(
+        src,
+        s.active.to_glib(),
+        s.amount.get_format().to_glib(),
+        s.amount.get_value() as u64,
+        s.rate,
+        s.flush.to_glib(),
+        s.intermediate.to_glib(),
+    ));
 }
 
 pub struct QosBuilder<'a> {
@@ -2074,14 +2070,12 @@ impl<'a> ProgressBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_progress(
-            src,
-            s.type_.to_glib(),
-            s.code.to_glib_none().0,
-            s.text.to_glib_none().0,
-        )
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_progress(
+        src,
+        s.type_.to_glib(),
+        s.code.to_glib_none().0,
+        s.text.to_glib_none().0,
+    ));
 }
 
 pub struct TocBuilder<'a> {
@@ -2103,9 +2097,11 @@ impl<'a> TocBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &Self, src| {
-        ffi::gst_message_new_toc(src, s.toc.to_glib_none().0, s.updated.to_glib())
-    });
+    message_builder_generic_impl!(|s: &Self, src| ffi::gst_message_new_toc(
+        src,
+        s.toc.to_glib_none().0,
+        s.updated.to_glib()
+    ));
 }
 
 pub struct ResetTimeBuilder<'a> {
@@ -2125,9 +2121,10 @@ impl<'a> ResetTimeBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_reset_time(src, s.running_time.to_glib())
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_reset_time(
+        src,
+        s.running_time.to_glib()
+    ));
 }
 
 pub struct StreamStartBuilder<'a> {
@@ -2180,9 +2177,10 @@ impl<'a> NeedContextBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_need_context(src, s.context_type.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_need_context(
+        src,
+        s.context_type.to_glib_none().0
+    ));
 }
 
 pub struct HaveContextBuilder<'a> {
@@ -2225,9 +2223,10 @@ impl<'a> DeviceAddedBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_device_added(src, s.device.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_added(
+        src,
+        s.device.to_glib_none().0
+    ));
 }
 
 pub struct DeviceRemovedBuilder<'a> {
@@ -2247,9 +2246,10 @@ impl<'a> DeviceRemovedBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_device_removed(src, s.device.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_removed(
+        src,
+        s.device.to_glib_none().0
+    ));
 }
 
 #[cfg(any(feature = "v1_10", feature = "dox"))]
@@ -2313,9 +2313,10 @@ impl<'a> StreamCollectionBuilder<'a> {
         }
     }
 
-    message_builder_generic_impl!(|s: &mut Self, src| {
-        ffi::gst_message_new_stream_collection(src, s.collection.to_glib_none().0)
-    });
+    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_stream_collection(
+        src,
+        s.collection.to_glib_none().0
+    ));
 }
 
 #[cfg(any(feature = "v1_10", feature = "dox"))]
diff --git a/gstreamer/src/miniobject.rs b/gstreamer/src/miniobject.rs
index b49be9fe7..9f1be2410 100644
--- a/gstreamer/src/miniobject.rs
+++ b/gstreamer/src/miniobject.rs
@@ -66,10 +66,9 @@ impl<T: MiniObject> GstRc<T> {
                 return &mut *self.obj;
             }
 
-            self.obj = T::from_mut_ptr(
-                ffi::gst_mini_object_make_writable(self.as_mut_ptr() as *mut ffi::GstMiniObject)
-                    as *mut T::GstType,
-            );
+            self.obj = T::from_mut_ptr(ffi::gst_mini_object_make_writable(self.as_mut_ptr()
+                as *mut ffi::GstMiniObject)
+                as *mut T::GstType);
             assert!(self.is_writable());
 
             &mut *self.obj
@@ -86,9 +85,8 @@ impl<T: MiniObject> GstRc<T> {
 
     pub fn is_writable(&self) -> bool {
         unsafe {
-            from_glib(ffi::gst_mini_object_is_writable(
-                self.as_ptr() as *const ffi::GstMiniObject,
-            ))
+            from_glib(ffi::gst_mini_object_is_writable(self.as_ptr()
+                as *const ffi::GstMiniObject))
         }
     }
 
@@ -193,10 +191,9 @@ where
 
     fn copy(&self) -> GstRc<Self> {
         unsafe {
-            GstRc::from_glib_full(
-                ffi::gst_mini_object_copy(self.as_ptr() as *const ffi::GstMiniObject)
-                    as *const Self::GstType,
-            )
+            GstRc::from_glib_full(ffi::gst_mini_object_copy(self.as_ptr()
+                as *const ffi::GstMiniObject)
+                as *const Self::GstType)
         }
     }
 }
diff --git a/gstreamer/src/pad.rs b/gstreamer/src/pad.rs
index 63e19ad5b..c5918ae8e 100644
--- a/gstreamer/src/pad.rs
+++ b/gstreamer/src/pad.rs
@@ -874,24 +874,24 @@ unsafe extern "C" fn trampoline_pad_probe(
             let data = (*info).data as *const ffi::GstMiniObject;
             if (*data).type_ == Buffer::static_type().to_glib() {
                 data_type = Some(Buffer::static_type());
-                Some(PadProbeData::Buffer(
-                    from_glib_none(data as *const ffi::GstBuffer),
-                ))
+                Some(PadProbeData::Buffer(from_glib_none(
+                    data as *const ffi::GstBuffer,
+                )))
             } else if (*data).type_ == BufferList::static_type().to_glib() {
                 data_type = Some(BufferList::static_type());
-                Some(PadProbeData::BufferList(
-                    from_glib_none(data as *const ffi::GstBufferList),
-                ))
+                Some(PadProbeData::BufferList(from_glib_none(
+                    data as *const ffi::GstBufferList,
+                )))
             } else if (*data).type_ == Query::static_type().to_glib() {
                 data_type = Some(Query::static_type());
-                Some(PadProbeData::Query(
-                    QueryRef::from_mut_ptr(data as *mut ffi::GstQuery),
-                ))
+                Some(PadProbeData::Query(QueryRef::from_mut_ptr(
+                    data as *mut ffi::GstQuery,
+                )))
             } else if (*data).type_ == Event::static_type().to_glib() {
                 data_type = Some(Event::static_type());
-                Some(PadProbeData::Event(
-                    from_glib_none(data as *const ffi::GstEvent),
-                ))
+                Some(PadProbeData::Event(from_glib_none(
+                    data as *const ffi::GstEvent,
+                )))
             } else {
                 Some(PadProbeData::Unknown)
             }
@@ -1195,9 +1195,7 @@ mod tests {
 
         assert!(pad.send_event(::Event::new_stream_start("test").build()));
         let segment = ::FormattedSegment::<::ClockTime>::new();
-        assert!(pad.send_event(
-            ::Event::new_segment(segment.as_ref()).build()
-        ));
+        assert!(pad.send_event(::Event::new_segment(segment.as_ref()).build()));
 
         assert_eq!(pad.chain(::Buffer::new()), ::FlowReturn::Ok);
 
diff --git a/gstreamer/src/query.rs b/gstreamer/src/query.rs
index 01917e175..31336f97e 100644
--- a/gstreamer/src/query.rs
+++ b/gstreamer/src/query.rs
@@ -142,15 +142,21 @@ impl QueryRef {
     }
 
     pub fn is_downstream(&self) -> bool {
-        unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_DOWNSTREAM.bits()) != 0 }
+        unsafe {
+            ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_DOWNSTREAM.bits()) != 0
+        }
     }
 
     pub fn is_upstream(&self) -> bool {
-        unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_UPSTREAM.bits()) != 0 }
+        unsafe {
+            ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_UPSTREAM.bits()) != 0
+        }
     }
 
     pub fn is_serialized(&self) -> bool {
-        unsafe { ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_SERIALIZED.bits()) != 0 }
+        unsafe {
+            ((*self.as_ptr()).type_ as u32) & (ffi::GST_QUERY_TYPE_SERIALIZED.bits()) != 0
+        }
     }
 
     pub fn view(&self) -> QueryView<&Self> {
diff --git a/gstreamer/src/static_pad_template.rs b/gstreamer/src/static_pad_template.rs
index 62c8d683e..a28805a58 100644
--- a/gstreamer/src/static_pad_template.rs
+++ b/gstreamer/src/static_pad_template.rs
@@ -54,10 +54,9 @@ impl glib::types::StaticType for StaticPadTemplate {
 #[doc(hidden)]
 impl<'a> glib::value::FromValueOptional<'a> for StaticPadTemplate {
     unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
-        Option::<StaticPadTemplate>::from_glib_none(
-            gobject_ffi::g_value_get_boxed(value.to_glib_none().0)
-                as *mut ffi::GstStaticPadTemplate,
-        )
+        Option::<StaticPadTemplate>::from_glib_none(gobject_ffi::g_value_get_boxed(
+            value.to_glib_none().0,
+        ) as *mut ffi::GstStaticPadTemplate)
     }
 }
 
diff --git a/gstreamer/src/structure.rs b/gstreamer/src/structure.rs
index 8af37b0e5..f43cb1f9c 100644
--- a/gstreamer/src/structure.rs
+++ b/gstreamer/src/structure.rs
@@ -37,7 +37,9 @@ impl Structure {
     pub fn new_empty(name: &str) -> Structure {
         assert_initialized_main_thread!();
         Structure(
-            unsafe { ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef },
+            unsafe {
+                ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef
+            },
             PhantomData,
         )
     }
diff --git a/gstreamer/src/tags.rs b/gstreamer/src/tags.rs
index 8b3864b72..a7bc0acb3 100644
--- a/gstreamer/src/tags.rs
+++ b/gstreamer/src/tags.rs
@@ -306,7 +306,9 @@ impl TagListRef {
     }
 
     pub fn get_size<'a, T: Tag<'a>>(&'a self) -> u32 {
-        unsafe { ffi::gst_tag_list_get_tag_size(self.as_ptr(), T::tag_name().to_glib_none().0) }
+        unsafe {
+            ffi::gst_tag_list_get_tag_size(self.as_ptr(), T::tag_name().to_glib_none().0)
+        }
     }
 
     pub fn iter_tag<'a, T: Tag<'a>>(&'a self) -> TagIterator<'a, T> {
@@ -318,7 +320,9 @@ impl TagListRef {
     }
 
     pub fn insert(&mut self, other: &TagListRef, mode: TagMergeMode) {
-        unsafe { ffi::gst_tag_list_insert(self.as_mut_ptr(), other.as_ptr(), mode.to_glib()) }
+        unsafe {
+            ffi::gst_tag_list_insert(self.as_mut_ptr(), other.as_ptr(), mode.to_glib())
+        }
     }
 
     pub fn merge(&self, other: &TagListRef, mode: TagMergeMode) -> TagList {
diff --git a/gstreamer/src/toc.rs b/gstreamer/src/toc.rs
index 82279b905..f7cd23654 100644
--- a/gstreamer/src/toc.rs
+++ b/gstreamer/src/toc.rs
@@ -42,11 +42,15 @@ impl TocRef {
     }
 
     pub fn find_entry(&self, uid: &str) -> Option<TocEntry> {
-        unsafe { from_glib_none(ffi::gst_toc_find_entry(self.as_ptr(), uid.to_glib_none().0)) }
+        unsafe {
+            from_glib_none(ffi::gst_toc_find_entry(self.as_ptr(), uid.to_glib_none().0))
+        }
     }
 
     pub fn get_entries(&self) -> Vec<TocEntry> {
-        unsafe { FromGlibPtrContainer::from_glib_none(ffi::gst_toc_get_entries(self.as_ptr())) }
+        unsafe {
+            FromGlibPtrContainer::from_glib_none(ffi::gst_toc_get_entries(self.as_ptr()))
+        }
     }
 
     pub fn append_entry(&mut self, entry: TocEntry) {
diff --git a/gstreamer/src/typefind.rs b/gstreamer/src/typefind.rs
index fdb41f345..30bb853b3 100644
--- a/gstreamer/src/typefind.rs
+++ b/gstreamer/src/typefind.rs
@@ -248,9 +248,7 @@ mod tests {
             .cloned()
             .find(|f| {
                 f.get_caps()
-                    .map(|c| {
-                        c.get_structure(0).unwrap().get_name() == "application/xml"
-                    })
+                    .map(|c| c.get_structure(0).unwrap().get_name() == "application/xml")
                     .unwrap_or(false)
             })
             .unwrap();
diff --git a/tutorials/src/bin/basic-tutorial-2.rs b/tutorials/src/bin/basic-tutorial-2.rs
index f5c016c02..1d12b60c6 100644
--- a/tutorials/src/bin/basic-tutorial-2.rs
+++ b/tutorials/src/bin/basic-tutorial-2.rs
@@ -59,7 +59,6 @@ fn tutorial_main() {
     );
 }
 
-
 fn main() {
     // tutorials_common::run is only required to set up the application environment on macOS
     // (but not necessary in normal Cocoa applications where this is set up automatically)
diff --git a/tutorials/src/bin/basic-tutorial-4.rs b/tutorials/src/bin/basic-tutorial-4.rs
index 25370846a..8f93e2a0d 100644
--- a/tutorials/src/bin/basic-tutorial-4.rs
+++ b/tutorials/src/bin/basic-tutorial-4.rs
@@ -123,8 +123,7 @@ fn handle_message(custom_data: &mut CustomData, msg: &gst::GstRc<gst::MessageRef
 
             println!(
                 "Pipeline state changed from {:?} to {:?}",
-                old_state,
-                new_state
+                old_state, new_state
             );
 
             custom_data.playing = new_state == gst::State::Playing;
diff --git a/tutorials/src/bin/basic-tutorial-5.rs b/tutorials/src/bin/basic-tutorial-5.rs
index cc78a061c..bb165aa5d 100644
--- a/tutorials/src/bin/basic-tutorial-5.rs
+++ b/tutorials/src/bin/basic-tutorial-5.rs
@@ -53,9 +53,10 @@ mod tutorial5 {
                     }
 
                     if let Some(bitrate) = tags.get::<gst::tags::Bitrate>() {
-                        textbuf.insert_at_cursor(
-                            &format!("    bitrate: {} \n", bitrate.get().unwrap()),
-                        );
+                        textbuf.insert_at_cursor(&format!(
+                            "    bitrate: {} \n",
+                            bitrate.get().unwrap()
+                        ));
                     }
                 }
             },
diff --git a/tutorials/src/bin/basic-tutorial-7.rs b/tutorials/src/bin/basic-tutorial-7.rs
index bf9d1cc96..02feba5bd 100644
--- a/tutorials/src/bin/basic-tutorial-7.rs
+++ b/tutorials/src/bin/basic-tutorial-7.rs
@@ -44,12 +44,7 @@ fn tutorial_main() {
         .unwrap();
 
     gst::Element::link_many(&[&audio_source, &tee]).unwrap();
-    gst::Element::link_many(&[
-        &audio_queue,
-        &audio_convert,
-        &audio_resample,
-        &audio_sink,
-    ]).unwrap();
+    gst::Element::link_many(&[&audio_queue, &audio_convert, &audio_resample, &audio_sink]).unwrap();
     gst::Element::link_many(&[&video_queue, &visual, &video_convert, &video_sink]).unwrap();
 
     let tee_audio_pad = tee.get_request_pad("src_%u").unwrap();
diff --git a/tutorials/src/bin/basic-tutorial-8.rs b/tutorials/src/bin/basic-tutorial-8.rs
index e9719c754..2ecbad6c6 100644
--- a/tutorials/src/bin/basic-tutorial-8.rs
+++ b/tutorials/src/bin/basic-tutorial-8.rs
@@ -90,12 +90,8 @@ fn main() {
         .unwrap();
 
     gst::Element::link_many(&[&appsrc, &tee]).unwrap();
-    gst::Element::link_many(&[
-        &audio_queue,
-        &audio_convert1,
-        &audio_resample,
-        &audio_sink,
-    ]).unwrap();
+    gst::Element::link_many(&[&audio_queue, &audio_convert1, &audio_resample, &audio_sink])
+        .unwrap();
     gst::Element::link_many(&[
         &video_queue,
         &audio_convert2,
@@ -234,8 +230,6 @@ fn main() {
         gst::FlowReturn::Ok
     });
 
-
-
     pipeline
         .set_state(gst::State::Playing)
         .into_result()