Use MaybeUninit::zeroed() everywhere possible instead of mem::zeroed()

gstreamer-gl/src/gl_video_frame.rs

@@ -74,9 +74,9 @@ impl<'a> VideoFrameGLExt for VideoFrameRef<&'a gst::BufferRef> {
         }
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.to_glib_none().0,
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
@@ -87,7 +87,7 @@ impl<'a> VideoFrameGLExt for VideoFrameRef<&'a gst::BufferRef> {
             if !res {
                 Err(buffer)
             } else {
-                Ok(VideoFrame::from_glib_full(frame))
+                Ok(VideoFrame::from_glib_full(frame.assume_init()))
             }
         }
     }
@@ -111,9 +111,9 @@ impl<'a> VideoFrameGLExt for VideoFrameRef<&'a gst::BufferRef> {
         }
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.as_mut_ptr(),
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
@@ -124,7 +124,7 @@ impl<'a> VideoFrameGLExt for VideoFrameRef<&'a gst::BufferRef> {
             if !res {
                 None
             } else {
-                Some(VideoFrameRef::from_glib_borrow(&frame))
+                Some(VideoFrameRef::from_glib_borrow(&frame.assume_init()))
             }
         }
     }

gstreamer-sdp/src/sdp_attribute.rs

@@ -20,13 +20,13 @@ impl SDPAttribute {
     pub fn new(key: &str, value: Option<&str>) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut attr = mem::zeroed();
+            let mut attr = mem::MaybeUninit::zeroed();
             gst_sdp_sys::gst_sdp_attribute_set(
-                &mut attr,
+                attr.as_mut_ptr(),
                 key.to_glib_none().0,
                 value.to_glib_none().0,
             );
-            SDPAttribute(attr)
+            SDPAttribute(attr.assume_init())
         }
     }
 

gstreamer-sdp/src/sdp_bandwidth.rs

@@ -20,9 +20,9 @@ impl SDPBandwidth {
     pub fn new(bwtype: &str, bandwidth: u32) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut bw = mem::zeroed();
+            let mut bw = mem::MaybeUninit::zeroed();
-            gst_sdp_sys::gst_sdp_bandwidth_set(&mut bw, bwtype.to_glib_none().0, bandwidth);
+            gst_sdp_sys::gst_sdp_bandwidth_set(bw.as_mut_ptr(), bwtype.to_glib_none().0, bandwidth);
-            SDPBandwidth(bw)
+            SDPBandwidth(bw.assume_init())
         }
     }
 

gstreamer-sdp/src/sdp_connection.rs

@@ -20,16 +20,16 @@ impl SDPConnection {
     pub fn new(nettype: &str, addrtype: &str, address: &str, ttl: u32, addr_number: u32) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut conn = mem::zeroed();
+            let mut conn = mem::MaybeUninit::zeroed();
             gst_sdp_sys::gst_sdp_connection_set(
-                &mut conn,
+                conn.as_mut_ptr(),
                 nettype.to_glib_none().0,
                 addrtype.to_glib_none().0,
                 address.to_glib_none().0,
                 ttl,
                 addr_number,
             );
-            SDPConnection(conn)
+            SDPConnection(conn.assume_init())
         }
     }
 

gstreamer-sdp/src/sdp_message.rs

@@ -79,7 +79,7 @@ impl SDPMessage {
     pub fn new() -> SDPMessage {
         assert_initialized_main_thread!();
         unsafe {
-            let mut msg = mem::zeroed();
+            let mut msg = ptr::null_mut();
             gst_sdp_sys::gst_sdp_message_new(&mut msg);
             from_glib_full(msg)
         }
@@ -89,7 +89,7 @@ impl SDPMessage {
         assert_initialized_main_thread!();
         unsafe {
             let size = data.len() as u32;
-            let mut msg = mem::zeroed();
+            let mut msg = ptr::null_mut();
             gst_sdp_sys::gst_sdp_message_new(&mut msg);
             let result =
                 gst_sdp_sys::gst_sdp_message_parse_buffer(data.to_glib_none().0, size, msg);
@@ -106,7 +106,7 @@ impl SDPMessage {
     pub fn parse_uri(uri: &str) -> Result<Self, ()> {
         assert_initialized_main_thread!();
         unsafe {
-            let mut msg = mem::zeroed();
+            let mut msg = ptr::null_mut();
             gst_sdp_sys::gst_sdp_message_new(&mut msg);
             let result = gst_sdp_sys::gst_sdp_message_parse_uri(uri.to_glib_none().0, msg);
             match result {

gstreamer-sdp/src/sdp_time.rs

@@ -21,14 +21,14 @@ impl SDPTime {
     pub fn new(start: &str, stop: &str, repeat: &[&str]) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut time = mem::zeroed();
+            let mut time = mem::MaybeUninit::zeroed();
             gst_sdp_sys::gst_sdp_time_set(
-                &mut time,
+                time.as_mut_ptr(),
                 start.to_glib_none().0,
                 stop.to_glib_none().0,
                 repeat.to_glib_none().0,
             );
-            SDPTime(time)
+            SDPTime(time.assume_init())
         }
     }
 

gstreamer-sdp/src/sdp_zone.rs

@@ -20,13 +20,13 @@ impl SDPZone {
     pub fn new(time: &str, typed_time: &str) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut zone = mem::zeroed();
+            let mut zone = mem::MaybeUninit::zeroed();
             gst_sdp_sys::gst_sdp_zone_set(
-                &mut zone,
+                zone.as_mut_ptr(),
                 time.to_glib_none().0,
                 typed_time.to_glib_none().0,
             );
-            SDPZone(zone)
+            SDPZone(zone.assume_init())
         }
     }
 

gstreamer-video/src/video_buffer_pool.rs

@@ -89,13 +89,13 @@ pub trait VideoBufferPoolConfig {
 impl VideoBufferPoolConfig for gst::BufferPoolConfig {
     fn get_video_alignment(&self) -> Option<VideoAlignment> {
         unsafe {
-            let mut alignment: VideoAlignment = mem::zeroed();
+            let mut alignment = mem::MaybeUninit::zeroed();
             let ret = from_glib(gst_video_sys::gst_buffer_pool_config_get_video_alignment(
                 self.as_ref().as_mut_ptr(),
-                &mut alignment.0,
+                alignment.as_mut_ptr(),
             ));
             if ret {
-                Some(alignment)
+                Some(VideoAlignment(alignment.assume_init()))
             } else {
                 None
             }

gstreamer-video/src/video_frame.rs

@@ -189,9 +189,9 @@ impl VideoFrame<Readable> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.to_glib_none().0,
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ,
@@ -200,6 +200,7 @@ impl VideoFrame<Readable> {
             if !res {
                 Err(buffer)
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Ok(VideoFrame(frame, Some(buffer), info, PhantomData))
             }
@@ -214,9 +215,9 @@ impl VideoFrame<Readable> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.to_glib_none().0,
                 id,
@@ -226,6 +227,7 @@ impl VideoFrame<Readable> {
             if !res {
                 Err(buffer)
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Ok(VideoFrame(frame, Some(buffer), info, PhantomData))
             }
@@ -251,9 +253,9 @@ impl VideoFrame<Writable> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.to_glib_none().0,
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
@@ -264,6 +266,7 @@ impl VideoFrame<Writable> {
             if !res {
                 Err(buffer)
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Ok(VideoFrame(frame, Some(buffer), info, PhantomData))
             }
@@ -278,9 +281,9 @@ impl VideoFrame<Writable> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.to_glib_none().0,
                 id,
@@ -292,6 +295,7 @@ impl VideoFrame<Writable> {
             if !res {
                 Err(buffer)
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Ok(VideoFrame(frame, Some(buffer), info, PhantomData))
             }
@@ -367,9 +371,9 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.as_mut_ptr(),
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ,
@@ -378,6 +382,7 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
             if !res {
                 None
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Some(VideoFrameRef(frame, Some(buffer), info, false))
             }
@@ -392,9 +397,9 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.as_mut_ptr(),
                 id,
@@ -404,6 +409,7 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
             if !res {
                 None
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Some(VideoFrameRef(frame, Some(buffer), info, false))
             }
@@ -558,9 +564,9 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.as_mut_ptr(),
                 gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
@@ -571,6 +577,7 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
             if !res {
                 None
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Some(VideoFrameRef(frame, Some(buffer), info, false))
             }
@@ -585,9 +592,9 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
         skip_assert_initialized!();
 
         unsafe {
-            let mut frame = mem::zeroed();
+            let mut frame = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id(
-                &mut frame,
+                frame.as_mut_ptr(),
                 info.to_glib_none().0 as *mut _,
                 buffer.as_mut_ptr(),
                 id,
@@ -599,6 +606,7 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
             if !res {
                 None
             } else {
+                let frame = frame.assume_init();
                 let info = ::VideoInfo(ptr::read(&frame.info));
                 Some(VideoFrameRef(frame, Some(buffer), info, false))
             }

gstreamer-video/src/video_info.rs

@@ -118,13 +118,13 @@ impl VideoColorimetry {
         assert_initialized_main_thread!();
 
         unsafe {
-            let mut colorimetry = mem::zeroed();
+            let mut colorimetry = mem::MaybeUninit::zeroed();
             let valid: bool = from_glib(gst_video_sys::gst_video_colorimetry_from_string(
-                &mut colorimetry,
+                colorimetry.as_mut_ptr(),
                 s.to_glib_none().0,
             ));
             if valid {
-                Some(VideoColorimetry(colorimetry))
+                Some(VideoColorimetry(colorimetry.assume_init()))
             } else {
                 None
             }

gstreamer-video/src/video_time_code.rs

@@ -34,9 +34,9 @@ impl VideoTimeCode {
     pub fn new_empty() -> VideoTimeCode {
         assert_initialized_main_thread!();
         unsafe {
-            let mut v = mem::zeroed();
+            let mut v = mem::MaybeUninit::zeroed();
-            gst_video_sys::gst_video_time_code_clear(&mut v);
+            gst_video_sys::gst_video_time_code_clear(v.as_mut_ptr());
-            VideoTimeCode(v)
+            VideoTimeCode(v.assume_init())
         }
     }
 
@@ -53,9 +53,9 @@ impl VideoTimeCode {
     ) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut v = mem::zeroed();
+            let mut v = mem::MaybeUninit::zeroed();
             gst_video_sys::gst_video_time_code_init(
-                &mut v,
+                v.as_mut_ptr(),
                 *fps.numer() as u32,
                 *fps.denom() as u32,
                 latest_daily_jam.to_glib_none().0,
@@ -67,37 +67,37 @@ impl VideoTimeCode {
                 field_count,
             );
 
-            VideoTimeCode(v)
+            VideoTimeCode(v.assume_init())
         }
     }
 
-    //    #[cfg(any(feature = "v1_16", feature = "dox"))]
+    #[cfg(any(feature = "v1_16", feature = "dox"))]
-    //    pub fn new_from_date_time(
+    pub fn new_from_date_time(
-    //        fps: gst::Fraction,
+        fps: gst::Fraction,
-    //        dt: &glib::DateTime,
+        dt: &glib::DateTime,
-    //        flags: VideoTimeCodeFlags,
+        flags: VideoTimeCodeFlags,
-    //        field_count: u32,
+        field_count: u32,
-    //    ) -> Option<VideoTimeCode> {
+    ) -> Option<VideoTimeCode> {
-    //        assert_initialized_main_thread!();
+        assert_initialized_main_thread!();
-    //        assert!(fps_d > 0);
+        assert!(*fps.denom() > 0);
-    //        unsafe {
+        unsafe {
-    //            let mut v = mem::zeroed();
+            let mut v = mem::MaybeUninit::zeroed();
-    //            let res = gst_video_sys::gst_video_time_code_init_from_date_time_full(
+            let res = gst_video_sys::gst_video_time_code_init_from_date_time_full(
-    //                &mut v,
+                v.as_mut_ptr(),
-    //                *fps.numer() as u32,
+                *fps.numer() as u32,
-    //                *fps.denom() as u32,
+                *fps.denom() as u32,
-    //                dt.to_glib_none().0,
+                dt.to_glib_none().0,
-    //                flags.to_glib(),
+                flags.to_glib(),
-    //                field_count,
+                field_count,
-    //            );
+            );
-    //
+
-    //            if res == glib_sys::GFALSE {
+            if res == glib_sys::GFALSE {
-    //                None
+                None
-    //            } else {
+            } else {
-    //                Some(VideoTimeCode(v))
+                Some(VideoTimeCode(v.assume_init()))
-    //            }
+            }
-    //        }
+        }
-    //    }
+    }
 
     #[cfg(any(feature = "v1_12", feature = "dox"))]
     pub fn from_string(tc_str: &str) -> Option<VideoTimeCode> {

gstreamer-video/src/video_time_code_interval.rs

@@ -34,11 +34,15 @@ impl VideoTimeCodeInterval {
     pub fn new(hours: u32, minutes: u32, seconds: u32, frames: u32) -> Self {
         assert_initialized_main_thread!();
         unsafe {
-            let mut v = mem::zeroed();
+            let mut v = mem::MaybeUninit::zeroed();
             gst_video_sys::gst_video_time_code_interval_init(
-                &mut v, hours, minutes, seconds, frames,
+                v.as_mut_ptr(),
+                hours,
+                minutes,
+                seconds,
+                frames,
             );
-            VideoTimeCodeInterval(v)
+            VideoTimeCodeInterval(v.assume_init())
         }
     }
 

gstreamer/src/buffer.rs

@@ -119,44 +119,44 @@ impl Buffer {
     }
 
     pub fn into_mapped_buffer_readable(self) -> Result<MappedBuffer<Readable>, Self> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res: bool = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            from_glib(gst_sys::gst_buffer_map(
+            let res: bool = from_glib(gst_sys::gst_buffer_map(
                 self.as_mut_ptr(),
-                &mut map_info,
+                map_info.as_mut_ptr(),
                 gst_sys::GST_MAP_READ,
-            ))
+            ));
-        };
             if res {
                 Ok(MappedBuffer {
                     buffer: Some(self),
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 Err(self)
             }
         }
+    }
 
     pub fn into_mapped_buffer_writable(self) -> Result<MappedBuffer<Writable>, Self> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res: bool = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            from_glib(gst_sys::gst_buffer_map(
+            let res: bool = from_glib(gst_sys::gst_buffer_map(
                 self.as_mut_ptr(),
-                &mut map_info,
+                map_info.as_mut_ptr(),
                 gst_sys::GST_MAP_READWRITE,
-            ))
+            ));
-        };
             if res {
                 Ok(MappedBuffer {
                     buffer: Some(self),
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 Err(self)
             }
         }
+    }
 
     pub fn append(buffer: Self, other: Self) -> Self {
         skip_assert_initialized!();
@@ -177,36 +177,44 @@ impl Default for Buffer {
 
 impl BufferRef {
     pub fn map_readable(&self) -> Option<BufferMap<Readable>> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            gst_sys::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READ)
+            let res = gst_sys::gst_buffer_map(
-        };
+                self.as_mut_ptr(),
+                map_info.as_mut_ptr(),
+                gst_sys::GST_MAP_READ,
+            );
             if res == glib_sys::GTRUE {
                 Some(BufferMap {
                     buffer: self,
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 None
             }
         }
+    }
 
     pub fn map_writable(&mut self) -> Option<BufferMap<Writable>> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            gst_sys::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READWRITE)
+            let res = gst_sys::gst_buffer_map(
-        };
+                self.as_mut_ptr(),
+                map_info.as_mut_ptr(),
+                gst_sys::GST_MAP_READWRITE,
+            );
             if res == glib_sys::GTRUE {
                 Some(BufferMap {
                     buffer: self,
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 None
             }
         }
+    }
 
     pub fn copy_region(
         &self,

gstreamer/src/buffer_pool.rs

@@ -154,14 +154,14 @@ impl BufferPoolConfig {
     pub fn get_allocator(&self) -> Option<(Option<Allocator>, AllocationParams)> {
         unsafe {
             let mut allocator = ptr::null_mut();
-            let mut params = mem::zeroed();
+            let mut params = mem::MaybeUninit::zeroed();
             let ret = from_glib(gst_sys::gst_buffer_pool_config_get_allocator(
                 self.0.to_glib_none().0,
                 &mut allocator,
-                &mut params,
+                params.as_mut_ptr(),
             ));
             if ret {
-                Some((from_glib_none(allocator), params.into()))
+                Some((from_glib_none(allocator), params.assume_init().into()))
             } else {
                 None
             }

gstreamer/src/bus_unix.rs

@@ -10,7 +10,6 @@
 cfg_if! {
     if #[cfg(unix)] {
         use gst_sys;
-        use glib_sys;
         use glib::translate::ToGlibPtr;
 
         use std::mem;
@@ -36,9 +35,9 @@ impl UnixBusExtManual for Bus {
     fn get_pollfd(&self) -> unix::io::RawFd {
         #[cfg(unix)]
         unsafe {
-            let mut pollfd: glib_sys::GPollFD = mem::zeroed();
+            let mut pollfd = mem::MaybeUninit::zeroed();
-            gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, &mut pollfd);
+            gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, pollfd.as_mut_ptr());
-
+            let pollfd = pollfd.assume_init();
             pollfd.fd
         }
 

gstreamer/src/bus_windows.rs

@@ -36,9 +36,9 @@ impl WindowsBusExtManual for Bus {
     fn get_pollfd(&self) -> windows::io::RawHandle {
         #[cfg(windows)]
         unsafe {
-            let mut pollfd: glib_sys::GPollFD = mem::zeroed();
+            let mut pollfd = mem::MaybeUninit::zeroed();
-            gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, &mut pollfd);
+            gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, pollfd.assume_init());
-
+            let pollfd = pollfd.assume_init();
             pollfd.fd as *mut _
         }
 

gstreamer/src/memory.rs

@@ -128,38 +128,37 @@ impl Memory {
     }
 
     pub fn into_mapped_memory_readable(self) -> Result<MappedMemory<Readable>, Self> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res: bool = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            from_glib(gst_sys::gst_memory_map(
+            let res: bool = from_glib(gst_sys::gst_memory_map(
                 self.as_mut_ptr(),
-                &mut map_info,
+                map_info.as_mut_ptr(),
                 gst_sys::GST_MAP_READ,
-            ))
+            ));
-        };
             if res {
                 Ok(MappedMemory {
                     memory: Some(self),
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 Err(self)
             }
         }
+    }
 
     pub fn into_mapped_memory_writable(self) -> Result<MappedMemory<Writable>, Self> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res: bool = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            from_glib(gst_sys::gst_memory_map(
+            let res: bool = from_glib(gst_sys::gst_memory_map(
                 self.as_mut_ptr(),
-                &mut map_info,
+                map_info.as_mut_ptr(),
                 gst_sys::GST_MAP_READWRITE,
-            ))
+            ));
-        };
             if res {
                 Ok(MappedMemory {
                     memory: Some(self),
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
@@ -167,6 +166,7 @@ impl Memory {
             }
         }
     }
+}
 
 impl MemoryRef {
     pub fn get_allocator(&self) -> Option<Allocator> {
@@ -247,36 +247,44 @@ impl MemoryRef {
     }
 
     pub fn map_readable(&self) -> Option<MemoryMap<Readable>> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            gst_sys::gst_memory_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READ)
+            let res = gst_sys::gst_memory_map(
-        };
+                self.as_mut_ptr(),
+                map_info.as_mut_ptr(),
+                gst_sys::GST_MAP_READ,
+            );
             if res == glib_sys::GTRUE {
                 Some(MemoryMap {
                     memory: self,
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 None
             }
         }
+    }
 
     pub fn map_writable(&mut self) -> Option<MemoryMap<Writable>> {
-        let mut map_info: gst_sys::GstMapInfo = unsafe { mem::zeroed() };
+        unsafe {
-        let res = unsafe {
+            let mut map_info = mem::MaybeUninit::zeroed();
-            gst_sys::gst_memory_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READWRITE)
+            let res = gst_sys::gst_memory_map(
-        };
+                self.as_mut_ptr(),
+                map_info.as_mut_ptr(),
+                gst_sys::GST_MAP_READWRITE,
+            );
             if res == glib_sys::GTRUE {
                 Some(MemoryMap {
                     memory: self,
-                map_info,
+                    map_info: map_info.assume_init(),
                     phantom: PhantomData,
                 })
             } else {
                 None
             }
         }
+    }
 
     pub fn share(&self, offset: isize, size: Option<usize>) -> Memory {
         let pos_sz = match size {

gstreamer/src/segment.rs

@@ -77,9 +77,9 @@ impl<T: FormattedValue> FormattedSegment<T> {
     pub fn new() -> Self {
         assert_initialized_main_thread!();
         let segment = unsafe {
-            let mut segment = mem::zeroed();
+            let mut segment = mem::MaybeUninit::zeroed();
-            gst_sys::gst_segment_init(&mut segment, T::get_default_format().to_glib());
+            gst_sys::gst_segment_init(segment.as_mut_ptr(), T::get_default_format().to_glib());
-            segment
+            segment.assume_init()
         };
         FormattedSegment(segment, PhantomData)
     }

gstreamer/src/tags.rs

@@ -412,10 +412,10 @@ impl TagListRef {
 
     pub fn get_generic(&self, tag_name: &str) -> Option<SendValue> {
         unsafe {
-            let mut value: SendValue = mem::zeroed();
+            let mut value: mem::MaybeUninit<SendValue> = mem::MaybeUninit::zeroed();
 
             let found: bool = from_glib(gst_sys::gst_tag_list_copy_value(
-                value.to_glib_none_mut().0,
+                (*value.as_mut_ptr()).to_glib_none_mut().0,
                 self.as_ptr(),
                 tag_name.to_glib_none().0,
             ));
@@ -424,7 +424,7 @@ impl TagListRef {
                 return None;
             }
 
-            Some(value)
+            Some(value.assume_init())
         }
     }