mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-05-20 01:08:26 +00:00
Code Issues Projects Releases Wiki Activity

Update for class struct handling changes in the glib bindings

Browse source 
See https://github.com/gtk-rs/gtk-rs/pull/10
This commit is contained in:
Sebastian Dröge 2020-11-05 15:18:19 +02:00
parent 0dd9275b8f
commit 027de84349
29 changed files with 118 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -23,7 +23,6 @@ use std::ptr;
use crate::prelude::*;
use AudioDecoder;
use AudioDecoderClass;
pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
fn open(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
@ -510,14 +509,14 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
}
}
unsafe impl<T: AudioDecoderImpl> IsSubclassable<T> for AudioDecoderClass
unsafe impl<T: AudioDecoderImpl> IsSubclassable<T> for AudioDecoder
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioDecoderClass);
let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioDecoderClass);
klass.open = Some(audio_decoder_open::<T>);
klass.close = Some(audio_decoder_close::<T>);
klass.start = Some(audio_decoder_start::<T>);

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

@ -21,7 +21,6 @@ use std::ptr;
use crate::prelude::*;
use AudioEncoder;
use AudioEncoderClass;
use AudioInfo;
pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl {
@ -459,14 +458,14 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
}
}
unsafe impl<T: AudioEncoderImpl> IsSubclassable<T> for AudioEncoderClass
unsafe impl<T: AudioEncoderImpl> IsSubclassable<T> for AudioEncoder
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioEncoderClass);
let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioEncoderClass);
klass.open = Some(audio_encoder_open::<T>);
klass.close = Some(audio_encoder_close::<T>);
klass.start = Some(audio_encoder_start::<T>);

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

@ -10,7 +10,6 @@ use gst_base::subclass::prelude::*;
use AudioRingBufferSpec;
use AudioSink;
use AudioSinkClass;
pub trait AudioSinkImpl: AudioSinkImplExt + BaseSinkImpl {
fn close(&self, sink: &AudioSink) -> Result<(), LoggableError> {
@ -185,14 +184,14 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
}
}
unsafe impl<T: AudioSinkImpl> IsSubclassable<T> for AudioSinkClass
unsafe impl<T: AudioSinkImpl> IsSubclassable<T> for AudioSink
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst_base::BaseSinkClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst_base::BaseSink as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioSinkClass);
let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioSinkClass);
klass.close = Some(audiosink_close::<T>);
klass.delay = Some(audiosink_delay::<T>);
klass.open = Some(audiosink_open::<T>);

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

@ -12,7 +12,6 @@ use gst_base::subclass::prelude::*;
use AudioRingBufferSpec;
use AudioSrc;
use AudioSrcClass;
pub trait AudioSrcImpl: AudioSrcImplExt + BaseSrcImpl {
fn close(&self, src: &AudioSrc) -> Result<(), LoggableError> {
@ -201,14 +200,14 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
}
}
unsafe impl<T: AudioSrcImpl> IsSubclassable<T> for AudioSrcClass
unsafe impl<T: AudioSrcImpl> IsSubclassable<T> for AudioSrc
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst_base::BaseSrcClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst_base::BaseSrc as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioSrcClass);
let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioSrcClass);
klass.close = Some(audiosrc_close::<T>);
klass.delay = Some(audiosrc_delay::<T>);
klass.open = Some(audiosrc_open::<T>);

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

@ -21,7 +21,6 @@ use gst::subclass::prelude::*;
use std::ptr;
use Aggregator;
use AggregatorClass;
use AggregatorPad;
pub trait AggregatorImpl: AggregatorImplExt + ElementImpl {
@ -673,14 +672,14 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
}
}
unsafe impl<T: AggregatorImpl> IsSubclassable<T> for AggregatorClass
unsafe impl<T: AggregatorImpl> IsSubclassable<T> for Aggregator
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstAggregatorClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstAggregatorClass);
klass.flush = Some(aggregator_flush::<T>);
klass.clip = Some(aggregator_clip::<T>);
klass.finish_buffer = Some(aggregator_finish_buffer::<T>);

9
gstreamer-base/src/subclass/aggregator_pad.rs
View file

@ -18,7 +18,6 @@ use gst::subclass::prelude::*;
use Aggregator;
use AggregatorPad;
use AggregatorPadClass;
pub trait AggregatorPadImpl: AggregatorPadImplExt + PadImpl {
fn flush(
@ -100,11 +99,11 @@ impl<T: AggregatorPadImpl> AggregatorPadImplExt for T {
}
}
}
unsafe impl<T: AggregatorPadImpl> IsSubclassable<T> for AggregatorPadClass {
fn override_vfuncs(&mut self) {
<gst::PadClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: AggregatorPadImpl> IsSubclassable<T> for AggregatorPad {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Pad as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstAggregatorPadClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstAggregatorPadClass);
klass.flush = Some(aggregator_pad_flush::<T>);
klass.skip_buffer = Some(aggregator_pad_skip_buffer::<T>);
}

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

@ -20,7 +20,6 @@ use gst;
use gst::subclass::prelude::*;
use BaseParse;
use BaseParseClass;
use BaseParseFrame;
pub trait BaseParseImpl: BaseParseImplExt + ElementImpl {
@ -215,14 +214,14 @@ impl<T: BaseParseImpl> BaseParseImplExt for T {
}
}
unsafe impl<T: BaseParseImpl> IsSubclassable<T> for BaseParseClass
unsafe impl<T: BaseParseImpl> IsSubclassable<T> for BaseParse
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseParseClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseParseClass);
klass.start = Some(base_parse_start::<T>);
klass.stop = Some(base_parse_stop::<T>);
klass.set_sink_caps = Some(base_parse_set_sink_caps::<T>);

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

@ -19,7 +19,6 @@ use gst::subclass::prelude::*;
use std::ptr;
use BaseSink;
use BaseSinkClass;
pub trait BaseSinkImpl: BaseSinkImplExt + ElementImpl {
fn start(&self, element: &BaseSink) -> Result<(), gst::ErrorMessage> {
@ -381,14 +380,14 @@ impl<T: BaseSinkImpl> BaseSinkImplExt for T {
}
}
unsafe impl<T: BaseSinkImpl> IsSubclassable<T> for BaseSinkClass
unsafe impl<T: BaseSinkImpl> IsSubclassable<T> for BaseSink
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseSinkClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseSinkClass);
klass.start = Some(base_sink_start::<T>);
klass.stop = Some(base_sink_stop::<T>);
klass.render = Some(base_sink_render::<T>);

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

@ -20,7 +20,6 @@ use std::mem;
use std::ptr;
use BaseSrc;
use BaseSrcClass;
#[derive(Debug)]
pub enum CreateSuccess {
@ -570,14 +569,14 @@ impl<T: BaseSrcImpl> BaseSrcImplExt for T {
}
}
unsafe impl<T: BaseSrcImpl> IsSubclassable<T> for BaseSrcClass
unsafe impl<T: BaseSrcImpl> IsSubclassable<T> for BaseSrc
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseSrcClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseSrcClass);
klass.start = Some(base_src_start::<T>);
klass.stop = Some(base_src_stop::<T>);
klass.is_seekable = Some(base_src_is_seekable::<T>);

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

@ -21,7 +21,6 @@ use std::mem;
use std::ptr;
use BaseTransform;
use BaseTransformClass;
pub trait BaseTransformImpl: BaseTransformImplExt + ElementImpl {
fn start(&self, element: &BaseTransform) -> Result<(), gst::ErrorMessage> {
@ -827,14 +826,14 @@ pub enum BaseTransformMode {
Both,
}
unsafe impl<T: BaseTransformImpl> IsSubclassable<T> for BaseTransformClass
unsafe impl<T: BaseTransformImpl> IsSubclassable<T> for BaseTransform
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseTransformClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseTransformClass);
klass.start = Some(base_transform_start::<T>);
klass.stop = Some(base_transform_stop::<T>);
klass.transform_caps = Some(base_transform_transform_caps::<T>);

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

@ -19,7 +19,6 @@ use std::ptr;
use super::base_src::BaseSrcImpl;
use PushSrc;
use PushSrcClass;
pub trait PushSrcImpl: PushSrcImplExt + BaseSrcImpl {
fn fill(
@ -114,14 +113,14 @@ impl<T: PushSrcImpl> PushSrcImplExt for T {
}
}
unsafe impl<T: PushSrcImpl> IsSubclassable<T> for PushSrcClass
unsafe impl<T: PushSrcImpl> IsSubclassable<T> for PushSrc
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<::BaseSrcClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<::BaseSrc as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstPushSrcClass);
let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstPushSrcClass);
klass.fill = Some(push_src_fill::<T>);
klass.alloc = Some(push_src_alloc::<T>);
klass.create = Some(push_src_create::<T>);

9
gstreamer-rtsp-server/src/subclass/rtsp_client.rs
View file

@ -14,7 +14,6 @@ use glib::translate::*;
use std::mem;
use RTSPClient;
use RTSPClientClass;
pub trait RTSPClientImpl: RTSPClientImplExt + ObjectImpl + Send + Sync {
fn create_sdp(&self, client: &RTSPClient, media: &::RTSPMedia) -> Option<gst_sdp::SDPMessage> {
@ -793,11 +792,11 @@ impl<T: RTSPClientImpl> RTSPClientImplExt for T {
}
}
}
unsafe impl<T: RTSPClientImpl> IsSubclassable<T> for RTSPClientClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: RTSPClientImpl> IsSubclassable<T> for RTSPClient {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPClientClass);
let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPClientClass);
klass.create_sdp = Some(client_create_sdp::<T>);
klass.configure_client_media = Some(client_configure_client_media::<T>);
klass.params_set = Some(client_params_set::<T>);

9
gstreamer-rtsp-server/src/subclass/rtsp_media.rs
View file

@ -14,7 +14,6 @@ use glib::translate::*;
use std::ptr;
use RTSPMedia;
use RTSPMediaClass;
use RTSPThread;
#[derive(Debug)]
@ -449,11 +448,11 @@ impl<T: RTSPMediaImpl> RTSPMediaImplExt for T {
}
}
}
unsafe impl<T: RTSPMediaImpl> IsSubclassable<T> for RTSPMediaClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: RTSPMediaImpl> IsSubclassable<T> for RTSPMedia {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPMediaClass);
let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPMediaClass);
klass.handle_message = Some(media_handle_message::<T>);
klass.prepare = Some(media_prepare::<T>);
klass.unprepare = Some(media_unprepare::<T>);

9
gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs
View file

@ -14,7 +14,6 @@ use gst_rtsp;
use glib::subclass::prelude::*;
use RTSPMediaFactory;
use RTSPMediaFactoryClass;
use std::mem::transmute;
@ -202,12 +201,12 @@ impl<T: RTSPMediaFactoryImpl> RTSPMediaFactoryImplExt for T {
}
}
}
unsafe impl<T: RTSPMediaFactoryImpl> IsSubclassable<T> for RTSPMediaFactoryClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: RTSPMediaFactoryImpl> IsSubclassable<T> for RTSPMediaFactory {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass =
&mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPMediaFactoryClass);
&mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPMediaFactoryClass);
klass.gen_key = Some(factory_gen_key::<T>);
klass.create_element = Some(factory_create_element::<T>);
klass.construct = Some(factory_construct::<T>);

9
gstreamer-rtsp-server/src/subclass/rtsp_server.rs
View file

@ -12,7 +12,6 @@ use glib::subclass::prelude::*;
use glib::translate::*;
use RTSPServer;
use RTSPServerClass;
pub trait RTSPServerImpl: RTSPServerImplExt + ObjectImpl + Send + Sync {
fn create_client(&self, server: &RTSPServer) -> Option<::RTSPClient> {
@ -54,11 +53,11 @@ impl<T: RTSPServerImpl> RTSPServerImplExt for T {
}
}
}
unsafe impl<T: RTSPServerImpl> IsSubclassable<T> for RTSPServerClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: RTSPServerImpl> IsSubclassable<T> for RTSPServer {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPServerClass);
let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPServerClass);
klass.create_client = Some(server_create_client::<T>);
klass.client_connected = Some(server_client_connected::<T>);
}

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

@ -22,7 +22,6 @@ use crate::prelude::*;
use video_codec_state::{Readable, VideoCodecState};
use VideoCodecFrame;
use VideoDecoder;
use VideoDecoderClass;
pub trait VideoDecoderImpl: VideoDecoderImplExt + ElementImpl {
fn open(&self, element: &VideoDecoder) -> Result<(), gst::ErrorMessage> {
@ -499,14 +498,14 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
}
}
unsafe impl<T: VideoDecoderImpl> IsSubclassable<T> for VideoDecoderClass
unsafe impl<T: VideoDecoderImpl> IsSubclassable<T> for VideoDecoder
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoDecoderClass);
let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoDecoderClass);
klass.open = Some(video_decoder_open::<T>);
klass.close = Some(video_decoder_close::<T>);
klass.start = Some(video_decoder_start::<T>);

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

@ -21,7 +21,6 @@ use crate::prelude::*;
use video_codec_state::{Readable, VideoCodecState};
use VideoCodecFrame;
use VideoEncoder;
use VideoEncoderClass;
pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl {
fn open(&self, element: &VideoEncoder) -> Result<(), gst::ErrorMessage> {
@ -435,14 +434,14 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
}
}
unsafe impl<T: VideoEncoderImpl> IsSubclassable<T> for VideoEncoderClass
unsafe impl<T: VideoEncoderImpl> IsSubclassable<T> for VideoEncoder
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoEncoderClass);
let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoEncoderClass);
klass.open = Some(video_encoder_open::<T>);
klass.close = Some(video_encoder_close::<T>);
klass.start = Some(video_encoder_start::<T>);

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

@ -17,7 +17,6 @@ use gst::subclass::prelude::*;
use gst_base::subclass::prelude::*;
use VideoSink;
use VideoSinkClass;
pub trait VideoSinkImpl: VideoSinkImplExt + BaseSinkImpl + ElementImpl {
fn show_frame(
@ -58,14 +57,14 @@ impl<T: VideoSinkImpl> VideoSinkImplExt for T {
}
}
unsafe impl<T: VideoSinkImpl> IsSubclassable<T> for VideoSinkClass
unsafe impl<T: VideoSinkImpl> IsSubclassable<T> for VideoSink
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<gst_base::BaseSinkClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<gst_base::BaseSink as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoSinkClass);
let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoSinkClass);
klass.show_frame = Some(video_sink_show_frame::<T>);
}
}

10
gstreamer/src/element.rs
View file

@ -844,8 +844,8 @@ impl<O: IsA<Element>> ElementExtManual for O {
}
}
impl ElementClass {
pub fn get_metadata<'a>(&self, key: &str) -> Option<&'a str> {
pub unsafe trait ElementClassExt {
fn get_metadata<'a>(&self, key: &str) -> Option<&'a str> {
unsafe {
let klass = self as *const _ as *const gst_sys::GstElementClass;
@ -860,7 +860,7 @@ impl ElementClass {
}
}
pub fn get_pad_template(&self, name: &str) -> Option<PadTemplate> {
fn get_pad_template(&self, name: &str) -> Option<PadTemplate> {
unsafe {
let klass = self as *const _ as *const gst_sys::GstElementClass;
@ -871,7 +871,7 @@ impl ElementClass {
}
}
pub fn get_pad_template_list(&self) -> Vec<PadTemplate> {
fn get_pad_template_list(&self) -> Vec<PadTemplate> {
unsafe {
let klass = self as *const _ as *const gst_sys::GstElementClass;
@ -882,6 +882,8 @@ impl ElementClass {
}
}
unsafe impl<T: IsA<Element>> ElementClassExt for glib::object::Class<T> {}
pub static ELEMENT_METADATA_AUTHOR: Lazy<&'static str> = Lazy::new(|| unsafe {
CStr::from_ptr(gst_sys::GST_ELEMENT_METADATA_AUTHOR)
.to_str()

2
gstreamer/src/lib.rs
View file

@ -341,7 +341,7 @@ pub mod prelude {
pub use allocator::AllocatorExtManual;
pub use bin::GstBinExtManual;
pub use element::ElementExtManual;
pub use element::{ElementClassExt, ElementExtManual};
// OS dependent Bus extensions (also import the other plateform trait for doc)
#[cfg(any(feature = "v1_14", feature = "dox"))]

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

@ -15,7 +15,6 @@ use super::prelude::*;
use glib::subclass::prelude::*;
use Bin;
use BinClass;
use Element;
use LoggableError;
use Message;
@ -87,14 +86,14 @@ impl<T: BinImpl> BinImplExt for T {
}
}
unsafe impl<T: BinImpl> IsSubclassable<T> for BinClass
unsafe impl<T: BinImpl> IsSubclassable<T> for Bin
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<::Element as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstBinClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstBinClass);
klass.add_element = Some(bin_add_element::<T>);
klass.remove_element = Some(bin_remove_element::<T>);
klass.handle_message = Some(bin_handle_message::<T>);

9
gstreamer/src/subclass/clock.rs
View file

@ -14,7 +14,6 @@ use glib::subclass::prelude::*;
use glib::translate::*;
use Clock;
use ClockClass;
use ClockError;
use ClockId;
use ClockReturn;
@ -233,12 +232,12 @@ impl<T: ClockImpl> ClockImplExt for T {
}
}
unsafe impl<T: ClockImpl> IsSubclassable<T> for ClockClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: ClockImpl> IsSubclassable<T> for Clock {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstClockClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstClockClass);
klass.change_resolution = Some(clock_change_resolution::<T>);
klass.get_resolution = Some(clock_get_resolution::<T>);
klass.get_internal_time = Some(clock_get_internal_time::<T>);

9
gstreamer/src/subclass/device.rs
View file

@ -14,7 +14,6 @@ use glib::translate::*;
use glib::subclass::prelude::*;
use Device;
use DeviceClass;
use Element;
use LoggableError;
@ -99,11 +98,11 @@ impl<T: DeviceImpl> DeviceImplExt for T {
}
}
unsafe impl<T: DeviceImpl> IsSubclassable<T> for DeviceClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: DeviceImpl> IsSubclassable<T> for Device {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstDeviceClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstDeviceClass);
klass.create_element = Some(device_create_element::<T>);
klass.reconfigure_element = Some(device_reconfigure_element::<T>);
}

8
gstreamer/src/subclass/device_provider.rs
View file

@ -114,11 +114,11 @@ pub unsafe trait DeviceProviderClassSubclassExt: Sized + 'static {
unsafe impl DeviceProviderClassSubclassExt for DeviceProviderClass {}
unsafe impl<T: DeviceProviderImpl> IsSubclassable<T> for DeviceProviderClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: DeviceProviderImpl> IsSubclassable<T> for DeviceProvider {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstDeviceProviderClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstDeviceProviderClass);
klass.probe = Some(device_provider_probe::<T>);
klass.start = Some(device_provider_start::<T>);
klass.stop = Some(device_provider_stop::<T>);

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

@ -338,15 +338,15 @@ pub unsafe trait ElementClassSubclassExt: Sized + 'static {
unsafe impl ElementClassSubclassExt for ElementClass {}
unsafe impl<T: ElementImpl> IsSubclassable<T> for ElementClass
unsafe impl<T: ElementImpl> IsSubclassable<T> for Element
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstElementClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstElementClass);
klass.change_state = Some(element_change_state::<T>);
klass.request_new_pad = Some(element_request_new_pad::<T>);
klass.release_pad = Some(element_release_pad::<T>);

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

@ -11,15 +11,15 @@ use gst_sys;
use super::prelude::*;
use glib::subclass::prelude::*;
use GhostPadClass;
use GhostPad;
pub trait GhostPadImpl: PadImpl {}
unsafe impl<T: GhostPadImpl> IsSubclassable<T> for GhostPadClass {
fn override_vfuncs(&mut self) {
<::PadClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: GhostPadImpl> IsSubclassable<T> for GhostPad {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<::Pad as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let _klass = &mut *(self as *mut Self as *mut gst_sys::GstGhostPadClass);
let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstGhostPadClass);
// Nothing to do here
}
}

9
gstreamer/src/subclass/pad.rs
View file

@ -14,7 +14,6 @@ use glib::translate::*;
use glib::subclass::prelude::*;
use Pad;
use PadClass;
pub trait PadImpl: PadImplExt + ObjectImpl + Send + Sync {
fn linked(&self, pad: &Pad, peer: &Pad) {
@ -58,12 +57,12 @@ impl<T: PadImpl> PadImplExt for T {
}
}
unsafe impl<T: PadImpl> IsSubclassable<T> for PadClass {
fn override_vfuncs(&mut self) {
<glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: PadImpl> IsSubclassable<T> for Pad {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let klass = &mut *(self as *mut Self as *mut gst_sys::GstPadClass);
let klass = &mut *(klass.as_mut() as *mut gst_sys::GstPadClass);
klass.linked = Some(pad_linked::<T>);
klass.unlinked = Some(pad_unlinked::<T>);
}

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

@ -11,18 +11,18 @@ use gst_sys;
use super::prelude::*;
use glib::subclass::prelude::*;
use PipelineClass;
use Pipeline;
pub trait PipelineImpl: BinImpl {}
unsafe impl<T: PipelineImpl> IsSubclassable<T> for PipelineClass
unsafe impl<T: PipelineImpl> IsSubclassable<T> for Pipeline
where
<T as ObjectSubclass>::Instance: PanicPoison,
{
fn override_vfuncs(&mut self) {
<::BinClass as IsSubclassable<T>>::override_vfuncs(self);
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<::Bin as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let _klass = &mut *(self as *mut Self as *mut gst_sys::GstPipelineClass);
let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstPipelineClass);
// Nothing to do here
}
}

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

@ -11,15 +11,15 @@ use gst_sys;
use super::prelude::*;
use glib::subclass::prelude::*;
use SystemClockClass;
use SystemClock;
pub trait SystemClockImpl: ClockImpl {}
unsafe impl<T: SystemClockImpl> IsSubclassable<T> for SystemClockClass {
fn override_vfuncs(&mut self) {
<::ClockClass as IsSubclassable<T>>::override_vfuncs(self);
unsafe impl<T: SystemClockImpl> IsSubclassable<T> for SystemClock {
fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
<::Clock as IsSubclassable<T>>::override_vfuncs(klass);
unsafe {
let _klass = &mut *(self as *mut Self as *mut gst_sys::GstSystemClockClass);
let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstSystemClockClass);
// Nothing to do here
}
}