2020-12-15 10:53:31 +00:00
|
|
|
// Take a look at the license at the top of the repository in the LICENSE file.
|
|
|
|
|
2019-12-18 14:03:18 +00:00
|
|
|
use std::mem;
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
use glib::prelude::*;
|
2019-12-18 14:03:18 +00:00
|
|
|
use glib::translate::*;
|
|
|
|
|
2021-08-24 06:12:27 +00:00
|
|
|
use super::prelude::*;
|
2019-12-18 14:03:18 +00:00
|
|
|
use gst::LoggableError;
|
|
|
|
use gst_base::subclass::prelude::*;
|
|
|
|
|
2020-11-21 18:17:20 +00:00
|
|
|
use crate::AudioRingBufferSpec;
|
|
|
|
use crate::AudioSrc;
|
2019-12-18 14:03:18 +00:00
|
|
|
|
2021-08-24 06:12:27 +00:00
|
|
|
pub trait AudioSrcImpl: AudioSrcImplExt + AudioBaseSrcImpl {
|
2020-11-14 16:11:50 +00:00
|
|
|
fn close(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
self.parent_close(src)
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn delay(&self, src: &Self::Type) -> u32 {
|
2019-12-18 14:03:18 +00:00
|
|
|
self.parent_delay(src)
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn open(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
self.parent_open(src)
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn prepare(
|
|
|
|
&self,
|
|
|
|
src: &Self::Type,
|
|
|
|
spec: &mut AudioRingBufferSpec,
|
|
|
|
) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
AudioSrcImplExt::parent_prepare(self, src, spec)
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
self.parent_unprepare(src)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn read(
|
|
|
|
&self,
|
2020-11-14 16:11:50 +00:00
|
|
|
src: &Self::Type,
|
2019-12-18 14:03:18 +00:00
|
|
|
audio_data: &mut [u8],
|
2021-04-28 22:29:13 +00:00
|
|
|
) -> Result<(u32, Option<gst::ClockTime>), LoggableError> {
|
2020-06-30 20:43:13 +00:00
|
|
|
self.parent_read(src, audio_data)
|
|
|
|
}
|
2020-06-30 20:44:29 +00:00
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn reset(&self, src: &Self::Type) {
|
2020-06-30 20:44:29 +00:00
|
|
|
self.parent_reset(src)
|
|
|
|
}
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
pub trait AudioSrcImplExt: ObjectSubclass {
|
|
|
|
fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError>;
|
|
|
|
fn parent_delay(&self, src: &Self::Type) -> u32;
|
|
|
|
fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError>;
|
2019-12-18 14:03:18 +00:00
|
|
|
fn parent_prepare(
|
|
|
|
&self,
|
2020-11-14 16:11:50 +00:00
|
|
|
src: &Self::Type,
|
2019-12-18 14:03:18 +00:00
|
|
|
spec: &mut AudioRingBufferSpec,
|
|
|
|
) -> Result<(), LoggableError>;
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError>;
|
2019-12-18 14:03:18 +00:00
|
|
|
fn parent_read(
|
|
|
|
&self,
|
2020-11-14 16:11:50 +00:00
|
|
|
src: &Self::Type,
|
2019-12-18 14:03:18 +00:00
|
|
|
audio_data: &mut [u8],
|
2021-04-28 22:29:13 +00:00
|
|
|
) -> Result<(u32, Option<gst::ClockTime>), LoggableError>;
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_reset(&self, src: &Self::Type);
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
impl<T: AudioSrcImpl> AudioSrcImplExt for T {
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).close {
|
|
|
|
None => return Ok(()),
|
|
|
|
Some(f) => f,
|
|
|
|
};
|
2020-12-20 15:09:22 +00:00
|
|
|
gst::result_from_gboolean!(
|
2020-11-14 16:11:50 +00:00
|
|
|
f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Failed to close element using the parent function"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_delay(&self, src: &Self::Type) -> u32 {
|
2019-12-18 14:03:18 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).delay {
|
|
|
|
Some(f) => f,
|
|
|
|
None => return 0,
|
|
|
|
};
|
2020-11-14 16:11:50 +00:00
|
|
|
f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0)
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).open {
|
|
|
|
Some(f) => f,
|
|
|
|
None => return Ok(()),
|
|
|
|
};
|
2020-12-20 15:09:22 +00:00
|
|
|
gst::result_from_gboolean!(
|
2020-11-14 16:11:50 +00:00
|
|
|
f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Failed to open element using the parent function"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn parent_prepare(
|
|
|
|
&self,
|
2020-11-14 16:11:50 +00:00
|
|
|
src: &Self::Type,
|
2019-12-18 14:03:18 +00:00
|
|
|
spec: &mut AudioRingBufferSpec,
|
|
|
|
) -> Result<(), LoggableError> {
|
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).prepare {
|
|
|
|
Some(f) => f,
|
|
|
|
None => return Ok(()),
|
|
|
|
};
|
2020-12-20 15:09:22 +00:00
|
|
|
gst::result_from_gboolean!(
|
2020-11-14 16:11:50 +00:00
|
|
|
f(
|
|
|
|
src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0,
|
|
|
|
&mut spec.0
|
|
|
|
),
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Failed to prepare element using the parent function"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).unprepare {
|
|
|
|
Some(f) => f,
|
|
|
|
None => {
|
2020-12-20 15:09:22 +00:00
|
|
|
return Err(gst::loggable_error!(
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Unprepare is not implemented!"
|
|
|
|
))
|
|
|
|
}
|
|
|
|
};
|
2020-12-20 15:09:22 +00:00
|
|
|
gst::result_from_gboolean!(
|
2020-11-14 16:11:50 +00:00
|
|
|
f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Failed to unprepare element using the parent function"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn parent_read(
|
|
|
|
&self,
|
2020-11-14 16:11:50 +00:00
|
|
|
src: &Self::Type,
|
2019-12-18 14:03:18 +00:00
|
|
|
buffer: &mut [u8],
|
2021-04-28 22:29:13 +00:00
|
|
|
) -> Result<(u32, Option<gst::ClockTime>), LoggableError> {
|
2019-12-18 14:03:18 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2019-12-18 14:03:18 +00:00
|
|
|
let f = match (*parent_class).read {
|
|
|
|
Some(f) => f,
|
2021-04-28 22:29:13 +00:00
|
|
|
None => return Ok((0, gst::ClockTime::NONE)),
|
2019-12-18 14:03:18 +00:00
|
|
|
};
|
|
|
|
let buffer_ptr = buffer.as_mut_ptr() as *mut _;
|
|
|
|
let mut timestamp = mem::MaybeUninit::uninit();
|
|
|
|
let ret = f(
|
2020-11-14 16:11:50 +00:00
|
|
|
src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0,
|
2019-12-18 14:03:18 +00:00
|
|
|
buffer_ptr,
|
|
|
|
buffer.len() as u32,
|
|
|
|
timestamp.as_mut_ptr(),
|
|
|
|
);
|
|
|
|
if ret > 0 {
|
|
|
|
Ok((ret, from_glib(timestamp.assume_init())))
|
|
|
|
} else {
|
2020-12-20 15:09:22 +00:00
|
|
|
Err(gst::loggable_error!(
|
2019-12-18 14:03:18 +00:00
|
|
|
gst::CAT_RUST,
|
|
|
|
"Failed to read using the parent function"
|
|
|
|
))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-06-30 20:44:29 +00:00
|
|
|
|
2020-11-14 16:11:50 +00:00
|
|
|
fn parent_reset(&self, src: &Self::Type) {
|
2020-06-30 20:44:29 +00:00
|
|
|
unsafe {
|
2021-04-29 20:06:41 +00:00
|
|
|
let data = Self::type_data();
|
2021-04-11 19:39:50 +00:00
|
|
|
let parent_class = data.as_ref().parent_class() as *mut ffi::GstAudioSrcClass;
|
2020-06-30 20:44:29 +00:00
|
|
|
if let Some(f) = (*parent_class).reset {
|
2020-11-14 16:11:50 +00:00
|
|
|
f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0)
|
2020-06-30 20:44:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2021-03-09 13:37:05 +00:00
|
|
|
unsafe impl<T: AudioSrcImpl> IsSubclassable<T> for AudioSrc {
|
2021-03-08 10:06:56 +00:00
|
|
|
fn class_init(klass: &mut glib::Class<Self>) {
|
2021-08-24 05:55:37 +00:00
|
|
|
Self::parent_class_init::<T>(klass);
|
2020-11-05 17:07:31 +00:00
|
|
|
let klass = klass.as_mut();
|
|
|
|
klass.close = Some(audiosrc_close::<T>);
|
|
|
|
klass.delay = Some(audiosrc_delay::<T>);
|
|
|
|
klass.open = Some(audiosrc_open::<T>);
|
|
|
|
klass.prepare = Some(audiosrc_prepare::<T>);
|
|
|
|
klass.unprepare = Some(audiosrc_unprepare::<T>);
|
|
|
|
klass.read = Some(audiosrc_read::<T>);
|
|
|
|
klass.reset = Some(audiosrc_reset::<T>);
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
unsafe extern "C" fn audiosrc_close<T: AudioSrcImpl>(
|
2020-11-21 18:17:20 +00:00
|
|
|
ptr: *mut ffi::GstAudioSrc,
|
2021-03-09 13:37:05 +00:00
|
|
|
) -> glib::ffi::gboolean {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), false, {
|
2020-11-14 16:11:50 +00:00
|
|
|
match imp.close(wrap.unsafe_cast_ref()) {
|
2019-12-18 14:03:18 +00:00
|
|
|
Ok(()) => true,
|
|
|
|
Err(err) => {
|
2020-04-05 14:52:56 +00:00
|
|
|
err.log_with_object(&*wrap);
|
2019-12-18 14:03:18 +00:00
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
2021-04-27 15:15:46 +00:00
|
|
|
.into_glib()
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2021-03-09 13:37:05 +00:00
|
|
|
unsafe extern "C" fn audiosrc_delay<T: AudioSrcImpl>(ptr: *mut ffi::GstAudioSrc) -> u32 {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), 0, {
|
2020-11-14 16:11:50 +00:00
|
|
|
imp.delay(wrap.unsafe_cast_ref())
|
|
|
|
})
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
unsafe extern "C" fn audiosrc_open<T: AudioSrcImpl>(
|
2020-11-21 18:17:20 +00:00
|
|
|
ptr: *mut ffi::GstAudioSrc,
|
2021-03-09 13:37:05 +00:00
|
|
|
) -> glib::ffi::gboolean {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), false, {
|
2020-11-14 16:11:50 +00:00
|
|
|
match imp.open(wrap.unsafe_cast_ref()) {
|
2019-12-18 14:03:18 +00:00
|
|
|
Ok(()) => true,
|
|
|
|
Err(err) => {
|
2020-04-05 14:52:56 +00:00
|
|
|
err.log_with_object(&*wrap);
|
2019-12-18 14:03:18 +00:00
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
2021-04-27 15:15:46 +00:00
|
|
|
.into_glib()
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
unsafe extern "C" fn audiosrc_prepare<T: AudioSrcImpl>(
|
2020-11-21 18:17:20 +00:00
|
|
|
ptr: *mut ffi::GstAudioSrc,
|
|
|
|
spec: *mut ffi::GstAudioRingBufferSpec,
|
2021-03-09 13:37:05 +00:00
|
|
|
) -> glib::ffi::gboolean {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
|
|
|
|
let spec = &mut *(spec as *mut AudioRingBufferSpec);
|
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), false, {
|
2020-11-14 16:11:50 +00:00
|
|
|
match AudioSrcImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) {
|
2019-12-18 14:03:18 +00:00
|
|
|
Ok(()) => true,
|
|
|
|
Err(err) => {
|
2020-04-05 14:52:56 +00:00
|
|
|
err.log_with_object(&*wrap);
|
2019-12-18 14:03:18 +00:00
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
2021-04-27 15:15:46 +00:00
|
|
|
.into_glib()
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
unsafe extern "C" fn audiosrc_unprepare<T: AudioSrcImpl>(
|
2020-11-21 18:17:20 +00:00
|
|
|
ptr: *mut ffi::GstAudioSrc,
|
2021-03-09 13:37:05 +00:00
|
|
|
) -> glib::ffi::gboolean {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), false, {
|
2020-11-14 16:11:50 +00:00
|
|
|
match imp.unprepare(wrap.unsafe_cast_ref()) {
|
2019-12-18 14:03:18 +00:00
|
|
|
Ok(()) => true,
|
|
|
|
Err(err) => {
|
2020-04-05 14:52:56 +00:00
|
|
|
err.log_with_object(&*wrap);
|
2019-12-18 14:03:18 +00:00
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
2021-04-27 15:15:46 +00:00
|
|
|
.into_glib()
|
2019-12-18 14:03:18 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 08:02:04 +00:00
|
|
|
unsafe extern "C" fn audiosrc_read<T: AudioSrcImpl>(
|
2020-11-21 18:17:20 +00:00
|
|
|
ptr: *mut ffi::GstAudioSrc,
|
|
|
|
data: glib::ffi::gpointer,
|
2019-12-18 14:03:18 +00:00
|
|
|
length: u32,
|
2020-11-21 18:17:20 +00:00
|
|
|
timestamp: *mut gst::ffi::GstClockTime,
|
2021-03-09 13:37:05 +00:00
|
|
|
) -> u32 {
|
2019-12-18 14:03:18 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-04-05 14:52:56 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
2019-12-18 14:03:18 +00:00
|
|
|
let data_slice = std::slice::from_raw_parts_mut(data as *mut u8, length as usize);
|
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), 0, {
|
2019-12-18 14:03:18 +00:00
|
|
|
let (res, timestamp_res) = imp
|
2020-11-14 16:11:50 +00:00
|
|
|
.read(wrap.unsafe_cast_ref(), data_slice)
|
2021-04-28 22:29:13 +00:00
|
|
|
.unwrap_or((0, gst::ClockTime::NONE));
|
2021-04-27 15:15:46 +00:00
|
|
|
*timestamp = timestamp_res.into_glib();
|
2019-12-18 14:03:18 +00:00
|
|
|
|
|
|
|
res
|
|
|
|
})
|
|
|
|
}
|
2020-06-30 20:44:29 +00:00
|
|
|
|
2021-03-09 13:37:05 +00:00
|
|
|
unsafe extern "C" fn audiosrc_reset<T: AudioSrcImpl>(ptr: *mut ffi::GstAudioSrc) {
|
2020-06-30 20:44:29 +00:00
|
|
|
let instance = &*(ptr as *mut T::Instance);
|
2021-12-28 15:50:06 +00:00
|
|
|
let imp = instance.imp();
|
2020-06-30 20:44:29 +00:00
|
|
|
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
|
|
|
|
|
2021-07-30 10:19:24 +00:00
|
|
|
gst::panic_to_error!(&wrap, imp.panicked(), (), {
|
2020-11-14 16:11:50 +00:00
|
|
|
imp.reset(wrap.unsafe_cast_ref());
|
2020-06-30 20:44:29 +00:00
|
|
|
});
|
|
|
|
}
|