gstreamer_rtsp_server/subclass/
rtsp_client.rs

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

gstreamer_rtsp_server/subclass/
rtsp_client.rs
