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

Change some assertions to debug assertions

Browse source 
These assertions can only trigger because of bugs in the bindings
implementation or in the C code and not because of bugs in calling code,
so using debug assertions is perfectly fine for them and reduces the
number of assertions inlined everywhere in release builds.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1188>
This commit is contained in:
Sebastian Dröge 2022-12-25 12:47:02 +02:00
parent f235dc987d
commit 37bfb78fdc
77 changed files with 229 additions and 257 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
gstreamer-allocators/src/dma_buf_allocator.rs
View file

@ -37,7 +37,7 @@ impl fmt::Debug for DmaBufMemoryRef {
impl DmaBufMemoryRef {
#[doc(alias = "gst_dmabuf_memory_get_fd")]
pub fn fd(&self) -> RawFd {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { ffi::gst_dmabuf_memory_get_fd(self.as_mut_ptr()) }
}
}
@ -49,7 +49,7 @@ impl DmaBufAllocator {
fd: A,
size: usize,
) -> Result<gst::Memory, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
Option::<_>::from_glib_full(ffi::gst_dmabuf_allocator_alloc(
self.unsafe_cast_ref::<gst::Allocator>().to_glib_none().0,
fd.into_raw_fd(),
@ -67,7 +67,7 @@ impl DmaBufAllocator {
size: usize,
flags: FdMemoryFlags,
) -> Result<gst::Memory, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
Option::<_>::from_glib_full(ffi::gst_dmabuf_allocator_alloc_with_flags(
self.unsafe_cast_ref::<gst::Allocator>().to_glib_none().0,
fd,

4
gstreamer-allocators/src/fd_allocator.rs
View file

@ -39,7 +39,7 @@ impl fmt::Debug for FdMemoryRef {
impl FdMemoryRef {
#[doc(alias = "gst_fd_memory_get_fd")]
pub fn fd(&self) -> RawFd {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { ffi::gst_fd_memory_get_fd(self.as_mut_ptr()) }
}
}
@ -52,7 +52,7 @@ impl FdAllocator {
size: usize,
flags: FdMemoryFlags,
) -> Result<gst::Memory, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
Option::<_>::from_glib_full(ffi::gst_fd_allocator_alloc(
self.unsafe_cast_ref::<gst::Allocator>().to_glib_none().0,
fd,

2
gstreamer-allocators/src/phys_memory.rs
View file

@ -37,7 +37,7 @@ impl fmt::Debug for PhysMemoryRef {
impl PhysMemoryRef {
#[doc(alias = "gst_phys_memory_get_phys_addr")]
pub fn phys_addr(&self) -> libc::uintptr_t {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { ffi::gst_phys_memory_get_phys_addr(self.as_mut_ptr()) }
}
}

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

@ -397,7 +397,7 @@ impl<T> AudioBufferRef<T> {
impl<'a> AudioBufferRef<&'a gst::BufferRef> {
#[inline]
pub unsafe fn from_glib_borrow(audio_buffer: *const ffi::GstAudioBuffer) -> Borrowed<Self> {
assert!(!audio_buffer.is_null());
debug_assert!(!audio_buffer.is_null());
let info = crate::AudioInfo::from_glib_none(
&(*audio_buffer).info as *const _ as *mut ffi::GstAudioInfo,
@ -455,7 +455,7 @@ impl<'a> AudioBufferRef<&'a gst::BufferRef> {
impl<'a> AudioBufferRef<&'a mut gst::BufferRef> {
#[inline]
pub unsafe fn from_glib_borrow_mut(audio_buffer: *mut ffi::GstAudioBuffer) -> Borrowed<Self> {
assert!(!audio_buffer.is_null());
debug_assert!(!audio_buffer.is_null());
let info = crate::AudioInfo::from_glib_none(
&(*audio_buffer).info as *const _ as *mut ffi::GstAudioInfo,

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

@ -164,7 +164,7 @@ pub fn buffer_reorder_channels(
from: &[AudioChannelPosition],
to: &[AudioChannelPosition],
) -> Result<(), glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
if from.len() != to.len() || from.len() > 64 {
return Err(glib::bool_error!("Invalid number of channels"));

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

@ -18,7 +18,7 @@ impl FromGlib<i32> for AudioEndianness {
#[allow(unused_unsafe)]
#[inline]
unsafe fn from_glib(value: i32) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
match value {
1234 => Self::LittleEndian,
@ -52,7 +52,7 @@ impl AudioFormatInfo {
unsafe {
let info = ffi::gst_audio_format_get_info(format.into_glib());
assert!(!info.is_null());
debug_assert!(!info.is_null());
Self(&*info)
}

2
gstreamer-audio/src/functions.rs
View file

@ -48,7 +48,7 @@ pub fn audio_make_raw_caps(
formats: &[crate::AudioFormat],
layout: crate::AudioLayout,
) -> crate::AudioCapsBuilder<gst::caps::NoFeature> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let formats = formats.iter().copied().map(|f| match f {
crate::AudioFormat::Encoded => panic!("Invalid encoded format"),

11
gstreamer-base/src/base_parse_frame.rs
View file

@ -80,7 +80,7 @@ impl<'a> BaseParseFrame<'a> {
#[inline]
pub(crate) unsafe fn new(frame: *mut ffi::GstBaseParseFrame, _parse: &'a BaseParse) -> Self {
skip_assert_initialized!();
assert!(!frame.is_null());
debug_assert!(!frame.is_null());
Self(ptr::NonNull::new_unchecked(frame), PhantomData)
}
@ -146,19 +146,14 @@ impl<'a> BaseParseFrame<'a> {
pub fn set_output_buffer(&mut self, output_buffer: gst::Buffer) {
unsafe {
assert!(output_buffer.is_writable());
let prev = (*self.to_glib_none().0).out_buffer;
if !prev.is_null() {
gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject);
}
let ptr = output_buffer.into_glib_ptr();
let writable: bool = from_glib(gst::ffi::gst_mini_object_is_writable(
ptr as *const gst::ffi::GstMiniObject,
));
assert!(writable);
(*self.to_glib_none().0).out_buffer = ptr;
(*self.to_glib_none().0).out_buffer = output_buffer.into_glib_ptr();
}
}

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

@ -61,7 +61,7 @@ pub fn type_find_helper_for_buffer<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::BufferRef,
) -> Result<(gst::Caps, gst::TypeFindProbability), glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = ffi::gst_type_find_helper_for_buffer(
@ -85,7 +85,7 @@ pub fn type_find_helper_for_buffer_with_extension<P: IsA<gst::Object>>(
buf: &gst::BufferRef,
extension: Option<&str>,
) -> Result<(gst::Caps, gst::TypeFindProbability), glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = ffi::gst_type_find_helper_for_buffer_with_extension(
@ -110,7 +110,7 @@ pub fn type_find_helper_for_buffer_with_caps(
buf: &gst::BufferRef,
caps: &gst::CapsRef,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut prob = mem::MaybeUninit::uninit();
let ret = from_glib_full(ffi::gst_type_find_helper_for_buffer_with_caps(
@ -131,7 +131,7 @@ pub fn type_find_helper_for_data_with_caps(
data: &[u8],
caps: &gst::CapsRef,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!();
skip_assert_initialized!();
let size = data.len() as _;
unsafe {
let mut prob = mem::MaybeUninit::uninit();
@ -153,7 +153,7 @@ pub fn type_find_list_factories_for_caps(
obj: Option<&impl IsA<gst::Object>>,
caps: &gst::CapsRef,
) -> glib::List<gst::TypeFindFactory> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
glib::collections::List::from_glib_full(ffi::gst_type_find_list_factories_for_caps(
obj.map(|p| p.as_ref()).to_glib_none().0,

4
gstreamer-check/src/harness.rs
View file

@ -595,7 +595,7 @@ impl Harness {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstHarness) -> Harness {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Harness(ptr::NonNull::new_unchecked(ptr))
}
@ -646,7 +646,7 @@ impl Harness {
element_sinkpad_name: Option<&str>,
element_srcpad_name: Option<&str>,
) -> Harness {
assert_initialized_main_thread!();
skip_assert_initialized!();
let element_sinkpad_name = element_sinkpad_name.to_glib_none();
let element_srcpad_name = element_srcpad_name.to_glib_none();
unsafe {

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

@ -17,6 +17,10 @@ macro_rules! assert_initialized_main_thread {
};
}
macro_rules! skip_assert_initialized {
() => {};
}
#[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)]

4
gstreamer-gl/src/functions.rs
View file

@ -12,7 +12,7 @@ pub fn gl_handle_context_query(
context: Option<&impl IsA<GLContext>>,
other_context: Option<&impl IsA<GLContext>>,
) -> bool {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib(ffi::gst_gl_handle_context_query(
element.as_ref().to_glib_none().0,
@ -29,7 +29,7 @@ pub fn gl_handle_set_context(
element: &impl IsA<gst::Element>,
context: &gst::Context,
) -> (Option<GLDisplay>, Option<GLContext>) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut display = ptr::null_mut();
let mut other_context = ptr::null_mut();

2
gstreamer-net/src/ptp_clock.rs
View file

@ -87,7 +87,7 @@ impl PtpClock {
Box::into_raw(user_data) as glib::ffi::gpointer,
Some(destroy::<F>),
);
assert_ne!(id, 0);
debug_assert_ne!(id, 0);
PtpStatisticsCallback(NonZeroU64::new_unchecked(id as _))
}

2
gstreamer-pbutils/src/element_properties.rs
View file

@ -90,7 +90,7 @@ impl ElementProperties {
let structure_name = self.0.name();
if structure_name != "element-properties" {
assert_eq!(structure_name, "element-properties-map");
debug_assert_eq!(structure_name, "element-properties-map");
return false;
}

2
gstreamer-pbutils/src/encoding_profile.rs
View file

@ -312,7 +312,7 @@ impl EncodingContainerProfile {
profile.upcast().into_glib_ptr(),
);
// Can't possibly fail unless we pass random pointers
assert_ne!(res, glib::ffi::GFALSE);
debug_assert_ne!(res, glib::ffi::GFALSE);
}
}
}

12
gstreamer-play/src/config.rs
View file

@ -41,13 +41,13 @@ impl PlayConfig {
#[doc(alias = "get_position_update_interval")]
#[doc(alias = "gst_play_config_get_position_update_interval")]
pub fn position_update_interval(&self) -> u32 {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { ffi::gst_play_config_get_position_update_interval(self.0.to_glib_none().0) }
}
#[doc(alias = "get_seek_accurate")]
pub fn is_seek_accurate(&self) -> bool {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib(ffi::gst_play_config_get_seek_accurate(
self.0.to_glib_none().0,
@ -58,13 +58,13 @@ impl PlayConfig {
#[doc(alias = "get_user_agent")]
#[doc(alias = "gst_play_config_get_user_agent")]
pub fn user_agent(&self) -> Option<String> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { from_glib_full(ffi::gst_play_config_get_user_agent(self.0.to_glib_none().0)) }
}
#[doc(alias = "gst_play_config_set_position_update_interval")]
pub fn set_position_update_interval(&mut self, interval: u32) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
ffi::gst_play_config_set_position_update_interval(
self.0.to_glib_none_mut().0,
@ -74,7 +74,7 @@ impl PlayConfig {
}
pub fn set_seek_accurate(&mut self, accurate: bool) {
assert_initialized_main_thread!();
skip_assert_initialized!();
// FIXME: Work-around for
// http://cgit.freedesktop.org/gstreamer/gst-plugins-bad/commit/?id=cc58bd6ae071dec4ea7b4be626034accd0372755
self.set("accurate-seek", accurate);
@ -82,7 +82,7 @@ impl PlayConfig {
#[doc(alias = "gst_play_config_set_user_agent")]
pub fn set_user_agent(&mut self, agent: &str) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
ffi::gst_play_config_set_user_agent(
self.0.to_glib_none_mut().0,

4
gstreamer-play/src/play_video_overlay_video_renderer.rs
View file

@ -20,7 +20,7 @@ impl PlayVideoOverlayVideoRenderer {
window_handle: uintptr_t,
video_sink: &P,
) -> PlayVideoOverlayVideoRenderer {
assert_initialized_main_thread!();
skip_assert_initialized!();
from_glib_full(ffi::gst_play_video_overlay_video_renderer_new_with_sink(
window_handle as *mut _,
@ -30,7 +30,7 @@ impl PlayVideoOverlayVideoRenderer {
#[doc(alias = "gst_play_video_overlay_video_renderer_new_with_sink")]
pub fn with_sink<P: IsA<gst::Element>>(video_sink: &P) -> PlayVideoOverlayVideoRenderer {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_play_video_overlay_video_renderer_new_with_sink(

12
gstreamer-player/src/config.rs
View file

@ -41,13 +41,13 @@ impl PlayerConfig {
#[doc(alias = "get_position_update_interval")]
#[doc(alias = "gst_player_config_get_position_update_interval")]
pub fn position_update_interval(&self) -> u32 {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { ffi::gst_player_config_get_position_update_interval(self.0.to_glib_none().0) }
}
#[doc(alias = "get_seek_accurate")]
pub fn is_seek_accurate(&self) -> bool {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib(ffi::gst_player_config_get_seek_accurate(
self.0.to_glib_none().0,
@ -58,7 +58,7 @@ impl PlayerConfig {
#[doc(alias = "get_user_agent")]
#[doc(alias = "gst_player_config_get_user_agent")]
pub fn user_agent(&self) -> Option<String> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_player_config_get_user_agent(
self.0.to_glib_none().0,
@ -68,7 +68,7 @@ impl PlayerConfig {
#[doc(alias = "gst_player_config_set_position_update_interval")]
pub fn set_position_update_interval(&mut self, interval: u32) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
ffi::gst_player_config_set_position_update_interval(
self.0.to_glib_none_mut().0,
@ -78,7 +78,7 @@ impl PlayerConfig {
}
pub fn set_seek_accurate(&mut self, accurate: bool) {
assert_initialized_main_thread!();
skip_assert_initialized!();
// FIXME: Work-around for
// http://cgit.freedesktop.org/gstreamer/gst-plugins-bad/commit/?id=cc58bd6ae071dec4ea7b4be626034accd0372755
self.set("accurate-seek", accurate);
@ -86,7 +86,7 @@ impl PlayerConfig {
#[doc(alias = "gst_player_config_set_user_agent")]
pub fn set_user_agent(&mut self, agent: &str) {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
ffi::gst_player_config_set_user_agent(
self.0.to_glib_none_mut().0,

4
gstreamer-player/src/player_video_overlay_video_renderer.rs
View file

@ -20,7 +20,7 @@ impl PlayerVideoOverlayVideoRenderer {
window_handle: uintptr_t,
video_sink: &P,
) -> PlayerVideoOverlayVideoRenderer {
assert_initialized_main_thread!();
skip_assert_initialized!();
from_glib_full(ffi::gst_player_video_overlay_video_renderer_new_with_sink(
window_handle as *mut _,
@ -30,7 +30,7 @@ impl PlayerVideoOverlayVideoRenderer {
#[doc(alias = "gst_player_video_overlay_video_renderer_new_with_sink")]
pub fn with_sink<P: IsA<gst::Element>>(video_sink: &P) -> PlayerVideoOverlayVideoRenderer {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_player_video_overlay_video_renderer_new_with_sink(

2
gstreamer-rtp/src/rtp_buffer.rs
View file

@ -319,7 +319,7 @@ impl<'a, T> RTPBuffer<'a, T> {
unsafe {
let ptr = self.rtp_buffer.buffer;
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
gst::BufferRef::from_ptr(ptr)
}

2
gstreamer-rtsp-server/src/rtsp_context.rs
View file

@ -29,7 +29,7 @@ impl RTSPContext {
impl FromGlibPtrBorrow<*mut ffi::GstRTSPContext> for RTSPContext {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstRTSPContext) -> Borrowed<Self> {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Borrowed::new(RTSPContext(ptr::NonNull::new_unchecked(ptr)))
}
}

2
gstreamer-rtsp-server/src/rtsp_token.rs
View file

@ -16,7 +16,7 @@ impl RTSPToken {
}
pub fn new(values: &[(&str, &(dyn ToSendValue + Sync))]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut token = RTSPToken::new_empty();
{

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

@ -38,7 +38,7 @@ impl SDPBandwidth {
impl Clone for SDPBandwidth {
fn clone(&self) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut bw = mem::MaybeUninit::uninit();
ffi::gst_sdp_bandwidth_set(bw.as_mut_ptr(), self.0.bwtype, self.0.bandwidth);

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

@ -69,7 +69,7 @@ impl SDPConnection {
impl Clone for SDPConnection {
fn clone(&self) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut conn = mem::MaybeUninit::uninit();
ffi::gst_sdp_connection_set(

8
gstreamer-sdp/src/sdp_media.rs
View file

@ -21,11 +21,13 @@ glib::wrapper! {
match fn {
copy => |ptr| {
let mut copy = ptr::null_mut();
assert_eq!(ffi::gst_sdp_media_copy(ptr, &mut copy), ffi::GST_SDP_OK);
let res = ffi::gst_sdp_media_copy(ptr, &mut copy);
debug_assert_eq!(res, ffi::GST_SDP_OK);
copy
},
free => |ptr| {
ffi::gst_sdp_media_free(ptr);
let res = ffi::gst_sdp_media_free(ptr);
debug_assert_eq!(res, ffi::GST_SDP_OK);
},
}
}
@ -612,7 +614,7 @@ impl SDPMediaRef {
caps: &gst::CapsRef,
media: &mut SDPMedia,
) -> Result<(), glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let result = unsafe {
ffi::gst_sdp_media_set_media_from_caps(caps.as_ptr(), media.to_glib_none_mut().0)
};

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

@ -27,10 +27,14 @@ glib::wrapper! {
match fn {
copy => |ptr| {
let mut copy = std::ptr::null_mut();
assert_eq!(ffi::gst_sdp_message_copy(ptr, &mut copy), ffi::GST_SDP_OK);
let res = ffi::gst_sdp_message_copy(ptr, &mut copy);
debug_assert_eq!(res, ffi::GST_SDP_OK);
copy
},
free => |ptr| assert_eq!(ffi::gst_sdp_message_free(ptr), ffi::GST_SDP_OK),
free => |ptr| {
let res = ffi::gst_sdp_message_free(ptr);
debug_assert_eq!(res, ffi::GST_SDP_OK);
},
type_ => || ffi::gst_sdp_message_get_type(),
}
}
@ -887,7 +891,7 @@ impl SDPMessageRef {
#[doc(alias = "gst_sdp_message_as_uri")]
pub fn as_uri(&self, scheme: &str) -> Result<String, glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
match from_glib_full(ffi::gst_sdp_message_as_uri(
scheme.to_glib_none().0,

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

@ -66,7 +66,7 @@ impl SDPTime {
impl Clone for SDPTime {
fn clone(&self) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
#[allow(clippy::cast_ptr_alignment)]
unsafe {
let mut time = mem::MaybeUninit::uninit();

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

@ -48,7 +48,7 @@ impl SDPZone {
impl Clone for SDPZone {
fn clone(&self) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut zone = mem::MaybeUninit::uninit();
ffi::gst_sdp_zone_set(zone.as_mut_ptr(), self.0.time, self.0.typed_time);

4
gstreamer-video/src/enums.rs
View file

@ -16,7 +16,7 @@ use crate::VideoOrientationMethod;
impl VideoCaptionType {
#[doc(alias = "gst_video_caption_type_from_caps")]
pub fn from_caps(caps: &gst::CapsRef) -> VideoCaptionType {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { from_glib(ffi::gst_video_caption_type_from_caps(caps.as_ptr())) }
}
}
@ -28,7 +28,7 @@ impl VideoOrientationMethod {
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(alias = "gst_video_orientation_from_tag")]
pub fn from_tag(taglist: &gst::TagListRef) -> Option<VideoOrientationMethod> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
use std::mem;

2
gstreamer-video/src/functions.rs
View file

@ -212,7 +212,7 @@ pub fn is_common_aspect_ratio(width: u32, height: u32, par: gst::Fraction) -> bo
pub fn video_make_raw_caps(
formats: &[crate::VideoFormat],
) -> crate::VideoCapsBuilder<gst::caps::NoFeature> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let formats = formats.iter().copied().map(|f| match f {
crate::VideoFormat::Encoded => panic!("Invalid encoded format"),

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

@ -66,7 +66,7 @@ impl VideoAlignment {
padding_right: u32,
stride_align: &[u32; ffi::GST_VIDEO_MAX_PLANES as usize],
) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let videoalignment = ffi::GstVideoAlignment {
padding_top,

11
gstreamer-video/src/video_codec_frame.rs
View file

@ -192,7 +192,7 @@ impl<'a> VideoCodecFrame<'a> {
let writable: bool = from_glib(gst::ffi::gst_mini_object_is_writable(
ptr as *const gst::ffi::GstMiniObject,
));
assert!(writable);
debug_assert!(writable);
Some(gst::BufferRef::from_mut_ptr(ptr))
}
@ -201,19 +201,14 @@ impl<'a> VideoCodecFrame<'a> {
pub fn set_output_buffer(&mut self, output_buffer: gst::Buffer) {
unsafe {
assert!(output_buffer.is_writable());
let prev = (*self.to_glib_none().0).output_buffer;
if !prev.is_null() {
gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject);
}
let ptr = output_buffer.into_glib_ptr();
let writable: bool = from_glib(gst::ffi::gst_mini_object_is_writable(
ptr as *const gst::ffi::GstMiniObject,
));
assert!(writable);
(*self.to_glib_none().0).output_buffer = ptr;
(*self.to_glib_none().0).output_buffer = output_buffer.into_glib_ptr();
}
}

2
gstreamer-video/src/video_converter.rs
View file

@ -27,7 +27,7 @@ impl VideoConverter {
out_info: &crate::VideoInfo,
config: Option<VideoConverterConfig>,
) -> Result<Self, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
if in_info.fps() != out_info.fps() {
return Err(glib::bool_error!("Can't do framerate conversion"));
}

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

@ -43,7 +43,7 @@ macro_rules! event_builder_generic_impl {
#[must_use = "Building the event without using it has no effect"]
pub fn build(mut self) -> gst::Event {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let event = $new_fn(&mut self);
if let Some(seqnum) = self.seqnum {
@ -151,6 +151,7 @@ pub struct DownstreamForceKeyUnitEvent {
impl DownstreamForceKeyUnitEvent {
pub fn builder<'a>() -> DownstreamForceKeyUnitEventBuilder<'a> {
assert_initialized_main_thread!();
DownstreamForceKeyUnitEventBuilder::new()
}
@ -246,6 +247,7 @@ pub struct UpstreamForceKeyUnitEvent {
impl UpstreamForceKeyUnitEvent {
pub fn builder<'a>() -> UpstreamForceKeyUnitEventBuilder<'a> {
assert_initialized_main_thread!();
UpstreamForceKeyUnitEventBuilder::new()
}
@ -370,7 +372,7 @@ macro_rules! nav_event_builder {
}
impl<'a> $builder<'a> {
pub fn new($($event_field: $event_type)?) -> Self {
fn new($($event_field: $event_type)?) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -500,7 +502,7 @@ pub struct CommandEventBuilder<'a> {
}
impl<'a> CommandEventBuilder<'a> {
pub fn new(command: NavigationCommand) -> Self {
fn new(command: NavigationCommand) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -958,7 +960,7 @@ impl NavigationEvent {
#[doc(alias = "gst_navigation_event_get_type")]
pub fn type_(event: &gst::EventRef) -> NavigationEventType {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { from_glib(ffi::gst_navigation_event_get_type(event.as_mut_ptr())) }
}

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

@ -11,18 +11,16 @@ pub struct VideoFormatInfo(&'static ffi::GstVideoFormatInfo);
impl VideoFormatInfo {
#[inline]
pub unsafe fn from_ptr(format_info: *const ffi::GstVideoFormatInfo) -> Self {
assert_initialized_main_thread!();
assert!(!format_info.is_null());
debug_assert!(!format_info.is_null());
Self(&*format_info)
}
#[inline]
pub fn from_format(format: crate::VideoFormat) -> Self {
assert_initialized_main_thread!();
unsafe {
let info = ffi::gst_video_format_get_info(format.into_glib());
assert!(!info.is_null());
debug_assert!(!info.is_null());
Self(&*info)
}

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

@ -732,7 +732,7 @@ impl<T> VideoFrameRef<T> {
impl<'a> VideoFrameRef<&'a gst::BufferRef> {
#[inline]
pub unsafe fn from_glib_borrow(frame: *const ffi::GstVideoFrame) -> Borrowed<Self> {
assert!(!frame.is_null());
debug_assert!(!frame.is_null());
let frame = ptr::read(frame);
let info = crate::VideoInfo(ptr::read(&frame.info));
@ -832,7 +832,7 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
#[inline]
pub unsafe fn from_glib_borrow_mut(frame: *mut ffi::GstVideoFrame) -> Self {
assert!(!frame.is_null());
debug_assert!(!frame.is_null());
let frame = ptr::read(frame);
let info = crate::VideoInfo(ptr::read(&frame.info));

4
gstreamer-video/src/video_hdr.rs
View file

@ -10,7 +10,7 @@ pub struct VideoContentLightLevel(ffi::GstVideoContentLightLevel);
impl VideoContentLightLevel {
pub fn new(max_content_light_level: u16, max_frame_average_light_level: u16) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
VideoContentLightLevel(ffi::GstVideoContentLightLevel {
max_content_light_level,
@ -148,7 +148,7 @@ impl VideoMasteringDisplayInfo {
max_display_mastering_luminance: u32,
min_display_mastering_luminance: u32,
) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
VideoMasteringDisplayInfo(ffi::GstVideoMasteringDisplayInfo {
display_primaries: unsafe { mem::transmute(display_primaries) },

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

@ -101,7 +101,7 @@ impl VideoColorimetry {
transfer: crate::VideoTransferFunction,
primaries: crate::VideoColorPrimaries,
) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let colorimetry = ffi::GstVideoColorimetry {
range: range.into_glib(),

14
gstreamer-video/src/video_message.rs
View file

@ -42,7 +42,7 @@ macro_rules! message_builder_generic_impl {
#[must_use = "Building the message without using it has no effect"]
pub fn build(mut self) -> Message {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let src = self.builder.src.to_glib_none().0;
let msg = $new_fn(&mut self, src);
@ -77,8 +77,8 @@ struct MessageBuilder<'a> {
}
impl<'a> MessageBuilder<'a> {
pub fn new() -> Self {
assert_initialized_main_thread!();
pub(crate) fn new() -> Self {
skip_assert_initialized!();
Self {
src: None,
seqnum: None,
@ -151,18 +151,18 @@ impl NavigationEventMessage {
#[doc(alias = "gst_navigation_message_new_event")]
#[allow(clippy::new_ret_no_self)]
pub fn new(event: gst::Event) -> gst::Message {
assert_initialized_main_thread!();
skip_assert_initialized!();
NavigationEventMessageBuilder::new(event).build()
}
pub fn builder<'a>(event: gst::Event) -> NavigationEventMessageBuilder<'a> {
assert_initialized_main_thread!();
skip_assert_initialized!();
NavigationEventMessageBuilder::new(event)
}
#[doc(alias = "gst_navigation_message_parse_event")]
pub fn parse(msg: &gst::MessageRef) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut event = ptr::null_mut();
let ret = from_glib(ffi::gst_navigation_message_parse_event(
@ -188,7 +188,7 @@ pub enum NavigationMessage {
impl NavigationMessage {
#[doc(alias = "gst_navigation_message_get_type")]
pub fn type_(msg: &gst::MessageRef) -> NavigationMessageType {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe { from_glib(ffi::gst_navigation_message_get_type(msg.as_mut_ptr())) }
}

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

@ -37,7 +37,7 @@ impl VideoOverlayRectangle {
render_height: u32,
flags: crate::VideoOverlayFormatFlags,
) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
assert!(buffer.meta::<crate::VideoMeta>().is_some());
unsafe {
from_glib_full(ffi::gst_video_overlay_rectangle_new_raw(

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

@ -203,7 +203,7 @@ impl ValidVideoTimeCode {
frames: u32,
field_count: u32,
) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let tc = VideoTimeCode::new(
fps,
latest_daily_jam,
@ -233,7 +233,6 @@ impl ValidVideoTimeCode {
#[doc(alias = "gst_video_time_code_add_frames")]
pub fn add_frames(&mut self, frames: i64) {
skip_assert_initialized!();
unsafe {
ffi::gst_video_time_code_add_frames(self.to_glib_none_mut().0, frames);
}

8
gstreamer-webrtc/src/lib.rs
View file

@ -10,14 +10,6 @@ pub use glib;
pub use gst;
pub use gst_sdp;
macro_rules! assert_initialized_main_thread {
() => {
if !gst::INITIALIZED.load(std::sync::atomic::Ordering::SeqCst) {
gst::assert_initialized();
}
};
}
macro_rules! skip_assert_initialized {
() => {};
}

2
gstreamer-webrtc/src/web_rtc_session_description.rs
View file

@ -9,7 +9,7 @@ use crate::{WebRTCSDPType, WebRTCSessionDescription};
impl WebRTCSessionDescription {
#[doc(alias = "gst_webrtc_session_description_new")]
pub fn new(type_: WebRTCSDPType, sdp: gst_sdp::SDPMessage) -> WebRTCSessionDescription {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut sdp = mem::ManuallyDrop::new(sdp);
from_glib_full(ffi::gst_webrtc_session_description_new(

2
gstreamer/src/allocation_params.rs
View file

@ -82,7 +82,7 @@ impl FromGlib<ffi::GstAllocationParams> for AllocationParams {
#[allow(unused_unsafe)]
#[inline]
unsafe fn from_glib(value: ffi::GstAllocationParams) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self::from(value)
}
}

4
gstreamer/src/buffer.rs
View file

@ -163,7 +163,6 @@ impl Buffer {
#[doc(alias = "gst_buffer_append")]
pub fn append(&mut self, other: Self) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_buffer_append(self.as_mut_ptr(), other.into_glib_ptr());
self.replace_ptr(ptr);
@ -1001,8 +1000,7 @@ impl<'a> IntoIterator for &'a BufferRef {
impl std::iter::FromIterator<Memory> for Buffer {
fn from_iter<T: IntoIterator<Item = Memory>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let iter = iter.into_iter();
let mut buffer = Buffer::new();

6
gstreamer/src/buffer_cursor.rs
View file

@ -112,7 +112,7 @@ macro_rules! define_read_write_fn_impl(
buffer_ref($self).as_mut_ptr(),
$self.cur_mem_idx,
);
assert!(!memory.is_null());
debug_assert!(!memory.is_null());
if ffi::gst_memory_map(memory, &mut $self.map_info, $map_flags)
== glib::ffi::GFALSE
@ -124,10 +124,10 @@ macro_rules! define_read_write_fn_impl(
}
}
assert!($self.cur_mem_offset < $self.map_info.size);
debug_assert!($self.cur_mem_offset < $self.map_info.size);
}
assert!(!$self.map_info.memory.is_null());
debug_assert!(!$self.map_info.memory.is_null());
// Copy all data we can currently copy
let data_left = $self.map_info.size - $self.cur_mem_offset;

4
gstreamer/src/buffer_pool.rs
View file

@ -52,7 +52,7 @@ pub struct BufferPoolConfigRef(StructureRef);
impl BufferPoolConfigRef {
#[inline]
pub unsafe fn from_glib_borrow<'a>(ptr: *const ffi::GstStructure) -> &'a BufferPoolConfigRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&*(ptr as *mut StructureRef as *mut BufferPoolConfigRef)
}
@ -61,7 +61,7 @@ impl BufferPoolConfigRef {
pub unsafe fn from_glib_borrow_mut<'a>(
ptr: *mut ffi::GstStructure,
) -> &'a mut BufferPoolConfigRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&mut *(ptr as *mut StructureRef as *mut BufferPoolConfigRef)
}

18
gstreamer/src/caps.rs
View file

@ -51,7 +51,7 @@ impl Caps {
#[doc(alias = "gst_caps_new_simple")]
pub fn new_simple(name: &str, values: &[(&str, &(dyn ToSendValue + Sync))]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut caps = Caps::new_empty();
let structure = Structure::new(name, values);
@ -68,7 +68,6 @@ impl Caps {
#[doc(alias = "gst_caps_fixate")]
pub fn fixate(&mut self) {
skip_assert_initialized!();
unsafe {
// See https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/388
assert!(!self.is_any());
@ -83,7 +82,6 @@ impl Caps {
#[doc(alias = "gst_caps_merge")]
pub fn merge(&mut self, other: Self) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_merge(self.as_mut_ptr(), other.into_glib_ptr());
self.replace_ptr(ptr);
@ -92,7 +90,6 @@ impl Caps {
#[doc(alias = "gst_caps_merge_structure")]
pub fn merge_structure(&mut self, structure: Structure) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_merge_structure(self.as_mut_ptr(), structure.into_glib_ptr());
self.replace_ptr(ptr);
@ -101,7 +98,6 @@ impl Caps {
#[doc(alias = "gst_caps_merge_structure_full")]
pub fn merge_structure_full(&mut self, structure: Structure, features: Option<CapsFeatures>) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_merge_structure_full(
self.as_mut_ptr(),
@ -116,7 +112,6 @@ impl Caps {
#[doc(alias = "gst_caps_normalize")]
pub fn normalize(&mut self) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_normalize(self.as_mut_ptr());
self.replace_ptr(ptr);
@ -125,7 +120,6 @@ impl Caps {
#[doc(alias = "gst_caps_simplify")]
pub fn simplify(&mut self) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_simplify(self.as_mut_ptr());
self.replace_ptr(ptr);
@ -134,7 +128,6 @@ impl Caps {
#[doc(alias = "gst_caps_truncate")]
pub fn truncate(&mut self) {
skip_assert_initialized!();
unsafe {
let ptr = ffi::gst_caps_truncate(self.as_mut_ptr());
self.replace_ptr(ptr);
@ -157,7 +150,7 @@ impl str::FromStr for Caps {
impl std::iter::FromIterator<Structure> for Caps {
fn from_iter<T: IntoIterator<Item = Structure>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut caps = Caps::new_empty();
{
@ -171,7 +164,7 @@ impl std::iter::FromIterator<Structure> for Caps {
impl std::iter::FromIterator<(Structure, CapsFeatures)> for Caps {
fn from_iter<T: IntoIterator<Item = (Structure, CapsFeatures)>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut caps = Caps::new_empty();
{
@ -186,7 +179,7 @@ impl std::iter::FromIterator<(Structure, CapsFeatures)> for Caps {
impl std::iter::FromIterator<(Structure, Option<CapsFeatures>)> for Caps {
fn from_iter<T: IntoIterator<Item = (Structure, Option<CapsFeatures>)>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut caps = Caps::new_empty();
{
@ -201,7 +194,7 @@ impl std::iter::FromIterator<(Structure, Option<CapsFeatures>)> for Caps {
impl std::iter::FromIterator<Caps> for Caps {
fn from_iter<T: IntoIterator<Item = Caps>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut caps = Caps::new_empty();
{
@ -493,7 +486,6 @@ impl CapsRef {
#[doc(alias = "gst_caps_subtract")]
pub fn subtract(&self, other: &Self) -> Caps {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_caps_subtract(
self.as_mut_ptr(),

41
gstreamer/src/caps_features.rs
View file

@ -22,7 +22,7 @@ unsafe impl Sync for CapsFeatures {}
impl CapsFeatures {
#[doc(alias = "gst_caps_features_new")]
pub fn new(features: &[&str]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut f = Self::new_empty();
for feature in features {
@ -34,7 +34,7 @@ impl CapsFeatures {
#[doc(alias = "gst_caps_features_new_id")]
pub fn from_quarks(features: &[glib::Quark]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut f = Self::new_empty();
for feature in features {
@ -104,7 +104,7 @@ impl Clone for CapsFeatures {
fn clone(&self) -> Self {
unsafe {
let ptr = ffi::gst_caps_features_copy(self.0.as_ref());
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
CapsFeatures(ptr::NonNull::new_unchecked(ptr))
}
}
@ -218,9 +218,9 @@ impl<'a> ToGlibPtrMut<'a, *mut ffi::GstCapsFeatures> for CapsFeatures {
impl FromGlibPtrNone<*const ffi::GstCapsFeatures> for CapsFeatures {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstCapsFeatures) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let ptr = ffi::gst_caps_features_copy(ptr);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
CapsFeatures(ptr::NonNull::new_unchecked(ptr))
}
}
@ -228,9 +228,9 @@ impl FromGlibPtrNone<*const ffi::GstCapsFeatures> for CapsFeatures {
impl FromGlibPtrNone<*mut ffi::GstCapsFeatures> for CapsFeatures {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstCapsFeatures) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let ptr = ffi::gst_caps_features_copy(ptr);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
CapsFeatures(ptr::NonNull::new_unchecked(ptr))
}
}
@ -238,7 +238,7 @@ impl FromGlibPtrNone<*mut ffi::GstCapsFeatures> for CapsFeatures {
impl FromGlibPtrFull<*const ffi::GstCapsFeatures> for CapsFeatures {
#[inline]
unsafe fn from_glib_full(ptr: *const ffi::GstCapsFeatures) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
CapsFeatures(ptr::NonNull::new_unchecked(
ptr as *mut ffi::GstCapsFeatures,
))
@ -248,7 +248,7 @@ impl FromGlibPtrFull<*const ffi::GstCapsFeatures> for CapsFeatures {
impl FromGlibPtrFull<*mut ffi::GstCapsFeatures> for CapsFeatures {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstCapsFeatures) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
CapsFeatures(ptr::NonNull::new_unchecked(ptr))
}
}
@ -327,7 +327,7 @@ pub struct CapsFeaturesRef(ffi::GstCapsFeatures);
impl CapsFeaturesRef {
#[inline]
pub unsafe fn from_glib_borrow<'a>(ptr: *const ffi::GstCapsFeatures) -> &'a CapsFeaturesRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&*(ptr as *mut CapsFeaturesRef)
}
@ -336,7 +336,7 @@ impl CapsFeaturesRef {
pub unsafe fn from_glib_borrow_mut<'a>(
ptr: *mut ffi::GstCapsFeatures,
) -> &'a mut CapsFeaturesRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&mut *(ptr as *mut CapsFeaturesRef)
}
@ -547,7 +547,7 @@ impl<'a> Iterator for Iter<'a> {
unsafe {
let feature =
ffi::gst_caps_features_get_nth(self.caps_features.as_ptr(), self.idx as u32);
assert!(!feature.is_null());
debug_assert!(!feature.is_null());
self.idx += 1;
@ -576,7 +576,7 @@ impl<'a> Iterator for Iter<'a> {
self.idx = end + 1;
let feature =
ffi::gst_caps_features_get_nth(self.caps_features.as_ptr(), end as u32);
assert!(!feature.is_null());
debug_assert!(!feature.is_null());
Some(CStr::from_ptr(feature).to_str().unwrap())
}
}
@ -591,7 +591,7 @@ impl<'a> Iterator for Iter<'a> {
self.caps_features.as_ptr(),
self.n_features as u32 - 1,
);
assert!(!feature.is_null());
debug_assert!(!feature.is_null());
Some(CStr::from_ptr(feature).to_str().unwrap())
}
}
@ -609,7 +609,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
unsafe {
let feature =
ffi::gst_caps_features_get_nth(self.caps_features.as_ptr(), self.n_features as u32);
assert!(!feature.is_null());
debug_assert!(!feature.is_null());
Some(CStr::from_ptr(feature).to_str().unwrap())
}
@ -627,7 +627,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
self.caps_features.as_ptr(),
self.n_features as u32,
);
assert!(!feature.is_null());
debug_assert!(!feature.is_null());
Some(CStr::from_ptr(feature).to_str().unwrap())
}
@ -650,8 +650,7 @@ impl<'a> IntoIterator for &'a CapsFeaturesRef {
impl<'a> std::iter::FromIterator<&'a str> for CapsFeatures {
fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut features = CapsFeatures::new_empty();
iter.into_iter().for_each(|f| features.add(f));
@ -662,8 +661,7 @@ impl<'a> std::iter::FromIterator<&'a str> for CapsFeatures {
impl std::iter::FromIterator<String> for CapsFeatures {
fn from_iter<T: IntoIterator<Item = String>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut features = CapsFeatures::new_empty();
iter.into_iter().for_each(|f| features.add(&f));
@ -674,8 +672,7 @@ impl std::iter::FromIterator<String> for CapsFeatures {
impl std::iter::FromIterator<glib::Quark> for CapsFeatures {
fn from_iter<T: IntoIterator<Item = glib::Quark>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut features = CapsFeatures::new_empty();
iter.into_iter().for_each(|f| features.add_from_quark(f));

1
gstreamer/src/clock.rs
View file

@ -469,7 +469,6 @@ impl<O: IsA<Clock>> ClockExtManual for O {
start_time: ClockTime,
interval: ClockTime,
) -> Result<(), glib::BoolError> {
skip_assert_initialized!();
unsafe {
let res: bool = from_glib(ffi::gst_clock_periodic_id_reinit(
self.as_ref().to_glib_none().0,

2
gstreamer/src/device_monitor.rs
View file

@ -22,7 +22,7 @@ impl FromGlib<libc::c_uint> for DeviceMonitorFilterId {
#[inline]
unsafe fn from_glib(val: libc::c_uint) -> DeviceMonitorFilterId {
skip_assert_initialized!();
assert_ne!(val, 0);
debug_assert_ne!(val, 0);
DeviceMonitorFilterId(NonZeroU32::new_unchecked(val))
}
}

2
gstreamer/src/device_provider.rs
View file

@ -14,7 +14,7 @@ impl DeviceProvider {
rank: Rank,
type_: glib::types::Type,
) -> Result<(), glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
glib::result_from_gboolean!(
ffi::gst_device_provider_register(

4
gstreamer/src/element.rs
View file

@ -56,7 +56,7 @@ impl Element {
rank: Rank,
type_: glib::types::Type,
) -> Result<(), glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
glib::result_from_gboolean!(
ffi::gst_element_register(
@ -94,7 +94,7 @@ impl FromGlib<libc::c_ulong> for NotifyWatchId {
#[inline]
unsafe fn from_glib(val: libc::c_ulong) -> NotifyWatchId {
skip_assert_initialized!();
assert_ne!(val, 0);
debug_assert_ne!(val, 0);
NotifyWatchId(NonZeroU64::new_unchecked(val as _))
}
}

10
gstreamer/src/element_factory.rs
View file

@ -17,8 +17,6 @@ impl ElementFactory {
&self,
properties: &[(&str, &dyn ToValue)],
) -> Result<Element, glib::BoolError> {
assert_initialized_main_thread!();
let mut builder = self.create();
builder.properties = properties
.iter()
@ -33,8 +31,7 @@ impl ElementFactory {
factoryname: &str,
properties: &[(&str, &dyn ToValue)],
) -> Result<Element, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut builder = Self::make(factoryname);
builder.properties = properties
.iter()
@ -47,6 +44,8 @@ impl ElementFactory {
#[doc(alias = "gst_element_factory_create_with_properties")]
#[track_caller]
pub fn create(&self) -> ElementBuilder {
assert_initialized_main_thread!();
ElementBuilder {
name_or_factory: NameOrFactory::Factory(self),
properties: Vec::new(),
@ -81,8 +80,7 @@ impl ElementFactory {
factoryname: &str,
name: Option<&str>,
) -> Result<Element, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut builder = Self::make(factoryname);
if let Some(name) = name {
builder = builder.name(name);

4
gstreamer/src/error.rs
View file

@ -62,7 +62,7 @@ impl ErrorMessage {
function: &'static str,
line: u32,
) -> ErrorMessage {
assert_initialized_main_thread!();
skip_assert_initialized!();
let error_domain = T::domain();
let error_code = error.code();
@ -115,7 +115,7 @@ pub struct LoggableError {
impl LoggableError {
pub fn new(category: crate::DebugCategory, bool_error: glib::BoolError) -> LoggableError {
assert_initialized_main_thread!();
skip_assert_initialized!();
LoggableError {
category,
bool_error,

5
gstreamer/src/event.rs
View file

@ -157,7 +157,7 @@ impl EventRef {
pub fn seqnum(&self) -> Seqnum {
unsafe {
let seqnum = ffi::gst_event_get_seqnum(self.as_mut_ptr());
assert_ne!(seqnum, 0);
debug_assert_ne!(seqnum, 0);
Seqnum(NonZeroU32::new_unchecked(seqnum))
}
}
@ -770,7 +770,7 @@ impl StreamGroupDone {
ffi::gst_event_parse_stream_group_done(self.as_mut_ptr(), group_id.as_mut_ptr());
let group_id = group_id.assume_init();
assert_ne!(group_id, 0);
debug_assert_ne!(group_id, 0);
GroupId(NonZeroU32::new_unchecked(group_id))
}
}
@ -1544,7 +1544,6 @@ macro_rules! event_builder_generic_impl {
#[must_use = "Building the event without using it has no effect"]
pub fn build(mut self) -> Event {
assert_initialized_main_thread!();
unsafe {
let event = $new_fn(&mut self);
if let Some(seqnum) = self.builder.seqnum {

6
gstreamer/src/functions.rs
View file

@ -16,7 +16,7 @@ pub fn parse_bin_from_description_with_name(
ghost_unlinked_pads: bool,
bin_name: &str,
) -> Result<Bin, glib::Error> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let bin = parse_bin_from_description(bin_description, ghost_unlinked_pads)?;
if !bin_name.is_empty() {
let obj = bin.clone().upcast::<Object>();
@ -34,7 +34,7 @@ pub fn parse_bin_from_description_full(
mut context: Option<&mut ParseContext>,
flags: ParseFlags,
) -> Result<Element, glib::Error> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::gst_parse_bin_from_description_full(
@ -59,7 +59,7 @@ pub fn parse_bin_from_description_with_name_full(
context: Option<&mut ParseContext>,
flags: ParseFlags,
) -> Result<Element, glib::Error> {
assert_initialized_main_thread!();
skip_assert_initialized!();
let bin =
parse_bin_from_description_full(bin_description, ghost_unlinked_pads, context, flags)?;
if !bin_name.is_empty() {

12
gstreamer/src/iterator.rs
View file

@ -590,7 +590,7 @@ impl<'a, T: 'static> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstIterator> fo
impl<T: StaticType> glib::translate::FromGlibPtrNone<*const ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstIterator) -> Self {
assert_ne!(
debug_assert_ne!(
glib::gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().into_glib()),
glib::ffi::GFALSE
);
@ -602,7 +602,7 @@ impl<T: StaticType> glib::translate::FromGlibPtrNone<*const ffi::GstIterator> fo
impl<T: StaticType> glib::translate::FromGlibPtrNone<*mut ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstIterator) -> Self {
assert_ne!(
debug_assert_ne!(
glib::gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().into_glib()),
glib::ffi::GFALSE
);
@ -614,8 +614,8 @@ impl<T: StaticType> glib::translate::FromGlibPtrNone<*mut ffi::GstIterator> for
impl<T: StaticType> glib::translate::FromGlibPtrBorrow<*mut ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstIterator) -> Borrowed<Self> {
assert!(!ptr.is_null());
assert_ne!(
debug_assert!(!ptr.is_null());
debug_assert_ne!(
glib::gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().into_glib()),
glib::ffi::GFALSE
);
@ -630,8 +630,8 @@ impl<T: StaticType> glib::translate::FromGlibPtrBorrow<*mut ffi::GstIterator> fo
impl<T: StaticType> glib::translate::FromGlibPtrFull<*mut ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstIterator) -> Self {
assert!(!ptr.is_null());
assert_ne!(
debug_assert!(!ptr.is_null());
debug_assert_ne!(
glib::gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().into_glib()),
glib::ffi::GFALSE
);

4
gstreamer/src/log.rs
View file

@ -525,7 +525,7 @@ unsafe impl TransparentPtrType for DebugCategory {}
impl FromGlibPtrNone<*mut ffi::GstDebugCategory> for DebugCategory {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstDebugCategory) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
DebugCategory(Some(ptr::NonNull::new_unchecked(ptr)))
}
}
@ -533,7 +533,7 @@ impl FromGlibPtrNone<*mut ffi::GstDebugCategory> for DebugCategory {
impl FromGlibPtrFull<*mut ffi::GstDebugCategory> for DebugCategory {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstDebugCategory) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
DebugCategory(Some(ptr::NonNull::new_unchecked(ptr)))
}
}

2
gstreamer/src/memory.rs
View file

@ -836,7 +836,7 @@ macro_rules! memory_object_wrapper {
let value = &*(value as *const $crate::glib::Value as *const $crate::glib::gobject_ffi::GValue);
let ptr = &value.data[0].v_pointer as *const $crate::glib::ffi::gpointer
as *const *const $ffi_name;
assert!(!(*ptr).is_null());
debug_assert!(!(*ptr).is_null());
&*(ptr as *const $name)
}
}

1
gstreamer/src/message.rs
View file

@ -1853,7 +1853,6 @@ macro_rules! message_builder_generic_impl {
#[must_use = "Building the message without using it has no effect"]
pub fn build(mut self) -> Message {
assert_initialized_main_thread!();
unsafe {
let src = self.builder.src.to_glib_none().0;
let msg = $new_fn(&mut self, src);

10
gstreamer/src/meta.rs
View file

@ -17,11 +17,11 @@ pub unsafe trait MetaAPI: Sync + Send + Sized {
#[inline]
unsafe fn from_ptr(buffer: &BufferRef, ptr: *const Self::GstType) -> MetaRef<Self> {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let meta_api = Self::meta_api();
if meta_api != glib::Type::INVALID {
assert_eq!(
debug_assert_eq!(
meta_api,
from_glib((*(*(ptr as *const ffi::GstMeta)).info).api)
)
@ -38,11 +38,11 @@ pub unsafe trait MetaAPI: Sync + Send + Sized {
buffer: &mut BufferRef,
ptr: *mut Self::GstType,
) -> MetaRefMut<Self, T> {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let meta_api = Self::meta_api();
if meta_api != glib::Type::INVALID {
assert_eq!(
debug_assert_eq!(
meta_api,
from_glib((*(*(ptr as *const ffi::GstMeta)).info).api)
)
@ -278,7 +278,7 @@ impl<'a, T> MetaRefMut<'a, T, Standalone> {
self.buffer.as_mut_ptr(),
self.meta as *mut T as *mut ffi::GstMeta,
);
assert_ne!(res, glib::ffi::GFALSE);
debug_assert_ne!(res, glib::ffi::GFALSE);
Ok(())
}

18
gstreamer/src/miniobject.rs
View file

@ -31,7 +31,7 @@ macro_rules! mini_object_wrapper (
#[inline]
pub unsafe fn from_glib_none(ptr: *const $ffi_name) -> Self {
skip_assert_initialized!();
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
$crate::ffi::gst_mini_object_ref(ptr as *mut $crate::ffi::GstMiniObject);
@ -43,7 +43,7 @@ macro_rules! mini_object_wrapper (
#[inline]
pub unsafe fn from_glib_full(ptr: *const $ffi_name) -> Self {
skip_assert_initialized!();
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
$name {
obj: std::ptr::NonNull::new_unchecked(ptr as *mut $ffi_name),
@ -53,7 +53,7 @@ macro_rules! mini_object_wrapper (
#[inline]
pub unsafe fn from_glib_borrow(ptr: *const $ffi_name) -> $crate::glib::translate::Borrowed<Self> {
skip_assert_initialized!();
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
$crate::glib::translate::Borrowed::new($name {
obj: std::ptr::NonNull::new_unchecked(ptr as *mut $ffi_name),
@ -62,7 +62,7 @@ macro_rules! mini_object_wrapper (
#[inline]
pub unsafe fn replace_ptr(&mut self, ptr: *mut $ffi_name) {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
self.obj = std::ptr::NonNull::new_unchecked(ptr);
}
@ -78,7 +78,7 @@ macro_rules! mini_object_wrapper (
self.as_mut_ptr() as *mut $crate::ffi::GstMiniObject
);
self.replace_ptr(ptr as *mut $ffi_name);
assert!(self.is_writable());
debug_assert!(self.is_writable());
&mut *(self.obj.as_mut() as *mut $ffi_name as *mut $ref_name)
}
@ -435,14 +435,14 @@ macro_rules! mini_object_wrapper (
#[inline]
pub unsafe fn from_ptr<'a>(ptr: *const $ffi_name) -> &'a Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&*(ptr as *const Self)
}
#[inline]
pub unsafe fn from_mut_ptr<'a>(ptr: *mut $ffi_name) -> &'a mut Self {
assert!(!ptr.is_null());
assert_ne!(
debug_assert!(!ptr.is_null());
debug_assert_ne!(
$crate::ffi::gst_mini_object_is_writable(ptr as *mut $crate::ffi::GstMiniObject),
$crate::glib::ffi::GFALSE
);
@ -542,7 +542,7 @@ macro_rules! mini_object_wrapper (
assert_eq!(std::mem::size_of::<$name>(), std::mem::size_of::<$crate::glib::ffi::gpointer>());
let value = &*(value as *const $crate::glib::Value as *const $crate::glib::gobject_ffi::GValue);
let ptr = &value.data[0].v_pointer as *const $crate::glib::ffi::gpointer as *const *const $ffi_name;
assert!(!(*ptr).is_null());
debug_assert!(!(*ptr).is_null());
&*(ptr as *const $name)
}
}

10
gstreamer/src/pad.rs
View file

@ -33,7 +33,7 @@ impl FromGlib<libc::c_ulong> for PadProbeId {
#[inline]
unsafe fn from_glib(val: libc::c_ulong) -> PadProbeId {
skip_assert_initialized!();
assert_ne!(val, 0);
debug_assert_ne!(val, 0);
PadProbeId(NonZeroU64::new_unchecked(val as _))
}
}
@ -1364,7 +1364,7 @@ where
{
let func: &F = &*((*pad).getrangedata as *const F);
assert!(!buffer.is_null());
debug_assert!(!buffer.is_null());
let pad = Pad::from_glib_borrow(pad);
let pad = pad.unsafe_cast_ref();
@ -1639,7 +1639,7 @@ impl<T: IsA<Pad> + IsA<glib::Object> + glib::object::IsClass> PadBuilder<T> {
unsafe {
let res = ffi::gst_ghost_pad_construct(pad.to_glib_none().0);
// This can't really fail...
assert_ne!(res, glib::ffi::GFALSE, "Failed to construct ghost pad");
debug_assert_ne!(res, glib::ffi::GFALSE, "Failed to construct ghost pad");
}
}
@ -1647,7 +1647,7 @@ impl<T: IsA<Pad> + IsA<glib::Object> + glib::object::IsClass> PadBuilder<T> {
}
pub fn from_static_template(templ: &StaticPadTemplate, name: Option<&str>) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let templ = templ.get();
Self::from_template(&templ, name)
@ -1691,7 +1691,7 @@ impl<T: IsA<Pad> + IsA<glib::Object> + glib::object::IsClass> PadBuilder<T> {
unsafe {
let res = ffi::gst_ghost_pad_construct(pad.to_glib_none().0);
// This can't really fail...
assert_ne!(res, glib::ffi::GFALSE, "Failed to construct ghost pad");
debug_assert_ne!(res, glib::ffi::GFALSE, "Failed to construct ghost pad");
}
}

4
gstreamer/src/pad_template.rs
View file

@ -12,7 +12,7 @@ impl PadTemplate {
pad_template: &StaticPadTemplate,
pad_type: glib::types::Type,
) -> Result<PadTemplate, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
Option::<_>::from_glib_none(
ffi::gst_pad_template_new_from_static_pad_template_with_gtype(
@ -83,7 +83,7 @@ impl PadTemplate {
presence: PadPresence,
caps: &'a Caps,
) -> PadTemplateBuilder<'a> {
assert_initialized_main_thread!();
skip_assert_initialized!();
PadTemplateBuilder {
name_template,

4
gstreamer/src/param_spec.rs
View file

@ -127,7 +127,7 @@ pub struct ParamSpecFractionBuilder<'a> {
impl<'a> ParamSpecFractionBuilder<'a> {
fn new(name: &'a str) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self {
name,
..Default::default()
@ -292,7 +292,7 @@ pub struct ParamSpecArrayBuilder<'a> {
impl<'a> ParamSpecArrayBuilder<'a> {
fn new(name: &'a str) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self {
name,
..Default::default()

10
gstreamer/src/query.rs
View file

@ -274,7 +274,7 @@ macro_rules! declare_concrete_query(
impl DerefMut for $name<Query> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
assert!(self.0.is_writable());
debug_assert!(self.0.is_writable());
unsafe { &mut *(self.0.as_mut_ptr() as *mut Self::Target) }
}
}
@ -931,7 +931,7 @@ declare_concrete_query!(Custom, T);
impl Custom<Query> {
#[doc(alias = "gst_query_new_custom")]
pub fn new(structure: crate::Structure) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
Self(from_glib_full(ffi::gst_query_new_custom(
ffi::GST_QUERY_CUSTOM,
@ -1020,7 +1020,7 @@ declare_concrete_query!(Allocation, T);
impl Allocation<Query> {
#[doc(alias = "gst_query_new_allocation")]
pub fn new(caps: &crate::Caps, need_pool: bool) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
Self(from_glib_full(ffi::gst_query_new_allocation(
caps.as_mut_ptr(),
@ -1386,7 +1386,7 @@ declare_concrete_query!(AcceptCaps, T);
impl AcceptCaps<Query> {
#[doc(alias = "gst_query_new_accept_caps")]
pub fn new(caps: &crate::Caps) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
Self(from_glib_full(ffi::gst_query_new_accept_caps(
caps.as_mut_ptr(),
@ -1434,7 +1434,7 @@ declare_concrete_query!(Caps, T);
impl Caps<Query> {
#[doc(alias = "gst_query_new_caps")]
pub fn new(filter: Option<&crate::Caps>) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
Self(from_glib_full(ffi::gst_query_new_caps(
filter.to_glib_none().0,

4
gstreamer/src/sample.rs
View file

@ -63,8 +63,6 @@ impl<'a> SampleBuilder<'a> {
#[must_use = "Building the sample without using it has no effect"]
pub fn build(self) -> Sample {
assert_initialized_main_thread!();
unsafe {
let info = self
.info
@ -92,6 +90,8 @@ impl<'a> SampleBuilder<'a> {
impl Sample {
pub fn builder<'a>() -> SampleBuilder<'a> {
assert_initialized_main_thread!();
SampleBuilder {
buffer: None,
buffer_list: None,

1
gstreamer/src/segment.rs
View file

@ -156,7 +156,6 @@ impl<T: FormattedValueIntrinsic> FormattedSegment<T> {
stop_type: SeekType,
stop: impl CompatibleFormattedValue<T>,
) -> Option<bool> {
skip_assert_initialized!();
let start = start.try_into_checked_explicit(self.format()).unwrap();
let stop = stop.try_into_checked_explicit(self.format()).unwrap();

6
gstreamer/src/static_caps.rs
View file

@ -124,7 +124,7 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticCaps> for StaticCap
impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstStaticCaps) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
StaticCaps(ptr::NonNull::new_unchecked(ptr as *mut _))
}
}
@ -133,7 +133,7 @@ impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticCaps> for StaticCaps
impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstStaticCaps) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
StaticCaps(ptr::NonNull::new_unchecked(ptr))
}
}
@ -142,7 +142,7 @@ impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticCaps> for StaticCaps {
impl glib::translate::FromGlibPtrBorrow<*mut ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstStaticCaps) -> Borrowed<Self> {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Borrowed::new(StaticCaps(ptr::NonNull::new_unchecked(ptr)))
}
}

6
gstreamer/src/static_pad_template.rs
View file

@ -160,7 +160,7 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticPadTemplate> for St
impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstStaticPadTemplate) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
StaticPadTemplate(ptr::NonNull::new_unchecked(ptr as *mut _))
}
}
@ -169,7 +169,7 @@ impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticPadTemplate> for Stat
impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstStaticPadTemplate) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
StaticPadTemplate(ptr::NonNull::new_unchecked(ptr))
}
}
@ -178,7 +178,7 @@ impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticPadTemplate> for Static
impl glib::translate::FromGlibPtrBorrow<*mut ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstStaticPadTemplate) -> Borrowed<Self> {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Borrowed::new(StaticPadTemplate(ptr::NonNull::new_unchecked(ptr)))
}
}

30
gstreamer/src/structure.rs
View file

@ -51,7 +51,7 @@ unsafe impl Sync for Structure {}
impl Structure {
#[doc(alias = "gst_structure_new")]
pub fn builder(name: &str) -> Builder {
assert_initialized_main_thread!();
skip_assert_initialized!();
Builder::new(name)
}
@ -60,14 +60,14 @@ impl Structure {
assert_initialized_main_thread!();
unsafe {
let ptr = ffi::gst_structure_new_empty(name.to_glib_none().0);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
#[doc(alias = "gst_structure_new")]
pub fn new(name: &str, values: &[(&str, &(dyn ToSendValue + Sync))]) -> Structure {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut structure = Structure::new_empty(name);
for &(f, v) in values {
@ -82,7 +82,7 @@ impl Structure {
name: &str,
iter: impl IntoIterator<Item = (&'a str, SendValue)>,
) -> Structure {
assert_initialized_main_thread!();
skip_assert_initialized!();
let mut structure = Structure::new_empty(name);
iter.into_iter()
@ -135,7 +135,7 @@ impl Clone for Structure {
fn clone(&self) -> Self {
unsafe {
let ptr = ffi::gst_structure_copy(self.0.as_ref());
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
@ -219,7 +219,7 @@ impl ToOwned for StructureRef {
fn to_owned(&self) -> Structure {
unsafe {
let ptr = ffi::gst_structure_copy(&self.0);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
@ -277,9 +277,9 @@ impl<'a> ToGlibPtrMut<'a, *mut ffi::GstStructure> for Structure {
impl FromGlibPtrNone<*const ffi::GstStructure> for Structure {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let ptr = ffi::gst_structure_copy(ptr);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
@ -287,9 +287,9 @@ impl FromGlibPtrNone<*const ffi::GstStructure> for Structure {
impl FromGlibPtrNone<*mut ffi::GstStructure> for Structure {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
let ptr = ffi::gst_structure_copy(ptr);
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
@ -297,7 +297,7 @@ impl FromGlibPtrNone<*mut ffi::GstStructure> for Structure {
impl FromGlibPtrFull<*const ffi::GstStructure> for Structure {
#[inline]
unsafe fn from_glib_full(ptr: *const ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr as *mut ffi::GstStructure))
}
}
@ -305,7 +305,7 @@ impl FromGlibPtrFull<*const ffi::GstStructure> for Structure {
impl FromGlibPtrFull<*mut ffi::GstStructure> for Structure {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr))
}
}
@ -404,14 +404,14 @@ unsafe impl Sync for StructureRef {}
impl StructureRef {
#[inline]
pub unsafe fn from_glib_borrow<'a>(ptr: *const ffi::GstStructure) -> &'a StructureRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&*(ptr as *mut StructureRef)
}
#[inline]
pub unsafe fn from_glib_borrow_mut<'a>(ptr: *mut ffi::GstStructure) -> &'a mut StructureRef {
assert!(!ptr.is_null());
debug_assert!(!ptr.is_null());
&mut *(ptr as *mut StructureRef)
}
@ -631,7 +631,7 @@ impl StructureRef {
unsafe {
let field_name = ffi::gst_structure_nth_field_name(&self.0, idx);
assert!(!field_name.is_null());
debug_assert!(!field_name.is_null());
Some(CStr::from_ptr(field_name).to_str().unwrap())
}

2
gstreamer/src/tags.rs
View file

@ -465,7 +465,7 @@ impl TagListRef {
unsafe {
let name = ffi::gst_tag_list_nth_tag_name(self.as_ptr(), idx);
assert!(!name.is_null());
debug_assert!(!name.is_null());
Some(CStr::from_ptr(name).to_str().unwrap())
}
}

2
gstreamer/src/task_pool.rs
View file

@ -37,7 +37,7 @@ impl<O: IsA<TaskPool>> TaskPoolExtManual for O {
);
if !error.is_null() {
assert!(handle.is_null());
debug_assert!(handle.is_null());
// Assume that task_pool_trampoline was
// not called and will not be called

2
gstreamer/src/tracer.rs
View file

@ -11,7 +11,7 @@ impl Tracer {
name: &str,
type_: glib::types::Type,
) -> Result<(), glib::error::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
glib::result_from_gboolean!(
ffi::gst_tracer_register(

2
gstreamer/src/typefind.rs
View file

@ -33,7 +33,7 @@ impl TypeFind {
where
F: Fn(&mut TypeFind) + Send + Sync + 'static,
{
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let func: Box<F> = Box::new(func);
let func = Box::into_raw(func);

44
gstreamer/src/value.rs
View file

@ -11,17 +11,17 @@ pub struct Fraction(pub Rational32);
impl Fraction {
#[inline]
pub fn new(num: i32, den: i32) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
(num, den).into()
}
pub fn approximate_f32(x: f32) -> Option<Self> {
assert_initialized_main_thread!();
skip_assert_initialized!();
Rational32::approximate_float(x).map(|r| r.into())
}
pub fn approximate_f64(x: f64) -> Option<Self> {
assert_initialized_main_thread!();
skip_assert_initialized!();
Rational32::approximate_float(x).map(|r| r.into())
}
@ -232,7 +232,7 @@ impl ops::Neg for &Fraction {
impl From<i32> for Fraction {
#[inline]
fn from(x: i32) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Fraction(x.into())
}
}
@ -240,7 +240,7 @@ impl From<i32> for Fraction {
impl From<(i32, i32)> for Fraction {
#[inline]
fn from(x: (i32, i32)) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Fraction(x.into())
}
}
@ -256,7 +256,7 @@ impl From<Fraction> for (i32, i32) {
impl From<Rational32> for Fraction {
#[inline]
fn from(x: Rational32) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Fraction(x)
}
}
@ -357,7 +357,7 @@ impl IntRangeType for i32 {
#[inline]
fn with_step(min: i32, max: i32, step: i32) -> IntRange<Self> {
assert_initialized_main_thread!();
skip_assert_initialized!();
assert!(min <= max);
assert!(step > 0);
@ -375,7 +375,7 @@ impl IntRangeType for i64 {
#[inline]
fn with_step(min: i64, max: i64, step: i64) -> IntRange<Self> {
assert_initialized_main_thread!();
skip_assert_initialized!();
assert!(min <= max);
assert!(step > 0);
@ -387,13 +387,13 @@ impl IntRangeType for i64 {
impl<T: IntRangeType> IntRange<T> {
#[inline]
pub fn new(min: T, max: T) -> IntRange<T> {
assert_initialized_main_thread!();
skip_assert_initialized!();
T::with_min_max(min, max)
}
#[inline]
pub fn with_step(min: T, max: T, step: T) -> IntRange<T> {
assert_initialized_main_thread!();
skip_assert_initialized!();
T::with_step(min, max, step)
}
}
@ -548,7 +548,7 @@ pub struct FractionRange {
impl FractionRange {
#[inline]
pub fn new<T: Into<Fraction>, U: Into<Fraction>>(min: T, max: U) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
let min = min.into();
let max = max.into();
@ -644,7 +644,7 @@ pub struct Bitmask(pub u64);
impl Bitmask {
#[inline]
pub fn new(v: u64) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Bitmask(v)
}
}
@ -783,7 +783,7 @@ impl Array {
}
pub fn from_values(values: impl IntoIterator<Item = glib::SendValue>) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self::new(values)
}
@ -817,7 +817,7 @@ impl Array {
impl Default for Array {
fn default() -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let value = glib::Value::for_value_type::<Array>();
@ -845,7 +845,7 @@ impl AsRef<[glib::SendValue]> for Array {
impl std::iter::FromIterator<glib::SendValue> for Array {
fn from_iter<T: IntoIterator<Item = glib::SendValue>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self::from_values(iter)
}
}
@ -903,7 +903,7 @@ unsafe impl<'a> Sync for ArrayRef<'a> {}
impl<'a> ArrayRef<'a> {
pub fn new(values: &'a [glib::SendValue]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self(values)
}
@ -1010,7 +1010,7 @@ impl List {
}
pub fn from_values(values: impl IntoIterator<Item = glib::SendValue>) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self::new(values)
}
@ -1044,7 +1044,7 @@ impl List {
impl Default for List {
fn default() -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let value = glib::Value::for_value_type::<List>();
@ -1072,7 +1072,7 @@ impl AsRef<[glib::SendValue]> for List {
impl std::iter::FromIterator<glib::SendValue> for List {
fn from_iter<T: IntoIterator<Item = glib::SendValue>>(iter: T) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self::from_values(iter)
}
}
@ -1130,7 +1130,7 @@ unsafe impl<'a> Sync for ListRef<'a> {}
impl<'a> ListRef<'a> {
pub fn new(values: &'a [glib::SendValue]) -> Self {
assert_initialized_main_thread!();
skip_assert_initialized!();
Self(values)
}
@ -1384,7 +1384,7 @@ impl GstValueExt for glib::Value {
}
fn deserialize(s: &str, type_: glib::Type) -> Result<glib::Value, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut value = glib::Value::from_type(type_);
@ -1406,7 +1406,7 @@ impl GstValueExt for glib::Value {
s: &str,
pspec: &glib::ParamSpec,
) -> Result<glib::Value, glib::BoolError> {
assert_initialized_main_thread!();
skip_assert_initialized!();
unsafe {
let mut value = glib::Value::from_type_unchecked(pspec.value_type());