mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git
synced 2024-05-16 15:22:53 +00:00
1b2b3a75bc
The `gir` repository now includes `generator.py` for easier sharing of improvements with other projects like `gtk(4)-rs`.
2652 lines
106 KiB
Rust
2652 lines
106 KiB
Rust
// Generated by gir (https://github.com/gtk-rs/gir @ a972bd6)
|
|
// from gir-files (https://github.com/gtk-rs/gir-files @ 6088bb6)
|
|
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git @ 208138a)
|
|
// DO NOT EDIT
|
|
|
|
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
|
|
#![allow(
|
|
clippy::approx_constant,
|
|
clippy::type_complexity,
|
|
clippy::unreadable_literal,
|
|
clippy::upper_case_acronyms
|
|
)]
|
|
#![cfg_attr(feature = "dox", feature(doc_cfg))]
|
|
|
|
use gio_sys as gio;
|
|
use glib_sys as glib;
|
|
use gobject_sys as gobject;
|
|
use gstreamer_net_sys as gst_net;
|
|
use gstreamer_rtsp_sys as gst_rtsp;
|
|
use gstreamer_sdp_sys as gst_sdp;
|
|
use gstreamer_sys as gst;
|
|
|
|
#[allow(unused_imports)]
|
|
use libc::{
|
|
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
|
|
intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
|
|
};
|
|
|
|
#[allow(unused_imports)]
|
|
use glib::{gboolean, gconstpointer, gpointer, GType};
|
|
|
|
// Enums
|
|
pub type GstRTSPAddressPoolResult = c_int;
|
|
pub const GST_RTSP_ADDRESS_POOL_OK: GstRTSPAddressPoolResult = 0;
|
|
pub const GST_RTSP_ADDRESS_POOL_EINVAL: GstRTSPAddressPoolResult = -1;
|
|
pub const GST_RTSP_ADDRESS_POOL_ERESERVED: GstRTSPAddressPoolResult = -2;
|
|
pub const GST_RTSP_ADDRESS_POOL_ERANGE: GstRTSPAddressPoolResult = -3;
|
|
pub const GST_RTSP_ADDRESS_POOL_ELAST: GstRTSPAddressPoolResult = -4;
|
|
|
|
pub type GstRTSPFilterResult = c_int;
|
|
pub const GST_RTSP_FILTER_REMOVE: GstRTSPFilterResult = 0;
|
|
pub const GST_RTSP_FILTER_KEEP: GstRTSPFilterResult = 1;
|
|
pub const GST_RTSP_FILTER_REF: GstRTSPFilterResult = 2;
|
|
|
|
pub type GstRTSPMediaStatus = c_int;
|
|
pub const GST_RTSP_MEDIA_STATUS_UNPREPARED: GstRTSPMediaStatus = 0;
|
|
pub const GST_RTSP_MEDIA_STATUS_UNPREPARING: GstRTSPMediaStatus = 1;
|
|
pub const GST_RTSP_MEDIA_STATUS_PREPARING: GstRTSPMediaStatus = 2;
|
|
pub const GST_RTSP_MEDIA_STATUS_PREPARED: GstRTSPMediaStatus = 3;
|
|
pub const GST_RTSP_MEDIA_STATUS_SUSPENDED: GstRTSPMediaStatus = 4;
|
|
pub const GST_RTSP_MEDIA_STATUS_ERROR: GstRTSPMediaStatus = 5;
|
|
|
|
pub type GstRTSPPublishClockMode = c_int;
|
|
pub const GST_RTSP_PUBLISH_CLOCK_MODE_NONE: GstRTSPPublishClockMode = 0;
|
|
pub const GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK: GstRTSPPublishClockMode = 1;
|
|
pub const GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET: GstRTSPPublishClockMode = 2;
|
|
|
|
pub type GstRTSPSuspendMode = c_int;
|
|
pub const GST_RTSP_SUSPEND_MODE_NONE: GstRTSPSuspendMode = 0;
|
|
pub const GST_RTSP_SUSPEND_MODE_PAUSE: GstRTSPSuspendMode = 1;
|
|
pub const GST_RTSP_SUSPEND_MODE_RESET: GstRTSPSuspendMode = 2;
|
|
|
|
pub type GstRTSPThreadType = c_int;
|
|
pub const GST_RTSP_THREAD_TYPE_CLIENT: GstRTSPThreadType = 0;
|
|
pub const GST_RTSP_THREAD_TYPE_MEDIA: GstRTSPThreadType = 1;
|
|
|
|
// Constants
|
|
pub const GST_RTSP_ADDRESS_POOL_ANY_IPV4: *const c_char =
|
|
b"0.0.0.0\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_ADDRESS_POOL_ANY_IPV6: *const c_char = b"::\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_AUTH_CHECK_CONNECT: *const c_char =
|
|
b"auth.check.connect\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_ACCESS: *const c_char =
|
|
b"auth.check.media.factory.access\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_CONSTRUCT: *const c_char =
|
|
b"auth.check.media.factory.construct\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_AUTH_CHECK_TRANSPORT_CLIENT_SETTINGS: *const c_char =
|
|
b"auth.check.transport.client-settings\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_AUTH_CHECK_URL: *const c_char =
|
|
b"auth.check.url\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_ONVIF_BACKCHANNEL_REQUIREMENT: *const c_char =
|
|
b"www.onvif.org/ver20/backchannel\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_ONVIF_REPLAY_REQUIREMENT: *const c_char =
|
|
b"onvif-replay\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_PERM_MEDIA_FACTORY_ACCESS: *const c_char =
|
|
b"media.factory.access\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_PERM_MEDIA_FACTORY_CONSTRUCT: *const c_char =
|
|
b"media.factory.construct\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_TOKEN_MEDIA_FACTORY_ROLE: *const c_char =
|
|
b"media.factory.role\0" as *const u8 as *const c_char;
|
|
pub const GST_RTSP_TOKEN_TRANSPORT_CLIENT_SETTINGS: *const c_char =
|
|
b"transport.client-settings\0" as *const u8 as *const c_char;
|
|
|
|
// Flags
|
|
pub type GstRTSPAddressFlags = c_uint;
|
|
pub const GST_RTSP_ADDRESS_FLAG_NONE: GstRTSPAddressFlags = 0;
|
|
pub const GST_RTSP_ADDRESS_FLAG_IPV4: GstRTSPAddressFlags = 1;
|
|
pub const GST_RTSP_ADDRESS_FLAG_IPV6: GstRTSPAddressFlags = 2;
|
|
pub const GST_RTSP_ADDRESS_FLAG_EVEN_PORT: GstRTSPAddressFlags = 4;
|
|
pub const GST_RTSP_ADDRESS_FLAG_MULTICAST: GstRTSPAddressFlags = 8;
|
|
pub const GST_RTSP_ADDRESS_FLAG_UNICAST: GstRTSPAddressFlags = 16;
|
|
|
|
pub type GstRTSPTransportMode = c_uint;
|
|
pub const GST_RTSP_TRANSPORT_MODE_PLAY: GstRTSPTransportMode = 1;
|
|
pub const GST_RTSP_TRANSPORT_MODE_RECORD: GstRTSPTransportMode = 2;
|
|
|
|
// Callbacks
|
|
pub type GstRTSPClientSendFunc = Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut gst_rtsp::GstRTSPMessage,
|
|
gboolean,
|
|
gpointer,
|
|
) -> gboolean,
|
|
>;
|
|
pub type GstRTSPClientSendMessagesFunc = Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut gst_rtsp::GstRTSPMessage,
|
|
c_uint,
|
|
gboolean,
|
|
gpointer,
|
|
) -> gboolean,
|
|
>;
|
|
pub type GstRTSPClientSessionFilterFunc = Option<
|
|
unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPSession, gpointer) -> GstRTSPFilterResult,
|
|
>;
|
|
pub type GstRTSPKeepAliveFunc = Option<unsafe extern "C" fn(gpointer)>;
|
|
pub type GstRTSPMessageSentFunc = Option<unsafe extern "C" fn(gpointer)>;
|
|
pub type GstRTSPMessageSentFuncFull =
|
|
Option<unsafe extern "C" fn(*mut GstRTSPStreamTransport, gpointer)>;
|
|
pub type GstRTSPSendFunc =
|
|
Option<unsafe extern "C" fn(*mut gst::GstBuffer, u8, gpointer) -> gboolean>;
|
|
pub type GstRTSPSendListFunc =
|
|
Option<unsafe extern "C" fn(*mut gst::GstBufferList, u8, gpointer) -> gboolean>;
|
|
pub type GstRTSPServerClientFilterFunc = Option<
|
|
unsafe extern "C" fn(*mut GstRTSPServer, *mut GstRTSPClient, gpointer) -> GstRTSPFilterResult,
|
|
>;
|
|
pub type GstRTSPSessionFilterFunc = Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPSession,
|
|
*mut GstRTSPSessionMedia,
|
|
gpointer,
|
|
) -> GstRTSPFilterResult,
|
|
>;
|
|
pub type GstRTSPSessionPoolFilterFunc = Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPSessionPool,
|
|
*mut GstRTSPSession,
|
|
gpointer,
|
|
) -> GstRTSPFilterResult,
|
|
>;
|
|
pub type GstRTSPSessionPoolFunc =
|
|
Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, gpointer) -> gboolean>;
|
|
pub type GstRTSPStreamTransportFilterFunc = Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPStream,
|
|
*mut GstRTSPStreamTransport,
|
|
gpointer,
|
|
) -> GstRTSPFilterResult,
|
|
>;
|
|
|
|
// Records
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPAddress {
|
|
pub pool: *mut GstRTSPAddressPool,
|
|
pub address: *mut c_char,
|
|
pub port: u16,
|
|
pub n_ports: c_int,
|
|
pub ttl: u8,
|
|
pub priv_: gpointer,
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPAddress {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPAddress @ {:?}", self as *const _))
|
|
.field("pool", &self.pool)
|
|
.field("address", &self.address)
|
|
.field("port", &self.port)
|
|
.field("n_ports", &self.n_ports)
|
|
.field("ttl", &self.ttl)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPAddressPoolClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPAddressPoolClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPAddressPoolClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPAddressPoolPrivate(c_void);
|
|
|
|
pub type GstRTSPAddressPoolPrivate = *mut _GstRTSPAddressPoolPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPAuthClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub authenticate:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext) -> gboolean>,
|
|
pub check: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext, *const c_char) -> gboolean,
|
|
>,
|
|
pub generate_authenticate_header:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext)>,
|
|
pub accept_certificate: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPAuth,
|
|
*mut gio::GTlsConnection,
|
|
*mut gio::GTlsCertificate,
|
|
gio::GTlsCertificateFlags,
|
|
) -> gboolean,
|
|
>,
|
|
pub _gst_reserved: [gpointer; 3],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPAuthClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPAuthClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("authenticate", &self.authenticate)
|
|
.field("check", &self.check)
|
|
.field(
|
|
"generate_authenticate_header",
|
|
&self.generate_authenticate_header,
|
|
)
|
|
.field("accept_certificate", &self.accept_certificate)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPAuthPrivate(c_void);
|
|
|
|
pub type GstRTSPAuthPrivate = *mut _GstRTSPAuthPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPClientClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub create_sdp: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPMedia) -> *mut gst_sdp::GstSDPMessage,
|
|
>,
|
|
pub configure_client_media: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPMedia,
|
|
*mut GstRTSPStream,
|
|
*mut GstRTSPContext,
|
|
) -> gboolean,
|
|
>,
|
|
pub configure_client_transport: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
*mut gst_rtsp::GstRTSPTransport,
|
|
) -> gboolean,
|
|
>,
|
|
pub params_set: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext) -> gst_rtsp::GstRTSPResult,
|
|
>,
|
|
pub params_get: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext) -> gst_rtsp::GstRTSPResult,
|
|
>,
|
|
pub make_path_from_uri: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPClient, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
|
|
>,
|
|
pub adjust_play_mode: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
*mut *mut gst_rtsp::GstRTSPTimeRange,
|
|
*mut gst::GstSeekFlags,
|
|
*mut c_double,
|
|
*mut gst::GstClockTime,
|
|
*mut gboolean,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub adjust_play_response: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub closed: Option<unsafe extern "C" fn(*mut GstRTSPClient)>,
|
|
pub new_session: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPSession)>,
|
|
pub options_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub describe_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub setup_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub play_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub pause_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub teardown_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub set_parameter_request:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub get_parameter_request:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub handle_response: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub tunnel_http_response: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut gst_rtsp::GstRTSPMessage,
|
|
*mut gst_rtsp::GstRTSPMessage,
|
|
),
|
|
>,
|
|
pub send_message: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
*mut gst_rtsp::GstRTSPMessage,
|
|
),
|
|
>,
|
|
pub handle_sdp: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
*mut GstRTSPMedia,
|
|
*mut gst_sdp::GstSDPMessage,
|
|
) -> gboolean,
|
|
>,
|
|
pub announce_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub record_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
|
|
pub check_requirements: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
*mut *mut c_char,
|
|
) -> *mut c_char,
|
|
>,
|
|
pub pre_options_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_describe_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_setup_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_play_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_pause_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_teardown_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_set_parameter_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_get_parameter_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_announce_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub pre_record_request: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPClient,
|
|
*mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPStatusCode,
|
|
>,
|
|
pub _gst_reserved: [gpointer; 2],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPClientClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPClientClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("create_sdp", &self.create_sdp)
|
|
.field("configure_client_media", &self.configure_client_media)
|
|
.field(
|
|
"configure_client_transport",
|
|
&self.configure_client_transport,
|
|
)
|
|
.field("params_set", &self.params_set)
|
|
.field("params_get", &self.params_get)
|
|
.field("make_path_from_uri", &self.make_path_from_uri)
|
|
.field("adjust_play_mode", &self.adjust_play_mode)
|
|
.field("adjust_play_response", &self.adjust_play_response)
|
|
.field("closed", &self.closed)
|
|
.field("new_session", &self.new_session)
|
|
.field("options_request", &self.options_request)
|
|
.field("describe_request", &self.describe_request)
|
|
.field("setup_request", &self.setup_request)
|
|
.field("play_request", &self.play_request)
|
|
.field("pause_request", &self.pause_request)
|
|
.field("teardown_request", &self.teardown_request)
|
|
.field("set_parameter_request", &self.set_parameter_request)
|
|
.field("get_parameter_request", &self.get_parameter_request)
|
|
.field("handle_response", &self.handle_response)
|
|
.field("tunnel_http_response", &self.tunnel_http_response)
|
|
.field("send_message", &self.send_message)
|
|
.field("handle_sdp", &self.handle_sdp)
|
|
.field("announce_request", &self.announce_request)
|
|
.field("record_request", &self.record_request)
|
|
.field("check_requirements", &self.check_requirements)
|
|
.field("pre_options_request", &self.pre_options_request)
|
|
.field("pre_describe_request", &self.pre_describe_request)
|
|
.field("pre_setup_request", &self.pre_setup_request)
|
|
.field("pre_play_request", &self.pre_play_request)
|
|
.field("pre_pause_request", &self.pre_pause_request)
|
|
.field("pre_teardown_request", &self.pre_teardown_request)
|
|
.field("pre_set_parameter_request", &self.pre_set_parameter_request)
|
|
.field("pre_get_parameter_request", &self.pre_get_parameter_request)
|
|
.field("pre_announce_request", &self.pre_announce_request)
|
|
.field("pre_record_request", &self.pre_record_request)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPClientPrivate(c_void);
|
|
|
|
pub type GstRTSPClientPrivate = *mut _GstRTSPClientPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPContext {
|
|
pub server: *mut GstRTSPServer,
|
|
pub conn: *mut gst_rtsp::GstRTSPConnection,
|
|
pub client: *mut GstRTSPClient,
|
|
pub request: *mut gst_rtsp::GstRTSPMessage,
|
|
pub uri: *mut gst_rtsp::GstRTSPUrl,
|
|
pub method: gst_rtsp::GstRTSPMethod,
|
|
pub auth: *mut GstRTSPAuth,
|
|
pub token: *mut GstRTSPToken,
|
|
pub session: *mut GstRTSPSession,
|
|
pub sessmedia: *mut GstRTSPSessionMedia,
|
|
pub factory: *mut GstRTSPMediaFactory,
|
|
pub media: *mut GstRTSPMedia,
|
|
pub stream: *mut GstRTSPStream,
|
|
pub response: *mut gst_rtsp::GstRTSPMessage,
|
|
pub trans: *mut GstRTSPStreamTransport,
|
|
pub _gst_reserved: [gpointer; 3],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPContext {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPContext @ {:?}", self as *const _))
|
|
.field("server", &self.server)
|
|
.field("conn", &self.conn)
|
|
.field("client", &self.client)
|
|
.field("request", &self.request)
|
|
.field("uri", &self.uri)
|
|
.field("method", &self.method)
|
|
.field("auth", &self.auth)
|
|
.field("token", &self.token)
|
|
.field("session", &self.session)
|
|
.field("sessmedia", &self.sessmedia)
|
|
.field("factory", &self.factory)
|
|
.field("media", &self.media)
|
|
.field("stream", &self.stream)
|
|
.field("response", &self.response)
|
|
.field("trans", &self.trans)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMediaClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub handle_message:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst::GstMessage) -> gboolean>,
|
|
pub prepare: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPThread) -> gboolean>,
|
|
pub unprepare: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
|
|
pub suspend: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
|
|
pub unsuspend: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
|
|
pub convert_range: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPMedia,
|
|
*mut gst_rtsp::GstRTSPTimeRange,
|
|
gst_rtsp::GstRTSPRangeUnit,
|
|
) -> gboolean,
|
|
>,
|
|
pub query_position: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut i64) -> gboolean>,
|
|
pub query_stop: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut i64) -> gboolean>,
|
|
pub create_rtpbin: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> *mut gst::GstElement>,
|
|
pub setup_rtpbin:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst::GstElement) -> gboolean>,
|
|
pub setup_sdp: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPMedia,
|
|
*mut gst_sdp::GstSDPMessage,
|
|
*mut GstSDPInfo,
|
|
) -> gboolean,
|
|
>,
|
|
pub new_stream: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPStream)>,
|
|
pub removed_stream: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPStream)>,
|
|
pub prepared: Option<unsafe extern "C" fn(*mut GstRTSPMedia)>,
|
|
pub unprepared: Option<unsafe extern "C" fn(*mut GstRTSPMedia)>,
|
|
pub target_state: Option<unsafe extern "C" fn(*mut GstRTSPMedia, gst::GstState)>,
|
|
pub new_state: Option<unsafe extern "C" fn(*mut GstRTSPMedia, gst::GstState)>,
|
|
pub handle_sdp:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst_sdp::GstSDPMessage) -> gboolean>,
|
|
pub _gst_reserved: [gpointer; 19],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMediaClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMediaClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("handle_message", &self.handle_message)
|
|
.field("prepare", &self.prepare)
|
|
.field("unprepare", &self.unprepare)
|
|
.field("suspend", &self.suspend)
|
|
.field("unsuspend", &self.unsuspend)
|
|
.field("convert_range", &self.convert_range)
|
|
.field("query_position", &self.query_position)
|
|
.field("query_stop", &self.query_stop)
|
|
.field("create_rtpbin", &self.create_rtpbin)
|
|
.field("setup_rtpbin", &self.setup_rtpbin)
|
|
.field("setup_sdp", &self.setup_sdp)
|
|
.field("new_stream", &self.new_stream)
|
|
.field("removed_stream", &self.removed_stream)
|
|
.field("prepared", &self.prepared)
|
|
.field("unprepared", &self.unprepared)
|
|
.field("target_state", &self.target_state)
|
|
.field("new_state", &self.new_state)
|
|
.field("handle_sdp", &self.handle_sdp)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMediaFactoryClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub gen_key: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPMediaFactory, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
|
|
>,
|
|
pub create_element: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPMediaFactory,
|
|
*const gst_rtsp::GstRTSPUrl,
|
|
) -> *mut gst::GstElement,
|
|
>,
|
|
pub construct: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPMediaFactory,
|
|
*const gst_rtsp::GstRTSPUrl,
|
|
) -> *mut GstRTSPMedia,
|
|
>,
|
|
pub create_pipeline: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia) -> *mut gst::GstElement,
|
|
>,
|
|
pub configure: Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
|
|
pub media_constructed:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
|
|
pub media_configure: Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMediaFactoryClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPMediaFactoryClass @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("gen_key", &self.gen_key)
|
|
.field("create_element", &self.create_element)
|
|
.field("construct", &self.construct)
|
|
.field("create_pipeline", &self.create_pipeline)
|
|
.field("configure", &self.configure)
|
|
.field("media_constructed", &self.media_constructed)
|
|
.field("media_configure", &self.media_configure)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPMediaFactoryPrivate(c_void);
|
|
|
|
pub type GstRTSPMediaFactoryPrivate = *mut _GstRTSPMediaFactoryPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMediaFactoryURIClass {
|
|
pub parent_class: GstRTSPMediaFactoryClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMediaFactoryURIClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPMediaFactoryURIClass @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPMediaFactoryURIPrivate(c_void);
|
|
|
|
pub type GstRTSPMediaFactoryURIPrivate = *mut _GstRTSPMediaFactoryURIPrivate;
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPMediaPrivate(c_void);
|
|
|
|
pub type GstRTSPMediaPrivate = *mut _GstRTSPMediaPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMountPointsClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub make_path: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPMountPoints, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
|
|
>,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMountPointsClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMountPointsClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("make_path", &self.make_path)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPMountPointsPrivate(c_void);
|
|
|
|
pub type GstRTSPMountPointsPrivate = *mut _GstRTSPMountPointsPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifClientClass {
|
|
pub parent: GstRTSPClientClass,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifClientClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifClientClass @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifMediaClass {
|
|
pub parent: GstRTSPMediaClass,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifMediaClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifMediaClass @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifMediaFactoryClass {
|
|
pub parent: GstRTSPMediaFactoryClass,
|
|
pub has_backchannel_support:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPOnvifMediaFactory) -> gboolean>,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifMediaFactoryClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPOnvifMediaFactoryClass @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent", &self.parent)
|
|
.field("has_backchannel_support", &self.has_backchannel_support)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPOnvifMediaFactoryPrivate(c_void);
|
|
|
|
pub type GstRTSPOnvifMediaFactoryPrivate = *mut _GstRTSPOnvifMediaFactoryPrivate;
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPOnvifMediaPrivate(c_void);
|
|
|
|
pub type GstRTSPOnvifMediaPrivate = *mut _GstRTSPOnvifMediaPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifServerClass {
|
|
pub parent: GstRTSPServerClass,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifServerClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifServerClass @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPPermissions {
|
|
pub mini_object: gst::GstMiniObject,
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPPermissions {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPPermissions @ {:?}", self as *const _))
|
|
.field("mini_object", &self.mini_object)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPServerClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub create_client: Option<unsafe extern "C" fn(*mut GstRTSPServer) -> *mut GstRTSPClient>,
|
|
pub client_connected: Option<unsafe extern "C" fn(*mut GstRTSPServer, *mut GstRTSPClient)>,
|
|
pub _gst_reserved: [gpointer; 20],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPServerClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPServerClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("create_client", &self.create_client)
|
|
.field("client_connected", &self.client_connected)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPServerPrivate(c_void);
|
|
|
|
pub type GstRTSPServerPrivate = *mut _GstRTSPServerPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSessionClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSessionClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPSessionClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSessionMediaClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSessionMediaClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPSessionMediaClass @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPSessionMediaPrivate(c_void);
|
|
|
|
pub type GstRTSPSessionMediaPrivate = *mut _GstRTSPSessionMediaPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSessionPoolClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub create_session_id: Option<unsafe extern "C" fn(*mut GstRTSPSessionPool) -> *mut c_char>,
|
|
pub create_session:
|
|
Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, *const c_char) -> *mut GstRTSPSession>,
|
|
pub session_removed: Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, *mut GstRTSPSession)>,
|
|
pub _gst_reserved: [gpointer; 19],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSessionPoolClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPSessionPoolClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("create_session_id", &self.create_session_id)
|
|
.field("create_session", &self.create_session)
|
|
.field("session_removed", &self.session_removed)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPSessionPoolPrivate(c_void);
|
|
|
|
pub type GstRTSPSessionPoolPrivate = *mut _GstRTSPSessionPoolPrivate;
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPSessionPrivate(c_void);
|
|
|
|
pub type GstRTSPSessionPrivate = *mut _GstRTSPSessionPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPStreamClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPStreamClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPStreamClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPStreamPrivate(c_void);
|
|
|
|
pub type GstRTSPStreamPrivate = *mut _GstRTSPStreamPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPStreamTransportClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPStreamTransportClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPStreamTransportClass @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent_class", &self.parent_class)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPStreamTransportPrivate(c_void);
|
|
|
|
pub type GstRTSPStreamTransportPrivate = *mut _GstRTSPStreamTransportPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPThread {
|
|
pub mini_object: gst::GstMiniObject,
|
|
pub type_: GstRTSPThreadType,
|
|
pub context: *mut glib::GMainContext,
|
|
pub loop_: *mut glib::GMainLoop,
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPThread {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPThread @ {:?}", self as *const _))
|
|
.field("mini_object", &self.mini_object)
|
|
.field("type_", &self.type_)
|
|
.field("context", &self.context)
|
|
.field("loop_", &self.loop_)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPThreadPoolClass {
|
|
pub parent_class: gobject::GObjectClass,
|
|
pub pool: *mut glib::GThreadPool,
|
|
pub get_thread: Option<
|
|
unsafe extern "C" fn(
|
|
*mut GstRTSPThreadPool,
|
|
GstRTSPThreadType,
|
|
*mut GstRTSPContext,
|
|
) -> *mut GstRTSPThread,
|
|
>,
|
|
pub configure_thread: Option<
|
|
unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread, *mut GstRTSPContext),
|
|
>,
|
|
pub thread_enter: Option<unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread)>,
|
|
pub thread_leave: Option<unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread)>,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPThreadPoolClass {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPThreadPoolClass @ {:?}", self as *const _))
|
|
.field("parent_class", &self.parent_class)
|
|
.field("pool", &self.pool)
|
|
.field("get_thread", &self.get_thread)
|
|
.field("configure_thread", &self.configure_thread)
|
|
.field("thread_enter", &self.thread_enter)
|
|
.field("thread_leave", &self.thread_leave)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct _GstRTSPThreadPoolPrivate(c_void);
|
|
|
|
pub type GstRTSPThreadPoolPrivate = *mut _GstRTSPThreadPoolPrivate;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPToken {
|
|
pub mini_object: gst::GstMiniObject,
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPToken {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPToken @ {:?}", self as *const _))
|
|
.field("mini_object", &self.mini_object)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstSDPInfo {
|
|
pub is_ipv6: gboolean,
|
|
pub server_ip: *const c_char,
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstSDPInfo {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstSDPInfo @ {:?}", self as *const _))
|
|
.field("is_ipv6", &self.is_ipv6)
|
|
.field("server_ip", &self.server_ip)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
// Classes
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPAddressPool {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPAddressPoolPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPAddressPool {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPAddressPool @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPAuth {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPAuthPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPAuth {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPAuth @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPClient {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPClientPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPClient {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPClient @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMedia {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPMediaPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMedia {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMedia @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMediaFactory {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPMediaFactoryPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMediaFactory {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMediaFactory @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMediaFactoryURI {
|
|
pub parent: GstRTSPMediaFactory,
|
|
pub priv_: *mut GstRTSPMediaFactoryURIPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMediaFactoryURI {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMediaFactoryURI @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPMountPoints {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPMountPointsPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPMountPoints {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPMountPoints @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifClient {
|
|
pub parent: GstRTSPClient,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifClient {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifClient @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifMedia {
|
|
pub parent: GstRTSPMedia,
|
|
pub priv_: *mut GstRTSPOnvifMediaPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifMedia {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifMedia @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.field("priv_", &self.priv_)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifMediaFactory {
|
|
pub parent: GstRTSPMediaFactory,
|
|
pub priv_: *mut GstRTSPOnvifMediaFactoryPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifMediaFactory {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!(
|
|
"GstRTSPOnvifMediaFactory @ {:?}",
|
|
self as *const _
|
|
))
|
|
.field("parent", &self.parent)
|
|
.field("priv_", &self.priv_)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPOnvifServer {
|
|
pub parent: GstRTSPServer,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPOnvifServer {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPOnvifServer @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPServer {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPServerPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPServer {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPServer @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSession {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPSessionPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSession {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPSession @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSessionMedia {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPSessionMediaPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSessionMedia {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPSessionMedia @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPSessionPool {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPSessionPoolPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPSessionPool {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPSessionPool @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPStream {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPStreamPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPStream {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPStream @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPStreamTransport {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPStreamTransportPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPStreamTransport {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPStreamTransport @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct GstRTSPThreadPool {
|
|
pub parent: gobject::GObject,
|
|
pub priv_: *mut GstRTSPThreadPoolPrivate,
|
|
pub _gst_reserved: [gpointer; 4],
|
|
}
|
|
|
|
impl ::std::fmt::Debug for GstRTSPThreadPool {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
f.debug_struct(&format!("GstRTSPThreadPool @ {:?}", self as *const _))
|
|
.field("parent", &self.parent)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[link(name = "gstrtspserver-1.0")]
|
|
extern "C" {
|
|
|
|
//=========================================================================
|
|
// GstRTSPPublishClockMode
|
|
//=========================================================================
|
|
pub fn gst_rtsp_publish_clock_mode_get_type() -> GType;
|
|
|
|
//=========================================================================
|
|
// GstRTSPSuspendMode
|
|
//=========================================================================
|
|
pub fn gst_rtsp_suspend_mode_get_type() -> GType;
|
|
|
|
//=========================================================================
|
|
// GstRTSPTransportMode
|
|
//=========================================================================
|
|
pub fn gst_rtsp_transport_mode_get_type() -> GType;
|
|
|
|
//=========================================================================
|
|
// GstRTSPAddress
|
|
//=========================================================================
|
|
pub fn gst_rtsp_address_get_type() -> GType;
|
|
pub fn gst_rtsp_address_copy(addr: *mut GstRTSPAddress) -> *mut GstRTSPAddress;
|
|
pub fn gst_rtsp_address_free(addr: *mut GstRTSPAddress);
|
|
|
|
//=========================================================================
|
|
// GstRTSPContext
|
|
//=========================================================================
|
|
pub fn gst_rtsp_context_pop_current(ctx: *mut GstRTSPContext);
|
|
pub fn gst_rtsp_context_push_current(ctx: *mut GstRTSPContext);
|
|
pub fn gst_rtsp_context_get_current() -> *mut GstRTSPContext;
|
|
|
|
//=========================================================================
|
|
// GstRTSPPermissions
|
|
//=========================================================================
|
|
pub fn gst_rtsp_permissions_get_type() -> GType;
|
|
pub fn gst_rtsp_permissions_new() -> *mut GstRTSPPermissions;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_permissions_add_permission_for_role(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
permission: *const c_char,
|
|
allowed: gboolean,
|
|
);
|
|
pub fn gst_rtsp_permissions_add_role(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
fieldname: *const c_char,
|
|
...
|
|
);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_permissions_add_role_empty(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_permissions_add_role_from_structure(
|
|
permissions: *mut GstRTSPPermissions,
|
|
structure: *mut gst::GstStructure,
|
|
);
|
|
//pub fn gst_rtsp_permissions_add_role_valist(permissions: *mut GstRTSPPermissions, role: *const c_char, fieldname: *const c_char, var_args: /*Unimplemented*/va_list);
|
|
pub fn gst_rtsp_permissions_get_role(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
) -> *const gst::GstStructure;
|
|
pub fn gst_rtsp_permissions_is_allowed(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
permission: *const c_char,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_permissions_remove_role(
|
|
permissions: *mut GstRTSPPermissions,
|
|
role: *const c_char,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPThread
|
|
//=========================================================================
|
|
pub fn gst_rtsp_thread_get_type() -> GType;
|
|
pub fn gst_rtsp_thread_new(type_: GstRTSPThreadType) -> *mut GstRTSPThread;
|
|
pub fn gst_rtsp_thread_reuse(thread: *mut GstRTSPThread) -> gboolean;
|
|
pub fn gst_rtsp_thread_stop(thread: *mut GstRTSPThread);
|
|
|
|
//=========================================================================
|
|
// GstRTSPToken
|
|
//=========================================================================
|
|
pub fn gst_rtsp_token_get_type() -> GType;
|
|
pub fn gst_rtsp_token_new(firstfield: *const c_char, ...) -> *mut GstRTSPToken;
|
|
pub fn gst_rtsp_token_new_empty() -> *mut GstRTSPToken;
|
|
//pub fn gst_rtsp_token_new_valist(firstfield: *const c_char, var_args: /*Unimplemented*/va_list) -> *mut GstRTSPToken;
|
|
pub fn gst_rtsp_token_get_string(
|
|
token: *mut GstRTSPToken,
|
|
field: *const c_char,
|
|
) -> *const c_char;
|
|
pub fn gst_rtsp_token_get_structure(token: *mut GstRTSPToken) -> *const gst::GstStructure;
|
|
pub fn gst_rtsp_token_is_allowed(token: *mut GstRTSPToken, field: *const c_char) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_token_set_bool(
|
|
token: *mut GstRTSPToken,
|
|
field: *const c_char,
|
|
bool_value: gboolean,
|
|
);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_token_set_string(
|
|
token: *mut GstRTSPToken,
|
|
field: *const c_char,
|
|
string_value: *const c_char,
|
|
);
|
|
pub fn gst_rtsp_token_writable_structure(token: *mut GstRTSPToken) -> *mut gst::GstStructure;
|
|
|
|
//=========================================================================
|
|
// GstRTSPAddressPool
|
|
//=========================================================================
|
|
pub fn gst_rtsp_address_pool_get_type() -> GType;
|
|
pub fn gst_rtsp_address_pool_new() -> *mut GstRTSPAddressPool;
|
|
pub fn gst_rtsp_address_pool_acquire_address(
|
|
pool: *mut GstRTSPAddressPool,
|
|
flags: GstRTSPAddressFlags,
|
|
n_ports: c_int,
|
|
) -> *mut GstRTSPAddress;
|
|
pub fn gst_rtsp_address_pool_add_range(
|
|
pool: *mut GstRTSPAddressPool,
|
|
min_address: *const c_char,
|
|
max_address: *const c_char,
|
|
min_port: u16,
|
|
max_port: u16,
|
|
ttl: u8,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_address_pool_clear(pool: *mut GstRTSPAddressPool);
|
|
pub fn gst_rtsp_address_pool_dump(pool: *mut GstRTSPAddressPool);
|
|
pub fn gst_rtsp_address_pool_has_unicast_addresses(pool: *mut GstRTSPAddressPool) -> gboolean;
|
|
pub fn gst_rtsp_address_pool_reserve_address(
|
|
pool: *mut GstRTSPAddressPool,
|
|
ip_address: *const c_char,
|
|
port: c_uint,
|
|
n_ports: c_uint,
|
|
ttl: c_uint,
|
|
address: *mut *mut GstRTSPAddress,
|
|
) -> GstRTSPAddressPoolResult;
|
|
|
|
//=========================================================================
|
|
// GstRTSPAuth
|
|
//=========================================================================
|
|
pub fn gst_rtsp_auth_get_type() -> GType;
|
|
pub fn gst_rtsp_auth_new() -> *mut GstRTSPAuth;
|
|
pub fn gst_rtsp_auth_check(check: *const c_char) -> gboolean;
|
|
pub fn gst_rtsp_auth_make_basic(user: *const c_char, pass: *const c_char) -> *mut c_char;
|
|
pub fn gst_rtsp_auth_add_basic(
|
|
auth: *mut GstRTSPAuth,
|
|
basic: *const c_char,
|
|
token: *mut GstRTSPToken,
|
|
);
|
|
#[cfg(any(feature = "v1_12", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
|
|
pub fn gst_rtsp_auth_add_digest(
|
|
auth: *mut GstRTSPAuth,
|
|
user: *const c_char,
|
|
pass: *const c_char,
|
|
token: *mut GstRTSPToken,
|
|
);
|
|
pub fn gst_rtsp_auth_get_default_token(auth: *mut GstRTSPAuth) -> *mut GstRTSPToken;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_auth_get_realm(auth: *mut GstRTSPAuth) -> *mut c_char;
|
|
#[cfg(any(feature = "v1_12", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
|
|
pub fn gst_rtsp_auth_get_supported_methods(
|
|
auth: *mut GstRTSPAuth,
|
|
) -> gst_rtsp::GstRTSPAuthMethod;
|
|
pub fn gst_rtsp_auth_get_tls_authentication_mode(
|
|
auth: *mut GstRTSPAuth,
|
|
) -> gio::GTlsAuthenticationMode;
|
|
pub fn gst_rtsp_auth_get_tls_certificate(auth: *mut GstRTSPAuth) -> *mut gio::GTlsCertificate;
|
|
pub fn gst_rtsp_auth_get_tls_database(auth: *mut GstRTSPAuth) -> *mut gio::GTlsDatabase;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_auth_parse_htdigest(
|
|
auth: *mut GstRTSPAuth,
|
|
path: *const c_char,
|
|
token: *mut GstRTSPToken,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_auth_remove_basic(auth: *mut GstRTSPAuth, basic: *const c_char);
|
|
#[cfg(any(feature = "v1_12", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
|
|
pub fn gst_rtsp_auth_remove_digest(auth: *mut GstRTSPAuth, user: *const c_char);
|
|
pub fn gst_rtsp_auth_set_default_token(auth: *mut GstRTSPAuth, token: *mut GstRTSPToken);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_auth_set_realm(auth: *mut GstRTSPAuth, realm: *const c_char);
|
|
#[cfg(any(feature = "v1_12", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
|
|
pub fn gst_rtsp_auth_set_supported_methods(
|
|
auth: *mut GstRTSPAuth,
|
|
methods: gst_rtsp::GstRTSPAuthMethod,
|
|
);
|
|
pub fn gst_rtsp_auth_set_tls_authentication_mode(
|
|
auth: *mut GstRTSPAuth,
|
|
mode: gio::GTlsAuthenticationMode,
|
|
);
|
|
pub fn gst_rtsp_auth_set_tls_certificate(
|
|
auth: *mut GstRTSPAuth,
|
|
cert: *mut gio::GTlsCertificate,
|
|
);
|
|
pub fn gst_rtsp_auth_set_tls_database(auth: *mut GstRTSPAuth, database: *mut gio::GTlsDatabase);
|
|
|
|
//=========================================================================
|
|
// GstRTSPClient
|
|
//=========================================================================
|
|
pub fn gst_rtsp_client_get_type() -> GType;
|
|
pub fn gst_rtsp_client_new() -> *mut GstRTSPClient;
|
|
pub fn gst_rtsp_client_attach(
|
|
client: *mut GstRTSPClient,
|
|
context: *mut glib::GMainContext,
|
|
) -> c_uint;
|
|
pub fn gst_rtsp_client_close(client: *mut GstRTSPClient);
|
|
pub fn gst_rtsp_client_get_auth(client: *mut GstRTSPClient) -> *mut GstRTSPAuth;
|
|
pub fn gst_rtsp_client_get_connection(
|
|
client: *mut GstRTSPClient,
|
|
) -> *mut gst_rtsp::GstRTSPConnection;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_client_get_content_length_limit(client: *mut GstRTSPClient) -> c_uint;
|
|
pub fn gst_rtsp_client_get_mount_points(client: *mut GstRTSPClient) -> *mut GstRTSPMountPoints;
|
|
pub fn gst_rtsp_client_get_session_pool(client: *mut GstRTSPClient) -> *mut GstRTSPSessionPool;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_client_get_stream_transport(
|
|
client: *mut GstRTSPClient,
|
|
channel: u8,
|
|
) -> *mut GstRTSPStreamTransport;
|
|
pub fn gst_rtsp_client_get_thread_pool(client: *mut GstRTSPClient) -> *mut GstRTSPThreadPool;
|
|
pub fn gst_rtsp_client_handle_message(
|
|
client: *mut GstRTSPClient,
|
|
message: *mut gst_rtsp::GstRTSPMessage,
|
|
) -> gst_rtsp::GstRTSPResult;
|
|
pub fn gst_rtsp_client_send_message(
|
|
client: *mut GstRTSPClient,
|
|
session: *mut GstRTSPSession,
|
|
message: *mut gst_rtsp::GstRTSPMessage,
|
|
) -> gst_rtsp::GstRTSPResult;
|
|
pub fn gst_rtsp_client_session_filter(
|
|
client: *mut GstRTSPClient,
|
|
func: GstRTSPClientSessionFilterFunc,
|
|
user_data: gpointer,
|
|
) -> *mut glib::GList;
|
|
pub fn gst_rtsp_client_set_auth(client: *mut GstRTSPClient, auth: *mut GstRTSPAuth);
|
|
pub fn gst_rtsp_client_set_connection(
|
|
client: *mut GstRTSPClient,
|
|
conn: *mut gst_rtsp::GstRTSPConnection,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_client_set_content_length_limit(client: *mut GstRTSPClient, limit: c_uint);
|
|
pub fn gst_rtsp_client_set_mount_points(
|
|
client: *mut GstRTSPClient,
|
|
mounts: *mut GstRTSPMountPoints,
|
|
);
|
|
pub fn gst_rtsp_client_set_send_func(
|
|
client: *mut GstRTSPClient,
|
|
func: GstRTSPClientSendFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_client_set_send_messages_func(
|
|
client: *mut GstRTSPClient,
|
|
func: GstRTSPClientSendMessagesFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
pub fn gst_rtsp_client_set_session_pool(
|
|
client: *mut GstRTSPClient,
|
|
pool: *mut GstRTSPSessionPool,
|
|
);
|
|
pub fn gst_rtsp_client_set_thread_pool(
|
|
client: *mut GstRTSPClient,
|
|
pool: *mut GstRTSPThreadPool,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPMedia
|
|
//=========================================================================
|
|
pub fn gst_rtsp_media_get_type() -> GType;
|
|
pub fn gst_rtsp_media_new(element: *mut gst::GstElement) -> *mut GstRTSPMedia;
|
|
pub fn gst_rtsp_media_collect_streams(media: *mut GstRTSPMedia);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_media_complete_pipeline(
|
|
media: *mut GstRTSPMedia,
|
|
transports: *mut glib::GPtrArray,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_create_stream(
|
|
media: *mut GstRTSPMedia,
|
|
payloader: *mut gst::GstElement,
|
|
pad: *mut gst::GstPad,
|
|
) -> *mut GstRTSPStream;
|
|
pub fn gst_rtsp_media_find_stream(
|
|
media: *mut GstRTSPMedia,
|
|
control: *const c_char,
|
|
) -> *mut GstRTSPStream;
|
|
pub fn gst_rtsp_media_get_address_pool(media: *mut GstRTSPMedia) -> *mut GstRTSPAddressPool;
|
|
pub fn gst_rtsp_media_get_base_time(media: *mut GstRTSPMedia) -> gst::GstClockTime;
|
|
pub fn gst_rtsp_media_get_buffer_size(media: *mut GstRTSPMedia) -> c_uint;
|
|
pub fn gst_rtsp_media_get_clock(media: *mut GstRTSPMedia) -> *mut gst::GstClock;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_get_do_retransmission(media: *mut GstRTSPMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_get_dscp_qos(media: *mut GstRTSPMedia) -> c_int;
|
|
pub fn gst_rtsp_media_get_element(media: *mut GstRTSPMedia) -> *mut gst::GstElement;
|
|
pub fn gst_rtsp_media_get_latency(media: *mut GstRTSPMedia) -> c_uint;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_get_max_mcast_ttl(media: *mut GstRTSPMedia) -> c_uint;
|
|
pub fn gst_rtsp_media_get_multicast_iface(media: *mut GstRTSPMedia) -> *mut c_char;
|
|
pub fn gst_rtsp_media_get_permissions(media: *mut GstRTSPMedia) -> *mut GstRTSPPermissions;
|
|
pub fn gst_rtsp_media_get_profiles(media: *mut GstRTSPMedia) -> gst_rtsp::GstRTSPProfile;
|
|
pub fn gst_rtsp_media_get_protocols(media: *mut GstRTSPMedia) -> gst_rtsp::GstRTSPLowerTrans;
|
|
pub fn gst_rtsp_media_get_publish_clock_mode(
|
|
media: *mut GstRTSPMedia,
|
|
) -> GstRTSPPublishClockMode;
|
|
pub fn gst_rtsp_media_get_range_string(
|
|
media: *mut GstRTSPMedia,
|
|
play: gboolean,
|
|
unit: gst_rtsp::GstRTSPRangeUnit,
|
|
) -> *mut c_char;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_get_rate_control(media: *mut GstRTSPMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_get_rates(
|
|
media: *mut GstRTSPMedia,
|
|
rate: *mut c_double,
|
|
applied_rate: *mut c_double,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_get_retransmission_time(media: *mut GstRTSPMedia) -> gst::GstClockTime;
|
|
pub fn gst_rtsp_media_get_status(media: *mut GstRTSPMedia) -> GstRTSPMediaStatus;
|
|
pub fn gst_rtsp_media_get_stream(media: *mut GstRTSPMedia, idx: c_uint) -> *mut GstRTSPStream;
|
|
pub fn gst_rtsp_media_get_suspend_mode(media: *mut GstRTSPMedia) -> GstRTSPSuspendMode;
|
|
pub fn gst_rtsp_media_get_time_provider(
|
|
media: *mut GstRTSPMedia,
|
|
address: *const c_char,
|
|
port: u16,
|
|
) -> *mut gst_net::GstNetTimeProvider;
|
|
pub fn gst_rtsp_media_get_transport_mode(media: *mut GstRTSPMedia) -> GstRTSPTransportMode;
|
|
pub fn gst_rtsp_media_handle_sdp(
|
|
media: *mut GstRTSPMedia,
|
|
sdp: *mut gst_sdp::GstSDPMessage,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_has_completed_sender(media: *mut GstRTSPMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_is_bind_mcast_address(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_is_eos_shutdown(media: *mut GstRTSPMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_is_receive_only(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_is_reusable(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_is_shared(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_is_stop_on_disconnect(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_is_time_provider(media: *mut GstRTSPMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_lock(media: *mut GstRTSPMedia);
|
|
pub fn gst_rtsp_media_n_streams(media: *mut GstRTSPMedia) -> c_uint;
|
|
pub fn gst_rtsp_media_prepare(media: *mut GstRTSPMedia, thread: *mut GstRTSPThread)
|
|
-> gboolean;
|
|
pub fn gst_rtsp_media_seek(
|
|
media: *mut GstRTSPMedia,
|
|
range: *mut gst_rtsp::GstRTSPTimeRange,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_seek_full(
|
|
media: *mut GstRTSPMedia,
|
|
range: *mut gst_rtsp::GstRTSPTimeRange,
|
|
flags: gst::GstSeekFlags,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_seek_trickmode(
|
|
media: *mut GstRTSPMedia,
|
|
range: *mut gst_rtsp::GstRTSPTimeRange,
|
|
flags: gst::GstSeekFlags,
|
|
rate: c_double,
|
|
trickmode_interval: gst::GstClockTime,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_media_seekable(media: *mut GstRTSPMedia) -> gst::GstClockTimeDiff;
|
|
pub fn gst_rtsp_media_set_address_pool(media: *mut GstRTSPMedia, pool: *mut GstRTSPAddressPool);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_set_bind_mcast_address(
|
|
media: *mut GstRTSPMedia,
|
|
bind_mcast_addr: gboolean,
|
|
);
|
|
pub fn gst_rtsp_media_set_buffer_size(media: *mut GstRTSPMedia, size: c_uint);
|
|
pub fn gst_rtsp_media_set_clock(media: *mut GstRTSPMedia, clock: *mut gst::GstClock);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_set_do_retransmission(
|
|
media: *mut GstRTSPMedia,
|
|
do_retransmission: gboolean,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_set_dscp_qos(media: *mut GstRTSPMedia, dscp_qos: c_int);
|
|
pub fn gst_rtsp_media_set_eos_shutdown(media: *mut GstRTSPMedia, eos_shutdown: gboolean);
|
|
pub fn gst_rtsp_media_set_latency(media: *mut GstRTSPMedia, latency: c_uint);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_set_max_mcast_ttl(media: *mut GstRTSPMedia, ttl: c_uint) -> gboolean;
|
|
pub fn gst_rtsp_media_set_multicast_iface(
|
|
media: *mut GstRTSPMedia,
|
|
multicast_iface: *const c_char,
|
|
);
|
|
pub fn gst_rtsp_media_set_permissions(
|
|
media: *mut GstRTSPMedia,
|
|
permissions: *mut GstRTSPPermissions,
|
|
);
|
|
pub fn gst_rtsp_media_set_pipeline_state(media: *mut GstRTSPMedia, state: gst::GstState);
|
|
pub fn gst_rtsp_media_set_profiles(
|
|
media: *mut GstRTSPMedia,
|
|
profiles: gst_rtsp::GstRTSPProfile,
|
|
);
|
|
pub fn gst_rtsp_media_set_protocols(
|
|
media: *mut GstRTSPMedia,
|
|
protocols: gst_rtsp::GstRTSPLowerTrans,
|
|
);
|
|
pub fn gst_rtsp_media_set_publish_clock_mode(
|
|
media: *mut GstRTSPMedia,
|
|
mode: GstRTSPPublishClockMode,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_set_rate_control(media: *mut GstRTSPMedia, enabled: gboolean);
|
|
pub fn gst_rtsp_media_set_retransmission_time(
|
|
media: *mut GstRTSPMedia,
|
|
time: gst::GstClockTime,
|
|
);
|
|
pub fn gst_rtsp_media_set_reusable(media: *mut GstRTSPMedia, reusable: gboolean);
|
|
pub fn gst_rtsp_media_set_shared(media: *mut GstRTSPMedia, shared: gboolean);
|
|
pub fn gst_rtsp_media_set_state(
|
|
media: *mut GstRTSPMedia,
|
|
state: gst::GstState,
|
|
transports: *mut glib::GPtrArray,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_set_stop_on_disconnect(
|
|
media: *mut GstRTSPMedia,
|
|
stop_on_disconnect: gboolean,
|
|
);
|
|
pub fn gst_rtsp_media_set_suspend_mode(media: *mut GstRTSPMedia, mode: GstRTSPSuspendMode);
|
|
pub fn gst_rtsp_media_set_transport_mode(media: *mut GstRTSPMedia, mode: GstRTSPTransportMode);
|
|
pub fn gst_rtsp_media_setup_sdp(
|
|
media: *mut GstRTSPMedia,
|
|
sdp: *mut gst_sdp::GstSDPMessage,
|
|
info: *mut GstSDPInfo,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_suspend(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_take_pipeline(media: *mut GstRTSPMedia, pipeline: *mut gst::GstPipeline);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_unlock(media: *mut GstRTSPMedia);
|
|
pub fn gst_rtsp_media_unprepare(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_unsuspend(media: *mut GstRTSPMedia) -> gboolean;
|
|
pub fn gst_rtsp_media_use_time_provider(media: *mut GstRTSPMedia, time_provider: gboolean);
|
|
|
|
//=========================================================================
|
|
// GstRTSPMediaFactory
|
|
//=========================================================================
|
|
pub fn gst_rtsp_media_factory_get_type() -> GType;
|
|
pub fn gst_rtsp_media_factory_new() -> *mut GstRTSPMediaFactory;
|
|
pub fn gst_rtsp_media_factory_add_role(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
role: *const c_char,
|
|
fieldname: *const c_char,
|
|
...
|
|
);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_media_factory_add_role_from_structure(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
structure: *mut gst::GstStructure,
|
|
);
|
|
pub fn gst_rtsp_media_factory_construct(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
url: *const gst_rtsp::GstRTSPUrl,
|
|
) -> *mut GstRTSPMedia;
|
|
pub fn gst_rtsp_media_factory_create_element(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
url: *const gst_rtsp::GstRTSPUrl,
|
|
) -> *mut gst::GstElement;
|
|
pub fn gst_rtsp_media_factory_get_address_pool(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> *mut GstRTSPAddressPool;
|
|
pub fn gst_rtsp_media_factory_get_buffer_size(factory: *mut GstRTSPMediaFactory) -> c_uint;
|
|
pub fn gst_rtsp_media_factory_get_clock(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> *mut gst::GstClock;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_get_do_retransmission(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_factory_get_dscp_qos(factory: *mut GstRTSPMediaFactory) -> c_int;
|
|
pub fn gst_rtsp_media_factory_get_latency(factory: *mut GstRTSPMediaFactory) -> c_uint;
|
|
pub fn gst_rtsp_media_factory_get_launch(factory: *mut GstRTSPMediaFactory) -> *mut c_char;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_get_max_mcast_ttl(factory: *mut GstRTSPMediaFactory) -> c_uint;
|
|
pub fn gst_rtsp_media_factory_get_media_gtype(factory: *mut GstRTSPMediaFactory) -> GType;
|
|
pub fn gst_rtsp_media_factory_get_multicast_iface(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> *mut c_char;
|
|
pub fn gst_rtsp_media_factory_get_permissions(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> *mut GstRTSPPermissions;
|
|
pub fn gst_rtsp_media_factory_get_profiles(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gst_rtsp::GstRTSPProfile;
|
|
pub fn gst_rtsp_media_factory_get_protocols(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gst_rtsp::GstRTSPLowerTrans;
|
|
pub fn gst_rtsp_media_factory_get_publish_clock_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> GstRTSPPublishClockMode;
|
|
pub fn gst_rtsp_media_factory_get_retransmission_time(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gst::GstClockTime;
|
|
pub fn gst_rtsp_media_factory_get_suspend_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> GstRTSPSuspendMode;
|
|
pub fn gst_rtsp_media_factory_get_transport_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> GstRTSPTransportMode;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_is_bind_mcast_address(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_factory_is_eos_shutdown(factory: *mut GstRTSPMediaFactory) -> gboolean;
|
|
pub fn gst_rtsp_media_factory_is_shared(factory: *mut GstRTSPMediaFactory) -> gboolean;
|
|
pub fn gst_rtsp_media_factory_is_stop_on_disonnect(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_factory_set_address_pool(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
pool: *mut GstRTSPAddressPool,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_set_bind_mcast_address(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
bind_mcast_addr: gboolean,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_buffer_size(factory: *mut GstRTSPMediaFactory, size: c_uint);
|
|
pub fn gst_rtsp_media_factory_set_clock(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
clock: *mut gst::GstClock,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_set_do_retransmission(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
do_retransmission: gboolean,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_media_factory_set_dscp_qos(factory: *mut GstRTSPMediaFactory, dscp_qos: c_int);
|
|
pub fn gst_rtsp_media_factory_set_eos_shutdown(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
eos_shutdown: gboolean,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_latency(factory: *mut GstRTSPMediaFactory, latency: c_uint);
|
|
pub fn gst_rtsp_media_factory_set_launch(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
launch: *const c_char,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_media_factory_set_max_mcast_ttl(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
ttl: c_uint,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_media_factory_set_media_gtype(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
media_gtype: GType,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_multicast_iface(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
multicast_iface: *const c_char,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_permissions(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
permissions: *mut GstRTSPPermissions,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_profiles(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
profiles: gst_rtsp::GstRTSPProfile,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_protocols(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
protocols: gst_rtsp::GstRTSPLowerTrans,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_publish_clock_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
mode: GstRTSPPublishClockMode,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_retransmission_time(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
time: gst::GstClockTime,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_shared(factory: *mut GstRTSPMediaFactory, shared: gboolean);
|
|
pub fn gst_rtsp_media_factory_set_stop_on_disconnect(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
stop_on_disconnect: gboolean,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_suspend_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
mode: GstRTSPSuspendMode,
|
|
);
|
|
pub fn gst_rtsp_media_factory_set_transport_mode(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
mode: GstRTSPTransportMode,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPMediaFactoryURI
|
|
//=========================================================================
|
|
pub fn gst_rtsp_media_factory_uri_get_type() -> GType;
|
|
pub fn gst_rtsp_media_factory_uri_new() -> *mut GstRTSPMediaFactoryURI;
|
|
pub fn gst_rtsp_media_factory_uri_get_uri(factory: *mut GstRTSPMediaFactoryURI) -> *mut c_char;
|
|
pub fn gst_rtsp_media_factory_uri_set_uri(
|
|
factory: *mut GstRTSPMediaFactoryURI,
|
|
uri: *const c_char,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPMountPoints
|
|
//=========================================================================
|
|
pub fn gst_rtsp_mount_points_get_type() -> GType;
|
|
pub fn gst_rtsp_mount_points_new() -> *mut GstRTSPMountPoints;
|
|
pub fn gst_rtsp_mount_points_add_factory(
|
|
mounts: *mut GstRTSPMountPoints,
|
|
path: *const c_char,
|
|
factory: *mut GstRTSPMediaFactory,
|
|
);
|
|
pub fn gst_rtsp_mount_points_make_path(
|
|
mounts: *mut GstRTSPMountPoints,
|
|
url: *const gst_rtsp::GstRTSPUrl,
|
|
) -> *mut c_char;
|
|
pub fn gst_rtsp_mount_points_match(
|
|
mounts: *mut GstRTSPMountPoints,
|
|
path: *const c_char,
|
|
matched: *mut c_int,
|
|
) -> *mut GstRTSPMediaFactory;
|
|
pub fn gst_rtsp_mount_points_remove_factory(
|
|
mounts: *mut GstRTSPMountPoints,
|
|
path: *const c_char,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPOnvifClient
|
|
//=========================================================================
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_client_get_type() -> GType;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_onvif_client_new() -> *mut GstRTSPClient;
|
|
|
|
//=========================================================================
|
|
// GstRTSPOnvifMedia
|
|
//=========================================================================
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_get_type() -> GType;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_collect_backchannel(media: *mut GstRTSPOnvifMedia) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_get_backchannel_bandwidth(media: *mut GstRTSPOnvifMedia) -> c_uint;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_set_backchannel_bandwidth(
|
|
media: *mut GstRTSPOnvifMedia,
|
|
bandwidth: c_uint,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPOnvifMediaFactory
|
|
//=========================================================================
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_get_type() -> GType;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_new() -> *mut GstRTSPMediaFactory;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_requires_backchannel(
|
|
factory: *mut GstRTSPMediaFactory,
|
|
ctx: *mut GstRTSPContext,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_get_backchannel_bandwidth(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
) -> c_uint;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_get_backchannel_launch(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
) -> *mut c_char;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_has_backchannel_support(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_onvif_media_factory_has_replay_support(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_set_backchannel_bandwidth(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
bandwidth: c_uint,
|
|
);
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_media_factory_set_backchannel_launch(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
launch: *const c_char,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_onvif_media_factory_set_replay_support(
|
|
factory: *mut GstRTSPOnvifMediaFactory,
|
|
has_replay_support: gboolean,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPOnvifServer
|
|
//=========================================================================
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_server_get_type() -> GType;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_onvif_server_new() -> *mut GstRTSPServer;
|
|
|
|
//=========================================================================
|
|
// GstRTSPServer
|
|
//=========================================================================
|
|
pub fn gst_rtsp_server_get_type() -> GType;
|
|
pub fn gst_rtsp_server_new() -> *mut GstRTSPServer;
|
|
pub fn gst_rtsp_server_io_func(
|
|
socket: *mut gio::GSocket,
|
|
condition: glib::GIOCondition,
|
|
server: *mut GstRTSPServer,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_server_attach(
|
|
server: *mut GstRTSPServer,
|
|
context: *mut glib::GMainContext,
|
|
) -> c_uint;
|
|
pub fn gst_rtsp_server_client_filter(
|
|
server: *mut GstRTSPServer,
|
|
func: GstRTSPServerClientFilterFunc,
|
|
user_data: gpointer,
|
|
) -> *mut glib::GList;
|
|
pub fn gst_rtsp_server_create_socket(
|
|
server: *mut GstRTSPServer,
|
|
cancellable: *mut gio::GCancellable,
|
|
error: *mut *mut glib::GError,
|
|
) -> *mut gio::GSocket;
|
|
pub fn gst_rtsp_server_create_source(
|
|
server: *mut GstRTSPServer,
|
|
cancellable: *mut gio::GCancellable,
|
|
error: *mut *mut glib::GError,
|
|
) -> *mut glib::GSource;
|
|
pub fn gst_rtsp_server_get_address(server: *mut GstRTSPServer) -> *mut c_char;
|
|
pub fn gst_rtsp_server_get_auth(server: *mut GstRTSPServer) -> *mut GstRTSPAuth;
|
|
pub fn gst_rtsp_server_get_backlog(server: *mut GstRTSPServer) -> c_int;
|
|
pub fn gst_rtsp_server_get_bound_port(server: *mut GstRTSPServer) -> c_int;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_server_get_content_length_limit(server: *mut GstRTSPServer) -> c_uint;
|
|
pub fn gst_rtsp_server_get_mount_points(server: *mut GstRTSPServer) -> *mut GstRTSPMountPoints;
|
|
pub fn gst_rtsp_server_get_service(server: *mut GstRTSPServer) -> *mut c_char;
|
|
pub fn gst_rtsp_server_get_session_pool(server: *mut GstRTSPServer) -> *mut GstRTSPSessionPool;
|
|
pub fn gst_rtsp_server_get_thread_pool(server: *mut GstRTSPServer) -> *mut GstRTSPThreadPool;
|
|
pub fn gst_rtsp_server_set_address(server: *mut GstRTSPServer, address: *const c_char);
|
|
pub fn gst_rtsp_server_set_auth(server: *mut GstRTSPServer, auth: *mut GstRTSPAuth);
|
|
pub fn gst_rtsp_server_set_backlog(server: *mut GstRTSPServer, backlog: c_int);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_server_set_content_length_limit(server: *mut GstRTSPServer, limit: c_uint);
|
|
pub fn gst_rtsp_server_set_mount_points(
|
|
server: *mut GstRTSPServer,
|
|
mounts: *mut GstRTSPMountPoints,
|
|
);
|
|
pub fn gst_rtsp_server_set_service(server: *mut GstRTSPServer, service: *const c_char);
|
|
pub fn gst_rtsp_server_set_session_pool(
|
|
server: *mut GstRTSPServer,
|
|
pool: *mut GstRTSPSessionPool,
|
|
);
|
|
pub fn gst_rtsp_server_set_thread_pool(
|
|
server: *mut GstRTSPServer,
|
|
pool: *mut GstRTSPThreadPool,
|
|
);
|
|
pub fn gst_rtsp_server_transfer_connection(
|
|
server: *mut GstRTSPServer,
|
|
socket: *mut gio::GSocket,
|
|
ip: *const c_char,
|
|
port: c_int,
|
|
initial_buffer: *const c_char,
|
|
) -> gboolean;
|
|
|
|
//=========================================================================
|
|
// GstRTSPSession
|
|
//=========================================================================
|
|
pub fn gst_rtsp_session_get_type() -> GType;
|
|
pub fn gst_rtsp_session_new(sessionid: *const c_char) -> *mut GstRTSPSession;
|
|
pub fn gst_rtsp_session_allow_expire(session: *mut GstRTSPSession);
|
|
pub fn gst_rtsp_session_filter(
|
|
sess: *mut GstRTSPSession,
|
|
func: GstRTSPSessionFilterFunc,
|
|
user_data: gpointer,
|
|
) -> *mut glib::GList;
|
|
pub fn gst_rtsp_session_get_header(session: *mut GstRTSPSession) -> *mut c_char;
|
|
pub fn gst_rtsp_session_get_media(
|
|
sess: *mut GstRTSPSession,
|
|
path: *const c_char,
|
|
matched: *mut c_int,
|
|
) -> *mut GstRTSPSessionMedia;
|
|
pub fn gst_rtsp_session_get_sessionid(session: *mut GstRTSPSession) -> *const c_char;
|
|
pub fn gst_rtsp_session_get_timeout(session: *mut GstRTSPSession) -> c_uint;
|
|
pub fn gst_rtsp_session_is_expired(
|
|
session: *mut GstRTSPSession,
|
|
now: *mut glib::GTimeVal,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_is_expired_usec(session: *mut GstRTSPSession, now: i64) -> gboolean;
|
|
pub fn gst_rtsp_session_manage_media(
|
|
sess: *mut GstRTSPSession,
|
|
path: *const c_char,
|
|
media: *mut GstRTSPMedia,
|
|
) -> *mut GstRTSPSessionMedia;
|
|
pub fn gst_rtsp_session_next_timeout(
|
|
session: *mut GstRTSPSession,
|
|
now: *mut glib::GTimeVal,
|
|
) -> c_int;
|
|
pub fn gst_rtsp_session_next_timeout_usec(session: *mut GstRTSPSession, now: i64) -> c_int;
|
|
pub fn gst_rtsp_session_prevent_expire(session: *mut GstRTSPSession);
|
|
pub fn gst_rtsp_session_release_media(
|
|
sess: *mut GstRTSPSession,
|
|
media: *mut GstRTSPSessionMedia,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_set_timeout(session: *mut GstRTSPSession, timeout: c_uint);
|
|
pub fn gst_rtsp_session_touch(session: *mut GstRTSPSession);
|
|
|
|
//=========================================================================
|
|
// GstRTSPSessionMedia
|
|
//=========================================================================
|
|
pub fn gst_rtsp_session_media_get_type() -> GType;
|
|
pub fn gst_rtsp_session_media_new(
|
|
path: *const c_char,
|
|
media: *mut GstRTSPMedia,
|
|
) -> *mut GstRTSPSessionMedia;
|
|
pub fn gst_rtsp_session_media_alloc_channels(
|
|
media: *mut GstRTSPSessionMedia,
|
|
range: *mut gst_rtsp::GstRTSPRange,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_media_get_base_time(
|
|
media: *mut GstRTSPSessionMedia,
|
|
) -> gst::GstClockTime;
|
|
pub fn gst_rtsp_session_media_get_media(media: *mut GstRTSPSessionMedia) -> *mut GstRTSPMedia;
|
|
pub fn gst_rtsp_session_media_get_rtpinfo(media: *mut GstRTSPSessionMedia) -> *mut c_char;
|
|
pub fn gst_rtsp_session_media_get_rtsp_state(
|
|
media: *mut GstRTSPSessionMedia,
|
|
) -> gst_rtsp::GstRTSPState;
|
|
pub fn gst_rtsp_session_media_get_transport(
|
|
media: *mut GstRTSPSessionMedia,
|
|
idx: c_uint,
|
|
) -> *mut GstRTSPStreamTransport;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_session_media_get_transports(
|
|
media: *mut GstRTSPSessionMedia,
|
|
) -> *mut glib::GPtrArray;
|
|
pub fn gst_rtsp_session_media_matches(
|
|
media: *mut GstRTSPSessionMedia,
|
|
path: *const c_char,
|
|
matched: *mut c_int,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_media_set_rtsp_state(
|
|
media: *mut GstRTSPSessionMedia,
|
|
state: gst_rtsp::GstRTSPState,
|
|
);
|
|
pub fn gst_rtsp_session_media_set_state(
|
|
media: *mut GstRTSPSessionMedia,
|
|
state: gst::GstState,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_media_set_transport(
|
|
media: *mut GstRTSPSessionMedia,
|
|
stream: *mut GstRTSPStream,
|
|
tr: *mut gst_rtsp::GstRTSPTransport,
|
|
) -> *mut GstRTSPStreamTransport;
|
|
|
|
//=========================================================================
|
|
// GstRTSPSessionPool
|
|
//=========================================================================
|
|
pub fn gst_rtsp_session_pool_get_type() -> GType;
|
|
pub fn gst_rtsp_session_pool_new() -> *mut GstRTSPSessionPool;
|
|
pub fn gst_rtsp_session_pool_cleanup(pool: *mut GstRTSPSessionPool) -> c_uint;
|
|
pub fn gst_rtsp_session_pool_create(pool: *mut GstRTSPSessionPool) -> *mut GstRTSPSession;
|
|
pub fn gst_rtsp_session_pool_create_watch(pool: *mut GstRTSPSessionPool) -> *mut glib::GSource;
|
|
pub fn gst_rtsp_session_pool_filter(
|
|
pool: *mut GstRTSPSessionPool,
|
|
func: GstRTSPSessionPoolFilterFunc,
|
|
user_data: gpointer,
|
|
) -> *mut glib::GList;
|
|
pub fn gst_rtsp_session_pool_find(
|
|
pool: *mut GstRTSPSessionPool,
|
|
sessionid: *const c_char,
|
|
) -> *mut GstRTSPSession;
|
|
pub fn gst_rtsp_session_pool_get_max_sessions(pool: *mut GstRTSPSessionPool) -> c_uint;
|
|
pub fn gst_rtsp_session_pool_get_n_sessions(pool: *mut GstRTSPSessionPool) -> c_uint;
|
|
pub fn gst_rtsp_session_pool_remove(
|
|
pool: *mut GstRTSPSessionPool,
|
|
sess: *mut GstRTSPSession,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_session_pool_set_max_sessions(pool: *mut GstRTSPSessionPool, max: c_uint);
|
|
|
|
//=========================================================================
|
|
// GstRTSPStream
|
|
//=========================================================================
|
|
pub fn gst_rtsp_stream_get_type() -> GType;
|
|
pub fn gst_rtsp_stream_new(
|
|
idx: c_uint,
|
|
payloader: *mut gst::GstElement,
|
|
pad: *mut gst::GstPad,
|
|
) -> *mut GstRTSPStream;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_add_multicast_client_address(
|
|
stream: *mut GstRTSPStream,
|
|
destination: *const c_char,
|
|
rtp_port: c_uint,
|
|
rtcp_port: c_uint,
|
|
family: gio::GSocketFamily,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_add_transport(
|
|
stream: *mut GstRTSPStream,
|
|
trans: *mut GstRTSPStreamTransport,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_allocate_udp_sockets(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
transport: *mut gst_rtsp::GstRTSPTransport,
|
|
use_client_settings: gboolean,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_complete_stream(
|
|
stream: *mut GstRTSPStream,
|
|
transport: *const gst_rtsp::GstRTSPTransport,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_get_address_pool(stream: *mut GstRTSPStream) -> *mut GstRTSPAddressPool;
|
|
pub fn gst_rtsp_stream_get_buffer_size(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_caps(stream: *mut GstRTSPStream) -> *mut gst::GstCaps;
|
|
pub fn gst_rtsp_stream_get_control(stream: *mut GstRTSPStream) -> *mut c_char;
|
|
pub fn gst_rtsp_stream_get_current_seqnum(stream: *mut GstRTSPStream) -> u16;
|
|
pub fn gst_rtsp_stream_get_dscp_qos(stream: *mut GstRTSPStream) -> c_int;
|
|
pub fn gst_rtsp_stream_get_index(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_joined_bin(stream: *mut GstRTSPStream) -> *mut gst::GstBin;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_get_max_mcast_ttl(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_mtu(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_multicast_address(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
) -> *mut GstRTSPAddress;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_get_multicast_client_addresses(
|
|
stream: *mut GstRTSPStream,
|
|
) -> *mut c_char;
|
|
pub fn gst_rtsp_stream_get_multicast_iface(stream: *mut GstRTSPStream) -> *mut c_char;
|
|
pub fn gst_rtsp_stream_get_profiles(stream: *mut GstRTSPStream) -> gst_rtsp::GstRTSPProfile;
|
|
pub fn gst_rtsp_stream_get_protocols(stream: *mut GstRTSPStream)
|
|
-> gst_rtsp::GstRTSPLowerTrans;
|
|
pub fn gst_rtsp_stream_get_pt(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_publish_clock_mode(
|
|
stream: *mut GstRTSPStream,
|
|
) -> GstRTSPPublishClockMode;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_stream_get_rate_control(stream: *mut GstRTSPStream) -> gboolean;
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_stream_get_rates(
|
|
stream: *mut GstRTSPStream,
|
|
rate: *mut c_double,
|
|
applied_rate: *mut c_double,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_get_retransmission_pt(stream: *mut GstRTSPStream) -> c_uint;
|
|
pub fn gst_rtsp_stream_get_retransmission_time(stream: *mut GstRTSPStream)
|
|
-> gst::GstClockTime;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_get_rtcp_multicast_socket(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
) -> *mut gio::GSocket;
|
|
pub fn gst_rtsp_stream_get_rtcp_socket(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
) -> *mut gio::GSocket;
|
|
pub fn gst_rtsp_stream_get_rtp_multicast_socket(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
) -> *mut gio::GSocket;
|
|
pub fn gst_rtsp_stream_get_rtp_socket(
|
|
stream: *mut GstRTSPStream,
|
|
family: gio::GSocketFamily,
|
|
) -> *mut gio::GSocket;
|
|
pub fn gst_rtsp_stream_get_rtpinfo(
|
|
stream: *mut GstRTSPStream,
|
|
rtptime: *mut c_uint,
|
|
seq: *mut c_uint,
|
|
clock_rate: *mut c_uint,
|
|
running_time: *mut gst::GstClockTime,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_get_rtpsession(stream: *mut GstRTSPStream) -> *mut gobject::GObject;
|
|
pub fn gst_rtsp_stream_get_server_port(
|
|
stream: *mut GstRTSPStream,
|
|
server_port: *mut gst_rtsp::GstRTSPRange,
|
|
family: gio::GSocketFamily,
|
|
);
|
|
pub fn gst_rtsp_stream_get_sinkpad(stream: *mut GstRTSPStream) -> *mut gst::GstPad;
|
|
pub fn gst_rtsp_stream_get_srcpad(stream: *mut GstRTSPStream) -> *mut gst::GstPad;
|
|
pub fn gst_rtsp_stream_get_srtp_encoder(stream: *mut GstRTSPStream) -> *mut gst::GstElement;
|
|
pub fn gst_rtsp_stream_get_ssrc(stream: *mut GstRTSPStream, ssrc: *mut c_uint);
|
|
pub fn gst_rtsp_stream_get_ulpfec_enabled(stream: *mut GstRTSPStream) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_get_ulpfec_percentage(stream: *mut GstRTSPStream) -> c_uint;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_get_ulpfec_pt(stream: *mut GstRTSPStream) -> c_uint;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_handle_keymgmt(
|
|
stream: *mut GstRTSPStream,
|
|
keymgmt: *const c_char,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_has_control(
|
|
stream: *mut GstRTSPStream,
|
|
control: *const c_char,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_is_bind_mcast_address(stream: *mut GstRTSPStream) -> gboolean;
|
|
pub fn gst_rtsp_stream_is_blocking(stream: *mut GstRTSPStream) -> gboolean;
|
|
pub fn gst_rtsp_stream_is_client_side(stream: *mut GstRTSPStream) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_is_complete(stream: *mut GstRTSPStream) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_is_receiver(stream: *mut GstRTSPStream) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_is_sender(stream: *mut GstRTSPStream) -> gboolean;
|
|
pub fn gst_rtsp_stream_is_transport_supported(
|
|
stream: *mut GstRTSPStream,
|
|
transport: *mut gst_rtsp::GstRTSPTransport,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_join_bin(
|
|
stream: *mut GstRTSPStream,
|
|
bin: *mut gst::GstBin,
|
|
rtpbin: *mut gst::GstElement,
|
|
state: gst::GstState,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_leave_bin(
|
|
stream: *mut GstRTSPStream,
|
|
bin: *mut gst::GstBin,
|
|
rtpbin: *mut gst::GstElement,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_query_position(
|
|
stream: *mut GstRTSPStream,
|
|
position: *mut i64,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_query_stop(stream: *mut GstRTSPStream, stop: *mut i64) -> gboolean;
|
|
pub fn gst_rtsp_stream_recv_rtcp(
|
|
stream: *mut GstRTSPStream,
|
|
buffer: *mut gst::GstBuffer,
|
|
) -> gst::GstFlowReturn;
|
|
pub fn gst_rtsp_stream_recv_rtp(
|
|
stream: *mut GstRTSPStream,
|
|
buffer: *mut gst::GstBuffer,
|
|
) -> gst::GstFlowReturn;
|
|
pub fn gst_rtsp_stream_remove_transport(
|
|
stream: *mut GstRTSPStream,
|
|
trans: *mut GstRTSPStreamTransport,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_request_aux_receiver(
|
|
stream: *mut GstRTSPStream,
|
|
sessid: c_uint,
|
|
) -> *mut gst::GstElement;
|
|
pub fn gst_rtsp_stream_request_aux_sender(
|
|
stream: *mut GstRTSPStream,
|
|
sessid: c_uint,
|
|
) -> *mut gst::GstElement;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_request_ulpfec_decoder(
|
|
stream: *mut GstRTSPStream,
|
|
rtpbin: *mut gst::GstElement,
|
|
sessid: c_uint,
|
|
) -> *mut gst::GstElement;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_request_ulpfec_encoder(
|
|
stream: *mut GstRTSPStream,
|
|
sessid: c_uint,
|
|
) -> *mut gst::GstElement;
|
|
pub fn gst_rtsp_stream_reserve_address(
|
|
stream: *mut GstRTSPStream,
|
|
address: *const c_char,
|
|
port: c_uint,
|
|
n_ports: c_uint,
|
|
ttl: c_uint,
|
|
) -> *mut GstRTSPAddress;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_stream_seekable(stream: *mut GstRTSPStream) -> gboolean;
|
|
pub fn gst_rtsp_stream_set_address_pool(
|
|
stream: *mut GstRTSPStream,
|
|
pool: *mut GstRTSPAddressPool,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_set_bind_mcast_address(
|
|
stream: *mut GstRTSPStream,
|
|
bind_mcast_addr: gboolean,
|
|
);
|
|
pub fn gst_rtsp_stream_set_blocked(stream: *mut GstRTSPStream, blocked: gboolean) -> gboolean;
|
|
pub fn gst_rtsp_stream_set_buffer_size(stream: *mut GstRTSPStream, size: c_uint);
|
|
pub fn gst_rtsp_stream_set_client_side(stream: *mut GstRTSPStream, client_side: gboolean);
|
|
pub fn gst_rtsp_stream_set_control(stream: *mut GstRTSPStream, control: *const c_char);
|
|
pub fn gst_rtsp_stream_set_dscp_qos(stream: *mut GstRTSPStream, dscp_qos: c_int);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_set_max_mcast_ttl(stream: *mut GstRTSPStream, ttl: c_uint) -> gboolean;
|
|
pub fn gst_rtsp_stream_set_mtu(stream: *mut GstRTSPStream, mtu: c_uint);
|
|
pub fn gst_rtsp_stream_set_multicast_iface(
|
|
stream: *mut GstRTSPStream,
|
|
multicast_iface: *const c_char,
|
|
);
|
|
pub fn gst_rtsp_stream_set_profiles(
|
|
stream: *mut GstRTSPStream,
|
|
profiles: gst_rtsp::GstRTSPProfile,
|
|
);
|
|
pub fn gst_rtsp_stream_set_protocols(
|
|
stream: *mut GstRTSPStream,
|
|
protocols: gst_rtsp::GstRTSPLowerTrans,
|
|
);
|
|
pub fn gst_rtsp_stream_set_pt_map(
|
|
stream: *mut GstRTSPStream,
|
|
pt: c_uint,
|
|
caps: *mut gst::GstCaps,
|
|
);
|
|
pub fn gst_rtsp_stream_set_publish_clock_mode(
|
|
stream: *mut GstRTSPStream,
|
|
mode: GstRTSPPublishClockMode,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_stream_set_rate_control(stream: *mut GstRTSPStream, enabled: gboolean);
|
|
pub fn gst_rtsp_stream_set_retransmission_pt(stream: *mut GstRTSPStream, rtx_pt: c_uint);
|
|
pub fn gst_rtsp_stream_set_retransmission_time(
|
|
stream: *mut GstRTSPStream,
|
|
time: gst::GstClockTime,
|
|
);
|
|
pub fn gst_rtsp_stream_set_seqnum_offset(stream: *mut GstRTSPStream, seqnum: u16);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_set_ulpfec_percentage(stream: *mut GstRTSPStream, percentage: c_uint);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_set_ulpfec_pt(stream: *mut GstRTSPStream, pt: c_uint);
|
|
pub fn gst_rtsp_stream_transport_filter(
|
|
stream: *mut GstRTSPStream,
|
|
func: GstRTSPStreamTransportFilterFunc,
|
|
user_data: gpointer,
|
|
) -> *mut glib::GList;
|
|
pub fn gst_rtsp_stream_unblock_linked(stream: *mut GstRTSPStream) -> gboolean;
|
|
pub fn gst_rtsp_stream_update_crypto(
|
|
stream: *mut GstRTSPStream,
|
|
ssrc: c_uint,
|
|
crypto: *mut gst::GstCaps,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_verify_mcast_ttl(stream: *mut GstRTSPStream, ttl: c_uint) -> gboolean;
|
|
|
|
//=========================================================================
|
|
// GstRTSPStreamTransport
|
|
//=========================================================================
|
|
pub fn gst_rtsp_stream_transport_get_type() -> GType;
|
|
pub fn gst_rtsp_stream_transport_new(
|
|
stream: *mut GstRTSPStream,
|
|
tr: *mut gst_rtsp::GstRTSPTransport,
|
|
) -> *mut GstRTSPStreamTransport;
|
|
pub fn gst_rtsp_stream_transport_get_rtpinfo(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
start_time: gst::GstClockTime,
|
|
) -> *mut c_char;
|
|
pub fn gst_rtsp_stream_transport_get_stream(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
) -> *mut GstRTSPStream;
|
|
pub fn gst_rtsp_stream_transport_get_transport(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
) -> *const gst_rtsp::GstRTSPTransport;
|
|
pub fn gst_rtsp_stream_transport_get_url(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
) -> *const gst_rtsp::GstRTSPUrl;
|
|
pub fn gst_rtsp_stream_transport_is_timed_out(trans: *mut GstRTSPStreamTransport) -> gboolean;
|
|
pub fn gst_rtsp_stream_transport_keep_alive(trans: *mut GstRTSPStreamTransport);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_transport_message_sent(trans: *mut GstRTSPStreamTransport);
|
|
pub fn gst_rtsp_stream_transport_recv_data(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
channel: c_uint,
|
|
buffer: *mut gst::GstBuffer,
|
|
) -> gst::GstFlowReturn;
|
|
pub fn gst_rtsp_stream_transport_send_rtcp(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
buffer: *mut gst::GstBuffer,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_transport_send_rtcp_list(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
buffer_list: *mut gst::GstBufferList,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_transport_send_rtp(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
buffer: *mut gst::GstBuffer,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_transport_send_rtp_list(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
buffer_list: *mut gst::GstBufferList,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_transport_set_active(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
active: gboolean,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_stream_transport_set_callbacks(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
send_rtp: GstRTSPSendFunc,
|
|
send_rtcp: GstRTSPSendFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
pub fn gst_rtsp_stream_transport_set_keepalive(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
keep_alive: GstRTSPKeepAliveFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
|
pub fn gst_rtsp_stream_transport_set_list_callbacks(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
send_rtp_list: GstRTSPSendListFunc,
|
|
send_rtcp_list: GstRTSPSendListFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
pub fn gst_rtsp_stream_transport_set_message_sent(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
message_sent: GstRTSPMessageSentFunc,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
|
pub fn gst_rtsp_stream_transport_set_message_sent_full(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
message_sent: GstRTSPMessageSentFuncFull,
|
|
user_data: gpointer,
|
|
notify: glib::GDestroyNotify,
|
|
);
|
|
pub fn gst_rtsp_stream_transport_set_timed_out(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
timedout: gboolean,
|
|
);
|
|
pub fn gst_rtsp_stream_transport_set_transport(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
tr: *mut gst_rtsp::GstRTSPTransport,
|
|
);
|
|
pub fn gst_rtsp_stream_transport_set_url(
|
|
trans: *mut GstRTSPStreamTransport,
|
|
url: *const gst_rtsp::GstRTSPUrl,
|
|
);
|
|
|
|
//=========================================================================
|
|
// GstRTSPThreadPool
|
|
//=========================================================================
|
|
pub fn gst_rtsp_thread_pool_get_type() -> GType;
|
|
pub fn gst_rtsp_thread_pool_new() -> *mut GstRTSPThreadPool;
|
|
pub fn gst_rtsp_thread_pool_cleanup();
|
|
pub fn gst_rtsp_thread_pool_get_max_threads(pool: *mut GstRTSPThreadPool) -> c_int;
|
|
pub fn gst_rtsp_thread_pool_get_thread(
|
|
pool: *mut GstRTSPThreadPool,
|
|
type_: GstRTSPThreadType,
|
|
ctx: *mut GstRTSPContext,
|
|
) -> *mut GstRTSPThread;
|
|
pub fn gst_rtsp_thread_pool_set_max_threads(pool: *mut GstRTSPThreadPool, max_threads: c_int);
|
|
|
|
//=========================================================================
|
|
// Other functions
|
|
//=========================================================================
|
|
pub fn gst_rtsp_context_get_type() -> GType;
|
|
pub fn gst_rtsp_params_get(
|
|
client: *mut GstRTSPClient,
|
|
ctx: *mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPResult;
|
|
pub fn gst_rtsp_params_set(
|
|
client: *mut GstRTSPClient,
|
|
ctx: *mut GstRTSPContext,
|
|
) -> gst_rtsp::GstRTSPResult;
|
|
pub fn gst_rtsp_sdp_from_media(
|
|
sdp: *mut gst_sdp::GstSDPMessage,
|
|
info: *mut GstSDPInfo,
|
|
media: *mut GstRTSPMedia,
|
|
) -> gboolean;
|
|
pub fn gst_rtsp_sdp_from_stream(
|
|
sdp: *mut gst_sdp::GstSDPMessage,
|
|
info: *mut GstSDPInfo,
|
|
stream: *mut GstRTSPStream,
|
|
) -> gboolean;
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
|
pub fn gst_rtsp_sdp_make_media(
|
|
sdp: *mut gst_sdp::GstSDPMessage,
|
|
info: *mut GstSDPInfo,
|
|
stream: *mut GstRTSPStream,
|
|
caps: *mut gst::GstCaps,
|
|
profile: gst_rtsp::GstRTSPProfile,
|
|
) -> gboolean;
|
|
|
|
}
|