1 // Take a look at the license at the top of the repository in the LICENSE file.
2
3 use glib::translate::*;
4
5 use gst::subclass::prelude::*;
6
7 use crate::prelude::*;
8 use crate::video_codec_state::{Readable, VideoCodecState};
9 use crate::VideoCodecFrame;
10 use crate::VideoEncoder;
11
12 pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl {
open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>13 fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
14 self.parent_open(element)
15 }
16
close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>17 fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
18 self.parent_close(element)
19 }
20
start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>21 fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
22 self.parent_start(element)
23 }
24
stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>25 fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
26 self.parent_stop(element)
27 }
28
finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError>29 fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
30 self.parent_finish(element)
31 }
32
set_format( &self, element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError>33 fn set_format(
34 &self,
35 element: &Self::Type,
36 state: &VideoCodecState<'static, Readable>,
37 ) -> Result<(), gst::LoggableError> {
38 self.parent_set_format(element, state)
39 }
40
handle_frame( &self, element: &Self::Type, frame: VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError>41 fn handle_frame(
42 &self,
43 element: &Self::Type,
44 frame: VideoCodecFrame,
45 ) -> Result<gst::FlowSuccess, gst::FlowError> {
46 self.parent_handle_frame(element, frame)
47 }
48
flush(&self, element: &Self::Type) -> bool49 fn flush(&self, element: &Self::Type) -> bool {
50 self.parent_flush(element)
51 }
52
negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>53 fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
54 self.parent_negotiate(element)
55 }
56
caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps57 fn caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
58 self.parent_caps(element, filter)
59 }
60
sink_event(&self, element: &Self::Type, event: gst::Event) -> bool61 fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
62 self.parent_sink_event(element, event)
63 }
64
sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool65 fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
66 self.parent_sink_query(element, query)
67 }
68
src_event(&self, element: &Self::Type, event: gst::Event) -> bool69 fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
70 self.parent_src_event(element, event)
71 }
72
src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool73 fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
74 self.parent_src_query(element, query)
75 }
76
propose_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>77 fn propose_allocation(
78 &self,
79 element: &Self::Type,
80 query: &mut gst::QueryRef,
81 ) -> Result<(), gst::ErrorMessage> {
82 self.parent_propose_allocation(element, query)
83 }
84
decide_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>85 fn decide_allocation(
86 &self,
87 element: &Self::Type,
88 query: &mut gst::QueryRef,
89 ) -> Result<(), gst::ErrorMessage> {
90 self.parent_decide_allocation(element, query)
91 }
92 }
93
94 pub trait VideoEncoderImplExt: ObjectSubclass {
parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>95 fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
96
parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>97 fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
98
parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>99 fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
100
parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>101 fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
102
parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError>103 fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError>;
104
parent_set_format( &self, element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError>105 fn parent_set_format(
106 &self,
107 element: &Self::Type,
108 state: &VideoCodecState<'static, Readable>,
109 ) -> Result<(), gst::LoggableError>;
110
parent_handle_frame( &self, element: &Self::Type, frame: VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError>111 fn parent_handle_frame(
112 &self,
113 element: &Self::Type,
114 frame: VideoCodecFrame,
115 ) -> Result<gst::FlowSuccess, gst::FlowError>;
116
parent_flush(&self, element: &Self::Type) -> bool117 fn parent_flush(&self, element: &Self::Type) -> bool;
118
parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>119 fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>;
120
parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps121 fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps;
122
parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool123 fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool;
124
parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool125 fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
126
parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool127 fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool;
128
parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool129 fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
130
parent_propose_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>131 fn parent_propose_allocation(
132 &self,
133 element: &Self::Type,
134 query: &mut gst::QueryRef,
135 ) -> Result<(), gst::ErrorMessage>;
136
parent_decide_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>137 fn parent_decide_allocation(
138 &self,
139 element: &Self::Type,
140 query: &mut gst::QueryRef,
141 ) -> Result<(), gst::ErrorMessage>;
142 }
143
144 impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>145 fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
146 unsafe {
147 let data = Self::type_data();
148 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
149 (*parent_class)
150 .open
151 .map(|f| {
152 if from_glib(f(element
153 .unsafe_cast_ref::<VideoEncoder>()
154 .to_glib_none()
155 .0))
156 {
157 Ok(())
158 } else {
159 Err(gst::error_msg!(
160 gst::CoreError::StateChange,
161 ["Parent function `open` failed"]
162 ))
163 }
164 })
165 .unwrap_or(Ok(()))
166 }
167 }
168
parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>169 fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
170 unsafe {
171 let data = Self::type_data();
172 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
173 (*parent_class)
174 .close
175 .map(|f| {
176 if from_glib(f(element
177 .unsafe_cast_ref::<VideoEncoder>()
178 .to_glib_none()
179 .0))
180 {
181 Ok(())
182 } else {
183 Err(gst::error_msg!(
184 gst::CoreError::StateChange,
185 ["Parent function `close` failed"]
186 ))
187 }
188 })
189 .unwrap_or(Ok(()))
190 }
191 }
192
parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>193 fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
194 unsafe {
195 let data = Self::type_data();
196 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
197 (*parent_class)
198 .start
199 .map(|f| {
200 if from_glib(f(element
201 .unsafe_cast_ref::<VideoEncoder>()
202 .to_glib_none()
203 .0))
204 {
205 Ok(())
206 } else {
207 Err(gst::error_msg!(
208 gst::CoreError::StateChange,
209 ["Parent function `start` failed"]
210 ))
211 }
212 })
213 .unwrap_or(Ok(()))
214 }
215 }
216
parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>217 fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
218 unsafe {
219 let data = Self::type_data();
220 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
221 (*parent_class)
222 .stop
223 .map(|f| {
224 if from_glib(f(element
225 .unsafe_cast_ref::<VideoEncoder>()
226 .to_glib_none()
227 .0))
228 {
229 Ok(())
230 } else {
231 Err(gst::error_msg!(
232 gst::CoreError::StateChange,
233 ["Parent function `stop` failed"]
234 ))
235 }
236 })
237 .unwrap_or(Ok(()))
238 }
239 }
240
parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError>241 fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
242 unsafe {
243 let data = Self::type_data();
244 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
245 (*parent_class)
246 .finish
247 .map(|f| {
248 try_from_glib(f(element
249 .unsafe_cast_ref::<VideoEncoder>()
250 .to_glib_none()
251 .0))
252 })
253 .unwrap_or(Ok(gst::FlowSuccess::Ok))
254 }
255 }
256
parent_set_format( &self, element: &Self::Type, state: &VideoCodecState<'static, Readable>, ) -> Result<(), gst::LoggableError>257 fn parent_set_format(
258 &self,
259 element: &Self::Type,
260 state: &VideoCodecState<'static, Readable>,
261 ) -> Result<(), gst::LoggableError> {
262 unsafe {
263 let data = Self::type_data();
264 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
265 (*parent_class)
266 .set_format
267 .map(|f| {
268 gst::result_from_gboolean!(
269 f(
270 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
271 state.as_mut_ptr()
272 ),
273 gst::CAT_RUST,
274 "parent function `set_format` failed"
275 )
276 })
277 .unwrap_or(Ok(()))
278 }
279 }
280
parent_handle_frame( &self, element: &Self::Type, frame: VideoCodecFrame, ) -> Result<gst::FlowSuccess, gst::FlowError>281 fn parent_handle_frame(
282 &self,
283 element: &Self::Type,
284 frame: VideoCodecFrame,
285 ) -> Result<gst::FlowSuccess, gst::FlowError> {
286 unsafe {
287 let data = Self::type_data();
288 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
289 (*parent_class)
290 .handle_frame
291 .map(|f| {
292 try_from_glib(f(
293 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
294 frame.to_glib_none().0,
295 ))
296 })
297 .unwrap_or(Err(gst::FlowError::Error))
298 }
299 }
300
parent_flush(&self, element: &Self::Type) -> bool301 fn parent_flush(&self, element: &Self::Type) -> bool {
302 unsafe {
303 let data = Self::type_data();
304 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
305 (*parent_class)
306 .flush
307 .map(|f| {
308 from_glib(f(element
309 .unsafe_cast_ref::<VideoEncoder>()
310 .to_glib_none()
311 .0))
312 })
313 .unwrap_or(false)
314 }
315 }
316
parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>317 fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
318 unsafe {
319 let data = Self::type_data();
320 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
321 (*parent_class)
322 .negotiate
323 .map(|f| {
324 gst::result_from_gboolean!(
325 f(element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0),
326 gst::CAT_RUST,
327 "Parent function `negotiate` failed"
328 )
329 })
330 .unwrap_or(Ok(()))
331 }
332 }
333
parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps334 fn parent_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
335 unsafe {
336 let data = Self::type_data();
337 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
338 (*parent_class)
339 .getcaps
340 .map(|f| {
341 from_glib_full(f(
342 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
343 filter.to_glib_none().0,
344 ))
345 })
346 .unwrap_or_else(|| {
347 element
348 .unsafe_cast_ref::<VideoEncoder>()
349 .proxy_getcaps(None, filter)
350 })
351 }
352 }
353
parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool354 fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
355 unsafe {
356 let data = Self::type_data();
357 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
358 let f = (*parent_class)
359 .sink_event
360 .expect("Missing parent function `sink_event`");
361 from_glib(f(
362 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
363 event.into_ptr(),
364 ))
365 }
366 }
367
parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool368 fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
369 unsafe {
370 let data = Self::type_data();
371 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
372 let f = (*parent_class)
373 .sink_query
374 .expect("Missing parent function `sink_query`");
375 from_glib(f(
376 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
377 query.as_mut_ptr(),
378 ))
379 }
380 }
381
parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool382 fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
383 unsafe {
384 let data = Self::type_data();
385 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
386 let f = (*parent_class)
387 .src_event
388 .expect("Missing parent function `src_event`");
389 from_glib(f(
390 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
391 event.into_ptr(),
392 ))
393 }
394 }
395
parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool396 fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
397 unsafe {
398 let data = Self::type_data();
399 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
400 let f = (*parent_class)
401 .src_query
402 .expect("Missing parent function `src_query`");
403 from_glib(f(
404 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
405 query.as_mut_ptr(),
406 ))
407 }
408 }
409
parent_propose_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>410 fn parent_propose_allocation(
411 &self,
412 element: &Self::Type,
413 query: &mut gst::QueryRef,
414 ) -> Result<(), gst::ErrorMessage> {
415 unsafe {
416 let data = Self::type_data();
417 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
418 (*parent_class)
419 .propose_allocation
420 .map(|f| {
421 if from_glib(f(
422 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
423 query.as_mut_ptr(),
424 )) {
425 Ok(())
426 } else {
427 Err(gst::error_msg!(
428 gst::CoreError::StateChange,
429 ["Parent function `propose_allocation` failed"]
430 ))
431 }
432 })
433 .unwrap_or(Ok(()))
434 }
435 }
436
parent_decide_allocation( &self, element: &Self::Type, query: &mut gst::QueryRef, ) -> Result<(), gst::ErrorMessage>437 fn parent_decide_allocation(
438 &self,
439 element: &Self::Type,
440 query: &mut gst::QueryRef,
441 ) -> Result<(), gst::ErrorMessage> {
442 unsafe {
443 let data = Self::type_data();
444 let parent_class = data.as_ref().parent_class() as *mut ffi::GstVideoEncoderClass;
445 (*parent_class)
446 .decide_allocation
447 .map(|f| {
448 if from_glib(f(
449 element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
450 query.as_mut_ptr(),
451 )) {
452 Ok(())
453 } else {
454 Err(gst::error_msg!(
455 gst::CoreError::StateChange,
456 ["Parent function `decide_allocation` failed"]
457 ))
458 }
459 })
460 .unwrap_or(Ok(()))
461 }
462 }
463 }
464
465 unsafe impl<T: VideoEncoderImpl> IsSubclassable<T> for VideoEncoder {
class_init(klass: &mut glib::Class<Self>)466 fn class_init(klass: &mut glib::Class<Self>) {
467 <gst::Element as IsSubclassable<T>>::class_init(klass);
468 let klass = klass.as_mut();
469 klass.open = Some(video_encoder_open::<T>);
470 klass.close = Some(video_encoder_close::<T>);
471 klass.start = Some(video_encoder_start::<T>);
472 klass.stop = Some(video_encoder_stop::<T>);
473 klass.finish = Some(video_encoder_finish::<T>);
474 klass.set_format = Some(video_encoder_set_format::<T>);
475 klass.handle_frame = Some(video_encoder_handle_frame::<T>);
476 klass.flush = Some(video_encoder_flush::<T>);
477 klass.negotiate = Some(video_encoder_negotiate::<T>);
478 klass.getcaps = Some(video_encoder_getcaps::<T>);
479 klass.sink_event = Some(video_encoder_sink_event::<T>);
480 klass.src_event = Some(video_encoder_src_event::<T>);
481 klass.sink_query = Some(video_encoder_sink_query::<T>);
482 klass.src_query = Some(video_encoder_src_query::<T>);
483 klass.propose_allocation = Some(video_encoder_propose_allocation::<T>);
484 klass.decide_allocation = Some(video_encoder_decide_allocation::<T>);
485 }
486
instance_init(instance: &mut glib::subclass::InitializingObject<T>)487 fn instance_init(instance: &mut glib::subclass::InitializingObject<T>) {
488 <gst::Element as IsSubclassable<T>>::instance_init(instance);
489 }
490 }
491
video_encoder_open<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean492 unsafe extern "C" fn video_encoder_open<T: VideoEncoderImpl>(
493 ptr: *mut ffi::GstVideoEncoder,
494 ) -> glib::ffi::gboolean {
495 let instance = &*(ptr as *mut T::Instance);
496 let imp = instance.impl_();
497 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
498
499 gst::panic_to_error!(&wrap, imp.panicked(), false, {
500 match imp.open(wrap.unsafe_cast_ref()) {
501 Ok(()) => true,
502 Err(err) => {
503 wrap.post_error_message(err);
504 false
505 }
506 }
507 })
508 .into_glib()
509 }
510
video_encoder_close<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean511 unsafe extern "C" fn video_encoder_close<T: VideoEncoderImpl>(
512 ptr: *mut ffi::GstVideoEncoder,
513 ) -> glib::ffi::gboolean {
514 let instance = &*(ptr as *mut T::Instance);
515 let imp = instance.impl_();
516 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
517
518 gst::panic_to_error!(&wrap, imp.panicked(), false, {
519 match imp.close(wrap.unsafe_cast_ref()) {
520 Ok(()) => true,
521 Err(err) => {
522 wrap.post_error_message(err);
523 false
524 }
525 }
526 })
527 .into_glib()
528 }
529
video_encoder_start<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean530 unsafe extern "C" fn video_encoder_start<T: VideoEncoderImpl>(
531 ptr: *mut ffi::GstVideoEncoder,
532 ) -> glib::ffi::gboolean {
533 let instance = &*(ptr as *mut T::Instance);
534 let imp = instance.impl_();
535 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
536
537 gst::panic_to_error!(&wrap, imp.panicked(), false, {
538 match imp.start(wrap.unsafe_cast_ref()) {
539 Ok(()) => true,
540 Err(err) => {
541 wrap.post_error_message(err);
542 false
543 }
544 }
545 })
546 .into_glib()
547 }
548
video_encoder_stop<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean549 unsafe extern "C" fn video_encoder_stop<T: VideoEncoderImpl>(
550 ptr: *mut ffi::GstVideoEncoder,
551 ) -> glib::ffi::gboolean {
552 let instance = &*(ptr as *mut T::Instance);
553 let imp = instance.impl_();
554 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
555
556 gst::panic_to_error!(&wrap, imp.panicked(), false, {
557 match imp.stop(wrap.unsafe_cast_ref()) {
558 Ok(()) => true,
559 Err(err) => {
560 wrap.post_error_message(err);
561 false
562 }
563 }
564 })
565 .into_glib()
566 }
567
video_encoder_finish<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> gst::ffi::GstFlowReturn568 unsafe extern "C" fn video_encoder_finish<T: VideoEncoderImpl>(
569 ptr: *mut ffi::GstVideoEncoder,
570 ) -> gst::ffi::GstFlowReturn {
571 let instance = &*(ptr as *mut T::Instance);
572 let imp = instance.impl_();
573 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
574
575 gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
576 imp.finish(wrap.unsafe_cast_ref()).into()
577 })
578 .into_glib()
579 }
580
video_encoder_set_format<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, state: *mut ffi::GstVideoCodecState, ) -> glib::ffi::gboolean581 unsafe extern "C" fn video_encoder_set_format<T: VideoEncoderImpl>(
582 ptr: *mut ffi::GstVideoEncoder,
583 state: *mut ffi::GstVideoCodecState,
584 ) -> glib::ffi::gboolean {
585 let instance = &*(ptr as *mut T::Instance);
586 let imp = instance.impl_();
587 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
588 ffi::gst_video_codec_state_ref(state);
589 let wrap_state = VideoCodecState::<Readable>::new(state);
590
591 gst::panic_to_error!(&wrap, imp.panicked(), false, {
592 match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) {
593 Ok(()) => true,
594 Err(err) => {
595 err.log_with_object(&*wrap);
596 false
597 }
598 }
599 })
600 .into_glib()
601 }
602
video_encoder_handle_frame<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, frame: *mut ffi::GstVideoCodecFrame, ) -> gst::ffi::GstFlowReturn603 unsafe extern "C" fn video_encoder_handle_frame<T: VideoEncoderImpl>(
604 ptr: *mut ffi::GstVideoEncoder,
605 frame: *mut ffi::GstVideoCodecFrame,
606 ) -> gst::ffi::GstFlowReturn {
607 let instance = &*(ptr as *mut T::Instance);
608 let imp = instance.impl_();
609 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
610 let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
611
612 gst::panic_to_error!(&wrap, imp.panicked(), gst::FlowReturn::Error, {
613 imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into()
614 })
615 .into_glib()
616 }
617
video_encoder_flush<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean618 unsafe extern "C" fn video_encoder_flush<T: VideoEncoderImpl>(
619 ptr: *mut ffi::GstVideoEncoder,
620 ) -> glib::ffi::gboolean {
621 let instance = &*(ptr as *mut T::Instance);
622 let imp = instance.impl_();
623 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
624
625 gst::panic_to_error!(&wrap, imp.panicked(), false, {
626 VideoEncoderImpl::flush(imp, wrap.unsafe_cast_ref())
627 })
628 .into_glib()
629 }
630
video_encoder_negotiate<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, ) -> glib::ffi::gboolean631 unsafe extern "C" fn video_encoder_negotiate<T: VideoEncoderImpl>(
632 ptr: *mut ffi::GstVideoEncoder,
633 ) -> glib::ffi::gboolean {
634 let instance = &*(ptr as *mut T::Instance);
635 let imp = instance.impl_();
636 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
637
638 gst::panic_to_error!(&wrap, imp.panicked(), false, {
639 match imp.negotiate(wrap.unsafe_cast_ref()) {
640 Ok(()) => true,
641 Err(err) => {
642 err.log_with_object(&*wrap);
643 false
644 }
645 }
646 })
647 .into_glib()
648 }
649
video_encoder_getcaps<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, filter: *mut gst::ffi::GstCaps, ) -> *mut gst::ffi::GstCaps650 unsafe extern "C" fn video_encoder_getcaps<T: VideoEncoderImpl>(
651 ptr: *mut ffi::GstVideoEncoder,
652 filter: *mut gst::ffi::GstCaps,
653 ) -> *mut gst::ffi::GstCaps {
654 let instance = &*(ptr as *mut T::Instance);
655 let imp = instance.impl_();
656 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
657
658 gst::panic_to_error!(&wrap, imp.panicked(), gst::Caps::new_empty(), {
659 VideoEncoderImpl::caps(
660 imp,
661 wrap.unsafe_cast_ref(),
662 Option::<gst::Caps>::from_glib_borrow(filter)
663 .as_ref()
664 .as_ref(),
665 )
666 })
667 .to_glib_full()
668 }
669
video_encoder_sink_event<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, event: *mut gst::ffi::GstEvent, ) -> glib::ffi::gboolean670 unsafe extern "C" fn video_encoder_sink_event<T: VideoEncoderImpl>(
671 ptr: *mut ffi::GstVideoEncoder,
672 event: *mut gst::ffi::GstEvent,
673 ) -> glib::ffi::gboolean {
674 let instance = &*(ptr as *mut T::Instance);
675 let imp = instance.impl_();
676 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
677
678 gst::panic_to_error!(&wrap, imp.panicked(), false, {
679 imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
680 })
681 .into_glib()
682 }
683
video_encoder_sink_query<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, query: *mut gst::ffi::GstQuery, ) -> glib::ffi::gboolean684 unsafe extern "C" fn video_encoder_sink_query<T: VideoEncoderImpl>(
685 ptr: *mut ffi::GstVideoEncoder,
686 query: *mut gst::ffi::GstQuery,
687 ) -> glib::ffi::gboolean {
688 let instance = &*(ptr as *mut T::Instance);
689 let imp = instance.impl_();
690 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
691
692 gst::panic_to_error!(&wrap, imp.panicked(), false, {
693 imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
694 })
695 .into_glib()
696 }
697
video_encoder_src_event<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, event: *mut gst::ffi::GstEvent, ) -> glib::ffi::gboolean698 unsafe extern "C" fn video_encoder_src_event<T: VideoEncoderImpl>(
699 ptr: *mut ffi::GstVideoEncoder,
700 event: *mut gst::ffi::GstEvent,
701 ) -> glib::ffi::gboolean {
702 let instance = &*(ptr as *mut T::Instance);
703 let imp = instance.impl_();
704 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
705
706 gst::panic_to_error!(&wrap, imp.panicked(), false, {
707 imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
708 })
709 .into_glib()
710 }
711
video_encoder_src_query<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, query: *mut gst::ffi::GstQuery, ) -> glib::ffi::gboolean712 unsafe extern "C" fn video_encoder_src_query<T: VideoEncoderImpl>(
713 ptr: *mut ffi::GstVideoEncoder,
714 query: *mut gst::ffi::GstQuery,
715 ) -> glib::ffi::gboolean {
716 let instance = &*(ptr as *mut T::Instance);
717 let imp = instance.impl_();
718 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
719
720 gst::panic_to_error!(&wrap, imp.panicked(), false, {
721 imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
722 })
723 .into_glib()
724 }
725
video_encoder_propose_allocation<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, query: *mut gst::ffi::GstQuery, ) -> glib::ffi::gboolean726 unsafe extern "C" fn video_encoder_propose_allocation<T: VideoEncoderImpl>(
727 ptr: *mut ffi::GstVideoEncoder,
728 query: *mut gst::ffi::GstQuery,
729 ) -> glib::ffi::gboolean {
730 let instance = &*(ptr as *mut T::Instance);
731 let imp = instance.impl_();
732 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
733 let query = gst::QueryRef::from_mut_ptr(query);
734
735 gst::panic_to_error!(&wrap, imp.panicked(), false, {
736 match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
737 Ok(()) => true,
738 Err(err) => {
739 wrap.post_error_message(err);
740 false
741 }
742 }
743 })
744 .into_glib()
745 }
746
video_encoder_decide_allocation<T: VideoEncoderImpl>( ptr: *mut ffi::GstVideoEncoder, query: *mut gst::ffi::GstQuery, ) -> glib::ffi::gboolean747 unsafe extern "C" fn video_encoder_decide_allocation<T: VideoEncoderImpl>(
748 ptr: *mut ffi::GstVideoEncoder,
749 query: *mut gst::ffi::GstQuery,
750 ) -> glib::ffi::gboolean {
751 let instance = &*(ptr as *mut T::Instance);
752 let imp = instance.impl_();
753 let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
754 let query = gst::QueryRef::from_mut_ptr(query);
755
756 gst::panic_to_error!(&wrap, imp.panicked(), false, {
757 match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
758 Ok(()) => true,
759 Err(err) => {
760 wrap.post_error_message(err);
761 false
762 }
763 }
764 })
765 .into_glib()
766 }
767