rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

Switch everything from mem::uninitialized() to MaybeUninit or mem::zeroed()

Browse source 
And also fix a few cases where mem::uninitialized() was simply wrong to
use.
This commit is contained in:
Sebastian Dröge 2019-07-11 15:34:28 +03:00
parent 3ea9a435e2
commit 3a8d05075d
30 changed files with 889 additions and 680 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
Gir_GstBase.toml
View file

@ -89,6 +89,11 @@ status = "generate"
# Use Result<FlowSuccess, FlowError> # Use Result<FlowSuccess, FlowError>
ignore = true ignore = true
[[object.function]]
name = "wait_clock"
# Use Result<ClockSuccess, ClockError>
ignore = true
[[object]] [[object]]
name = "GstBase.BaseSrc" name = "GstBase.BaseSrc"
status = "generate" status = "generate"
@ -162,7 +167,22 @@ status = "generate"
[[object.function]] [[object.function]]
name = "type_find_helper_for_data" name = "type_find_helper_for_data"
# broken data type # broken return value
ignore = true
[[object.function]]
name = "type_find_helper_for_data_with_extension"
# broken return value
ignore = true
[[object.function]]
name = "type_find_helper_for_buffer"
# broken return value
ignore = true
[[object.function]]
name = "type_find_helper_for_buffer_with_extension"
# broken return value
ignore = true ignore = true
[[object]] [[object]]

26
examples/src/bin/glupload.rs
View file

@ -104,7 +104,7 @@ struct Gl {
program: gl::types::GLuint, program: gl::types::GLuint,
attr_position: gl::types::GLint, attr_position: gl::types::GLint,
attr_texture: gl::types::GLint, attr_texture: gl::types::GLint,
vao: gl::types::GLuint, vao: Option<gl::types::GLuint>,
vertex_buffer: gl::types::GLuint, vertex_buffer: gl::types::GLuint,
vbo_indices: gl::types::GLuint, vbo_indices: gl::types::GLuint,
} }
@ -133,7 +133,7 @@ impl Gl {
self.gl.UseProgram(self.program); self.gl.UseProgram(self.program);
if self.gl.BindVertexArray.is_loaded() { if self.gl.BindVertexArray.is_loaded() {
self.gl.BindVertexArray(self.vao); self.gl.BindVertexArray(self.vao.unwrap());
} }
{ {
@ -242,14 +242,19 @@ fn load(gl_context: &glutin::WindowedContext<glutin::PossiblyCurrent>) -> Gl {
let attr_position = gl.GetAttribLocation(program, b"a_position\0".as_ptr() as *const _); let attr_position = gl.GetAttribLocation(program, b"a_position\0".as_ptr() as *const _);
let attr_texture = gl.GetAttribLocation(program, b"a_texcoord\0".as_ptr() as *const _); let attr_texture = gl.GetAttribLocation(program, b"a_texcoord\0".as_ptr() as *const _);
let mut vao = mem::uninitialized(); let vao = if gl.BindVertexArray.is_loaded() {
if gl.BindVertexArray.is_loaded() { let mut vao = mem::MaybeUninit::uninit();
gl.GenVertexArrays(1, &mut vao); gl.GenVertexArrays(1, vao.as_mut_ptr());
let vao = vao.assume_init();
gl.BindVertexArray(vao); gl.BindVertexArray(vao);
} Some(vao)
} else {
None
};
let mut vertex_buffer = mem::uninitialized(); let mut vertex_buffer = mem::MaybeUninit::uninit();
gl.GenBuffers(1, &mut vertex_buffer); gl.GenBuffers(1, vertex_buffer.as_mut_ptr());
let vertex_buffer = vertex_buffer.assume_init();
gl.BindBuffer(gl::ARRAY_BUFFER, vertex_buffer); gl.BindBuffer(gl::ARRAY_BUFFER, vertex_buffer);
gl.BufferData( gl.BufferData(
gl::ARRAY_BUFFER, gl::ARRAY_BUFFER,
@ -258,8 +263,9 @@ fn load(gl_context: &glutin::WindowedContext<glutin::PossiblyCurrent>) -> Gl {
gl::STATIC_DRAW, gl::STATIC_DRAW,
); );
let mut vbo_indices = mem::uninitialized(); let mut vbo_indices = mem::MaybeUninit::uninit();
gl.GenBuffers(1, &mut vbo_indices); gl.GenBuffers(1, vbo_indices.as_mut_ptr());
let vbo_indices = vbo_indices.assume_init();
gl.BindBuffer(gl::ELEMENT_ARRAY_BUFFER, vbo_indices); gl.BindBuffer(gl::ELEMENT_ARRAY_BUFFER, vbo_indices);
gl.BufferData( gl.BufferData(
gl::ELEMENT_ARRAY_BUFFER, gl::ELEMENT_ARRAY_BUFFER,

12
gstreamer-app/src/app_src.rs
View file

@ -217,10 +217,14 @@ impl AppSrc {
pub fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) { pub fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) {
unsafe { unsafe {
let mut min = mem::uninitialized(); let mut min = mem::MaybeUninit::uninit();
let mut max = mem::uninitialized(); let mut max = mem::MaybeUninit::uninit();
gst_app_sys::gst_app_src_get_latency(self.to_glib_none().0, &mut min, &mut max); gst_app_sys::gst_app_src_get_latency(
(from_glib(min), from_glib(max)) self.to_glib_none().0,
min.as_mut_ptr(),
max.as_mut_ptr(),
);
(from_glib(min.assume_init()), from_glib(max.assume_init()))
} }
} }
} }

6
gstreamer-audio/src/audio_channel_position.rs
View file

@ -48,15 +48,15 @@ impl AudioChannelPosition {
}); });
unsafe { unsafe {
let mut mask = mem::uninitialized(); let mut mask = mem::MaybeUninit::uninit();
let valid: bool = from_glib(gst_audio_sys::gst_audio_channel_positions_to_mask( let valid: bool = from_glib(gst_audio_sys::gst_audio_channel_positions_to_mask(
positions_raw.as_ptr() as *mut _, positions_raw.as_ptr() as *mut _,
len as i32, len as i32,
force_order.to_glib(), force_order.to_glib(),
&mut mask, mask.as_mut_ptr(),
)); ));
if valid { if valid {
Some(mask) Some(mask.assume_init())
} else { } else {
None None
} }

26
gstreamer-audio/src/audio_info.rs
View file

@ -51,7 +51,7 @@ pub struct AudioInfoBuilder<'a> {
impl<'a> AudioInfoBuilder<'a> { impl<'a> AudioInfoBuilder<'a> {
pub fn build(self) -> Option<AudioInfo> { pub fn build(self) -> Option<AudioInfo> {
unsafe { unsafe {
let mut info = mem::uninitialized(); let mut info = mem::MaybeUninit::uninit();
let positions = if let Some(p) = self.positions { let positions = if let Some(p) = self.positions {
if p.len() != self.channels as usize || p.len() > 64 { if p.len() != self.channels as usize || p.len() > 64 {
@ -88,13 +88,15 @@ impl<'a> AudioInfoBuilder<'a> {
.unwrap_or(ptr::null()); .unwrap_or(ptr::null());
gst_audio_sys::gst_audio_info_set_format( gst_audio_sys::gst_audio_info_set_format(
&mut info, info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.rate as i32, self.rate as i32,
self.channels as i32, self.channels as i32,
positions_ptr as *mut _, positions_ptr as *mut _,
); );
let mut info = info.assume_init();
if info.finfo.is_null() || info.rate <= 0 || info.channels <= 0 { if info.finfo.is_null() || info.rate <= 0 || info.channels <= 0 {
return None; return None;
} }
@ -153,11 +155,12 @@ impl AudioInfo {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let mut info = mem::uninitialized(); let mut info = mem::MaybeUninit::uninit();
if from_glib(gst_audio_sys::gst_audio_info_from_caps( if from_glib(gst_audio_sys::gst_audio_info_from_caps(
&mut info, info.as_mut_ptr(),
caps.as_ptr(), caps.as_ptr(),
)) { )) {
let info = info.assume_init();
let positions = array_init::array_init_copy(|i| from_glib(info.position[i])); let positions = array_init::array_init_copy(|i| from_glib(info.position[i]));
Some(AudioInfo(info, positions)) Some(AudioInfo(info, positions))
} else { } else {
@ -178,15 +181,15 @@ impl AudioInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_audio_sys::gst_audio_info_convert( if from_glib(gst_audio_sys::gst_audio_info_convert(
&self.0, &self.0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)) { )) {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -202,15 +205,18 @@ impl AudioInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_audio_sys::gst_audio_info_convert( if from_glib(gst_audio_sys::gst_audio_info_convert(
&self.0, &self.0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
dest_fmt.to_glib(), dest_fmt.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)) { )) {
Some(gst::GenericFormattedValue::new(dest_fmt, dest_val)) Some(gst::GenericFormattedValue::new(
dest_fmt,
dest_val.assume_init(),
))
} else { } else {
None None
} }

18
gstreamer-audio/src/audio_stream_align.rs
View file

@ -22,23 +22,23 @@ impl AudioStreamAlign {
n_samples: u32, n_samples: u32,
) -> (bool, gst::ClockTime, gst::ClockTime, u64) { ) -> (bool, gst::ClockTime, gst::ClockTime, u64) {
unsafe { unsafe {
let mut out_timestamp = mem::uninitialized(); let mut out_timestamp = mem::MaybeUninit::uninit();
let mut out_duration = mem::uninitialized(); let mut out_duration = mem::MaybeUninit::uninit();
let mut out_sample_position = mem::uninitialized(); let mut out_sample_position = mem::MaybeUninit::uninit();
let ret = from_glib(gst_audio_sys::gst_audio_stream_align_process( let ret = from_glib(gst_audio_sys::gst_audio_stream_align_process(
self.to_glib_none_mut().0, self.to_glib_none_mut().0,
discont.to_glib(), discont.to_glib(),
timestamp.to_glib(), timestamp.to_glib(),
n_samples, n_samples,
&mut out_timestamp, out_timestamp.as_mut_ptr(),
&mut out_duration, out_duration.as_mut_ptr(),
&mut out_sample_position, out_sample_position.as_mut_ptr(),
)); ));
( (
ret, ret,
from_glib(out_timestamp), from_glib(out_timestamp.assume_init()),
from_glib(out_duration), from_glib(out_duration.assume_init()),
out_sample_position, out_sample_position.assume_init(),
) )
} }
} }

4
gstreamer-audio/src/lib.rs
View file

@ -54,7 +54,7 @@ pub fn audio_buffer_clip(
buffer: gst::Buffer, buffer: gst::Buffer,
segment: &gst::Segment, segment: &gst::Segment,
rate: u32, rate: u32,
channels: u32, bpf: u32,
) -> Option<gst::Buffer> { ) -> Option<gst::Buffer> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -63,7 +63,7 @@ pub fn audio_buffer_clip(
buffer.into_ptr(), buffer.into_ptr(),
segment.to_glib_none().0, segment.to_glib_none().0,
rate as i32, rate as i32,
channels as i32, bpf as i32,
)) ))
} }
} }

15
gstreamer-base/src/auto/base_sink.rs
View file

@ -91,8 +91,6 @@ pub trait BaseSinkExt: 'static {
fn set_ts_offset(&self, offset: gst::ClockTimeDiff); fn set_ts_offset(&self, offset: gst::ClockTimeDiff);
fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff);
fn get_property_async(&self) -> bool; fn get_property_async(&self) -> bool;
fn set_property_async(&self, async: bool); fn set_property_async(&self, async: bool);
@ -394,19 +392,6 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
} }
fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff) {
unsafe {
let mut jitter = mem::MaybeUninit::uninit();
let ret = from_glib(gst_base_sys::gst_base_sink_wait_clock(
self.as_ref().to_glib_none().0,
time.to_glib(),
jitter.as_mut_ptr(),
));
let jitter = jitter.assume_init();
(ret, jitter)
}
}
fn get_property_async(&self) -> bool { fn get_property_async(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());

62
gstreamer-base/src/auto/functions.rs
View file

@ -6,7 +6,6 @@ use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_base_sys; use gst_base_sys;
use std::mem;
pub fn type_find_helper<P: IsA<gst::Pad>>(src: &P, size: u64) -> Option<gst::Caps> { pub fn type_find_helper<P: IsA<gst::Pad>>(src: &P, size: u64) -> Option<gst::Caps> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
@ -18,67 +17,6 @@ pub fn type_find_helper<P: IsA<gst::Pad>>(src: &P, size: u64) -> Option<gst::Cap
} }
} }
pub fn type_find_helper_for_buffer<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_buffer(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
prob.as_mut_ptr(),
));
let prob = prob.assume_init();
(ret, from_glib(prob))
}
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_buffer_with_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
extension: Option<&str>,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = from_glib_full(
gst_base_sys::gst_type_find_helper_for_buffer_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
extension.to_glib_none().0,
prob.as_mut_ptr(),
),
);
let prob = prob.assume_init();
(ret, from_glib(prob))
}
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_data_with_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
data: &[u8],
extension: Option<&str>,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!();
let size = data.len() as usize;
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_data_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
data.to_glib_none().0,
size,
extension.to_glib_none().0,
prob.as_mut_ptr(),
));
let prob = prob.assume_init();
(ret, from_glib(prob))
}
}
pub fn type_find_helper_for_extension<P: IsA<gst::Object>>( pub fn type_find_helper_for_extension<P: IsA<gst::Object>>(
obj: Option<&P>, obj: Option<&P>,
extension: &str, extension: &str,

15
gstreamer-base/src/base_parse.rs
View file

@ -86,16 +86,16 @@ impl<O: IsA<BaseParse>> BaseParseExtManual for O {
) -> Option<U> { ) -> Option<U> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_base_sys::gst_base_parse_convert_default( let ret = from_glib(gst_base_sys::gst_base_parse_convert_default(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -109,16 +109,19 @@ impl<O: IsA<BaseParse>> BaseParseExtManual for O {
) -> Option<gst::GenericFormattedValue> { ) -> Option<gst::GenericFormattedValue> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_base_sys::gst_base_parse_convert_default( let ret = from_glib(gst_base_sys::gst_base_parse_convert_default(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
dest_format.to_glib(), dest_format.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(gst::GenericFormattedValue::new(dest_format, dest_val)) Some(gst::GenericFormattedValue::new(
dest_format,
dest_val.assume_init(),
))
} else { } else {
None None
} }

28
gstreamer-base/src/base_sink.rs
View file

@ -10,7 +10,6 @@ use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_base_sys; use gst_base_sys;
use std::mem;
use BaseSink; use BaseSink;
pub trait BaseSinkExtManual: 'static { pub trait BaseSinkExtManual: 'static {
@ -22,6 +21,13 @@ pub trait BaseSinkExtManual: 'static {
) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff); ) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff);
fn wait_preroll(&self) -> Result<gst::FlowSuccess, gst::FlowError>; fn wait_preroll(&self) -> Result<gst::FlowSuccess, gst::FlowError>;
fn wait_clock(
&self,
time: gst::ClockTime,
) -> (
Result<gst::ClockSuccess, gst::ClockError>,
gst::ClockTimeDiff,
);
} }
impl<O: IsA<BaseSink>> BaseSinkExtManual for O { impl<O: IsA<BaseSink>> BaseSinkExtManual for O {
@ -38,7 +44,7 @@ impl<O: IsA<BaseSink>> BaseSinkExtManual for O {
time: gst::ClockTime, time: gst::ClockTime,
) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff) { ) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff) {
unsafe { unsafe {
let mut jitter = mem::uninitialized(); let mut jitter = 0;
let ret: gst::FlowReturn = from_glib(gst_base_sys::gst_base_sink_wait( let ret: gst::FlowReturn = from_glib(gst_base_sys::gst_base_sink_wait(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
time.to_glib(), time.to_glib(),
@ -56,4 +62,22 @@ impl<O: IsA<BaseSink>> BaseSinkExtManual for O {
}; };
ret.into_result() ret.into_result()
} }
fn wait_clock(
&self,
time: gst::ClockTime,
) -> (
Result<gst::ClockSuccess, gst::ClockError>,
gst::ClockTimeDiff,
) {
unsafe {
let mut jitter = 0;
let ret: gst::ClockReturn = from_glib(gst_base_sys::gst_base_sink_wait_clock(
self.as_ref().to_glib_none().0,
time.to_glib(),
&mut jitter,
));
(ret.into_result(), jitter)
}
}
} }

85
gstreamer-base/src/functions.rs
View file

@ -15,18 +15,91 @@ use std::mem;
pub fn type_find_helper_for_data<P: IsA<gst::Object>, R: AsRef<[u8]>>( pub fn type_find_helper_for_data<P: IsA<gst::Object>, R: AsRef<[u8]>>(
obj: Option<&P>, obj: Option<&P>,
data: R, data: R,
) -> (Option<gst::Caps>, gst::TypeFindProbability) { ) -> Option<(gst::Caps, gst::TypeFindProbability)> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut prob = mem::uninitialized(); let mut prob = mem::MaybeUninit::uninit();
let data = data.as_ref(); let data = data.as_ref();
let (ptr, len) = (data.as_ptr(), data.len()); let (ptr, len) = (data.as_ptr(), data.len());
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_data( let ret = gst_base_sys::gst_type_find_helper_for_data(
obj.map(|p| p.as_ref()).to_glib_none().0, obj.map(|p| p.as_ref()).to_glib_none().0,
mut_override(ptr), mut_override(ptr),
len, len,
&mut prob, prob.as_mut_ptr(),
)); );
(ret, from_glib(prob)) if ret.is_null() {
None
} else {
Some((from_glib_full(ret), from_glib(prob.assume_init())))
}
}
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_data_with_extension<P: IsA<gst::Object>, R: AsRef<[u8]>>(
obj: Option<&P>,
data: R,
extension: Option<&str>,
) -> Option<(gst::Caps, gst::TypeFindProbability)> {
assert_initialized_main_thread!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let data = data.as_ref();
let (ptr, len) = (data.as_ptr(), data.len());
let ret = gst_base_sys::gst_type_find_helper_for_data_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
mut_override(ptr),
len,
extension.to_glib_none().0,
prob.as_mut_ptr(),
);
if ret.is_null() {
None
} else {
Some((from_glib_full(ret), from_glib(prob.assume_init())))
}
}
}
pub fn type_find_helper_for_buffer<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
) -> Option<(gst::Caps, gst::TypeFindProbability)> {
assert_initialized_main_thread!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = gst_base_sys::gst_type_find_helper_for_buffer(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
prob.as_mut_ptr(),
);
if ret.is_null() {
None
} else {
Some((from_glib_full(ret), from_glib(prob.assume_init())))
}
}
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_buffer_with_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
extension: Option<&str>,
) -> Option<(gst::Caps, gst::TypeFindProbability)> {
assert_initialized_main_thread!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = gst_base_sys::gst_type_find_helper_for_buffer_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
extension.to_glib_none().0,
prob.as_mut_ptr(),
);
if ret.is_null() {
None
} else {
Some((from_glib_full(ret), from_glib(prob.assume_init())))
}
} }
} }

11
gstreamer-base/src/subclass/base_parse.rs
View file

@ -162,22 +162,23 @@ impl<T: BaseParseImpl + ObjectImpl> BaseParseImplExt for T {
data.as_ref().get_parent_class() as *mut gst_base_sys::GstBaseParseClass; data.as_ref().get_parent_class() as *mut gst_base_sys::GstBaseParseClass;
let src_val = src_val.into(); let src_val = src_val.into();
let res = (*parent_class).convert.map(|f| { let res = (*parent_class).convert.map(|f| {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let res = from_glib(f( let res = from_glib(f(
element.to_glib_none().0, element.to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
dest_format.to_glib(), dest_format.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
(res, dest_val) (res, dest_val)
}); });
match res { match res {
Some((true, dest_val)) => { Some((true, dest_val)) => Some(gst::GenericFormattedValue::new(
Some(gst::GenericFormattedValue::new(dest_format, dest_val)) dest_format,
} dest_val.assume_init(),
)),
_ => None, _ => None,
} }
} }

7
gstreamer-base/src/subclass/base_src.rs
View file

@ -17,6 +17,7 @@ use glib::subclass::prelude::*;
use gst; use gst;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use std::mem;
use std::ptr; use std::ptr;
use BaseSrc; use BaseSrc;
@ -205,9 +206,9 @@ impl<T: BaseSrcImpl + ObjectImpl> BaseSrcImplExt for T {
(*parent_class) (*parent_class)
.get_size .get_size
.map(|f| { .map(|f| {
let mut size = 0; let mut size = mem::MaybeUninit::uninit();
if from_glib(f(element.to_glib_none().0, &mut size)) { if from_glib(f(element.to_glib_none().0, size.as_mut_ptr())) {
Some(size) Some(size.assume_init())
} else { } else {
None None
} }

14
gstreamer-base/src/subclass/base_transform.rs
View file

@ -17,6 +17,8 @@ use glib::subclass::prelude::*;
use gst; use gst;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use std::mem;
use BaseTransform; use BaseTransform;
use BaseTransformClass; use BaseTransformClass;
@ -372,17 +374,17 @@ impl<T: BaseTransformImpl + ObjectImpl> BaseTransformImplExt for T {
(*parent_class) (*parent_class)
.transform_size .transform_size
.map(|f| { .map(|f| {
let mut othersize = 0; let mut othersize = mem::MaybeUninit::uninit();
let res: bool = from_glib(f( let res: bool = from_glib(f(
element.to_glib_none().0, element.to_glib_none().0,
direction.to_glib(), direction.to_glib(),
caps.to_glib_none().0, caps.to_glib_none().0,
size, size,
othercaps.to_glib_none().0, othercaps.to_glib_none().0,
&mut othersize, othersize.as_mut_ptr(),
)); ));
if res { if res {
Some(othersize) Some(othersize.assume_init())
} else { } else {
None None
} }
@ -410,13 +412,13 @@ impl<T: BaseTransformImpl + ObjectImpl> BaseTransformImplExt for T {
} }
}); });
let mut size = 0; let mut size = mem::MaybeUninit::uninit();
if from_glib(f( if from_glib(f(
element.to_glib_none().0, element.to_glib_none().0,
caps.to_glib_none().0, caps.to_glib_none().0,
&mut size, size.as_mut_ptr(),
)) { )) {
Some(size) Some(size.assume_init())
} else { } else {
None None
} }

20
gstreamer-player/src/player_video_info.rs
View file

@ -15,27 +15,27 @@ use PlayerVideoInfo;
impl PlayerVideoInfo { impl PlayerVideoInfo {
pub fn get_framerate(&self) -> gst::Fraction { pub fn get_framerate(&self) -> gst::Fraction {
unsafe { unsafe {
let mut fps_n = mem::uninitialized(); let mut fps_n = mem::MaybeUninit::uninit();
let mut fps_d = mem::uninitialized(); let mut fps_d = mem::MaybeUninit::uninit();
gst_player_sys::gst_player_video_info_get_framerate( gst_player_sys::gst_player_video_info_get_framerate(
self.to_glib_none().0, self.to_glib_none().0,
&mut fps_n, fps_n.as_mut_ptr(),
&mut fps_d, fps_d.as_mut_ptr(),
); );
(fps_n as i32, fps_d as i32).into() (fps_n.assume_init() as i32, fps_d.as_mut_ptr() as i32).into()
} }
} }
pub fn get_pixel_aspect_ratio(&self) -> gst::Fraction { pub fn get_pixel_aspect_ratio(&self) -> gst::Fraction {
unsafe { unsafe {
let mut par_n = mem::uninitialized(); let mut par_n = mem::MaybeUninit::uninit();
let mut par_d = mem::uninitialized(); let mut par_d = mem::MaybeUninit::uninit();
gst_player_sys::gst_player_video_info_get_pixel_aspect_ratio( gst_player_sys::gst_player_video_info_get_pixel_aspect_ratio(
self.to_glib_none().0, self.to_glib_none().0,
&mut par_n, par_n.as_mut_ptr(),
&mut par_d, par_d.as_mut_ptr(),
); );
(par_n as i32, par_d as i32).into() (par_n.assume_init() as i32, par_d.assume_init() as i32).into()
} }
} }
} }

54
gstreamer-video/src/video_event.rs
View file

@ -160,29 +160,29 @@ pub fn parse_downstream_force_key_unit_event(
event: &gst::EventRef, event: &gst::EventRef,
) -> Option<DownstreamForceKeyUnitEvent> { ) -> Option<DownstreamForceKeyUnitEvent> {
unsafe { unsafe {
let mut timestamp = mem::uninitialized(); let mut timestamp = mem::MaybeUninit::uninit();
let mut stream_time = mem::uninitialized(); let mut stream_time = mem::MaybeUninit::uninit();
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
let mut all_headers = mem::uninitialized(); let mut all_headers = mem::MaybeUninit::uninit();
let mut count = mem::uninitialized(); let mut count = mem::MaybeUninit::uninit();
let res: bool = from_glib( let res: bool = from_glib(
gst_video_sys::gst_video_event_parse_downstream_force_key_unit( gst_video_sys::gst_video_event_parse_downstream_force_key_unit(
event.as_mut_ptr(), event.as_mut_ptr(),
&mut timestamp, timestamp.as_mut_ptr(),
&mut stream_time, stream_time.as_mut_ptr(),
&mut running_time, running_time.as_mut_ptr(),
&mut all_headers, all_headers.as_mut_ptr(),
&mut count, count.as_mut_ptr(),
), ),
); );
if res { if res {
Some(DownstreamForceKeyUnitEvent { Some(DownstreamForceKeyUnitEvent {
timestamp: from_glib(timestamp), timestamp: from_glib(timestamp.assume_init()),
stream_time: from_glib(stream_time), stream_time: from_glib(stream_time.assume_init()),
running_time: from_glib(running_time), running_time: from_glib(running_time.assume_init()),
all_headers: from_glib(all_headers), all_headers: from_glib(all_headers.assume_init()),
count, count: count.assume_init(),
}) })
} else { } else {
None None
@ -254,23 +254,23 @@ pub fn parse_upstream_force_key_unit_event(
event: &gst::EventRef, event: &gst::EventRef,
) -> Option<UpstreamForceKeyUnitEvent> { ) -> Option<UpstreamForceKeyUnitEvent> {
unsafe { unsafe {
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
let mut all_headers = mem::uninitialized(); let mut all_headers = mem::MaybeUninit::uninit();
let mut count = mem::uninitialized(); let mut count = mem::MaybeUninit::uninit();
let res: bool = from_glib( let res: bool = from_glib(
gst_video_sys::gst_video_event_parse_upstream_force_key_unit( gst_video_sys::gst_video_event_parse_upstream_force_key_unit(
event.as_mut_ptr(), event.as_mut_ptr(),
&mut running_time, running_time.as_mut_ptr(),
&mut all_headers, all_headers.as_mut_ptr(),
&mut count, count.as_mut_ptr(),
), ),
); );
if res { if res {
Some(UpstreamForceKeyUnitEvent { Some(UpstreamForceKeyUnitEvent {
running_time: from_glib(running_time), running_time: from_glib(running_time.assume_init()),
all_headers: from_glib(all_headers), all_headers: from_glib(all_headers.assume_init()),
count, count: count.assume_init(),
}) })
} else { } else {
None None
@ -326,15 +326,15 @@ pub struct StillFrameEvent {
pub fn parse_still_frame_event(event: &gst::EventRef) -> Option<StillFrameEvent> { pub fn parse_still_frame_event(event: &gst::EventRef) -> Option<StillFrameEvent> {
unsafe { unsafe {
let mut in_still = mem::uninitialized(); let mut in_still = mem::MaybeUninit::uninit();
let res: bool = from_glib(gst_video_sys::gst_video_event_parse_still_frame( let res: bool = from_glib(gst_video_sys::gst_video_event_parse_still_frame(
event.as_mut_ptr(), event.as_mut_ptr(),
&mut in_still, in_still.as_mut_ptr(),
)); ));
if res { if res {
Some(StillFrameEvent { Some(StillFrameEvent {
in_still: from_glib(in_still), in_still: from_glib(in_still.assume_init()),
}) })
} else { } else {
None None

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

@ -270,41 +270,52 @@ pub struct VideoInfoBuilder<'a> {
impl<'a> VideoInfoBuilder<'a> { impl<'a> VideoInfoBuilder<'a> {
pub fn build(self) -> Option<VideoInfo> { pub fn build(self) -> Option<VideoInfo> {
unsafe { unsafe {
let mut info = mem::uninitialized(); let mut info = mem::MaybeUninit::uninit();
#[cfg(not(feature = "v1_16"))] #[cfg(not(feature = "v1_16"))]
{ let res: bool = {
gst_video_sys::gst_video_info_set_format( let res = from_glib(gst_video_sys::gst_video_info_set_format(
&mut info, info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
self.height, self.height,
); ));
if let Some(interlace_mode) = self.interlace_mode { if res {
info.interlace_mode = interlace_mode.to_glib(); if let Some(interlace_mode) = self.interlace_mode {
let info = info.as_mut_ptr();
(*info).interlace_mode = interlace_mode.to_glib();
}
} }
}
res
};
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
{ let res: bool = {
if let Some(interlace_mode) = self.interlace_mode { from_glib(if let Some(interlace_mode) = self.interlace_mode {
gst_video_sys::gst_video_info_set_interlaced_format( gst_video_sys::gst_video_info_set_interlaced_format(
&mut info, info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
interlace_mode.to_glib(), interlace_mode.to_glib(),
self.width, self.width,
self.height, self.height,
); )
} else { } else {
gst_video_sys::gst_video_info_set_format( gst_video_sys::gst_video_info_set_format(
&mut info, info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
self.height, self.height,
); )
} })
};
if !res {
return None;
} }
let mut info = info.assume_init();
if info.finfo.is_null() || info.width <= 0 || info.height <= 0 { if info.finfo.is_null() || info.width <= 0 || info.height <= 0 {
return None; return None;
} }
@ -524,12 +535,12 @@ impl VideoInfo {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let mut info = mem::uninitialized(); let mut info = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_from_caps( if from_glib(gst_video_sys::gst_video_info_from_caps(
&mut info, info.as_mut_ptr(),
caps.as_ptr(), caps.as_ptr(),
)) { )) {
Some(VideoInfo(info)) Some(VideoInfo(info.assume_init()))
} else { } else {
None None
} }
@ -658,15 +669,15 @@ impl VideoInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_convert( if from_glib(gst_video_sys::gst_video_info_convert(
&self.0 as *const _ as *mut _, &self.0 as *const _ as *mut _,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)) { )) {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -682,15 +693,18 @@ impl VideoInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_convert( if from_glib(gst_video_sys::gst_video_info_convert(
&self.0 as *const _ as *mut _, &self.0 as *const _ as *mut _,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
dest_fmt.to_glib(), dest_fmt.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)) { )) {
Some(gst::GenericFormattedValue::new(dest_fmt, dest_val)) Some(gst::GenericFormattedValue::new(
dest_fmt,
dest_val.assume_init(),
))
} else { } else {
None None
} }

24
gstreamer-video/src/video_overlay_composition.rs
View file

@ -7,6 +7,7 @@
// except according to those terms. // except according to those terms.
use std::fmt; use std::fmt;
use std::mem;
use gst; use gst;
use gst::miniobject::*; use gst::miniobject::*;
@ -81,20 +82,25 @@ impl VideoOverlayRectangleRef {
pub fn get_render_rectangle(&self) -> (i32, i32, u32, u32) { pub fn get_render_rectangle(&self) -> (i32, i32, u32, u32) {
unsafe { unsafe {
let mut render_x = 0; let mut render_x = mem::MaybeUninit::uninit();
let mut render_y = 0; let mut render_y = mem::MaybeUninit::uninit();
let mut render_width = 0; let mut render_width = mem::MaybeUninit::uninit();
let mut render_height = 0; let mut render_height = mem::MaybeUninit::uninit();
gst_video_sys::gst_video_overlay_rectangle_get_render_rectangle( gst_video_sys::gst_video_overlay_rectangle_get_render_rectangle(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut render_x, render_x.as_mut_ptr(),
&mut render_y, render_y.as_mut_ptr(),
&mut render_width, render_width.as_mut_ptr(),
&mut render_height, render_height.as_mut_ptr(),
); );
(render_x, render_y, render_width, render_height) (
render_x.assume_init(),
render_y.assume_init(),
render_width.assume_init(),
render_height.assume_init(),
)
} }
} }

38
gstreamer/src/buffer.rs
View file

@ -297,19 +297,18 @@ impl BufferRef {
} }
pub fn get_maxsize(&self) -> usize { pub fn get_maxsize(&self) -> usize {
let mut maxsize: usize = 0;
unsafe { unsafe {
let mut maxsize = mem::MaybeUninit::uninit();
gst_sys::gst_buffer_get_sizes_range( gst_sys::gst_buffer_get_sizes_range(
self.as_mut_ptr(), self.as_mut_ptr(),
0, 0,
-1, -1,
ptr::null_mut(), ptr::null_mut(),
&mut maxsize, maxsize.as_mut_ptr(),
); );
};
maxsize maxsize.assume_init()
}
} }
pub fn set_size(&mut self, size: usize) { pub fn set_size(&mut self, size: usize) {
@ -412,24 +411,25 @@ impl BufferRef {
} }
pub fn find_memory(&self, offset: usize, size: Option<usize>) -> Option<(u32, u32, usize)> { pub fn find_memory(&self, offset: usize, size: Option<usize>) -> Option<(u32, u32, usize)> {
let mut idx = 0;
let mut length = 0;
let mut skip = 0;
let res;
unsafe { unsafe {
res = from_glib(gst_sys::gst_buffer_find_memory( let mut idx = mem::MaybeUninit::uninit();
let mut length = mem::MaybeUninit::uninit();
let mut skip = mem::MaybeUninit::uninit();
let res = from_glib(gst_sys::gst_buffer_find_memory(
self.as_mut_ptr(), self.as_mut_ptr(),
offset, offset,
size.unwrap_or(usize::MAX), size.unwrap_or(usize::MAX),
&mut idx, idx.as_mut_ptr(),
&mut length, length.as_mut_ptr(),
&mut skip, skip.as_mut_ptr(),
)) ));
}
if res { if res {
Some((idx, length, skip)) Some((idx.assume_init(), length.assume_init(), skip.assume_init()))
} else { } else {
None None
}
} }
} }

19
gstreamer/src/buffer_pool.rs
View file

@ -106,22 +106,27 @@ impl BufferPoolConfig {
pub fn get_params(&self) -> Option<(Option<::Caps>, u32, u32, u32)> { pub fn get_params(&self) -> Option<(Option<::Caps>, u32, u32, u32)> {
unsafe { unsafe {
let mut caps = ptr::null_mut(); let mut caps = ptr::null_mut();
let mut size = mem::uninitialized(); let mut size = mem::MaybeUninit::uninit();
let mut min_buffers = mem::uninitialized(); let mut min_buffers = mem::MaybeUninit::uninit();
let mut max_buffers = mem::uninitialized(); let mut max_buffers = mem::MaybeUninit::uninit();
let ret: bool = from_glib(gst_sys::gst_buffer_pool_config_get_params( let ret: bool = from_glib(gst_sys::gst_buffer_pool_config_get_params(
self.0.to_glib_none().0, self.0.to_glib_none().0,
&mut caps, &mut caps,
&mut size, size.as_mut_ptr(),
&mut min_buffers, min_buffers.as_mut_ptr(),
&mut max_buffers, max_buffers.as_mut_ptr(),
)); ));
if !ret { if !ret {
return None; return None;
} }
Some((from_glib_none(caps), size, min_buffers, max_buffers)) Some((
from_glib_none(caps),
size.assume_init(),
min_buffers.assume_init(),
max_buffers.assume_init(),
))
} }
} }

3
gstreamer/src/clock.rs
View file

@ -15,7 +15,6 @@ use glib_sys::{gboolean, gpointer};
use gst_sys; use gst_sys;
use libc::c_void; use libc::c_void;
use std::cmp; use std::cmp;
use std::mem;
use std::ptr; use std::ptr;
use Clock; use Clock;
use ClockError; use ClockError;
@ -74,7 +73,7 @@ impl ClockId {
pub fn wait(&self) -> (Result<ClockSuccess, ClockError>, ClockTimeDiff) { pub fn wait(&self) -> (Result<ClockSuccess, ClockError>, ClockTimeDiff) {
unsafe { unsafe {
let mut jitter = mem::uninitialized(); let mut jitter = 0;
let res: ClockReturn = from_glib(gst_sys::gst_clock_id_wait( let res: ClockReturn = from_glib(gst_sys::gst_clock_id_wait(
self.to_glib_none().0, self.to_glib_none().0,
&mut jitter, &mut jitter,

53
gstreamer/src/element.rs
View file

@ -285,15 +285,19 @@ impl<O: IsA<Element>> ElementExtManual for O {
timeout: ClockTime, timeout: ClockTime,
) -> (Result<StateChangeSuccess, StateChangeError>, State, State) { ) -> (Result<StateChangeSuccess, StateChangeError>, State, State) {
unsafe { unsafe {
let mut state = mem::uninitialized(); let mut state = mem::MaybeUninit::uninit();
let mut pending = mem::uninitialized(); let mut pending = mem::MaybeUninit::uninit();
let ret: StateChangeReturn = from_glib(gst_sys::gst_element_get_state( let ret: StateChangeReturn = from_glib(gst_sys::gst_element_get_state(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
&mut state, state.as_mut_ptr(),
&mut pending, pending.as_mut_ptr(),
timeout.to_glib(), timeout.to_glib(),
)); ));
(ret.into_result(), from_glib(state), from_glib(pending)) (
ret.into_result(),
from_glib(state.assume_init()),
from_glib(pending.assume_init()),
)
} }
} }
@ -548,16 +552,16 @@ impl<O: IsA<Element>> ElementExtManual for O {
) -> Option<U> { ) -> Option<U> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_convert( let ret = from_glib(gst_sys::gst_element_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -571,16 +575,19 @@ impl<O: IsA<Element>> ElementExtManual for O {
) -> Option<GenericFormattedValue> { ) -> Option<GenericFormattedValue> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_convert( let ret = from_glib(gst_sys::gst_element_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.get_value(), src_val.get_value(),
dest_format.to_glib(), dest_format.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(dest_format, dest_val)) Some(GenericFormattedValue::new(
dest_format,
dest_val.assume_init(),
))
} else { } else {
None None
} }
@ -589,14 +596,14 @@ impl<O: IsA<Element>> ElementExtManual for O {
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> { fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_duration( let ret = from_glib(gst_sys::gst_element_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), duration)) Some(T::from_raw(T::get_default_format(), duration.assume_init()))
} else { } else {
None None
} }
@ -605,14 +612,14 @@ impl<O: IsA<Element>> ElementExtManual for O {
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_duration( let ret = from_glib(gst_sys::gst_element_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, duration)) Some(GenericFormattedValue::new(format, duration.assume_init()))
} else { } else {
None None
} }
@ -621,14 +628,14 @@ impl<O: IsA<Element>> ElementExtManual for O {
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> { fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_position( let ret = from_glib(gst_sys::gst_element_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), cur)) Some(T::from_raw(T::get_default_format(), cur.assume_init()))
} else { } else {
None None
} }
@ -637,14 +644,14 @@ impl<O: IsA<Element>> ElementExtManual for O {
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_element_query_position( let ret = from_glib(gst_sys::gst_element_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, cur)) Some(GenericFormattedValue::new(format, cur.assume_init()))
} else { } else {
None None
} }

185
gstreamer/src/event.rs
View file

@ -520,11 +520,11 @@ declare_concrete_event!(FlushStop);
impl<'a> FlushStop<'a> { impl<'a> FlushStop<'a> {
pub fn get_reset_time(&self) -> bool { pub fn get_reset_time(&self) -> bool {
unsafe { unsafe {
let mut reset_time = mem::uninitialized(); let mut reset_time = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_flush_stop(self.as_mut_ptr(), &mut reset_time); gst_sys::gst_event_parse_flush_stop(self.as_mut_ptr(), reset_time.as_mut_ptr());
from_glib(reset_time) from_glib(reset_time.assume_init())
} }
} }
} }
@ -542,21 +542,21 @@ impl<'a> StreamStart<'a> {
pub fn get_stream_flags(&self) -> ::StreamFlags { pub fn get_stream_flags(&self) -> ::StreamFlags {
unsafe { unsafe {
let mut stream_flags = mem::uninitialized(); let mut stream_flags = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_stream_flags(self.as_mut_ptr(), &mut stream_flags); gst_sys::gst_event_parse_stream_flags(self.as_mut_ptr(), stream_flags.as_mut_ptr());
from_glib(stream_flags) from_glib(stream_flags.assume_init())
} }
} }
pub fn get_group_id(&self) -> GroupId { pub fn get_group_id(&self) -> GroupId {
unsafe { unsafe {
let mut group_id = mem::uninitialized(); let mut group_id = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_group_id(self.as_mut_ptr(), &mut group_id); gst_sys::gst_event_parse_group_id(self.as_mut_ptr(), group_id.as_mut_ptr());
from_glib(group_id) from_glib(group_id.assume_init())
} }
} }
} }
@ -622,22 +622,22 @@ declare_concrete_event!(BufferSize);
impl<'a> BufferSize<'a> { impl<'a> BufferSize<'a> {
pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) { pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut minsize = mem::uninitialized(); let mut minsize = mem::MaybeUninit::uninit();
let mut maxsize = mem::uninitialized(); let mut maxsize = mem::MaybeUninit::uninit();
let mut async = mem::uninitialized(); let mut async_ = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_buffer_size( gst_sys::gst_event_parse_buffer_size(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut minsize, minsize.as_mut_ptr(),
&mut maxsize, maxsize.as_mut_ptr(),
&mut async, async_.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(fmt), minsize), GenericFormattedValue::new(from_glib(fmt.assume_init()), minsize.assume_init()),
GenericFormattedValue::new(from_glib(fmt), maxsize), GenericFormattedValue::new(from_glib(fmt.assume_init()), maxsize.assume_init()),
from_glib(async), from_glib(async_.assume_init()),
) )
} }
} }
@ -660,11 +660,11 @@ impl<'a> StreamGroupDone<'a> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn get_group_id(&self) -> GroupId { pub fn get_group_id(&self) -> GroupId {
unsafe { unsafe {
let mut group_id = mem::uninitialized(); let mut group_id = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_stream_group_done(self.as_mut_ptr(), &mut group_id); gst_sys::gst_event_parse_stream_group_done(self.as_mut_ptr(), group_id.as_mut_ptr());
from_glib(group_id) from_glib(group_id.assume_init())
} }
} }
} }
@ -676,10 +676,10 @@ impl<'a> Toc<'a> {
pub fn get_toc(&self) -> (&'a ::TocRef, bool) { pub fn get_toc(&self) -> (&'a ::TocRef, bool) {
unsafe { unsafe {
let mut toc = ptr::null_mut(); let mut toc = ptr::null_mut();
let mut updated = mem::uninitialized(); let mut updated = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_toc(self.as_mut_ptr(), &mut toc, &mut updated); gst_sys::gst_event_parse_toc(self.as_mut_ptr(), &mut toc, updated.as_mut_ptr());
(::TocRef::from_ptr(toc), from_glib(updated)) (::TocRef::from_ptr(toc), from_glib(updated.assume_init()))
} }
} }
@ -730,12 +730,16 @@ declare_concrete_event!(SegmentDone);
impl<'a> SegmentDone<'a> { impl<'a> SegmentDone<'a> {
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut position = mem::uninitialized(); let mut position = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_segment_done(self.as_mut_ptr(), &mut fmt, &mut position); gst_sys::gst_event_parse_segment_done(
self.as_mut_ptr(),
fmt.as_mut_ptr(),
position.as_mut_ptr(),
);
GenericFormattedValue::new(from_glib(fmt), position) GenericFormattedValue::new(from_glib(fmt.assume_init()), position.assume_init())
} }
} }
} }
@ -744,12 +748,19 @@ declare_concrete_event!(Gap);
impl<'a> Gap<'a> { impl<'a> Gap<'a> {
pub fn get(&self) -> (::ClockTime, ::ClockTime) { pub fn get(&self) -> (::ClockTime, ::ClockTime) {
unsafe { unsafe {
let mut timestamp = mem::uninitialized(); let mut timestamp = mem::MaybeUninit::uninit();
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_gap(self.as_mut_ptr(), &mut timestamp, &mut duration); gst_sys::gst_event_parse_gap(
self.as_mut_ptr(),
timestamp.as_mut_ptr(),
duration.as_mut_ptr(),
);
(from_glib(timestamp), from_glib(duration)) (
from_glib(timestamp.assume_init()),
from_glib(duration.assume_init()),
)
} }
} }
} }
@ -758,20 +769,25 @@ declare_concrete_event!(Qos);
impl<'a> Qos<'a> { impl<'a> Qos<'a> {
pub fn get(&self) -> (::QOSType, f64, i64, ::ClockTime) { pub fn get(&self) -> (::QOSType, f64, i64, ::ClockTime) {
unsafe { unsafe {
let mut type_ = mem::uninitialized(); let mut type_ = mem::MaybeUninit::uninit();
let mut proportion = mem::uninitialized(); let mut proportion = mem::MaybeUninit::uninit();
let mut diff = mem::uninitialized(); let mut diff = mem::MaybeUninit::uninit();
let mut timestamp = mem::uninitialized(); let mut timestamp = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_qos( gst_sys::gst_event_parse_qos(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut type_, type_.as_mut_ptr(),
&mut proportion, proportion.as_mut_ptr(),
&mut diff, diff.as_mut_ptr(),
&mut timestamp, timestamp.as_mut_ptr(),
); );
(from_glib(type_), proportion, diff, from_glib(timestamp)) (
from_glib(type_.assume_init()),
proportion.assume_init(),
diff.assume_init(),
from_glib(timestamp.assume_init()),
)
} }
} }
} }
@ -789,32 +805,32 @@ impl<'a> Seek<'a> {
GenericFormattedValue, GenericFormattedValue,
) { ) {
unsafe { unsafe {
let mut rate = mem::uninitialized(); let mut rate = mem::MaybeUninit::uninit();
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut flags = mem::uninitialized(); let mut flags = mem::MaybeUninit::uninit();
let mut start_type = mem::uninitialized(); let mut start_type = mem::MaybeUninit::uninit();
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut stop_type = mem::uninitialized(); let mut stop_type = mem::MaybeUninit::uninit();
let mut stop = mem::uninitialized(); let mut stop = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_seek( gst_sys::gst_event_parse_seek(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut rate, rate.as_mut_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut flags, flags.as_mut_ptr(),
&mut start_type, start_type.as_mut_ptr(),
&mut start, start.as_mut_ptr(),
&mut stop_type, stop_type.as_mut_ptr(),
&mut stop, stop.as_mut_ptr(),
); );
( (
rate, rate.assume_init(),
from_glib(flags), from_glib(flags.assume_init()),
from_glib(start_type), from_glib(start_type.assume_init()),
GenericFormattedValue::new(from_glib(fmt), start), GenericFormattedValue::new(from_glib(fmt.assume_init()), start.assume_init()),
from_glib(stop_type), from_glib(stop_type.assume_init()),
GenericFormattedValue::new(from_glib(fmt), stop), GenericFormattedValue::new(from_glib(fmt.assume_init()), stop.assume_init()),
) )
} }
} }
@ -822,14 +838,14 @@ impl<'a> Seek<'a> {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn get_trickmode_interval(&self) -> ::ClockTime { pub fn get_trickmode_interval(&self) -> ::ClockTime {
unsafe { unsafe {
let mut trickmode_interval = mem::uninitialized(); let mut trickmode_interval = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_seek_trickmode_interval( gst_sys::gst_event_parse_seek_trickmode_interval(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut trickmode_interval, trickmode_interval.as_mut_ptr(),
); );
from_glib(trickmode_interval) from_glib(trickmode_interval.assume_init())
} }
} }
} }
@ -840,11 +856,11 @@ declare_concrete_event!(Latency);
impl<'a> Latency<'a> { impl<'a> Latency<'a> {
pub fn get_latency(&self) -> ::ClockTime { pub fn get_latency(&self) -> ::ClockTime {
unsafe { unsafe {
let mut latency = mem::uninitialized(); let mut latency = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_latency(self.as_mut_ptr(), &mut latency); gst_sys::gst_event_parse_latency(self.as_mut_ptr(), latency.as_mut_ptr());
from_glib(latency) from_glib(latency.assume_init())
} }
} }
} }
@ -853,26 +869,29 @@ declare_concrete_event!(Step);
impl<'a> Step<'a> { impl<'a> Step<'a> {
pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) { pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut amount = mem::uninitialized(); let mut amount = mem::MaybeUninit::uninit();
let mut rate = mem::uninitialized(); let mut rate = mem::MaybeUninit::uninit();
let mut flush = mem::uninitialized(); let mut flush = mem::MaybeUninit::uninit();
let mut intermediate = mem::uninitialized(); let mut intermediate = mem::MaybeUninit::uninit();
gst_sys::gst_event_parse_step( gst_sys::gst_event_parse_step(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut amount, amount.as_mut_ptr(),
&mut rate, rate.as_mut_ptr(),
&mut flush, flush.as_mut_ptr(),
&mut intermediate, intermediate.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(fmt), amount as i64), GenericFormattedValue::new(
rate, from_glib(fmt.assume_init()),
from_glib(flush), amount.assume_init() as i64,
from_glib(intermediate), ),
rate.assume_init(),
from_glib(flush.assume_init()),
from_glib(intermediate.assume_init()),
) )
} }
} }

6
gstreamer/src/memory.rs
View file

@ -223,14 +223,14 @@ impl MemoryRef {
pub fn is_span(&self, mem2: &MemoryRef) -> Option<usize> { pub fn is_span(&self, mem2: &MemoryRef) -> Option<usize> {
unsafe { unsafe {
let mut offset = 0; let mut offset = mem::MaybeUninit::uninit();
let res = from_glib(gst_sys::gst_memory_is_span( let res = from_glib(gst_sys::gst_memory_is_span(
self.as_mut_ptr(), self.as_mut_ptr(),
mem2.as_mut_ptr(), mem2.as_mut_ptr(),
&mut offset, offset.as_mut_ptr(),
)); ));
if res { if res {
Some(offset) Some(offset.assume_init())
} else { } else {
None None
} }

290
gstreamer/src/message.rs
View file

@ -562,28 +562,33 @@ declare_concrete_message!(Buffering);
impl<'a> Buffering<'a> { impl<'a> Buffering<'a> {
pub fn get_percent(&self) -> i32 { pub fn get_percent(&self) -> i32 {
unsafe { unsafe {
let mut p = mem::uninitialized(); let mut p = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_buffering(self.as_mut_ptr(), &mut p); gst_sys::gst_message_parse_buffering(self.as_mut_ptr(), p.as_mut_ptr());
p p.assume_init()
} }
} }
pub fn get_buffering_stats(&self) -> (::BufferingMode, i32, i32, i64) { pub fn get_buffering_stats(&self) -> (::BufferingMode, i32, i32, i64) {
unsafe { unsafe {
let mut mode = mem::uninitialized(); let mut mode = mem::MaybeUninit::uninit();
let mut avg_in = mem::uninitialized(); let mut avg_in = mem::MaybeUninit::uninit();
let mut avg_out = mem::uninitialized(); let mut avg_out = mem::MaybeUninit::uninit();
let mut buffering_left = mem::uninitialized(); let mut buffering_left = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_buffering_stats( gst_sys::gst_message_parse_buffering_stats(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut mode, mode.as_mut_ptr(),
&mut avg_in, avg_in.as_mut_ptr(),
&mut avg_out, avg_out.as_mut_ptr(),
&mut buffering_left, buffering_left.as_mut_ptr(),
); );
(from_glib(mode), avg_in, avg_out, buffering_left) (
from_glib(mode.assume_init()),
avg_in.assume_init(),
avg_out.assume_init(),
buffering_left.assume_init(),
)
} }
} }
} }
@ -592,46 +597,46 @@ declare_concrete_message!(StateChanged);
impl<'a> StateChanged<'a> { impl<'a> StateChanged<'a> {
pub fn get_old(&self) -> ::State { pub fn get_old(&self) -> ::State {
unsafe { unsafe {
let mut state = mem::uninitialized(); let mut state = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_state_changed( gst_sys::gst_message_parse_state_changed(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut state, state.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); );
from_glib(state) from_glib(state.assume_init())
} }
} }
pub fn get_current(&self) -> ::State { pub fn get_current(&self) -> ::State {
unsafe { unsafe {
let mut state = mem::uninitialized(); let mut state = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_state_changed( gst_sys::gst_message_parse_state_changed(
self.as_mut_ptr(), self.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
&mut state, state.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
); );
from_glib(state) from_glib(state.assume_init())
} }
} }
pub fn get_pending(&self) -> ::State { pub fn get_pending(&self) -> ::State {
unsafe { unsafe {
let mut state = mem::uninitialized(); let mut state = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_state_changed( gst_sys::gst_message_parse_state_changed(
self.as_mut_ptr(), self.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
&mut state, state.as_mut_ptr(),
); );
from_glib(state) from_glib(state.assume_init())
} }
} }
} }
@ -651,32 +656,38 @@ impl<'a> StepDone<'a> {
bool, bool,
) { ) {
unsafe { unsafe {
let mut format = mem::uninitialized(); let mut format = mem::MaybeUninit::uninit();
let mut amount = mem::uninitialized(); let mut amount = mem::MaybeUninit::uninit();
let mut rate = mem::uninitialized(); let mut rate = mem::MaybeUninit::uninit();
let mut flush = mem::uninitialized(); let mut flush = mem::MaybeUninit::uninit();
let mut intermediate = mem::uninitialized(); let mut intermediate = mem::MaybeUninit::uninit();
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let mut eos = mem::uninitialized(); let mut eos = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_step_done( gst_sys::gst_message_parse_step_done(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut format, format.as_mut_ptr(),
&mut amount, amount.as_mut_ptr(),
&mut rate, rate.as_mut_ptr(),
&mut flush, flush.as_mut_ptr(),
&mut intermediate, intermediate.as_mut_ptr(),
&mut duration, duration.as_mut_ptr(),
&mut eos, eos.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(format), amount as i64), GenericFormattedValue::new(
rate, from_glib(format.assume_init()),
from_glib(flush), amount.assume_init() as i64,
from_glib(intermediate), ),
GenericFormattedValue::new(from_glib(format), duration as i64), rate.assume_init(),
from_glib(eos), from_glib(flush.assume_init()),
from_glib(intermediate.assume_init()),
GenericFormattedValue::new(
from_glib(format.assume_init()),
duration.assume_init() as i64,
),
from_glib(eos.assume_init()),
) )
} }
} }
@ -700,15 +711,15 @@ impl<'a> ClockProvide<'a> {
pub fn get_ready(&self) -> bool { pub fn get_ready(&self) -> bool {
unsafe { unsafe {
let mut ready = mem::uninitialized(); let mut ready = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_clock_provide( gst_sys::gst_message_parse_clock_provide(
self.as_mut_ptr(), self.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
&mut ready, ready.as_mut_ptr(),
); );
from_glib(ready) from_glib(ready.assume_init())
} }
} }
} }
@ -743,18 +754,22 @@ declare_concrete_message!(StructureChange);
impl<'a> StructureChange<'a> { impl<'a> StructureChange<'a> {
pub fn get(&self) -> (::StructureChangeType, ::Element, bool) { pub fn get(&self) -> (::StructureChangeType, ::Element, bool) {
unsafe { unsafe {
let mut type_ = mem::uninitialized(); let mut type_ = mem::MaybeUninit::uninit();
let mut owner = ptr::null_mut(); let mut owner = ptr::null_mut();
let mut busy = mem::uninitialized(); let mut busy = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_structure_change( gst_sys::gst_message_parse_structure_change(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut type_, type_.as_mut_ptr(),
&mut owner, &mut owner,
&mut busy, busy.as_mut_ptr(),
); );
(from_glib(type_), from_glib_none(owner), from_glib(busy)) (
from_glib(type_.assume_init()),
from_glib_none(owner),
from_glib(busy.assume_init()),
)
} }
} }
} }
@ -763,12 +778,16 @@ declare_concrete_message!(StreamStatus);
impl<'a> StreamStatus<'a> { impl<'a> StreamStatus<'a> {
pub fn get(&self) -> (::StreamStatusType, ::Element) { pub fn get(&self) -> (::StreamStatusType, ::Element) {
unsafe { unsafe {
let mut type_ = mem::uninitialized(); let mut type_ = mem::MaybeUninit::uninit();
let mut owner = ptr::null_mut(); let mut owner = ptr::null_mut();
gst_sys::gst_message_parse_stream_status(self.as_mut_ptr(), &mut type_, &mut owner); gst_sys::gst_message_parse_stream_status(
self.as_mut_ptr(),
type_.as_mut_ptr(),
&mut owner,
);
(from_glib(type_), from_glib_none(owner)) (from_glib(type_.assume_init()), from_glib_none(owner))
} }
} }
@ -789,12 +808,16 @@ declare_concrete_message!(SegmentStart);
impl<'a> SegmentStart<'a> { impl<'a> SegmentStart<'a> {
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut format = mem::uninitialized(); let mut format = mem::MaybeUninit::uninit();
let mut position = mem::uninitialized(); let mut position = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_segment_start(self.as_mut_ptr(), &mut format, &mut position); gst_sys::gst_message_parse_segment_start(
self.as_mut_ptr(),
format.as_mut_ptr(),
position.as_mut_ptr(),
);
GenericFormattedValue::new(from_glib(format), position) GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
} }
} }
} }
@ -803,12 +826,16 @@ declare_concrete_message!(SegmentDone);
impl<'a> SegmentDone<'a> { impl<'a> SegmentDone<'a> {
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut format = mem::uninitialized(); let mut format = mem::MaybeUninit::uninit();
let mut position = mem::uninitialized(); let mut position = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_segment_done(self.as_mut_ptr(), &mut format, &mut position); gst_sys::gst_message_parse_segment_done(
self.as_mut_ptr(),
format.as_mut_ptr(),
position.as_mut_ptr(),
);
GenericFormattedValue::new(from_glib(format), position) GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
} }
} }
} }
@ -821,11 +848,11 @@ declare_concrete_message!(AsyncDone);
impl<'a> AsyncDone<'a> { impl<'a> AsyncDone<'a> {
pub fn get_running_time(&self) -> ::ClockTime { pub fn get_running_time(&self) -> ::ClockTime {
unsafe { unsafe {
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_async_done(self.as_mut_ptr(), &mut running_time); gst_sys::gst_message_parse_async_done(self.as_mut_ptr(), running_time.as_mut_ptr());
from_glib(running_time) from_glib(running_time.assume_init())
} }
} }
} }
@ -834,11 +861,11 @@ declare_concrete_message!(RequestState);
impl<'a> RequestState<'a> { impl<'a> RequestState<'a> {
pub fn get_requested_state(&self) -> ::State { pub fn get_requested_state(&self) -> ::State {
unsafe { unsafe {
let mut state = mem::uninitialized(); let mut state = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_request_state(self.as_mut_ptr(), &mut state); gst_sys::gst_message_parse_request_state(self.as_mut_ptr(), state.as_mut_ptr());
from_glib(state) from_glib(state.assume_init())
} }
} }
} }
@ -847,29 +874,32 @@ declare_concrete_message!(StepStart);
impl<'a> StepStart<'a> { impl<'a> StepStart<'a> {
pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) { pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
unsafe { unsafe {
let mut active = mem::uninitialized(); let mut active = mem::MaybeUninit::uninit();
let mut format = mem::uninitialized(); let mut format = mem::MaybeUninit::uninit();
let mut amount = mem::uninitialized(); let mut amount = mem::MaybeUninit::uninit();
let mut rate = mem::uninitialized(); let mut rate = mem::MaybeUninit::uninit();
let mut flush = mem::uninitialized(); let mut flush = mem::MaybeUninit::uninit();
let mut intermediate = mem::uninitialized(); let mut intermediate = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_step_start( gst_sys::gst_message_parse_step_start(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut active, active.as_mut_ptr(),
&mut format, format.as_mut_ptr(),
&mut amount, amount.as_mut_ptr(),
&mut rate, rate.as_mut_ptr(),
&mut flush, flush.as_mut_ptr(),
&mut intermediate, intermediate.as_mut_ptr(),
); );
( (
from_glib(active), from_glib(active.assume_init()),
GenericFormattedValue::new(from_glib(format), amount as i64), GenericFormattedValue::new(
rate, from_glib(format.assume_init()),
from_glib(flush), amount.assume_init() as i64,
from_glib(intermediate), ),
rate.assume_init(),
from_glib(flush.assume_init()),
from_glib(intermediate.assume_init()),
) )
} }
} }
@ -879,64 +909,74 @@ declare_concrete_message!(Qos);
impl<'a> Qos<'a> { impl<'a> Qos<'a> {
pub fn get(&self) -> (bool, ::ClockTime, ::ClockTime, ::ClockTime, ::ClockTime) { pub fn get(&self) -> (bool, ::ClockTime, ::ClockTime, ::ClockTime, ::ClockTime) {
unsafe { unsafe {
let mut live = mem::uninitialized(); let mut live = mem::MaybeUninit::uninit();
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
let mut stream_time = mem::uninitialized(); let mut stream_time = mem::MaybeUninit::uninit();
let mut timestamp = mem::uninitialized(); let mut timestamp = mem::MaybeUninit::uninit();
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_qos( gst_sys::gst_message_parse_qos(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut live, live.as_mut_ptr(),
&mut running_time, running_time.as_mut_ptr(),
&mut stream_time, stream_time.as_mut_ptr(),
&mut timestamp, timestamp.as_mut_ptr(),
&mut duration, duration.as_mut_ptr(),
); );
( (
from_glib(live), from_glib(live.assume_init()),
from_glib(running_time), from_glib(running_time.assume_init()),
from_glib(stream_time), from_glib(stream_time.assume_init()),
from_glib(timestamp), from_glib(timestamp.assume_init()),
from_glib(duration), from_glib(duration.assume_init()),
) )
} }
} }
pub fn get_values(&self) -> (i64, f64, i32) { pub fn get_values(&self) -> (i64, f64, i32) {
unsafe { unsafe {
let mut jitter = mem::uninitialized(); let mut jitter = mem::MaybeUninit::uninit();
let mut proportion = mem::uninitialized(); let mut proportion = mem::MaybeUninit::uninit();
let mut quality = mem::uninitialized(); let mut quality = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_qos_values( gst_sys::gst_message_parse_qos_values(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut jitter, jitter.as_mut_ptr(),
&mut proportion, proportion.as_mut_ptr(),
&mut quality, quality.as_mut_ptr(),
); );
(jitter, proportion, quality) (
jitter.assume_init(),
proportion.assume_init(),
quality.assume_init(),
)
} }
} }
pub fn get_stats(&self) -> (GenericFormattedValue, GenericFormattedValue) { pub fn get_stats(&self) -> (GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut format = mem::uninitialized(); let mut format = mem::MaybeUninit::uninit();
let mut processed = mem::uninitialized(); let mut processed = mem::MaybeUninit::uninit();
let mut dropped = mem::uninitialized(); let mut dropped = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_qos_stats( gst_sys::gst_message_parse_qos_stats(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut format, format.as_mut_ptr(),
&mut processed, processed.as_mut_ptr(),
&mut dropped, dropped.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(format), processed as i64), GenericFormattedValue::new(
GenericFormattedValue::new(from_glib(format), dropped as i64), from_glib(format.assume_init()),
processed.assume_init() as i64,
),
GenericFormattedValue::new(
from_glib(format.assume_init()),
dropped.assume_init() as i64,
),
) )
} }
} }
@ -946,13 +986,13 @@ declare_concrete_message!(Progress);
impl<'a> Progress<'a> { impl<'a> Progress<'a> {
pub fn get(&self) -> (::ProgressType, &'a str, &'a str) { pub fn get(&self) -> (::ProgressType, &'a str, &'a str) {
unsafe { unsafe {
let mut type_ = mem::uninitialized(); let mut type_ = mem::MaybeUninit::uninit();
let mut code = ptr::null_mut(); let mut code = ptr::null_mut();
let mut text = ptr::null_mut(); let mut text = ptr::null_mut();
gst_sys::gst_message_parse_progress( gst_sys::gst_message_parse_progress(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut type_, type_.as_mut_ptr(),
&mut code, &mut code,
&mut text, &mut text,
); );
@ -960,7 +1000,7 @@ impl<'a> Progress<'a> {
let code = CStr::from_ptr(code).to_str().unwrap(); let code = CStr::from_ptr(code).to_str().unwrap();
let text = CStr::from_ptr(text).to_str().unwrap(); let text = CStr::from_ptr(text).to_str().unwrap();
(from_glib(type_), code, text) (from_glib(type_.assume_init()), code, text)
} }
} }
} }
@ -970,9 +1010,9 @@ impl<'a> Toc<'a> {
pub fn get_toc(&self) -> (::Toc, bool) { pub fn get_toc(&self) -> (::Toc, bool) {
unsafe { unsafe {
let mut toc = ptr::null_mut(); let mut toc = ptr::null_mut();
let mut updated = mem::uninitialized(); let mut updated = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_toc(self.as_mut_ptr(), &mut toc, &mut updated); gst_sys::gst_message_parse_toc(self.as_mut_ptr(), &mut toc, updated.as_mut_ptr());
(from_glib_full(toc), from_glib(updated)) (from_glib_full(toc), from_glib(updated.assume_init()))
} }
} }
} }
@ -981,11 +1021,11 @@ declare_concrete_message!(ResetTime);
impl<'a> ResetTime<'a> { impl<'a> ResetTime<'a> {
pub fn get_running_time(&self) -> ::ClockTime { pub fn get_running_time(&self) -> ::ClockTime {
unsafe { unsafe {
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
gst_sys::gst_message_parse_reset_time(self.as_mut_ptr(), &mut running_time); gst_sys::gst_message_parse_reset_time(self.as_mut_ptr(), running_time.as_mut_ptr());
from_glib(running_time) from_glib(running_time.assume_init())
} }
} }
} }
@ -994,13 +1034,13 @@ declare_concrete_message!(StreamStart);
impl<'a> StreamStart<'a> { impl<'a> StreamStart<'a> {
pub fn get_group_id(&self) -> Option<GroupId> { pub fn get_group_id(&self) -> Option<GroupId> {
unsafe { unsafe {
let mut group_id = mem::uninitialized(); let mut group_id = mem::MaybeUninit::uninit();
if from_glib(gst_sys::gst_message_parse_group_id( if from_glib(gst_sys::gst_message_parse_group_id(
self.as_mut_ptr(), self.as_mut_ptr(),
&mut group_id, group_id.as_mut_ptr(),
)) { )) {
Some(from_glib(group_id)) Some(from_glib(group_id.assume_init()))
} else { } else {
None None
} }

78
gstreamer/src/pad.rs
View file

@ -702,16 +702,16 @@ impl<O: IsA<Pad>> PadExtManual for O {
) -> Option<U> { ) -> Option<U> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_convert( let ret = from_glib(gst_sys::gst_pad_peer_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -725,16 +725,19 @@ impl<O: IsA<Pad>> PadExtManual for O {
) -> Option<GenericFormattedValue> { ) -> Option<GenericFormattedValue> {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_convert( let ret = from_glib(gst_sys::gst_pad_peer_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
dest_format.to_glib(), dest_format.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(dest_format, dest_val)) Some(GenericFormattedValue::new(
dest_format,
dest_val.assume_init(),
))
} else { } else {
None None
} }
@ -743,14 +746,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn peer_query_duration<T: SpecificFormattedValue>(&self) -> Option<T> { fn peer_query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_duration( let ret = from_glib(gst_sys::gst_pad_peer_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), duration)) Some(T::from_raw(T::get_default_format(), duration.assume_init()))
} else { } else {
None None
} }
@ -759,14 +762,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn peer_query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn peer_query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_duration( let ret = from_glib(gst_sys::gst_pad_peer_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, duration)) Some(GenericFormattedValue::new(format, duration.assume_init()))
} else { } else {
None None
} }
@ -775,14 +778,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn peer_query_position<T: SpecificFormattedValue>(&self) -> Option<T> { fn peer_query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_position( let ret = from_glib(gst_sys::gst_pad_peer_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), cur)) Some(T::from_raw(T::get_default_format(), cur.assume_init()))
} else { } else {
None None
} }
@ -791,14 +794,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn peer_query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn peer_query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_peer_query_position( let ret = from_glib(gst_sys::gst_pad_peer_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, cur)) Some(GenericFormattedValue::new(format, cur.assume_init()))
} else { } else {
None None
} }
@ -812,16 +815,16 @@ impl<O: IsA<Pad>> PadExtManual for O {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_convert( let ret = from_glib(gst_sys::gst_pad_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
U::get_default_format().to_glib(), U::get_default_format().to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(U::from_raw(U::get_default_format(), dest_val)) Some(U::from_raw(U::get_default_format(), dest_val.assume_init()))
} else { } else {
None None
} }
@ -836,16 +839,19 @@ impl<O: IsA<Pad>> PadExtManual for O {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::uninitialized(); let mut dest_val = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_convert( let ret = from_glib(gst_sys::gst_pad_query_convert(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.get_value(), src_val.get_value(),
dest_format.to_glib(), dest_format.to_glib(),
&mut dest_val, dest_val.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(dest_format, dest_val)) Some(GenericFormattedValue::new(
dest_format,
dest_val.assume_init(),
))
} else { } else {
None None
} }
@ -854,14 +860,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> { fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_duration( let ret = from_glib(gst_sys::gst_pad_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), duration)) Some(T::from_raw(T::get_default_format(), duration.assume_init()))
} else { } else {
None None
} }
@ -870,14 +876,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut duration = mem::uninitialized(); let mut duration = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_duration( let ret = from_glib(gst_sys::gst_pad_query_duration(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut duration, duration.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, duration)) Some(GenericFormattedValue::new(format, duration.assume_init()))
} else { } else {
None None
} }
@ -886,14 +892,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> { fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_position( let ret = from_glib(gst_sys::gst_pad_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
T::get_default_format().to_glib(), T::get_default_format().to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(T::from_raw(T::get_default_format(), cur)) Some(T::from_raw(T::get_default_format(), cur.assume_init()))
} else { } else {
None None
} }
@ -902,14 +908,14 @@ impl<O: IsA<Pad>> PadExtManual for O {
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> { fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe { unsafe {
let mut cur = mem::uninitialized(); let mut cur = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_pad_query_position( let ret = from_glib(gst_sys::gst_pad_query_position(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
format.to_glib(), format.to_glib(),
&mut cur, cur.as_mut_ptr(),
)); ));
if ret { if ret {
Some(GenericFormattedValue::new(format, cur)) Some(GenericFormattedValue::new(format, cur.assume_init()))
} else { } else {
None None
} }

309
gstreamer/src/query.rs
View file

@ -365,22 +365,22 @@ declare_concrete_query!(Position, T);
impl<T: AsPtr> Position<T> { impl<T: AsPtr> Position<T> {
pub fn get_result(&self) -> GenericFormattedValue { pub fn get_result(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut pos = mem::uninitialized(); let mut pos = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_position(self.0.as_ptr(), &mut fmt, &mut pos); gst_sys::gst_query_parse_position(self.0.as_ptr(), fmt.as_mut_ptr(), pos.as_mut_ptr());
GenericFormattedValue::new(from_glib(fmt), pos) GenericFormattedValue::new(from_glib(fmt.assume_init()), pos.assume_init())
} }
} }
pub fn get_format(&self) -> ::Format { pub fn get_format(&self) -> ::Format {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_position(self.0.as_ptr(), &mut fmt, ptr::null_mut()); gst_sys::gst_query_parse_position(self.0.as_ptr(), fmt.as_mut_ptr(), ptr::null_mut());
from_glib(fmt) from_glib(fmt.assume_init())
} }
} }
} }
@ -403,22 +403,22 @@ declare_concrete_query!(Duration, T);
impl<T: AsPtr> Duration<T> { impl<T: AsPtr> Duration<T> {
pub fn get_result(&self) -> GenericFormattedValue { pub fn get_result(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut pos = mem::uninitialized(); let mut pos = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_duration(self.0.as_ptr(), &mut fmt, &mut pos); gst_sys::gst_query_parse_duration(self.0.as_ptr(), fmt.as_mut_ptr(), pos.as_mut_ptr());
GenericFormattedValue::new(from_glib(fmt), pos) GenericFormattedValue::new(from_glib(fmt.assume_init()), pos.assume_init())
} }
} }
pub fn get_format(&self) -> ::Format { pub fn get_format(&self) -> ::Format {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_duration(self.0.as_ptr(), &mut fmt, ptr::null_mut()); gst_sys::gst_query_parse_duration(self.0.as_ptr(), fmt.as_mut_ptr(), ptr::null_mut());
from_glib(fmt) from_glib(fmt.assume_init())
} }
} }
} }
@ -441,13 +441,22 @@ declare_concrete_query!(Latency, T);
impl<T: AsPtr> Latency<T> { impl<T: AsPtr> Latency<T> {
pub fn get_result(&self) -> (bool, ::ClockTime, ::ClockTime) { pub fn get_result(&self) -> (bool, ::ClockTime, ::ClockTime) {
unsafe { unsafe {
let mut live = mem::uninitialized(); let mut live = mem::MaybeUninit::uninit();
let mut min = mem::uninitialized(); let mut min = mem::MaybeUninit::uninit();
let mut max = mem::uninitialized(); let mut max = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_latency(self.0.as_ptr(), &mut live, &mut min, &mut max); gst_sys::gst_query_parse_latency(
self.0.as_ptr(),
live.as_mut_ptr(),
min.as_mut_ptr(),
max.as_mut_ptr(),
);
(from_glib(live), from_glib(min), from_glib(max)) (
from_glib(live.assume_init()),
from_glib(min.assume_init()),
from_glib(max.assume_init()),
)
} }
} }
} }
@ -472,38 +481,38 @@ declare_concrete_query!(Seeking, T);
impl<T: AsPtr> Seeking<T> { impl<T: AsPtr> Seeking<T> {
pub fn get_result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) { pub fn get_result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut seekable = mem::uninitialized(); let mut seekable = mem::MaybeUninit::uninit();
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut end = mem::uninitialized(); let mut end = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_seeking( gst_sys::gst_query_parse_seeking(
self.0.as_ptr(), self.0.as_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut seekable, seekable.as_mut_ptr(),
&mut start, start.as_mut_ptr(),
&mut end, end.as_mut_ptr(),
); );
( (
from_glib(seekable), from_glib(seekable.assume_init()),
GenericFormattedValue::new(from_glib(fmt), start), GenericFormattedValue::new(from_glib(fmt.assume_init()), start.assume_init()),
GenericFormattedValue::new(from_glib(fmt), end), GenericFormattedValue::new(from_glib(fmt.assume_init()), end.assume_init()),
) )
} }
} }
pub fn get_format(&self) -> ::Format { pub fn get_format(&self) -> ::Format {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_seeking( gst_sys::gst_query_parse_seeking(
self.0.as_ptr(), self.0.as_ptr(),
&mut fmt, fmt.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); );
from_glib(fmt) from_glib(fmt.assume_init())
} }
} }
} }
@ -532,38 +541,38 @@ declare_concrete_query!(Segment, T);
impl<T: AsPtr> Segment<T> { impl<T: AsPtr> Segment<T> {
pub fn get_result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) { pub fn get_result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut rate = mem::uninitialized(); let mut rate = mem::MaybeUninit::uninit();
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut stop = mem::uninitialized(); let mut stop = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_segment( gst_sys::gst_query_parse_segment(
self.0.as_ptr(), self.0.as_ptr(),
&mut rate, rate.as_mut_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut start, start.as_mut_ptr(),
&mut stop, stop.as_mut_ptr(),
); );
( (
rate, rate.assume_init(),
GenericFormattedValue::new(from_glib(fmt), start), GenericFormattedValue::new(from_glib(fmt.assume_init()), start.assume_init()),
GenericFormattedValue::new(from_glib(fmt), stop), GenericFormattedValue::new(from_glib(fmt.assume_init()), stop.assume_init()),
) )
} }
} }
pub fn get_format(&self) -> ::Format { pub fn get_format(&self) -> ::Format {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_segment( gst_sys::gst_query_parse_segment(
self.0.as_ptr(), self.0.as_ptr(),
ptr::null_mut(), ptr::null_mut(),
&mut fmt, fmt.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); );
from_glib(fmt) from_glib(fmt.assume_init())
} }
} }
} }
@ -591,41 +600,41 @@ declare_concrete_query!(Convert, T);
impl<T: AsPtr> Convert<T> { impl<T: AsPtr> Convert<T> {
pub fn get_result(&self) -> (GenericFormattedValue, GenericFormattedValue) { pub fn get_result(&self) -> (GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut src_fmt = mem::uninitialized(); let mut src_fmt = mem::MaybeUninit::uninit();
let mut src = mem::uninitialized(); let mut src = mem::MaybeUninit::uninit();
let mut dest_fmt = mem::uninitialized(); let mut dest_fmt = mem::MaybeUninit::uninit();
let mut dest = mem::uninitialized(); let mut dest = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_convert( gst_sys::gst_query_parse_convert(
self.0.as_ptr(), self.0.as_ptr(),
&mut src_fmt, src_fmt.as_mut_ptr(),
&mut src, src.as_mut_ptr(),
&mut dest_fmt, dest_fmt.as_mut_ptr(),
&mut dest, dest.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(src_fmt), src), GenericFormattedValue::new(from_glib(src_fmt.assume_init()), src.assume_init()),
GenericFormattedValue::new(from_glib(dest_fmt), dest), GenericFormattedValue::new(from_glib(dest_fmt.assume_init()), dest.assume_init()),
) )
} }
} }
pub fn get(&self) -> (GenericFormattedValue, ::Format) { pub fn get(&self) -> (GenericFormattedValue, ::Format) {
unsafe { unsafe {
let mut src_fmt = mem::uninitialized(); let mut src_fmt = mem::MaybeUninit::uninit();
let mut src = mem::uninitialized(); let mut src = mem::MaybeUninit::uninit();
let mut dest_fmt = mem::uninitialized(); let mut dest_fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_convert( gst_sys::gst_query_parse_convert(
self.0.as_ptr(), self.0.as_ptr(),
&mut src_fmt, src_fmt.as_mut_ptr(),
&mut src, src.as_mut_ptr(),
&mut dest_fmt, dest_fmt.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
); );
( (
GenericFormattedValue::new(from_glib(src_fmt), src), GenericFormattedValue::new(from_glib(src_fmt.assume_init()), src.assume_init()),
from_glib(dest_fmt), from_glib(dest_fmt.assume_init()),
) )
} }
} }
@ -652,14 +661,15 @@ declare_concrete_query!(Formats, T);
impl<T: AsPtr> Formats<T> { impl<T: AsPtr> Formats<T> {
pub fn get_result(&self) -> Vec<::Format> { pub fn get_result(&self) -> Vec<::Format> {
unsafe { unsafe {
let mut n = mem::uninitialized(); let mut n = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_n_formats(self.0.as_ptr(), &mut n); gst_sys::gst_query_parse_n_formats(self.0.as_ptr(), n.as_mut_ptr());
let n = n.assume_init();
let mut res = Vec::with_capacity(n as usize); let mut res = Vec::with_capacity(n as usize);
for i in 0..n { for i in 0..n {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_nth_format(self.0.as_ptr(), i, &mut fmt); gst_sys::gst_query_parse_nth_format(self.0.as_ptr(), i, fmt.as_mut_ptr());
res.push(from_glib(fmt)); res.push(from_glib(fmt.assume_init()));
} }
res res
@ -684,99 +694,108 @@ declare_concrete_query!(Buffering, T);
impl<T: AsPtr> Buffering<T> { impl<T: AsPtr> Buffering<T> {
pub fn get_format(&self) -> ::Format { pub fn get_format(&self) -> ::Format {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_buffering_range( gst_sys::gst_query_parse_buffering_range(
self.0.as_ptr(), self.0.as_ptr(),
&mut fmt, fmt.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); );
from_glib(fmt) from_glib(fmt.assume_init())
} }
} }
pub fn get_percent(&self) -> (bool, i32) { pub fn get_percent(&self) -> (bool, i32) {
unsafe { unsafe {
let mut busy = mem::uninitialized(); let mut busy = mem::MaybeUninit::uninit();
let mut percent = mem::uninitialized(); let mut percent = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_buffering_percent(self.0.as_ptr(), &mut busy, &mut percent); gst_sys::gst_query_parse_buffering_percent(
self.0.as_ptr(),
busy.as_mut_ptr(),
percent.as_mut_ptr(),
);
(from_glib(busy), percent) (from_glib(busy.assume_init()), percent.assume_init())
} }
} }
pub fn get_range(&self) -> (GenericFormattedValue, GenericFormattedValue, i64) { pub fn get_range(&self) -> (GenericFormattedValue, GenericFormattedValue, i64) {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut stop = mem::uninitialized(); let mut stop = mem::MaybeUninit::uninit();
let mut estimated_total = mem::uninitialized(); let mut estimated_total = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_buffering_range( gst_sys::gst_query_parse_buffering_range(
self.0.as_ptr(), self.0.as_ptr(),
&mut fmt, fmt.as_mut_ptr(),
&mut start, start.as_mut_ptr(),
&mut stop, stop.as_mut_ptr(),
&mut estimated_total, estimated_total.as_mut_ptr(),
); );
( (
GenericFormattedValue::new(from_glib(fmt), start), GenericFormattedValue::new(from_glib(fmt.assume_init()), start.assume_init()),
GenericFormattedValue::new(from_glib(fmt), stop), GenericFormattedValue::new(from_glib(fmt.assume_init()), stop.assume_init()),
estimated_total, estimated_total.assume_init(),
) )
} }
} }
pub fn get_stats(&self) -> (::BufferingMode, i32, i32, i64) { pub fn get_stats(&self) -> (::BufferingMode, i32, i32, i64) {
unsafe { unsafe {
let mut mode = mem::uninitialized(); let mut mode = mem::MaybeUninit::uninit();
let mut avg_in = mem::uninitialized(); let mut avg_in = mem::MaybeUninit::uninit();
let mut avg_out = mem::uninitialized(); let mut avg_out = mem::MaybeUninit::uninit();
let mut buffering_left = mem::uninitialized(); let mut buffering_left = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_buffering_stats( gst_sys::gst_query_parse_buffering_stats(
self.0.as_ptr(), self.0.as_ptr(),
&mut mode, mode.as_mut_ptr(),
&mut avg_in, avg_in.as_mut_ptr(),
&mut avg_out, avg_out.as_mut_ptr(),
&mut buffering_left, buffering_left.as_mut_ptr(),
); );
(from_glib(mode), avg_in, avg_out, buffering_left) (
from_glib(mode.assume_init()),
avg_in.assume_init(),
avg_out.assume_init(),
buffering_left.assume_init(),
)
} }
} }
pub fn get_ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> { pub fn get_ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> {
unsafe { unsafe {
let mut fmt = mem::uninitialized(); let mut fmt = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_buffering_range( gst_sys::gst_query_parse_buffering_range(
self.0.as_ptr(), self.0.as_ptr(),
&mut fmt, fmt.as_mut_ptr(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); );
let fmt = from_glib(fmt); let fmt = from_glib(fmt.assume_init());
let n = gst_sys::gst_query_get_n_buffering_ranges(self.0.as_ptr()); let n = gst_sys::gst_query_get_n_buffering_ranges(self.0.as_ptr());
let mut res = Vec::with_capacity(n as usize); let mut res = Vec::with_capacity(n as usize);
for i in 0..n { for i in 0..n {
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut stop = mem::uninitialized(); let mut stop = mem::MaybeUninit::uninit();
let s: bool = from_glib(gst_sys::gst_query_parse_nth_buffering_range( let s: bool = from_glib(gst_sys::gst_query_parse_nth_buffering_range(
self.0.as_ptr(), self.0.as_ptr(),
i, i,
&mut start, start.as_mut_ptr(),
&mut stop, stop.as_mut_ptr(),
)); ));
if s { if s {
res.push(( res.push((
GenericFormattedValue::new(fmt, start), GenericFormattedValue::new(fmt, start.assume_init()),
GenericFormattedValue::new(fmt, stop), GenericFormattedValue::new(fmt, stop.assume_init()),
)); ));
} }
} }
@ -873,10 +892,13 @@ impl<T: AsPtr> Uri<T> {
unsafe { unsafe {
let mut uri = ptr::null_mut(); let mut uri = ptr::null_mut();
gst_sys::gst_query_parse_uri_redirection(self.0.as_ptr(), &mut uri); gst_sys::gst_query_parse_uri_redirection(self.0.as_ptr(), &mut uri);
let mut permanent = mem::uninitialized(); let mut permanent = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_uri_redirection_permanent(self.0.as_ptr(), &mut permanent); gst_sys::gst_query_parse_uri_redirection_permanent(
self.0.as_ptr(),
permanent.as_mut_ptr(),
);
(from_glib_full(uri), from_glib(permanent)) (from_glib_full(uri), from_glib(permanent.assume_init()))
} }
} }
} }
@ -906,10 +928,13 @@ impl<T: AsPtr> Allocation<T> {
pub fn get(&self) -> (&::CapsRef, bool) { pub fn get(&self) -> (&::CapsRef, bool) {
unsafe { unsafe {
let mut caps = ptr::null_mut(); let mut caps = ptr::null_mut();
let mut need_pool = 0; let mut need_pool = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_allocation(self.0.as_ptr(), &mut caps, &mut need_pool); gst_sys::gst_query_parse_allocation(self.0.as_ptr(), &mut caps, need_pool.as_mut_ptr());
(::CapsRef::from_ptr(caps), from_glib(need_pool)) (
::CapsRef::from_ptr(caps),
from_glib(need_pool.assume_init()),
)
} }
} }
@ -926,19 +951,24 @@ impl<T: AsPtr> Allocation<T> {
let mut pools = Vec::with_capacity(n as usize); let mut pools = Vec::with_capacity(n as usize);
for i in 0..n { for i in 0..n {
let mut pool = ptr::null_mut(); let mut pool = ptr::null_mut();
let mut size = 0; let mut size = mem::MaybeUninit::uninit();
let mut min_buffers = 0; let mut min_buffers = mem::MaybeUninit::uninit();
let mut max_buffers = 0; let mut max_buffers = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_nth_allocation_pool( gst_sys::gst_query_parse_nth_allocation_pool(
self.0.as_ptr(), self.0.as_ptr(),
i, i,
&mut pool, &mut pool,
&mut size, size.as_mut_ptr(),
&mut min_buffers, min_buffers.as_mut_ptr(),
&mut max_buffers, max_buffers.as_mut_ptr(),
); );
pools.push((from_glib_full(pool), size, min_buffers, max_buffers)); pools.push((
from_glib_full(pool),
size.assume_init(),
min_buffers.assume_init(),
max_buffers.assume_init(),
));
} }
pools pools
@ -973,14 +1003,14 @@ impl<T: AsPtr> Allocation<T> {
pub fn find_allocation_meta<U: ::MetaAPI>(&self) -> Option<u32> { pub fn find_allocation_meta<U: ::MetaAPI>(&self) -> Option<u32> {
unsafe { unsafe {
let mut idx = 0; let mut idx = mem::MaybeUninit::uninit();
if gst_sys::gst_query_find_allocation_meta( if gst_sys::gst_query_find_allocation_meta(
self.0.as_ptr(), self.0.as_ptr(),
U::get_meta_api().to_glib(), U::get_meta_api().to_glib(),
&mut idx, idx.as_mut_ptr(),
) != glib_sys::GFALSE ) != glib_sys::GFALSE
{ {
Some(idx) Some(idx.assume_init())
} else { } else {
None None
} }
@ -1097,20 +1127,25 @@ impl<T: AsPtr> Scheduling<T> {
pub fn get_result(&self) -> (::SchedulingFlags, i32, i32, i32) { pub fn get_result(&self) -> (::SchedulingFlags, i32, i32, i32) {
unsafe { unsafe {
let mut flags = mem::uninitialized(); let mut flags = mem::MaybeUninit::uninit();
let mut minsize = mem::uninitialized(); let mut minsize = mem::MaybeUninit::uninit();
let mut maxsize = mem::uninitialized(); let mut maxsize = mem::MaybeUninit::uninit();
let mut align = mem::uninitialized(); let mut align = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_scheduling( gst_sys::gst_query_parse_scheduling(
self.0.as_ptr(), self.0.as_ptr(),
&mut flags, flags.as_mut_ptr(),
&mut minsize, minsize.as_mut_ptr(),
&mut maxsize, maxsize.as_mut_ptr(),
&mut align, align.as_mut_ptr(),
); );
(from_glib(flags), minsize, maxsize, align) (
from_glib(flags.assume_init()),
minsize.assume_init(),
maxsize.assume_init(),
align.assume_init(),
)
} }
} }
} }
@ -1153,9 +1188,9 @@ impl<T: AsPtr> AcceptCaps<T> {
pub fn get_result(&self) -> bool { pub fn get_result(&self) -> bool {
unsafe { unsafe {
let mut accepted = mem::uninitialized(); let mut accepted = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_accept_caps_result(self.0.as_ptr(), &mut accepted); gst_sys::gst_query_parse_accept_caps_result(self.0.as_ptr(), accepted.as_mut_ptr());
from_glib(accepted) from_glib(accepted.assume_init())
} }
} }
} }
@ -1256,9 +1291,9 @@ impl<T: AsPtr> Bitrate<T> {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn get_bitrate(&self) -> u32 { pub fn get_bitrate(&self) -> u32 {
unsafe { unsafe {
let mut bitrate = 0; let mut bitrate = mem::MaybeUninit::uninit();
gst_sys::gst_query_parse_bitrate(self.0.as_ptr(), &mut bitrate); gst_sys::gst_query_parse_bitrate(self.0.as_ptr(), bitrate.as_mut_ptr());
bitrate bitrate.assume_init()
} }
} }
} }

54
gstreamer/src/segment.rs
View file

@ -110,20 +110,20 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut clip_start = mem::uninitialized(); let mut clip_start = mem::MaybeUninit::uninit();
let mut clip_stop = mem::uninitialized(); let mut clip_stop = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_segment_clip( let ret = from_glib(gst_sys::gst_segment_clip(
&self.0, &self.0,
start.get_format().to_glib(), start.get_format().to_glib(),
start.to_raw_value() as u64, start.to_raw_value() as u64,
stop.to_raw_value() as u64, stop.to_raw_value() as u64,
&mut clip_start, clip_start.as_mut_ptr(),
&mut clip_stop, clip_stop.as_mut_ptr(),
)); ));
if ret { if ret {
Some(( Some((
T::from_raw(self.get_format(), clip_start as i64), T::from_raw(self.get_format(), clip_start.assume_init() as i64),
T::from_raw(self.get_format(), clip_stop as i64), T::from_raw(self.get_format(), clip_stop.assume_init() as i64),
)) ))
} else { } else {
None None
@ -151,7 +151,7 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut update = mem::uninitialized(); let mut update = mem::MaybeUninit::uninit();
let ret = from_glib(gst_sys::gst_segment_do_seek( let ret = from_glib(gst_sys::gst_segment_do_seek(
&mut self.0, &mut self.0,
rate, rate,
@ -161,10 +161,10 @@ impl<T: FormattedValue> FormattedSegment<T> {
start.to_raw_value() as u64, start.to_raw_value() as u64,
stop_type.to_glib(), stop_type.to_glib(),
stop.to_raw_value() as u64, stop.to_raw_value() as u64,
&mut update, update.as_mut_ptr(),
)); ));
if ret { if ret {
Some(from_glib(update)) Some(from_glib(update.assume_init()))
} else { } else {
None None
} }
@ -211,14 +211,17 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut position = mem::uninitialized(); let mut position = mem::MaybeUninit::uninit();
let ret = gst_sys::gst_segment_position_from_running_time_full( let ret = gst_sys::gst_segment_position_from_running_time_full(
&self.0, &self.0,
self.get_format().to_glib(), self.get_format().to_glib(),
running_time.to_raw_value() as u64, running_time.to_raw_value() as u64,
&mut position, position.as_mut_ptr(),
); );
(ret, T::from_raw(self.get_format(), position as i64)) (
ret,
T::from_raw(self.get_format(), position.assume_init() as i64),
)
} }
} }
@ -249,14 +252,17 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut position = mem::uninitialized(); let mut position = mem::MaybeUninit::uninit();
let ret = gst_sys::gst_segment_position_from_stream_time_full( let ret = gst_sys::gst_segment_position_from_stream_time_full(
&self.0, &self.0,
self.get_format().to_glib(), self.get_format().to_glib(),
stream_time.to_raw_value() as u64, stream_time.to_raw_value() as u64,
&mut position, position.as_mut_ptr(),
); );
(ret, T::from_raw(self.get_format(), position as i64)) (
ret,
T::from_raw(self.get_format(), position.assume_init() as i64),
)
} }
} }
@ -306,14 +312,17 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut running_time = mem::uninitialized(); let mut running_time = mem::MaybeUninit::uninit();
let ret = gst_sys::gst_segment_to_running_time_full( let ret = gst_sys::gst_segment_to_running_time_full(
&self.0, &self.0,
self.get_format().to_glib(), self.get_format().to_glib(),
position.to_raw_value() as u64, position.to_raw_value() as u64,
&mut running_time, running_time.as_mut_ptr(),
); );
(ret, T::from_raw(self.get_format(), running_time as i64)) (
ret,
T::from_raw(self.get_format(), running_time.assume_init() as i64),
)
} }
} }
@ -344,14 +353,17 @@ impl<T: FormattedValue> FormattedSegment<T> {
} }
unsafe { unsafe {
let mut stream_time = mem::uninitialized(); let mut stream_time = mem::MaybeUninit::uninit();
let ret = gst_sys::gst_segment_to_stream_time_full( let ret = gst_sys::gst_segment_to_stream_time_full(
&self.0, &self.0,
self.get_format().to_glib(), self.get_format().to_glib(),
position.to_raw_value() as u64, position.to_raw_value() as u64,
&mut stream_time, stream_time.as_mut_ptr(),
); );
(ret, T::from_raw(self.get_format(), stream_time as i64)) (
ret,
T::from_raw(self.get_format(), stream_time.assume_init() as i64),
)
} }
} }

23
gstreamer/src/toc.rs
View file

@ -145,15 +145,15 @@ impl TocEntryRef {
pub fn get_start_stop_times(&self) -> Option<(i64, i64)> { pub fn get_start_stop_times(&self) -> Option<(i64, i64)> {
unsafe { unsafe {
let mut start = mem::uninitialized(); let mut start = mem::MaybeUninit::uninit();
let mut stop = mem::uninitialized(); let mut stop = mem::MaybeUninit::uninit();
if from_glib(gst_sys::gst_toc_entry_get_start_stop_times( if from_glib(gst_sys::gst_toc_entry_get_start_stop_times(
self.as_ptr(), self.as_ptr(),
&mut start, start.as_mut_ptr(),
&mut stop, stop.as_mut_ptr(),
)) { )) {
Some((start, stop)) Some((start.assume_init(), stop.assume_init()))
} else { } else {
None None
} }
@ -196,14 +196,17 @@ impl TocEntryRef {
pub fn get_loop(&self) -> Option<(TocLoopType, i32)> { pub fn get_loop(&self) -> Option<(TocLoopType, i32)> {
unsafe { unsafe {
let mut loop_type = mem::uninitialized(); let mut loop_type = mem::MaybeUninit::uninit();
let mut repeat_count = mem::uninitialized(); let mut repeat_count = mem::MaybeUninit::uninit();
if from_glib(gst_sys::gst_toc_entry_get_loop( if from_glib(gst_sys::gst_toc_entry_get_loop(
self.as_ptr(), self.as_ptr(),
&mut loop_type, loop_type.as_mut_ptr(),
&mut repeat_count, repeat_count.as_mut_ptr(),
)) { )) {
Some((from_glib(loop_type), repeat_count)) Some((
from_glib(loop_type.assume_init()),
repeat_count.assume_init(),
))
} else { } else {
None None
} }