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

Fix various needless-borrow clippy warnings

Browse source
This commit is contained in:
Sebastian Dröge 2021-07-30 13:19:24 +03:00
parent 044a72d9f6
commit b1afc4804a
38 changed files with 257 additions and 252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
examples/src/bin/rtpfecclient.rs
View file

@ -216,7 +216,7 @@ fn example_main() -> Result<(), Error> {
None => return,
};
match connect_rtpbin_srcpad(&src_pad, &depay) {
match connect_rtpbin_srcpad(src_pad, &depay) {
Ok(_) => (),
Err(err) => {
element_error!(

4
examples/src/bin/rtpfecserver.rs
View file

@ -63,7 +63,7 @@ fn request_pad(element: &gst::Element, pad_name: &'static str) -> Result<gst::Pa
}
fn connect_decodebin_pad(src_pad: &gst::Pad, sink: &gst::Element) -> Result<(), Error> {
let sinkpad = static_pad(&sink, "sink")?;
let sinkpad = static_pad(sink, "sink")?;
src_pad.link(&sinkpad)?;
Ok(())
@ -136,7 +136,7 @@ fn example_main() -> Result<(), Error> {
srcpad.link(&sinkpad)?;
src.connect_pad_added(
move |decodebin, src_pad| match connect_decodebin_pad(&src_pad, &conv) {
move |decodebin, src_pad| match connect_decodebin_pad(src_pad, &conv) {
Ok(_) => (),
Err(err) => {
element_error!(

38
gstreamer-app/src/app_sink.rs
View file

@ -134,11 +134,11 @@ 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]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
} else if let Some(cause) = err.downcast_ref::<String>() {
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
} else {
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
}
}
@ -148,7 +148,7 @@ unsafe extern "C" fn trampoline_eos(appsink: *mut ffi::GstAppSink, callbacks: gp
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSink> = from_glib_borrow(appsink);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return;
}
@ -175,7 +175,7 @@ unsafe extern "C" fn trampoline_new_preroll(
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSink> = from_glib_borrow(appsink);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return gst::FlowReturn::Error.into_glib();
}
@ -208,7 +208,7 @@ unsafe extern "C" fn trampoline_new_sample(
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSink> = from_glib_borrow(appsink);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return gst::FlowReturn::Error.into_glib();
}
@ -533,7 +533,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -561,7 +561,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -589,7 +589,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -617,7 +617,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -645,7 +645,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -673,7 +673,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -703,7 +703,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -729,7 +729,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -757,7 +757,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -785,7 +785,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -811,7 +811,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -839,7 +839,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);
@ -867,7 +867,7 @@ impl AppSink {
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&AppSink::from_glib_borrow(this).unsafe_cast_ref())
f(AppSink::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box<F> = Box::new(f);

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

@ -111,11 +111,11 @@ 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]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
} else if let Some(cause) = err.downcast_ref::<String>() {
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked: {}", cause]);
} else {
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
}
}
@ -129,7 +129,7 @@ unsafe extern "C" fn trampoline_need_data(
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSrc> = from_glib_borrow(appsrc);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return;
}
@ -153,7 +153,7 @@ unsafe extern "C" fn trampoline_enough_data(appsrc: *mut ffi::GstAppSrc, callbac
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSrc> = from_glib_borrow(appsrc);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return;
}
@ -179,7 +179,7 @@ unsafe extern "C" fn trampoline_seek_data(
if callbacks.panicked.load(Ordering::Relaxed) {
let element: Borrowed<AppSrc> = from_glib_borrow(appsrc);
gst::element_error!(&element, gst::LibraryError::Failed, ["Panicked"]);
gst::element_error!(element, gst::LibraryError::Failed, ["Panicked"]);
return false.into_glib();
}

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

@ -23,6 +23,7 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)]
#[allow(clippy::use_self)]
#[allow(clippy::needless_borrow)]
mod auto;
pub use crate::auto::*;

34
gstreamer-audio/src/subclass/audio_decoder.rs
View file

@ -555,7 +555,7 @@ unsafe extern "C" fn audio_decoder_open<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -574,7 +574,7 @@ unsafe extern "C" fn audio_decoder_close<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -593,7 +593,7 @@ unsafe extern "C" fn audio_decoder_start<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -612,7 +612,7 @@ unsafe extern "C" fn audio_decoder_stop<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -632,7 +632,7 @@ unsafe extern "C" fn audio_decoder_set_format<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) {
Ok(()) => true,
Err(err) => {
@ -654,7 +654,7 @@ unsafe extern "C" fn audio_decoder_parse<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.parse(wrap.unsafe_cast_ref(), &from_glib_borrow(adapter)) {
Ok((new_offset, new_len)) => {
assert!(new_offset <= std::i32::MAX as u32);
@ -680,7 +680,7 @@ unsafe extern "C" fn audio_decoder_handle_frame<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(
wrap.unsafe_cast_ref(),
Option::<gst::Buffer>::from_glib_none(buffer).as_ref(),
@ -698,7 +698,7 @@ unsafe extern "C" fn audio_decoder_pre_push<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) {
Ok(Some(new_buffer)) => {
*buffer = new_buffer.into_ptr();
@ -723,7 +723,7 @@ unsafe extern "C" fn audio_decoder_flush<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
AudioDecoderImpl::flush(imp, wrap.unsafe_cast_ref(), from_glib(hard))
})
}
@ -735,7 +735,7 @@ unsafe extern "C" fn audio_decoder_negotiate<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -755,7 +755,7 @@ unsafe extern "C" fn audio_decoder_getcaps<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
AudioDecoderImpl::caps(
imp,
wrap.unsafe_cast_ref(),
@ -775,7 +775,7 @@ unsafe extern "C" fn audio_decoder_sink_event<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -789,7 +789,7 @@ unsafe extern "C" fn audio_decoder_sink_query<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -803,7 +803,7 @@ unsafe extern "C" fn audio_decoder_src_event<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -817,7 +817,7 @@ unsafe extern "C" fn audio_decoder_src_query<T: AudioDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -832,7 +832,7 @@ unsafe extern "C" fn audio_decoder_propose_allocation<T: AudioDecoderImpl>(
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {
@ -853,7 +853,7 @@ unsafe extern "C" fn audio_decoder_decide_allocation<T: AudioDecoderImpl>(
let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {

32
gstreamer-audio/src/subclass/audio_encoder.rs
View file

@ -504,7 +504,7 @@ unsafe extern "C" fn audio_encoder_open<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -523,7 +523,7 @@ unsafe extern "C" fn audio_encoder_close<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -542,7 +542,7 @@ unsafe extern "C" fn audio_encoder_start<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -561,7 +561,7 @@ unsafe extern "C" fn audio_encoder_stop<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -581,7 +581,7 @@ unsafe extern "C" fn audio_encoder_set_format<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_none(info)) {
Ok(()) => true,
Err(err) => {
@ -603,7 +603,7 @@ unsafe extern "C" fn audio_encoder_handle_frame<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(
wrap.unsafe_cast_ref(),
Option::<gst::Buffer>::from_glib_none(buffer).as_ref(),
@ -621,7 +621,7 @@ unsafe extern "C" fn audio_encoder_pre_push<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) {
Ok(Some(new_buffer)) => {
*buffer = new_buffer.into_ptr();
@ -643,7 +643,7 @@ unsafe extern "C" fn audio_encoder_flush<T: AudioEncoderImpl>(ptr: *mut ffi::Gst
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
AudioEncoderImpl::flush(imp, wrap.unsafe_cast_ref())
})
}
@ -655,7 +655,7 @@ unsafe extern "C" fn audio_encoder_negotiate<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -675,7 +675,7 @@ unsafe extern "C" fn audio_encoder_getcaps<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
AudioEncoderImpl::caps(
imp,
wrap.unsafe_cast_ref(),
@ -695,7 +695,7 @@ unsafe extern "C" fn audio_encoder_sink_event<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -709,7 +709,7 @@ unsafe extern "C" fn audio_encoder_sink_query<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -723,7 +723,7 @@ unsafe extern "C" fn audio_encoder_src_event<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -737,7 +737,7 @@ unsafe extern "C" fn audio_encoder_src_query<T: AudioEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -752,7 +752,7 @@ unsafe extern "C" fn audio_encoder_propose_allocation<T: AudioEncoderImpl>(
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {
@ -773,7 +773,7 @@ unsafe extern "C" fn audio_encoder_decide_allocation<T: AudioEncoderImpl>(
let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {

14
gstreamer-audio/src/subclass/audio_sink.rs
View file

@ -207,7 +207,7 @@ unsafe extern "C" fn audiosink_close<T: AudioSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -224,7 +224,7 @@ unsafe extern "C" fn audiosink_delay<T: AudioSinkImpl>(ptr: *mut ffi::GstAudioSi
let imp = instance.impl_();
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), 0, {
gst::panic_to_error!(&wrap, imp.panicked(), 0, {
imp.delay(wrap.unsafe_cast_ref())
})
}
@ -236,7 +236,7 @@ unsafe extern "C" fn audiosink_open<T: AudioSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -258,7 +258,7 @@ unsafe extern "C" fn audiosink_prepare<T: AudioSinkImpl>(
let spec = &mut *(spec as *mut AudioRingBufferSpec);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match AudioSinkImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) {
Ok(()) => true,
Err(err) => {
@ -277,7 +277,7 @@ unsafe extern "C" fn audiosink_unprepare<T: AudioSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unprepare(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -299,7 +299,7 @@ unsafe extern "C" fn audiosink_write<T: AudioSinkImpl>(
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
let data_slice = std::slice::from_raw_parts(data as *const u8, length as usize);
gst::panic_to_error!(&wrap, &imp.panicked(), -1, {
gst::panic_to_error!(&wrap, imp.panicked(), -1, {
imp.write(wrap.unsafe_cast_ref(), data_slice).unwrap_or(-1)
})
}
@ -309,7 +309,7 @@ unsafe extern "C" fn audiosink_reset<T: AudioSinkImpl>(ptr: *mut ffi::GstAudioSi
let imp = instance.impl_();
let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
imp.reset(wrap.unsafe_cast_ref());
});
}

14
gstreamer-audio/src/subclass/audio_src.rs
View file

@ -223,7 +223,7 @@ unsafe extern "C" fn audiosrc_close<T: AudioSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -240,7 +240,7 @@ unsafe extern "C" fn audiosrc_delay<T: AudioSrcImpl>(ptr: *mut ffi::GstAudioSrc)
let imp = instance.impl_();
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), 0, {
gst::panic_to_error!(&wrap, imp.panicked(), 0, {
imp.delay(wrap.unsafe_cast_ref())
})
}
@ -252,7 +252,7 @@ unsafe extern "C" fn audiosrc_open<T: AudioSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -274,7 +274,7 @@ unsafe extern "C" fn audiosrc_prepare<T: AudioSrcImpl>(
let spec = &mut *(spec as *mut AudioRingBufferSpec);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match AudioSrcImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) {
Ok(()) => true,
Err(err) => {
@ -293,7 +293,7 @@ unsafe extern "C" fn audiosrc_unprepare<T: AudioSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unprepare(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -316,7 +316,7 @@ unsafe extern "C" fn audiosrc_read<T: AudioSrcImpl>(
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
let data_slice = std::slice::from_raw_parts_mut(data as *mut u8, length as usize);
gst::panic_to_error!(&wrap, &imp.panicked(), 0, {
gst::panic_to_error!(&wrap, imp.panicked(), 0, {
let (res, timestamp_res) = imp
.read(wrap.unsafe_cast_ref(), data_slice)
.unwrap_or((0, gst::ClockTime::NONE));
@ -331,7 +331,7 @@ unsafe extern "C" fn audiosrc_reset<T: AudioSrcImpl>(ptr: *mut ffi::GstAudioSrc)
let imp = instance.impl_();
let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
imp.reset(wrap.unsafe_cast_ref());
});
}

4
gstreamer-base/src/aggregator.rs
View file

@ -249,7 +249,7 @@ impl<O: IsA<Aggregator>> AggregatorExtManual for O {
{
let f: &F = &*(f as *const F);
f(
&Aggregator::from_glib_borrow(this).unsafe_cast_ref(),
Aggregator::from_glib_borrow(this).unsafe_cast_ref(),
&gst::Segment::from_glib_borrow(segment),
from_glib(pts),
from_glib(dts),
@ -286,5 +286,5 @@ unsafe extern "C" fn notify_min_upstream_latency_trampoline<P, F: Fn(&P) + Send
P: IsA<Aggregator>,
{
let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast_ref())
f(Aggregator::from_glib_borrow(this).unsafe_cast_ref())
}

42
gstreamer-base/src/subclass/aggregator.rs
View file

@ -739,7 +739,7 @@ unsafe extern "C" fn aggregator_flush<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.flush(wrap.unsafe_cast_ref()).into()
})
.into_glib()
@ -754,7 +754,7 @@ unsafe extern "C" fn aggregator_clip<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
let ret = gst::panic_to_error!(&wrap, &imp.panicked(), None, {
let ret = gst::panic_to_error!(&wrap, imp.panicked(), None, {
imp.clip(
wrap.unsafe_cast_ref(),
&from_glib_borrow(aggregator_pad),
@ -773,7 +773,7 @@ unsafe extern "C" fn aggregator_finish_buffer<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.finish_buffer(wrap.unsafe_cast_ref(), from_glib_full(buffer))
.into()
})
@ -790,7 +790,7 @@ unsafe extern "C" fn aggregator_finish_buffer_list<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.finish_buffer_list(wrap.unsafe_cast_ref(), from_glib_full(buffer_list))
.into()
})
@ -806,7 +806,7 @@ unsafe extern "C" fn aggregator_sink_event<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(wrap, &imp.panicked(), false, {
gst::panic_to_error!(wrap, imp.panicked(), false, {
imp.sink_event(
wrap.unsafe_cast_ref(),
&from_glib_borrow(aggregator_pad),
@ -827,7 +827,7 @@ unsafe extern "C" fn aggregator_sink_event_pre_queue<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.sink_event_pre_queue(
wrap.unsafe_cast_ref(),
&from_glib_borrow(aggregator_pad),
@ -847,7 +847,7 @@ unsafe extern "C" fn aggregator_sink_query<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query(
wrap.unsafe_cast_ref(),
&from_glib_borrow(aggregator_pad),
@ -868,7 +868,7 @@ unsafe extern "C" fn aggregator_sink_query_pre_queue<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query_pre_queue(
wrap.unsafe_cast_ref(),
&from_glib_borrow(aggregator_pad),
@ -886,7 +886,7 @@ unsafe extern "C" fn aggregator_src_event<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -900,7 +900,7 @@ unsafe extern "C" fn aggregator_src_query<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -915,7 +915,7 @@ unsafe extern "C" fn aggregator_src_activate<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.src_activate(wrap.unsafe_cast_ref(), from_glib(mode), from_glib(active)) {
Ok(()) => true,
Err(err) => {
@ -935,7 +935,7 @@ unsafe extern "C" fn aggregator_aggregate<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.aggregate(wrap.unsafe_cast_ref(), from_glib(timeout))
.into()
})
@ -949,7 +949,7 @@ unsafe extern "C" fn aggregator_start<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -968,7 +968,7 @@ unsafe extern "C" fn aggregator_stop<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -987,7 +987,7 @@ unsafe extern "C" fn aggregator_get_next_time<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::ClockTime::NONE, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::ClockTime::NONE, {
imp.next_time(wrap.unsafe_cast_ref())
})
.into_glib()
@ -1003,7 +1003,7 @@ unsafe extern "C" fn aggregator_create_new_pad<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
let req_name: Borrowed<Option<glib::GString>> = from_glib_borrow(req_name);
imp.create_new_pad(
@ -1029,7 +1029,7 @@ unsafe extern "C" fn aggregator_update_src_caps<T: AggregatorImpl>(
*res = ptr::null_mut();
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.update_src_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) {
Ok(res_caps) => {
*res = res_caps.into_ptr();
@ -1049,7 +1049,7 @@ unsafe extern "C" fn aggregator_fixate_src_caps<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
imp.fixate_src_caps(wrap.unsafe_cast_ref(), from_glib_full(caps))
})
.into_ptr()
@ -1063,7 +1063,7 @@ unsafe extern "C" fn aggregator_negotiated_src_caps<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiated_src_caps(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) {
Ok(()) => true,
Err(err) => {
@ -1084,7 +1084,7 @@ unsafe extern "C" fn aggregator_negotiate<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.negotiate(wrap.unsafe_cast_ref())
})
.into_glib()
@ -1100,7 +1100,7 @@ unsafe extern "C" fn aggregator_peek_next_sample<T: AggregatorImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Aggregator> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
imp.peek_next_sample(wrap.unsafe_cast_ref(), &from_glib_borrow(pad))
})
.to_glib_full()

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

@ -220,7 +220,7 @@ unsafe extern "C" fn base_parse_start<T: BaseParseImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseParse> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -239,7 +239,7 @@ unsafe extern "C" fn base_parse_stop<T: BaseParseImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseParse> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -260,7 +260,7 @@ unsafe extern "C" fn base_parse_set_sink_caps<T: BaseParseImpl>(
let wrap: Borrowed<BaseParse> = from_glib_borrow(ptr);
let caps: Borrowed<gst::Caps> = from_glib_borrow(caps);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_sink_caps(wrap.unsafe_cast_ref(), &caps) {
Ok(()) => true,
Err(err) => {
@ -282,8 +282,8 @@ unsafe extern "C" fn base_parse_handle_frame<T: BaseParseImpl>(
let wrap: Borrowed<BaseParse> = from_glib_borrow(ptr);
let wrap_frame = BaseParseFrame::new(frame, &wrap);
let res = gst::panic_to_error!(&wrap, &imp.panicked(), Err(gst::FlowError::Error), {
imp.handle_frame(&wrap.unsafe_cast_ref(), wrap_frame)
let res = gst::panic_to_error!(&wrap, imp.panicked(), Err(gst::FlowError::Error), {
imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame)
});
match res {
@ -308,7 +308,7 @@ unsafe extern "C" fn base_parse_convert<T: BaseParseImpl>(
let wrap: Borrowed<BaseParse> = from_glib_borrow(ptr);
let source = gst::GenericFormattedValue::new(from_glib(source_format), source_value);
let res = gst::panic_to_error!(&wrap, &imp.panicked(), None, {
let res = gst::panic_to_error!(&wrap, imp.panicked(), None, {
imp.convert(wrap.unsafe_cast_ref(), source, from_glib(dest_format))
});

26
gstreamer-base/src/subclass/base_sink.rs
View file

@ -418,7 +418,7 @@ unsafe extern "C" fn base_sink_start<T: BaseSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -437,7 +437,7 @@ unsafe extern "C" fn base_sink_stop<T: BaseSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -458,7 +458,7 @@ unsafe extern "C" fn base_sink_render<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let buffer = from_glib_borrow(buffer);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.render(wrap.unsafe_cast_ref(), &buffer).into()
})
.into_glib()
@ -473,7 +473,7 @@ unsafe extern "C" fn base_sink_prepare<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let buffer = from_glib_borrow(buffer);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.prepare(wrap.unsafe_cast_ref(), &buffer).into()
})
.into_glib()
@ -488,7 +488,7 @@ unsafe extern "C" fn base_sink_render_list<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let list = from_glib_borrow(list);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.render_list(wrap.unsafe_cast_ref(), &list).into()
})
.into_glib()
@ -503,7 +503,7 @@ unsafe extern "C" fn base_sink_prepare_list<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let list = from_glib_borrow(list);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.prepare_list(wrap.unsafe_cast_ref(), &list).into()
})
.into_glib()
@ -518,7 +518,7 @@ unsafe extern "C" fn base_sink_query<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query_ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
BaseSinkImpl::query(imp, wrap.unsafe_cast_ref(), query)
})
.into_glib()
@ -532,7 +532,7 @@ unsafe extern "C" fn base_sink_event<T: BaseSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.event(wrap.unsafe_cast_ref(), from_glib_full(event_ptr))
})
.into_glib()
@ -547,7 +547,7 @@ unsafe extern "C" fn base_sink_get_caps<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let filter = Option::<gst::Caps>::from_glib_borrow(filter);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
imp.caps(wrap.unsafe_cast_ref(), filter.as_ref().as_ref())
})
.map(|caps| caps.into_ptr())
@ -563,7 +563,7 @@ unsafe extern "C" fn base_sink_set_caps<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let caps = from_glib_borrow(caps);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_caps(wrap.unsafe_cast_ref(), &caps) {
Ok(()) => true,
Err(err) => {
@ -584,7 +584,7 @@ unsafe extern "C" fn base_sink_fixate<T: BaseSinkImpl>(
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
let caps = from_glib_full(caps);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
imp.fixate(wrap.unsafe_cast_ref(), caps)
})
.into_ptr()
@ -597,7 +597,7 @@ unsafe extern "C" fn base_sink_unlock<T: BaseSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unlock(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -616,7 +616,7 @@ unsafe extern "C" fn base_sink_unlock_stop<T: BaseSinkImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSink> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unlock_stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {

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

@ -606,7 +606,7 @@ unsafe extern "C" fn base_src_start<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -625,7 +625,7 @@ unsafe extern "C" fn base_src_stop<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -644,7 +644,7 @@ unsafe extern "C" fn base_src_is_seekable<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.is_seekable(wrap.unsafe_cast_ref())
})
.into_glib()
@ -658,7 +658,7 @@ unsafe extern "C" fn base_src_get_size<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.size(wrap.unsafe_cast_ref()) {
Some(s) => {
*size = s;
@ -684,7 +684,7 @@ unsafe extern "C" fn base_src_get_times<T: BaseSrcImpl>(
*start = gst::ffi::GST_CLOCK_TIME_NONE;
*stop = gst::ffi::GST_CLOCK_TIME_NONE;
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
let (start_, stop_) = imp.times(wrap.unsafe_cast_ref(), buffer);
*start = start_.into_glib();
*stop = stop_.into_glib();
@ -702,7 +702,7 @@ unsafe extern "C" fn base_src_fill<T: BaseSrcImpl>(
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
let buffer = gst::BufferRef::from_mut_ptr(buffer);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.fill(wrap.unsafe_cast_ref(), offset, length, buffer)
.into()
})
@ -722,7 +722,7 @@ unsafe extern "C" fn base_src_alloc<T: BaseSrcImpl>(
// https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3
let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer;
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.alloc(wrap.unsafe_cast_ref(), offset, length) {
Ok(buffer) => {
*buffer_ptr = buffer.into_ptr();
@ -753,7 +753,7 @@ unsafe extern "C" fn base_src_create<T: BaseSrcImpl>(
Some(gst::BufferRef::from_mut_ptr(*buffer_ptr))
};
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.create(
wrap.unsafe_cast_ref(),
offset,
@ -828,7 +828,7 @@ unsafe extern "C" fn base_src_do_seek<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
let mut s = from_glib_none(segment);
let res = imp.do_seek(wrap.unsafe_cast_ref(), &mut s);
ptr::write(segment, *(s.to_glib_none().0));
@ -847,7 +847,7 @@ unsafe extern "C" fn base_src_query<T: BaseSrcImpl>(
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query_ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
BaseSrcImpl::query(imp, wrap.unsafe_cast_ref(), query)
})
.into_glib()
@ -861,7 +861,7 @@ unsafe extern "C" fn base_src_event<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.event(wrap.unsafe_cast_ref(), &from_glib_borrow(event_ptr))
})
.into_glib()
@ -876,7 +876,7 @@ unsafe extern "C" fn base_src_get_caps<T: BaseSrcImpl>(
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
let filter = Option::<gst::Caps>::from_glib_borrow(filter);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
imp.caps(wrap.unsafe_cast_ref(), filter.as_ref().as_ref())
})
.map(|caps| caps.into_ptr())
@ -890,7 +890,7 @@ unsafe extern "C" fn base_src_negotiate<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -911,7 +911,7 @@ unsafe extern "C" fn base_src_set_caps<T: BaseSrcImpl>(
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
let caps = from_glib_borrow(caps);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_caps(wrap.unsafe_cast_ref(), &caps) {
Ok(()) => true,
Err(err) => {
@ -932,7 +932,7 @@ unsafe extern "C" fn base_src_fixate<T: BaseSrcImpl>(
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
let caps = from_glib_full(caps);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
imp.fixate(wrap.unsafe_cast_ref(), caps)
})
.into_ptr()
@ -945,7 +945,7 @@ unsafe extern "C" fn base_src_unlock<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unlock(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -964,7 +964,7 @@ unsafe extern "C" fn base_src_unlock_stop<T: BaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unlock_stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {

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

@ -891,7 +891,7 @@ unsafe extern "C" fn base_transform_start<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -910,7 +910,7 @@ unsafe extern "C" fn base_transform_stop<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -932,7 +932,7 @@ unsafe extern "C" fn base_transform_transform_caps<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
let filter: Borrowed<Option<gst::Caps>> = from_glib_borrow(filter);
imp.transform_caps(
@ -956,7 +956,7 @@ unsafe extern "C" fn base_transform_fixate_caps<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
imp.fixate_caps(
wrap.unsafe_cast_ref(),
from_glib(direction),
@ -976,7 +976,7 @@ unsafe extern "C" fn base_transform_set_caps<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_caps(
wrap.unsafe_cast_ref(),
&from_glib_borrow(incaps),
@ -1001,7 +1001,7 @@ unsafe extern "C" fn base_transform_accept_caps<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.accept_caps(
wrap.unsafe_cast_ref(),
from_glib(direction),
@ -1020,7 +1020,7 @@ unsafe extern "C" fn base_transform_query<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
BaseTransformImpl::query(
imp,
wrap.unsafe_cast_ref(),
@ -1043,7 +1043,7 @@ unsafe extern "C" fn base_transform_transform_size<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.transform_size(
wrap.unsafe_cast_ref(),
from_glib(direction),
@ -1070,7 +1070,7 @@ unsafe extern "C" fn base_transform_get_unit_size<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.unit_size(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) {
Some(s) => {
*size = s;
@ -1094,7 +1094,7 @@ unsafe extern "C" fn base_transform_prepare_output_buffer<T: BaseTransformImpl>(
// FIXME: Wrong signature in FFI
let outbuf = outbuf as *mut *mut gst::ffi::GstBuffer;
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.prepare_output_buffer(wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(inbuf)) {
Ok(PrepareOutputBufferSuccess::InputBuffer) => {
*outbuf = inbuf;
@ -1118,7 +1118,7 @@ unsafe extern "C" fn base_transform_sink_event<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -1132,7 +1132,7 @@ unsafe extern "C" fn base_transform_src_event<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -1147,7 +1147,7 @@ unsafe extern "C" fn base_transform_transform<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.transform(
wrap.unsafe_cast_ref(),
&from_glib_borrow(inbuf),
@ -1169,7 +1169,7 @@ unsafe extern "C" fn base_transform_transform_ip<T: BaseTransformImpl>(
// FIXME: Wrong signature in FFI
let buf = buf as *mut gst::ffi::GstBuffer;
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
if from_glib(ffi::gst_base_transform_is_passthrough(ptr)) {
imp.transform_ip_passthrough(wrap.unsafe_cast_ref(), &from_glib_borrow(buf))
.into()
@ -1193,7 +1193,7 @@ unsafe extern "C" fn base_transform_transform_meta<T: BaseTransformImpl>(
let inbuf = gst::BufferRef::from_ptr(inbuf);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.transform_meta(
wrap.unsafe_cast_ref(),
gst::BufferRef::from_mut_ptr(outbuf),
@ -1223,7 +1223,7 @@ unsafe extern "C" fn base_transform_copy_metadata<T: BaseTransformImpl>(
return glib::ffi::GFALSE;
}
gst::panic_to_error!(&wrap, &imp.panicked(), true, {
gst::panic_to_error!(&wrap, imp.panicked(), true, {
match imp.copy_metadata(
wrap.unsafe_cast_ref(),
gst::BufferRef::from_ptr(inbuf),
@ -1247,7 +1247,7 @@ unsafe extern "C" fn base_transform_before_transform<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
imp.before_transform(wrap.unsafe_cast_ref(), gst::BufferRef::from_ptr(inbuf));
})
}
@ -1261,7 +1261,7 @@ unsafe extern "C" fn base_transform_submit_input_buffer<T: BaseTransformImpl>(
let imp = instance.impl_();
let wrap: Borrowed<BaseTransform> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.submit_input_buffer(
wrap.unsafe_cast_ref(),
from_glib(is_discont),
@ -1282,7 +1282,7 @@ unsafe extern "C" fn base_transform_generate_output<T: BaseTransformImpl>(
*buf = ptr::null_mut();
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match imp.generate_output(wrap.unsafe_cast_ref()) {
Ok(GenerateOutputSuccess::Dropped) => crate::BASE_TRANSFORM_FLOW_DROPPED.into(),
Ok(GenerateOutputSuccess::NoOutput) => gst::FlowReturn::Ok,

6
gstreamer-base/src/subclass/push_src.rs
View file

@ -130,7 +130,7 @@ unsafe extern "C" fn push_src_fill<T: PushSrcImpl>(
let wrap: Borrowed<PushSrc> = from_glib_borrow(ptr);
let buffer = gst::BufferRef::from_mut_ptr(buffer);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
PushSrcImpl::fill(imp, wrap.unsafe_cast_ref(), buffer).into()
})
.into_glib()
@ -147,7 +147,7 @@ unsafe extern "C" fn push_src_alloc<T: PushSrcImpl>(
// https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3
let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer;
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match PushSrcImpl::alloc(imp, wrap.unsafe_cast_ref()) {
Ok(buffer) => {
*buffer_ptr = buffer.into_ptr();
@ -170,7 +170,7 @@ unsafe extern "C" fn push_src_create<T: PushSrcImpl>(
// https://gitlab.freedesktop.org/gstreamer/gstreamer-rs-sys/issues/3
let buffer_ptr = buffer_ptr as *mut *mut gst::ffi::GstBuffer;
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
match PushSrcImpl::create(imp, wrap.unsafe_cast_ref()) {
Ok(buffer) => {
*buffer_ptr = buffer.into_ptr();

1
gstreamer-editing-services/src/lib.rs
View file

@ -53,6 +53,7 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)]
#[allow(clippy::use_self)]
#[allow(clippy::needless_borrow)]
mod auto;
pub use crate::auto::*;

6
gstreamer-gl/src/subclass/gl_base_filter.rs
View file

@ -123,7 +123,7 @@ unsafe extern "C" fn gl_set_caps<T: GLBaseFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLBaseFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.gl_set_caps(
wrap.unsafe_cast_ref(),
&from_glib_borrow(incaps),
@ -146,7 +146,7 @@ unsafe extern "C" fn gl_start<T: GLBaseFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLBaseFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.gl_start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -163,7 +163,7 @@ unsafe extern "C" fn gl_stop<T: GLBaseFilterImpl>(ptr: *mut GstGLBaseFilter) {
let imp = instance.impl_();
let wrap: Borrowed<GLBaseFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
imp.gl_stop(wrap.unsafe_cast_ref())
})
}

6
gstreamer-gl/src/subclass/gl_base_src.rs
View file

@ -113,7 +113,7 @@ unsafe extern "C" fn gl_start<T: GLBaseSrcImpl>(ptr: *mut GstGLBaseSrc) -> glib:
let imp = instance.impl_();
let wrap: Borrowed<GLBaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.gl_start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -130,7 +130,7 @@ unsafe extern "C" fn gl_stop<T: GLBaseSrcImpl>(ptr: *mut GstGLBaseSrc) {
let imp = instance.impl_();
let wrap: Borrowed<GLBaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), (), {
gst::panic_to_error!(&wrap, imp.panicked(), (), {
imp.gl_stop(wrap.unsafe_cast_ref())
})
}
@ -143,7 +143,7 @@ unsafe extern "C" fn fill_gl_memory<T: GLBaseSrcImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLBaseSrc> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.fill_gl_memory(wrap.unsafe_cast_ref(), &from_glib_borrow(memory)) {
Ok(()) => true,
Err(err) => {

10
gstreamer-gl/src/subclass/gl_filter.rs
View file

@ -262,7 +262,7 @@ unsafe extern "C" fn filter<T: GLFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.filter(
wrap.unsafe_cast_ref(),
&from_glib_borrow(input),
@ -287,7 +287,7 @@ unsafe extern "C" fn filter_texture<T: GLFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.filter_texture(
wrap.unsafe_cast_ref(),
&from_glib_borrow(input),
@ -308,7 +308,7 @@ unsafe extern "C" fn init_fbo<T: GLFilterImpl>(ptr: *mut GstGLFilter) -> glib::f
let imp = instance.impl_();
let wrap: Borrowed<GLFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.init_fbo(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -329,7 +329,7 @@ unsafe extern "C" fn set_caps<T: GLFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match GLFilterImpl::set_caps(
imp,
wrap.unsafe_cast_ref(),
@ -356,7 +356,7 @@ unsafe extern "C" fn transform_internal_caps<T: GLFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<GLFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), None, {
gst::panic_to_error!(&wrap, imp.panicked(), None, {
let filter_caps: Borrowed<Option<Caps>> = from_glib_borrow(filter_caps);
imp.transform_internal_caps(

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

@ -61,5 +61,5 @@ unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'sta
P: IsA<Discoverer>,
{
let f: &F = &*(f as *const F);
f(&Discoverer::from_glib_borrow(this).unsafe_cast_ref())
f(Discoverer::from_glib_borrow(this).unsafe_cast_ref())
}

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

@ -92,7 +92,7 @@ where
{
let f: &F = &*(f as *const F);
match f(
&RTSPAuth::from_glib_borrow(this).unsafe_cast_ref(),
RTSPAuth::from_glib_borrow(this).unsafe_cast_ref(),
&from_glib_borrow(connection),
&from_glib_borrow(peer_cert),
from_glib(errors),

1
gstreamer-video/src/lib.rs
View file

@ -23,6 +23,7 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)]
#[allow(clippy::use_self)]
#[allow(clippy::needless_borrow)]
mod auto;
pub use crate::auto::*;

36
gstreamer-video/src/subclass/video_decoder.rs
View file

@ -562,7 +562,7 @@ unsafe extern "C" fn video_decoder_open<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -581,7 +581,7 @@ unsafe extern "C" fn video_decoder_close<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -600,7 +600,7 @@ unsafe extern "C" fn video_decoder_start<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -619,7 +619,7 @@ unsafe extern "C" fn video_decoder_stop<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -638,7 +638,7 @@ unsafe extern "C" fn video_decoder_finish<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.finish(wrap.unsafe_cast_ref()).into()
})
.into_glib()
@ -651,7 +651,7 @@ unsafe extern "C" fn video_decoder_drain<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.drain(wrap.unsafe_cast_ref()).into()
})
.into_glib()
@ -667,7 +667,7 @@ unsafe extern "C" fn video_decoder_set_format<T: VideoDecoderImpl>(
ffi::gst_video_codec_state_ref(state);
let wrap_state = VideoCodecState::<Readable>::new(state);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) {
Ok(()) => true,
Err(err) => {
@ -693,7 +693,7 @@ unsafe extern "C" fn video_decoder_parse<T: VideoDecoderImpl>(
let wrap_adapter: Borrowed<gst_base::Adapter> = from_glib_borrow(adapter);
let at_eos: bool = from_glib(at_eos);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.parse(wrap.unsafe_cast_ref(), &wrap_frame, &wrap_adapter, at_eos)
.into()
})
@ -709,7 +709,7 @@ unsafe extern "C" fn video_decoder_handle_frame<T: VideoDecoderImpl>(
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into()
})
.into_glib()
@ -722,7 +722,7 @@ unsafe extern "C" fn video_decoder_flush<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
VideoDecoderImpl::flush(imp, wrap.unsafe_cast_ref())
})
.into_glib()
@ -735,7 +735,7 @@ unsafe extern "C" fn video_decoder_negotiate<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -755,7 +755,7 @@ unsafe extern "C" fn video_decoder_getcaps<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
VideoDecoderImpl::caps(
imp,
wrap.unsafe_cast_ref(),
@ -775,7 +775,7 @@ unsafe extern "C" fn video_decoder_sink_event<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -789,7 +789,7 @@ unsafe extern "C" fn video_decoder_sink_query<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -803,7 +803,7 @@ unsafe extern "C" fn video_decoder_src_event<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -817,7 +817,7 @@ unsafe extern "C" fn video_decoder_src_query<T: VideoDecoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -832,7 +832,7 @@ unsafe extern "C" fn video_decoder_propose_allocation<T: VideoDecoderImpl>(
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {
@ -853,7 +853,7 @@ unsafe extern "C" fn video_decoder_decide_allocation<T: VideoDecoderImpl>(
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {

32
gstreamer-video/src/subclass/video_encoder.rs
View file

@ -496,7 +496,7 @@ unsafe extern "C" fn video_encoder_open<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -515,7 +515,7 @@ unsafe extern "C" fn video_encoder_close<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -534,7 +534,7 @@ unsafe extern "C" fn video_encoder_start<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -553,7 +553,7 @@ unsafe extern "C" fn video_encoder_stop<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -572,7 +572,7 @@ unsafe extern "C" fn video_encoder_finish<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.finish(wrap.unsafe_cast_ref()).into()
})
.into_glib()
@ -588,7 +588,7 @@ unsafe extern "C" fn video_encoder_set_format<T: VideoEncoderImpl>(
ffi::gst_video_codec_state_ref(state);
let wrap_state = VideoCodecState::<Readable>::new(state);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) {
Ok(()) => true,
Err(err) => {
@ -609,7 +609,7 @@ unsafe extern "C" fn video_encoder_handle_frame<T: VideoEncoderImpl>(
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into()
})
.into_glib()
@ -622,7 +622,7 @@ unsafe extern "C" fn video_encoder_flush<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
VideoEncoderImpl::flush(imp, wrap.unsafe_cast_ref())
})
.into_glib()
@ -635,7 +635,7 @@ unsafe extern "C" fn video_encoder_negotiate<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
@ -655,7 +655,7 @@ unsafe extern "C" fn video_encoder_getcaps<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::Caps::new_empty(), {
gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
VideoEncoderImpl::caps(
imp,
wrap.unsafe_cast_ref(),
@ -675,7 +675,7 @@ unsafe extern "C" fn video_encoder_sink_event<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -689,7 +689,7 @@ unsafe extern "C" fn video_encoder_sink_query<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -703,7 +703,7 @@ unsafe extern "C" fn video_encoder_src_event<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -717,7 +717,7 @@ unsafe extern "C" fn video_encoder_src_query<T: VideoEncoderImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
})
.into_glib()
@ -732,7 +732,7 @@ unsafe extern "C" fn video_encoder_propose_allocation<T: VideoEncoderImpl>(
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {
@ -753,7 +753,7 @@ unsafe extern "C" fn video_encoder_decide_allocation<T: VideoEncoderImpl>(
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true,
Err(err) => {

6
gstreamer-video/src/subclass/video_filter.rs
View file

@ -247,7 +247,7 @@ unsafe extern "C" fn video_filter_set_info<T: VideoFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), false, {
gst::panic_to_error!(&wrap, imp.panicked(), false, {
match imp.set_info(
wrap.unsafe_cast_ref(),
&from_glib_borrow(incaps),
@ -274,7 +274,7 @@ unsafe extern "C" fn video_filter_transform_frame<T: VideoFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.transform_frame(
wrap.unsafe_cast_ref(),
&VideoFrameRef::from_glib_borrow(inframe),
@ -293,7 +293,7 @@ unsafe extern "C" fn video_filter_transform_frame_ip<T: VideoFilterImpl>(
let imp = instance.impl_();
let wrap: Borrowed<VideoFilter> = from_glib_borrow(ptr);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
if from_glib(gst_base::ffi::gst_base_transform_is_passthrough(
ptr as *mut gst_base::ffi::GstBaseTransform,
)) {

2
gstreamer-video/src/subclass/video_sink.rs
View file

@ -68,7 +68,7 @@ unsafe extern "C" fn video_sink_show_frame<T: VideoSinkImpl>(
let wrap: Borrowed<VideoSink> = from_glib_borrow(ptr);
let buffer = from_glib_borrow(buffer);
gst::panic_to_error!(&wrap, &imp.panicked(), gst::FlowReturn::Error, {
gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
imp.show_frame(wrap.unsafe_cast_ref(), &buffer).into()
})
.into_glib()

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

@ -328,9 +328,9 @@ impl Ord for VideoFormatInfo {
fn cmp(&self, other: &Self) -> Ordering {
self.n_components()
.cmp(&other.n_components())
.then_with(|| self.depth().cmp(&other.depth()))
.then_with(|| self.w_sub().cmp(&other.w_sub()).reverse())
.then_with(|| self.h_sub().cmp(&other.h_sub()).reverse())
.then_with(|| self.depth().cmp(other.depth()))
.then_with(|| self.w_sub().cmp(other.w_sub()).reverse())
.then_with(|| self.h_sub().cmp(other.h_sub()).reverse())
.then_with(|| self.n_planes().cmp(&other.n_planes()))
.then_with(|| {
// Format using native endianess is considered as bigger
@ -363,8 +363,8 @@ impl Ord for VideoFormatInfo {
_ => Ordering::Equal,
}
})
.then_with(|| self.pixel_stride().cmp(&other.pixel_stride()))
.then_with(|| self.poffset().cmp(&other.poffset()))
.then_with(|| self.pixel_stride().cmp(other.pixel_stride()))
.then_with(|| self.poffset().cmp(other.poffset()))
.then_with(|| {
// Prefer non-complex formats
match (
@ -401,7 +401,7 @@ impl Ord for VideoFormatInfo {
})
.then_with(|| {
// tie, sort by name
self.name().cmp(&other.name())
self.name().cmp(other.name())
})
}
}

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

@ -23,6 +23,7 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)]
#[allow(clippy::use_self)]
#[allow(clippy::needless_borrow)]
mod auto;
pub use crate::auto::*;

2
gstreamer/src/bin.rs
View file

@ -218,7 +218,7 @@ where
P: IsA<Bin>,
{
let f: &F = &*(f as *const F);
match f(&Bin::from_glib_borrow(this).unsafe_cast_ref()) {
match f(Bin::from_glib_borrow(this).unsafe_cast_ref()) {
Ok(()) => true,
Err(err) => {
err.log_with_object(&*Bin::from_glib_borrow(this));

2
gstreamer/src/element.rs
View file

@ -743,7 +743,7 @@ impl<O: IsA<Element>> ElementExtManual for O {
let user_data: &mut Option<F> = &mut *(user_data as *mut _);
let callback = user_data.take().unwrap();
callback(&Element::from_glib_borrow(element).unsafe_cast_ref());
callback(Element::from_glib_borrow(element).unsafe_cast_ref());
}
unsafe extern "C" fn free_user_data<O: IsA<Element>, F: FnOnce(&O) + Send + 'static>(

1
gstreamer/src/lib.rs
View file

@ -27,6 +27,7 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::match_same_arms)]
#[allow(clippy::type_complexity)]
#[allow(clippy::use_self)]
#[allow(clippy::needless_borrow)]
mod auto;
pub use crate::auto::functions::*;
pub use crate::auto::*;

24
gstreamer/src/pad.rs
View file

@ -1157,7 +1157,7 @@ where
let (mut probe_info, data_type) = create_probe_info(info);
let ret = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
&mut probe_info,
);
@ -1179,7 +1179,7 @@ where
let func: &F = &*((*pad).activatedata as *const F);
match func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1211,7 +1211,7 @@ where
let func: &F = &*((*pad).activatemodedata as *const F);
match func(
&&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1244,7 +1244,7 @@ where
let func: &F = &*((*pad).chaindata as *const F);
let res: FlowReturn = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1271,7 +1271,7 @@ where
let func: &F = &*((*pad).chainlistdata as *const F);
let res: FlowReturn = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1295,7 +1295,7 @@ where
let func: &F = &*((*pad).eventdata as *const F);
func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1321,7 +1321,7 @@ where
let func: &F = &*((*pad).eventdata as *const F);
let res: FlowReturn = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1366,7 +1366,7 @@ where
};
match func(
&pad,
pad,
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1440,7 +1440,7 @@ where
// Steal the iterator and return it
let ret = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1470,7 +1470,7 @@ where
let func: &F = &*((*pad).linkdata as *const F);
let res: crate::PadLinkReturn = func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1494,7 +1494,7 @@ where
let func: &F = &*((*pad).querydata as *const F);
func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),
@ -1515,7 +1515,7 @@ unsafe extern "C" fn trampoline_unlink_function<
let func: &F = &*((*pad).unlinkdata as *const F);
func(
&Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Pad::from_glib_borrow(pad).unsafe_cast_ref(),
Option::<crate::Object>::from_glib_borrow(parent)
.as_ref()
.as_ref(),

4
gstreamer/src/structure.rs
View file

@ -941,7 +941,7 @@ mod tests {
let a = "Test, f1=(string)abc, f2=(uint)123;";
let s = Structure::from_str(&a).unwrap();
let s = Structure::from_str(a).unwrap();
assert_eq!(s.get::<&str>("f1"), Ok("abc"));
assert_eq!(s.get::<u32>("f2"), Ok(123));
@ -956,7 +956,7 @@ mod tests {
let a = None::<&Structure>.to_value();
assert!(a.get::<Option<Structure>>().unwrap().is_none());
let b = Structure::from_str(&"foo").unwrap().to_value();
let b = Structure::from_str("foo").unwrap().to_value();
assert!(b.get::<Option<Structure>>().unwrap().is_some());
}

6
gstreamer/src/subclass/bin.rs
View file

@ -120,7 +120,7 @@ unsafe extern "C" fn bin_add_element<T: BinImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Bin> = from_glib_borrow(ptr);
panic_to_error!(&wrap, &imp.panicked(), false, {
panic_to_error!(&wrap, imp.panicked(), false, {
match imp.add_element(wrap.unsafe_cast_ref(), &from_glib_none(element)) {
Ok(()) => true,
Err(err) => {
@ -149,7 +149,7 @@ unsafe extern "C" fn bin_remove_element<T: BinImpl>(
return glib::ffi::GFALSE;
}
panic_to_error!(&wrap, &imp.panicked(), false, {
panic_to_error!(&wrap, imp.panicked(), false, {
match imp.remove_element(wrap.unsafe_cast_ref(), &from_glib_none(element)) {
Ok(()) => true,
Err(err) => {
@ -169,7 +169,7 @@ unsafe extern "C" fn bin_handle_message<T: BinImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Bin> = from_glib_borrow(ptr);
panic_to_error!(&wrap, &imp.panicked(), (), {
panic_to_error!(&wrap, imp.panicked(), (), {
imp.handle_message(wrap.unsafe_cast_ref(), from_glib_full(message))
});
}

10
gstreamer/src/subclass/child_proxy.rs
View file

@ -135,7 +135,7 @@ unsafe extern "C" fn child_proxy_get_child_by_name<T: ChildProxyImpl>(
let imp = instance.impl_();
imp.child_by_name(
&from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
&glib::GString::from_glib_borrow(name),
)
.to_glib_full()
@ -149,7 +149,7 @@ unsafe extern "C" fn child_proxy_get_child_by_index<T: ChildProxyImpl>(
let imp = instance.impl_();
imp.child_by_index(
&from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
index,
)
.to_glib_full()
@ -161,7 +161,7 @@ unsafe extern "C" fn child_proxy_get_children_count<T: ChildProxyImpl>(
let instance = &*(child_proxy as *mut T::Instance);
let imp = instance.impl_();
imp.children_count(&from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref())
imp.children_count(from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref())
}
unsafe extern "C" fn child_proxy_child_added<T: ChildProxyImpl>(
@ -173,7 +173,7 @@ unsafe extern "C" fn child_proxy_child_added<T: ChildProxyImpl>(
let imp = instance.impl_();
imp.child_added(
&from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
&from_glib_borrow(child),
&glib::GString::from_glib_borrow(name),
)
@ -188,7 +188,7 @@ unsafe extern "C" fn child_proxy_child_removed<T: ChildProxyImpl>(
let imp = instance.impl_();
imp.child_removed(
&from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
from_glib_borrow::<_, ChildProxy>(child_proxy).unsafe_cast_ref(),
&from_glib_borrow(child),
&glib::GString::from_glib_borrow(name),
)

26
gstreamer/src/subclass/element.rs
View file

@ -332,7 +332,7 @@ impl<T: ElementImpl> ElementImplExt for T {
let instance = &*(ptr as *mut T::Instance);
let imp = instance.impl_();
panic_to_error!(element, &imp.panicked(), fallback(), { f(&imp) })
panic_to_error!(element, imp.panicked(), fallback(), { f(imp) })
}
}
@ -348,8 +348,8 @@ impl<T: ElementImpl> ElementImplExt for T {
let instance = &*(ptr as *mut Self::Instance);
let imp = instance.impl_();
panic_to_error!(wrap, &imp.panicked(), fallback(), {
f(&imp, wrap.unsafe_cast_ref())
panic_to_error!(wrap, imp.panicked(), fallback(), {
f(imp, wrap.unsafe_cast_ref())
})
}
}
@ -420,7 +420,7 @@ unsafe extern "C" fn element_change_state<T: ElementImpl>(
_ => StateChangeReturn::Failure,
};
panic_to_error!(&wrap, &imp.panicked(), fallback, {
panic_to_error!(&wrap, imp.panicked(), fallback, {
imp.change_state(wrap.unsafe_cast_ref(), transition).into()
})
.into_glib()
@ -440,7 +440,7 @@ unsafe extern "C" fn element_request_new_pad<T: ElementImpl>(
// XXX: This is effectively unsafe but the best we can do
// See https://bugzilla.gnome.org/show_bug.cgi?id=791193
let pad = panic_to_error!(&wrap, &imp.panicked(), None, {
let pad = panic_to_error!(&wrap, imp.panicked(), None, {
imp.request_new_pad(
wrap.unsafe_cast_ref(),
&from_glib_borrow(templ),
@ -478,7 +478,7 @@ unsafe extern "C" fn element_release_pad<T: ElementImpl>(
return;
}
panic_to_error!(&wrap, &imp.panicked(), (), {
panic_to_error!(&wrap, imp.panicked(), (), {
imp.release_pad(wrap.unsafe_cast_ref(), &from_glib_none(pad))
})
}
@ -491,7 +491,7 @@ unsafe extern "C" fn element_send_event<T: ElementImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Element> = from_glib_borrow(ptr);
panic_to_error!(&wrap, &imp.panicked(), false, {
panic_to_error!(&wrap, imp.panicked(), false, {
imp.send_event(wrap.unsafe_cast_ref(), from_glib_full(event))
})
.into_glib()
@ -506,7 +506,7 @@ unsafe extern "C" fn element_query<T: ElementImpl>(
let wrap: Borrowed<Element> = from_glib_borrow(ptr);
let query = QueryRef::from_mut_ptr(query);
panic_to_error!(&wrap, &imp.panicked(), false, {
panic_to_error!(&wrap, imp.panicked(), false, {
imp.query(wrap.unsafe_cast_ref(), query)
})
.into_glib()
@ -520,7 +520,7 @@ unsafe extern "C" fn element_set_context<T: ElementImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Element> = from_glib_borrow(ptr);
panic_to_error!(&wrap, &imp.panicked(), (), {
panic_to_error!(&wrap, imp.panicked(), (), {
imp.set_context(wrap.unsafe_cast_ref(), &from_glib_borrow(context))
})
}
@ -535,7 +535,7 @@ unsafe extern "C" fn element_set_clock<T: ElementImpl>(
let clock = Option::<crate::Clock>::from_glib_borrow(clock);
panic_to_error!(&wrap, &imp.panicked(), false, {
panic_to_error!(&wrap, imp.panicked(), false, {
imp.set_clock(wrap.unsafe_cast_ref(), clock.as_ref().as_ref())
})
.into_glib()
@ -548,7 +548,7 @@ unsafe extern "C" fn element_provide_clock<T: ElementImpl>(
let imp = instance.impl_();
let wrap: Borrowed<Element> = from_glib_borrow(ptr);
panic_to_error!(&wrap, &imp.panicked(), None, {
panic_to_error!(&wrap, imp.panicked(), None, {
imp.provide_clock(wrap.unsafe_cast_ref())
})
.to_glib_full()
@ -790,9 +790,9 @@ mod tests {
src.set_property("num-buffers", &100i32).unwrap();
pipeline
.add_many(&[&src, &element.upcast_ref(), &sink])
.add_many(&[&src, element.upcast_ref(), &sink])
.unwrap();
Element::link_many(&[&src, &element.upcast_ref(), &sink]).unwrap();
Element::link_many(&[&src, element.upcast_ref(), &sink]).unwrap();
pipeline.set_state(crate::State::Playing).unwrap();
let bus = pipeline.bus().unwrap();

4
gstreamer/src/subclass/uri_handler.rs
View file

@ -128,7 +128,7 @@ unsafe extern "C" fn uri_handler_get_uri<T: URIHandlerImpl>(
let instance = &*(uri_handler as *mut T::Instance);
let imp = instance.impl_();
imp.uri(&from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref())
imp.uri(from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref())
.to_glib_full()
}
@ -141,7 +141,7 @@ unsafe extern "C" fn uri_handler_set_uri<T: URIHandlerImpl>(
let imp = instance.impl_();
match imp.set_uri(
&from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref(),
from_glib_borrow::<_, URIHandler>(uri_handler).unsafe_cast_ref(),
glib::GString::from_glib_borrow(uri).as_str(),
) {
Ok(()) => true.into_glib(),