mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 04:01:08 +00:00
Code Issues 1 Projects Releases Wiki Activity

webrtc: Remove non rtcp-mux code

Browse source 
RTCP mux is now always required by the WebRTC spec

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/1765>
This commit is contained in:
Olivier Crête 2020-11-02 19:49:55 -05:00 committed by GStreamer Merge Bot
parent 64f96facca
commit 5d5417f271
14 changed files with 46 additions and 379 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

102
ext/webrtc/gstwebrtcbin.c
View file

@ -80,10 +80,10 @@
* configuration. Some cases are outlined below for a simple single * configuration. Some cases are outlined below for a simple single
* audio/video/data session: * audio/video/data session:
* *
* - max-bundle (requires rtcp-muxing) uses a single transport for all * - max-bundle uses a single transport for all
* media/data transported. Renegotiation involves adding/removing the * media/data transported. Renegotiation involves adding/removing the
* necessary streams to the existing transports. * necessary streams to the existing transports.
* - max-compat without rtcp-mux involves two TransportStream per media stream * - max-compat involves two TransportStream per media stream
* to transport the rtp and the rtcp packets and a single TransportStream for * to transport the rtp and the rtcp packets and a single TransportStream for
* all data channels. Each stream change involves modifying the associated * all data channels. Each stream change involves modifying the associated
* TransportStream/s as necessary. * TransportStream/s as necessary.
@ -859,11 +859,8 @@ _collate_ice_connection_states (GstWebRTCBin * webrtc)
for (i = 0; i < webrtc->priv->transceivers->len; i++) { for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *rtp_trans = GstWebRTCRTPTransceiver *rtp_trans =
g_ptr_array_index (webrtc->priv->transceivers, i); g_ptr_array_index (webrtc->priv->transceivers, i);
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans); GstWebRTCICETransport *transport;
TransportStream *stream = trans->stream;
GstWebRTCICETransport *transport, *rtcp_transport;
GstWebRTCICEConnectionState ice_state; GstWebRTCICEConnectionState ice_state;
gboolean rtcp_mux = FALSE;
if (rtp_trans->stopped) { if (rtp_trans->stopped) {
GST_TRACE_OBJECT (webrtc, "transceiver %p stopped", rtp_trans); GST_TRACE_OBJECT (webrtc, "transceiver %p stopped", rtp_trans);
@ -875,8 +872,6 @@ _collate_ice_connection_states (GstWebRTCBin * webrtc)
continue; continue;
} }
g_object_get (stream, "rtcp-mux", &rtcp_mux, NULL);
transport = webrtc_transceiver_get_dtls_transport (rtp_trans)->transport; transport = webrtc_transceiver_get_dtls_transport (rtp_trans)->transport;
/* get transport state */ /* get transport state */
@ -892,24 +887,6 @@ _collate_ice_connection_states (GstWebRTCBin * webrtc)
if (ice_state != STATE (CONNECTED) && ice_state != STATE (COMPLETED) if (ice_state != STATE (CONNECTED) && ice_state != STATE (COMPLETED)
&& ice_state != STATE (CLOSED)) && ice_state != STATE (CLOSED))
all_connected_completed_or_closed = FALSE; all_connected_completed_or_closed = FALSE;
rtcp_transport =
webrtc_transceiver_get_rtcp_dtls_transport (rtp_trans)->transport;
if (!rtcp_mux && rtcp_transport && transport != rtcp_transport) {
g_object_get (rtcp_transport, "state", &ice_state, NULL);
GST_TRACE_OBJECT (webrtc, "transceiver %p RTCP state 0x%x", rtp_trans,
ice_state);
any_state |= (1 << ice_state);
if (ice_state != STATE (NEW) && ice_state != STATE (CLOSED))
all_new_or_closed = FALSE;
if (ice_state != STATE (COMPLETED) && ice_state != STATE (CLOSED))
all_completed_or_closed = FALSE;
if (ice_state != STATE (CONNECTED) && ice_state != STATE (COMPLETED)
&& ice_state != STATE (CLOSED))
all_connected_completed_or_closed = FALSE;
}
} }
GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x", any_state); GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x", any_state);
@ -970,7 +947,7 @@ _collate_ice_gathering_states (GstWebRTCBin * webrtc)
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans); WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream; TransportStream *stream = trans->stream;
GstWebRTCDTLSTransport *dtls_transport; GstWebRTCDTLSTransport *dtls_transport;
GstWebRTCICETransport *transport, *rtcp_transport; GstWebRTCICETransport *transport;
GstWebRTCICEGatheringState ice_state; GstWebRTCICEGatheringState ice_state;
gboolean rtcp_mux = FALSE; gboolean rtcp_mux = FALSE;
@ -1003,22 +980,6 @@ _collate_ice_gathering_states (GstWebRTCBin * webrtc)
any_state |= (1 << ice_state); any_state |= (1 << ice_state);
if (ice_state != STATE (COMPLETE)) if (ice_state != STATE (COMPLETE))
all_completed = FALSE; all_completed = FALSE;
dtls_transport = webrtc_transceiver_get_rtcp_dtls_transport (rtp_trans);
if (dtls_transport == NULL) {
GST_WARNING ("Transceiver %p has no DTLS RTCP transport", rtp_trans);
continue;
}
rtcp_transport = dtls_transport->transport;
if (!rtcp_mux && rtcp_transport && rtcp_transport != transport) {
g_object_get (rtcp_transport, "gathering-state", &ice_state, NULL);
GST_TRACE_OBJECT (webrtc, "transceiver %p RTCP gathering state: 0x%x",
rtp_trans, ice_state);
any_state |= (1 << ice_state);
if (ice_state != STATE (COMPLETE))
all_completed = FALSE;
}
} }
GST_TRACE_OBJECT (webrtc, "ICE gathering state: 0x%x", any_state); GST_TRACE_OBJECT (webrtc, "ICE gathering state: 0x%x", any_state);
@ -1064,7 +1025,7 @@ _collate_peer_connection_states (GstWebRTCBin * webrtc)
g_ptr_array_index (webrtc->priv->transceivers, i); g_ptr_array_index (webrtc->priv->transceivers, i);
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans); WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream; TransportStream *stream = trans->stream;
GstWebRTCDTLSTransport *transport, *rtcp_transport; GstWebRTCDTLSTransport *transport;
GstWebRTCICEConnectionState ice_state; GstWebRTCICEConnectionState ice_state;
GstWebRTCDTLSTransportState dtls_state; GstWebRTCDTLSTransportState dtls_state;
gboolean rtcp_mux = FALSE; gboolean rtcp_mux = FALSE;
@ -1107,38 +1068,6 @@ _collate_peer_connection_states (GstWebRTCBin * webrtc)
if (ice_state != ICE_STATE (CONNECTED) && ice_state != ICE_STATE (COMPLETED) if (ice_state != ICE_STATE (CONNECTED) && ice_state != ICE_STATE (COMPLETED)
&& ice_state != ICE_STATE (CLOSED)) && ice_state != ICE_STATE (CLOSED))
ice_all_connected_completed_or_closed = FALSE; ice_all_connected_completed_or_closed = FALSE;
rtcp_transport = webrtc_transceiver_get_rtcp_dtls_transport (rtp_trans);
if (!rtcp_mux && rtcp_transport && rtcp_transport != transport) {
g_object_get (rtcp_transport, "state", &dtls_state, NULL);
GST_TRACE_OBJECT (webrtc, "transceiver %p RTCP DTLS state: 0x%x",
rtp_trans, dtls_state);
any_dtls_state |= (1 << dtls_state);
if (dtls_state != DTLS_STATE (NEW) && dtls_state != DTLS_STATE (CLOSED))
dtls_all_new_or_closed = FALSE;
if (dtls_state != DTLS_STATE (NEW)
&& dtls_state != DTLS_STATE (CONNECTING))
dtls_all_new_connecting_or_checking = FALSE;
if (dtls_state != DTLS_STATE (CONNECTED)
&& dtls_state != DTLS_STATE (CLOSED))
dtls_all_connected_completed_or_closed = FALSE;
g_object_get (rtcp_transport->transport, "state", &ice_state, NULL);
GST_TRACE_OBJECT (webrtc, "transceiver %p RTCP ICE state: 0x%x",
rtp_trans, ice_state);
any_ice_state |= (1 << ice_state);
if (ice_state != ICE_STATE (NEW) && ice_state != ICE_STATE (CLOSED))
ice_all_new_or_closed = FALSE;
if (ice_state != ICE_STATE (NEW) && ice_state != ICE_STATE (CHECKING))
ice_all_new_connecting_or_checking = FALSE;
if (ice_state != ICE_STATE (CONNECTED)
&& ice_state != ICE_STATE (COMPLETED)
&& ice_state != ICE_STATE (CLOSED))
ice_all_connected_completed_or_closed = FALSE;
}
} }
GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x. DTLS connection " GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x. DTLS connection "
@ -1704,7 +1633,7 @@ _on_sending_rtcp (GObject * internal_session, GstBuffer * buffer,
pad_name = pad_name =
g_strdup_printf ("send_rtcp_src_%u", g_strdup_printf ("send_rtcp_src_%u",
rtp_trans->sender->rtcp_transport->session_id); rtp_trans->sender->transport->session_id);
pad = gst_element_get_static_pad (webrtc->rtpbin, pad_name); pad = gst_element_get_static_pad (webrtc->rtpbin, pad_name);
g_free (pad_name); g_free (pad_name);
if (pad) { if (pad) {
@ -1895,8 +1824,6 @@ gst_webrtc_bin_attach_tos (GstWebRTCBin * webrtc)
gst_webrtc_bin_attach_probe_to_ice_sink (webrtc, gst_webrtc_bin_attach_probe_to_ice_sink (webrtc,
stream->transport->transport); stream->transport->transport);
gst_webrtc_bin_attach_probe_to_ice_sink (webrtc,
stream->rtcp_transport->transport);
} }
gst_webrtc_bin_update_sctp_priority (webrtc); gst_webrtc_bin_update_sctp_priority (webrtc);
@ -1954,18 +1881,6 @@ _create_transport_channel (GstWebRTCBin * webrtc, guint session_id)
if (webrtc->priv->tos_attached) if (webrtc->priv->tos_attached)
gst_webrtc_bin_attach_probe_to_ice_sink (webrtc, transport->transport); gst_webrtc_bin_attach_probe_to_ice_sink (webrtc, transport->transport);
if ((transport = ret->rtcp_transport)) {
g_signal_connect (G_OBJECT (transport->transport),
"notify::state", G_CALLBACK (_on_ice_transport_notify_state), webrtc);
g_signal_connect (G_OBJECT (transport->transport),
"notify::gathering-state",
G_CALLBACK (_on_ice_transport_notify_gathering_state), webrtc);
g_signal_connect (G_OBJECT (transport), "notify::state",
G_CALLBACK (_on_dtls_transport_notify_state), webrtc);
if (webrtc->priv->tos_attached)
gst_webrtc_bin_attach_probe_to_ice_sink (webrtc, transport->transport);
}
GST_TRACE_OBJECT (webrtc, GST_TRACE_OBJECT (webrtc,
"Create transport %" GST_PTR_FORMAT " for session %u", ret, session_id); "Create transport %" GST_PTR_FORMAT " for session %u", ret, session_id);
@ -6985,11 +6900,6 @@ _transport_free (GObject * object)
g_signal_handlers_disconnect_by_data (stream->transport->transport, webrtc); g_signal_handlers_disconnect_by_data (stream->transport->transport, webrtc);
g_signal_handlers_disconnect_by_data (stream->transport, webrtc); g_signal_handlers_disconnect_by_data (stream->transport, webrtc);
} }
if (stream->rtcp_transport) {
g_signal_handlers_disconnect_by_data (stream->rtcp_transport->transport,
webrtc);
g_signal_handlers_disconnect_by_data (stream->rtcp_transport, webrtc);
}
gst_object_unref (object); gst_object_unref (object);
} }

4
ext/webrtc/nicetransport.c
View file

@ -171,7 +171,6 @@ gst_webrtc_nice_transport_finalize (GObject * object)
void void
gst_webrtc_nice_transport_update_buffer_size (GstWebRTCNiceTransport * nice) gst_webrtc_nice_transport_update_buffer_size (GstWebRTCNiceTransport * nice)
{ {
GstWebRTCICETransport *ice = GST_WEBRTC_ICE_TRANSPORT (nice);
NiceAgent *agent = NULL; NiceAgent *agent = NULL;
GPtrArray *sockets; GPtrArray *sockets;
guint i; guint i;
@ -179,8 +178,7 @@ gst_webrtc_nice_transport_update_buffer_size (GstWebRTCNiceTransport * nice)
g_object_get (nice->stream->ice, "agent", &agent, NULL); g_object_get (nice->stream->ice, "agent", &agent, NULL);
g_assert (agent != NULL); g_assert (agent != NULL);
sockets = nice_agent_get_sockets (agent, nice->stream->stream_id, sockets = nice_agent_get_sockets (agent, nice->stream->stream_id, 1);
ice->component + 1);
if (sockets == NULL) { if (sockets == NULL) {
g_object_unref (agent); g_object_unref (agent);
return; return;

122
ext/webrtc/transportreceivebin.c
View file

@ -25,24 +25,16 @@
#include "utils.h" #include "utils.h"
/* /*
* ,----------------------------transport_receive_%u---------------------------, * ,-----------------------transport_receive_%u------------------,
* ; (rtp/data) ; * ; ;
* ; ,-nicesrc-, ,-capsfilter-, ,--queue--, ,-dtlssrtpdec-, ,-funnel-, ; * ; ,-nicesrc-, ,-capsfilter-, ,---queue---, ,-dtlssrtpdec-, ;
* ; ; src o-o sink src o-osink srco-osink rtp_srco-------o sink_0 ; ; * ; ; src o-o sink src o-o sink src o-osink rtp_srco---o rtp_src
* ; '---------' '------------' '---------' ; ; ; src o--o rtp_src * ; '---------' '------------' '-----------' ; ; ;
* ; ; rtcp_srco---, ,-o sink_1 ; ; * ; ; rtcp_srco---o rtcp_src
* ; ; ; ; ; '--------' ; * ; ; ; ;
* ; ; data_srco-, ; ; ,-funnel-, ; * ; ; data_srco---o data_src
* ; (rtcp) '-------------' ; '-+-o sink_0 ; ; * ; '-------------' ;
* ; ,-nicesrc-, ,-capsfilter-, ,--queue--, ,-dtlssrtpdec-, ; ,-' ; src o--o rtcp_src * '-------------------------------------------------------------'
* ; ; src o-o sink src o-osink srco-osink rtp_srco-+-' ,-o sink_1 ; ;
* ; '---------' '------------' '---------' ; ; ; ; '--------' ;
* ; ; rtcp_srco-+---' ,-funnel-, ;
* ; ; ; '-----o sink_0 ; ;
* ; ; data_srco-, ; src o--o data_src
* ; '-------------' '-----o sink_1 ; ;
* ; '--------' ;
* '---------------------------------------------------------------------------'
* *
* Do we really wnat to be *that* permissive in what we accept? * Do we really wnat to be *that* permissive in what we accept?
* *
@ -155,24 +147,9 @@ transport_receive_bin_set_receive_state (TransportReceiveBin * receive,
(GstPadProbeCallback) pad_block, receive, NULL); (GstPadProbeCallback) pad_block, receive, NULL);
gst_object_unref (peer_pad); gst_object_unref (peer_pad);
gst_object_unref (pad); gst_object_unref (pad);
transport = receive->stream->rtcp_transport;
dtlssrtpdec = transport->dtlssrtpdec;
pad = gst_element_get_static_pad (dtlssrtpdec, "sink");
peer_pad = gst_pad_get_peer (pad);
receive->rtcp_block =
_create_pad_block (GST_ELEMENT (receive), peer_pad, 0, NULL, NULL);
receive->rtcp_block->block_id =
gst_pad_add_probe (peer_pad,
GST_PAD_PROBE_TYPE_BLOCK |
GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
(GstPadProbeCallback) pad_block, receive, NULL);
gst_object_unref (peer_pad);
gst_object_unref (pad);
} }
} }
} }
receive->receive_state = state; receive->receive_state = state;
g_mutex_unlock (&receive->pad_block_lock); g_mutex_unlock (&receive->pad_block_lock);
} }
@ -250,9 +227,6 @@ transport_receive_bin_change_state (GstElement * element,
elem = receive->stream->transport->transport->src; elem = receive->stream->transport->transport->src;
gst_element_set_locked_state (elem, TRUE); gst_element_set_locked_state (elem, TRUE);
gst_element_set_state (elem, GST_STATE_PLAYING); gst_element_set_state (elem, GST_STATE_PLAYING);
elem = receive->stream->rtcp_transport->transport->src;
gst_element_set_locked_state (elem, TRUE);
gst_element_set_state (elem, GST_STATE_PLAYING);
break; break;
} }
default: default:
@ -270,9 +244,6 @@ transport_receive_bin_change_state (GstElement * element,
elem = receive->stream->transport->transport->src; elem = receive->stream->transport->transport->src;
gst_element_set_locked_state (elem, FALSE); gst_element_set_locked_state (elem, FALSE);
gst_element_set_state (elem, GST_STATE_NULL); gst_element_set_state (elem, GST_STATE_NULL);
elem = receive->stream->rtcp_transport->transport->src;
gst_element_set_locked_state (elem, FALSE);
gst_element_set_state (elem, GST_STATE_NULL);
if (receive->rtp_block) if (receive->rtp_block)
_free_pad_block (receive->rtp_block); _free_pad_block (receive->rtp_block);
@ -303,7 +274,7 @@ transport_receive_bin_constructed (GObject * object)
TransportReceiveBin *receive = TRANSPORT_RECEIVE_BIN (object); TransportReceiveBin *receive = TRANSPORT_RECEIVE_BIN (object);
GstWebRTCDTLSTransport *transport; GstWebRTCDTLSTransport *transport;
GstPad *ghost, *pad; GstPad *ghost, *pad;
GstElement *capsfilter, *funnel, *queue; GstElement *capsfilter, *queue;
GstCaps *caps; GstCaps *caps;
g_return_if_fail (receive->stream); g_return_if_fail (receive->stream);
@ -336,76 +307,25 @@ transport_receive_bin_constructed (GObject * object)
GST_ELEMENT (capsfilter), "sink")) GST_ELEMENT (capsfilter), "sink"))
g_warn_if_reached (); g_warn_if_reached ();
/* link ice src, dtlsrtp together for rtcp */ /* expose rtp_src */
transport = receive->stream->rtcp_transport; pad =
gst_bin_add (GST_BIN (receive), GST_ELEMENT (transport->dtlssrtpdec)); gst_element_get_static_pad (receive->stream->transport->dtlssrtpdec,
"rtp_src");
capsfilter = gst_element_factory_make ("capsfilter", NULL);
caps = gst_caps_new_empty_simple ("application/x-rtcp");
g_object_set (capsfilter, "caps", caps, NULL);
gst_caps_unref (caps);
queue = gst_element_factory_make ("queue", NULL);
/* FIXME: make this configurable? */
g_object_set (queue, "leaky", 2, "max-size-time", (guint64) 0,
"max-size-buffers", 0, "max-size-bytes", 5 * 1024 * 1024, NULL);
g_signal_connect (queue, "overrun", G_CALLBACK (rtp_queue_overrun), receive);
gst_bin_add (GST_BIN (receive), queue);
gst_bin_add (GST_BIN (receive), GST_ELEMENT (capsfilter));
if (!gst_element_link_pads (capsfilter, "src", queue, "sink"))
g_warn_if_reached ();
if (!gst_element_link_pads (queue, "src", transport->dtlssrtpdec, "sink"))
g_warn_if_reached ();
gst_bin_add (GST_BIN (receive), GST_ELEMENT (transport->transport->src));
if (!gst_element_link_pads (GST_ELEMENT (transport->transport->src), "src",
GST_ELEMENT (capsfilter), "sink"))
g_warn_if_reached ();
/* create funnel for rtp_src */
funnel = gst_element_factory_make ("funnel", NULL);
gst_bin_add (GST_BIN (receive), funnel);
if (!gst_element_link_pads (receive->stream->transport->dtlssrtpdec,
"rtp_src", funnel, "sink_0"))
g_warn_if_reached ();
if (!gst_element_link_pads (receive->stream->rtcp_transport->dtlssrtpdec,
"rtp_src", funnel, "sink_1"))
g_warn_if_reached ();
pad = gst_element_get_static_pad (funnel, "src");
receive->rtp_src = gst_ghost_pad_new ("rtp_src", pad); receive->rtp_src = gst_ghost_pad_new ("rtp_src", pad);
gst_element_add_pad (GST_ELEMENT (receive), receive->rtp_src); gst_element_add_pad (GST_ELEMENT (receive), receive->rtp_src);
gst_object_unref (pad); gst_object_unref (pad);
/* create funnel for rtcp_src */ /* expose rtcp_rtc */
funnel = gst_element_factory_make ("funnel", NULL); pad = gst_element_get_static_pad (receive->stream->transport->dtlssrtpdec,
gst_bin_add (GST_BIN (receive), funnel); "rtcp_src");
if (!gst_element_link_pads (receive->stream->transport->dtlssrtpdec,
"rtcp_src", funnel, "sink_0"))
g_warn_if_reached ();
if (!gst_element_link_pads (receive->stream->rtcp_transport->dtlssrtpdec,
"rtcp_src", funnel, "sink_1"))
g_warn_if_reached ();
pad = gst_element_get_static_pad (funnel, "src");
receive->rtcp_src = gst_ghost_pad_new ("rtcp_src", pad); receive->rtcp_src = gst_ghost_pad_new ("rtcp_src", pad);
gst_element_add_pad (GST_ELEMENT (receive), receive->rtcp_src); gst_element_add_pad (GST_ELEMENT (receive), receive->rtcp_src);
gst_object_unref (pad); gst_object_unref (pad);
/* create funnel for data_src */ /* expose data_src */
funnel = gst_element_factory_make ("funnel", NULL); pad = gst_element_get_request_pad (receive->stream->transport->dtlssrtpdec,
gst_bin_add (GST_BIN (receive), funnel); "data_src");
if (!gst_element_link_pads (receive->stream->transport->dtlssrtpdec,
"data_src", funnel, "sink_0"))
g_warn_if_reached ();
if (!gst_element_link_pads (receive->stream->rtcp_transport->dtlssrtpdec,
"data_src", funnel, "sink_1"))
g_warn_if_reached ();
pad = gst_element_get_static_pad (funnel, "src");
ghost = gst_ghost_pad_new ("data_src", pad); ghost = gst_ghost_pad_new ("data_src", pad);
gst_element_add_pad (GST_ELEMENT (receive), ghost); gst_element_add_pad (GST_ELEMENT (receive), ghost);
gst_object_unref (pad); gst_object_unref (pad);

98
ext/webrtc/transportsendbin.c
View file

@ -25,20 +25,16 @@
#include "utils.h" #include "utils.h"
/* /*
* ,------------------------transport_send_%u-------------------------, * ,--------------transport_send_%u-------- ---,
* ; ,-----dtlssrtpenc---, ; * ; ,-----dtlssrtpenc---, ;
* data_sink o--------------------------o data_sink ; ; * data_sink o---o data_sink ; ;
* ; ; ; ,---nicesink---, ; * ; ; ; ,---nicesink---, ;
* rtp_sink o--------------------------o rtp_sink_0 src o--o sink ; ; * rtp_sink o---o rtp_sink_0 src o--o sink ; ;
* ; ; ; '--------------' ; * ; ; ; '--------------' ;
* ; ,--outputselector--, ,-o rtcp_sink_0 ; ; * rtcp_sink o---o rtcp_sink_0 ; ;
* ; ; src_0 o-' '-------------------' ; * ; '-------------------'
* rtcp_sink ;---o sink ; ,----dtlssrtpenc----, ,---nicesink---, ; * '-------------------------------------------'
* ; ; src_1 o---o rtcp_sink_0 src o--o sink ; ;
* ; '------------------' '-------------------' '--------------' ;
* '------------------------------------------------------------------'
* *
* outputselecter is used to switch between rtcp-mux and no rtcp-mux
* *
* FIXME: Do we need a valve drop=TRUE for the no RTCP case? * FIXME: Do we need a valve drop=TRUE for the no RTCP case?
*/ */
@ -82,24 +78,6 @@ enum
static void cleanup_blocks (TransportSendBin * send); static void cleanup_blocks (TransportSendBin * send);
static void
_set_rtcp_mux (TransportSendBin * send, gboolean rtcp_mux)
{
GstPad *active_pad;
if (rtcp_mux)
active_pad = gst_element_get_static_pad (send->outputselector, "src_0");
else
active_pad = gst_element_get_static_pad (send->outputselector, "src_1");
send->rtcp_mux = rtcp_mux;
GST_OBJECT_UNLOCK (send);
g_object_set (send->outputselector, "active-pad", active_pad, NULL);
gst_object_unref (active_pad);
GST_OBJECT_LOCK (send);
}
static void static void
transport_send_bin_set_property (GObject * object, guint prop_id, transport_send_bin_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
@ -112,9 +90,6 @@ transport_send_bin_set_property (GObject * object, guint prop_id,
/* XXX: weak-ref this? Note, it's construct-only so can't be changed later */ /* XXX: weak-ref this? Note, it's construct-only so can't be changed later */
send->stream = TRANSPORT_STREAM (g_value_get_object (value)); send->stream = TRANSPORT_STREAM (g_value_get_object (value));
break; break;
case PROP_RTCP_MUX:
_set_rtcp_mux (send, g_value_get_boolean (value));
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -133,9 +108,6 @@ transport_send_bin_get_property (GObject * object, guint prop_id,
case PROP_STREAM: case PROP_STREAM:
g_value_set_object (value, send->stream); g_value_set_object (value, send->stream);
break; break;
case PROP_RTCP_MUX:
g_value_set_boolean (value, send->rtcp_mux);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -201,7 +173,6 @@ transport_send_bin_change_state (GstElement * element,
* we should only add it once/if we get the encoding keys */ * we should only add it once/if we get the encoding keys */
TSB_LOCK (send); TSB_LOCK (send);
gst_element_set_locked_state (send->rtp_ctx.dtlssrtpenc, TRUE); gst_element_set_locked_state (send->rtp_ctx.dtlssrtpenc, TRUE);
gst_element_set_locked_state (send->rtcp_ctx.dtlssrtpenc, TRUE);
send->active = TRUE; send->active = TRUE;
TSB_UNLOCK (send); TSB_UNLOCK (send);
break; break;
@ -220,13 +191,6 @@ transport_send_bin_change_state (GstElement * element,
elem = send->stream->transport->transport->sink; elem = send->stream->transport->transport->sink;
send->rtp_ctx.nice_block = block_peer_pad (elem, "sink"); send->rtp_ctx.nice_block = block_peer_pad (elem, "sink");
/* RTCP */
elem = send->stream->rtcp_transport->dtlssrtpenc;
/* Block the RTCP DTLS encoder */
send->rtcp_ctx.rtcp_block = block_peer_pad (elem, "rtcp_sink_0");
/* unblock ice sink once a connection is made, this should also be automatic */
elem = send->stream->rtcp_transport->transport->sink;
send->rtcp_ctx.nice_block = block_peer_pad (elem, "sink");
TSB_UNLOCK (send); TSB_UNLOCK (send);
break; break;
} }
@ -257,7 +221,6 @@ transport_send_bin_change_state (GstElement * element,
cleanup_blocks (send); cleanup_blocks (send);
gst_element_set_locked_state (send->rtp_ctx.dtlssrtpenc, FALSE); gst_element_set_locked_state (send->rtp_ctx.dtlssrtpenc, FALSE);
gst_element_set_locked_state (send->rtcp_ctx.dtlssrtpenc, FALSE);
TSB_UNLOCK (send); TSB_UNLOCK (send);
break; break;
@ -276,8 +239,6 @@ _on_dtls_enc_key_set (GstElement * dtlssrtpenc, TransportSendBin * send)
if (dtlssrtpenc == send->rtp_ctx.dtlssrtpenc) if (dtlssrtpenc == send->rtp_ctx.dtlssrtpenc)
ctx = &send->rtp_ctx; ctx = &send->rtp_ctx;
else if (dtlssrtpenc == send->rtcp_ctx.dtlssrtpenc)
ctx = &send->rtcp_ctx;
else { else {
GST_WARNING_OBJECT (send, GST_WARNING_OBJECT (send,
"Received dtls-enc key info for unknown element %" GST_PTR_FORMAT, "Received dtls-enc key info for unknown element %" GST_PTR_FORMAT,
@ -308,8 +269,6 @@ _on_notify_dtls_client_status (GstElement * dtlssrtpenc,
TransportSendBinDTLSContext *ctx; TransportSendBinDTLSContext *ctx;
if (dtlssrtpenc == send->rtp_ctx.dtlssrtpenc) if (dtlssrtpenc == send->rtp_ctx.dtlssrtpenc)
ctx = &send->rtp_ctx; ctx = &send->rtp_ctx;
else if (dtlssrtpenc == send->rtcp_ctx.dtlssrtpenc)
ctx = &send->rtcp_ctx;
else { else {
GST_WARNING_OBJECT (send, GST_WARNING_OBJECT (send,
"Received dtls-enc client mode for unknown element %" GST_PTR_FORMAT, "Received dtls-enc client mode for unknown element %" GST_PTR_FORMAT,
@ -351,13 +310,6 @@ _on_notify_ice_connection_state (GstWebRTCICETransport * transport,
_free_pad_block (send->rtp_ctx.nice_block); _free_pad_block (send->rtp_ctx.nice_block);
send->rtp_ctx.nice_block = NULL; send->rtp_ctx.nice_block = NULL;
} }
} else if (transport == send->stream->rtcp_transport->transport) {
if (send->rtcp_ctx.nice_block) {
GST_LOG_OBJECT (send, "Unblocking pad %" GST_PTR_FORMAT,
send->rtcp_ctx.nice_block->pad);
_free_pad_block (send->rtcp_ctx.nice_block);
send->rtcp_ctx.nice_block = NULL;
}
} }
TSB_UNLOCK (send); TSB_UNLOCK (send);
} }
@ -400,13 +352,6 @@ transport_send_bin_constructed (GObject * object)
g_return_if_fail (send->stream); g_return_if_fail (send->stream);
g_object_bind_property (send, "rtcp-mux", send->stream, "rtcp-mux",
G_BINDING_BIDIRECTIONAL);
/* Output selector to direct the RTCP for muxed-mode */
send->outputselector = gst_element_factory_make ("output-selector", NULL);
gst_bin_add (GST_BIN (send), send->outputselector);
/* RTP */ /* RTP */
transport = send->stream->transport; transport = send->stream->transport;
/* Do the common init for the context struct */ /* Do the common init for the context struct */
@ -417,10 +362,6 @@ transport_send_bin_constructed (GObject * object)
pad = gst_element_request_pad (transport->dtlssrtpenc, templ, "rtp_sink_0", pad = gst_element_request_pad (transport->dtlssrtpenc, templ, "rtp_sink_0",
NULL); NULL);
if (!gst_element_link_pads (GST_ELEMENT (send->outputselector), "src_0",
GST_ELEMENT (transport->dtlssrtpenc), "rtcp_sink_0"))
g_warn_if_reached ();
ghost = gst_ghost_pad_new ("rtp_sink", pad); ghost = gst_ghost_pad_new ("rtp_sink", pad);
gst_element_add_pad (GST_ELEMENT (send), ghost); gst_element_add_pad (GST_ELEMENT (send), ghost);
gst_object_unref (pad); gst_object_unref (pad);
@ -436,17 +377,11 @@ transport_send_bin_constructed (GObject * object)
gst_object_unref (pad); gst_object_unref (pad);
/* RTCP */ /* RTCP */
transport = send->stream->rtcp_transport;
/* Do the common init for the context struct */ /* Do the common init for the context struct */
tsb_setup_ctx (send, &send->rtcp_ctx, transport);
templ = _find_pad_template (transport->dtlssrtpenc, templ = _find_pad_template (transport->dtlssrtpenc,
GST_PAD_SINK, GST_PAD_REQUEST, "rtcp_sink_%d"); GST_PAD_SINK, GST_PAD_REQUEST, "rtcp_sink_%d");
pad = gst_element_request_pad (transport->dtlssrtpenc, templ, "rtcp_sink_0",
if (!gst_element_link_pads (GST_ELEMENT (send->outputselector), "src_1", NULL);
GST_ELEMENT (transport->dtlssrtpenc), "rtcp_sink_0"))
g_warn_if_reached ();
pad = gst_element_get_static_pad (send->outputselector, "sink");
ghost = gst_ghost_pad_new ("rtcp_sink", pad); ghost = gst_ghost_pad_new ("rtcp_sink", pad);
gst_element_add_pad (GST_ELEMENT (send), ghost); gst_element_add_pad (GST_ELEMENT (send), ghost);
@ -478,7 +413,6 @@ static void
cleanup_blocks (TransportSendBin * send) cleanup_blocks (TransportSendBin * send)
{ {
cleanup_ctx_blocks (&send->rtp_ctx); cleanup_ctx_blocks (&send->rtp_ctx);
cleanup_ctx_blocks (&send->rtcp_ctx);
} }
static void static void
@ -491,10 +425,6 @@ transport_send_bin_dispose (GObject * object)
g_signal_handlers_disconnect_by_data (send->rtp_ctx.nicesink, send); g_signal_handlers_disconnect_by_data (send->rtp_ctx.nicesink, send);
send->rtp_ctx.nicesink = NULL; send->rtp_ctx.nicesink = NULL;
} }
if (send->rtcp_ctx.nicesink) {
g_signal_handlers_disconnect_by_data (send->rtcp_ctx.nicesink, send);
send->rtcp_ctx.nicesink = NULL;
}
cleanup_blocks (send); cleanup_blocks (send);
TSB_UNLOCK (send); TSB_UNLOCK (send);
@ -623,12 +553,6 @@ transport_send_bin_class_init (TransportSendBinClass * klass)
"The TransportStream for this sending bin", "The TransportStream for this sending bin",
transport_stream_get_type (), transport_stream_get_type (),
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_RTCP_MUX,
g_param_spec_boolean ("rtcp-mux", "RTCP Mux",
"Whether RTCP packets are muxed with RTP packets",
FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
} }
static void static void

4
ext/webrtc/transportsendbin.h
View file

@ -54,12 +54,8 @@ struct _TransportSendBin
gboolean active; /* Flag that's cleared on shutdown */ gboolean active; /* Flag that's cleared on shutdown */
TransportStream *stream; /* parent transport stream */ TransportStream *stream; /* parent transport stream */
gboolean rtcp_mux;
GstElement *outputselector;
TransportSendBinDTLSContext rtp_ctx; TransportSendBinDTLSContext rtp_ctx;
TransportSendBinDTLSContext rtcp_ctx;
/* /*
struct pad_block *rtp_block; struct pad_block *rtp_block;

19
ext/webrtc/transportstream.c
View file

@ -178,10 +178,6 @@ transport_stream_dispose (GObject * object)
gst_object_unref (stream->transport); gst_object_unref (stream->transport);
stream->transport = NULL; stream->transport = NULL;
if (stream->rtcp_transport)
gst_object_unref (stream->rtcp_transport);
stream->rtcp_transport = NULL;
if (stream->rtxsend) if (stream->rtxsend)
gst_object_unref (stream->rtxsend); gst_object_unref (stream->rtxsend);
stream->rtxsend = NULL; stream->rtxsend = NULL;
@ -213,19 +209,12 @@ transport_stream_constructed (GObject * object)
GstWebRTCBin *webrtc; GstWebRTCBin *webrtc;
GstWebRTCICETransport *ice_trans; GstWebRTCICETransport *ice_trans;
stream->transport = gst_webrtc_dtls_transport_new (stream->session_id, FALSE); stream->transport = gst_webrtc_dtls_transport_new (stream->session_id);
stream->rtcp_transport =
gst_webrtc_dtls_transport_new (stream->session_id, TRUE);
webrtc = GST_WEBRTC_BIN (gst_object_get_parent (GST_OBJECT (object))); webrtc = GST_WEBRTC_BIN (gst_object_get_parent (GST_OBJECT (object)));
g_object_bind_property (stream->transport, "client", stream, "dtls-client", g_object_bind_property (stream->transport, "client", stream, "dtls-client",
G_BINDING_BIDIRECTIONAL); G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->rtcp_transport, "client", stream,
"dtls-client", G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->transport, "certificate",
stream->rtcp_transport, "certificate", G_BINDING_BIDIRECTIONAL);
/* Need to go full Java and have a transport manager? /* Need to go full Java and have a transport manager?
* Or make the caller set the ICE transport up? */ * Or make the caller set the ICE transport up? */
@ -242,12 +231,6 @@ transport_stream_constructed (GObject * object)
gst_webrtc_dtls_transport_set_transport (stream->transport, ice_trans); gst_webrtc_dtls_transport_set_transport (stream->transport, ice_trans);
gst_object_unref (ice_trans); gst_object_unref (ice_trans);
ice_trans =
gst_webrtc_ice_find_transport (webrtc->priv->ice, stream->stream,
GST_WEBRTC_ICE_COMPONENT_RTCP);
gst_webrtc_dtls_transport_set_transport (stream->rtcp_transport, ice_trans);
gst_object_unref (ice_trans);
stream->send_bin = g_object_new (transport_send_bin_get_type (), "stream", stream->send_bin = g_object_new (transport_send_bin_get_type (), "stream",
stream, NULL); stream, NULL);
gst_object_ref_sink (stream->send_bin); gst_object_ref_sink (stream->send_bin);

1
ext/webrtc/transportstream.h
View file

@ -58,7 +58,6 @@ struct _TransportStream
GstWebRTCICEStream *stream; GstWebRTCICEStream *stream;
GstWebRTCDTLSTransport *transport; GstWebRTCDTLSTransport *transport;
GstWebRTCDTLSTransport *rtcp_transport;
GArray *ptmap; /* array of PtMapItem's */ GArray *ptmap; /* array of PtMapItem's */
GArray *remote_ssrcmap; /* array of SsrcMapItem's */ GArray *remote_ssrcmap; /* array of SsrcMapItem's */

21
ext/webrtc/webrtctransceiver.c
View file

@ -65,13 +65,6 @@ webrtc_transceiver_set_transport (WebRTCTransceiver * trans,
if (rtp_trans->receiver) if (rtp_trans->receiver)
gst_object_replace ((GstObject **) & rtp_trans->receiver->transport, gst_object_replace ((GstObject **) & rtp_trans->receiver->transport,
(GstObject *) stream->transport); (GstObject *) stream->transport);
if (rtp_trans->sender)
gst_object_replace ((GstObject **) & rtp_trans->sender->rtcp_transport,
(GstObject *) stream->rtcp_transport);
if (rtp_trans->receiver)
gst_object_replace ((GstObject **) & rtp_trans->receiver->rtcp_transport,
(GstObject *) stream->rtcp_transport);
} }
GstWebRTCDTLSTransport * GstWebRTCDTLSTransport *
@ -88,20 +81,6 @@ webrtc_transceiver_get_dtls_transport (GstWebRTCRTPTransceiver * trans)
return NULL; return NULL;
} }
GstWebRTCDTLSTransport *
webrtc_transceiver_get_rtcp_dtls_transport (GstWebRTCRTPTransceiver * trans)
{
g_return_val_if_fail (WEBRTC_IS_TRANSCEIVER (trans), NULL);
if (trans->sender) {
return trans->sender->rtcp_transport;
} else if (trans->receiver) {
return trans->receiver->rtcp_transport;
}
return NULL;
}
static void static void
webrtc_transceiver_set_property (GObject * object, guint prop_id, webrtc_transceiver_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)

23
gst-libs/gst/webrtc/dtlstransport.c
View file

@ -55,8 +55,7 @@ enum
PROP_STATE, PROP_STATE,
PROP_CLIENT, PROP_CLIENT,
PROP_CERTIFICATE, PROP_CERTIFICATE,
PROP_REMOTE_CERTIFICATE, PROP_REMOTE_CERTIFICATE
PROP_RTCP,
}; };
void void
@ -88,9 +87,6 @@ gst_webrtc_dtls_transport_set_property (GObject * object, guint prop_id,
case PROP_CERTIFICATE: case PROP_CERTIFICATE:
g_object_set_property (G_OBJECT (webrtc->dtlssrtpdec), "pem", value); g_object_set_property (G_OBJECT (webrtc->dtlssrtpdec), "pem", value);
break; break;
case PROP_RTCP:
webrtc->is_rtcp = g_value_get_boolean (value);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -123,9 +119,6 @@ gst_webrtc_dtls_transport_get_property (GObject * object, guint prop_id,
case PROP_REMOTE_CERTIFICATE: case PROP_REMOTE_CERTIFICATE:
g_object_get_property (G_OBJECT (webrtc->dtlssrtpdec), "peer-pem", value); g_object_get_property (G_OBJECT (webrtc->dtlssrtpdec), "peer-pem", value);
break; break;
case PROP_RTCP:
g_value_set_boolean (value, webrtc->is_rtcp);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -184,8 +177,8 @@ gst_webrtc_dtls_transport_constructed (GObject * object)
/* XXX: this may collide with another connection_id however this is only a /* XXX: this may collide with another connection_id however this is only a
* problem if multiple dtls element sets are being used within the same * problem if multiple dtls element sets are being used within the same
* process */ * process */
connection_id = g_strdup_printf ("%s_%u_%u", webrtc->is_rtcp ? "rtcp" : "rtp", connection_id = g_strdup_printf ("rtp_%u_%u", webrtc->session_id,
webrtc->session_id, g_random_int ()); g_random_int ());
webrtc->dtlssrtpenc = gst_element_factory_make ("dtlssrtpenc", NULL); webrtc->dtlssrtpenc = gst_element_factory_make ("dtlssrtpenc", NULL);
g_object_set (webrtc->dtlssrtpenc, "connection-id", connection_id, g_object_set (webrtc->dtlssrtpenc, "connection-id", connection_id,
@ -249,12 +242,6 @@ gst_webrtc_dtls_transport_class_init (GstWebRTCDTLSTransportClass * klass)
g_param_spec_string ("remote-certificate", "Remote DTLS certificate", g_param_spec_string ("remote-certificate", "Remote DTLS certificate",
"Remote DTLS certificate", NULL, "Remote DTLS certificate", NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_RTCP,
g_param_spec_boolean ("rtcp", "RTCP",
"The transport is being used solely for RTCP", FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
} }
static void static void
@ -263,8 +250,8 @@ gst_webrtc_dtls_transport_init (GstWebRTCDTLSTransport * webrtc)
} }
GstWebRTCDTLSTransport * GstWebRTCDTLSTransport *
gst_webrtc_dtls_transport_new (guint session_id, gboolean is_rtcp) gst_webrtc_dtls_transport_new (guint session_id)
{ {
return g_object_new (GST_TYPE_WEBRTC_DTLS_TRANSPORT, "session-id", session_id, return g_object_new (GST_TYPE_WEBRTC_DTLS_TRANSPORT, "session-id", session_id,
"rtcp", is_rtcp, NULL); NULL);
} }

3
gst-libs/gst/webrtc/dtlstransport.h
View file

@ -45,7 +45,6 @@ struct _GstWebRTCDTLSTransport
GstWebRTCICETransport *transport; GstWebRTCICETransport *transport;
GstWebRTCDTLSTransportState state; GstWebRTCDTLSTransportState state;
gboolean is_rtcp;
gboolean client; gboolean client;
guint session_id; guint session_id;
GstElement *dtlssrtpenc; GstElement *dtlssrtpenc;
@ -62,7 +61,7 @@ struct _GstWebRTCDTLSTransportClass
}; };
GST_WEBRTC_API GST_WEBRTC_API
GstWebRTCDTLSTransport * gst_webrtc_dtls_transport_new (guint session_id, gboolean rtcp); GstWebRTCDTLSTransport * gst_webrtc_dtls_transport_new (guint session_id);
GST_WEBRTC_API GST_WEBRTC_API
void gst_webrtc_dtls_transport_set_transport (GstWebRTCDTLSTransport * transport, void gst_webrtc_dtls_transport_set_transport (GstWebRTCDTLSTransport * transport,

11
gst-libs/gst/webrtc/rtpreceiver.c
View file

@ -63,17 +63,6 @@ gst_webrtc_rtp_receiver_set_transport (GstWebRTCRTPReceiver * receiver,
GST_OBJECT_LOCK (receiver); GST_OBJECT_LOCK (receiver);
gst_object_replace ((GstObject **) & receiver->transport, gst_object_replace ((GstObject **) & receiver->transport,
GST_OBJECT (transport)); GST_OBJECT (transport));
GST_OBJECT_UNLOCK (receiver);
}
void
gst_webrtc_rtp_receiver_set_rtcp_transport (GstWebRTCRTPReceiver * receiver,
GstWebRTCDTLSTransport * transport)
{
g_return_if_fail (GST_IS_WEBRTC_RTP_RECEIVER (receiver));
g_return_if_fail (GST_IS_WEBRTC_DTLS_TRANSPORT (transport));
GST_OBJECT_LOCK (receiver);
gst_object_replace ((GstObject **) & receiver->rtcp_transport, gst_object_replace ((GstObject **) & receiver->rtcp_transport,
GST_OBJECT (transport)); GST_OBJECT (transport));
GST_OBJECT_UNLOCK (receiver); GST_OBJECT_UNLOCK (receiver);

3
gst-libs/gst/webrtc/rtpreceiver.h
View file

@ -69,9 +69,6 @@ GstWebRTCRTPReceiver * gst_webrtc_rtp_receiver_new (void);
GST_WEBRTC_API GST_WEBRTC_API
void gst_webrtc_rtp_receiver_set_transport (GstWebRTCRTPReceiver * receiver, void gst_webrtc_rtp_receiver_set_transport (GstWebRTCRTPReceiver * receiver,
GstWebRTCDTLSTransport * transport); GstWebRTCDTLSTransport * transport);
GST_WEBRTC_API
void gst_webrtc_rtp_receiver_set_rtcp_transport (GstWebRTCRTPReceiver * receiver,
GstWebRTCDTLSTransport * transport);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GstWebRTCRTPReceiver, gst_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(GstWebRTCRTPReceiver, gst_object_unref)

11
gst-libs/gst/webrtc/rtpsender.c
View file

@ -66,17 +66,6 @@ gst_webrtc_rtp_sender_set_transport (GstWebRTCRTPSender * sender,
GST_OBJECT_LOCK (sender); GST_OBJECT_LOCK (sender);
gst_object_replace ((GstObject **) & sender->transport, gst_object_replace ((GstObject **) & sender->transport,
GST_OBJECT (transport)); GST_OBJECT (transport));
GST_OBJECT_UNLOCK (sender);
}
void
gst_webrtc_rtp_sender_set_rtcp_transport (GstWebRTCRTPSender * sender,
GstWebRTCDTLSTransport * transport)
{
g_return_if_fail (GST_IS_WEBRTC_RTP_SENDER (sender));
g_return_if_fail (GST_IS_WEBRTC_DTLS_TRANSPORT (transport));
GST_OBJECT_LOCK (sender);
gst_object_replace ((GstObject **) & sender->rtcp_transport, gst_object_replace ((GstObject **) & sender->rtcp_transport,
GST_OBJECT (transport)); GST_OBJECT (transport));
GST_OBJECT_UNLOCK (sender); GST_OBJECT_UNLOCK (sender);

3
gst-libs/gst/webrtc/rtpsender.h
View file

@ -83,9 +83,6 @@ GST_WEBRTC_API
void gst_webrtc_rtp_sender_set_transport (GstWebRTCRTPSender * sender, void gst_webrtc_rtp_sender_set_transport (GstWebRTCRTPSender * sender,
GstWebRTCDTLSTransport * transport); GstWebRTCDTLSTransport * transport);
GST_WEBRTC_API GST_WEBRTC_API
void gst_webrtc_rtp_sender_set_rtcp_transport (GstWebRTCRTPSender * sender,
GstWebRTCDTLSTransport * transport);
GST_WEBRTC_API
void gst_webrtc_rtp_sender_set_priority (GstWebRTCRTPSender *sender, void gst_webrtc_rtp_sender_set_priority (GstWebRTCRTPSender *sender,
GstWebRTCPriorityType priority); GstWebRTCPriorityType priority);