mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-12-22 16:16:37 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Sebastian Dröge 2019-07-11 16:02:46 +03:00
parent 3a8d05075d
commit 424a87efbf
19 changed files with 229 additions and 202 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
gstreamer-gl/src/gl_video_frame.rs
View file

@ -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()))
}
}
}

6
gstreamer-sdp/src/sdp_attribute.rs
View file

@ -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())
}
}

6
gstreamer-sdp/src/sdp_bandwidth.rs
View file

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

6
gstreamer-sdp/src/sdp_connection.rs
View file

@ -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())
}
}

6
gstreamer-sdp/src/sdp_message.rs
View file

@ -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 {

6
gstreamer-sdp/src/sdp_time.rs
View file

@ -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())
}
}

6
gstreamer-sdp/src/sdp_zone.rs
View file

@ -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())
}
}

6
gstreamer-video/src/video_buffer_pool.rs
View file

@ -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
}

40
gstreamer-video/src/video_frame.rs
View file

@ -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))
}

6
gstreamer-video/src/video_info.rs
View file

@ -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
}

66
gstreamer-video/src/video_time_code.rs
View file

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

10
gstreamer-video/src/video_time_code_interval.rs
View file

@ -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())
}
}

56
gstreamer/src/buffer.rs
View file

@ -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() };
let res: bool = unsafe {
from_glib(gst_sys::gst_buffer_map(
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res: bool = unsafe {
from_glib(gst_sys::gst_buffer_map(
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res = unsafe {
gst_sys::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READ)
};
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res = unsafe {
gst_sys::gst_buffer_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READWRITE)
};
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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,

6
gstreamer/src/buffer_pool.rs
View file

@ -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
}

7
gstreamer/src/bus_unix.rs
View file

@ -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();
gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, &mut pollfd);
let mut pollfd = mem::MaybeUninit::zeroed();
gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, pollfd.as_mut_ptr());
let pollfd = pollfd.assume_init();
pollfd.fd
}

6
gstreamer/src/bus_windows.rs
View file

@ -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();
gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, &mut pollfd);
let mut pollfd = mem::MaybeUninit::zeroed();
gst_sys::gst_bus_get_pollfd(self.to_glib_none().0, pollfd.assume_init());
let pollfd = pollfd.assume_init();
pollfd.fd as *mut _
}

56
gstreamer/src/memory.rs
View file

@ -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() };
let res: bool = unsafe {
from_glib(gst_sys::gst_memory_map(
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res: bool = unsafe {
from_glib(gst_sys::gst_memory_map(
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res = unsafe {
gst_sys::gst_memory_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READ)
};
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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() };
let res = unsafe {
gst_sys::gst_memory_map(self.as_mut_ptr(), &mut map_info, gst_sys::GST_MAP_READWRITE)
};
unsafe {
let mut map_info = mem::MaybeUninit::zeroed();
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 {

6
gstreamer/src/segment.rs
View file

@ -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();
gst_sys::gst_segment_init(&mut segment, T::get_default_format().to_glib());
segment
let mut segment = mem::MaybeUninit::zeroed();
gst_sys::gst_segment_init(segment.as_mut_ptr(), T::get_default_format().to_glib());
segment.assume_init()
};
FormattedSegment(segment, PhantomData)
}

6
gstreamer/src/tags.rs
View file

@ -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())
}
}