gstreamer*: Add missing init checks

gstreamer-app/src/app_sink.rs

@@ -146,6 +146,7 @@ impl AppSinkCallbacksBuilder {
 }
 
 fn post_panic_error_message(element: &AppSink, err: &dyn std::any::Any) {
+    skip_assert_initialized!();
     if let Some(cause) = err.downcast_ref::<&str>() {
         gst_element_error!(&element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
     } else if let Some(cause) = err.downcast_ref::<String>() {

gstreamer-app/src/app_src.rs

@@ -118,6 +118,7 @@ impl AppSrcCallbacksBuilder {
 }
 
 fn post_panic_error_message(element: &AppSrc, err: &dyn std::any::Any) {
+    skip_assert_initialized!();
     if let Some(cause) = err.downcast_ref::<&str>() {
         gst_element_error!(&element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
     } else if let Some(cause) = err.downcast_ref::<String>() {

gstreamer-audio/src/audio_meta.rs

@@ -27,6 +27,7 @@ impl AudioClippingMeta {
         start: V,
         end: V,
     ) -> gst::MetaRefMut<Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         let start = start.into();
         let end = end.into();
         assert_eq!(start.get_format(), end.get_format());

gstreamer-base/src/base_parse_frame.rs

@@ -49,6 +49,7 @@ impl ToGlib for Overhead {
 impl FromGlib<i32> for Overhead {
     #[inline]
     fn from_glib(val: i32) -> Overhead {
+        skip_assert_initialized!();
         match val {
             0 => Overhead::None,
             1 => Overhead::Frame,
@@ -94,6 +95,7 @@ impl<'a> BaseParseFrame<'a> {
         frame: *mut gst_base_sys::GstBaseParseFrame,
         _parse: &'a BaseParse,
     ) -> BaseParseFrame<'a> {
+        skip_assert_initialized!();
         assert!(!frame.is_null());
         BaseParseFrame(ptr::NonNull::new_unchecked(frame), PhantomData)
     }

gstreamer-base/src/utils.rs

@@ -15,6 +15,7 @@ pub struct MutexGuard<'a>(&'a glib_sys::GMutex);
 impl<'a> MutexGuard<'a> {
     #[allow(clippy::trivially_copy_pass_by_ref)]
     pub fn lock(mutex: &'a glib_sys::GMutex) -> Self {
+        skip_assert_initialized!();
         unsafe {
             glib_sys::g_mutex_lock(mut_override(mutex));
         }

gstreamer-editing-services/src/lib.rs

@@ -75,6 +75,7 @@ pub use auto::*;
 #[macro_use]
 extern crate bitflags;
 
+mod asset;
 mod timeline_element;
 pub use timeline_element::TimelineElementExtManual;
 

gstreamer-gl/src/gl_context.rs

@@ -31,6 +31,7 @@ impl GLContext {
     }
 
     pub fn get_current_gl_context(context_type: GLPlatform) -> uintptr_t {
+        skip_assert_initialized!();
         unsafe {
             gst_gl_sys::gst_gl_context_get_current_gl_context(context_type.to_glib()) as uintptr_t
         }
@@ -41,6 +42,7 @@ impl GLContext {
         gl_api: GLAPI,
         name: &str,
     ) -> uintptr_t {
+        skip_assert_initialized!();
         unsafe {
             gst_gl_sys::gst_gl_context_get_proc_address_with_platform(
                 context_type.to_glib(),

gstreamer-gl/src/gl_sync_meta.rs

@@ -19,6 +19,7 @@ impl GLSyncMeta {
         buffer: &'a mut gst::BufferRef,
         context: &C,
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_gl_sys::gst_buffer_add_gl_sync_meta(
                 context.as_ref().to_glib_none().0,

gstreamer-gl/src/gl_video_frame.rs

@@ -39,6 +39,7 @@ impl VideoFrameGLExt for VideoFrame<Readable> {
         buffer: gst::Buffer,
         info: &VideoInfo,
     ) -> Result<VideoFrame<Readable>, gst::Buffer> {
+        skip_assert_initialized!();
         VideoFrameRef::<&gst::BufferRef>::from_buffer_readable_gl(buffer, info)
     }
 
@@ -46,6 +47,7 @@ impl VideoFrameGLExt for VideoFrame<Readable> {
         buffer: &'a gst::BufferRef,
         info: &'b VideoInfo,
     ) -> Result<VideoFrameRef<&'a gst::BufferRef>, glib::error::BoolError> {
+        skip_assert_initialized!();
         VideoFrameRef::<&gst::BufferRef>::from_buffer_ref_readable_gl(buffer, info)
     }
 
@@ -153,6 +155,7 @@ impl<'a> VideoFrameGLExt for VideoFrameRef<&'a gst::BufferRef> {
 }
 
 fn buffer_n_gl_memory(buffer: &gst::BufferRef) -> Option<u32> {
+    skip_assert_initialized!();
     unsafe {
         let buf = buffer.as_mut_ptr();
         let num = gst_sys::gst_buffer_n_memory(buf);

gstreamer-net/src/lib.rs

@@ -24,6 +24,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)]

gstreamer-net/src/net_address_meta.rs

@@ -18,6 +18,7 @@ impl NetAddressMeta {
         buffer: &'a mut gst::BufferRef,
         addr: &A,
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_net_sys::gst_buffer_add_net_address_meta(
                 buffer.as_mut_ptr(),

gstreamer-pbutils/src/encoding_profile.rs

@@ -362,6 +362,7 @@ fn set_common_fields<T: EncodingProfileBuilderCommon>(
     profile: &T,
     base_data: &EncodingProfileBuilderCommonData,
 ) {
+    skip_assert_initialized!();
     profile.set_name(base_data.name);
     profile.set_description(base_data.description);
     profile.set_preset(base_data.preset);

gstreamer-rtp/src/rtp_buffer.rs

@@ -32,6 +32,7 @@ impl<'a> RTPBuffer<'a, Readable> {
     pub fn from_buffer_readable(
         buffer: &gst::Buffer,
     ) -> Result<RTPBuffer<Readable>, glib::BoolError> {
+        skip_assert_initialized!();
         unsafe {
             let mut rtp_buffer = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_rtp_sys::gst_rtp_buffer_map(
@@ -57,6 +58,7 @@ impl<'a> RTPBuffer<'a, Writable> {
     pub fn from_buffer_writable(
         buffer: &mut gst::Buffer,
     ) -> Result<RTPBuffer<Writable>, glib::BoolError> {
+        skip_assert_initialized!();
         unsafe {
             let mut rtp_buffer = mem::MaybeUninit::zeroed();
             let res: bool = from_glib(gst_rtp_sys::gst_rtp_buffer_map(
@@ -132,6 +134,7 @@ impl RTPBufferExt for gst::Buffer {
         pad_len: u8,
         csrc_count: u8,
     ) -> Result<gst::Buffer, glib::BoolError> {
+        assert_initialized_main_thread!();
         unsafe {
             Option::<_>::from_glib_full(gst_rtp_sys::gst_rtp_buffer_new_allocate(
                 payload_len,
@@ -144,6 +147,7 @@ impl RTPBufferExt for gst::Buffer {
 }
 
 pub fn compare_seqnum(seqnum1: u16, seqnum2: u16) -> i32 {
+    skip_assert_initialized!();
     unsafe { gst_rtp_sys::gst_rtp_buffer_compare_seqnum(seqnum1, seqnum2) }
 }
 

gstreamer-rtsp-server/src/rtsp_thread.rs

@@ -14,6 +14,7 @@ gst_define_mini_object_wrapper!(
 
 impl RTSPThread {
     pub fn new(type_: ::RTSPThreadType) -> Option<Self> {
+        assert_initialized_main_thread!();
         unsafe { from_glib_full(gst_rtsp_server_sys::gst_rtsp_thread_new(type_.to_glib())) }
     }
 }

gstreamer-rtsp-server/src/rtsp_token.rs

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

gstreamer-video/src/functions.rs

@@ -22,6 +22,7 @@ pub fn convert_sample(
     caps: &gst::Caps,
     timeout: gst::ClockTime,
 ) -> Result<gst::Sample, glib::Error> {
+    skip_assert_initialized!();
     unsafe {
         let mut error = ptr::null_mut();
         let ret = gst_video_sys::gst_video_convert_sample(
@@ -47,6 +48,7 @@ pub fn convert_sample_async<F>(
 ) where
     F: FnOnce(Result<gst::Sample, glib::Error>) + Send + 'static,
 {
+    skip_assert_initialized!();
     unsafe { convert_sample_async_unsafe(sample, caps, timeout, func) }
 }
 
@@ -58,6 +60,7 @@ pub fn convert_sample_async_local<F>(
 ) where
     F: FnOnce(Result<gst::Sample, glib::Error>) + Send + 'static,
 {
+    skip_assert_initialized!();
     unsafe {
         assert!(glib::MainContext::ref_thread_default().is_owner());
         convert_sample_async_unsafe(sample, caps, timeout, func)
@@ -113,6 +116,8 @@ pub fn convert_sample_future(
     timeout: gst::ClockTime,
 ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<gst::Sample, glib::Error>> + 'static>>
 {
+    skip_assert_initialized!();
+
     use futures_channel::oneshot;
     use futures_util::future::lazy;
     use futures_util::future::FutureExt;

gstreamer-video/src/video_codec_frame.rs

@@ -69,6 +69,7 @@ impl<'a> VideoCodecFrame<'a> {
         frame: *mut gst_video_sys::GstVideoCodecFrame,
         element: &'a T,
     ) -> Self {
+        skip_assert_initialized!();
         let stream_lock = element.get_stream_lock();
         glib_sys::g_rec_mutex_lock(stream_lock);
         Self { frame, element }

gstreamer-video/src/video_codec_state.rs

@@ -73,6 +73,7 @@ impl<'a, T: VideoCodecStateContext<'a>> fmt::Debug for VideoCodecState<'a, T> {
 impl<'a> VideoCodecState<'a, Readable> {
     // Take ownership of @state
     pub(crate) unsafe fn new(state: *mut gst_video_sys::GstVideoCodecState) -> Self {
+        skip_assert_initialized!();
         Self {
             state,
             context: Readable {},
@@ -87,6 +88,7 @@ impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
         state: *mut gst_video_sys::GstVideoCodecState,
         element: &'a T,
     ) -> Self {
+        skip_assert_initialized!();
         let stream_lock = element.get_stream_lock();
         glib_sys::g_rec_mutex_lock(stream_lock);
         Self {

gstreamer-video/src/video_converter.rs

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

gstreamer-video/src/video_event.rs

@@ -16,6 +16,7 @@ use gst::MiniObject;
 use std::mem;
 
 pub fn is_force_key_unit_event(event: &gst::EventRef) -> bool {
+    skip_assert_initialized!();
     unsafe {
         from_glib(gst_video_sys::gst_video_event_is_force_key_unit(
             event.as_mut_ptr(),
@@ -159,6 +160,7 @@ pub struct DownstreamForceKeyUnitEvent {
 pub fn parse_downstream_force_key_unit_event(
     event: &gst::EventRef,
 ) -> Result<DownstreamForceKeyUnitEvent, glib::error::BoolError> {
+    skip_assert_initialized!();
     unsafe {
         let mut timestamp = mem::MaybeUninit::uninit();
         let mut stream_time = mem::MaybeUninit::uninit();
@@ -253,6 +255,7 @@ pub struct UpstreamForceKeyUnitEvent {
 pub fn parse_upstream_force_key_unit_event(
     event: &gst::EventRef,
 ) -> Result<UpstreamForceKeyUnitEvent, glib::error::BoolError> {
+    skip_assert_initialized!();
     unsafe {
         let mut running_time = mem::MaybeUninit::uninit();
         let mut all_headers = mem::MaybeUninit::uninit();
@@ -287,6 +290,7 @@ pub enum ForceKeyUnitEvent {
 pub fn parse_force_key_unit_event(
     event: &gst::EventRef,
 ) -> Result<ForceKeyUnitEvent, glib::error::BoolError> {
+    skip_assert_initialized!();
     if event.is_upstream() {
         parse_upstream_force_key_unit_event(event).map(ForceKeyUnitEvent::Upstream)
     } else {
@@ -295,6 +299,7 @@ pub fn parse_force_key_unit_event(
 }
 
 pub fn new_still_frame_event<'a>(in_still: bool) -> StillFrameEventBuilder<'a> {
+    assert_initialized_main_thread!();
     StillFrameEventBuilder::new(in_still)
 }
 
@@ -329,6 +334,7 @@ pub struct StillFrameEvent {
 pub fn parse_still_frame_event(
     event: &gst::EventRef,
 ) -> Result<StillFrameEvent, glib::error::BoolError> {
+    skip_assert_initialized!();
     unsafe {
         let mut in_still = mem::MaybeUninit::uninit();
 

gstreamer-video/src/video_info.rs

@@ -189,6 +189,7 @@ impl fmt::Display for ::VideoColorimetry {
 
 impl From<::VideoMultiviewFramePacking> for ::VideoMultiviewMode {
     fn from(v: ::VideoMultiviewFramePacking) -> Self {
+        skip_assert_initialized!();
         from_glib(v.to_glib())
     }
 }
@@ -199,6 +200,8 @@ impl std::convert::TryFrom<::VideoMultiviewMode> for ::VideoMultiviewFramePackin
     fn try_from(
         v: ::VideoMultiviewMode,
     ) -> Result<::VideoMultiviewFramePacking, ::VideoMultiviewMode> {
+        skip_assert_initialized!();
+
         let v2 = from_glib(v.to_glib());
 
         if let ::VideoMultiviewFramePacking::__Unknown(_) = v2 {

gstreamer-video/src/video_meta.rs

@@ -29,6 +29,8 @@ impl VideoMeta {
         width: u32,
         height: u32,
     ) -> gst::MetaRefMut<Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
+
         let info = ::VideoInfo::new(format, width, height).build().unwrap();
         assert!(buffer.get_size() >= info.size());
 
@@ -54,6 +56,8 @@ impl VideoMeta {
         offset: &[usize],
         stride: &[i32],
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
+
         let n_planes = offset.len() as u32;
         let info = ::VideoInfo::new(format, width, height)
             .offset(offset)
@@ -145,6 +149,7 @@ impl VideoOverlayCompositionMeta {
         buffer: &'a mut gst::BufferRef,
         overlay: &::VideoOverlayComposition,
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_video_sys::gst_buffer_add_video_overlay_composition_meta(
                 buffer.as_mut_ptr(),
@@ -204,6 +209,7 @@ impl VideoCaptionMeta {
         caption_type: ::VideoCaptionType,
         data: &[u8],
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_video_sys::gst_buffer_add_video_caption_meta(
                 buffer.as_mut_ptr(),

gstreamer-video/src/video_overlay.rs

@@ -31,6 +31,7 @@ impl<O: IsA<VideoOverlay>> VideoOverlayExtManual for O {
 }
 
 pub fn is_video_overlay_prepare_window_handle_message(msg: &gst::MessageRef) -> bool {
+    skip_assert_initialized!();
     unsafe {
         from_glib(
             gst_video_sys::gst_is_video_overlay_prepare_window_handle_message(msg.as_mut_ptr()),

gstreamer-video/src/video_overlay_composition.rs

@@ -43,6 +43,7 @@ impl VideoOverlayRectangle {
         render_height: u32,
         flags: ::VideoOverlayFormatFlags,
     ) -> Self {
+        assert_initialized_main_thread!();
         assert!(buffer.get_meta::<::VideoMeta>().is_some());
         unsafe {
             from_glib_full(gst_video_sys::gst_video_overlay_rectangle_new_raw(
@@ -201,6 +202,7 @@ impl VideoOverlayComposition {
     pub fn new<'a, T: IntoIterator<Item = &'a VideoOverlayRectangle>>(
         rects: T,
     ) -> Result<Self, glib::error::BoolError> {
+        assert_initialized_main_thread!();
         unsafe {
             let mut iter = rects.into_iter();
 

gstreamer-video/src/video_rectangle.rs

@@ -19,6 +19,7 @@ pub struct VideoRectangle {
 
 impl VideoRectangle {
     pub fn new(x: i32, y: i32, w: i32, h: i32) -> Self {
+        skip_assert_initialized!();
         VideoRectangle { x, y, w, h }
     }
 }
@@ -28,6 +29,7 @@ pub fn center_video_rectangle(
     dst: &VideoRectangle,
     scale: bool,
 ) -> VideoRectangle {
+    skip_assert_initialized!();
     let mut result = gst_video_sys::GstVideoRectangle {
         x: 0,
         y: 0,

gstreamer-video/src/video_time_code.rs

@@ -144,6 +144,7 @@ impl TryFrom<VideoTimeCode> for ValidVideoTimeCode {
     type Error = VideoTimeCode;
 
     fn try_from(v: VideoTimeCode) -> Result<ValidVideoTimeCode, VideoTimeCode> {
+        skip_assert_initialized!();
         if v.is_valid() {
             Ok(ValidVideoTimeCode(v.0))
         } else {
@@ -164,6 +165,7 @@ impl ValidVideoTimeCode {
         frames: u32,
         field_count: u32,
     ) -> Result<Self, glib::error::BoolError> {
+        assert_initialized_main_thread!();
         let tc = VideoTimeCode::new(
             fps,
             latest_daily_jam,
@@ -192,6 +194,7 @@ impl ValidVideoTimeCode {
     //    }
 
     pub fn add_frames(&mut self, frames: i64) {
+        skip_assert_initialized!();
         unsafe {
             gst_video_sys::gst_video_time_code_add_frames(self.to_glib_none_mut().0, frames);
         }
@@ -517,6 +520,7 @@ impl Ord for ValidVideoTimeCode {
 
 impl From<ValidVideoTimeCode> for VideoTimeCode {
     fn from(v: ValidVideoTimeCode) -> VideoTimeCode {
+        skip_assert_initialized!();
         VideoTimeCode(v.0)
     }
 }
@@ -532,6 +536,7 @@ impl VideoTimeCodeMeta {
         buffer: &'a mut gst::BufferRef,
         tc: &ValidVideoTimeCode,
     ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_video_sys::gst_buffer_add_video_time_code_meta(
                 buffer.as_mut_ptr(),

gstreamer/src/allocation_params.rs

@@ -58,6 +58,7 @@ impl AllocationParams {
 
 impl From<gst_sys::GstAllocationParams> for AllocationParams {
     fn from(params: gst_sys::GstAllocationParams) -> Self {
+        skip_assert_initialized!();
         AllocationParams(params)
     }
 }

gstreamer/src/buffer_cursor.rs

@@ -286,6 +286,7 @@ impl<T> BufferCursor<T> {
 
 impl BufferCursor<Readable> {
     pub(crate) fn new_readable(buffer: Buffer) -> BufferCursor<Readable> {
+        skip_assert_initialized!();
         let size = buffer.get_size() as u64;
         let num_mem = buffer.n_memory();
 
@@ -304,6 +305,7 @@ impl BufferCursor<Readable> {
 
 impl BufferCursor<Writable> {
     pub(crate) fn new_writable(buffer: Buffer) -> Result<BufferCursor<Writable>, glib::BoolError> {
+        skip_assert_initialized!();
         if !buffer.is_writable() || !buffer.is_all_memory_writable() {
             return Err(glib_bool_error!("Not all memories are writable"));
         }
@@ -383,6 +385,7 @@ impl<'a> BufferRefCursor<&'a BufferRef> {
     }
 
     pub(crate) fn new_readable(buffer: &'a BufferRef) -> BufferRefCursor<&'a BufferRef> {
+        skip_assert_initialized!();
         let size = buffer.get_size() as u64;
         let num_mem = buffer.n_memory();
 
@@ -406,6 +409,7 @@ impl<'a> BufferRefCursor<&'a mut BufferRef> {
     pub(crate) fn new_writable(
         buffer: &'a mut BufferRef,
     ) -> Result<BufferRefCursor<&'a mut BufferRef>, glib::BoolError> {
+        skip_assert_initialized!();
         if !buffer.is_all_memory_writable() {
             return Err(glib_bool_error!("Not all memories are writable"));
         }

gstreamer/src/buffer_pool.rs

@@ -192,6 +192,7 @@ unsafe impl Sync for BufferPoolAcquireParams {}
 
 impl BufferPoolAcquireParams {
     pub fn with_flags(flags: ::BufferPoolAcquireFlags) -> Self {
+        skip_assert_initialized!();
         BufferPoolAcquireParams(gst_sys::GstBufferPoolAcquireParams {
             format: gst_sys::GST_FORMAT_UNDEFINED,
             start: -1,
@@ -206,6 +207,7 @@ impl BufferPoolAcquireParams {
         stop: T,
         flags: ::BufferPoolAcquireFlags,
     ) -> Self {
+        skip_assert_initialized!();
         unsafe {
             BufferPoolAcquireParams(gst_sys::GstBufferPoolAcquireParams {
                 format: start.get_format().to_glib(),

gstreamer/src/buffer_serde.rs

@@ -57,6 +57,7 @@ struct BufferDe {
 
 impl From<BufferDe> for Buffer {
     fn from(buf_de: BufferDe) -> Self {
+        skip_assert_initialized!();
         let mut buffer = Buffer::from_mut_slice(buf_de.buffer.to_vec());
         {
             let buffer = buffer.get_mut().unwrap();
@@ -73,6 +74,7 @@ impl From<BufferDe> for Buffer {
 
 impl<'de> Deserialize<'de> for Buffer {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         BufferDe::deserialize(deserializer).map(|buffer_de| buffer_de.into())
     }
 }

gstreamer/src/bufferlist_serde.rs

@@ -60,6 +60,7 @@ impl<'de> Visitor<'de> for BufferListVisitor {
 
 impl<'de> Deserialize<'de> for BufferList {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(BufferListVisitor)
     }
 }

gstreamer/src/caps.rs

@@ -570,6 +570,7 @@ impl<T> fmt::Debug for Builder<T> {
 
 impl Builder<NoFeature> {
     fn new(name: &str) -> Builder<NoFeature> {
+        skip_assert_initialized!();
         Builder {
             s: ::Structure::new_empty(name),
             features: None,
@@ -639,6 +640,7 @@ impl BuilderFull<SomeFeatures> {
     }
 
     fn new_with_features(features: CapsFeatures) -> Self {
+        skip_assert_initialized!();
         BuilderFull {
             caps: Caps::new_empty(),
             features: Some(features),

gstreamer/src/caps_features.rs

@@ -32,6 +32,7 @@ unsafe impl Sync for CapsFeatures {}
 
 impl CapsFeatures {
     pub fn new(features: &[&str]) -> Self {
+        assert_initialized_main_thread!();
         let mut f = Self::new_empty();
 
         for feature in features {

gstreamer/src/caps_features_serde.rs

@@ -94,6 +94,7 @@ impl<'de> Visitor<'de> for CapsFeaturesSomeVisitor {
 
 impl<'de> Deserialize<'de> for CapsFeaturesSome {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<CapsFeaturesSome, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(CapsFeaturesSomeVisitor)
     }
 }
@@ -131,6 +132,7 @@ impl<'de> Visitor<'de> for CapsFeaturesVariantKindsVisitor {
 
 impl<'de> Deserialize<'de> for CapsFeaturesVariantKinds {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_identifier(CapsFeaturesVariantKindsVisitor)
     }
 }
@@ -157,6 +159,7 @@ impl<'de> Visitor<'de> for CapsFeaturesVisitor {
 
 impl<'de> Deserialize<'de> for CapsFeatures {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_enum(
             stringify!(Caps),
             CAPS_FEATURES_VARIANT_NAMES,

gstreamer/src/caps_serde.rs

@@ -128,6 +128,7 @@ impl<'de> Visitor<'de> for CapsItemVisitor {
 
 impl<'de> Deserialize<'de> for CapsItemDe {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<CapsItemDe, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_tuple(2, CapsItemVisitor)
     }
 }
@@ -156,6 +157,7 @@ impl<'de> Visitor<'de> for CapsSomeVisitor {
 
 impl<'de> Deserialize<'de> for CapsSome {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<CapsSome, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(CapsSomeVisitor)
     }
 }
@@ -192,6 +194,7 @@ impl<'de> Visitor<'de> for CapsVariantKindsVisitor {
 
 impl<'de> Deserialize<'de> for CapsVariantKinds {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_identifier(CapsVariantKindsVisitor)
     }
 }
@@ -219,6 +222,7 @@ impl<'de> Visitor<'de> for CapsVisitor {
 
 impl<'de> Deserialize<'de> for Caps {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_enum(stringify!(Caps), CAPS_VARIANT_NAMES, CapsVisitor)
     }
 }

gstreamer/src/clock.rs

@@ -188,6 +188,7 @@ impl Clock {
         cnum: ClockTime,
         cdenom: ClockTime,
     ) -> ClockTime {
+        skip_assert_initialized!();
         unsafe {
             from_glib(gst_sys::gst_clock_adjust_with_calibration(
                 ptr::null_mut(),
@@ -207,6 +208,7 @@ impl Clock {
         cnum: ClockTime,
         cdenom: ClockTime,
     ) -> ClockTime {
+        skip_assert_initialized!();
         unsafe {
             from_glib(gst_sys::gst_clock_unadjust_with_calibration(
                 ptr::null_mut(),

gstreamer/src/clock_time.rs

@@ -44,18 +44,22 @@ impl ClockTime {
     }
 
     pub fn from_seconds(seconds: u64) -> ClockTime {
+        skip_assert_initialized!();
         seconds * ::SECOND
     }
 
     pub fn from_mseconds(mseconds: u64) -> ClockTime {
+        skip_assert_initialized!();
         mseconds * ::MSECOND
     }
 
     pub fn from_useconds(useconds: u64) -> ClockTime {
+        skip_assert_initialized!();
         useconds * ::USECOND
     }
 
     pub fn from_nseconds(nseconds: u64) -> ClockTime {
+        skip_assert_initialized!();
         nseconds * ::NSECOND
     }
 

gstreamer/src/clock_time_serde.rs

@@ -45,6 +45,7 @@ impl<'de> Visitor<'de> for ClockTimeVisitor {
 
 impl<'de> Deserialize<'de> for ClockTime {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_option(ClockTimeVisitor)
     }
 }

gstreamer/src/date_time.rs

@@ -89,6 +89,7 @@ impl cmp::PartialOrd for DateTime {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         #[inline]
         fn get_cmp(delta: i32) -> Option<cmp::Ordering> {
+            skip_assert_initialized!();
             Some(delta.cmp(&0))
         }
 
@@ -235,6 +236,7 @@ impl<'a> convert::TryFrom<&'a glib::DateTime> for DateTime {
     type Error = glib::BoolError;
 
     fn try_from(v: &'a glib::DateTime) -> Result<DateTime, glib::BoolError> {
+        skip_assert_initialized!();
         DateTime::new_from_g_date_time(v)
     }
 }
@@ -243,6 +245,7 @@ impl convert::TryFrom<glib::DateTime> for DateTime {
     type Error = glib::BoolError;
 
     fn try_from(v: glib::DateTime) -> Result<DateTime, glib::BoolError> {
+        skip_assert_initialized!();
         DateTime::new_from_g_date_time(&v)
     }
 }
@@ -251,6 +254,7 @@ impl<'a> convert::TryFrom<&'a DateTime> for glib::DateTime {
     type Error = glib::BoolError;
 
     fn try_from(v: &'a DateTime) -> Result<glib::DateTime, glib::BoolError> {
+        skip_assert_initialized!();
         v.to_g_date_time()
     }
 }
@@ -259,6 +263,7 @@ impl convert::TryFrom<DateTime> for glib::DateTime {
     type Error = glib::BoolError;
 
     fn try_from(v: DateTime) -> Result<glib::DateTime, glib::BoolError> {
+        skip_assert_initialized!();
         v.to_g_date_time()
     }
 }

gstreamer/src/date_time_serde.rs

@@ -34,6 +34,7 @@ pub(crate) struct Date(glib::Date);
 
 impl From<glib::Date> for Date {
     fn from(glib_date: glib::Date) -> Self {
+        skip_assert_initialized!();
         Date(glib_date)
     }
 }
@@ -109,6 +110,7 @@ impl TryFrom<DateTimeVariants> for Date {
     type Error = &'static str;
 
     fn try_from(dt_variant: DateTimeVariants) -> Result<Self, Self::Error> {
+        skip_assert_initialized!();
         match dt_variant {
             DateTimeVariants::YMD(y, m, d) => {
                 let month = glib::DateMonth::from_glib(m);
@@ -129,6 +131,7 @@ impl TryFrom<DateTimeVariants> for Date {
 
 impl<'de> Deserialize<'de> for Date {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         DateTimeVariants::deserialize(deserializer)
             .and_then(|dt_variant| dt_variant.try_into().map_err(D::Error::custom))
     }
@@ -139,6 +142,7 @@ impl TryFrom<DateTimeVariants> for DateTime {
     type Error = glib::BoolError;
 
     fn try_from(dt_variant: DateTimeVariants) -> Result<Self, Self::Error> {
+        skip_assert_initialized!();
         match dt_variant {
             DateTimeVariants::Y(y) => DateTime::new_y(y),
             DateTimeVariants::YM(y, m) => DateTime::new_ym(y, m),
@@ -155,6 +159,7 @@ impl TryFrom<DateTimeVariants> for DateTime {
 
 impl<'de> Deserialize<'de> for DateTime {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         DateTimeVariants::deserialize(deserializer)
             .and_then(|dt_variant| dt_variant.try_into().map_err(D::Error::custom))
     }

gstreamer/src/enums.rs

@@ -33,10 +33,12 @@ impl StateChangeReturn {
     }
 
     pub fn from_error(_: StateChangeError) -> Self {
+        skip_assert_initialized!();
         StateChangeReturn::Failure
     }
 
     pub fn from_ok(v: StateChangeSuccess) -> Self {
+        skip_assert_initialized!();
         match v {
             StateChangeSuccess::Success => StateChangeReturn::Success,
             StateChangeSuccess::Async => StateChangeReturn::Async,
@@ -54,6 +56,7 @@ pub enum StateChangeSuccess {
 
 impl From<StateChangeSuccess> for StateChangeReturn {
     fn from(value: StateChangeSuccess) -> Self {
+        skip_assert_initialized!();
         StateChangeReturn::from_ok(value)
     }
 }
@@ -65,12 +68,14 @@ pub struct StateChangeError;
 
 impl From<StateChangeError> for StateChangeReturn {
     fn from(value: StateChangeError) -> Self {
+        skip_assert_initialized!();
         StateChangeReturn::from_error(value)
     }
 }
 
 impl From<Result<StateChangeSuccess, StateChangeError>> for StateChangeReturn {
     fn from(res: Result<StateChangeSuccess, StateChangeError>) -> Self {
+        skip_assert_initialized!();
         match res {
             Ok(success) => StateChangeReturn::from_ok(success),
             Err(error) => StateChangeReturn::from_error(error),
@@ -106,6 +111,7 @@ impl FlowReturn {
     }
 
     pub fn from_error(v: FlowError) -> Self {
+        skip_assert_initialized!();
         match v {
             FlowError::NotLinked => FlowReturn::NotLinked,
             FlowError::Flushing => FlowReturn::Flushing,
@@ -120,6 +126,7 @@ impl FlowReturn {
     }
 
     pub fn from_ok(v: FlowSuccess) -> Self {
+        skip_assert_initialized!();
         match v {
             FlowSuccess::CustomSuccess2 => FlowReturn::CustomSuccess2,
             FlowSuccess::CustomSuccess1 => FlowReturn::CustomSuccess1,
@@ -139,6 +146,7 @@ pub enum FlowSuccess {
 
 impl From<FlowSuccess> for FlowReturn {
     fn from(value: FlowSuccess) -> Self {
+        skip_assert_initialized!();
         FlowReturn::from_ok(value)
     }
 }
@@ -168,12 +176,14 @@ pub enum FlowError {
 
 impl From<FlowError> for FlowReturn {
     fn from(value: FlowError) -> Self {
+        skip_assert_initialized!();
         FlowReturn::from_error(value)
     }
 }
 
 impl From<Result<FlowSuccess, FlowError>> for FlowReturn {
     fn from(res: Result<FlowSuccess, FlowError>) -> Self {
+        skip_assert_initialized!();
         match res {
             Ok(success) => FlowReturn::from_ok(success),
             Err(error) => FlowReturn::from_error(error),
@@ -196,6 +206,7 @@ impl PadLinkReturn {
     }
 
     pub fn from_error(v: PadLinkError) -> Self {
+        skip_assert_initialized!();
         match v {
             PadLinkError::WrongHierarchy => PadLinkReturn::WrongHierarchy,
             PadLinkError::WasLinked => PadLinkReturn::WasLinked,
@@ -207,6 +218,7 @@ impl PadLinkReturn {
     }
 
     pub fn from_ok(_: PadLinkSuccess) -> Self {
+        skip_assert_initialized!();
         PadLinkReturn::Ok
     }
 }
@@ -216,6 +228,7 @@ pub struct PadLinkSuccess;
 
 impl From<PadLinkSuccess> for PadLinkReturn {
     fn from(value: PadLinkSuccess) -> Self {
+        skip_assert_initialized!();
         PadLinkReturn::from_ok(value)
     }
 }
@@ -239,12 +252,14 @@ pub enum PadLinkError {
 
 impl From<PadLinkError> for PadLinkReturn {
     fn from(value: PadLinkError) -> Self {
+        skip_assert_initialized!();
         PadLinkReturn::from_error(value)
     }
 }
 
 impl From<Result<PadLinkSuccess, PadLinkError>> for PadLinkReturn {
     fn from(res: Result<PadLinkSuccess, PadLinkError>) -> Self {
+        skip_assert_initialized!();
         match res {
             Ok(success) => PadLinkReturn::from_ok(success),
             Err(error) => PadLinkReturn::from_error(error),
@@ -268,6 +283,7 @@ impl ClockReturn {
     }
 
     pub fn from_error(v: ClockError) -> Self {
+        skip_assert_initialized!();
         match v {
             ClockError::Early => ClockReturn::Early,
             ClockError::Unscheduled => ClockReturn::Unscheduled,
@@ -279,6 +295,7 @@ impl ClockReturn {
     }
 
     pub fn from_ok(v: ClockSuccess) -> Self {
+        skip_assert_initialized!();
         match v {
             ClockSuccess::Ok => ClockReturn::Ok,
             ClockSuccess::Done => ClockReturn::Done,
@@ -294,6 +311,7 @@ pub enum ClockSuccess {
 
 impl From<ClockSuccess> for ClockReturn {
     fn from(value: ClockSuccess) -> Self {
+        skip_assert_initialized!();
         ClockReturn::from_ok(value)
     }
 }
@@ -317,12 +335,14 @@ pub enum ClockError {
 
 impl From<ClockError> for ClockReturn {
     fn from(value: ClockError) -> Self {
+        skip_assert_initialized!();
         ClockReturn::from_error(value)
     }
 }
 
 impl From<Result<ClockSuccess, ClockError>> for ClockReturn {
     fn from(res: Result<ClockSuccess, ClockError>) -> Self {
+        skip_assert_initialized!();
         match res {
             Ok(success) => ClockReturn::from_ok(success),
             Err(error) => ClockReturn::from_error(error),

gstreamer/src/error.rs

@@ -70,6 +70,7 @@ impl ErrorMessage {
         function: &'static str,
         line: u32,
     ) -> ErrorMessage {
+        assert_initialized_main_thread!();
         let error_domain = T::domain();
         let error_code = error.code();
 
@@ -122,6 +123,7 @@ pub struct LoggableError {
 
 impl LoggableError {
     pub fn new(category: ::DebugCategory, bool_error: glib::BoolError) -> LoggableError {
+        assert_initialized_main_thread!();
         LoggableError {
             category,
             bool_error,
@@ -157,6 +159,7 @@ impl LoggableError {
 
 impl From<glib::BoolError> for LoggableError {
     fn from(bool_error: glib::BoolError) -> Self {
+        skip_assert_initialized!();
         LoggableError {
             category: *::CAT_RUST,
             bool_error,

gstreamer/src/format.rs

@@ -77,6 +77,7 @@ impl FormattedValue for GenericFormattedValue {
 
 impl GenericFormattedValue {
     pub fn new(format: Format, value: i64) -> Self {
+        skip_assert_initialized!();
         match format {
             Format::Undefined => GenericFormattedValue::Undefined(Undefined(value)),
             Format::Default => GenericFormattedValue::Default(if value == -1 {
@@ -298,6 +299,7 @@ macro_rules! impl_format_value_traits(
 
         impl From<$name> for GenericFormattedValue {
             fn from(v: $name) -> GenericFormattedValue {
+	        skip_assert_initialized!();
                 GenericFormattedValue::$format_value(v)
             }
         }
@@ -306,6 +308,7 @@ macro_rules! impl_format_value_traits(
             type Error = TryFromGenericFormattedValueError;
 
             fn try_from(v: GenericFormattedValue) -> Result<$name, TryFromGenericFormattedValueError> {
+	        skip_assert_initialized!();
                 if let GenericFormattedValue::$format_value(v) = v {
                     Ok(v)
                 } else {
@@ -318,12 +321,14 @@ macro_rules! impl_format_value_traits(
 
         impl From<u64> for $name {
             fn from(v: u64) -> $name {
+	        skip_assert_initialized!();
                 $name(Some(v))
             }
         }
 
         impl From<Option<u64>> for $name {
             fn from(v: Option<u64>) -> $name {
+	        skip_assert_initialized!();
                 $name(v)
             }
         }
@@ -535,6 +540,7 @@ impl FormattedValue for Undefined {
 
 impl From<Undefined> for GenericFormattedValue {
     fn from(v: Undefined) -> GenericFormattedValue {
+        skip_assert_initialized!();
         GenericFormattedValue::Undefined(v)
     }
 }
@@ -543,6 +549,7 @@ impl TryFrom<GenericFormattedValue> for Undefined {
     type Error = TryFromGenericFormattedValueError;
 
     fn try_from(v: GenericFormattedValue) -> Result<Undefined, TryFromGenericFormattedValueError> {
+        skip_assert_initialized!();
         if let GenericFormattedValue::Undefined(v) = v {
             Ok(v)
         } else {
@@ -555,6 +562,7 @@ impl SpecificFormattedValue for Undefined {}
 
 impl From<i64> for Undefined {
     fn from(v: i64) -> Undefined {
+        skip_assert_initialized!();
         Undefined(v)
     }
 }
@@ -616,6 +624,7 @@ impl FormattedValue for Percent {
 
 impl From<Percent> for GenericFormattedValue {
     fn from(v: Percent) -> GenericFormattedValue {
+        skip_assert_initialized!();
         GenericFormattedValue::Percent(v)
     }
 }
@@ -624,6 +633,7 @@ impl TryFrom<GenericFormattedValue> for Percent {
     type Error = TryFromGenericFormattedValueError;
 
     fn try_from(v: GenericFormattedValue) -> Result<Percent, TryFromGenericFormattedValueError> {
+        skip_assert_initialized!();
         if let GenericFormattedValue::Percent(v) = v {
             Ok(v)
         } else {
@@ -675,6 +685,7 @@ impl TryFrom<f64> for Percent {
     type Error = TryPercentFromFloatError;
 
     fn try_from(v: f64) -> Result<Self, Self::Error> {
+        skip_assert_initialized!();
         if v < 0.0 || v > 1.0 {
             Err(TryPercentFromFloatError(()))
         } else {
@@ -689,6 +700,7 @@ impl TryFrom<f32> for Percent {
     type Error = TryPercentFromFloatError;
 
     fn try_from(v: f32) -> Result<Self, Self::Error> {
+        skip_assert_initialized!();
         if v < 0.0 || v > 1.0 {
             Err(TryPercentFromFloatError(()))
         } else {

gstreamer/src/format_serde.rs

@@ -24,6 +24,7 @@ macro_rules! impl_ser_de(
 
         impl<'de> Deserialize<'de> for $t {
             fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+	        skip_assert_initialized!();
                 Option::<u64>::deserialize(deserializer).map($t)
             }
         }
@@ -42,6 +43,7 @@ impl Serialize for Undefined {
 
 impl<'de> Deserialize<'de> for Undefined {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         i64::deserialize(deserializer).map(Undefined)
     }
 }
@@ -54,6 +56,7 @@ impl Serialize for Percent {
 
 impl<'de> Deserialize<'de> for Percent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         Option::<u32>::deserialize(deserializer).map(Percent)
     }
 }

gstreamer/src/functions.rs

@@ -88,6 +88,7 @@ pub fn calculate_linear_regression(
     xy: &[(u64, u64)],
     temp: Option<&mut [(u64, u64)]>,
 ) -> Option<(u64, u64, u64, u64, f64)> {
+    skip_assert_initialized!();
     use std::mem;
 
     unsafe {

gstreamer/src/iterator.rs

@@ -178,6 +178,7 @@ where
     for<'a> T: FromValueOptional<'a> + StaticType + ToValue + Send + 'static,
 {
     pub fn new<I: IteratorImpl<T>>(imp: I) -> Self {
+        assert_initialized_main_thread!();
         static DUMMY_COOKIE: u32 = 0;
 
         unsafe {
@@ -208,6 +209,7 @@ where
     for<'a> T: FromValueOptional<'a> + StaticType + ToValue + Clone + Send + 'static,
 {
     pub fn from_vec(items: Vec<T>) -> Self {
+        skip_assert_initialized!();
         Self::new(VecIteratorImpl::new(items))
     }
 }
@@ -291,6 +293,7 @@ where
     for<'a> T: StaticType + ToValue + FromValueOptional<'a> + Clone + Send + 'static,
 {
     fn new(items: Vec<T>) -> Self {
+        skip_assert_initialized!();
         Self { pos: 0, items }
     }
 }
@@ -616,6 +619,7 @@ pub struct StdIterator<T> {
 
 impl<T> StdIterator<T> {
     fn new(inner: Iterator<T>) -> Self {
+        skip_assert_initialized!();
         Self { inner, error: None }
     }
 }

gstreamer/src/log.rs

@@ -51,6 +51,7 @@ pub struct DebugCategory(ptr::NonNull<gst_sys::GstDebugCategory>);
 
 impl DebugCategory {
     pub fn new(name: &str, color: ::DebugColorFlags, description: Option<&str>) -> DebugCategory {
+        assert_initialized_main_thread!();
         extern "C" {
             fn _gst_debug_category_new(
                 name: *const c_char,
@@ -72,6 +73,7 @@ impl DebugCategory {
     }
 
     pub fn get(name: &str) -> Option<DebugCategory> {
+        skip_assert_initialized!();
         unsafe {
             extern "C" {
                 fn _gst_debug_get_category(name: *const c_char) -> *mut gst_sys::GstDebugCategory;
@@ -364,6 +366,7 @@ where
         + Sync
         + 'static,
 {
+    skip_assert_initialized!();
     unsafe {
         let user_data = Box::new(function);
         let user_data_ptr = Box::into_raw(user_data) as gpointer;
@@ -377,12 +380,14 @@ where
 }
 
 pub fn debug_remove_default_log_function() {
+    skip_assert_initialized!();
     unsafe {
         gst_sys::gst_debug_remove_log_function(Some(gst_sys::gst_debug_log_default));
     }
 }
 
 pub fn debug_remove_log_function(log_fn: DebugLogFunction) {
+    skip_assert_initialized!();
     unsafe {
         let removed = gst_sys::gst_debug_remove_log_function_by_data(log_fn.0.as_ptr());
         assert_eq!(removed, 1);

gstreamer/src/memory.rs

@@ -65,6 +65,7 @@ impl Memory {
     }
 
     pub fn with_size(size: usize) -> Self {
+        assert_initialized_main_thread!();
         unsafe {
             from_glib_full(gst_sys::gst_allocator_alloc(
                 ptr::null_mut(),
@@ -75,6 +76,7 @@ impl Memory {
     }
 
     pub fn with_size_and_params(size: usize, params: &AllocationParams) -> Self {
+        assert_initialized_main_thread!();
         unsafe {
             from_glib_full(gst_sys::gst_allocator_alloc(
                 ptr::null_mut(),

gstreamer/src/meta.rs

@@ -264,6 +264,7 @@ unsafe impl Sync for ParentBufferMeta {}
 
 impl ParentBufferMeta {
     pub fn add<'a>(buffer: &'a mut BufferRef, parent: &Buffer) -> MetaRefMut<'a, Self, Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_sys::gst_buffer_add_parent_buffer_meta(
                 buffer.as_mut_ptr(),
@@ -316,6 +317,7 @@ impl ReferenceTimestampMeta {
         timestamp: ClockTime,
         duration: ClockTime,
     ) -> MetaRefMut<'a, Self, Standalone> {
+        skip_assert_initialized!();
         unsafe {
             let meta = gst_sys::gst_buffer_add_reference_timestamp_meta(
                 buffer.as_mut_ptr(),

gstreamer/src/miniobject.rs

@@ -25,6 +25,7 @@ pub struct GstRc<T: MiniObject> {
 
 impl<T: MiniObject> GstRc<T> {
     pub unsafe fn from_glib_none(ptr: *const T::GstType) -> Self {
+        skip_assert_initialized!();
         assert!(!ptr.is_null());
 
         gst_sys::gst_mini_object_ref(ptr as *mut gst_sys::GstMiniObject);
@@ -538,6 +539,7 @@ macro_rules! gst_define_mini_object_wrapper(
 
         impl From<$crate::GstRc<$ref_name>> for $name {
             fn from(rc: $crate::GstRc<$ref_name>) -> $name {
+	        skip_assert_initialized!();
                 $name(rc)
             }
         }

gstreamer/src/param_spec.rs

@@ -40,6 +40,7 @@ impl GstParamSpecExt for glib::ParamSpec {
         element_spec: &glib::ParamSpec,
         flags: glib::ParamFlags,
     ) -> glib::ParamSpec {
+        assert_initialized_main_thread!();
         unsafe {
             from_glib_full(gst_sys::gst_param_spec_array(
                 name.to_glib_none().0,
@@ -60,6 +61,7 @@ impl GstParamSpecExt for glib::ParamSpec {
         default: ::Fraction,
         flags: glib::ParamFlags,
     ) -> glib::ParamSpec {
+        assert_initialized_main_thread!();
         unsafe {
             from_glib_full(gst_sys::gst_param_spec_fraction(
                 name.to_glib_none().0,

gstreamer/src/promise.rs

@@ -44,6 +44,7 @@ impl Promise {
     where
         F: FnOnce(Result<&StructureRef, PromiseError>) + Send + 'static,
     {
+        assert_initialized_main_thread!();
         let user_data: Box<Option<F>> = Box::new(Some(func));
 
         unsafe extern "C" fn trampoline<

gstreamer/src/query.rs

@@ -355,6 +355,7 @@ macro_rules! declare_concrete_query(
 
         impl From<$name<Query>> for Query {
             fn from(concrete: $name<Query>) -> Self {
+                skip_assert_initialized!();
                 unsafe { from_glib_none(concrete.0.as_mut_ptr()) }
             }
         }
@@ -1319,6 +1320,7 @@ mod tests {
         ::init().unwrap();
 
         fn check_mut(query: &mut QueryRef) {
+            skip_assert_initialized!();
             match query.view_mut() {
                 QueryView::Position(ref mut p) => {
                     let pos = p.get_result();
@@ -1332,6 +1334,7 @@ mod tests {
         }
 
         fn check_ref(query: &QueryRef) {
+            skip_assert_initialized!();
             match query.view() {
                 QueryView::Position(ref p) => {
                     let pos = p.get_result();

gstreamer/src/sample_serde.rs

@@ -46,6 +46,7 @@ struct SampleDe {
 
 impl From<SampleDe> for Sample {
     fn from(buf_de: SampleDe) -> Self {
+        skip_assert_initialized!();
         let mut builder = Sample::new();
 
         if let Some(buffer) = buf_de.buffer.as_ref() {
@@ -74,6 +75,7 @@ impl From<SampleDe> for Sample {
 
 impl<'de> Deserialize<'de> for Sample {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         SampleDe::deserialize(deserializer).map(|sample_de| sample_de.into())
     }
 }

gstreamer/src/segment_serde.rs

@@ -56,6 +56,7 @@ impl<T: FormattedValue> Serialize for FormattedSegment<T> {
 
 impl<'de> Deserialize<'de> for Segment {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         FormattedSegmentSerde::deserialize(deserializer).map(|fmt_seg_de| {
             let mut segment = Self::new();
             segment.set_flags(fmt_seg_de.flags);
@@ -98,6 +99,7 @@ impl<'de> Deserialize<'de> for Segment {
 
 impl<'de, T: FormattedValue + SpecificFormattedValue> Deserialize<'de> for FormattedSegment<T> {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         Segment::deserialize(deserializer).and_then(|segment| {
             segment.downcast::<T>().map_err(|segment| {
                 de::Error::custom(format!(

gstreamer/src/structure.rs

@@ -44,10 +44,12 @@ pub enum GetError<'name> {
 
 impl<'name> GetError<'name> {
     fn new_field_not_found(name: &'name str) -> GetError {
+        skip_assert_initialized!();
         GetError::FieldNotFound { name }
     }
 
     fn from_value_get_error(name: &'name str, value_get_error: glib::value::GetError) -> GetError {
+        skip_assert_initialized!();
         GetError::ValueGetError {
             name,
             value_get_error,
@@ -713,6 +715,7 @@ pub struct Builder {
 
 impl Builder {
     fn new(name: &str) -> Self {
+        skip_assert_initialized!();
         Builder {
             s: Structure::new_empty(name),
         }

gstreamer/src/structure_serde.rs

@@ -76,6 +76,7 @@ impl Serialize for Structure {
 struct FieldDe(String, SendValue);
 impl From<FieldDe> for (String, glib::SendValue) {
     fn from(field_de: FieldDe) -> Self {
+        skip_assert_initialized!();
         (field_de.0, field_de.1.into())
     }
 }
@@ -105,6 +106,7 @@ impl<'de> Visitor<'de> for FieldVisitor {
 
 impl<'de> Deserialize<'de> for FieldDe {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_tuple(3, FieldVisitor)
     }
 }
@@ -133,6 +135,7 @@ impl<'de, 'a> DeserializeSeed<'de> for FieldsDe<'a> {
     type Value = ();
 
     fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<(), D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(FieldsVisitor(self.0))
     }
 }
@@ -159,6 +162,7 @@ impl<'de> Visitor<'de> for StructureVisitor {
 
 impl<'de> Deserialize<'de> for Structure {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_tuple(2, StructureVisitor)
     }
 }

gstreamer/src/tags.rs

@@ -789,14 +789,17 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
 impl<'a> ExactSizeIterator for Iter<'a> {}
 
 pub fn tag_exists(name: &str) -> bool {
+    skip_assert_initialized!();
     unsafe { from_glib(gst_sys::gst_tag_exists(name.to_glib_none().0)) }
 }
 
 pub fn tag_get_type(name: &str) -> glib::Type {
+    skip_assert_initialized!();
     unsafe { from_glib(gst_sys::gst_tag_get_type(name.to_glib_none().0)) }
 }
 
 pub fn tag_get_nick(name: &str) -> Option<&'static str> {
+    skip_assert_initialized!();
     unsafe {
         let ptr = gst_sys::gst_tag_get_nick(name.to_glib_none().0);
 
@@ -809,6 +812,7 @@ pub fn tag_get_nick(name: &str) -> Option<&'static str> {
 }
 
 pub fn tag_get_description(name: &str) -> Option<&'static str> {
+    skip_assert_initialized!();
     unsafe {
         let ptr = gst_sys::gst_tag_get_description(name.to_glib_none().0);
 
@@ -821,6 +825,7 @@ pub fn tag_get_description(name: &str) -> Option<&'static str> {
 }
 
 pub fn tag_get_flag(name: &str) -> ::TagFlag {
+    skip_assert_initialized!();
     unsafe { from_glib(gst_sys::gst_tag_get_flag(name.to_glib_none().0)) }
 }
 
@@ -830,6 +835,7 @@ pub trait CustomTag<'a>: Tag<'a> {
     const DESCRIPTION: &'static str;
 
     fn merge_func(src: &Value) -> Value {
+        skip_assert_initialized!();
         merge_use_first(src)
     }
 }
@@ -857,6 +863,7 @@ pub fn register<T: for<'a> CustomTag<'a>>() {
 }
 
 pub fn merge_use_first(src: &Value) -> Value {
+    skip_assert_initialized!();
     assert_eq!(src.type_(), ::List::static_type());
 
     unsafe {
@@ -869,6 +876,7 @@ pub fn merge_use_first(src: &Value) -> Value {
 }
 
 pub fn merge_strings_with_comma(src: &Value) -> Value {
+    skip_assert_initialized!();
     assert_eq!(src.type_(), ::List::static_type());
 
     unsafe {
@@ -1064,6 +1072,7 @@ mod tests {
             const DESCRIPTION: &'static str = "My own custom tag type for testing";
 
             fn merge_func(src: &Value) -> Value {
+                skip_assert_initialized!();
                 merge_strings_with_comma(src)
             }
         }

gstreamer/src/tags_serde.rs

@@ -52,6 +52,7 @@ macro_rules! ser_opt_tag (
 struct TagValuesSer<'a>(Rc<RefCell<GenericTagIter<'a>>>);
 impl<'a> TagValuesSer<'a> {
     fn from(tags_ser: &TagsSer<'a>) -> Self {
+        skip_assert_initialized!();
         TagValuesSer(Rc::clone(&tags_ser.1))
     }
 }
@@ -107,6 +108,7 @@ impl<'a> Serialize for TagValuesSer<'a> {
 struct TagsSer<'a>(&'a str, Rc<RefCell<GenericTagIter<'a>>>);
 impl<'a> TagsSer<'a> {
     fn new(name: &'a str, tag_iter: GenericTagIter<'a>) -> Self {
+        skip_assert_initialized!();
         TagsSer(name, Rc::new(RefCell::new(tag_iter)))
     }
 }
@@ -238,6 +240,7 @@ impl<'de, 'a> DeserializeSeed<'de> for TagValues<'a> {
     type Value = ();
 
     fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<(), D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(TagValuesVisitor(self.0, self.1))
     }
 }
@@ -267,6 +270,7 @@ impl<'de, 'a> DeserializeSeed<'de> for TagValuesTuple<'a> {
     type Value = ();
 
     fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<(), D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_tuple(2, TagValuesTupleVisitor(self.0))
     }
 }
@@ -295,6 +299,7 @@ impl<'de> Visitor<'de> for TagsVisitor {
 
 impl<'de> Deserialize<'de> for TagsDe {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_seq(TagsVisitor)
     }
 }
@@ -307,6 +312,7 @@ struct TagListDe {
 
 impl From<TagListDe> for TagList {
     fn from(tag_list_de: TagListDe) -> Self {
+        skip_assert_initialized!();
         let mut tag_list = tag_list_de.tags.0;
         tag_list.get_mut().unwrap().set_scope(tag_list_de.scope);
 
@@ -316,6 +322,7 @@ impl From<TagListDe> for TagList {
 
 impl<'de> Deserialize<'de> for TagList {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         TagListDe::deserialize(deserializer).map(|tag_list_de| tag_list_de.into())
     }
 }

gstreamer/src/toc_serde.rs

@@ -59,6 +59,7 @@ struct TocDe {
 
 impl From<TocDe> for Toc {
     fn from(mut toc_de: TocDe) -> Self {
+        skip_assert_initialized!();
         let mut toc = Toc::new(toc_de.scope);
         {
             let toc = toc.get_mut().unwrap();
@@ -76,6 +77,7 @@ impl From<TocDe> for Toc {
 
 impl<'de> Deserialize<'de> for Toc {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         TocDe::deserialize(deserializer).map(|toc_de| toc_de.into())
     }
 }
@@ -93,6 +95,7 @@ struct TocEntryDe {
 
 impl From<TocEntryDe> for TocEntry {
     fn from(mut toc_entry_de: TocEntryDe) -> Self {
+        skip_assert_initialized!();
         let mut toc_entry = TocEntry::new(toc_entry_de.entry_type, toc_entry_de.uid.as_str());
         {
             let toc_entry = toc_entry.get_mut().unwrap();
@@ -117,6 +120,7 @@ impl From<TocEntryDe> for TocEntry {
 
 impl<'de> Deserialize<'de> for TocEntry {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         TocEntryDe::deserialize(deserializer).map(|toc_entry_de| toc_entry_de.into())
     }
 }

gstreamer/src/typefind.rs

@@ -44,6 +44,7 @@ impl<'a> TypeFind<'a> {
     where
         F: Fn(&mut TypeFind) + Send + Sync + 'static,
     {
+        assert_initialized_main_thread!();
         unsafe {
             let func: Box<F> = Box::new(func);
             let func = Box::into_raw(func);
@@ -160,6 +161,7 @@ pub struct SliceTypeFind<T: AsRef<[u8]>> {
 
 impl<T: AsRef<[u8]>> SliceTypeFind<T> {
     pub fn new(data: T) -> SliceTypeFind<T> {
+        assert_initialized_main_thread!();
         SliceTypeFind {
             probability: None,
             caps: None,
@@ -181,6 +183,7 @@ impl<T: AsRef<[u8]>> SliceTypeFind<T> {
     }
 
     pub fn type_find(data: T) -> (TypeFindProbability, Option<Caps>) {
+        assert_initialized_main_thread!();
         let mut t = SliceTypeFind {
             probability: None,
             caps: None,

gstreamer/src/utils.rs

@@ -15,6 +15,7 @@ pub struct MutexGuard<'a>(&'a glib_sys::GMutex);
 impl<'a> MutexGuard<'a> {
     #[allow(clippy::trivially_copy_pass_by_ref)]
     pub fn lock(mutex: &'a glib_sys::GMutex) -> Self {
+        skip_assert_initialized!();
         unsafe {
             glib_sys::g_mutex_lock(mut_override(mutex));
         }

gstreamer/src/value_serde.rs

@@ -57,6 +57,7 @@ impl<'a> Serialize for Fraction {
 
 impl<'de> Deserialize<'de> for Fraction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         Rational32::deserialize(deserializer)
             .map(|rational| Fraction::new(*rational.numer(), *rational.denom()))
     }
@@ -143,12 +144,14 @@ macro_rules! ser_value (
 pub(crate) struct SendValue(glib::SendValue);
 impl SendValue {
     pub(crate) fn from(send_value: glib::SendValue) -> Self {
+        skip_assert_initialized!();
         SendValue(send_value)
     }
 }
 
 impl From<SendValue> for glib::SendValue {
     fn from(send_value: SendValue) -> Self {
+        skip_assert_initialized!();
         send_value.0
     }
 }
@@ -279,6 +282,7 @@ impl<'de> Visitor<'de> for SendValueVisitor {
 
 impl<'de> Deserialize<'de> for SendValue {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        skip_assert_initialized!();
         deserializer.deserialize_tuple(2, SendValueVisitor {})
     }
 }
@@ -287,6 +291,7 @@ macro_rules! impl_de_send_value_collection (
     ($t:ident) => {
         impl<'a, 'de> Deserialize<'de> for $t<'a> {
             fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+                skip_assert_initialized!();
                 let send_value_vec = Vec::<SendValue>::deserialize(deserializer)?;
                 Ok($t::from_owned(unsafe{
                     mem::transmute::<Vec<SendValue>, Vec<glib::SendValue>>(send_value_vec)