webrtcbin: implement support for FEC and RTX
https://bugzilla.gnome.org/show_bug.cgi?id=795044
diff --git a/ext/webrtc/gstwebrtcbin.c b/ext/webrtc/gstwebrtcbin.c
index 08e6b6a..c553a93 100644
--- a/ext/webrtc/gstwebrtcbin.c
+++ b/ext/webrtc/gstwebrtcbin.c
@@ -76,6 +76,8 @@
* how to deal with replacing a input/output track/stream
*/
+static void _update_need_negotiation (GstWebRTCBin * webrtc);
+
#define GST_CAT_DEFAULT gst_webrtc_bin_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@@ -118,6 +120,10 @@
gst_object_unref (pad->trans);
pad->trans = NULL;
+ if (pad->received_caps)
+ gst_caps_unref (pad->received_caps);
+ pad->received_caps = NULL;
+
G_OBJECT_CLASS (gst_webrtc_bin_pad_parent_class)->finalize (object);
}
@@ -145,6 +151,48 @@
return NULL;
}
+static gint
+_transport_stream_get_pt (TransportStream * stream, const gchar * encoding_name)
+{
+ guint i;
+ gint ret = 0;
+
+ for (i = 0; i < stream->ptmap->len; i++) {
+ PtMapItem *item = &g_array_index (stream->ptmap, PtMapItem, i);
+ if (!gst_caps_is_empty (item->caps)) {
+ GstStructure *s = gst_caps_get_structure (item->caps, 0);
+ if (!g_strcmp0 (gst_structure_get_string (s, "encoding-name"),
+ encoding_name)) {
+ ret = item->pt;
+ break;
+ }
+ }
+ }
+
+ return ret;
+}
+
+static gboolean
+gst_webrtcbin_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
+{
+ GstWebRTCBinPad *wpad = GST_WEBRTC_BIN_PAD (pad);
+
+ if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS) {
+ GstCaps *caps;
+ gboolean do_update;
+
+ gst_event_parse_caps (event, &caps);
+ do_update = (!wpad->received_caps
+ || gst_caps_is_equal (wpad->received_caps, caps));
+ gst_caps_replace (&wpad->received_caps, caps);
+
+ if (do_update)
+ _update_need_negotiation (GST_WEBRTC_BIN (parent));
+ }
+
+ return gst_pad_event_default (pad, parent, event);
+}
+
static void
gst_webrtc_bin_pad_init (GstWebRTCBinPad * pad)
{
@@ -157,6 +205,8 @@
g_object_new (gst_webrtc_bin_pad_get_type (), "name", name, "direction",
direction, NULL);
+ gst_pad_set_event_function (GST_PAD (pad), gst_webrtcbin_sink_event);
+
if (!gst_ghost_pad_construct (GST_GHOST_PAD (pad))) {
gst_object_unref (pad);
return NULL;
@@ -172,6 +222,9 @@
GST_DEBUG_CATEGORY_INIT (gst_webrtc_bin_debug, "webrtcbin", 0,
"webrtcbin element"););
+static GstPad *_connect_input_stream (GstWebRTCBin * webrtc,
+ GstWebRTCBinPad * pad);
+
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
@@ -192,6 +245,7 @@
ADD_ICE_CANDIDATE_SIGNAL,
ON_NEGOTIATION_NEEDED_SIGNAL,
ON_ICE_CANDIDATE_SIGNAL,
+ ON_NEW_TRANSCEIVER_SIGNAL,
GET_STATS_SIGNAL,
ADD_TRANSCEIVER_SIGNAL,
GET_TRANSCEIVERS_SIGNAL,
@@ -1005,6 +1059,34 @@
NULL, NULL);
}
+static gboolean
+_all_sinks_have_caps (GstWebRTCBin * webrtc)
+{
+ GList *l;
+ gboolean res = FALSE;
+
+ GST_OBJECT_LOCK (webrtc);
+ l = GST_ELEMENT (webrtc)->pads;
+ for (; l; l = g_list_next (l)) {
+ if (!GST_IS_WEBRTC_BIN_PAD (l->data))
+ continue;
+ if (!GST_WEBRTC_BIN_PAD (l->data)->received_caps)
+ goto done;
+ }
+
+ l = webrtc->priv->pending_pads;
+ for (; l; l = g_list_next (l)) {
+ if (!GST_IS_WEBRTC_BIN_PAD (l->data))
+ goto done;
+ }
+
+ res = TRUE;
+
+done:
+ GST_OBJECT_UNLOCK (webrtc);
+ return res;
+}
+
/* http://w3c.github.io/webrtc-pc/#dfn-check-if-negotiation-is-needed */
static gboolean
_check_if_negotiation_is_needed (GstWebRTCBin * webrtc)
@@ -1013,6 +1095,14 @@
GST_LOG_OBJECT (webrtc, "checking if negotiation is needed");
+ /* We can't negotiate until we have received caps on all our sink pads,
+ * as we will need the ssrcs in our offer / answer */
+ if (!_all_sinks_have_caps (webrtc)) {
+ GST_LOG_OBJECT (webrtc,
+ "no negotiation possible until caps have been received on all sink pads");
+ return FALSE;
+ }
+
/* If any implementation-specific negotiation is required, as described at
* the start of this section, return "true".
* FIXME */
@@ -1161,7 +1251,7 @@
GST_LOG_OBJECT (webrtc, "retreiving codec preferences from %" GST_PTR_FORMAT,
trans);
- if (trans->codec_preferences) {
+ if (trans && trans->codec_preferences) {
GST_LOG_OBJECT (webrtc, "Using codec preferences: %" GST_PTR_FORMAT,
trans->codec_preferences);
ret = gst_caps_ref (trans->codec_preferences);
@@ -1187,18 +1277,21 @@
}
static GstCaps *
-_add_supported_attributes_to_caps (const GstCaps * caps)
+_add_supported_attributes_to_caps (GstWebRTCBin * webrtc,
+ WebRTCTransceiver * trans, const GstCaps * caps)
{
GstCaps *ret;
- int i;
+ guint i;
ret = gst_caps_make_writable (caps);
for (i = 0; i < gst_caps_get_size (ret); i++) {
GstStructure *s = gst_caps_get_structure (ret, i);
- if (!gst_structure_has_field (s, "rtcp-fb-nack"))
- gst_structure_set (s, "rtcp-fb-nack", G_TYPE_BOOLEAN, TRUE, NULL);
+ if (trans->do_nack)
+ if (!gst_structure_has_field (s, "rtcp-fb-nack"))
+ gst_structure_set (s, "rtcp-fb-nack", G_TYPE_BOOLEAN, TRUE, NULL);
+
if (!gst_structure_has_field (s, "rtcp-fb-nack-pli"))
gst_structure_set (s, "rtcp-fb-nack-pli", G_TYPE_BOOLEAN, TRUE, NULL);
/* FIXME: is this needed? */
@@ -1234,7 +1327,8 @@
}
static WebRTCTransceiver *
-_create_webrtc_transceiver (GstWebRTCBin * webrtc)
+_create_webrtc_transceiver (GstWebRTCBin * webrtc,
+ GstWebRTCRTPTransceiverDirection direction, guint mline)
{
WebRTCTransceiver *trans;
GstWebRTCRTPTransceiver *rtp_trans;
@@ -1245,14 +1339,17 @@
receiver = gst_webrtc_rtp_receiver_new ();
trans = webrtc_transceiver_new (webrtc, sender, receiver);
rtp_trans = GST_WEBRTC_RTP_TRANSCEIVER (trans);
- rtp_trans->direction = GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV;
- rtp_trans->mline = -1;
+ rtp_trans->direction = direction;
+ rtp_trans->mline = mline;
g_array_append_val (webrtc->priv->transceivers, trans);
gst_object_unref (sender);
gst_object_unref (receiver);
+ g_signal_emit (webrtc, gst_webrtc_bin_signals[ON_NEW_TRANSCEIVER_SIGNAL],
+ 0, trans);
+
return trans;
}
@@ -1311,6 +1408,216 @@
return ret;
}
+static guint
+g_array_find_uint (GArray * array, guint val)
+{
+ guint i;
+
+ for (i = 0; i < array->len; i++) {
+ if (g_array_index (array, guint, i) == val)
+ return i;
+ }
+
+ return G_MAXUINT;
+}
+
+static gboolean
+_pick_available_pt (GArray * reserved_pts, guint * i)
+{
+ gboolean ret = FALSE;
+
+ for (*i = 96; *i <= 127; (*i)++) {
+ if (g_array_find_uint (reserved_pts, *i) == G_MAXUINT) {
+ g_array_append_val (reserved_pts, *i);
+ ret = TRUE;
+ break;
+ }
+ }
+
+ return ret;
+}
+
+static gboolean
+_pick_fec_payload_types (GstWebRTCBin * webrtc, WebRTCTransceiver * trans,
+ GArray * reserved_pts, gint clockrate, gint * rtx_target_pt,
+ GstSDPMedia * media)
+{
+ gboolean ret = TRUE;
+
+ if (trans->fec_type == GST_WEBRTC_FEC_TYPE_NONE)
+ goto done;
+
+ if (trans->fec_type == GST_WEBRTC_FEC_TYPE_ULP_RED && clockrate != -1) {
+ guint pt;
+ gchar *str;
+
+ if (!(ret = _pick_available_pt (reserved_pts, &pt)))
+ goto done;
+
+ /* https://tools.ietf.org/html/rfc5109#section-14.1 */
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+ str = g_strdup_printf ("%u red/%d", pt, clockrate);
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+
+ *rtx_target_pt = pt;
+
+ if (!(ret = _pick_available_pt (reserved_pts, &pt)))
+ goto done;
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+ str = g_strdup_printf ("%u ulpfec/%d", pt, clockrate);
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+ }
+
+done:
+ return ret;
+}
+
+static gboolean
+_pick_rtx_payload_types (GstWebRTCBin * webrtc, WebRTCTransceiver * trans,
+ GArray * reserved_pts, gint clockrate, gint target_pt, guint target_ssrc,
+ GstSDPMedia * media)
+{
+ gboolean ret = TRUE;
+
+ if (trans->local_rtx_ssrc_map)
+ gst_structure_free (trans->local_rtx_ssrc_map);
+
+ trans->local_rtx_ssrc_map =
+ gst_structure_new_empty ("application/x-rtp-ssrc-map");
+
+ if (trans->do_nack) {
+ guint pt;
+ gchar *str;
+
+ if (!(ret = _pick_available_pt (reserved_pts, &pt)))
+ goto done;
+
+ /* https://tools.ietf.org/html/rfc4588#section-8.6 */
+
+ str = g_strdup_printf ("%u", target_ssrc);
+ gst_structure_set (trans->local_rtx_ssrc_map, str, G_TYPE_UINT,
+ g_random_int (), NULL);
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+
+ str = g_strdup_printf ("%u rtx/%d", pt, clockrate);
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+
+ str = g_strdup_printf ("%u apt=%d", pt, target_pt);
+ gst_sdp_media_add_attribute (media, "fmtp", str);
+ g_free (str);
+ }
+
+done:
+ return ret;
+}
+
+/* https://tools.ietf.org/html/rfc5576#section-4.2 */
+static gboolean
+_media_add_rtx_ssrc_group (GQuark field_id, const GValue * value,
+ GstSDPMedia * media)
+{
+ gchar *str;
+
+ str =
+ g_strdup_printf ("FID %s %u", g_quark_to_string (field_id),
+ g_value_get_uint (value));
+ gst_sdp_media_add_attribute (media, "ssrc-group", str);
+
+ g_free (str);
+
+ return TRUE;
+}
+
+typedef struct
+{
+ GstSDPMedia *media;
+ GstWebRTCBin *webrtc;
+ WebRTCTransceiver *trans;
+} RtxSsrcData;
+
+static gboolean
+_media_add_rtx_ssrc (GQuark field_id, const GValue * value, RtxSsrcData * data)
+{
+ gchar *str;
+ GstStructure *sdes;
+ const gchar *cname;
+
+ g_object_get (data->webrtc->rtpbin, "sdes", &sdes, NULL);
+ /* http://www.freesoft.org/CIE/RFC/1889/24.htm */
+ cname = gst_structure_get_string (sdes, "cname");
+
+ /* https://tools.ietf.org/html/draft-ietf-mmusic-msid-16 */
+ str =
+ g_strdup_printf ("%u msid:%s %s", g_value_get_uint (value),
+ cname, GST_OBJECT_NAME (data->trans));
+ gst_sdp_media_add_attribute (data->media, "ssrc", str);
+ g_free (str);
+
+ str = g_strdup_printf ("%u cname:%s", g_value_get_uint (value), cname);
+ gst_sdp_media_add_attribute (data->media, "ssrc", str);
+ g_free (str);
+
+ gst_structure_free (sdes);
+
+ return TRUE;
+}
+
+static void
+_media_add_ssrcs (GstSDPMedia * media, GstCaps * caps, GstWebRTCBin * webrtc,
+ WebRTCTransceiver * trans)
+{
+ guint i;
+ RtxSsrcData data = { media, webrtc, trans };
+ const gchar *cname;
+ GstStructure *sdes;
+
+ g_object_get (webrtc->rtpbin, "sdes", &sdes, NULL);
+ /* http://www.freesoft.org/CIE/RFC/1889/24.htm */
+ cname = gst_structure_get_string (sdes, "cname");
+
+ if (trans->local_rtx_ssrc_map)
+ gst_structure_foreach (trans->local_rtx_ssrc_map,
+ (GstStructureForeachFunc) _media_add_rtx_ssrc_group, media);
+
+ for (i = 0; i < gst_caps_get_size (caps); i++) {
+ const GstStructure *s = gst_caps_get_structure (caps, i);
+ guint ssrc;
+
+ if (gst_structure_get_uint (s, "ssrc", &ssrc)) {
+ gchar *str;
+
+ /* https://tools.ietf.org/html/draft-ietf-mmusic-msid-16 */
+ str =
+ g_strdup_printf ("%u msid:%s %s", ssrc, cname,
+ GST_OBJECT_NAME (trans));
+ gst_sdp_media_add_attribute (media, "ssrc", str);
+ g_free (str);
+
+ str = g_strdup_printf ("%u cname:%s", ssrc, cname);
+ gst_sdp_media_add_attribute (media, "ssrc", str);
+ g_free (str);
+ }
+ }
+
+ gst_structure_free (sdes);
+
+ if (trans->local_rtx_ssrc_map)
+ gst_structure_foreach (trans->local_rtx_ssrc_map,
+ (GstStructureForeachFunc) _media_add_rtx_ssrc, &data);
+}
+
/* based off https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-18#section-5.2.1 */
static gboolean
sdp_media_from_transceiver (GstWebRTCBin * webrtc, GstSDPMedia * media,
@@ -1353,7 +1660,9 @@
if (type == GST_WEBRTC_SDP_TYPE_OFFER) {
caps = _find_codec_preferences (webrtc, trans, GST_PAD_SINK, media_idx);
- caps = _add_supported_attributes_to_caps (caps);
+ caps =
+ _add_supported_attributes_to_caps (webrtc, WEBRTC_TRANSCEIVER (trans),
+ caps);
} else if (type == GST_WEBRTC_SDP_TYPE_ANSWER) {
caps = _find_codec_preferences (webrtc, trans, GST_PAD_SRC, media_idx);
/* FIXME: add rtcp-fb paramaters */
@@ -1384,6 +1693,34 @@
gst_caps_unref (format);
}
+ if (type == GST_WEBRTC_SDP_TYPE_OFFER) {
+ GArray *reserved_pts = g_array_new (FALSE, FALSE, sizeof (guint));
+ const GstStructure *s = gst_caps_get_structure (caps, 0);
+ gint clockrate = -1;
+ gint rtx_target_pt;
+ gint original_rtx_target_pt; /* Workaround chrome bug: https://bugs.chromium.org/p/webrtc/issues/detail?id=6196 */
+ guint rtx_target_ssrc;
+
+ if (gst_structure_get_int (s, "payload", &rtx_target_pt))
+ g_array_append_val (reserved_pts, rtx_target_pt);
+
+ original_rtx_target_pt = rtx_target_pt;
+
+ gst_structure_get_int (s, "clock-rate", &clockrate);
+ gst_structure_get_uint (s, "ssrc", &rtx_target_ssrc);
+
+ _pick_fec_payload_types (webrtc, WEBRTC_TRANSCEIVER (trans), reserved_pts,
+ clockrate, &rtx_target_pt, media);
+ _pick_rtx_payload_types (webrtc, WEBRTC_TRANSCEIVER (trans), reserved_pts,
+ clockrate, rtx_target_pt, rtx_target_ssrc, media);
+ if (original_rtx_target_pt != rtx_target_pt)
+ _pick_rtx_payload_types (webrtc, WEBRTC_TRANSCEIVER (trans), reserved_pts,
+ clockrate, original_rtx_target_pt, rtx_target_ssrc, media);
+ g_array_free (reserved_pts, TRUE);
+ }
+
+ _media_add_ssrcs (media, caps, webrtc, WEBRTC_TRANSCEIVER (trans));
+
/* Some identifier; we also add the media name to it so it's identifiable */
sdp_mid = g_strdup_printf ("%s%u", gst_sdp_media_get_media (media),
webrtc->priv->media_counter++);
@@ -1426,6 +1763,7 @@
{
GstSDPMessage *ret;
int i;
+ gchar *str;
gst_sdp_message_new (&ret);
@@ -1440,6 +1778,11 @@
gst_sdp_message_add_time (ret, "0", "0", NULL);
gst_sdp_message_add_attribute (ret, "ice-options", "trickle");
+ /* https://tools.ietf.org/html/draft-ietf-mmusic-msid-05#section-3 */
+ str = g_strdup_printf ("WMS %s", GST_OBJECT (webrtc)->name);
+ gst_sdp_message_add_attribute (ret, "msid-semantic", str);
+ g_free (str);
+
/* for each rtp transceiver */
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *trans;
@@ -1476,13 +1819,122 @@
return ret;
}
+static void
+_media_add_fec (GstSDPMedia * media, WebRTCTransceiver * trans, GstCaps * caps,
+ gint * rtx_target_pt)
+{
+ guint i;
+
+ if (trans->fec_type == GST_WEBRTC_FEC_TYPE_NONE)
+ return;
+
+ for (i = 0; i < gst_caps_get_size (caps); i++) {
+ const GstStructure *s = gst_caps_get_structure (caps, i);
+
+ if (gst_structure_has_name (s, "application/x-rtp")) {
+ const gchar *encoding_name =
+ gst_structure_get_string (s, "encoding-name");
+ gint clock_rate;
+ gint pt;
+
+ if (gst_structure_get_int (s, "clock-rate", &clock_rate) &&
+ gst_structure_get_int (s, "payload", &pt)) {
+ if (!g_strcmp0 (encoding_name, "RED")) {
+ gchar *str;
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+ str = g_strdup_printf ("%u red/%d", pt, clock_rate);
+ *rtx_target_pt = pt;
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+ } else if (!g_strcmp0 (encoding_name, "ULPFEC")) {
+ gchar *str;
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+ str = g_strdup_printf ("%u ulpfec/%d", pt, clock_rate);
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+ }
+ }
+ }
+ }
+}
+
+static void
+_media_add_rtx (GstSDPMedia * media, WebRTCTransceiver * trans,
+ GstCaps * offer_caps, gint target_pt, guint target_ssrc)
+{
+ guint i;
+ const GstStructure *s;
+
+ if (trans->local_rtx_ssrc_map)
+ gst_structure_free (trans->local_rtx_ssrc_map);
+
+ trans->local_rtx_ssrc_map =
+ gst_structure_new_empty ("application/x-rtp-ssrc-map");
+
+ for (i = 0; i < gst_caps_get_size (offer_caps); i++) {
+ s = gst_caps_get_structure (offer_caps, i);
+
+ if (gst_structure_has_name (s, "application/x-rtp")) {
+ const gchar *encoding_name =
+ gst_structure_get_string (s, "encoding-name");
+ const gchar *apt_str = gst_structure_get_string (s, "apt");
+ gint apt;
+ gint clock_rate;
+ gint pt;
+
+ if (!apt_str)
+ continue;
+
+ apt = atoi (apt_str);
+
+ if (gst_structure_get_int (s, "clock-rate", &clock_rate) &&
+ gst_structure_get_int (s, "payload", &pt) && apt == target_pt) {
+ if (!g_strcmp0 (encoding_name, "RTX")) {
+ gchar *str;
+
+ str = g_strdup_printf ("%u", pt);
+ gst_sdp_media_add_format (media, str);
+ g_free (str);
+ str = g_strdup_printf ("%u rtx/%d", pt, clock_rate);
+ gst_sdp_media_add_attribute (media, "rtpmap", str);
+ g_free (str);
+
+ str = g_strdup_printf ("%d apt=%d", pt, apt);
+ gst_sdp_media_add_attribute (media, "fmtp", str);
+ g_free (str);
+
+ str = g_strdup_printf ("%u", target_ssrc);
+ gst_structure_set (trans->local_rtx_ssrc_map, str, G_TYPE_UINT,
+ g_random_int (), NULL);
+ }
+ }
+ }
+ }
+}
+
+static void
+_get_rtx_target_pt_and_ssrc_from_caps (GstCaps * answer_caps, gint * target_pt,
+ guint * target_ssrc)
+{
+ const GstStructure *s = gst_caps_get_structure (answer_caps, 0);
+
+ gst_structure_get_int (s, "payload", target_pt);
+ gst_structure_get_uint (s, "ssrc", target_ssrc);
+}
+
static GstSDPMessage *
_create_answer_task (GstWebRTCBin * webrtc, const GstStructure * options)
{
GstSDPMessage *ret = NULL;
const GstWebRTCSessionDescription *pending_remote =
webrtc->pending_remote_description;
- int i;
+ guint i;
if (!webrtc->pending_remote_description) {
GST_ERROR_OBJECT (webrtc,
@@ -1523,7 +1975,11 @@
GstWebRTCDTLSSetup offer_setup, answer_setup;
GstCaps *offer_caps, *answer_caps = NULL;
gchar *cert;
- int j;
+ guint j;
+ guint k;
+ gint target_pt = -1;
+ gint original_target_pt = -1;
+ guint target_ssrc = 0;
gst_sdp_media_new (&media);
gst_sdp_media_set_port_info (media, 9, 0);
@@ -1557,7 +2013,6 @@
for (j = 0; j < gst_sdp_media_formats_len (offer_media); j++) {
guint pt = atoi (gst_sdp_media_get_format (offer_media, j));
GstCaps *caps;
- int k;
caps = gst_sdp_media_get_caps_from_media (offer_media, pt);
@@ -1579,7 +2034,7 @@
rtp_trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
j);
- trans_caps = _find_codec_preferences (webrtc, rtp_trans, GST_PAD_SINK, i);
+ trans_caps = _find_codec_preferences (webrtc, rtp_trans, GST_PAD_SINK, j);
GST_TRACE_OBJECT (webrtc, "trying to compare %" GST_PTR_FORMAT
" and %" GST_PTR_FORMAT, offer_caps, trans_caps);
@@ -1621,21 +2076,44 @@
answer_dir = GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY;
answer_caps = gst_caps_ref (offer_caps);
}
- /* respond with the requested caps */
- if (answer_caps) {
- gst_sdp_media_set_media_from_caps (answer_caps, media);
- gst_caps_unref (answer_caps);
- answer_caps = NULL;
- }
+
if (!rtp_trans) {
- trans = _create_webrtc_transceiver (webrtc);
+ trans = _create_webrtc_transceiver (webrtc, answer_dir, i);
rtp_trans = GST_WEBRTC_RTP_TRANSCEIVER (trans);
- rtp_trans->direction = answer_dir;
- rtp_trans->mline = i;
} else {
trans = WEBRTC_TRANSCEIVER (rtp_trans);
}
+ if (!trans->do_nack) {
+ answer_caps = gst_caps_make_writable (answer_caps);
+ for (k = 0; k < gst_caps_get_size (answer_caps); k++) {
+ GstStructure *s = gst_caps_get_structure (answer_caps, k);
+ gst_structure_remove_fields (s, "rtcp-fb-nack", NULL);
+ }
+ }
+
+ gst_sdp_media_set_media_from_caps (answer_caps, media);
+
+ _get_rtx_target_pt_and_ssrc_from_caps (answer_caps, &target_pt,
+ &target_ssrc);
+
+ original_target_pt = target_pt;
+
+ _media_add_fec (media, trans, offer_caps, &target_pt);
+ if (trans->do_nack) {
+ _media_add_rtx (media, trans, offer_caps, target_pt, target_ssrc);
+ if (target_pt != original_target_pt)
+ _media_add_rtx (media, trans, offer_caps, original_target_pt,
+ target_ssrc);
+ }
+
+ if (answer_dir != GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY)
+ _media_add_ssrcs (media, answer_caps, webrtc,
+ WEBRTC_TRANSCEIVER (rtp_trans));
+
+ gst_caps_unref (answer_caps);
+ answer_caps = NULL;
+
/* set the new media direction */
offer_dir = _get_direction_from_media (offer_media);
answer_dir = _intersect_answer_directions (offer_dir, answer_dir);
@@ -1864,6 +2342,7 @@
gst_object_unref (rtp_sink);
trans = WEBRTC_TRANSCEIVER (pad->trans);
+
if (!trans->stream) {
TransportStream *item;
/* FIXME: bundle */
@@ -1958,6 +2437,16 @@
gst_webrtc_ice_add_candidate (webrtc->priv->ice, stream, item->candidate);
}
+static gboolean
+_filter_sdp_fields (GQuark field_id, const GValue * value,
+ GstStructure * new_structure)
+{
+ if (!g_str_has_prefix (g_quark_to_string (field_id), "a-")) {
+ gst_structure_id_set_value (new_structure, field_id, value);
+ }
+ return TRUE;
+}
+
static void
_update_transceiver_from_sdp_media (GstWebRTCBin * webrtc,
const GstSDPMessage * sdp, guint media_idx,
@@ -2037,6 +2526,7 @@
GstStructure *s;
PtMapItem item;
gint pt;
+ guint j;
pt = atoi (gst_sdp_media_get_format (media, i));
@@ -2056,9 +2546,24 @@
s = gst_caps_get_structure (outcaps, 0);
gst_structure_set_name (s, "application/x-rtp");
+ if (!g_strcmp0 (gst_structure_get_string (s, "encoding-name"),
+ "ULPFEC"))
+ gst_structure_set (s, "is-fec", G_TYPE_BOOLEAN, TRUE, NULL);
+
+ item.caps = gst_caps_new_empty ();
+
+ for (j = 0; j < gst_caps_get_size (outcaps); j++) {
+ GstStructure *s = gst_caps_get_structure (outcaps, j);
+ GstStructure *filtered =
+ gst_structure_new_empty (gst_structure_get_name (s));
+
+ gst_structure_foreach (s,
+ (GstStructureForeachFunc) _filter_sdp_fields, filtered);
+ gst_caps_append_structure (item.caps, filtered);
+ }
item.pt = pt;
- item.caps = outcaps;
+ gst_caps_unref (outcaps);
g_array_append_val (stream->ptmap, item);
}
@@ -2195,14 +2700,14 @@
} else {
trans = _find_transceiver (webrtc, NULL,
(FindTransceiverFunc) _find_compatible_unassociated_transceiver);
- if (!trans)
- trans =
- GST_WEBRTC_RTP_TRANSCEIVER (_create_webrtc_transceiver (webrtc));
/* XXX: default to the advertised direction in the sdp for new
* transceviers. The spec doesn't actually say what happens here, only
* that calls to setDirection will change the value. Nothing about
* a default value when the transceiver is created internally */
- trans->direction = _get_direction_from_media (media);
+ if (!trans)
+ trans =
+ GST_WEBRTC_RTP_TRANSCEIVER (_create_webrtc_transceiver (webrtc,
+ _get_direction_from_media (media), i));
_update_transceiver_from_sdp_media (webrtc, sdp->sdp, i, trans);
}
}
@@ -2433,11 +2938,24 @@
}
if (webrtc->signaling_state == GST_WEBRTC_SIGNALING_STATE_STABLE) {
+ GList *tmp;
gboolean prev_need_negotiation = webrtc->priv->need_negotiation;
/* media modifications */
_update_transceivers_from_sdp (webrtc, sd->source, sd->sdp);
+ for (tmp = webrtc->priv->pending_sink_transceivers; tmp; tmp = tmp->next) {
+ GstWebRTCBinPad *pad = GST_WEBRTC_BIN_PAD (tmp->data);
+
+ _connect_input_stream (webrtc, pad);
+ gst_pad_remove_probe (GST_PAD (pad), pad->block_id);
+ pad->block_id = 0;
+ }
+
+ g_list_free_full (webrtc->priv->pending_sink_transceivers,
+ (GDestroyNotify) gst_object_unref);
+ webrtc->priv->pending_sink_transceivers = NULL;
+
/* If connection's signaling state is now stable, update the
* negotiation-needed flag. If connection's [[ needNegotiation]] slot
* was true both before and after this update, queue a task to check
@@ -2737,9 +3255,8 @@
g_return_val_if_fail (direction != GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE,
NULL);
- trans = _create_webrtc_transceiver (webrtc);
+ trans = _create_webrtc_transceiver (webrtc, direction, -1);
rtp_trans = GST_WEBRTC_RTP_TRANSCEIVER (trans);
- rtp_trans->direction = direction;
if (caps)
rtp_trans->codec_preferences = gst_caps_ref (caps);
@@ -2858,14 +3375,266 @@
on_rtpbin_request_aux_sender (GstElement * rtpbin, guint session_id,
GstWebRTCBin * webrtc)
{
- return NULL;
+ TransportStream *stream;
+ GstStructure *pt_map = gst_structure_new_empty ("application/x-rtp-pt-map");
+ GstElement *ret = NULL;
+ GstWebRTCRTPTransceiver *trans;
+
+ stream = _find_transport_for_session (webrtc, session_id);
+ trans = _find_transceiver (webrtc, &session_id,
+ (FindTransceiverFunc) transceiver_match_for_mline);
+
+ if (stream) {
+ guint i;
+
+ for (i = 0; i < stream->ptmap->len; i++) {
+ PtMapItem *item = &g_array_index (stream->ptmap, PtMapItem, i);
+ if (!gst_caps_is_empty (item->caps)) {
+ GstStructure *s = gst_caps_get_structure (item->caps, 0);
+ gint pt;
+ const gchar *apt_str = gst_structure_get_string (s, "apt");
+
+ if (!apt_str)
+ continue;
+
+ if (!g_strcmp0 (gst_structure_get_string (s, "encoding-name"), "RTX") &&
+ gst_structure_get_int (s, "payload", &pt)) {
+ gst_structure_set (pt_map, apt_str, G_TYPE_UINT, pt, NULL);
+ }
+ }
+ }
+ }
+
+ if (gst_structure_n_fields (pt_map)) {
+ GstElement *rtx;
+ GstPad *pad;
+ gchar *name;
+
+ GST_INFO ("creating AUX sender");
+ ret = gst_bin_new (NULL);
+ rtx = gst_element_factory_make ("rtprtxsend", NULL);
+ g_object_set (rtx, "payload-type-map", pt_map, "max-size-packets", 500,
+ NULL);
+
+ if (WEBRTC_TRANSCEIVER (trans)->local_rtx_ssrc_map)
+ g_object_set (rtx, "ssrc-map",
+ WEBRTC_TRANSCEIVER (trans)->local_rtx_ssrc_map, NULL);
+
+ gst_bin_add (GST_BIN (ret), rtx);
+
+ pad = gst_element_get_static_pad (rtx, "src");
+ name = g_strdup_printf ("src_%u", session_id);
+ gst_element_add_pad (ret, gst_ghost_pad_new (name, pad));
+ g_free (name);
+ gst_object_unref (pad);
+
+ pad = gst_element_get_static_pad (rtx, "sink");
+ name = g_strdup_printf ("sink_%u", session_id);
+ gst_element_add_pad (ret, gst_ghost_pad_new (name, pad));
+ g_free (name);
+ gst_object_unref (pad);
+ }
+
+ gst_structure_free (pt_map);
+
+ return ret;
}
static GstElement *
on_rtpbin_request_aux_receiver (GstElement * rtpbin, guint session_id,
GstWebRTCBin * webrtc)
{
- return NULL;
+ GstElement *ret = NULL;
+ GstElement *prev = NULL;
+ GstPad *sinkpad = NULL;
+ TransportStream *stream;
+ gint red_pt = 0;
+ gint rtx_pt = 0;
+
+ stream = _find_transport_for_session (webrtc, session_id);
+
+ if (stream) {
+ red_pt = _transport_stream_get_pt (stream, "RED");
+ rtx_pt = _transport_stream_get_pt (stream, "RTX");
+ }
+
+ if (red_pt || rtx_pt)
+ ret = gst_bin_new (NULL);
+
+ if (rtx_pt) {
+ GstCaps *rtx_caps = _transport_stream_get_caps_for_pt (stream, rtx_pt);
+ GstElement *rtx = gst_element_factory_make ("rtprtxreceive", NULL);
+ GstStructure *pt_map;
+ const GstStructure *s = gst_caps_get_structure (rtx_caps, 0);
+
+ gst_bin_add (GST_BIN (ret), rtx);
+
+ pt_map = gst_structure_new_empty ("application/x-rtp-pt-map");
+ gst_structure_set (pt_map, gst_structure_get_string (s, "apt"), G_TYPE_UINT,
+ rtx_pt, NULL);
+ g_object_set (rtx, "payload-type-map", pt_map, NULL);
+
+ sinkpad = gst_element_get_static_pad (rtx, "sink");
+
+ prev = rtx;
+ }
+
+ if (red_pt) {
+ GstElement *rtpreddec = gst_element_factory_make ("rtpreddec", NULL);
+
+ GST_DEBUG_OBJECT (webrtc, "Creating RED decoder for pt %d in session %u",
+ red_pt, session_id);
+
+ gst_bin_add (GST_BIN (ret), rtpreddec);
+
+ g_object_set (rtpreddec, "pt", red_pt, NULL);
+
+ if (prev)
+ gst_element_link (prev, rtpreddec);
+ else
+ sinkpad = gst_element_get_static_pad (rtpreddec, "sink");
+
+ prev = rtpreddec;
+ }
+
+ if (sinkpad) {
+ gchar *name = g_strdup_printf ("sink_%u", session_id);
+ GstPad *ghost = gst_ghost_pad_new (name, sinkpad);
+ g_free (name);
+ gst_object_unref (sinkpad);
+ gst_element_add_pad (ret, ghost);
+ }
+
+ if (prev) {
+ gchar *name = g_strdup_printf ("src_%u", session_id);
+ GstPad *srcpad = gst_element_get_static_pad (prev, "src");
+ GstPad *ghost = gst_ghost_pad_new (name, srcpad);
+ g_free (name);
+ gst_object_unref (srcpad);
+ gst_element_add_pad (ret, ghost);
+ }
+
+ return ret;
+}
+
+static GstElement *
+on_rtpbin_request_fec_decoder (GstElement * rtpbin, guint session_id,
+ GstWebRTCBin * webrtc)
+{
+ TransportStream *stream;
+ GstElement *ret = NULL;
+ gint pt = 0;
+ GObject *internal_storage;
+
+ stream = _find_transport_for_session (webrtc, session_id);
+
+ /* TODO: for now, we only support ulpfec, but once we support
+ * more algorithms, if the remote may use more than one algorithm,
+ * we will want to do the following:
+ *
+ * + Return a bin here, with the relevant FEC decoders plugged in
+ * and their payload type set to 0
+ * + Enable the decoders by setting the payload type only when
+ * we detect it (by connecting to ptdemux:new-payload-type for
+ * example)
+ */
+ if (stream)
+ pt = _transport_stream_get_pt (stream, "ULPFEC");
+
+ if (pt) {
+ GST_DEBUG_OBJECT (webrtc, "Creating ULPFEC decoder for pt %d in session %u",
+ pt, session_id);
+ ret = gst_element_factory_make ("rtpulpfecdec", NULL);
+ g_signal_emit_by_name (webrtc->rtpbin, "get-internal-storage", session_id,
+ &internal_storage);
+
+ g_object_set (ret, "pt", pt, "storage", internal_storage, NULL);
+ g_object_unref (internal_storage);
+ }
+
+ return ret;
+}
+
+static GstElement *
+on_rtpbin_request_fec_encoder (GstElement * rtpbin, guint session_id,
+ GstWebRTCBin * webrtc)
+{
+ GstElement *ret = NULL;
+ GstElement *prev = NULL;
+ TransportStream *stream;
+ guint ulpfec_pt = 0;
+ guint red_pt = 0;
+ GstPad *sinkpad = NULL;
+ GstWebRTCRTPTransceiver *trans;
+
+ stream = _find_transport_for_session (webrtc, session_id);
+ trans = _find_transceiver (webrtc, &session_id,
+ (FindTransceiverFunc) transceiver_match_for_mline);
+
+ if (stream) {
+ ulpfec_pt = _transport_stream_get_pt (stream, "ULPFEC");
+ red_pt = _transport_stream_get_pt (stream, "RED");
+ }
+
+ if (ulpfec_pt || red_pt)
+ ret = gst_bin_new (NULL);
+
+ if (ulpfec_pt) {
+ GstElement *fecenc = gst_element_factory_make ("rtpulpfecenc", NULL);
+ GstCaps *caps = _transport_stream_get_caps_for_pt (stream, ulpfec_pt);
+
+ GST_DEBUG_OBJECT (webrtc,
+ "Creating ULPFEC encoder for session %d with pt %d", session_id,
+ ulpfec_pt);
+
+ gst_bin_add (GST_BIN (ret), fecenc);
+ sinkpad = gst_element_get_static_pad (fecenc, "sink");
+ g_object_set (fecenc, "pt", ulpfec_pt, "percentage",
+ WEBRTC_TRANSCEIVER (trans)->fec_percentage, NULL);
+
+
+ if (caps && !gst_caps_is_empty (caps)) {
+ const GstStructure *s = gst_caps_get_structure (caps, 0);
+ const gchar *media = gst_structure_get_string (s, "media");
+
+ if (!g_strcmp0 (media, "video"))
+ g_object_set (fecenc, "multipacket", TRUE, NULL);
+ }
+
+ prev = fecenc;
+ }
+
+ if (red_pt) {
+ GstElement *redenc = gst_element_factory_make ("rtpredenc", NULL);
+
+ GST_DEBUG_OBJECT (webrtc, "Creating RED encoder for session %d with pt %d",
+ session_id, red_pt);
+
+ gst_bin_add (GST_BIN (ret), redenc);
+ if (prev)
+ gst_element_link (prev, redenc);
+ else
+ sinkpad = gst_element_get_static_pad (redenc, "sink");
+
+ g_object_set (redenc, "pt", red_pt, "allow-no-red-blocks", TRUE, NULL);
+
+ prev = redenc;
+ }
+
+ if (sinkpad) {
+ GstPad *ghost = gst_ghost_pad_new ("sink", sinkpad);
+ gst_object_unref (sinkpad);
+ gst_element_add_pad (ret, ghost);
+ }
+
+ if (prev) {
+ GstPad *srcpad = gst_element_get_static_pad (prev, "src");
+ GstPad *ghost = gst_ghost_pad_new ("src", srcpad);
+ gst_object_unref (srcpad);
+ gst_element_add_pad (ret, ghost);
+ }
+
+ return ret;
}
static void
@@ -2878,6 +3647,26 @@
on_rtpbin_new_jitterbuffer (GstElement * rtpbin, GstElement * jitterbuffer,
guint session_id, guint ssrc, GstWebRTCBin * webrtc)
{
+ GstWebRTCRTPTransceiver *trans;
+
+ trans = _find_transceiver (webrtc, &session_id,
+ (FindTransceiverFunc) transceiver_match_for_mline);
+
+ if (trans) {
+ /* We don't set do-retransmission on rtpbin as we want per-session control */
+ g_object_set (jitterbuffer, "do-retransmission",
+ WEBRTC_TRANSCEIVER (trans)->do_nack, NULL);
+ } else {
+ g_assert_not_reached ();
+ }
+}
+
+static void
+on_rtpbin_new_storage (GstElement * rtpbin, GstElement * storage,
+ guint session_id, GstWebRTCBin * webrtc)
+{
+ /* TODO: when exposing latency, set size-time based on that */
+ g_object_set (storage, "size-time", 250 * GST_MSECOND, NULL);
}
static GstElement *
@@ -2891,6 +3680,8 @@
/* mandated by WebRTC */
gst_util_set_object_arg (G_OBJECT (rtpbin), "rtp-profile", "savpf");
+ g_object_set (rtpbin, "do-lost", TRUE, NULL);
+
g_signal_connect (rtpbin, "pad-added", G_CALLBACK (on_rtpbin_pad_added),
webrtc);
g_signal_connect (rtpbin, "request-pt-map",
@@ -2899,6 +3690,12 @@
G_CALLBACK (on_rtpbin_request_aux_sender), webrtc);
g_signal_connect (rtpbin, "request-aux-receiver",
G_CALLBACK (on_rtpbin_request_aux_receiver), webrtc);
+ g_signal_connect (rtpbin, "new-storage",
+ G_CALLBACK (on_rtpbin_new_storage), webrtc);
+ g_signal_connect (rtpbin, "request-fec-decoder",
+ G_CALLBACK (on_rtpbin_request_fec_decoder), webrtc);
+ g_signal_connect (rtpbin, "request-fec-encoder",
+ G_CALLBACK (on_rtpbin_request_fec_encoder), webrtc);
g_signal_connect (rtpbin, "on-ssrc-active",
G_CALLBACK (on_rtpbin_ssrc_active), webrtc);
g_signal_connect (rtpbin, "new-jitterbuffer",
@@ -2974,6 +3771,14 @@
return ret;
}
+static GstPadProbeReturn
+pad_block (GstPad * pad, GstPadProbeInfo * info, gpointer unused)
+{
+ GST_LOG_OBJECT (pad, "blocking pad with data %" GST_PTR_FORMAT, info->data);
+
+ return GST_PAD_PROBE_OK;
+}
+
static GstPad *
gst_webrtc_bin_request_new_pad (GstElement * element, GstPadTemplate * templ,
const gchar * name, const GstCaps * caps)
@@ -3019,15 +3824,18 @@
pad = _create_pad_for_sdp_media (webrtc, GST_PAD_SINK, serial);
trans = _find_transceiver_for_mline (webrtc, serial);
- if (!(trans =
- GST_WEBRTC_RTP_TRANSCEIVER (_create_webrtc_transceiver (webrtc)))) {
- trans->direction = GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV;
- trans->mline = serial;
- }
+ if (!trans)
+ trans =
+ GST_WEBRTC_RTP_TRANSCEIVER (_create_webrtc_transceiver (webrtc,
+ GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV, serial));
pad->trans = gst_object_ref (trans);
- _connect_input_stream (webrtc, pad);
- /* TODO: update negotiation-needed */
+ pad->block_id = gst_pad_add_probe (GST_PAD (pad), GST_PAD_PROBE_TYPE_BLOCK |
+ GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_BUFFER_LIST,
+ (GstPadProbeCallback) pad_block, NULL, NULL);
+ webrtc->priv->pending_sink_transceivers =
+ g_list_append (webrtc->priv->pending_sink_transceivers,
+ gst_object_ref (pad));
_add_pad (webrtc, pad);
}
@@ -3173,6 +3981,11 @@
(GDestroyNotify) _free_pending_pad);
webrtc->priv->pending_pads = NULL;
+ if (webrtc->priv->pending_sink_transceivers)
+ g_list_free_full (webrtc->priv->pending_sink_transceivers,
+ (GDestroyNotify) gst_object_unref);
+ webrtc->priv->pending_sink_transceivers = NULL;
+
if (webrtc->current_local_description)
gst_webrtc_session_description_free (webrtc->current_local_description);
webrtc->current_local_description = NULL;
@@ -3206,7 +4019,8 @@
element_class->release_pad = gst_webrtc_bin_release_pad;
element_class->change_state = gst_webrtc_bin_change_state;
- gst_element_class_add_static_pad_template (element_class, &sink_template);
+ gst_element_class_add_static_pad_template_with_gtype (element_class,
+ &sink_template, GST_TYPE_WEBRTC_BIN_PAD);
gst_element_class_add_static_pad_template (element_class, &src_template);
gst_element_class_set_metadata (element_class, "WebRTC Bin",
@@ -3437,6 +4251,16 @@
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING);
/**
+ * GstWebRTCBin::on-new-transceiver:
+ * @object: the #GstWebRtcBin
+ * @candidate: the new #GstWebRTCRTPTransceiver
+ */
+ gst_webrtc_bin_signals[ON_NEW_TRANSCEIVER_SIGNAL] =
+ g_signal_new ("on-new-transceiver", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 1, GST_TYPE_WEBRTC_RTP_TRANSCEIVER);
+
+ /**
* GstWebRTCBin::add-transceiver:
* @object: the #GstWebRtcBin
* @direction: the direction of the new transceiver
diff --git a/ext/webrtc/gstwebrtcbin.h b/ext/webrtc/gstwebrtcbin.h
index bbcc5f5..49603ec 100644
--- a/ext/webrtc/gstwebrtcbin.h
+++ b/ext/webrtc/gstwebrtcbin.h
@@ -57,6 +57,9 @@
guint mlineindex;
GstWebRTCRTPTransceiver *trans;
+ gulong block_id;
+
+ GstCaps *received_caps;
};
struct _GstWebRTCBinPadClass
@@ -125,6 +128,7 @@
gboolean async_pending;
GList *pending_pads;
+ GList *pending_sink_transceivers;
/* count of the number of media streams we've offered for uniqueness */
/* FIXME: overflow? */
diff --git a/ext/webrtc/webrtctransceiver.c b/ext/webrtc/webrtctransceiver.c
index 310956f..1735b1a 100644
--- a/ext/webrtc/webrtctransceiver.c
+++ b/ext/webrtc/webrtctransceiver.c
@@ -29,10 +29,17 @@
G_DEFINE_TYPE (WebRTCTransceiver, webrtc_transceiver,
GST_TYPE_WEBRTC_RTP_TRANSCEIVER);
+#define DEFAULT_FEC_TYPE GST_WEBRTC_FEC_TYPE_NONE
+#define DEFAULT_DO_NACK FALSE
+#define DEFAULT_FEC_PERCENTAGE 100
+
enum
{
PROP_0,
PROP_WEBRTC,
+ PROP_FEC_TYPE,
+ PROP_FEC_PERCENTAGE,
+ PROP_DO_NACK,
};
void
@@ -78,6 +85,15 @@
switch (prop_id) {
case PROP_WEBRTC:
break;
+ case PROP_FEC_TYPE:
+ trans->fec_type = g_value_get_enum (value);
+ break;
+ case PROP_DO_NACK:
+ trans->do_nack = g_value_get_boolean (value);
+ break;
+ case PROP_FEC_PERCENTAGE:
+ trans->fec_percentage = g_value_get_uint (value);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
@@ -93,6 +109,15 @@
GST_OBJECT_LOCK (trans);
switch (prop_id) {
+ case PROP_FEC_TYPE:
+ g_value_set_enum (value, trans->fec_type);
+ break;
+ case PROP_DO_NACK:
+ g_value_set_boolean (value, trans->do_nack);
+ break;
+ case PROP_FEC_PERCENTAGE:
+ g_value_set_uint (value, trans->fec_percentage);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
@@ -109,6 +134,10 @@
gst_object_unref (trans->stream);
trans->stream = NULL;
+ if (trans->local_rtx_ssrc_map)
+ gst_structure_free (trans->local_rtx_ssrc_map);
+ trans->local_rtx_ssrc_map = NULL;
+
G_OBJECT_CLASS (parent_class)->finalize (object);
}
@@ -129,6 +158,28 @@
"Parent webrtcbin",
GST_TYPE_WEBRTC_BIN,
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class,
+ PROP_FEC_TYPE,
+ g_param_spec_enum ("fec-type", "FEC type",
+ "The type of Forward Error Correction to use",
+ GST_TYPE_WEBRTC_FEC_TYPE,
+ DEFAULT_FEC_TYPE,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class,
+ PROP_DO_NACK,
+ g_param_spec_boolean ("do-nack", "Do nack",
+ "Whether to send negative acknowledgements for feedback",
+ DEFAULT_DO_NACK,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class,
+ PROP_FEC_PERCENTAGE,
+ g_param_spec_uint ("fec-percentage", "FEC percentage",
+ "The amount of Forward Error Correction to apply",
+ 0, 100, DEFAULT_FEC_PERCENTAGE,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
static void
diff --git a/ext/webrtc/webrtctransceiver.h b/ext/webrtc/webrtctransceiver.h
index b90fea0..25bb24e 100644
--- a/ext/webrtc/webrtctransceiver.h
+++ b/ext/webrtc/webrtctransceiver.h
@@ -38,6 +38,12 @@
GstWebRTCRTPTransceiver parent;
TransportStream *stream;
+ GstStructure *local_rtx_ssrc_map;
+
+ /* Properties */
+ GstWebRTCFECType fec_type;
+ guint fec_percentage;
+ gboolean do_nack;
};
struct _WebRTCTransceiverClass
diff --git a/gst-libs/gst/webrtc/webrtc_fwd.h b/gst-libs/gst/webrtc/webrtc_fwd.h
index 6b8364d..be0a3c3 100644
--- a/gst-libs/gst/webrtc/webrtc_fwd.h
+++ b/gst-libs/gst/webrtc/webrtc_fwd.h
@@ -253,4 +253,15 @@
GST_WEBRTC_STATS_CERTIFICATE,
} GstWebRTCStatsType;
+/**
+ * GstWebRTCFECType:
+ * GST_WEBRTC_FEC_TYPE_NONE: none
+ * GST_WEBRTC_FEC_TYPE_ULP_RED: ulpfec + red
+ */
+typedef enum /*< underscore_name=gst_webrtc_fec_type >*/
+{
+ GST_WEBRTC_FEC_TYPE_NONE,
+ GST_WEBRTC_FEC_TYPE_ULP_RED,
+} GstWebRTCFECType;
+
#endif /* __GST_WEBRTC_FWD_H__ */
diff --git a/tests/check/elements/webrtcbin.c b/tests/check/elements/webrtcbin.c
index b7f42e0..756f380 100644
--- a/tests/check/elements/webrtcbin.c
+++ b/tests/check/elements/webrtcbin.c
@@ -822,6 +822,67 @@
GST_END_TEST;
static void
+on_sdp_media_payload_types (struct test_webrtc *t, GstElement * element,
+ GstWebRTCSessionDescription * desc, gpointer user_data)
+{
+ const GstSDPMedia *vmedia;
+ guint j;
+
+ fail_unless_equals_int (gst_sdp_message_medias_len (desc->sdp), 2);
+
+ vmedia = gst_sdp_message_get_media (desc->sdp, 1);
+
+ for (j = 0; j < gst_sdp_media_attributes_len (vmedia); j++) {
+ const GstSDPAttribute *attr = gst_sdp_media_get_attribute (vmedia, j);
+
+ if (!g_strcmp0 (attr->key, "rtpmap")) {
+ if (g_str_has_prefix (attr->value, "97")) {
+ fail_unless_equals_string (attr->value, "97 VP8/90000");
+ } else if (g_str_has_prefix (attr->value, "96")) {
+ fail_unless_equals_string (attr->value, "96 red/90000");
+ } else if (g_str_has_prefix (attr->value, "98")) {
+ fail_unless_equals_string (attr->value, "98 ulpfec/90000");
+ } else if (g_str_has_prefix (attr->value, "99")) {
+ fail_unless_equals_string (attr->value, "99 rtx/90000");
+ } else if (g_str_has_prefix (attr->value, "100")) {
+ fail_unless_equals_string (attr->value, "100 rtx/90000");
+ }
+ }
+ }
+}
+
+/* In this test we verify that webrtcbin will pick available payload
+ * types when it needs to, in that example for RTX and FEC */
+GST_START_TEST (test_payload_types)
+{
+ struct test_webrtc *t = create_audio_video_test ();
+ struct validate_sdp offer = { on_sdp_media_payload_types, NULL };
+ GstWebRTCRTPTransceiver *trans;
+ GArray *transceivers;
+
+ t->offer_data = &offer;
+ t->on_offer_created = validate_sdp;
+ t->on_ice_candidate = NULL;
+ /* We don't really care about the answer here */
+ t->on_answer_created = NULL;
+
+ g_signal_emit_by_name (t->webrtc1, "get-transceivers", &transceivers);
+ fail_unless_equals_int (transceivers->len, 2);
+ trans = g_array_index (transceivers, GstWebRTCRTPTransceiver *, 1);
+ g_object_set (trans, "fec-type", GST_WEBRTC_FEC_TYPE_ULP_RED, "do-nack", TRUE,
+ NULL);
+ g_array_unref (transceivers);
+
+ test_webrtc_create_offer (t, t->webrtc1);
+
+ test_webrtc_wait_for_answer_error_eos (t);
+ fail_unless_equals_int (STATE_ANSWER_CREATED, t->state);
+ test_webrtc_free (t);
+}
+
+GST_END_TEST;
+
+static void
on_sdp_media_setup (struct test_webrtc *t, GstElement * element,
GstWebRTCSessionDescription * desc, gpointer user_data)
{
@@ -1367,6 +1428,7 @@
tcase_add_test (tc, test_get_transceivers);
tcase_add_test (tc, test_add_recvonly_transceiver);
tcase_add_test (tc, test_recvonly_sendonly);
+ tcase_add_test (tc, test_payload_types);
}
if (nicesrc)
diff --git a/tests/examples/webrtc/Makefile.am b/tests/examples/webrtc/Makefile.am
index 520942d..6323263 100644
--- a/tests/examples/webrtc/Makefile.am
+++ b/tests/examples/webrtc/Makefile.am
@@ -1,5 +1,5 @@
-noinst_PROGRAMS = webrtc webrtcbidirectional webrtcswap
+noinst_PROGRAMS = webrtc webrtcbidirectional webrtcswap webrtctransceiver
webrtc_SOURCES = webrtc.c
webrtc_CFLAGS=\
@@ -39,3 +39,16 @@
$(GST_LIBS) \
$(GST_SDP_LIBS) \
$(top_builddir)/gst-libs/gst/webrtc/libgstwebrtc-@GST_API_VERSION@.la
+
+webrtctransceiver_SOURCES = webrtctransceiver.c
+webrtctransceiver_CFLAGS=\
+ -I$(top_srcdir)/gst-libs \
+ -I$(top_builddir)/gst-libs \
+ $(GST_PLUGINS_BASE_CFLAGS) \
+ $(GST_CFLAGS) \
+ $(GST_SDP_CFLAGS)
+webrtctransceiver_LDADD=\
+ $(GST_PLUGINS_BASE_LIBS) \
+ $(GST_LIBS) \
+ $(GST_SDP_LIBS) \
+ $(top_builddir)/gst-libs/gst/webrtc/libgstwebrtc-@GST_API_VERSION@.la
diff --git a/tests/examples/webrtc/meson.build b/tests/examples/webrtc/meson.build
index 7c2aab7..90c15e5 100644
--- a/tests/examples/webrtc/meson.build
+++ b/tests/examples/webrtc/meson.build
@@ -1,4 +1,4 @@
-examples = ['webrtc', 'webrtcbidirectional', 'webrtcswap']
+examples = ['webrtc', 'webrtcbidirectional', 'webrtcswap', 'webrtctransceiver']
foreach example : examples
exe_name = example
diff --git a/tests/examples/webrtc/webrtctransceiver.c b/tests/examples/webrtc/webrtctransceiver.c
new file mode 100644
index 0000000..df1a18e
--- /dev/null
+++ b/tests/examples/webrtc/webrtctransceiver.c
@@ -0,0 +1,218 @@
+#include <gst/gst.h>
+#include <gst/sdp/sdp.h>
+#include <gst/webrtc/webrtc.h>
+
+#include <string.h>
+
+static GMainLoop *loop;
+static GstElement *pipe1, *webrtc1, *webrtc2;
+static GstBus *bus1;
+
+static gboolean
+_bus_watch (GstBus * bus, GstMessage * msg, GstElement * pipe)
+{
+ switch (GST_MESSAGE_TYPE (msg)) {
+ case GST_MESSAGE_STATE_CHANGED:
+ if (GST_ELEMENT (msg->src) == pipe) {
+ GstState old, new, pending;
+
+ gst_message_parse_state_changed (msg, &old, &new, &pending);
+
+ {
+ gchar *dump_name = g_strconcat ("state_changed-",
+ gst_element_state_get_name (old), "_",
+ gst_element_state_get_name (new), NULL);
+ GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (msg->src),
+ GST_DEBUG_GRAPH_SHOW_ALL, dump_name);
+ g_free (dump_name);
+ }
+ }
+ break;
+ case GST_MESSAGE_ERROR:{
+ GError *err = NULL;
+ gchar *dbg_info = NULL;
+
+ GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipe),
+ GST_DEBUG_GRAPH_SHOW_ALL, "error");
+
+ gst_message_parse_error (msg, &err, &dbg_info);
+ g_printerr ("ERROR from element %s: %s\n",
+ GST_OBJECT_NAME (msg->src), err->message);
+ g_printerr ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none");
+ g_error_free (err);
+ g_free (dbg_info);
+ g_main_loop_quit (loop);
+ break;
+ }
+ case GST_MESSAGE_EOS:{
+ GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipe),
+ GST_DEBUG_GRAPH_SHOW_ALL, "eos");
+ g_print ("EOS received\n");
+ g_main_loop_quit (loop);
+ break;
+ }
+ default:
+ break;
+ }
+
+ return TRUE;
+}
+
+static void
+_webrtc_pad_added (GstElement * webrtc, GstPad * new_pad, GstElement * pipe)
+{
+ GstElement *out;
+ GstPad *sink;
+
+ if (GST_PAD_DIRECTION (new_pad) != GST_PAD_SRC)
+ return;
+
+ out = gst_parse_bin_from_description ("rtpvp8depay ! vp8dec ! "
+ "videoconvert ! queue ! xvimagesink", TRUE, NULL);
+ gst_bin_add (GST_BIN (pipe), out);
+ gst_element_sync_state_with_parent (out);
+
+ sink = out->sinkpads->data;
+
+ gst_pad_link (new_pad, sink);
+}
+
+static void
+_on_answer_received (GstPromise * promise, gpointer user_data)
+{
+ GstWebRTCSessionDescription *answer = NULL;
+ const GstStructure *reply;
+ gchar *desc;
+
+ g_assert (gst_promise_wait (promise) == GST_PROMISE_RESULT_REPLIED);
+ reply = gst_promise_get_reply (promise);
+ gst_structure_get (reply, "answer",
+ GST_TYPE_WEBRTC_SESSION_DESCRIPTION, &answer, NULL);
+ gst_promise_unref (promise);
+ desc = gst_sdp_message_as_text (answer->sdp);
+ g_print ("Created answer:\n%s\n", desc);
+ g_free (desc);
+
+ g_signal_emit_by_name (webrtc1, "set-remote-description", answer, NULL);
+ g_signal_emit_by_name (webrtc2, "set-local-description", answer, NULL);
+
+ gst_webrtc_session_description_free (answer);
+}
+
+static void
+_on_offer_received (GstPromise * promise, gpointer user_data)
+{
+ GstWebRTCSessionDescription *offer = NULL;
+ const GstStructure *reply;
+ gchar *desc;
+
+ g_assert (gst_promise_wait (promise) == GST_PROMISE_RESULT_REPLIED);
+ reply = gst_promise_get_reply (promise);
+ gst_structure_get (reply, "offer",
+ GST_TYPE_WEBRTC_SESSION_DESCRIPTION, &offer, NULL);
+ gst_promise_unref (promise);
+ desc = gst_sdp_message_as_text (offer->sdp);
+ g_print ("Created offer:\n%s\n", desc);
+ g_free (desc);
+
+ g_signal_emit_by_name (webrtc1, "set-local-description", offer, NULL);
+ g_signal_emit_by_name (webrtc2, "set-remote-description", offer, NULL);
+
+ promise = gst_promise_new_with_change_func (_on_answer_received, user_data,
+ NULL);
+ g_signal_emit_by_name (webrtc2, "create-answer", NULL, promise);
+
+ gst_webrtc_session_description_free (offer);
+}
+
+static void
+_on_negotiation_needed (GstElement * element, gpointer user_data)
+{
+ GstPromise *promise;
+
+ promise = gst_promise_new_with_change_func (_on_offer_received, user_data,
+ NULL);
+ g_signal_emit_by_name (webrtc1, "create-offer", NULL, promise);
+}
+
+static void
+_on_ice_candidate (GstElement * webrtc, guint mlineindex, gchar * candidate,
+ GstElement * other)
+{
+ g_signal_emit_by_name (other, "add-ice-candidate", mlineindex, candidate);
+}
+
+static void
+_on_new_transceiver (GstElement * webrtc, GstWebRTCRTPTransceiver * trans)
+{
+ /* If we expected more than one transceiver, we would take a look at
+ * trans->mline, and compare it with webrtcbin's local description */
+ g_object_set (trans, "fec-type", GST_WEBRTC_FEC_TYPE_ULP_RED, NULL);
+}
+
+static void
+add_fec_to_offer (GstElement * webrtc)
+{
+ GstWebRTCRTPTransceiver *trans;
+ GArray *transceivers;
+
+ /* A transceiver has already been created when a sink pad was
+ * requested on the sending webrtcbin */
+
+ g_signal_emit_by_name (webrtc, "get-transceivers", &transceivers);
+
+ trans = g_array_index (transceivers, GstWebRTCRTPTransceiver *, 0);
+
+ g_object_set (trans, "fec-type", GST_WEBRTC_FEC_TYPE_ULP_RED,
+ "fec-percentage", 100, NULL);
+
+ g_array_unref (transceivers);
+}
+
+int
+main (int argc, char *argv[])
+{
+ gst_init (&argc, &argv);
+
+ loop = g_main_loop_new (NULL, FALSE);
+ pipe1 =
+ gst_parse_launch
+ ("videotestsrc pattern=ball ! video/x-raw ! queue ! vp8enc ! rtpvp8pay ! queue ! "
+ "application/x-rtp,media=video,payload=96,encoding-name=VP8 ! "
+ "webrtcbin name=send webrtcbin name=recv", NULL);
+ bus1 = gst_pipeline_get_bus (GST_PIPELINE (pipe1));
+ gst_bus_add_watch (bus1, (GstBusFunc) _bus_watch, pipe1);
+
+ webrtc1 = gst_bin_get_by_name (GST_BIN (pipe1), "send");
+ g_signal_connect (webrtc1, "on-negotiation-needed",
+ G_CALLBACK (_on_negotiation_needed), NULL);
+ add_fec_to_offer (webrtc1);
+
+ webrtc2 = gst_bin_get_by_name (GST_BIN (pipe1), "recv");
+ g_signal_connect (webrtc2, "pad-added", G_CALLBACK (_webrtc_pad_added),
+ pipe1);
+ g_signal_connect (webrtc1, "on-ice-candidate",
+ G_CALLBACK (_on_ice_candidate), webrtc2);
+ g_signal_connect (webrtc2, "on-ice-candidate",
+ G_CALLBACK (_on_ice_candidate), webrtc1);
+ g_signal_connect (webrtc2, "on-new-transceiver",
+ G_CALLBACK (_on_new_transceiver), NULL);
+
+ g_print ("Starting pipeline\n");
+ gst_element_set_state (GST_ELEMENT (pipe1), GST_STATE_PLAYING);
+
+ g_main_loop_run (loop);
+
+ gst_element_set_state (GST_ELEMENT (pipe1), GST_STATE_NULL);
+ g_print ("Pipeline stopped\n");
+
+ gst_object_unref (webrtc1);
+ gst_object_unref (webrtc2);
+ gst_bus_remove_watch (bus1);
+ gst_object_unref (bus1);
+ gst_object_unref (pipe1);
+
+ gst_deinit ();
+
+ return 0;
+}
