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

gstreamer_video/subclass/
video_aggregator_pad.rs
