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

gstreamer_rtsp_server/subclass/
rtsp_client.rs
