gstreamer_rtsp_server/subclass/
rtsp_client.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use glib::{prelude::*, subclass::prelude::*, translate::*};
4
5use crate::{RTSPClient, ffi};
6
7pub trait RTSPClientImpl: ObjectImpl + ObjectSubclass<Type: IsA<RTSPClient>> + Send + Sync {
8    /// called when the SDP needs to be created for media.
9    fn create_sdp(&self, media: &crate::RTSPMedia) -> Option<gst_sdp::SDPMessage> {
10        self.parent_create_sdp(media)
11    }
12
13    /// called when the stream in media needs to be configured.
14    ///  The default implementation will configure the blocksize on the payloader when
15    ///  spcified in the request headers.
16    fn configure_client_media(
17        &self,
18        media: &crate::RTSPMedia,
19        stream: &crate::RTSPStream,
20        ctx: &crate::RTSPContext,
21    ) -> Result<(), gst::LoggableError> {
22        self.parent_configure_client_media(media, stream, ctx)
23    }
24
25    // TODO: configure_client_transport
26
27    /// response) via a call to `gst_rtsp_message_init_response()`
28    fn params_set(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult {
29        self.parent_params_set(ctx)
30    }
31
32    /// response) via a call to `gst_rtsp_message_init_response()`
33    fn params_get(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult {
34        self.parent_params_get(ctx)
35    }
36
37    /// called to create path from uri.
38    fn make_path_from_uri(&self, url: &gst_rtsp::RTSPUrl) -> Option<glib::GString> {
39        self.parent_make_path_from_uri(url)
40    }
41
42    fn closed(&self) {
43        self.parent_closed();
44    }
45
46    fn new_session(&self, session: &crate::RTSPSession) {
47        self.parent_new_session(session);
48    }
49
50    fn options_request(&self, ctx: &crate::RTSPContext) {
51        self.parent_options_request(ctx);
52    }
53
54    fn describe_request(&self, ctx: &crate::RTSPContext) {
55        self.parent_describe_request(ctx);
56    }
57
58    fn setup_request(&self, ctx: &crate::RTSPContext) {
59        self.parent_setup_request(ctx);
60    }
61
62    fn play_request(&self, ctx: &crate::RTSPContext) {
63        self.parent_play_request(ctx);
64    }
65
66    fn pause_request(&self, ctx: &crate::RTSPContext) {
67        self.parent_pause_request(ctx);
68    }
69
70    fn teardown_request(&self, ctx: &crate::RTSPContext) {
71        self.parent_teardown_request(ctx);
72    }
73
74    fn set_parameter_request(&self, ctx: &crate::RTSPContext) {
75        self.parent_set_parameter_request(ctx);
76    }
77
78    fn parameter_request(&self, ctx: &crate::RTSPContext) {
79        self.parent_parameter_request(ctx);
80    }
81
82    fn announce_request(&self, ctx: &crate::RTSPContext) {
83        self.parent_announce_request(ctx);
84    }
85
86    fn record_request(&self, ctx: &crate::RTSPContext) {
87        self.parent_record_request(ctx);
88    }
89
90    fn handle_response(&self, ctx: &crate::RTSPContext) {
91        self.parent_handle_response(ctx);
92    }
93
94    // TODO: tunnel_http_response
95    // TODO: send_message
96
97    fn handle_sdp(
98        &self,
99        ctx: &crate::RTSPContext,
100        media: &crate::RTSPMedia,
101        sdp: &gst_sdp::SDPMessageRef,
102    ) -> Result<(), gst::LoggableError> {
103        self.parent_handle_sdp(ctx, media, sdp)
104    }
105
106    fn check_requirements(
107        &self,
108        ctx: &crate::RTSPContext,
109        arr: &[String],
110    ) -> Option<glib::GString> {
111        self.parent_check_requirements(ctx, arr)
112    }
113
114    fn pre_options_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
115        self.parent_pre_options_request(ctx)
116    }
117
118    fn pre_describe_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
119        self.parent_pre_describe_request(ctx)
120    }
121
122    fn pre_setup_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
123        self.parent_pre_setup_request(ctx)
124    }
125
126    fn pre_play_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
127        self.parent_pre_play_request(ctx)
128    }
129
130    fn pre_pause_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
131        self.parent_pre_pause_request(ctx)
132    }
133
134    fn pre_teardown_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
135        self.parent_pre_teardown_request(ctx)
136    }
137
138    fn pre_set_parameter_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
139        self.parent_pre_set_parameter_request(ctx)
140    }
141
142    fn pre_get_parameter_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
143        self.parent_pre_get_parameter_request(ctx)
144    }
145
146    fn pre_announce_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
147        self.parent_pre_announce_request(ctx)
148    }
149
150    fn pre_record_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
151        self.parent_pre_record_request(ctx)
152    }
153
154    /// Called before sending error response to give the application the
155    /// possibility to adjust the error code.
156    /// ## `ctx`
157    /// a [`RTSPContext`][crate::RTSPContext]
158    /// ## `code`
159    /// a [`gst_rtsp::RTSPStatusCode`][crate::gst_rtsp::RTSPStatusCode]
160    ///
161    /// # Returns
162    ///
163    /// a [`gst_rtsp::RTSPStatusCode`][crate::gst_rtsp::RTSPStatusCode], containing the adjusted error code.
164    #[cfg(feature = "v1_22")]
165    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
166    fn adjust_error_code(
167        &self,
168        ctx: &crate::RTSPContext,
169        status_code: gst_rtsp::RTSPStatusCode,
170    ) -> gst_rtsp::RTSPStatusCode {
171        self.parent_adjust_error_code(ctx, status_code)
172    }
173}
174
175pub trait RTSPClientImplExt: RTSPClientImpl {
176    fn parent_create_sdp(&self, media: &crate::RTSPMedia) -> Option<gst_sdp::SDPMessage> {
177        unsafe {
178            let data = Self::type_data();
179            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
180            let f = (*parent_class)
181                .create_sdp
182                .expect("No `create_rtpbin` virtual method implementation in parent class");
183
184            from_glib_full(f(
185                self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
186                media.to_glib_none().0,
187            ))
188        }
189    }
190
191    fn parent_configure_client_media(
192        &self,
193        media: &crate::RTSPMedia,
194        stream: &crate::RTSPStream,
195        ctx: &crate::RTSPContext,
196    ) -> Result<(), gst::LoggableError> {
197        unsafe {
198            let data = Self::type_data();
199            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
200            let f = (*parent_class).configure_client_media.expect(
201                "No `configure_client_media` virtual method implementation in parent class",
202            );
203
204            gst::result_from_gboolean!(
205                f(
206                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
207                    media.to_glib_none().0,
208                    stream.to_glib_none().0,
209                    ctx.to_glib_none().0
210                ),
211                gst::CAT_RUST,
212                "Parent function `configure_client_media` failed"
213            )
214        }
215    }
216
217    // TODO: configure_client_transport
218
219    fn parent_params_set(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult {
220        unsafe {
221            let data = Self::type_data();
222            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
223            let f = (*parent_class)
224                .params_set
225                .expect("No `params_set` virtual method implementation in parent class");
226
227            from_glib(f(
228                self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
229                ctx.to_glib_none().0,
230            ))
231        }
232    }
233
234    fn parent_params_get(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPResult {
235        unsafe {
236            let data = Self::type_data();
237            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
238            let f = (*parent_class)
239                .params_get
240                .expect("No `params_get` virtual method implementation in parent class");
241
242            from_glib(f(
243                self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
244                ctx.to_glib_none().0,
245            ))
246        }
247    }
248
249    fn parent_make_path_from_uri(&self, url: &gst_rtsp::RTSPUrl) -> Option<glib::GString> {
250        unsafe {
251            let data = Self::type_data();
252            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
253            let f = (*parent_class)
254                .make_path_from_uri
255                .expect("No `make_path_from_uri` virtual method implementation in parent class");
256
257            from_glib_full(f(
258                self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
259                url.to_glib_none().0,
260            ))
261        }
262    }
263
264    fn parent_closed(&self) {
265        unsafe {
266            let data = Self::type_data();
267            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
268            if let Some(f) = (*parent_class).closed {
269                f(self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0);
270            }
271        }
272    }
273
274    fn parent_new_session(&self, session: &crate::RTSPSession) {
275        unsafe {
276            let data = Self::type_data();
277            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
278            if let Some(f) = (*parent_class).new_session {
279                f(
280                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
281                    session.to_glib_none().0,
282                );
283            }
284        }
285    }
286
287    fn parent_options_request(&self, ctx: &crate::RTSPContext) {
288        unsafe {
289            let data = Self::type_data();
290            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
291            if let Some(f) = (*parent_class).options_request {
292                f(
293                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
294                    ctx.to_glib_none().0,
295                );
296            }
297        }
298    }
299
300    fn parent_describe_request(&self, ctx: &crate::RTSPContext) {
301        unsafe {
302            let data = Self::type_data();
303            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
304            if let Some(f) = (*parent_class).describe_request {
305                f(
306                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
307                    ctx.to_glib_none().0,
308                );
309            }
310        }
311    }
312
313    fn parent_setup_request(&self, ctx: &crate::RTSPContext) {
314        unsafe {
315            let data = Self::type_data();
316            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
317            if let Some(f) = (*parent_class).setup_request {
318                f(
319                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
320                    ctx.to_glib_none().0,
321                );
322            }
323        }
324    }
325
326    fn parent_play_request(&self, ctx: &crate::RTSPContext) {
327        unsafe {
328            let data = Self::type_data();
329            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
330            if let Some(f) = (*parent_class).play_request {
331                f(
332                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
333                    ctx.to_glib_none().0,
334                );
335            }
336        }
337    }
338
339    fn parent_pause_request(&self, ctx: &crate::RTSPContext) {
340        unsafe {
341            let data = Self::type_data();
342            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
343            if let Some(f) = (*parent_class).pause_request {
344                f(
345                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
346                    ctx.to_glib_none().0,
347                );
348            }
349        }
350    }
351
352    fn parent_teardown_request(&self, ctx: &crate::RTSPContext) {
353        unsafe {
354            let data = Self::type_data();
355            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
356            if let Some(f) = (*parent_class).teardown_request {
357                f(
358                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
359                    ctx.to_glib_none().0,
360                );
361            }
362        }
363    }
364
365    fn parent_set_parameter_request(&self, ctx: &crate::RTSPContext) {
366        unsafe {
367            let data = Self::type_data();
368            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
369            if let Some(f) = (*parent_class).set_parameter_request {
370                f(
371                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
372                    ctx.to_glib_none().0,
373                );
374            }
375        }
376    }
377
378    fn parent_parameter_request(&self, ctx: &crate::RTSPContext) {
379        unsafe {
380            let data = Self::type_data();
381            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
382            if let Some(f) = (*parent_class).get_parameter_request {
383                f(
384                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
385                    ctx.to_glib_none().0,
386                );
387            }
388        }
389    }
390
391    fn parent_announce_request(&self, ctx: &crate::RTSPContext) {
392        unsafe {
393            let data = Self::type_data();
394            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
395            if let Some(f) = (*parent_class).announce_request {
396                f(
397                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
398                    ctx.to_glib_none().0,
399                );
400            }
401        }
402    }
403
404    fn parent_record_request(&self, ctx: &crate::RTSPContext) {
405        unsafe {
406            let data = Self::type_data();
407            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
408            if let Some(f) = (*parent_class).record_request {
409                f(
410                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
411                    ctx.to_glib_none().0,
412                );
413            }
414        }
415    }
416
417    fn parent_handle_response(&self, ctx: &crate::RTSPContext) {
418        unsafe {
419            let data = Self::type_data();
420            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
421            if let Some(f) = (*parent_class).handle_response {
422                f(
423                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
424                    ctx.to_glib_none().0,
425                );
426            }
427        }
428    }
429
430    // TODO: tunnel_http_response
431    // TODO: send_message
432
433    fn parent_handle_sdp(
434        &self,
435        ctx: &crate::RTSPContext,
436        media: &crate::RTSPMedia,
437        sdp: &gst_sdp::SDPMessageRef,
438    ) -> Result<(), gst::LoggableError> {
439        unsafe {
440            let data = Self::type_data();
441            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
442            let f = (*parent_class)
443                .handle_sdp
444                .expect("No `handle_sdp` virtual method implementation in parent class");
445
446            gst::result_from_gboolean!(
447                f(
448                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
449                    ctx.to_glib_none().0,
450                    media.to_glib_none().0,
451                    sdp as *const _ as *mut _
452                ),
453                gst::CAT_RUST,
454                "Parent function `handle_sdp` failed"
455            )
456        }
457    }
458
459    fn parent_check_requirements(
460        &self,
461        ctx: &crate::RTSPContext,
462        arr: &[String],
463    ) -> Option<glib::GString> {
464        unsafe {
465            let data = Self::type_data();
466            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
467            if let Some(f) = (*parent_class).check_requirements {
468                from_glib_full(f(
469                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
470                    ctx.to_glib_none().0,
471                    arr.to_glib_none().0,
472                ))
473            } else {
474                None
475            }
476        }
477    }
478
479    fn parent_pre_options_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
480        unsafe {
481            let data = Self::type_data();
482            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
483            if let Some(f) = (*parent_class).pre_options_request {
484                from_glib(f(
485                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
486                    ctx.to_glib_none().0,
487                ))
488            } else {
489                gst_rtsp::RTSPStatusCode::Ok
490            }
491        }
492    }
493
494    fn parent_pre_describe_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
495        unsafe {
496            let data = Self::type_data();
497            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
498            if let Some(f) = (*parent_class).pre_describe_request {
499                from_glib(f(
500                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
501                    ctx.to_glib_none().0,
502                ))
503            } else {
504                gst_rtsp::RTSPStatusCode::Ok
505            }
506        }
507    }
508
509    fn parent_pre_setup_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
510        unsafe {
511            let data = Self::type_data();
512            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
513            if let Some(f) = (*parent_class).pre_setup_request {
514                from_glib(f(
515                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
516                    ctx.to_glib_none().0,
517                ))
518            } else {
519                gst_rtsp::RTSPStatusCode::Ok
520            }
521        }
522    }
523
524    fn parent_pre_play_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
525        unsafe {
526            let data = Self::type_data();
527            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
528            if let Some(f) = (*parent_class).pre_play_request {
529                from_glib(f(
530                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
531                    ctx.to_glib_none().0,
532                ))
533            } else {
534                gst_rtsp::RTSPStatusCode::Ok
535            }
536        }
537    }
538
539    fn parent_pre_pause_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
540        unsafe {
541            let data = Self::type_data();
542            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
543            if let Some(f) = (*parent_class).pre_pause_request {
544                from_glib(f(
545                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
546                    ctx.to_glib_none().0,
547                ))
548            } else {
549                gst_rtsp::RTSPStatusCode::Ok
550            }
551        }
552    }
553
554    fn parent_pre_teardown_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
555        unsafe {
556            let data = Self::type_data();
557            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
558            if let Some(f) = (*parent_class).pre_teardown_request {
559                from_glib(f(
560                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
561                    ctx.to_glib_none().0,
562                ))
563            } else {
564                gst_rtsp::RTSPStatusCode::Ok
565            }
566        }
567    }
568
569    fn parent_pre_set_parameter_request(
570        &self,
571        ctx: &crate::RTSPContext,
572    ) -> gst_rtsp::RTSPStatusCode {
573        unsafe {
574            let data = Self::type_data();
575            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
576            if let Some(f) = (*parent_class).pre_set_parameter_request {
577                from_glib(f(
578                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
579                    ctx.to_glib_none().0,
580                ))
581            } else {
582                gst_rtsp::RTSPStatusCode::Ok
583            }
584        }
585    }
586
587    fn parent_pre_get_parameter_request(
588        &self,
589        ctx: &crate::RTSPContext,
590    ) -> gst_rtsp::RTSPStatusCode {
591        unsafe {
592            let data = Self::type_data();
593            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
594            if let Some(f) = (*parent_class).pre_get_parameter_request {
595                from_glib(f(
596                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
597                    ctx.to_glib_none().0,
598                ))
599            } else {
600                gst_rtsp::RTSPStatusCode::Ok
601            }
602        }
603    }
604
605    fn parent_pre_announce_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
606        unsafe {
607            let data = Self::type_data();
608            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
609            if let Some(f) = (*parent_class).pre_announce_request {
610                from_glib(f(
611                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
612                    ctx.to_glib_none().0,
613                ))
614            } else {
615                gst_rtsp::RTSPStatusCode::Ok
616            }
617        }
618    }
619
620    fn parent_pre_record_request(&self, ctx: &crate::RTSPContext) -> gst_rtsp::RTSPStatusCode {
621        unsafe {
622            let data = Self::type_data();
623            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
624            if let Some(f) = (*parent_class).pre_record_request {
625                from_glib(f(
626                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
627                    ctx.to_glib_none().0,
628                ))
629            } else {
630                gst_rtsp::RTSPStatusCode::Ok
631            }
632        }
633    }
634
635    #[cfg(feature = "v1_22")]
636    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
637    fn parent_adjust_error_code(
638        &self,
639        ctx: &crate::RTSPContext,
640        status_code: gst_rtsp::RTSPStatusCode,
641    ) -> gst_rtsp::RTSPStatusCode {
642        unsafe {
643            let data = Self::type_data();
644            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTSPClientClass;
645            if let Some(f) = (*parent_class).adjust_error_code {
646                from_glib(f(
647                    self.obj().unsafe_cast_ref::<RTSPClient>().to_glib_none().0,
648                    ctx.to_glib_none().0,
649                    status_code.into_glib(),
650                ))
651            } else {
652                gst_rtsp::RTSPStatusCode::Ok
653            }
654        }
655    }
656}
657
658impl<T: RTSPClientImpl> RTSPClientImplExt for T {}
659
660unsafe impl<T: RTSPClientImpl> IsSubclassable<T> for RTSPClient {
661    fn class_init(klass: &mut glib::Class<Self>) {
662        Self::parent_class_init::<T>(klass);
663        let klass = klass.as_mut();
664
665        // There was unintentional ABI breakage in 1.18 so let's work around that
666        // for now by casting to the old struct layout.
667        #[cfg(not(feature = "v1_18"))]
668        {
669            if gst::version() < (1, 18, 0, 0) {
670                #[derive(Copy, Clone)]
671                #[repr(C)]
672                pub struct CompatClass {
673                    pub parent_class: glib::gobject_ffi::GObjectClass,
674                    pub create_sdp: Option<
675                        unsafe extern "C" fn(
676                            *mut ffi::GstRTSPClient,
677                            *mut ffi::GstRTSPMedia,
678                        )
679                            -> *mut gst_sdp::ffi::GstSDPMessage,
680                    >,
681                    pub configure_client_media: Option<
682                        unsafe extern "C" fn(
683                            *mut ffi::GstRTSPClient,
684                            *mut ffi::GstRTSPMedia,
685                            *mut ffi::GstRTSPStream,
686                            *mut ffi::GstRTSPContext,
687                        ) -> glib::ffi::gboolean,
688                    >,
689                    pub configure_client_transport: Option<
690                        unsafe extern "C" fn(
691                            *mut ffi::GstRTSPClient,
692                            *mut ffi::GstRTSPContext,
693                            *mut gst_rtsp::ffi::GstRTSPTransport,
694                        ) -> glib::ffi::gboolean,
695                    >,
696                    pub params_set: Option<
697                        unsafe extern "C" fn(
698                            *mut ffi::GstRTSPClient,
699                            *mut ffi::GstRTSPContext,
700                        )
701                            -> gst_rtsp::ffi::GstRTSPResult,
702                    >,
703                    pub params_get: Option<
704                        unsafe extern "C" fn(
705                            *mut ffi::GstRTSPClient,
706                            *mut ffi::GstRTSPContext,
707                        )
708                            -> gst_rtsp::ffi::GstRTSPResult,
709                    >,
710                    pub make_path_from_uri: Option<
711                        unsafe extern "C" fn(
712                            *mut ffi::GstRTSPClient,
713                            *const gst_rtsp::ffi::GstRTSPUrl,
714                        ) -> *mut libc::c_char,
715                    >,
716                    pub closed: Option<unsafe extern "C" fn(*mut ffi::GstRTSPClient)>,
717                    pub new_session: Option<
718                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPSession),
719                    >,
720                    pub options_request: Option<
721                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
722                    >,
723                    pub describe_request: Option<
724                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
725                    >,
726                    pub setup_request: Option<
727                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
728                    >,
729                    pub play_request: Option<
730                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
731                    >,
732                    pub pause_request: Option<
733                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
734                    >,
735                    pub teardown_request: Option<
736                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
737                    >,
738                    pub set_parameter_request: Option<
739                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
740                    >,
741                    pub get_parameter_request: Option<
742                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
743                    >,
744                    pub handle_response: Option<
745                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
746                    >,
747                    pub tunnel_http_response: Option<
748                        unsafe extern "C" fn(
749                            *mut ffi::GstRTSPClient,
750                            *mut gst_rtsp::ffi::GstRTSPMessage,
751                            *mut gst_rtsp::ffi::GstRTSPMessage,
752                        ),
753                    >,
754                    pub send_message: Option<
755                        unsafe extern "C" fn(
756                            *mut ffi::GstRTSPClient,
757                            *mut ffi::GstRTSPContext,
758                            *mut gst_rtsp::ffi::GstRTSPMessage,
759                        ),
760                    >,
761                    pub handle_sdp: Option<
762                        unsafe extern "C" fn(
763                            *mut ffi::GstRTSPClient,
764                            *mut ffi::GstRTSPContext,
765                            *mut ffi::GstRTSPMedia,
766                            *mut gst_sdp::ffi::GstSDPMessage,
767                        ) -> glib::ffi::gboolean,
768                    >,
769                    pub announce_request: Option<
770                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
771                    >,
772                    pub record_request: Option<
773                        unsafe extern "C" fn(*mut ffi::GstRTSPClient, *mut ffi::GstRTSPContext),
774                    >,
775                    pub check_requirements: Option<
776                        unsafe extern "C" fn(
777                            *mut ffi::GstRTSPClient,
778                            *mut ffi::GstRTSPContext,
779                            *mut *mut libc::c_char,
780                        ) -> *mut libc::c_char,
781                    >,
782                    pub pre_options_request: Option<
783                        unsafe extern "C" fn(
784                            *mut ffi::GstRTSPClient,
785                            *mut ffi::GstRTSPContext,
786                        )
787                            -> gst_rtsp::ffi::GstRTSPStatusCode,
788                    >,
789                    pub pre_describe_request: Option<
790                        unsafe extern "C" fn(
791                            *mut ffi::GstRTSPClient,
792                            *mut ffi::GstRTSPContext,
793                        )
794                            -> gst_rtsp::ffi::GstRTSPStatusCode,
795                    >,
796                    pub pre_setup_request: Option<
797                        unsafe extern "C" fn(
798                            *mut ffi::GstRTSPClient,
799                            *mut ffi::GstRTSPContext,
800                        )
801                            -> gst_rtsp::ffi::GstRTSPStatusCode,
802                    >,
803                    pub pre_play_request: Option<
804                        unsafe extern "C" fn(
805                            *mut ffi::GstRTSPClient,
806                            *mut ffi::GstRTSPContext,
807                        )
808                            -> gst_rtsp::ffi::GstRTSPStatusCode,
809                    >,
810                    pub pre_pause_request: Option<
811                        unsafe extern "C" fn(
812                            *mut ffi::GstRTSPClient,
813                            *mut ffi::GstRTSPContext,
814                        )
815                            -> gst_rtsp::ffi::GstRTSPStatusCode,
816                    >,
817                    pub pre_teardown_request: Option<
818                        unsafe extern "C" fn(
819                            *mut ffi::GstRTSPClient,
820                            *mut ffi::GstRTSPContext,
821                        )
822                            -> gst_rtsp::ffi::GstRTSPStatusCode,
823                    >,
824                    pub pre_set_parameter_request: Option<
825                        unsafe extern "C" fn(
826                            *mut ffi::GstRTSPClient,
827                            *mut ffi::GstRTSPContext,
828                        )
829                            -> gst_rtsp::ffi::GstRTSPStatusCode,
830                    >,
831                    pub pre_get_parameter_request: Option<
832                        unsafe extern "C" fn(
833                            *mut ffi::GstRTSPClient,
834                            *mut ffi::GstRTSPContext,
835                        )
836                            -> gst_rtsp::ffi::GstRTSPStatusCode,
837                    >,
838                    pub pre_announce_request: Option<
839                        unsafe extern "C" fn(
840                            *mut ffi::GstRTSPClient,
841                            *mut ffi::GstRTSPContext,
842                        )
843                            -> gst_rtsp::ffi::GstRTSPStatusCode,
844                    >,
845                    pub pre_record_request: Option<
846                        unsafe extern "C" fn(
847                            *mut ffi::GstRTSPClient,
848                            *mut ffi::GstRTSPContext,
849                        )
850                            -> gst_rtsp::ffi::GstRTSPStatusCode,
851                    >,
852                    pub _gst_reserved: [glib::ffi::gpointer; 4],
853                }
854
855                let klass = unsafe {
856                    std::mem::transmute::<&mut ffi::GstRTSPClientClass, &mut CompatClass>(klass)
857                };
858
859                klass.create_sdp = Some(client_create_sdp::<T>);
860                klass.configure_client_media = Some(client_configure_client_media::<T>);
861                klass.params_set = Some(client_params_set::<T>);
862                klass.params_get = Some(client_params_get::<T>);
863                klass.make_path_from_uri = Some(client_make_path_from_uri::<T>);
864                klass.closed = Some(client_closed::<T>);
865                klass.new_session = Some(client_new_session::<T>);
866                klass.options_request = Some(client_options_request::<T>);
867                klass.describe_request = Some(client_describe_request::<T>);
868                klass.setup_request = Some(client_setup_request::<T>);
869                klass.play_request = Some(client_play_request::<T>);
870                klass.pause_request = Some(client_pause_request::<T>);
871                klass.teardown_request = Some(client_teardown_request::<T>);
872                klass.set_parameter_request = Some(client_set_parameter_request::<T>);
873                klass.get_parameter_request = Some(client_get_parameter_request::<T>);
874                klass.announce_request = Some(client_announce_request::<T>);
875                klass.record_request = Some(client_record_request::<T>);
876                klass.handle_response = Some(client_handle_response::<T>);
877                klass.handle_sdp = Some(client_handle_sdp::<T>);
878                klass.check_requirements = Some(client_check_requirements::<T>);
879                klass.pre_options_request = Some(client_pre_options_request::<T>);
880                klass.pre_describe_request = Some(client_pre_describe_request::<T>);
881                klass.pre_setup_request = Some(client_pre_setup_request::<T>);
882                klass.pre_play_request = Some(client_pre_play_request::<T>);
883                klass.pre_pause_request = Some(client_pre_pause_request::<T>);
884                klass.pre_teardown_request = Some(client_pre_teardown_request::<T>);
885                klass.pre_set_parameter_request = Some(client_pre_set_parameter_request::<T>);
886                klass.pre_get_parameter_request = Some(client_pre_get_parameter_request::<T>);
887                klass.pre_announce_request = Some(client_pre_announce_request::<T>);
888                klass.pre_record_request = Some(client_pre_record_request::<T>);
889
890                return;
891            }
892        }
893
894        klass.create_sdp = Some(client_create_sdp::<T>);
895        klass.configure_client_media = Some(client_configure_client_media::<T>);
896        klass.params_set = Some(client_params_set::<T>);
897        klass.params_get = Some(client_params_get::<T>);
898        klass.make_path_from_uri = Some(client_make_path_from_uri::<T>);
899        klass.closed = Some(client_closed::<T>);
900        klass.new_session = Some(client_new_session::<T>);
901        klass.options_request = Some(client_options_request::<T>);
902        klass.describe_request = Some(client_describe_request::<T>);
903        klass.setup_request = Some(client_setup_request::<T>);
904        klass.play_request = Some(client_play_request::<T>);
905        klass.pause_request = Some(client_pause_request::<T>);
906        klass.teardown_request = Some(client_teardown_request::<T>);
907        klass.set_parameter_request = Some(client_set_parameter_request::<T>);
908        klass.get_parameter_request = Some(client_get_parameter_request::<T>);
909        klass.announce_request = Some(client_announce_request::<T>);
910        klass.record_request = Some(client_record_request::<T>);
911        klass.handle_response = Some(client_handle_response::<T>);
912        klass.handle_sdp = Some(client_handle_sdp::<T>);
913        klass.check_requirements = Some(client_check_requirements::<T>);
914        klass.pre_options_request = Some(client_pre_options_request::<T>);
915        klass.pre_describe_request = Some(client_pre_describe_request::<T>);
916        klass.pre_setup_request = Some(client_pre_setup_request::<T>);
917        klass.pre_play_request = Some(client_pre_play_request::<T>);
918        klass.pre_pause_request = Some(client_pre_pause_request::<T>);
919        klass.pre_teardown_request = Some(client_pre_teardown_request::<T>);
920        klass.pre_set_parameter_request = Some(client_pre_set_parameter_request::<T>);
921        klass.pre_get_parameter_request = Some(client_pre_get_parameter_request::<T>);
922        klass.pre_announce_request = Some(client_pre_announce_request::<T>);
923        klass.pre_record_request = Some(client_pre_record_request::<T>);
924        #[cfg(feature = "v1_22")]
925        #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
926        {
927            klass.adjust_error_code = Some(client_adjust_error_code::<T>);
928        }
929    }
930}
931
932unsafe extern "C" fn client_create_sdp<T: RTSPClientImpl>(
933    ptr: *mut ffi::GstRTSPClient,
934    media: *mut ffi::GstRTSPMedia,
935) -> *mut gst_sdp::ffi::GstSDPMessage {
936    unsafe {
937        let instance = &*(ptr as *mut T::Instance);
938        let imp = instance.imp();
939
940        imp.create_sdp(&from_glib_borrow(media)).into_glib_ptr()
941    }
942}
943
944unsafe extern "C" fn client_configure_client_media<T: RTSPClientImpl>(
945    ptr: *mut ffi::GstRTSPClient,
946    media: *mut ffi::GstRTSPMedia,
947    stream: *mut ffi::GstRTSPStream,
948    ctx: *mut ffi::GstRTSPContext,
949) -> glib::ffi::gboolean {
950    unsafe {
951        let instance = &*(ptr as *mut T::Instance);
952        let imp = instance.imp();
953
954        match imp.configure_client_media(
955            &from_glib_borrow(media),
956            &from_glib_borrow(stream),
957            &from_glib_borrow(ctx),
958        ) {
959            Ok(()) => glib::ffi::GTRUE,
960            Err(err) => {
961                err.log_with_imp(imp);
962                glib::ffi::GFALSE
963            }
964        }
965    }
966}
967
968unsafe extern "C" fn client_params_set<T: RTSPClientImpl>(
969    ptr: *mut ffi::GstRTSPClient,
970    ctx: *mut ffi::GstRTSPContext,
971) -> gst_rtsp::ffi::GstRTSPResult {
972    unsafe {
973        let instance = &*(ptr as *mut T::Instance);
974        let imp = instance.imp();
975
976        imp.params_set(&from_glib_borrow(ctx)).into_glib()
977    }
978}
979
980unsafe extern "C" fn client_params_get<T: RTSPClientImpl>(
981    ptr: *mut ffi::GstRTSPClient,
982    ctx: *mut ffi::GstRTSPContext,
983) -> gst_rtsp::ffi::GstRTSPResult {
984    unsafe {
985        let instance = &*(ptr as *mut T::Instance);
986        let imp = instance.imp();
987
988        imp.params_get(&from_glib_borrow(ctx)).into_glib()
989    }
990}
991
992unsafe extern "C" fn client_make_path_from_uri<T: RTSPClientImpl>(
993    ptr: *mut ffi::GstRTSPClient,
994    url: *const gst_rtsp::ffi::GstRTSPUrl,
995) -> *mut std::ffi::c_char {
996    unsafe {
997        let instance = &*(ptr as *mut T::Instance);
998        let imp = instance.imp();
999
1000        imp.make_path_from_uri(&from_glib_borrow(url))
1001            .into_glib_ptr()
1002    }
1003}
1004
1005unsafe extern "C" fn client_closed<T: RTSPClientImpl>(ptr: *mut ffi::GstRTSPClient) {
1006    unsafe {
1007        let instance = &*(ptr as *mut T::Instance);
1008        let imp = instance.imp();
1009
1010        imp.closed();
1011    }
1012}
1013
1014unsafe extern "C" fn client_new_session<T: RTSPClientImpl>(
1015    ptr: *mut ffi::GstRTSPClient,
1016    session: *mut ffi::GstRTSPSession,
1017) {
1018    unsafe {
1019        let instance = &*(ptr as *mut T::Instance);
1020        let imp = instance.imp();
1021
1022        imp.new_session(&from_glib_borrow(session));
1023    }
1024}
1025
1026unsafe extern "C" fn client_options_request<T: RTSPClientImpl>(
1027    ptr: *mut ffi::GstRTSPClient,
1028    ctx: *mut ffi::GstRTSPContext,
1029) {
1030    unsafe {
1031        let instance = &*(ptr as *mut T::Instance);
1032        let imp = instance.imp();
1033
1034        imp.options_request(&from_glib_borrow(ctx));
1035    }
1036}
1037
1038unsafe extern "C" fn client_describe_request<T: RTSPClientImpl>(
1039    ptr: *mut ffi::GstRTSPClient,
1040    ctx: *mut ffi::GstRTSPContext,
1041) {
1042    unsafe {
1043        let instance = &*(ptr as *mut T::Instance);
1044        let imp = instance.imp();
1045
1046        imp.describe_request(&from_glib_borrow(ctx));
1047    }
1048}
1049
1050unsafe extern "C" fn client_setup_request<T: RTSPClientImpl>(
1051    ptr: *mut ffi::GstRTSPClient,
1052    ctx: *mut ffi::GstRTSPContext,
1053) {
1054    unsafe {
1055        let instance = &*(ptr as *mut T::Instance);
1056        let imp = instance.imp();
1057
1058        imp.setup_request(&from_glib_borrow(ctx));
1059    }
1060}
1061
1062unsafe extern "C" fn client_play_request<T: RTSPClientImpl>(
1063    ptr: *mut ffi::GstRTSPClient,
1064    ctx: *mut ffi::GstRTSPContext,
1065) {
1066    unsafe {
1067        let instance = &*(ptr as *mut T::Instance);
1068        let imp = instance.imp();
1069
1070        imp.play_request(&from_glib_borrow(ctx));
1071    }
1072}
1073
1074unsafe extern "C" fn client_pause_request<T: RTSPClientImpl>(
1075    ptr: *mut ffi::GstRTSPClient,
1076    ctx: *mut ffi::GstRTSPContext,
1077) {
1078    unsafe {
1079        let instance = &*(ptr as *mut T::Instance);
1080        let imp = instance.imp();
1081
1082        imp.pause_request(&from_glib_borrow(ctx));
1083    }
1084}
1085
1086unsafe extern "C" fn client_teardown_request<T: RTSPClientImpl>(
1087    ptr: *mut ffi::GstRTSPClient,
1088    ctx: *mut ffi::GstRTSPContext,
1089) {
1090    unsafe {
1091        let instance = &*(ptr as *mut T::Instance);
1092        let imp = instance.imp();
1093
1094        imp.teardown_request(&from_glib_borrow(ctx));
1095    }
1096}
1097
1098unsafe extern "C" fn client_set_parameter_request<T: RTSPClientImpl>(
1099    ptr: *mut ffi::GstRTSPClient,
1100    ctx: *mut ffi::GstRTSPContext,
1101) {
1102    unsafe {
1103        let instance = &*(ptr as *mut T::Instance);
1104        let imp = instance.imp();
1105
1106        imp.set_parameter_request(&from_glib_borrow(ctx));
1107    }
1108}
1109
1110unsafe extern "C" fn client_get_parameter_request<T: RTSPClientImpl>(
1111    ptr: *mut ffi::GstRTSPClient,
1112    ctx: *mut ffi::GstRTSPContext,
1113) {
1114    unsafe {
1115        let instance = &*(ptr as *mut T::Instance);
1116        let imp = instance.imp();
1117
1118        imp.parameter_request(&from_glib_borrow(ctx));
1119    }
1120}
1121
1122unsafe extern "C" fn client_announce_request<T: RTSPClientImpl>(
1123    ptr: *mut ffi::GstRTSPClient,
1124    ctx: *mut ffi::GstRTSPContext,
1125) {
1126    unsafe {
1127        let instance = &*(ptr as *mut T::Instance);
1128        let imp = instance.imp();
1129
1130        imp.announce_request(&from_glib_borrow(ctx));
1131    }
1132}
1133
1134unsafe extern "C" fn client_record_request<T: RTSPClientImpl>(
1135    ptr: *mut ffi::GstRTSPClient,
1136    ctx: *mut ffi::GstRTSPContext,
1137) {
1138    unsafe {
1139        let instance = &*(ptr as *mut T::Instance);
1140        let imp = instance.imp();
1141
1142        imp.record_request(&from_glib_borrow(ctx));
1143    }
1144}
1145
1146unsafe extern "C" fn client_handle_response<T: RTSPClientImpl>(
1147    ptr: *mut ffi::GstRTSPClient,
1148    ctx: *mut ffi::GstRTSPContext,
1149) {
1150    unsafe {
1151        let instance = &*(ptr as *mut T::Instance);
1152        let imp = instance.imp();
1153
1154        imp.handle_response(&from_glib_borrow(ctx));
1155    }
1156}
1157
1158unsafe extern "C" fn client_handle_sdp<T: RTSPClientImpl>(
1159    ptr: *mut ffi::GstRTSPClient,
1160    ctx: *mut ffi::GstRTSPContext,
1161    media: *mut ffi::GstRTSPMedia,
1162    sdp: *mut gst_sdp::ffi::GstSDPMessage,
1163) -> glib::ffi::gboolean {
1164    unsafe {
1165        let instance = &*(ptr as *mut T::Instance);
1166        let imp = instance.imp();
1167
1168        match imp.handle_sdp(
1169            &from_glib_borrow(ctx),
1170            &from_glib_borrow(media),
1171            &*(sdp as *mut _),
1172        ) {
1173            Ok(()) => glib::ffi::GTRUE,
1174            Err(err) => {
1175                err.log_with_imp(imp);
1176                glib::ffi::GFALSE
1177            }
1178        }
1179    }
1180}
1181
1182unsafe extern "C" fn client_check_requirements<T: RTSPClientImpl>(
1183    ptr: *mut ffi::GstRTSPClient,
1184    ctx: *mut ffi::GstRTSPContext,
1185    arr: *mut *mut std::ffi::c_char,
1186) -> *mut std::ffi::c_char {
1187    unsafe {
1188        let instance = &*(ptr as *mut T::Instance);
1189        let imp = instance.imp();
1190
1191        imp.check_requirements(&from_glib_borrow(ctx), Vec::from_glib_none(arr).as_slice())
1192            .into_glib_ptr()
1193    }
1194}
1195
1196unsafe extern "C" fn client_pre_options_request<T: RTSPClientImpl>(
1197    ptr: *mut ffi::GstRTSPClient,
1198    ctx: *mut ffi::GstRTSPContext,
1199) -> gst_rtsp::ffi::GstRTSPStatusCode {
1200    unsafe {
1201        let instance = &*(ptr as *mut T::Instance);
1202        let imp = instance.imp();
1203
1204        imp.pre_options_request(&from_glib_borrow(ctx)).into_glib()
1205    }
1206}
1207
1208unsafe extern "C" fn client_pre_describe_request<T: RTSPClientImpl>(
1209    ptr: *mut ffi::GstRTSPClient,
1210    ctx: *mut ffi::GstRTSPContext,
1211) -> gst_rtsp::ffi::GstRTSPStatusCode {
1212    unsafe {
1213        let instance = &*(ptr as *mut T::Instance);
1214        let imp = instance.imp();
1215
1216        imp.pre_describe_request(&from_glib_borrow(ctx)).into_glib()
1217    }
1218}
1219
1220unsafe extern "C" fn client_pre_setup_request<T: RTSPClientImpl>(
1221    ptr: *mut ffi::GstRTSPClient,
1222    ctx: *mut ffi::GstRTSPContext,
1223) -> gst_rtsp::ffi::GstRTSPStatusCode {
1224    unsafe {
1225        let instance = &*(ptr as *mut T::Instance);
1226        let imp = instance.imp();
1227
1228        imp.pre_setup_request(&from_glib_borrow(ctx)).into_glib()
1229    }
1230}
1231
1232unsafe extern "C" fn client_pre_play_request<T: RTSPClientImpl>(
1233    ptr: *mut ffi::GstRTSPClient,
1234    ctx: *mut ffi::GstRTSPContext,
1235) -> gst_rtsp::ffi::GstRTSPStatusCode {
1236    unsafe {
1237        let instance = &*(ptr as *mut T::Instance);
1238        let imp = instance.imp();
1239
1240        imp.pre_play_request(&from_glib_borrow(ctx)).into_glib()
1241    }
1242}
1243
1244unsafe extern "C" fn client_pre_pause_request<T: RTSPClientImpl>(
1245    ptr: *mut ffi::GstRTSPClient,
1246    ctx: *mut ffi::GstRTSPContext,
1247) -> gst_rtsp::ffi::GstRTSPStatusCode {
1248    unsafe {
1249        let instance = &*(ptr as *mut T::Instance);
1250        let imp = instance.imp();
1251
1252        imp.pre_pause_request(&from_glib_borrow(ctx)).into_glib()
1253    }
1254}
1255
1256unsafe extern "C" fn client_pre_teardown_request<T: RTSPClientImpl>(
1257    ptr: *mut ffi::GstRTSPClient,
1258    ctx: *mut ffi::GstRTSPContext,
1259) -> gst_rtsp::ffi::GstRTSPStatusCode {
1260    unsafe {
1261        let instance = &*(ptr as *mut T::Instance);
1262        let imp = instance.imp();
1263
1264        imp.pre_teardown_request(&from_glib_borrow(ctx)).into_glib()
1265    }
1266}
1267
1268unsafe extern "C" fn client_pre_set_parameter_request<T: RTSPClientImpl>(
1269    ptr: *mut ffi::GstRTSPClient,
1270    ctx: *mut ffi::GstRTSPContext,
1271) -> gst_rtsp::ffi::GstRTSPStatusCode {
1272    unsafe {
1273        let instance = &*(ptr as *mut T::Instance);
1274        let imp = instance.imp();
1275
1276        imp.pre_set_parameter_request(&from_glib_borrow(ctx))
1277            .into_glib()
1278    }
1279}
1280
1281unsafe extern "C" fn client_pre_get_parameter_request<T: RTSPClientImpl>(
1282    ptr: *mut ffi::GstRTSPClient,
1283    ctx: *mut ffi::GstRTSPContext,
1284) -> gst_rtsp::ffi::GstRTSPStatusCode {
1285    unsafe {
1286        let instance = &*(ptr as *mut T::Instance);
1287        let imp = instance.imp();
1288
1289        imp.pre_get_parameter_request(&from_glib_borrow(ctx))
1290            .into_glib()
1291    }
1292}
1293
1294unsafe extern "C" fn client_pre_announce_request<T: RTSPClientImpl>(
1295    ptr: *mut ffi::GstRTSPClient,
1296    ctx: *mut ffi::GstRTSPContext,
1297) -> gst_rtsp::ffi::GstRTSPStatusCode {
1298    unsafe {
1299        let instance = &*(ptr as *mut T::Instance);
1300        let imp = instance.imp();
1301
1302        imp.pre_announce_request(&from_glib_borrow(ctx)).into_glib()
1303    }
1304}
1305
1306unsafe extern "C" fn client_pre_record_request<T: RTSPClientImpl>(
1307    ptr: *mut ffi::GstRTSPClient,
1308    ctx: *mut ffi::GstRTSPContext,
1309) -> gst_rtsp::ffi::GstRTSPStatusCode {
1310    unsafe {
1311        let instance = &*(ptr as *mut T::Instance);
1312        let imp = instance.imp();
1313
1314        imp.pre_record_request(&from_glib_borrow(ctx)).into_glib()
1315    }
1316}
1317
1318#[cfg(feature = "v1_22")]
1319#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1320unsafe extern "C" fn client_adjust_error_code<T: RTSPClientImpl>(
1321    ptr: *mut ffi::GstRTSPClient,
1322    ctx: *mut ffi::GstRTSPContext,
1323    status_code: gst_rtsp::ffi::GstRTSPStatusCode,
1324) -> gst_rtsp::ffi::GstRTSPStatusCode {
1325    unsafe {
1326        let instance = &*(ptr as *mut T::Instance);
1327        let imp = instance.imp();
1328
1329        imp.adjust_error_code(&from_glib_borrow(ctx), from_glib(status_code))
1330            .into_glib()
1331    }
1332}
gstreamer_rtsp_server/subclass/rtsp_client.rs

gstreamer_rtsp_server/subclass/
rtsp_client.rs
