gstreamer_video/subclass/
video_aggregator_pad.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::{mem, ptr};
4
5use glib::translate::*;
6use gst_base::{prelude::*, subclass::prelude::*};
7
8use crate::{ffi, subclass::AggregateFramesToken, VideoAggregator, VideoAggregatorPad};
9
10pub trait VideoAggregatorPadImpl: VideoAggregatorPadImplExt + AggregatorPadImpl {
11    /// Called when either the input or output formats
12    ///  have changed.
13    fn update_conversion_info(&self) {
14        self.parent_update_conversion_info()
15    }
16
17    /// Prepare the frame from the pad buffer and sets it to prepared_frame.
18    ///  Implementations should always return TRUE. Returning FALSE will cease
19    ///  iteration over subsequent pads.
20    fn prepare_frame(
21        &self,
22        aggregator: &crate::VideoAggregator,
23        token: &AggregateFramesToken,
24        buffer: &gst::Buffer,
25    ) -> Option<crate::VideoFrame<crate::video_frame::Readable>> {
26        self.parent_prepare_frame(aggregator, token, buffer)
27    }
28
29    /// clean the frame previously prepared in prepare_frame
30    fn clean_frame(
31        &self,
32        aggregator: &crate::VideoAggregator,
33        token: &AggregateFramesToken,
34        frame: Option<crate::VideoFrame<crate::video_frame::Readable>>,
35    ) {
36        self.parent_clean_frame(aggregator, token, frame)
37    }
38}
39
40mod sealed {
41    pub trait Sealed {}
42    impl<T: super::VideoAggregatorPadImplExt> Sealed for T {}
43}
44
45pub trait VideoAggregatorPadImplExt: ObjectSubclass + sealed::Sealed {
46    fn parent_update_conversion_info(&self) {
47        unsafe {
48            let data = Self::type_data();
49            let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorPadClass;
50            if let Some(f) = (*parent_class).update_conversion_info {
51                f(self
52                    .obj()
53                    .unsafe_cast_ref::<VideoAggregatorPad>()
54                    .to_glib_none()
55                    .0);
56            }
57        }
58    }
59
60    fn parent_prepare_frame(
61        &self,
62        aggregator: &crate::VideoAggregator,
63        token: &AggregateFramesToken,
64        buffer: &gst::Buffer,
65    ) -> Option<crate::VideoFrame<crate::video_frame::Readable>> {
66        assert_eq!(aggregator.as_ptr(), token.0.as_ptr());
67
68        unsafe {
69            let data = Self::type_data();
70            let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorPadClass;
71            if let Some(f) = (*parent_class).prepare_frame {
72                let mut prepared_frame = mem::MaybeUninit::zeroed();
73
74                f(
75                    self.obj()
76                        .unsafe_cast_ref::<VideoAggregatorPad>()
77                        .to_glib_none()
78                        .0,
79                    aggregator.to_glib_none().0,
80                    buffer.as_mut_ptr(),
81                    prepared_frame.as_mut_ptr(),
82                );
83
84                let prepared_frame = prepared_frame.assume_init();
85                if prepared_frame.buffer.is_null() {
86                    None
87                } else {
88                    Some(crate::VideoFrame::from_glib_full(prepared_frame))
89                }
90            } else {
91                None
92            }
93        }
94    }
95
96    fn parent_clean_frame(
97        &self,
98        aggregator: &crate::VideoAggregator,
99        token: &AggregateFramesToken,
100        frame: Option<crate::VideoFrame<crate::video_frame::Readable>>,
101    ) {
102        assert_eq!(aggregator.as_ptr(), token.0.as_ptr());
103
104        unsafe {
105            let data = Self::type_data();
106            let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoAggregatorPadClass;
107            if let Some(f) = (*parent_class).clean_frame {
108                let mut prepared_frame = if let Some(frame) = frame {
109                    frame.into_raw()
110                } else {
111                    mem::zeroed()
112                };
113
114                f(
115                    self.obj()
116                        .unsafe_cast_ref::<VideoAggregatorPad>()
117                        .to_glib_none()
118                        .0,
119                    aggregator.to_glib_none().0,
120                    &mut prepared_frame,
121                );
122            }
123        }
124    }
125}
126
127impl<T: VideoAggregatorPadImpl> VideoAggregatorPadImplExt for T {}
128
129unsafe impl<T: VideoAggregatorPadImpl> IsSubclassable<T> for VideoAggregatorPad {
130    fn class_init(klass: &mut glib::Class<Self>) {
131        Self::parent_class_init::<T>(klass);
132
133        let klass = klass.as_mut();
134        klass.update_conversion_info = Some(video_aggregator_pad_update_conversion_info::<T>);
135        klass.prepare_frame = Some(video_aggregator_pad_prepare_frame::<T>);
136        klass.clean_frame = Some(video_aggregator_pad_clean_frame::<T>);
137    }
138}
139
140unsafe extern "C" fn video_aggregator_pad_update_conversion_info<T: VideoAggregatorPadImpl>(
141    ptr: *mut ffi::GstVideoAggregatorPad,
142) {
143    let instance = &*(ptr as *mut T::Instance);
144    let imp = instance.imp();
145
146    imp.update_conversion_info();
147}
148
149unsafe extern "C" fn video_aggregator_pad_prepare_frame<T: VideoAggregatorPadImpl>(
150    ptr: *mut ffi::GstVideoAggregatorPad,
151    aggregator: *mut ffi::GstVideoAggregator,
152    buffer: *mut gst::ffi::GstBuffer,
153    prepared_frame: *mut ffi::GstVideoFrame,
154) -> glib::ffi::gboolean {
155    let instance = &*(ptr as *mut T::Instance);
156    let imp = instance.imp();
157    let aggregator: Borrowed<VideoAggregator> = from_glib_borrow(aggregator);
158
159    let token = AggregateFramesToken(&aggregator);
160
161    match imp.prepare_frame(&aggregator, &token, &from_glib_borrow(buffer)) {
162        Some(frame) => {
163            *prepared_frame = frame.into_raw();
164        }
165        None => {
166            ptr::write(prepared_frame, mem::zeroed());
167        }
168    }
169
170    glib::ffi::GTRUE
171}
172
173unsafe extern "C" fn video_aggregator_pad_clean_frame<T: VideoAggregatorPadImpl>(
174    ptr: *mut ffi::GstVideoAggregatorPad,
175    aggregator: *mut ffi::GstVideoAggregator,
176    prepared_frame: *mut ffi::GstVideoFrame,
177) {
178    let instance = &*(ptr as *mut T::Instance);
179    let imp = instance.imp();
180    let aggregator: Borrowed<VideoAggregator> = from_glib_borrow(aggregator);
181
182    let token = AggregateFramesToken(&aggregator);
183
184    let frame = if (*prepared_frame).buffer.is_null() {
185        None
186    } else {
187        let frame = crate::VideoFrame::from_glib_full(*prepared_frame);
188        ptr::write(prepared_frame, mem::zeroed());
189        Some(frame)
190    };
191
192    imp.clean_frame(&aggregator, &token, frame);
193}
gstreamer_video/subclass/video_aggregator_pad.rs

gstreamer_video/subclass/
video_aggregator_pad.rs
