gst-plugins-rs/generic/threadshare/src/udpsink/imp.rs
Sebastian Dröge 4ad101b53b Use once_cell crate directly again
The glib crate does not depend on it anymore and also does not re-export
it anymore.

Also switch some usages of OnceCell to OnceLock from std.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/1441>
2024-01-31 18:07:57 +02:00

1256 lines
44 KiB
Rust

// Copyright (C) 2019 Mathieu Duponchelle <mathieu@centricular.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the
// Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
// Boston, MA 02110-1335, USA.
//
// SPDX-License-Identifier: LGPL-2.1-or-later
use futures::future::BoxFuture;
use futures::prelude::*;
use gst::glib;
use gst::prelude::*;
use gst::subclass::prelude::*;
use gst::EventView;
use gst::{element_error, error_msg};
use once_cell::sync::Lazy;
use crate::runtime::executor::block_on_or_add_sub_task;
use crate::runtime::prelude::*;
use crate::runtime::{self, Async, Context, PadSink};
use crate::socket::{wrap_socket, GioSocketWrapper};
use std::collections::BTreeSet;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use std::u16;
use std::u8;
const DEFAULT_HOST: Option<&str> = Some("127.0.0.1");
const DEFAULT_PORT: i32 = 5004;
const DEFAULT_SYNC: bool = true;
const DEFAULT_BIND_ADDRESS: &str = "0.0.0.0";
const DEFAULT_BIND_PORT: i32 = 0;
const DEFAULT_BIND_ADDRESS_V6: &str = "::";
const DEFAULT_BIND_PORT_V6: i32 = 0;
const DEFAULT_SOCKET: Option<GioSocketWrapper> = None;
const DEFAULT_USED_SOCKET: Option<GioSocketWrapper> = None;
const DEFAULT_SOCKET_V6: Option<GioSocketWrapper> = None;
const DEFAULT_USED_SOCKET_V6: Option<GioSocketWrapper> = None;
const DEFAULT_AUTO_MULTICAST: bool = true;
const DEFAULT_LOOP: bool = true;
const DEFAULT_TTL: u32 = 64;
const DEFAULT_TTL_MC: u32 = 1;
const DEFAULT_QOS_DSCP: i32 = -1;
const DEFAULT_CLIENTS: &str = "";
const DEFAULT_CONTEXT: &str = "";
const DEFAULT_CONTEXT_WAIT: Duration = Duration::ZERO;
#[derive(Debug, Clone, Copy)]
struct SocketConf {
auto_multicast: bool,
multicast_loop: bool,
ttl: u32,
ttl_mc: u32,
}
impl Default for SocketConf {
fn default() -> Self {
SocketConf {
auto_multicast: DEFAULT_AUTO_MULTICAST,
multicast_loop: DEFAULT_LOOP,
ttl: DEFAULT_TTL,
ttl_mc: DEFAULT_TTL_MC,
}
}
}
#[derive(Debug, Clone)]
struct Settings {
sync: bool,
bind_address: String,
bind_port: i32,
bind_address_v6: String,
bind_port_v6: i32,
socket: Option<GioSocketWrapper>,
used_socket: Option<GioSocketWrapper>,
socket_v6: Option<GioSocketWrapper>,
used_socket_v6: Option<GioSocketWrapper>,
socket_conf: SocketConf,
qos_dscp: i32,
context: String,
context_wait: Duration,
}
impl Default for Settings {
fn default() -> Self {
Settings {
sync: DEFAULT_SYNC,
bind_address: DEFAULT_BIND_ADDRESS.into(),
bind_port: DEFAULT_BIND_PORT,
bind_address_v6: DEFAULT_BIND_ADDRESS_V6.into(),
bind_port_v6: DEFAULT_BIND_PORT_V6,
socket: DEFAULT_SOCKET,
used_socket: DEFAULT_USED_SOCKET,
socket_v6: DEFAULT_SOCKET_V6,
used_socket_v6: DEFAULT_USED_SOCKET_V6,
socket_conf: SocketConf::default(),
qos_dscp: DEFAULT_QOS_DSCP,
context: DEFAULT_CONTEXT.into(),
context_wait: DEFAULT_CONTEXT_WAIT,
}
}
}
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
gst::DebugCategory::new(
"ts-udpsink",
gst::DebugColorFlags::empty(),
Some("Thread-sharing UDP sink"),
)
});
#[derive(Clone, Debug, Default)]
struct UdpSinkPadHandler(Arc<futures::lock::Mutex<UdpSinkPadHandlerInner>>);
impl UdpSinkPadHandler {
fn prepare(
&self,
_imp: &UdpSink,
socket: Option<Async<UdpSocket>>,
socket_v6: Option<Async<UdpSocket>>,
settings: &Settings,
) -> Result<(), gst::ErrorMessage> {
futures::executor::block_on(async move {
let mut inner = self.0.lock().await;
inner.sync = settings.sync;
inner.socket_conf = settings.socket_conf;
inner.socket = socket;
inner.socket_v6 = socket_v6;
for addr in inner.clients.iter() {
inner.configure_client(addr)?;
}
Ok(())
})
}
fn unprepare(&self) {
futures::executor::block_on(async move {
let mut inner = self.0.lock().await;
for addr in inner.clients.iter() {
let _ = inner.unconfigure_client(addr);
}
inner.socket = None;
inner.socket_v6 = None;
})
}
fn start(&self) {
futures::executor::block_on(async move {
self.0.lock().await.is_flushing = false;
})
}
fn stop(&self) {
futures::executor::block_on(async move {
self.0.lock().await.is_flushing = true;
})
}
fn set_sync(&self, sync: bool) {
futures::executor::block_on(async move {
self.0.lock().await.sync = sync;
})
}
fn set_latency(&self, latency: Option<gst::ClockTime>) {
futures::executor::block_on(async move {
self.0.lock().await.latency = latency;
})
}
fn set_socket_conf(&self, socket_conf: SocketConf) {
futures::executor::block_on(async move {
self.0.lock().await.socket_conf = socket_conf;
})
}
fn clients(&self) -> BTreeSet<SocketAddr> {
futures::executor::block_on(async move { self.0.lock().await.clients.clone() })
}
fn add_client(&self, imp: &UdpSink, addr: SocketAddr) {
futures::executor::block_on(async move {
let mut inner = self.0.lock().await;
if inner.clients.contains(&addr) {
gst::warning!(CAT, imp: imp, "Not adding client {addr:?} again");
return;
}
match inner.configure_client(&addr) {
Ok(()) => {
gst::info!(CAT, imp: imp, "Added client {addr:?}");
inner.clients.insert(addr);
}
Err(err) => {
gst::error!(CAT, imp: imp, "Failed to add client {addr:?}: {err}");
imp.obj().post_error_message(err);
}
}
})
}
fn remove_client(&self, imp: &UdpSink, addr: SocketAddr) {
futures::executor::block_on(async move {
let mut inner = self.0.lock().await;
if inner.clients.take(&addr).is_none() {
gst::warning!(CAT, imp: imp, "Not removing unknown client {addr:?}");
return;
}
match inner.unconfigure_client(&addr) {
Ok(()) => {
gst::info!(CAT, imp: imp, "Removed client {addr:?}");
}
Err(err) => {
gst::error!(CAT, imp: imp, "Failed to remove client {addr:?}: {err}");
imp.obj().post_error_message(err);
}
}
})
}
fn replace_clients(&self, imp: &UdpSink, mut new_clients: BTreeSet<SocketAddr>) {
futures::executor::block_on(async move {
let mut inner = self.0.lock().await;
if new_clients.is_empty() {
gst::info!(CAT, imp: imp, "Clearing clients");
} else {
gst::info!(CAT, imp: imp, "Replacing clients");
}
let old_clients = std::mem::take(&mut inner.clients);
let mut res = Ok(());
for addr in old_clients.iter() {
if new_clients.take(addr).is_some() {
// client is already configured
inner.clients.insert(*addr);
} else if let Err(err) = inner.unconfigure_client(addr) {
gst::error!(CAT, imp: imp, "Failed to remove client {addr:?}: {err}");
res = Err(err);
} else {
gst::info!(CAT, imp: imp, "Removed client {addr:?}");
}
}
for addr in new_clients.into_iter() {
if let Err(err) = inner.configure_client(&addr) {
gst::error!(CAT, imp: imp, "Failed to add client {addr:?}: {err}");
res = Err(err);
} else {
gst::info!(CAT, imp: imp, "Added client {addr:?}");
inner.clients.insert(addr);
}
}
// FIXME: which error handling:
// - If at least one client could be configured, should we keep going? (current)
// - or, should we consider the preparation failed when the first client
// configuration fails? (previously)
if let Err(err) = res {
imp.obj().post_error_message(err);
}
})
}
}
impl PadSinkHandler for UdpSinkPadHandler {
type ElementImpl = UdpSink;
fn sink_chain(
self,
_pad: gst::Pad,
elem: super::UdpSink,
buffer: gst::Buffer,
) -> BoxFuture<'static, Result<gst::FlowSuccess, gst::FlowError>> {
async move { self.0.lock().await.handle_buffer(&elem, buffer).await }.boxed()
}
fn sink_chain_list(
self,
_pad: gst::Pad,
elem: super::UdpSink,
list: gst::BufferList,
) -> BoxFuture<'static, Result<gst::FlowSuccess, gst::FlowError>> {
async move {
let mut inner = self.0.lock().await;
for buffer in list.iter_owned() {
inner.handle_buffer(&elem, buffer).await?;
}
Ok(gst::FlowSuccess::Ok)
}
.boxed()
}
fn sink_event_serialized(
self,
_pad: gst::Pad,
elem: super::UdpSink,
event: gst::Event,
) -> BoxFuture<'static, bool> {
async move {
gst::debug!(CAT, obj: elem, "Handling {event:?}");
match event.view() {
EventView::Eos(_) => {
let _ = elem.post_message(gst::message::Eos::builder().src(&elem).build());
}
EventView::Segment(e) => {
self.0.lock().await.segment = Some(e.segment().clone());
}
EventView::FlushStop(_) => {
self.0.lock().await.is_flushing = false;
}
EventView::SinkMessage(e) => {
let _ = elem.post_message(e.message());
}
_ => (),
}
true
}
.boxed()
}
fn sink_event(self, _pad: &gst::Pad, imp: &UdpSink, event: gst::Event) -> bool {
gst::debug!(CAT, imp: imp, "Handling {event:?}");
if let EventView::FlushStart(..) = event.view() {
block_on_or_add_sub_task(async move {
self.0.lock().await.is_flushing = true;
});
}
true
}
}
#[derive(Debug)]
struct UdpSinkPadHandlerInner {
is_flushing: bool,
sync: bool,
latency: Option<gst::ClockTime>,
socket: Option<Async<UdpSocket>>,
socket_v6: Option<Async<UdpSocket>>,
clients: BTreeSet<SocketAddr>,
socket_conf: SocketConf,
segment: Option<gst::Segment>,
}
impl Default for UdpSinkPadHandlerInner {
fn default() -> Self {
Self {
is_flushing: true,
sync: DEFAULT_SYNC,
latency: None,
socket: None,
socket_v6: None,
clients: BTreeSet::from([SocketAddr::new(
DEFAULT_HOST.unwrap().parse().unwrap(),
DEFAULT_PORT as u16,
)]),
socket_conf: Default::default(),
segment: None,
}
}
}
/// Socket configuration.
impl UdpSinkPadHandlerInner {
fn configure_client(&self, client: &SocketAddr) -> Result<(), gst::ErrorMessage> {
if client.ip().is_multicast() {
match client.ip() {
IpAddr::V4(addr) => {
if let Some(socket) = self.socket.as_ref() {
if self.socket_conf.auto_multicast {
socket
.as_ref()
.join_multicast_v4(&addr, &Ipv4Addr::new(0, 0, 0, 0))
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
[
"Failed to join multicast group for {:?}: {}",
client,
err
]
)
})?;
}
if self.socket_conf.multicast_loop {
socket.as_ref().set_multicast_loop_v4(true).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set multicast loop for {:?}: {}", client, err]
)
})?;
}
socket
.as_ref()
.set_multicast_ttl_v4(self.socket_conf.ttl_mc)
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set multicast ttl for {:?}: {}", client, err]
)
})?;
}
}
IpAddr::V6(addr) => {
if let Some(socket) = self.socket_v6.as_ref() {
if self.socket_conf.auto_multicast {
socket.as_ref().join_multicast_v6(&addr, 0).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to join multicast group for {:?}: {}", client, err]
)
})?;
}
if self.socket_conf.multicast_loop {
socket.as_ref().set_multicast_loop_v6(true).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set multicast loop for {:?}: {}", client, err]
)
})?;
}
/* FIXME no API for set_multicast_ttl_v6 ? */
}
}
}
} else {
match client.ip() {
IpAddr::V4(_) => {
if let Some(socket) = self.socket.as_ref() {
socket
.as_ref()
.set_ttl(self.socket_conf.ttl)
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set unicast ttl for {:?}: {}", client, err]
)
})?;
}
}
IpAddr::V6(_) => {
if let Some(socket) = self.socket_v6.as_ref() {
socket
.as_ref()
.set_ttl(self.socket_conf.ttl)
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set unicast ttl for {:?}: {}", client, err]
)
})?;
}
}
}
}
Ok(())
}
fn unconfigure_client(&self, client: &SocketAddr) -> Result<(), gst::ErrorMessage> {
if client.ip().is_multicast() {
match client.ip() {
IpAddr::V4(addr) => {
if let Some(socket) = self.socket.as_ref() {
if self.socket_conf.auto_multicast {
socket
.as_ref()
.leave_multicast_v4(&addr, &Ipv4Addr::new(0, 0, 0, 0))
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
[
"Failed to leave multicast group for {:?}: {}",
client,
err
]
)
})?;
}
}
}
IpAddr::V6(addr) => {
if let Some(socket) = self.socket_v6.as_ref() {
if self.socket_conf.auto_multicast {
socket
.as_ref()
.leave_multicast_v6(&addr, 0)
.map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
[
"Failed to leave multicast group for {:?}: {}",
client,
err
]
)
})?;
}
}
}
}
}
Ok(())
}
}
/// Buffer handling.
impl UdpSinkPadHandlerInner {
async fn render(
&mut self,
elem: &super::UdpSink,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
let data = buffer.map_readable().map_err(|_| {
gst::element_error!(
elem,
gst::StreamError::Format,
["Failed to map buffer readable"]
);
gst::FlowError::Error
})?;
for client in self.clients.iter() {
let socket = match client.ip() {
IpAddr::V4(_) => &mut self.socket,
IpAddr::V6(_) => &mut self.socket_v6,
};
if let Some(socket) = socket.as_mut() {
gst::log!(CAT, obj: elem, "Sending to {client:?}");
socket.send_to(&data, *client).await.map_err(|err| {
gst::element_error!(
elem,
gst::StreamError::Failed,
("I/O error"),
["streaming stopped, I/O error {}", err]
);
gst::FlowError::Error
})?;
} else {
gst::element_error!(
elem,
gst::StreamError::Failed,
("I/O error"),
["No socket available for sending to {}", client]
);
return Err(gst::FlowError::Error);
}
}
gst::log!(CAT, obj: elem, "Sent buffer {buffer:?} to all clients");
Ok(gst::FlowSuccess::Ok)
}
/// Waits until specified time.
async fn sync(&self, elem: &super::UdpSink, running_time: gst::ClockTime) {
let now = elem.current_running_time();
if let Ok(Some(delay)) = running_time.opt_checked_sub(now) {
gst::trace!(CAT, obj: elem, "sync: waiting {delay}");
runtime::timer::delay_for(delay.into()).await;
}
}
async fn handle_buffer(
&mut self,
elem: &super::UdpSink,
buffer: gst::Buffer,
) -> Result<gst::FlowSuccess, gst::FlowError> {
if self.is_flushing {
gst::info!(CAT, obj: elem, "Discarding {buffer:?} (flushing)");
return Err(gst::FlowError::Flushing);
}
if self.sync {
let rtime = self.segment.as_ref().and_then(|segment| {
segment
.downcast_ref::<gst::format::Time>()
.and_then(|segment| segment.to_running_time(buffer.pts()).opt_add(self.latency))
});
if let Some(rtime) = rtime {
self.sync(elem, rtime).await;
if self.is_flushing {
gst::info!(CAT, obj: elem, "Discarding {buffer:?} (flushing)");
return Err(gst::FlowError::Flushing);
}
}
}
gst::debug!(CAT, obj: elem, "Handling {buffer:?}");
self.render(elem, buffer).await.map_err(|err| {
element_error!(
elem,
gst::StreamError::Failed,
["Failed to render item, stopping task: {}", err]
);
gst::FlowError::Error
})
}
}
#[derive(Debug)]
enum SocketFamily {
Ipv4,
Ipv6,
}
#[derive(Debug)]
pub struct UdpSink {
sink_pad: PadSink,
sink_pad_handler: UdpSinkPadHandler,
settings: Mutex<Settings>,
ts_ctx: Mutex<Option<Context>>,
}
impl UdpSink {
fn prepare_socket(
&self,
ts_ctx: &Context,
settings: &mut Settings,
family: SocketFamily,
) -> Result<Option<Async<UdpSocket>>, gst::ErrorMessage> {
let wrapped_socket = match family {
SocketFamily::Ipv4 => &settings.socket,
SocketFamily::Ipv6 => &settings.socket_v6,
};
if let Some(ref wrapped_socket) = wrapped_socket {
let socket: UdpSocket = wrapped_socket.get();
let socket = ts_ctx.enter(|| {
Async::<UdpSocket>::try_from(socket).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to setup Async socket: {}", err]
)
})
})?;
match family {
SocketFamily::Ipv4 => {
settings.used_socket = Some(wrapped_socket.clone());
}
SocketFamily::Ipv6 => {
settings.used_socket_v6 = Some(wrapped_socket.clone());
}
}
Ok(Some(socket))
} else {
let bind_addr = match family {
SocketFamily::Ipv4 => &settings.bind_address,
SocketFamily::Ipv6 => &settings.bind_address_v6,
};
let bind_addr: IpAddr = bind_addr.parse().map_err(|err| {
error_msg!(
gst::ResourceError::Settings,
["Invalid address '{}' set: {}", bind_addr, err]
)
})?;
let bind_port = match family {
SocketFamily::Ipv4 => settings.bind_port,
SocketFamily::Ipv6 => settings.bind_port_v6,
};
let saddr = SocketAddr::new(bind_addr, bind_port as u16);
gst::debug!(CAT, imp: self, "Binding to {:?}", saddr);
let socket = match family {
SocketFamily::Ipv4 => socket2::Socket::new(
socket2::Domain::IPV4,
socket2::Type::DGRAM,
Some(socket2::Protocol::UDP),
),
SocketFamily::Ipv6 => socket2::Socket::new(
socket2::Domain::IPV6,
socket2::Type::DGRAM,
Some(socket2::Protocol::UDP),
),
};
let socket = match socket {
Ok(socket) => socket,
Err(err) => {
gst::warning!(
CAT,
imp: self,
"Failed to create {} socket: {}",
match family {
SocketFamily::Ipv4 => "IPv4",
SocketFamily::Ipv6 => "IPv6",
},
err
);
return Ok(None);
}
};
socket.bind(&saddr.into()).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to bind socket: {}", err]
)
})?;
let socket = ts_ctx.enter(|| {
Async::<UdpSocket>::try_from(socket).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to setup Async socket: {}", err]
)
})
})?;
let wrapper = wrap_socket(&socket)?;
if settings.qos_dscp != -1 {
wrapper.set_tos(settings.qos_dscp).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to set QoS DSCP: {}", err]
)
})?;
}
match family {
SocketFamily::Ipv4 => {
settings.used_socket = Some(wrapper);
}
SocketFamily::Ipv6 => {
settings.used_socket_v6 = Some(wrapper);
}
}
Ok(Some(socket))
}
}
fn prepare(&self) -> Result<(), gst::ErrorMessage> {
gst::debug!(CAT, imp: self, "Preparing");
let mut settings = self.settings.lock().unwrap();
let ts_ctx = Context::acquire(&settings.context, settings.context_wait).map_err(|err| {
error_msg!(
gst::ResourceError::OpenWrite,
["Failed to acquire Context: {}", err]
)
})?;
let socket = self.prepare_socket(&ts_ctx, &mut settings, SocketFamily::Ipv4)?;
let socket_v6 = self.prepare_socket(&ts_ctx, &mut settings, SocketFamily::Ipv6)?;
self.sink_pad_handler
.prepare(self, socket, socket_v6, &settings)?;
*self.ts_ctx.lock().unwrap() = Some(ts_ctx);
gst::debug!(CAT, imp: self, "Started preparation");
Ok(())
}
fn unprepare(&self) {
gst::debug!(CAT, imp: self, "Unpreparing");
self.sink_pad_handler.unprepare();
*self.ts_ctx.lock().unwrap() = None;
gst::debug!(CAT, imp: self, "Unprepared");
}
fn stop(&self) -> Result<(), gst::ErrorMessage> {
gst::debug!(CAT, imp: self, "Stopping");
self.sink_pad_handler.stop();
gst::debug!(CAT, imp: self, "Stopped");
Ok(())
}
fn start(&self) -> Result<(), gst::ErrorMessage> {
gst::debug!(CAT, imp: self, "Starting");
self.sink_pad_handler.start();
gst::debug!(CAT, imp: self, "Started");
Ok(())
}
fn try_into_socket_addr(&self, host: &str, port: i32) -> Result<SocketAddr, ()> {
let addr: IpAddr = match host.parse() {
Err(err) => {
gst::error!(CAT, imp: self, "Failed to parse host {}: {}", host, err);
return Err(());
}
Ok(addr) => addr,
};
let port: u16 = match port.try_into() {
Err(err) => {
gst::error!(CAT, imp: self, "Invalid port {}: {}", port, err);
return Err(());
}
Ok(port) => port,
};
Ok(SocketAddr::new(addr, port))
}
}
#[glib::object_subclass]
impl ObjectSubclass for UdpSink {
const NAME: &'static str = "GstTsUdpSink";
type Type = super::UdpSink;
type ParentType = gst::Element;
fn with_class(klass: &Self::Class) -> Self {
let sink_pad_handler = UdpSinkPadHandler::default();
Self {
sink_pad: PadSink::new(
gst::Pad::from_template(&klass.pad_template("sink").unwrap()),
sink_pad_handler.clone(),
),
sink_pad_handler,
settings: Default::default(),
ts_ctx: Default::default(),
}
}
}
impl ObjectImpl for UdpSink {
fn properties() -> &'static [glib::ParamSpec] {
static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
vec![
glib::ParamSpecString::builder("context")
.nick("Context")
.blurb("Context name to share threads with")
.default_value(Some(DEFAULT_CONTEXT))
.build(),
glib::ParamSpecUInt::builder("context-wait")
.nick("Context Wait")
.blurb("Throttle poll loop to run at most once every this many ms")
.maximum(1000)
.default_value(DEFAULT_CONTEXT_WAIT.as_millis() as u32)
.build(),
glib::ParamSpecBoolean::builder("sync")
.nick("Sync")
.blurb("Sync on the clock")
.default_value(DEFAULT_SYNC)
.build(),
glib::ParamSpecString::builder("bind-address")
.nick("Bind Address")
.blurb("Address to bind the socket to")
.default_value(Some(DEFAULT_BIND_ADDRESS))
.build(),
glib::ParamSpecInt::builder("bind-port")
.nick("Bind Port")
.blurb("Port to bind the socket to")
.minimum(0)
.maximum(u16::MAX as i32)
.default_value(DEFAULT_BIND_PORT)
.build(),
glib::ParamSpecString::builder("bind-address-v6")
.nick("Bind Address V6")
.blurb("Address to bind the V6 socket to")
.default_value(Some(DEFAULT_BIND_ADDRESS_V6))
.build(),
glib::ParamSpecInt::builder("bind-port-v6")
.nick("Bind Port")
.blurb("Port to bind the V6 socket to")
.minimum(0)
.maximum(u16::MAX as i32)
.default_value(DEFAULT_BIND_PORT_V6)
.build(),
glib::ParamSpecObject::builder::<gio::Socket>("socket")
.nick("Socket")
.blurb("Socket to use for UDP transmission. (None == allocate)")
.build(),
glib::ParamSpecObject::builder::<gio::Socket>("used-socket")
.nick("Used Socket")
.blurb("Socket currently in use for UDP transmission. (None = no socket)")
.read_only()
.build(),
glib::ParamSpecObject::builder::<gio::Socket>("socket-v6")
.nick("Socket V6")
.blurb("IPV6 Socket to use for UDP transmission. (None == allocate)")
.build(),
glib::ParamSpecObject::builder::<gio::Socket>("used-socket-v6")
.nick("Used Socket V6")
.blurb("V6 Socket currently in use for UDP transmission. (None = no socket)")
.read_only()
.build(),
glib::ParamSpecBoolean::builder("auto-multicast")
.nick("Auto multicast")
.blurb("Automatically join/leave the multicast groups, FALSE means user has to do it himself")
.default_value(DEFAULT_AUTO_MULTICAST)
.build(),
glib::ParamSpecBoolean::builder("loop")
.nick("Loop")
.blurb("Set the multicast loop parameter.")
.default_value(DEFAULT_LOOP)
.build(),
glib::ParamSpecUInt::builder("ttl")
.nick("Time To Live")
.blurb("Used for setting the unicast TTL parameter")
.maximum(u8::MAX as u32)
.default_value(DEFAULT_TTL)
.build(),
glib::ParamSpecUInt::builder("ttl-mc")
.nick("Time To Live Multicast")
.blurb("Used for setting the multicast TTL parameter")
.maximum(u8::MAX as u32)
.default_value(DEFAULT_TTL_MC)
.build(),
glib::ParamSpecInt::builder("qos-dscp")
.nick("QoS DSCP")
.blurb("Quality of Service, differentiated services code point (-1 default)")
.minimum(-1)
.maximum(63)
.default_value(DEFAULT_QOS_DSCP)
.build(),
glib::ParamSpecString::builder("clients")
.nick("Clients")
.blurb("A comma separated list of host:port pairs with destinations")
.default_value(Some(DEFAULT_CLIENTS))
.build(),
]
});
PROPERTIES.as_ref()
}
fn signals() -> &'static [glib::subclass::Signal] {
static SIGNALS: Lazy<Vec<glib::subclass::Signal>> = Lazy::new(|| {
vec![
glib::subclass::Signal::builder("add")
.param_types([String::static_type(), i32::static_type()])
.action()
.class_handler(|_, args| {
let elem = args[0].get::<super::UdpSink>().expect("signal arg");
let host = args[1].get::<String>().expect("signal arg");
let port = args[2].get::<i32>().expect("signal arg");
let imp = elem.imp();
if let Ok(addr) = imp.try_into_socket_addr(&host, port) {
imp.sink_pad_handler.add_client(imp, addr);
}
None
})
.build(),
glib::subclass::Signal::builder("remove")
.param_types([String::static_type(), i32::static_type()])
.action()
.class_handler(|_, args| {
let elem = args[0].get::<super::UdpSink>().expect("signal arg");
let host = args[1].get::<String>().expect("signal arg");
let port = args[2].get::<i32>().expect("signal arg");
let imp = elem.imp();
if let Ok(addr) = imp.try_into_socket_addr(&host, port) {
imp.sink_pad_handler.remove_client(imp, addr);
}
None
})
.build(),
glib::subclass::Signal::builder("clear")
.action()
.class_handler(|_, args| {
let elem = args[0].get::<super::UdpSink>().expect("signal arg");
let imp = elem.imp();
imp.sink_pad_handler.replace_clients(imp, BTreeSet::new());
None
})
.build(),
]
});
SIGNALS.as_ref()
}
fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
let mut settings = self.settings.lock().unwrap();
match pspec.name() {
"sync" => {
let sync = value.get().expect("type checked upstream");
settings.sync = sync;
self.sink_pad_handler.set_sync(sync);
}
"bind-address" => {
settings.bind_address = value
.get::<Option<String>>()
.expect("type checked upstream")
.unwrap_or_else(|| "".into());
}
"bind-port" => {
settings.bind_port = value.get().expect("type checked upstream");
}
"bind-address-v6" => {
settings.bind_address_v6 = value
.get::<Option<String>>()
.expect("type checked upstream")
.unwrap_or_else(|| "".into());
}
"bind-port-v6" => {
settings.bind_port_v6 = value.get().expect("type checked upstream");
}
"socket" => {
settings.socket = value
.get::<Option<gio::Socket>>()
.expect("type checked upstream")
.map(|socket| GioSocketWrapper::new(&socket));
}
"used-socket" => {
unreachable!();
}
"socket-v6" => {
settings.socket_v6 = value
.get::<Option<gio::Socket>>()
.expect("type checked upstream")
.map(|socket| GioSocketWrapper::new(&socket));
}
"used-socket-v6" => {
unreachable!();
}
"auto-multicast" => {
settings.socket_conf.auto_multicast = value.get().expect("type checked upstream");
self.sink_pad_handler.set_socket_conf(settings.socket_conf);
}
"loop" => {
settings.socket_conf.multicast_loop = value.get().expect("type checked upstream");
self.sink_pad_handler.set_socket_conf(settings.socket_conf);
}
"ttl" => {
settings.socket_conf.ttl = value.get().expect("type checked upstream");
self.sink_pad_handler.set_socket_conf(settings.socket_conf);
}
"ttl-mc" => {
settings.socket_conf.ttl_mc = value.get().expect("type checked upstream");
self.sink_pad_handler.set_socket_conf(settings.socket_conf);
}
"qos-dscp" => {
settings.qos_dscp = value.get().expect("type checked upstream");
}
"clients" => {
let clients = value
.get::<Option<String>>()
.expect("type checked upstream")
.unwrap_or_else(|| "".into());
let clients = clients.split(',').filter_map(|client| {
let mut split = client.splitn(2, ':');
if let Some((addr, port)) = split.next().zip(split.next()) {
match port.parse::<i32>() {
Ok(port) => match self.try_into_socket_addr(addr, port) {
Ok(socket_addr) => Some(socket_addr),
Err(()) => {
gst::error!(
CAT,
imp: self,
"Invalid socket address {addr}:{port}"
);
None
}
},
Err(err) => {
gst::error!(CAT, imp: self, "Invalid port {err}");
None
}
}
} else {
gst::error!(CAT, imp: self, "Invalid client {client}");
None
}
});
let clients = BTreeSet::from_iter(clients);
self.sink_pad_handler.replace_clients(self, clients);
}
"context" => {
settings.context = value
.get::<Option<String>>()
.expect("type checked upstream")
.unwrap_or_else(|| DEFAULT_CONTEXT.into());
}
"context-wait" => {
settings.context_wait = Duration::from_millis(
value.get::<u32>().expect("type checked upstream").into(),
);
}
_ => unimplemented!(),
}
}
fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
let settings = self.settings.lock().unwrap();
match pspec.name() {
"sync" => settings.sync.to_value(),
"bind-address" => settings.bind_address.to_value(),
"bind-port" => settings.bind_port.to_value(),
"bind-address-v6" => settings.bind_address_v6.to_value(),
"bind-port-v6" => settings.bind_port_v6.to_value(),
"socket" => settings
.socket
.as_ref()
.map(GioSocketWrapper::as_socket)
.to_value(),
"used-socket" => settings
.used_socket
.as_ref()
.map(GioSocketWrapper::as_socket)
.to_value(),
"socket-v6" => settings
.socket_v6
.as_ref()
.map(GioSocketWrapper::as_socket)
.to_value(),
"used-socket-v6" => settings
.used_socket_v6
.as_ref()
.map(GioSocketWrapper::as_socket)
.to_value(),
"auto-multicast" => settings.socket_conf.auto_multicast.to_value(),
"loop" => settings.socket_conf.multicast_loop.to_value(),
"ttl" => settings.socket_conf.ttl.to_value(),
"ttl-mc" => settings.socket_conf.ttl_mc.to_value(),
"qos-dscp" => settings.qos_dscp.to_value(),
"clients" => {
let clients = self.sink_pad_handler.clients();
let clients: Vec<String> = clients.iter().map(ToString::to_string).collect();
clients.join(",").to_value()
}
"context" => settings.context.to_value(),
"context-wait" => (settings.context_wait.as_millis() as u32).to_value(),
_ => unimplemented!(),
}
}
fn constructed(&self) {
self.parent_constructed();
let obj = self.obj();
obj.add_pad(self.sink_pad.gst_pad()).unwrap();
obj.set_element_flags(gst::ElementFlags::SINK);
}
}
impl GstObjectImpl for UdpSink {}
impl ElementImpl for UdpSink {
fn metadata() -> Option<&'static gst::subclass::ElementMetadata> {
static ELEMENT_METADATA: Lazy<gst::subclass::ElementMetadata> = Lazy::new(|| {
gst::subclass::ElementMetadata::new(
"Thread-sharing UDP sink",
"Sink/Network",
"Thread-sharing UDP sink",
"Mathieu <mathieu@centricular.com>",
)
});
Some(&*ELEMENT_METADATA)
}
fn pad_templates() -> &'static [gst::PadTemplate] {
static PAD_TEMPLATES: Lazy<Vec<gst::PadTemplate>> = Lazy::new(|| {
let caps = gst::Caps::new_any();
let sink_pad_template = gst::PadTemplate::new(
"sink",
gst::PadDirection::Sink,
gst::PadPresence::Always,
&caps,
)
.unwrap();
vec![sink_pad_template]
});
PAD_TEMPLATES.as_ref()
}
fn change_state(
&self,
transition: gst::StateChange,
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
match transition {
gst::StateChange::NullToReady => {
self.prepare().map_err(|err| {
self.post_error_message(err);
gst::StateChangeError
})?;
}
gst::StateChange::ReadyToPaused => {
self.start().map_err(|_| gst::StateChangeError)?;
}
gst::StateChange::PausedToReady => {
self.stop().map_err(|_| gst::StateChangeError)?;
}
gst::StateChange::ReadyToNull => {
self.unprepare();
}
_ => (),
}
self.parent_change_state(transition)
}
fn send_event(&self, event: gst::Event) -> bool {
match event.view() {
EventView::Latency(ev) => {
let latency = Some(ev.latency());
self.sink_pad_handler.set_latency(latency);
self.sink_pad.gst_pad().push_event(event)
}
EventView::Step(..) => false,
_ => self.sink_pad.gst_pad().push_event(event),
}
}
}