gstreamer_rtsp_server/subclass/
rtsp_client.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use glib::{prelude::*, subclass::prelude::*, translate::*};
4
5use crate::{RTSPClient, ffi};
6
7pub trait RTSPClientImpl: ObjectImpl + ObjectSubclass<Type: IsA<RTSPClient>> + Send + Sync {
8    /// called when the SDP needs to be created for media.
9    fn create_sdp(&self, media: &crate::RTSPMedia) -> Option<gst_sdp::SDPMessage> {
10        self.parent_create_sdp(media)
11    }
12
13    /// called when the stream in media needs to be configured.
14    ///  The default implementation will configure the blocksize on the payloader when
15    ///  spcified in the request headers.
16    fn configure_client_media(
17        &self,
18        media: &crate::RTSPMedia,
19        stream: &crate::RTSPStream,
20        ctx: &crate::RTSPContext,
21    ) -> Result<(), gst::LoggableError> {
22        self.parent_configure_client_media(media, stream, ctx)
23    }
24
25    // TODO: configure_client_transport
26
27    /// 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    unsafe {
939        let instance = &*(ptr as *mut T::Instance);
940        let imp = instance.imp();
941
942        imp.create_sdp(&from_glib_borrow(media)).into_glib_ptr()
943    }
944}
945
946unsafe extern "C" fn client_configure_client_media<T: RTSPClientImpl>(
947    ptr: *mut ffi::GstRTSPClient,
948    media: *mut ffi::GstRTSPMedia,
949    stream: *mut ffi::GstRTSPStream,
950    ctx: *mut ffi::GstRTSPContext,
951) -> glib::ffi::gboolean {
952    unsafe {
953        let instance = &*(ptr as *mut T::Instance);
954        let imp = instance.imp();
955
956        match imp.configure_client_media(
957            &from_glib_borrow(media),
958            &from_glib_borrow(stream),
959            &from_glib_borrow(ctx),
960        ) {
961            Ok(()) => glib::ffi::GTRUE,
962            Err(err) => {
963                err.log_with_imp(imp);
964                glib::ffi::GFALSE
965            }
966        }
967    }
968}
969
970unsafe extern "C" fn client_params_set<T: RTSPClientImpl>(
971    ptr: *mut ffi::GstRTSPClient,
972    ctx: *mut ffi::GstRTSPContext,
973) -> gst_rtsp::ffi::GstRTSPResult {
974    unsafe {
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}
981
982unsafe extern "C" fn client_params_get<T: RTSPClientImpl>(
983    ptr: *mut ffi::GstRTSPClient,
984    ctx: *mut ffi::GstRTSPContext,
985) -> gst_rtsp::ffi::GstRTSPResult {
986    unsafe {
987        let instance = &*(ptr as *mut T::Instance);
988        let imp = instance.imp();
989
990        imp.params_get(&from_glib_borrow(ctx)).into_glib()
991    }
992}
993
994unsafe extern "C" fn client_make_path_from_uri<T: RTSPClientImpl>(
995    ptr: *mut ffi::GstRTSPClient,
996    url: *const gst_rtsp::ffi::GstRTSPUrl,
997) -> *mut std::os::raw::c_char {
998    unsafe {
999        let instance = &*(ptr as *mut T::Instance);
1000        let imp = instance.imp();
1001
1002        imp.make_path_from_uri(&from_glib_borrow(url))
1003            .into_glib_ptr()
1004    }
1005}
1006
1007unsafe extern "C" fn client_closed<T: RTSPClientImpl>(ptr: *mut ffi::GstRTSPClient) {
1008    unsafe {
1009        let instance = &*(ptr as *mut T::Instance);
1010        let imp = instance.imp();
1011
1012        imp.closed();
1013    }
1014}
1015
1016unsafe extern "C" fn client_new_session<T: RTSPClientImpl>(
1017    ptr: *mut ffi::GstRTSPClient,
1018    session: *mut ffi::GstRTSPSession,
1019) {
1020    unsafe {
1021        let instance = &*(ptr as *mut T::Instance);
1022        let imp = instance.imp();
1023
1024        imp.new_session(&from_glib_borrow(session));
1025    }
1026}
1027
1028unsafe extern "C" fn client_options_request<T: RTSPClientImpl>(
1029    ptr: *mut ffi::GstRTSPClient,
1030    ctx: *mut ffi::GstRTSPContext,
1031) {
1032    unsafe {
1033        let instance = &*(ptr as *mut T::Instance);
1034        let imp = instance.imp();
1035
1036        imp.options_request(&from_glib_borrow(ctx));
1037    }
1038}
1039
1040unsafe extern "C" fn client_describe_request<T: RTSPClientImpl>(
1041    ptr: *mut ffi::GstRTSPClient,
1042    ctx: *mut ffi::GstRTSPContext,
1043) {
1044    unsafe {
1045        let instance = &*(ptr as *mut T::Instance);
1046        let imp = instance.imp();
1047
1048        imp.describe_request(&from_glib_borrow(ctx));
1049    }
1050}
1051
1052unsafe extern "C" fn client_setup_request<T: RTSPClientImpl>(
1053    ptr: *mut ffi::GstRTSPClient,
1054    ctx: *mut ffi::GstRTSPContext,
1055) {
1056    unsafe {
1057        let instance = &*(ptr as *mut T::Instance);
1058        let imp = instance.imp();
1059
1060        imp.setup_request(&from_glib_borrow(ctx));
1061    }
1062}
1063
1064unsafe extern "C" fn client_play_request<T: RTSPClientImpl>(
1065    ptr: *mut ffi::GstRTSPClient,
1066    ctx: *mut ffi::GstRTSPContext,
1067) {
1068    unsafe {
1069        let instance = &*(ptr as *mut T::Instance);
1070        let imp = instance.imp();
1071
1072        imp.play_request(&from_glib_borrow(ctx));
1073    }
1074}
1075
1076unsafe extern "C" fn client_pause_request<T: RTSPClientImpl>(
1077    ptr: *mut ffi::GstRTSPClient,
1078    ctx: *mut ffi::GstRTSPContext,
1079) {
1080    unsafe {
1081        let instance = &*(ptr as *mut T::Instance);
1082        let imp = instance.imp();
1083
1084        imp.pause_request(&from_glib_borrow(ctx));
1085    }
1086}
1087
1088unsafe extern "C" fn client_teardown_request<T: RTSPClientImpl>(
1089    ptr: *mut ffi::GstRTSPClient,
1090    ctx: *mut ffi::GstRTSPContext,
1091) {
1092    unsafe {
1093        let instance = &*(ptr as *mut T::Instance);
1094        let imp = instance.imp();
1095
1096        imp.teardown_request(&from_glib_borrow(ctx));
1097    }
1098}
1099
1100unsafe extern "C" fn client_set_parameter_request<T: RTSPClientImpl>(
1101    ptr: *mut ffi::GstRTSPClient,
1102    ctx: *mut ffi::GstRTSPContext,
1103) {
1104    unsafe {
1105        let instance = &*(ptr as *mut T::Instance);
1106        let imp = instance.imp();
1107
1108        imp.set_parameter_request(&from_glib_borrow(ctx));
1109    }
1110}
1111
1112unsafe extern "C" fn client_get_parameter_request<T: RTSPClientImpl>(
1113    ptr: *mut ffi::GstRTSPClient,
1114    ctx: *mut ffi::GstRTSPContext,
1115) {
1116    unsafe {
1117        let instance = &*(ptr as *mut T::Instance);
1118        let imp = instance.imp();
1119
1120        imp.parameter_request(&from_glib_borrow(ctx));
1121    }
1122}
1123
1124unsafe extern "C" fn client_announce_request<T: RTSPClientImpl>(
1125    ptr: *mut ffi::GstRTSPClient,
1126    ctx: *mut ffi::GstRTSPContext,
1127) {
1128    unsafe {
1129        let instance = &*(ptr as *mut T::Instance);
1130        let imp = instance.imp();
1131
1132        imp.announce_request(&from_glib_borrow(ctx));
1133    }
1134}
1135
1136unsafe extern "C" fn client_record_request<T: RTSPClientImpl>(
1137    ptr: *mut ffi::GstRTSPClient,
1138    ctx: *mut ffi::GstRTSPContext,
1139) {
1140    unsafe {
1141        let instance = &*(ptr as *mut T::Instance);
1142        let imp = instance.imp();
1143
1144        imp.record_request(&from_glib_borrow(ctx));
1145    }
1146}
1147
1148unsafe extern "C" fn client_handle_response<T: RTSPClientImpl>(
1149    ptr: *mut ffi::GstRTSPClient,
1150    ctx: *mut ffi::GstRTSPContext,
1151) {
1152    unsafe {
1153        let instance = &*(ptr as *mut T::Instance);
1154        let imp = instance.imp();
1155
1156        imp.handle_response(&from_glib_borrow(ctx));
1157    }
1158}
1159
1160unsafe extern "C" fn client_handle_sdp<T: RTSPClientImpl>(
1161    ptr: *mut ffi::GstRTSPClient,
1162    ctx: *mut ffi::GstRTSPContext,
1163    media: *mut ffi::GstRTSPMedia,
1164    sdp: *mut gst_sdp::ffi::GstSDPMessage,
1165) -> glib::ffi::gboolean {
1166    unsafe {
1167        let instance = &*(ptr as *mut T::Instance);
1168        let imp = instance.imp();
1169
1170        match imp.handle_sdp(
1171            &from_glib_borrow(ctx),
1172            &from_glib_borrow(media),
1173            &*(sdp as *mut _),
1174        ) {
1175            Ok(()) => glib::ffi::GTRUE,
1176            Err(err) => {
1177                err.log_with_imp(imp);
1178                glib::ffi::GFALSE
1179            }
1180        }
1181    }
1182}
1183
1184unsafe extern "C" fn client_check_requirements<T: RTSPClientImpl>(
1185    ptr: *mut ffi::GstRTSPClient,
1186    ctx: *mut ffi::GstRTSPContext,
1187    arr: *mut *mut std::os::raw::c_char,
1188) -> *mut std::os::raw::c_char {
1189    unsafe {
1190        let instance = &*(ptr as *mut T::Instance);
1191        let imp = instance.imp();
1192
1193        imp.check_requirements(&from_glib_borrow(ctx), Vec::from_glib_none(arr).as_slice())
1194            .into_glib_ptr()
1195    }
1196}
1197
1198unsafe extern "C" fn client_pre_options_request<T: RTSPClientImpl>(
1199    ptr: *mut ffi::GstRTSPClient,
1200    ctx: *mut ffi::GstRTSPContext,
1201) -> gst_rtsp::ffi::GstRTSPStatusCode {
1202    unsafe {
1203        let instance = &*(ptr as *mut T::Instance);
1204        let imp = instance.imp();
1205
1206        imp.pre_options_request(&from_glib_borrow(ctx)).into_glib()
1207    }
1208}
1209
1210unsafe extern "C" fn client_pre_describe_request<T: RTSPClientImpl>(
1211    ptr: *mut ffi::GstRTSPClient,
1212    ctx: *mut ffi::GstRTSPContext,
1213) -> gst_rtsp::ffi::GstRTSPStatusCode {
1214    unsafe {
1215        let instance = &*(ptr as *mut T::Instance);
1216        let imp = instance.imp();
1217
1218        imp.pre_describe_request(&from_glib_borrow(ctx)).into_glib()
1219    }
1220}
1221
1222unsafe extern "C" fn client_pre_setup_request<T: RTSPClientImpl>(
1223    ptr: *mut ffi::GstRTSPClient,
1224    ctx: *mut ffi::GstRTSPContext,
1225) -> gst_rtsp::ffi::GstRTSPStatusCode {
1226    unsafe {
1227        let instance = &*(ptr as *mut T::Instance);
1228        let imp = instance.imp();
1229
1230        imp.pre_setup_request(&from_glib_borrow(ctx)).into_glib()
1231    }
1232}
1233
1234unsafe extern "C" fn client_pre_play_request<T: RTSPClientImpl>(
1235    ptr: *mut ffi::GstRTSPClient,
1236    ctx: *mut ffi::GstRTSPContext,
1237) -> gst_rtsp::ffi::GstRTSPStatusCode {
1238    unsafe {
1239        let instance = &*(ptr as *mut T::Instance);
1240        let imp = instance.imp();
1241
1242        imp.pre_play_request(&from_glib_borrow(ctx)).into_glib()
1243    }
1244}
1245
1246unsafe extern "C" fn client_pre_pause_request<T: RTSPClientImpl>(
1247    ptr: *mut ffi::GstRTSPClient,
1248    ctx: *mut ffi::GstRTSPContext,
1249) -> gst_rtsp::ffi::GstRTSPStatusCode {
1250    unsafe {
1251        let instance = &*(ptr as *mut T::Instance);
1252        let imp = instance.imp();
1253
1254        imp.pre_pause_request(&from_glib_borrow(ctx)).into_glib()
1255    }
1256}
1257
1258unsafe extern "C" fn client_pre_teardown_request<T: RTSPClientImpl>(
1259    ptr: *mut ffi::GstRTSPClient,
1260    ctx: *mut ffi::GstRTSPContext,
1261) -> gst_rtsp::ffi::GstRTSPStatusCode {
1262    unsafe {
1263        let instance = &*(ptr as *mut T::Instance);
1264        let imp = instance.imp();
1265
1266        imp.pre_teardown_request(&from_glib_borrow(ctx)).into_glib()
1267    }
1268}
1269
1270unsafe extern "C" fn client_pre_set_parameter_request<T: RTSPClientImpl>(
1271    ptr: *mut ffi::GstRTSPClient,
1272    ctx: *mut ffi::GstRTSPContext,
1273) -> gst_rtsp::ffi::GstRTSPStatusCode {
1274    unsafe {
1275        let instance = &*(ptr as *mut T::Instance);
1276        let imp = instance.imp();
1277
1278        imp.pre_set_parameter_request(&from_glib_borrow(ctx))
1279            .into_glib()
1280    }
1281}
1282
1283unsafe extern "C" fn client_pre_get_parameter_request<T: RTSPClientImpl>(
1284    ptr: *mut ffi::GstRTSPClient,
1285    ctx: *mut ffi::GstRTSPContext,
1286) -> gst_rtsp::ffi::GstRTSPStatusCode {
1287    unsafe {
1288        let instance = &*(ptr as *mut T::Instance);
1289        let imp = instance.imp();
1290
1291        imp.pre_get_parameter_request(&from_glib_borrow(ctx))
1292            .into_glib()
1293    }
1294}
1295
1296unsafe extern "C" fn client_pre_announce_request<T: RTSPClientImpl>(
1297    ptr: *mut ffi::GstRTSPClient,
1298    ctx: *mut ffi::GstRTSPContext,
1299) -> gst_rtsp::ffi::GstRTSPStatusCode {
1300    unsafe {
1301        let instance = &*(ptr as *mut T::Instance);
1302        let imp = instance.imp();
1303
1304        imp.pre_announce_request(&from_glib_borrow(ctx)).into_glib()
1305    }
1306}
1307
1308unsafe extern "C" fn client_pre_record_request<T: RTSPClientImpl>(
1309    ptr: *mut ffi::GstRTSPClient,
1310    ctx: *mut ffi::GstRTSPContext,
1311) -> gst_rtsp::ffi::GstRTSPStatusCode {
1312    unsafe {
1313        let instance = &*(ptr as *mut T::Instance);
1314        let imp = instance.imp();
1315
1316        imp.pre_record_request(&from_glib_borrow(ctx)).into_glib()
1317    }
1318}
1319
1320#[cfg(feature = "v1_22")]
1321#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1322unsafe extern "C" fn client_adjust_error_code<T: RTSPClientImpl>(
1323    ptr: *mut ffi::GstRTSPClient,
1324    ctx: *mut ffi::GstRTSPContext,
1325    status_code: gst_rtsp::ffi::GstRTSPStatusCode,
1326) -> gst_rtsp::ffi::GstRTSPStatusCode {
1327    unsafe {
1328        let instance = &*(ptr as *mut T::Instance);
1329        let imp = instance.imp();
1330
1331        imp.adjust_error_code(&from_glib_borrow(ctx), from_glib(status_code))
1332            .into_glib()
1333    }
1334}
gstreamer_rtsp_server/subclass/rtsp_client.rs

gstreamer_rtsp_server/subclass/
rtsp_client.rs
