gstreamer/ext/webrtc/gstwebrtcbin.c
Matthew Waters ffeb09e4ab webrtc: bail on invalid rtpbin names
If we fail parsing rtpbin pad names, someone has screwed up so critical
and return.

CID #1429142
2018-02-08 15:29:56 +11:00

3533 lines
111 KiB
C

/* GStreamer
* Copyright (C) 2017 Matthew Waters <matthew@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 St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "gstwebrtcbin.h"
#include "gstwebrtcstats.h"
#include "transportstream.h"
#include "transportreceivebin.h"
#include "utils.h"
#include "webrtcsdp.h"
#include "webrtctransceiver.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define RANDOM_SESSION_ID \
((((((guint64) g_random_int()) << 32) | \
(guint64) g_random_int ())) & \
G_GUINT64_CONSTANT (0x7fffffffffffffff))
#define PC_GET_LOCK(w) (&w->priv->pc_lock)
#define PC_LOCK(w) (g_mutex_lock (PC_GET_LOCK(w)))
#define PC_UNLOCK(w) (g_mutex_unlock (PC_GET_LOCK(w)))
#define PC_GET_COND(w) (&w->priv->pc_cond)
#define PC_COND_WAIT(w) (g_cond_wait(PC_GET_COND(w), PC_GET_LOCK(w)))
#define PC_COND_BROADCAST(w) (g_cond_broadcast(PC_GET_COND(w)))
#define PC_COND_SIGNAL(w) (g_cond_signal(PC_GET_COND(w)))
/*
* This webrtcbin implements the majority of the W3's peerconnection API and
* implementation guide where possible. Generating offers, answers and setting
* local and remote SDP's are all supported. To start with, only the media
* interface has been implemented (no datachannel yet).
*
* Each input/output pad is equivalent to a Track in W3 parlance which are
* added/removed from the bin. The number of requested sink pads is the number
* of streams that will be sent to the receiver and will be associated with a
* GstWebRTCRTPTransceiver (very similar to W3 RTPTransceiver's).
*
* On the receiving side, RTPTransceiver's are created in response to setting
* a remote description. Output pads for the receiving streams in the set
* description are also created.
*/
/*
* TODO:
* assert sending payload type matches the stream
* reconfiguration (of anything)
* LS groups
* bundling
* setting custom DTLS certificates
* data channel
*
* seperate session id's from mlineindex properly
* how to deal with replacing a input/output track/stream
*/
#define GST_CAT_DEFAULT gst_webrtc_bin_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
GQuark
gst_webrtc_bin_error_quark (void)
{
return g_quark_from_static_string ("gst-webrtc-bin-error-quark");
}
G_DEFINE_TYPE (GstWebRTCBinPad, gst_webrtc_bin_pad, GST_TYPE_GHOST_PAD);
static void
gst_webrtc_bin_pad_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_webrtc_bin_pad_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_webrtc_bin_pad_finalize (GObject * object)
{
GstWebRTCBinPad *pad = GST_WEBRTC_BIN_PAD (object);
if (pad->trans)
gst_object_unref (pad->trans);
pad->trans = NULL;
G_OBJECT_CLASS (gst_webrtc_bin_pad_parent_class)->finalize (object);
}
static void
gst_webrtc_bin_pad_class_init (GstWebRTCBinPadClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
gobject_class->get_property = gst_webrtc_bin_pad_get_property;
gobject_class->set_property = gst_webrtc_bin_pad_set_property;
gobject_class->finalize = gst_webrtc_bin_pad_finalize;
}
static GstCaps *
_transport_stream_get_caps_for_pt (TransportStream * stream, guint pt)
{
guint i, len;
len = stream->ptmap->len;
for (i = 0; i < len; i++) {
PtMapItem *item = &g_array_index (stream->ptmap, PtMapItem, i);
if (item->pt == pt)
return item->caps;
}
return NULL;
}
static void
gst_webrtc_bin_pad_init (GstWebRTCBinPad * pad)
{
}
static GstWebRTCBinPad *
gst_webrtc_bin_pad_new (const gchar * name, GstPadDirection direction)
{
GstWebRTCBinPad *pad =
g_object_new (gst_webrtc_bin_pad_get_type (), "name", name, "direction",
direction, NULL);
if (!gst_ghost_pad_construct (GST_GHOST_PAD (pad))) {
gst_object_unref (pad);
return NULL;
}
GST_DEBUG_OBJECT (pad, "new visible pad with direction %s",
direction == GST_PAD_SRC ? "src" : "sink");
return pad;
}
#define gst_webrtc_bin_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstWebRTCBin, gst_webrtc_bin, GST_TYPE_BIN,
GST_DEBUG_CATEGORY_INIT (gst_webrtc_bin_debug, "webrtcbin", 0,
"webrtcbin element");
);
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS ("application/x-rtp"));
static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src_%u",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
GST_STATIC_CAPS ("application/x-rtp"));
enum
{
SIGNAL_0,
CREATE_OFFER_SIGNAL,
CREATE_ANSWER_SIGNAL,
SET_LOCAL_DESCRIPTION_SIGNAL,
SET_REMOTE_DESCRIPTION_SIGNAL,
ADD_ICE_CANDIDATE_SIGNAL,
ON_NEGOTIATION_NEEDED_SIGNAL,
ON_ICE_CANDIDATE_SIGNAL,
GET_STATS_SIGNAL,
ADD_TRANSCEIVER_SIGNAL,
GET_TRANSCEIVERS_SIGNAL,
LAST_SIGNAL,
};
enum
{
PROP_0,
PROP_CONNECTION_STATE,
PROP_SIGNALING_STATE,
PROP_ICE_GATHERING_STATE,
PROP_ICE_CONNECTION_STATE,
PROP_LOCAL_DESCRIPTION,
PROP_CURRENT_LOCAL_DESCRIPTION,
PROP_PENDING_LOCAL_DESCRIPTION,
PROP_REMOTE_DESCRIPTION,
PROP_CURRENT_REMOTE_DESCRIPTION,
PROP_PENDING_REMOTE_DESCRIPTION,
PROP_STUN_SERVER,
PROP_TURN_SERVER,
};
static guint gst_webrtc_bin_signals[LAST_SIGNAL] = { 0 };
static GstWebRTCDTLSTransport *
_transceiver_get_transport (GstWebRTCRTPTransceiver * trans)
{
if (trans->sender) {
return trans->sender->transport;
} else if (trans->receiver) {
return trans->receiver->transport;
}
return NULL;
}
static GstWebRTCDTLSTransport *
_transceiver_get_rtcp_transport (GstWebRTCRTPTransceiver * trans)
{
if (trans->sender) {
return trans->sender->rtcp_transport;
} else if (trans->receiver) {
return trans->receiver->rtcp_transport;
}
return NULL;
}
typedef struct
{
guint session_id;
GstWebRTCICEStream *stream;
} IceStreamItem;
/* FIXME: locking? */
GstWebRTCICEStream *
_find_ice_stream_for_session (GstWebRTCBin * webrtc, guint session_id)
{
int i;
for (i = 0; i < webrtc->priv->ice_stream_map->len; i++) {
IceStreamItem *item =
&g_array_index (webrtc->priv->ice_stream_map, IceStreamItem, i);
if (item->session_id == session_id) {
GST_TRACE_OBJECT (webrtc, "Found ice stream id %" GST_PTR_FORMAT " for "
"session %u", item->stream, session_id);
return item->stream;
}
}
GST_TRACE_OBJECT (webrtc, "No ice stream available for session %u",
session_id);
return NULL;
}
void
_add_ice_stream_item (GstWebRTCBin * webrtc, guint session_id,
GstWebRTCICEStream * stream)
{
IceStreamItem item = { session_id, stream };
GST_TRACE_OBJECT (webrtc, "adding ice stream %" GST_PTR_FORMAT " for "
"session %u", stream, session_id);
g_array_append_val (webrtc->priv->ice_stream_map, item);
}
typedef struct
{
guint session_id;
gchar *mid;
} SessionMidItem;
static void
clear_session_mid_item (SessionMidItem * item)
{
g_free (item->mid);
}
typedef gboolean (*FindTransceiverFunc) (GstWebRTCRTPTransceiver * p1,
gconstpointer data);
static GstWebRTCRTPTransceiver *
_find_transceiver (GstWebRTCBin * webrtc, gconstpointer data,
FindTransceiverFunc func)
{
int i;
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *transceiver =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
if (func (transceiver, data))
return transceiver;
}
return NULL;
}
static gboolean
match_for_mid (GstWebRTCRTPTransceiver * trans, const gchar * mid)
{
return g_strcmp0 (trans->mid, mid) == 0;
}
static gboolean
transceiver_match_for_mline (GstWebRTCRTPTransceiver * trans, guint * mline)
{
return trans->mline == *mline;
}
static GstWebRTCRTPTransceiver *
_find_transceiver_for_mline (GstWebRTCBin * webrtc, guint mlineindex)
{
GstWebRTCRTPTransceiver *trans;
trans = _find_transceiver (webrtc, &mlineindex,
(FindTransceiverFunc) transceiver_match_for_mline);
GST_TRACE_OBJECT (webrtc,
"Found transceiver %" GST_PTR_FORMAT " for mlineindex %u", trans,
mlineindex);
return trans;
}
typedef gboolean (*FindTransportFunc) (TransportStream * p1,
gconstpointer data);
static TransportStream *
_find_transport (GstWebRTCBin * webrtc, gconstpointer data,
FindTransportFunc func)
{
int i;
for (i = 0; i < webrtc->priv->transports->len; i++) {
TransportStream *stream =
g_array_index (webrtc->priv->transports, TransportStream *,
i);
if (func (stream, data))
return stream;
}
return NULL;
}
static gboolean
match_stream_for_session (TransportStream * trans, guint * session)
{
return trans->session_id == *session;
}
static TransportStream *
_find_transport_for_session (GstWebRTCBin * webrtc, guint session_id)
{
TransportStream *stream;
stream = _find_transport (webrtc, &session_id,
(FindTransportFunc) match_stream_for_session);
GST_TRACE_OBJECT (webrtc,
"Found transport %" GST_PTR_FORMAT " for session %u", stream, session_id);
return stream;
}
typedef gboolean (*FindPadFunc) (GstWebRTCBinPad * p1, gconstpointer data);
static GstWebRTCBinPad *
_find_pad (GstWebRTCBin * webrtc, gconstpointer data, FindPadFunc func)
{
GstElement *element = GST_ELEMENT (webrtc);
GList *l;
GST_OBJECT_LOCK (webrtc);
l = element->pads;
for (; l; l = g_list_next (l)) {
if (!GST_IS_WEBRTC_BIN_PAD (l->data))
continue;
if (func (l->data, data)) {
gst_object_ref (l->data);
GST_OBJECT_UNLOCK (webrtc);
return l->data;
}
}
l = webrtc->priv->pending_pads;
for (; l; l = g_list_next (l)) {
if (!GST_IS_WEBRTC_BIN_PAD (l->data))
continue;
if (func (l->data, data)) {
gst_object_ref (l->data);
GST_OBJECT_UNLOCK (webrtc);
return l->data;
}
}
GST_OBJECT_UNLOCK (webrtc);
return NULL;
}
static void
_add_pad_to_list (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
GST_OBJECT_LOCK (webrtc);
webrtc->priv->pending_pads = g_list_prepend (webrtc->priv->pending_pads, pad);
GST_OBJECT_UNLOCK (webrtc);
}
static void
_remove_pending_pad (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
GST_OBJECT_LOCK (webrtc);
webrtc->priv->pending_pads = g_list_remove (webrtc->priv->pending_pads, pad);
GST_OBJECT_UNLOCK (webrtc);
}
static void
_add_pad (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
_remove_pending_pad (webrtc, pad);
if (webrtc->priv->running)
gst_pad_set_active (GST_PAD (pad), TRUE);
gst_element_add_pad (GST_ELEMENT (webrtc), GST_PAD (pad));
}
static void
_remove_pad (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
_remove_pending_pad (webrtc, pad);
gst_element_remove_pad (GST_ELEMENT (webrtc), GST_PAD (pad));
}
typedef struct
{
GstPadDirection direction;
guint mlineindex;
} MLineMatch;
static gboolean
pad_match_for_mline (GstWebRTCBinPad * pad, const MLineMatch * match)
{
return GST_PAD_DIRECTION (pad) == match->direction
&& pad->mlineindex == match->mlineindex;
}
static GstWebRTCBinPad *
_find_pad_for_mline (GstWebRTCBin * webrtc, GstPadDirection direction,
guint mlineindex)
{
MLineMatch m = { direction, mlineindex };
return _find_pad (webrtc, &m, (FindPadFunc) pad_match_for_mline);
}
typedef struct
{
GstPadDirection direction;
GstWebRTCRTPTransceiver *trans;
} TransMatch;
static gboolean
pad_match_for_transceiver (GstWebRTCBinPad * pad, TransMatch * m)
{
return GST_PAD_DIRECTION (pad) == m->direction && pad->trans == m->trans;
}
static GstWebRTCBinPad *
_find_pad_for_transceiver (GstWebRTCBin * webrtc, GstPadDirection direction,
GstWebRTCRTPTransceiver * trans)
{
TransMatch m = { direction, trans };
return _find_pad (webrtc, &m, (FindPadFunc) pad_match_for_transceiver);
}
#if 0
static gboolean
match_for_ssrc (GstWebRTCBinPad * pad, guint * ssrc)
{
return pad->ssrc == *ssrc;
}
static gboolean
match_for_pad (GstWebRTCBinPad * pad, GstWebRTCBinPad * other)
{
return pad == other;
}
#endif
static gboolean
_unlock_pc_thread (GMutex * lock)
{
g_mutex_unlock (lock);
return G_SOURCE_REMOVE;
}
static gpointer
_gst_pc_thread (GstWebRTCBin * webrtc)
{
PC_LOCK (webrtc);
webrtc->priv->main_context = g_main_context_new ();
webrtc->priv->loop = g_main_loop_new (webrtc->priv->main_context, FALSE);
PC_COND_BROADCAST (webrtc);
g_main_context_invoke (webrtc->priv->main_context,
(GSourceFunc) _unlock_pc_thread, PC_GET_LOCK (webrtc));
/* Having the thread be the thread default GMainContext will break the
* required queue-like ordering (from W3's peerconnection spec) of re-entrant
* tasks */
g_main_loop_run (webrtc->priv->loop);
PC_LOCK (webrtc);
g_main_context_unref (webrtc->priv->main_context);
webrtc->priv->main_context = NULL;
g_main_loop_unref (webrtc->priv->loop);
webrtc->priv->loop = NULL;
PC_COND_BROADCAST (webrtc);
PC_UNLOCK (webrtc);
return NULL;
}
static void
_start_thread (GstWebRTCBin * webrtc)
{
PC_LOCK (webrtc);
webrtc->priv->thread = g_thread_new ("gst-pc-ops",
(GThreadFunc) _gst_pc_thread, webrtc);
while (!webrtc->priv->loop)
PC_COND_WAIT (webrtc);
webrtc->priv->is_closed = FALSE;
PC_UNLOCK (webrtc);
}
static void
_stop_thread (GstWebRTCBin * webrtc)
{
PC_LOCK (webrtc);
webrtc->priv->is_closed = TRUE;
g_main_loop_quit (webrtc->priv->loop);
while (webrtc->priv->loop)
PC_COND_WAIT (webrtc);
PC_UNLOCK (webrtc);
g_thread_unref (webrtc->priv->thread);
}
static gboolean
_execute_op (GstWebRTCBinTask * op)
{
PC_LOCK (op->webrtc);
if (op->webrtc->priv->is_closed) {
GST_DEBUG_OBJECT (op->webrtc,
"Peerconnection is closed, aborting execution");
goto out;
}
op->op (op->webrtc, op->data);
out:
PC_UNLOCK (op->webrtc);
return G_SOURCE_REMOVE;
}
static void
_free_op (GstWebRTCBinTask * op)
{
if (op->notify)
op->notify (op->data);
g_free (op);
}
void
gst_webrtc_bin_enqueue_task (GstWebRTCBin * webrtc, GstWebRTCBinFunc func,
gpointer data, GDestroyNotify notify)
{
GstWebRTCBinTask *op;
GSource *source;
g_return_if_fail (GST_IS_WEBRTC_BIN (webrtc));
if (webrtc->priv->is_closed) {
GST_DEBUG_OBJECT (webrtc, "Peerconnection is closed, aborting execution");
if (notify)
notify (data);
return;
}
op = g_new0 (GstWebRTCBinTask, 1);
op->webrtc = webrtc;
op->op = func;
op->data = data;
op->notify = notify;
source = g_idle_source_new ();
g_source_set_priority (source, G_PRIORITY_DEFAULT);
g_source_set_callback (source, (GSourceFunc) _execute_op, op,
(GDestroyNotify) _free_op);
g_source_attach (source, webrtc->priv->main_context);
g_source_unref (source);
}
/* https://www.w3.org/TR/webrtc/#dom-rtciceconnectionstate */
static GstWebRTCICEConnectionState
_collate_ice_connection_states (GstWebRTCBin * webrtc)
{
#define STATE(val) GST_WEBRTC_ICE_CONNECTION_STATE_ ## val
GstWebRTCICEConnectionState any_state = 0;
gboolean all_closed = TRUE;
int i;
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *rtp_trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream;
GstWebRTCICETransport *transport, *rtcp_transport;
GstWebRTCICEConnectionState ice_state;
gboolean rtcp_mux = FALSE;
if (rtp_trans->stopped)
continue;
if (!rtp_trans->mid)
continue;
g_object_get (stream, "rtcp-mux", &rtcp_mux, NULL);
transport = _transceiver_get_transport (rtp_trans)->transport;
/* get transport state */
g_object_get (transport, "state", &ice_state, NULL);
any_state |= (1 << ice_state);
if (ice_state != STATE (CLOSED))
all_closed = FALSE;
rtcp_transport = _transceiver_get_rtcp_transport (rtp_trans)->transport;
if (!rtcp_mux && rtcp_transport && transport != rtcp_transport) {
g_object_get (rtcp_transport, "state", &ice_state, NULL);
any_state |= (1 << ice_state);
if (ice_state != STATE (CLOSED))
all_closed = FALSE;
}
}
GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x", any_state);
if (webrtc->priv->is_closed) {
GST_TRACE_OBJECT (webrtc, "returning closed");
return STATE (CLOSED);
}
/* Any of the RTCIceTransport s are in the failed state. */
if (any_state & (1 << STATE (FAILED))) {
GST_TRACE_OBJECT (webrtc, "returning failed");
return STATE (FAILED);
}
/* Any of the RTCIceTransport s are in the disconnected state and
* none of them are in the failed state. */
if (any_state & (1 << STATE (DISCONNECTED))) {
GST_TRACE_OBJECT (webrtc, "returning disconnected");
return STATE (DISCONNECTED);
}
/* Any of the RTCIceTransport's are in the checking state and none of them
* are in the failed or disconnected state. */
if (any_state & (1 << STATE (CHECKING))) {
GST_TRACE_OBJECT (webrtc, "returning checking");
return STATE (CHECKING);
}
/* Any of the RTCIceTransport s are in the new state and none of them are
* in the checking, failed or disconnected state, or all RTCIceTransport's
* are in the closed state. */
if ((any_state & (1 << STATE (NEW))) || all_closed) {
GST_TRACE_OBJECT (webrtc, "returning new");
return STATE (NEW);
}
/* All RTCIceTransport s are in the connected, completed or closed state
* and at least one of them is in the connected state. */
if (any_state & (1 << STATE (CONNECTED) | 1 << STATE (COMPLETED) | 1 <<
STATE (CLOSED)) && any_state & (1 << STATE (CONNECTED))) {
GST_TRACE_OBJECT (webrtc, "returning connected");
return STATE (CONNECTED);
}
/* All RTCIceTransport s are in the completed or closed state and at least
* one of them is in the completed state. */
if (any_state & (1 << STATE (COMPLETED) | 1 << STATE (CLOSED))
&& any_state & (1 << STATE (COMPLETED))) {
GST_TRACE_OBJECT (webrtc, "returning connected");
return STATE (CONNECTED);
}
GST_FIXME ("unspecified situation, returning new");
return STATE (NEW);
#undef STATE
}
/* https://www.w3.org/TR/webrtc/#dom-rtcicegatheringstate */
static GstWebRTCICEGatheringState
_collate_ice_gathering_states (GstWebRTCBin * webrtc)
{
#define STATE(val) GST_WEBRTC_ICE_GATHERING_STATE_ ## val
GstWebRTCICEGatheringState any_state = 0;
gboolean all_completed = webrtc->priv->transceivers->len > 0;
int i;
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *rtp_trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream;
GstWebRTCICETransport *transport, *rtcp_transport;
GstWebRTCICEGatheringState ice_state;
gboolean rtcp_mux = FALSE;
if (rtp_trans->stopped)
continue;
if (!rtp_trans->mid)
continue;
g_object_get (stream, "rtcp-mux", &rtcp_mux, NULL);
transport = _transceiver_get_transport (rtp_trans)->transport;
/* get gathering state */
g_object_get (transport, "gathering-state", &ice_state, NULL);
any_state |= (1 << ice_state);
if (ice_state != STATE (COMPLETE))
all_completed = FALSE;
rtcp_transport = _transceiver_get_rtcp_transport (rtp_trans)->transport;
if (!rtcp_mux && rtcp_transport && rtcp_transport != transport) {
g_object_get (rtcp_transport, "gathering-state", &ice_state, NULL);
any_state |= (1 << ice_state);
if (ice_state != STATE (COMPLETE))
all_completed = FALSE;
}
}
GST_TRACE_OBJECT (webrtc, "ICE gathering state: 0x%x", any_state);
/* Any of the RTCIceTransport s are in the gathering state. */
if (any_state & (1 << STATE (GATHERING))) {
GST_TRACE_OBJECT (webrtc, "returning gathering");
return STATE (GATHERING);
}
/* At least one RTCIceTransport exists, and all RTCIceTransport s are in
* the completed gathering state. */
if (all_completed) {
GST_TRACE_OBJECT (webrtc, "returning complete");
return STATE (COMPLETE);
}
/* Any of the RTCIceTransport s are in the new gathering state and none
* of the transports are in the gathering state, or there are no transports. */
GST_TRACE_OBJECT (webrtc, "returning new");
return STATE (NEW);
#undef STATE
}
/* https://www.w3.org/TR/webrtc/#rtcpeerconnectionstate-enum */
static GstWebRTCPeerConnectionState
_collate_peer_connection_states (GstWebRTCBin * webrtc)
{
#define STATE(v) GST_WEBRTC_PEER_CONNECTION_STATE_ ## v
#define ICE_STATE(v) GST_WEBRTC_ICE_CONNECTION_STATE_ ## v
#define DTLS_STATE(v) GST_WEBRTC_DTLS_TRANSPORT_STATE_ ## v
GstWebRTCICEConnectionState any_ice_state = 0;
GstWebRTCDTLSTransportState any_dtls_state = 0;
int i;
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *rtp_trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream;
GstWebRTCDTLSTransport *transport, *rtcp_transport;
GstWebRTCICEGatheringState ice_state;
GstWebRTCDTLSTransportState dtls_state;
gboolean rtcp_mux = FALSE;
if (rtp_trans->stopped)
continue;
if (!rtp_trans->mid)
continue;
g_object_get (stream, "rtcp-mux", &rtcp_mux, NULL);
transport = _transceiver_get_transport (rtp_trans);
/* get transport state */
g_object_get (transport, "state", &dtls_state, NULL);
any_dtls_state |= (1 << dtls_state);
g_object_get (transport->transport, "state", &ice_state, NULL);
any_ice_state |= (1 << ice_state);
rtcp_transport = _transceiver_get_rtcp_transport (rtp_trans);
if (!rtcp_mux && rtcp_transport && rtcp_transport != transport) {
g_object_get (rtcp_transport, "state", &dtls_state, NULL);
any_dtls_state |= (1 << dtls_state);
g_object_get (rtcp_transport->transport, "state", &ice_state, NULL);
any_ice_state |= (1 << ice_state);
}
}
GST_TRACE_OBJECT (webrtc, "ICE connection state: 0x%x. DTLS connection "
"state: 0x%x", any_ice_state, any_dtls_state);
/* The RTCPeerConnection object's [[ isClosed]] slot is true. */
if (webrtc->priv->is_closed) {
GST_TRACE_OBJECT (webrtc, "returning closed");
return STATE (CLOSED);
}
/* Any of the RTCIceTransport s or RTCDtlsTransport s are in a failed state. */
if (any_ice_state & (1 << ICE_STATE (FAILED))) {
GST_TRACE_OBJECT (webrtc, "returning failed");
return STATE (FAILED);
}
if (any_dtls_state & (1 << DTLS_STATE (FAILED))) {
GST_TRACE_OBJECT (webrtc, "returning failed");
return STATE (FAILED);
}
/* Any of the RTCIceTransport's or RTCDtlsTransport's are in the connecting
* or checking state and none of them is in the failed state. */
if (any_ice_state & (1 << ICE_STATE (CHECKING))) {
GST_TRACE_OBJECT (webrtc, "returning connecting");
return STATE (CONNECTING);
}
if (any_dtls_state & (1 << DTLS_STATE (CONNECTING))) {
GST_TRACE_OBJECT (webrtc, "returning connecting");
return STATE (CONNECTING);
}
/* Any of the RTCIceTransport's or RTCDtlsTransport's are in the disconnected
* state and none of them are in the failed or connecting or checking state. */
if (any_ice_state & (1 << ICE_STATE (DISCONNECTED))) {
GST_TRACE_OBJECT (webrtc, "returning disconnected");
return STATE (DISCONNECTED);
}
/* All RTCIceTransport's and RTCDtlsTransport's are in the connected,
* completed or closed state and at least of them is in the connected or
* completed state. */
if (!(any_ice_state & ~(1 << ICE_STATE (CONNECTED) | 1 <<
ICE_STATE (COMPLETED) | 1 << ICE_STATE (CLOSED)))
&& !(any_dtls_state & ~(1 << DTLS_STATE (CONNECTED) | 1 <<
DTLS_STATE (CLOSED)))
&& (any_ice_state & (1 << ICE_STATE (CONNECTED) | 1 <<
ICE_STATE (COMPLETED))
|| any_dtls_state & (1 << DTLS_STATE (CONNECTED)))) {
GST_TRACE_OBJECT (webrtc, "returning connected");
return STATE (CONNECTED);
}
/* Any of the RTCIceTransport's or RTCDtlsTransport's are in the new state
* and none of the transports are in the connecting, checking, failed or
* disconnected state, or all transports are in the closed state. */
if (!(any_ice_state & ~(1 << ICE_STATE (CLOSED)))) {
GST_TRACE_OBJECT (webrtc, "returning new");
return STATE (NEW);
}
if ((any_ice_state & (1 << ICE_STATE (NEW))
|| any_dtls_state & (1 << DTLS_STATE (NEW)))
&& !(any_ice_state & (1 << ICE_STATE (CHECKING) | 1 << ICE_STATE (FAILED)
| (1 << ICE_STATE (DISCONNECTED))))
&& !(any_dtls_state & (1 << DTLS_STATE (CONNECTING) | 1 <<
DTLS_STATE (FAILED)))) {
GST_TRACE_OBJECT (webrtc, "returning new");
return STATE (NEW);
}
GST_FIXME_OBJECT (webrtc, "Undefined situation detected, returning new");
return STATE (NEW);
#undef DTLS_STATE
#undef ICE_STATE
#undef STATE
}
static void
_update_ice_gathering_state_task (GstWebRTCBin * webrtc, gpointer data)
{
GstWebRTCICEGatheringState old_state = webrtc->ice_gathering_state;
GstWebRTCICEGatheringState new_state;
new_state = _collate_ice_gathering_states (webrtc);
if (new_state != webrtc->ice_gathering_state) {
gchar *old_s, *new_s;
old_s = _enum_value_to_string (GST_TYPE_WEBRTC_ICE_GATHERING_STATE,
old_state);
new_s = _enum_value_to_string (GST_TYPE_WEBRTC_ICE_GATHERING_STATE,
new_state);
GST_INFO_OBJECT (webrtc, "ICE gathering state change from %s(%u) to %s(%u)",
old_s, old_state, new_s, new_state);
g_free (old_s);
g_free (new_s);
webrtc->ice_gathering_state = new_state;
PC_UNLOCK (webrtc);
g_object_notify (G_OBJECT (webrtc), "ice-gathering-state");
PC_LOCK (webrtc);
}
}
static void
_update_ice_gathering_state (GstWebRTCBin * webrtc)
{
gst_webrtc_bin_enqueue_task (webrtc, _update_ice_gathering_state_task, NULL,
NULL);
}
static void
_update_ice_connection_state_task (GstWebRTCBin * webrtc, gpointer data)
{
GstWebRTCICEConnectionState old_state = webrtc->ice_connection_state;
GstWebRTCICEConnectionState new_state;
new_state = _collate_ice_connection_states (webrtc);
if (new_state != old_state) {
gchar *old_s, *new_s;
old_s = _enum_value_to_string (GST_TYPE_WEBRTC_ICE_CONNECTION_STATE,
old_state);
new_s = _enum_value_to_string (GST_TYPE_WEBRTC_ICE_CONNECTION_STATE,
new_state);
GST_INFO_OBJECT (webrtc,
"ICE connection state change from %s(%u) to %s(%u)", old_s, old_state,
new_s, new_state);
g_free (old_s);
g_free (new_s);
webrtc->ice_connection_state = new_state;
PC_UNLOCK (webrtc);
g_object_notify (G_OBJECT (webrtc), "ice-connection-state");
PC_LOCK (webrtc);
}
}
static void
_update_ice_connection_state (GstWebRTCBin * webrtc)
{
gst_webrtc_bin_enqueue_task (webrtc, _update_ice_connection_state_task, NULL,
NULL);
}
static void
_update_peer_connection_state_task (GstWebRTCBin * webrtc, gpointer data)
{
GstWebRTCPeerConnectionState old_state = webrtc->peer_connection_state;
GstWebRTCPeerConnectionState new_state;
new_state = _collate_peer_connection_states (webrtc);
if (new_state != old_state) {
gchar *old_s, *new_s;
old_s = _enum_value_to_string (GST_TYPE_WEBRTC_PEER_CONNECTION_STATE,
old_state);
new_s = _enum_value_to_string (GST_TYPE_WEBRTC_PEER_CONNECTION_STATE,
new_state);
GST_INFO_OBJECT (webrtc,
"Peer connection state change from %s(%u) to %s(%u)", old_s, old_state,
new_s, new_state);
g_free (old_s);
g_free (new_s);
webrtc->peer_connection_state = new_state;
PC_UNLOCK (webrtc);
g_object_notify (G_OBJECT (webrtc), "connection-state");
PC_LOCK (webrtc);
}
}
static void
_update_peer_connection_state (GstWebRTCBin * webrtc)
{
gst_webrtc_bin_enqueue_task (webrtc, _update_peer_connection_state_task,
NULL, NULL);
}
/* http://w3c.github.io/webrtc-pc/#dfn-check-if-negotiation-is-needed */
static gboolean
_check_if_negotiation_is_needed (GstWebRTCBin * webrtc)
{
int i;
GST_LOG_OBJECT (webrtc, "checking if negotiation is needed");
/* If any implementation-specific negotiation is required, as described at
* the start of this section, return "true".
* FIXME */
/* FIXME: emit when input caps/format changes? */
/* If connection has created any RTCDataChannel's, and no m= section has
* been negotiated yet for data, return "true".
* FIXME */
if (!webrtc->current_local_description) {
GST_LOG_OBJECT (webrtc, "no local description set");
return TRUE;
}
if (!webrtc->current_remote_description) {
GST_LOG_OBJECT (webrtc, "no remote description set");
return TRUE;
}
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *trans;
trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
if (trans->stopped) {
/* FIXME: If t is stopped and is associated with an m= section according to
* [JSEP] (section 3.4.1.), but the associated m= section is not yet
* rejected in connection's currentLocalDescription or
* currentRemoteDescription , return "true". */
GST_FIXME_OBJECT (webrtc,
"check if the transceiver is rejected in descriptions");
} else {
const GstSDPMedia *media;
GstWebRTCRTPTransceiverDirection local_dir, remote_dir;
if (trans->mline == -1) {
GST_LOG_OBJECT (webrtc, "unassociated transceiver %i %" GST_PTR_FORMAT,
i, trans);
return TRUE;
}
/* internal inconsistency */
g_assert (trans->mline <
gst_sdp_message_medias_len (webrtc->current_local_description->sdp));
g_assert (trans->mline <
gst_sdp_message_medias_len (webrtc->current_remote_description->sdp));
/* FIXME: msid handling
* If t's direction is "sendrecv" or "sendonly", and the associated m=
* section in connection's currentLocalDescription doesn't contain an
* "a=msid" line, return "true". */
media =
gst_sdp_message_get_media (webrtc->current_local_description->sdp,
trans->mline);
local_dir = _get_direction_from_media (media);
media =
gst_sdp_message_get_media (webrtc->current_remote_description->sdp,
trans->mline);
remote_dir = _get_direction_from_media (media);
if (webrtc->current_local_description->type == GST_WEBRTC_SDP_TYPE_OFFER) {
/* If connection's currentLocalDescription if of type "offer", and
* the direction of the associated m= section in neither the offer
* nor answer matches t's direction, return "true". */
if (local_dir != trans->direction && remote_dir != trans->direction) {
GST_LOG_OBJECT (webrtc,
"transceiver direction doesn't match description");
return TRUE;
}
} else if (webrtc->current_local_description->type ==
GST_WEBRTC_SDP_TYPE_ANSWER) {
GstWebRTCRTPTransceiverDirection intersect_dir;
/* If connection's currentLocalDescription if of type "answer", and
* the direction of the associated m= section in the answer does not
* match t's direction intersected with the offered direction (as
* described in [JSEP] (section 5.3.1.)), return "true". */
/* remote is the offer, local is the answer */
intersect_dir = _intersect_answer_directions (remote_dir, local_dir);
if (intersect_dir != trans->direction) {
GST_LOG_OBJECT (webrtc,
"transceiver direction doesn't match description");
return TRUE;
}
}
}
}
GST_LOG_OBJECT (webrtc, "no negotiation needed");
return FALSE;
}
static void
_check_need_negotiation_task (GstWebRTCBin * webrtc, gpointer unused)
{
if (webrtc->priv->need_negotiation) {
GST_TRACE_OBJECT (webrtc, "emitting on-negotiation-needed");
PC_UNLOCK (webrtc);
g_signal_emit (webrtc, gst_webrtc_bin_signals[ON_NEGOTIATION_NEEDED_SIGNAL],
0);
PC_LOCK (webrtc);
}
}
/* http://w3c.github.io/webrtc-pc/#dfn-update-the-negotiation-needed-flag */
static void
_update_need_negotiation (GstWebRTCBin * webrtc)
{
/* If connection's [[isClosed]] slot is true, abort these steps. */
if (webrtc->priv->is_closed)
return;
/* If connection's signaling state is not "stable", abort these steps. */
if (webrtc->signaling_state != GST_WEBRTC_SIGNALING_STATE_STABLE)
return;
/* If the result of checking if negotiation is needed is "false", clear the
* negotiation-needed flag by setting connection's [[ needNegotiation]] slot
* to false, and abort these steps. */
if (!_check_if_negotiation_is_needed (webrtc)) {
webrtc->priv->need_negotiation = FALSE;
return;
}
/* If connection's [[needNegotiation]] slot is already true, abort these steps. */
if (webrtc->priv->need_negotiation)
return;
/* Set connection's [[needNegotiation]] slot to true. */
webrtc->priv->need_negotiation = TRUE;
/* Queue a task to check connection's [[ needNegotiation]] slot and, if still
* true, fire a simple event named negotiationneeded at connection. */
gst_webrtc_bin_enqueue_task (webrtc, _check_need_negotiation_task, NULL,
NULL);
}
static GstCaps *
_find_codec_preferences (GstWebRTCBin * webrtc, GstWebRTCRTPTransceiver * trans,
GstPadDirection direction, guint media_idx)
{
GstCaps *ret = NULL;
GST_LOG_OBJECT (webrtc, "retreiving codec preferences from %" GST_PTR_FORMAT,
trans);
if (trans->codec_preferences) {
GST_LOG_OBJECT (webrtc, "Using codec preferences: %" GST_PTR_FORMAT,
trans->codec_preferences);
ret = gst_caps_ref (trans->codec_preferences);
} else {
GstWebRTCBinPad *pad = _find_pad_for_mline (webrtc, direction, media_idx);
if (pad) {
GstCaps *caps = gst_pad_get_current_caps (GST_PAD (pad));
if (caps) {
GST_LOG_OBJECT (webrtc, "Using current pad caps: %" GST_PTR_FORMAT,
caps);
} else {
if ((caps = gst_pad_peer_query_caps (GST_PAD (pad), NULL)))
GST_LOG_OBJECT (webrtc, "Using peer query caps: %" GST_PTR_FORMAT,
caps);
}
if (caps)
ret = caps;
gst_object_unref (pad);
}
}
return ret;
}
static GstCaps *
_add_supported_attributes_to_caps (const GstCaps * caps)
{
GstCaps *ret;
int 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 (!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? */
/*if (!gst_structure_has_field (s, "rtcp-fb-transport-cc"))
gst_structure_set (s, "rtcp-fb-nack-pli", G_TYPE_BOOLEAN, TRUE, NULL); */
/* FIXME: codec-specific paramters? */
}
return ret;
}
static void
_on_ice_transport_notify_state (GstWebRTCICETransport * transport,
GParamSpec * pspec, GstWebRTCBin * webrtc)
{
_update_ice_connection_state (webrtc);
_update_peer_connection_state (webrtc);
}
static void
_on_ice_transport_notify_gathering_state (GstWebRTCICETransport * transport,
GParamSpec * pspec, GstWebRTCBin * webrtc)
{
_update_ice_gathering_state (webrtc);
}
static void
_on_dtls_transport_notify_state (GstWebRTCDTLSTransport * transport,
GParamSpec * pspec, GstWebRTCBin * webrtc)
{
_update_peer_connection_state (webrtc);
}
static WebRTCTransceiver *
_create_webrtc_transceiver (GstWebRTCBin * webrtc)
{
WebRTCTransceiver *trans;
GstWebRTCRTPTransceiver *rtp_trans;
GstWebRTCRTPSender *sender;
GstWebRTCRTPReceiver *receiver;
sender = gst_webrtc_rtp_sender_new (NULL);
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;
g_array_append_val (webrtc->priv->transceivers, trans);
gst_object_unref (sender);
gst_object_unref (receiver);
return trans;
}
static TransportStream *
_create_transport_channel (GstWebRTCBin * webrtc, guint session_id)
{
GstWebRTCDTLSTransport *transport;
TransportStream *ret;
gchar *pad_name;
/* FIXME: how to parametrize the sender and the receiver */
ret = transport_stream_new (webrtc, session_id);
transport = ret->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 ((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);
}
gst_bin_add (GST_BIN (webrtc), GST_ELEMENT (ret->send_bin));
gst_bin_add (GST_BIN (webrtc), GST_ELEMENT (ret->receive_bin));
pad_name = g_strdup_printf ("recv_rtcp_sink_%u", ret->session_id);
if (!gst_element_link_pads (GST_ELEMENT (ret->receive_bin), "rtcp_src",
GST_ELEMENT (webrtc->rtpbin), pad_name))
g_warn_if_reached ();
g_free (pad_name);
pad_name = g_strdup_printf ("send_rtcp_src_%u", ret->session_id);
if (!gst_element_link_pads (GST_ELEMENT (webrtc->rtpbin), pad_name,
GST_ELEMENT (ret->send_bin), "rtcp_sink"))
g_warn_if_reached ();
g_free (pad_name);
g_array_append_val (webrtc->priv->transports, ret);
GST_TRACE_OBJECT (webrtc,
"Create transport %" GST_PTR_FORMAT " for session %u", ret, session_id);
gst_element_sync_state_with_parent (GST_ELEMENT (ret->send_bin));
gst_element_sync_state_with_parent (GST_ELEMENT (ret->receive_bin));
return ret;
}
/* 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,
GstWebRTCRTPTransceiver * trans, GstWebRTCSDPType type, guint media_idx)
{
/* TODO:
* rtp header extensions
* ice attributes
* rtx
* fec
* msid-semantics
* msid
* dtls fingerprints
* multiple dtls fingerprints https://tools.ietf.org/html/draft-ietf-mmusic-4572-update-05
*/
gchar *direction, *sdp_mid;
GstCaps *caps;
int i;
/* "An m= section is generated for each RtpTransceiver that has been added
* to the Bin, excluding any stopped RtpTransceivers." */
if (trans->stopped)
return FALSE;
if (trans->direction == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE
|| trans->direction == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE)
return FALSE;
gst_sdp_media_set_port_info (media, 9, 0);
gst_sdp_media_set_proto (media, "UDP/TLS/RTP/SAVPF");
gst_sdp_media_add_connection (media, "IN", "IP4", "0.0.0.0", 0, 0);
direction =
_enum_value_to_string (GST_TYPE_WEBRTC_RTP_TRANSCEIVER_DIRECTION,
trans->direction);
gst_sdp_media_add_attribute (media, direction, "");
g_free (direction);
/* FIXME: negotiate this */
gst_sdp_media_add_attribute (media, "rtcp-mux", "");
gst_sdp_media_add_attribute (media, "rtcp-rsize", NULL);
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);
} else if (type == GST_WEBRTC_SDP_TYPE_ANSWER) {
caps = _find_codec_preferences (webrtc, trans, GST_PAD_SRC, media_idx);
/* FIXME: add rtcp-fb paramaters */
} else {
g_assert_not_reached ();
}
if (!caps || gst_caps_is_empty (caps) || gst_caps_is_any (caps)) {
GST_WARNING_OBJECT (webrtc, "no caps available for transceiver, skipping");
if (caps)
gst_caps_unref (caps);
return FALSE;
}
for (i = 0; i < gst_caps_get_size (caps); i++) {
GstCaps *format = gst_caps_new_empty ();
const GstStructure *s = gst_caps_get_structure (caps, i);
gst_caps_append_structure (format, gst_structure_copy (s));
GST_DEBUG_OBJECT (webrtc, "Adding %u-th caps %" GST_PTR_FORMAT
" to %u-th media", i, format, media_idx);
/* this only looks at the first structure so we loop over the given caps
* and add each structure inside it piecemeal */
gst_sdp_media_set_media_from_caps (format, media);
gst_caps_unref (format);
}
/* 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++);
gst_sdp_media_add_attribute (media, "mid", sdp_mid);
g_free (sdp_mid);
if (trans->sender) {
gchar *cert, *fingerprint, *val;
if (!trans->sender->transport) {
TransportStream *item;
/* FIXME: bundle */
item = _find_transport_for_session (webrtc, media_idx);
if (!item)
item = _create_transport_channel (webrtc, media_idx);
webrtc_transceiver_set_transport (WEBRTC_TRANSCEIVER (trans), item);
}
g_object_get (trans->sender->transport, "certificate", &cert, NULL);
fingerprint =
_generate_fingerprint_from_certificate (cert, G_CHECKSUM_SHA256);
g_free (cert);
val =
g_strdup_printf ("%s %s",
_g_checksum_to_webrtc_string (G_CHECKSUM_SHA256), fingerprint);
g_free (fingerprint);
gst_sdp_media_add_attribute (media, "fingerprint", val);
g_free (val);
}
gst_caps_unref (caps);
return TRUE;
}
static GstSDPMessage *
_create_offer_task (GstWebRTCBin * webrtc, const GstStructure * options)
{
GstSDPMessage *ret;
int i;
gst_sdp_message_new (&ret);
gst_sdp_message_set_version (ret, "0");
{
/* FIXME: session id and version need special handling depending on the state we're in */
gchar *sess_id = g_strdup_printf ("%" G_GUINT64_FORMAT, RANDOM_SESSION_ID);
gst_sdp_message_set_origin (ret, "-", sess_id, "0", "IN", "IP4", "0.0.0.0");
g_free (sess_id);
}
gst_sdp_message_set_session_name (ret, "-");
gst_sdp_message_add_time (ret, "0", "0", NULL);
gst_sdp_message_add_attribute (ret, "ice-options", "trickle");
/* for each rtp transceiver */
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *trans;
GstSDPMedia media = { 0, };
gchar *ufrag, *pwd;
trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
gst_sdp_media_init (&media);
/* mandated by JSEP */
gst_sdp_media_add_attribute (&media, "setup", "actpass");
/* FIXME: only needed when restarting ICE */
_generate_ice_credentials (&ufrag, &pwd);
gst_sdp_media_add_attribute (&media, "ice-ufrag", ufrag);
gst_sdp_media_add_attribute (&media, "ice-pwd", pwd);
g_free (ufrag);
g_free (pwd);
if (sdp_media_from_transceiver (webrtc, &media, trans,
GST_WEBRTC_SDP_TYPE_OFFER, i))
gst_sdp_message_add_media (ret, &media);
else
gst_sdp_media_uninit (&media);
}
/* FIXME: pre-emptively setup receiving elements when needed */
/* XXX: only true for the initial offerer */
g_object_set (webrtc->priv->ice, "controller", TRUE, NULL);
return ret;
}
static GstSDPMessage *
_create_answer_task (GstWebRTCBin * webrtc, const GstStructure * options)
{
GstSDPMessage *ret = NULL;
const GstWebRTCSessionDescription *pending_remote =
webrtc->pending_remote_description;
int i;
if (!webrtc->pending_remote_description) {
GST_ERROR_OBJECT (webrtc,
"Asked to create an answer without a remote description");
return NULL;
}
gst_sdp_message_new (&ret);
/* FIXME: session id and version need special handling depending on the state we're in */
gst_sdp_message_set_version (ret, "0");
{
const GstSDPOrigin *offer_origin =
gst_sdp_message_get_origin (pending_remote->sdp);
gst_sdp_message_set_origin (ret, "-", offer_origin->sess_id, "0", "IN",
"IP4", "0.0.0.0");
}
gst_sdp_message_set_session_name (ret, "-");
for (i = 0; i < gst_sdp_message_attributes_len (pending_remote->sdp); i++) {
const GstSDPAttribute *attr =
gst_sdp_message_get_attribute (pending_remote->sdp, i);
if (g_strcmp0 (attr->key, "ice-options") == 0) {
gst_sdp_message_add_attribute (ret, attr->key, attr->value);
}
}
for (i = 0; i < gst_sdp_message_medias_len (pending_remote->sdp); i++) {
/* FIXME:
* bundle policy
*/
GstSDPMedia *media = NULL;
GstSDPMedia *offer_media;
GstWebRTCRTPTransceiver *rtp_trans = NULL;
WebRTCTransceiver *trans = NULL;
GstWebRTCRTPTransceiverDirection offer_dir, answer_dir;
GstWebRTCDTLSSetup offer_setup, answer_setup;
GstCaps *offer_caps, *answer_caps = NULL;
gchar *cert;
int j;
gst_sdp_media_new (&media);
gst_sdp_media_set_port_info (media, 9, 0);
gst_sdp_media_set_proto (media, "UDP/TLS/RTP/SAVPF");
gst_sdp_media_add_connection (media, "IN", "IP4", "0.0.0.0", 0, 0);
{
/* FIXME: only needed when restarting ICE */
gchar *ufrag, *pwd;
_generate_ice_credentials (&ufrag, &pwd);
gst_sdp_media_add_attribute (media, "ice-ufrag", ufrag);
gst_sdp_media_add_attribute (media, "ice-pwd", pwd);
g_free (ufrag);
g_free (pwd);
}
offer_media =
(GstSDPMedia *) gst_sdp_message_get_media (pending_remote->sdp, i);
for (j = 0; j < gst_sdp_media_attributes_len (offer_media); j++) {
const GstSDPAttribute *attr =
gst_sdp_media_get_attribute (offer_media, j);
if (g_strcmp0 (attr->key, "mid") == 0
|| g_strcmp0 (attr->key, "rtcp-mux") == 0) {
gst_sdp_media_add_attribute (media, attr->key, attr->value);
/* FIXME: handle anything we want to keep */
}
}
offer_caps = gst_caps_new_empty ();
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);
/* gst_sdp_media_get_caps_from_media() produces caps with name
* "application/x-unknown" which will fail intersection with
* "application/x-rtp" caps so mangle the returns caps to have the
* correct name here */
for (k = 0; k < gst_caps_get_size (caps); k++) {
GstStructure *s = gst_caps_get_structure (caps, k);
gst_structure_set_name (s, "application/x-rtp");
}
gst_caps_append (offer_caps, caps);
}
for (j = 0; j < webrtc->priv->transceivers->len; j++) {
GstCaps *trans_caps;
rtp_trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
j);
trans_caps = _find_codec_preferences (webrtc, rtp_trans, GST_PAD_SINK, i);
GST_TRACE_OBJECT (webrtc, "trying to compare %" GST_PTR_FORMAT
" and %" GST_PTR_FORMAT, offer_caps, trans_caps);
/* FIXME: technically this is a little overreaching as some fields we
* we can deal with not having and/or we may have unrecognized fields
* that we cannot actually support */
if (trans_caps) {
answer_caps = gst_caps_intersect (offer_caps, trans_caps);
if (answer_caps && !gst_caps_is_empty (answer_caps)) {
GST_LOG_OBJECT (webrtc,
"found compatible transceiver %" GST_PTR_FORMAT
" for offer media %u", trans, i);
if (trans_caps)
gst_caps_unref (trans_caps);
break;
} else {
if (answer_caps) {
gst_caps_unref (answer_caps);
answer_caps = NULL;
}
if (trans_caps)
gst_caps_unref (trans_caps);
rtp_trans = NULL;
}
} else {
rtp_trans = NULL;
}
}
if (rtp_trans) {
answer_dir = rtp_trans->direction;
if (!answer_caps)
goto rejected;
} else {
/* if no transceiver, then we only receive that stream and respond with
* the exact same caps */
/* FIXME: how to validate that subsequent elements can actually receive
* this payload/format */
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);
rtp_trans = GST_WEBRTC_RTP_TRANSCEIVER (trans);
rtp_trans->direction = answer_dir;
rtp_trans->mline = i;
} else {
trans = WEBRTC_TRANSCEIVER (rtp_trans);
}
/* set the new media direction */
offer_dir = _get_direction_from_media (offer_media);
answer_dir = _intersect_answer_directions (offer_dir, answer_dir);
if (answer_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE) {
GST_WARNING_OBJECT (webrtc, "Could not intersect offer direction with "
"transceiver direction");
goto rejected;
}
_media_replace_direction (media, answer_dir);
/* set the a=setup: attribute */
offer_setup = _get_dtls_setup_from_media (offer_media);
answer_setup = _intersect_dtls_setup (offer_setup);
if (answer_setup == GST_WEBRTC_DTLS_SETUP_NONE) {
GST_WARNING_OBJECT (webrtc, "Could not intersect offer direction with "
"transceiver direction");
goto rejected;
}
_media_replace_setup (media, answer_setup);
/* FIXME: bundle! */
if (!trans->stream) {
TransportStream *item = _find_transport_for_session (webrtc, i);
if (!item)
item = _create_transport_channel (webrtc, i);
webrtc_transceiver_set_transport (trans, item);
}
/* set the a=fingerprint: for this transport */
g_object_get (trans->stream->transport, "certificate", &cert, NULL);
{
gchar *fingerprint, *val;
fingerprint =
_generate_fingerprint_from_certificate (cert, G_CHECKSUM_SHA256);
g_free (cert);
val =
g_strdup_printf ("%s %s",
_g_checksum_to_webrtc_string (G_CHECKSUM_SHA256), fingerprint);
g_free (fingerprint);
gst_sdp_media_add_attribute (media, "fingerprint", val);
g_free (val);
}
if (0) {
rejected:
GST_INFO_OBJECT (webrtc, "media %u rejected", i);
gst_sdp_media_free (media);
gst_sdp_media_copy (offer_media, &media);
gst_sdp_media_set_port_info (media, 0, 0);
}
gst_sdp_message_add_media (ret, media);
gst_sdp_media_free (media);
gst_caps_unref (offer_caps);
}
/* FIXME: can we add not matched transceivers? */
/* XXX: only true for the initial offerer */
g_object_set (webrtc->priv->ice, "controller", FALSE, NULL);
return ret;
}
struct create_sdp
{
GstStructure *options;
GstPromise *promise;
GstWebRTCSDPType type;
};
static void
_create_sdp_task (GstWebRTCBin * webrtc, struct create_sdp *data)
{
GstWebRTCSessionDescription *desc = NULL;
GstSDPMessage *sdp = NULL;
GstStructure *s = NULL;
GST_INFO_OBJECT (webrtc, "creating %s sdp with options %" GST_PTR_FORMAT,
gst_webrtc_sdp_type_to_string (data->type), data->options);
if (data->type == GST_WEBRTC_SDP_TYPE_OFFER)
sdp = _create_offer_task (webrtc, data->options);
else if (data->type == GST_WEBRTC_SDP_TYPE_ANSWER)
sdp = _create_answer_task (webrtc, data->options);
else {
g_assert_not_reached ();
goto out;
}
if (sdp) {
desc = gst_webrtc_session_description_new (data->type, sdp);
s = gst_structure_new ("application/x-gst-promise",
gst_webrtc_sdp_type_to_string (data->type),
GST_TYPE_WEBRTC_SESSION_DESCRIPTION, desc, NULL);
}
out:
PC_UNLOCK (webrtc);
gst_promise_reply (data->promise, s);
PC_LOCK (webrtc);
if (desc)
gst_webrtc_session_description_free (desc);
}
static void
_free_create_sdp_data (struct create_sdp *data)
{
if (data->options)
gst_structure_free (data->options);
gst_promise_unref (data->promise);
g_free (data);
}
static void
gst_webrtc_bin_create_offer (GstWebRTCBin * webrtc,
const GstStructure * options, GstPromise * promise)
{
struct create_sdp *data = g_new0 (struct create_sdp, 1);
if (options)
data->options = gst_structure_copy (options);
data->promise = gst_promise_ref (promise);
data->type = GST_WEBRTC_SDP_TYPE_OFFER;
gst_webrtc_bin_enqueue_task (webrtc, (GstWebRTCBinFunc) _create_sdp_task,
data, (GDestroyNotify) _free_create_sdp_data);
}
static void
gst_webrtc_bin_create_answer (GstWebRTCBin * webrtc,
const GstStructure * options, GstPromise * promise)
{
struct create_sdp *data = g_new0 (struct create_sdp, 1);
if (options)
data->options = gst_structure_copy (options);
data->promise = gst_promise_ref (promise);
data->type = GST_WEBRTC_SDP_TYPE_ANSWER;
gst_webrtc_bin_enqueue_task (webrtc, (GstWebRTCBinFunc) _create_sdp_task,
data, (GDestroyNotify) _free_create_sdp_data);
}
static GstWebRTCBinPad *
_create_pad_for_sdp_media (GstWebRTCBin * webrtc, GstPadDirection direction,
guint media_idx)
{
GstWebRTCBinPad *pad;
gchar *pad_name;
pad_name =
g_strdup_printf ("%s_%u", direction == GST_PAD_SRC ? "src" : "sink",
media_idx);
pad = gst_webrtc_bin_pad_new (pad_name, direction);
g_free (pad_name);
pad->mlineindex = media_idx;
return pad;
}
static GstWebRTCRTPTransceiver *
_find_transceiver_for_sdp_media (GstWebRTCBin * webrtc,
const GstSDPMessage * sdp, guint media_idx)
{
const GstSDPMedia *media = gst_sdp_message_get_media (sdp, media_idx);
GstWebRTCRTPTransceiver *ret = NULL;
int i;
for (i = 0; i < gst_sdp_media_attributes_len (media); i++) {
const GstSDPAttribute *attr = gst_sdp_media_get_attribute (media, i);
if (g_strcmp0 (attr->key, "mid") == 0) {
if ((ret =
_find_transceiver (webrtc, attr->value,
(FindTransceiverFunc) match_for_mid)))
goto out;
}
}
ret = _find_transceiver (webrtc, &media_idx,
(FindTransceiverFunc) transceiver_match_for_mline);
out:
GST_TRACE_OBJECT (webrtc, "Found transceiver %" GST_PTR_FORMAT, ret);
return ret;
}
static GstPad *
_connect_input_stream (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
/*
* ,-------------------------webrtcbin-------------------------,
* ; ;
* ; ,-------rtpbin-------, ,--transport_send_%u--, ;
* ; ; send_rtp_src_%u o---o rtp_sink ; ;
* ; ; ; ; ; ;
* ; ; send_rtcp_src_%u o---o rtcp_sink ; ;
* ; sink_%u ; ; '---------------------' ;
* o----------o send_rtp_sink_%u ; ;
* ; '--------------------' ;
* '--------------------- -------------------------------------'
*/
GstPadTemplate *rtp_templ;
GstPad *rtp_sink;
gchar *pad_name;
WebRTCTransceiver *trans;
g_return_val_if_fail (pad->trans != NULL, NULL);
GST_INFO_OBJECT (pad, "linking input stream %u", pad->mlineindex);
rtp_templ =
_find_pad_template (webrtc->rtpbin, GST_PAD_SINK, GST_PAD_REQUEST,
"send_rtp_sink_%u");
g_assert (rtp_templ);
pad_name = g_strdup_printf ("send_rtp_sink_%u", pad->mlineindex);
rtp_sink =
gst_element_request_pad (webrtc->rtpbin, rtp_templ, pad_name, NULL);
g_free (pad_name);
gst_ghost_pad_set_target (GST_GHOST_PAD (pad), rtp_sink);
gst_object_unref (rtp_sink);
trans = WEBRTC_TRANSCEIVER (pad->trans);
if (!trans->stream) {
TransportStream *item;
/* FIXME: bundle */
item = _find_transport_for_session (webrtc, pad->mlineindex);
if (!item)
item = _create_transport_channel (webrtc, pad->mlineindex);
webrtc_transceiver_set_transport (trans, item);
}
pad_name = g_strdup_printf ("send_rtp_src_%u", pad->mlineindex);
if (!gst_element_link_pads (GST_ELEMENT (webrtc->rtpbin), pad_name,
GST_ELEMENT (trans->stream->send_bin), "rtp_sink"))
g_warn_if_reached ();
g_free (pad_name);
gst_element_sync_state_with_parent (GST_ELEMENT (trans->stream->send_bin));
return GST_PAD (pad);
}
/* output pads are receiving elements */
static GstWebRTCBinPad *
_connect_output_stream (GstWebRTCBin * webrtc, GstWebRTCBinPad * pad)
{
/*
* ,------------------------webrtcbin------------------------,
* ; ,---------rtpbin---------, ;
* ; ,-transport_receive_%u--, ; ; ;
* ; ; rtp_src o---o recv_rtp_sink_%u ; ;
* ; ; ; ; ; ;
* ; ; rtcp_src o---o recv_rtcp_sink_%u ; ;
* ; '-----------------------' ; ; ; src_%u
* ; ; recv_rtp_src_%u_%u_%u o--o
* ; '------------------------' ;
* '---------------------------------------------------------'
*/
gchar *pad_name;
WebRTCTransceiver *trans;
g_return_val_if_fail (pad->trans != NULL, NULL);
GST_INFO_OBJECT (pad, "linking output stream %u", pad->mlineindex);
trans = WEBRTC_TRANSCEIVER (pad->trans);
if (!trans->stream) {
TransportStream *item;
/* FIXME: bundle */
item = _find_transport_for_session (webrtc, pad->mlineindex);
if (!item)
item = _create_transport_channel (webrtc, pad->mlineindex);
webrtc_transceiver_set_transport (trans, item);
}
pad_name = g_strdup_printf ("recv_rtp_sink_%u", pad->mlineindex);
if (!gst_element_link_pads (GST_ELEMENT (trans->stream->receive_bin),
"rtp_src", GST_ELEMENT (webrtc->rtpbin), pad_name))
g_warn_if_reached ();
g_free (pad_name);
gst_element_sync_state_with_parent (GST_ELEMENT (trans->stream->receive_bin));
return pad;
}
typedef struct
{
guint mlineindex;
gchar *candidate;
} IceCandidateItem;
static void
_clear_ice_candidate_item (IceCandidateItem ** item)
{
g_free ((*item)->candidate);
g_free (*item);
}
static void
_add_ice_candidate (GstWebRTCBin * webrtc, IceCandidateItem * item)
{
GstWebRTCICEStream *stream;
stream = _find_ice_stream_for_session (webrtc, item->mlineindex);
if (stream == NULL) {
GST_WARNING_OBJECT (webrtc, "Unknown mline %u, ignoring", item->mlineindex);
return;
}
GST_LOG_OBJECT (webrtc, "adding ICE candidate with mline:%u, %s",
item->mlineindex, item->candidate);
gst_webrtc_ice_add_candidate (webrtc->priv->ice, stream, item->candidate);
}
static void
_update_transceiver_from_sdp_media (GstWebRTCBin * webrtc,
const GstSDPMessage * sdp, guint media_idx,
GstWebRTCRTPTransceiver * rtp_trans)
{
WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (rtp_trans);
TransportStream *stream = trans->stream;
GstWebRTCRTPTransceiverDirection prev_dir = rtp_trans->current_direction;
GstWebRTCRTPTransceiverDirection new_dir;
const GstSDPMedia *media = gst_sdp_message_get_media (sdp, media_idx);
GstWebRTCDTLSSetup new_setup;
gboolean new_rtcp_mux, new_rtcp_rsize;
int i;
rtp_trans->mline = media_idx;
for (i = 0; i < gst_sdp_media_attributes_len (media); i++) {
const GstSDPAttribute *attr = gst_sdp_media_get_attribute (media, i);
if (g_strcmp0 (attr->key, "mid") == 0) {
g_free (rtp_trans->mid);
rtp_trans->mid = g_strdup (attr->value);
}
}
if (!stream) {
/* FIXME: find an existing transport for e.g. bundle/reconfiguration */
stream = _find_transport_for_session (webrtc, media_idx);
if (!stream)
stream = _create_transport_channel (webrtc, media_idx);
webrtc_transceiver_set_transport (trans, stream);
}
{
const GstSDPMedia *local_media, *remote_media;
GstWebRTCRTPTransceiverDirection local_dir, remote_dir;
GstWebRTCDTLSSetup local_setup, remote_setup;
guint i, len;
const gchar *proto;
GstCaps *global_caps;
local_media =
gst_sdp_message_get_media (webrtc->current_local_description->sdp,
media_idx);
remote_media =
gst_sdp_message_get_media (webrtc->current_remote_description->sdp,
media_idx);
local_setup = _get_dtls_setup_from_media (local_media);
remote_setup = _get_dtls_setup_from_media (remote_media);
new_setup = _get_final_setup (local_setup, remote_setup);
if (new_setup == GST_WEBRTC_DTLS_SETUP_NONE)
return;
local_dir = _get_direction_from_media (local_media);
remote_dir = _get_direction_from_media (remote_media);
new_dir = _get_final_direction (local_dir, remote_dir);
if (new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE)
return;
/* get proto */
proto = gst_sdp_media_get_proto (media);
if (proto != NULL) {
/* Parse global SDP attributes once */
global_caps = gst_caps_new_empty_simple ("application/x-unknown");
GST_DEBUG_OBJECT (webrtc, "mapping sdp session level attributes to caps");
gst_sdp_message_attributes_to_caps (sdp, global_caps);
GST_DEBUG_OBJECT (webrtc, "mapping sdp media level attributes to caps");
gst_sdp_media_attributes_to_caps (media, global_caps);
/* clear the ptmap */
g_array_set_size (stream->ptmap, 0);
len = gst_sdp_media_formats_len (media);
for (i = 0; i < len; i++) {
GstCaps *caps, *outcaps;
GstStructure *s;
PtMapItem item;
gint pt;
pt = atoi (gst_sdp_media_get_format (media, i));
GST_DEBUG_OBJECT (webrtc, " looking at %d pt: %d", i, pt);
/* convert caps */
caps = gst_sdp_media_get_caps_from_media (media, pt);
if (caps == NULL) {
GST_WARNING_OBJECT (webrtc, " skipping pt %d without caps", pt);
continue;
}
/* Merge in global caps */
/* Intersect will merge in missing fields to the current caps */
outcaps = gst_caps_intersect (caps, global_caps);
gst_caps_unref (caps);
s = gst_caps_get_structure (outcaps, 0);
gst_structure_set_name (s, "application/x-rtp");
item.pt = pt;
item.caps = outcaps;
g_array_append_val (stream->ptmap, item);
}
gst_caps_unref (global_caps);
}
new_rtcp_mux = _media_has_attribute_key (local_media, "rtcp-mux")
&& _media_has_attribute_key (remote_media, "rtcp-mux");
new_rtcp_rsize = _media_has_attribute_key (local_media, "rtcp-rsize")
&& _media_has_attribute_key (remote_media, "rtcp-rsize");
{
GObject *session;
g_signal_emit_by_name (webrtc->rtpbin, "get-internal-session",
media_idx, &session);
if (session) {
g_object_set (session, "rtcp-reduced-size", new_rtcp_rsize, NULL);
g_object_unref (session);
}
}
}
if (prev_dir != GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE
&& prev_dir != new_dir) {
GST_FIXME_OBJECT (webrtc, "implement transceiver direction changes");
return;
}
/* FIXME: bundle! */
g_object_set (stream, "rtcp-mux", new_rtcp_mux, NULL);
if (new_dir != prev_dir) {
TransportReceiveBin *receive;
GST_TRACE_OBJECT (webrtc, "transceiver direction change");
/* FIXME: this may not always be true. e.g. bundle */
g_assert (media_idx == stream->session_id);
if (new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY ||
new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV) {
GstWebRTCBinPad *pad =
_find_pad_for_mline (webrtc, GST_PAD_SINK, media_idx);
if (pad) {
GST_DEBUG_OBJECT (webrtc, "found existing send pad %" GST_PTR_FORMAT
" for transceiver %" GST_PTR_FORMAT, pad, trans);
g_assert (pad->trans == rtp_trans);
g_assert (pad->mlineindex == media_idx);
gst_object_unref (pad);
} else {
GST_DEBUG_OBJECT (webrtc,
"creating new pad send pad for transceiver %" GST_PTR_FORMAT,
trans);
pad = _create_pad_for_sdp_media (webrtc, GST_PAD_SINK, media_idx);
pad->trans = gst_object_ref (rtp_trans);
_connect_input_stream (webrtc, pad);
_add_pad (webrtc, pad);
}
g_object_set (stream, "dtls-client",
new_setup == GST_WEBRTC_DTLS_SETUP_ACTIVE, NULL);
}
if (new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY ||
new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV) {
GstWebRTCBinPad *pad =
_find_pad_for_mline (webrtc, GST_PAD_SRC, media_idx);
if (pad) {
GST_DEBUG_OBJECT (webrtc, "found existing receive pad %" GST_PTR_FORMAT
" for transceiver %" GST_PTR_FORMAT, pad, trans);
g_assert (pad->trans == rtp_trans);
g_assert (pad->mlineindex == media_idx);
gst_object_unref (pad);
} else {
GST_DEBUG_OBJECT (webrtc,
"creating new receive pad for transceiver %" GST_PTR_FORMAT, trans);
pad = _create_pad_for_sdp_media (webrtc, GST_PAD_SRC, media_idx);
pad->trans = gst_object_ref (rtp_trans);
_connect_output_stream (webrtc, pad);
/* delay adding the pad until rtpbin creates the recv output pad
* to ghost to so queries/events travel through the pipeline correctly
* as soon as the pad is added */
_add_pad_to_list (webrtc, pad);
}
g_object_set (stream, "dtls-client",
new_setup == GST_WEBRTC_DTLS_SETUP_ACTIVE, NULL);
}
receive = TRANSPORT_RECEIVE_BIN (stream->receive_bin);
if (new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY ||
new_dir == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV)
transport_receive_bin_set_receive_state (receive, RECEIVE_STATE_PASS);
else
transport_receive_bin_set_receive_state (receive, RECEIVE_STATE_DROP);
rtp_trans->mline = media_idx;
rtp_trans->current_direction = new_dir;
}
}
static gboolean
_find_compatible_unassociated_transceiver (GstWebRTCRTPTransceiver * p1,
gconstpointer data)
{
if (p1->mid)
return FALSE;
if (p1->mline != -1)
return FALSE;
return TRUE;
}
static gboolean
_update_transceivers_from_sdp (GstWebRTCBin * webrtc, SDPSource source,
GstWebRTCSessionDescription * sdp)
{
int i;
for (i = 0; i < gst_sdp_message_medias_len (sdp->sdp); i++) {
const GstSDPMedia *media = gst_sdp_message_get_media (sdp->sdp, i);
GstWebRTCRTPTransceiver *trans;
/* skip rejected media */
if (gst_sdp_media_get_port (media) == 0)
continue;
trans = _find_transceiver_for_sdp_media (webrtc, sdp->sdp, i);
if (source == SDP_LOCAL && sdp->type == GST_WEBRTC_SDP_TYPE_OFFER && !trans) {
GST_ERROR ("State mismatch. Could not find local transceiver by mline.");
return FALSE;
} else {
if (trans) {
_update_transceiver_from_sdp_media (webrtc, sdp->sdp, i, trans);
} 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);
_update_transceiver_from_sdp_media (webrtc, sdp->sdp, i, trans);
}
}
}
return TRUE;
}
static void
_get_ice_credentials_from_sdp_media (const GstSDPMessage * sdp, guint media_idx,
gchar ** ufrag, gchar ** pwd)
{
int i;
*ufrag = NULL;
*pwd = NULL;
{
/* search in the corresponding media section */
const GstSDPMedia *media = gst_sdp_message_get_media (sdp, media_idx);
const gchar *tmp_ufrag =
gst_sdp_media_get_attribute_val (media, "ice-ufrag");
const gchar *tmp_pwd = gst_sdp_media_get_attribute_val (media, "ice-pwd");
if (tmp_ufrag && tmp_pwd) {
*ufrag = g_strdup (tmp_ufrag);
*pwd = g_strdup (tmp_pwd);
return;
}
}
/* then in the sdp message itself */
for (i = 0; i < gst_sdp_message_attributes_len (sdp); i++) {
const GstSDPAttribute *attr = gst_sdp_message_get_attribute (sdp, i);
if (g_strcmp0 (attr->key, "ice-ufrag") == 0) {
g_assert (!*ufrag);
*ufrag = g_strdup (attr->value);
} else if (g_strcmp0 (attr->key, "ice-pwd") == 0) {
g_assert (!*pwd);
*pwd = g_strdup (attr->value);
}
}
if (!*ufrag && !*pwd) {
/* Check in the medias themselves. According to JSEP, they should be
* identical FIXME: only for bundle-d streams */
for (i = 0; i < gst_sdp_message_medias_len (sdp); i++) {
const GstSDPMedia *media = gst_sdp_message_get_media (sdp, i);
const gchar *tmp_ufrag =
gst_sdp_media_get_attribute_val (media, "ice-ufrag");
const gchar *tmp_pwd = gst_sdp_media_get_attribute_val (media, "ice-pwd");
if (tmp_ufrag && tmp_pwd) {
*ufrag = g_strdup (tmp_ufrag);
*pwd = g_strdup (tmp_pwd);
break;
}
}
}
}
struct set_description
{
GstPromise *promise;
SDPSource source;
GstWebRTCSessionDescription *sdp;
};
/* http://w3c.github.io/webrtc-pc/#set-description */
static void
_set_description_task (GstWebRTCBin * webrtc, struct set_description *sd)
{
GstWebRTCSignalingState new_signaling_state = webrtc->signaling_state;
GError *error = NULL;
{
gchar *state = _enum_value_to_string (GST_TYPE_WEBRTC_SIGNALING_STATE,
webrtc->signaling_state);
gchar *type_str =
_enum_value_to_string (GST_TYPE_WEBRTC_SDP_TYPE, sd->sdp->type);
gchar *sdp_text = gst_sdp_message_as_text (sd->sdp->sdp);
GST_INFO_OBJECT (webrtc, "Attempting to set %s %s in the %s state",
_sdp_source_to_string (sd->source), type_str, state);
GST_TRACE_OBJECT (webrtc, "SDP contents\n%s", sdp_text);
g_free (sdp_text);
g_free (state);
g_free (type_str);
}
if (!validate_sdp (webrtc, sd->source, sd->sdp, &error)) {
GST_ERROR_OBJECT (webrtc, "%s", error->message);
goto out;
}
if (webrtc->priv->is_closed) {
GST_WARNING_OBJECT (webrtc, "we are closed");
goto out;
}
switch (sd->sdp->type) {
case GST_WEBRTC_SDP_TYPE_OFFER:{
if (sd->source == SDP_LOCAL) {
if (webrtc->pending_local_description)
gst_webrtc_session_description_free
(webrtc->pending_local_description);
webrtc->pending_local_description =
gst_webrtc_session_description_copy (sd->sdp);
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER;
} else {
if (webrtc->pending_remote_description)
gst_webrtc_session_description_free
(webrtc->pending_remote_description);
webrtc->pending_remote_description =
gst_webrtc_session_description_copy (sd->sdp);
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER;
}
break;
}
case GST_WEBRTC_SDP_TYPE_ANSWER:{
if (sd->source == SDP_LOCAL) {
if (webrtc->current_local_description)
gst_webrtc_session_description_free
(webrtc->current_local_description);
webrtc->current_local_description =
gst_webrtc_session_description_copy (sd->sdp);
if (webrtc->current_remote_description)
gst_webrtc_session_description_free
(webrtc->current_remote_description);
webrtc->current_remote_description = webrtc->pending_remote_description;
webrtc->pending_remote_description = NULL;
} else {
if (webrtc->current_remote_description)
gst_webrtc_session_description_free
(webrtc->current_remote_description);
webrtc->current_remote_description =
gst_webrtc_session_description_copy (sd->sdp);
if (webrtc->current_local_description)
gst_webrtc_session_description_free
(webrtc->current_local_description);
webrtc->current_local_description = webrtc->pending_local_description;
webrtc->pending_local_description = NULL;
}
if (webrtc->pending_local_description)
gst_webrtc_session_description_free (webrtc->pending_local_description);
webrtc->pending_local_description = NULL;
if (webrtc->pending_remote_description)
gst_webrtc_session_description_free
(webrtc->pending_remote_description);
webrtc->pending_remote_description = NULL;
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_STABLE;
break;
}
case GST_WEBRTC_SDP_TYPE_ROLLBACK:{
GST_FIXME_OBJECT (webrtc, "rollbacks are completely untested");
if (sd->source == SDP_LOCAL) {
if (webrtc->pending_local_description)
gst_webrtc_session_description_free
(webrtc->pending_local_description);
webrtc->pending_local_description = NULL;
} else {
if (webrtc->pending_remote_description)
gst_webrtc_session_description_free
(webrtc->pending_remote_description);
webrtc->pending_remote_description = NULL;
}
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_STABLE;
break;
}
case GST_WEBRTC_SDP_TYPE_PRANSWER:{
GST_FIXME_OBJECT (webrtc, "pranswers are completely untested");
if (sd->source == SDP_LOCAL) {
if (webrtc->pending_local_description)
gst_webrtc_session_description_free
(webrtc->pending_local_description);
webrtc->pending_local_description =
gst_webrtc_session_description_copy (sd->sdp);
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER;
} else {
if (webrtc->pending_remote_description)
gst_webrtc_session_description_free
(webrtc->pending_remote_description);
webrtc->pending_remote_description =
gst_webrtc_session_description_copy (sd->sdp);
new_signaling_state = GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER;
}
break;
}
}
if (new_signaling_state != webrtc->signaling_state) {
gchar *from = _enum_value_to_string (GST_TYPE_WEBRTC_SIGNALING_STATE,
webrtc->signaling_state);
gchar *to = _enum_value_to_string (GST_TYPE_WEBRTC_SIGNALING_STATE,
new_signaling_state);
GST_TRACE_OBJECT (webrtc, "notify signaling-state from %s "
"to %s", from, to);
webrtc->signaling_state = new_signaling_state;
PC_UNLOCK (webrtc);
g_object_notify (G_OBJECT (webrtc), "signaling-state");
PC_LOCK (webrtc);
g_free (from);
g_free (to);
}
/* TODO: necessary data channel modifications */
if (sd->sdp->type == GST_WEBRTC_SDP_TYPE_ROLLBACK) {
/* FIXME:
* If the mid value of an RTCRtpTransceiver was set to a non-null value
* by the RTCSessionDescription that is being rolled back, set the mid
* value of that transceiver to null, as described by [JSEP]
* (section 4.1.7.2.).
* If an RTCRtpTransceiver was created by applying the
* RTCSessionDescription that is being rolled back, and a track has not
* been attached to it via addTrack, remove that transceiver from
* connection's set of transceivers, as described by [JSEP]
* (section 4.1.7.2.).
* Restore the value of connection's [[ sctpTransport]] internal slot
* to its value at the last stable signaling state.
*/
}
if (webrtc->signaling_state == GST_WEBRTC_SIGNALING_STATE_STABLE) {
gboolean prev_need_negotiation = webrtc->priv->need_negotiation;
/* media modifications */
_update_transceivers_from_sdp (webrtc, sd->source, sd->sdp);
/* 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
* connection's [[needNegotiation]] slot and, if still true, fire a
* simple event named negotiationneeded at connection.*/
_update_need_negotiation (webrtc);
if (prev_need_negotiation && webrtc->priv->need_negotiation) {
_check_need_negotiation_task (webrtc, NULL);
}
}
if (sd->source == SDP_LOCAL) {
int i;
for (i = 0; i < gst_sdp_message_medias_len (sd->sdp->sdp); i++) {
gchar *ufrag, *pwd;
TransportStream *item;
/* FIXME: bundle */
item = _find_transport_for_session (webrtc, i);
if (!item)
item = _create_transport_channel (webrtc, i);
_get_ice_credentials_from_sdp_media (sd->sdp->sdp, i, &ufrag, &pwd);
gst_webrtc_ice_set_local_credentials (webrtc->priv->ice,
item->stream, ufrag, pwd);
g_free (ufrag);
g_free (pwd);
}
}
if (sd->source == SDP_REMOTE) {
int i;
for (i = 0; i < gst_sdp_message_medias_len (sd->sdp->sdp); i++) {
gchar *ufrag, *pwd;
TransportStream *item;
/* FIXME: bundle */
item = _find_transport_for_session (webrtc, i);
if (!item)
item = _create_transport_channel (webrtc, i);
_get_ice_credentials_from_sdp_media (sd->sdp->sdp, i, &ufrag, &pwd);
gst_webrtc_ice_set_remote_credentials (webrtc->priv->ice,
item->stream, ufrag, pwd);
g_free (ufrag);
g_free (pwd);
}
}
{
int i;
for (i = 0; i < webrtc->priv->ice_stream_map->len; i++) {
IceStreamItem *item =
&g_array_index (webrtc->priv->ice_stream_map, IceStreamItem, i);
gst_webrtc_ice_gather_candidates (webrtc->priv->ice, item->stream);
}
}
if (webrtc->current_local_description && webrtc->current_remote_description) {
int i;
for (i = 0; i < webrtc->priv->pending_ice_candidates->len; i++) {
IceCandidateItem *item =
g_array_index (webrtc->priv->pending_ice_candidates,
IceCandidateItem *, i);
_add_ice_candidate (webrtc, item);
}
g_array_set_size (webrtc->priv->pending_ice_candidates, 0);
}
out:
PC_UNLOCK (webrtc);
gst_promise_reply (sd->promise, NULL);
PC_LOCK (webrtc);
}
static void
_free_set_description_data (struct set_description *sd)
{
if (sd->promise)
gst_promise_unref (sd->promise);
if (sd->sdp)
gst_webrtc_session_description_free (sd->sdp);
g_free (sd);
}
static void
gst_webrtc_bin_set_remote_description (GstWebRTCBin * webrtc,
GstWebRTCSessionDescription * remote_sdp, GstPromise * promise)
{
struct set_description *sd;
if (remote_sdp == NULL)
goto bad_input;
if (remote_sdp->sdp == NULL)
goto bad_input;
sd = g_new0 (struct set_description, 1);
if (promise != NULL)
sd->promise = gst_promise_ref (promise);
sd->source = SDP_REMOTE;
sd->sdp = gst_webrtc_session_description_copy (remote_sdp);
gst_webrtc_bin_enqueue_task (webrtc, (GstWebRTCBinFunc) _set_description_task,
sd, (GDestroyNotify) _free_set_description_data);
return;
bad_input:
{
gst_promise_reply (promise, NULL);
g_return_if_reached ();
}
}
static void
gst_webrtc_bin_set_local_description (GstWebRTCBin * webrtc,
GstWebRTCSessionDescription * local_sdp, GstPromise * promise)
{
struct set_description *sd;
if (local_sdp == NULL)
goto bad_input;
if (local_sdp->sdp == NULL)
goto bad_input;
sd = g_new0 (struct set_description, 1);
if (promise != NULL)
sd->promise = gst_promise_ref (promise);
sd->source = SDP_LOCAL;
sd->sdp = gst_webrtc_session_description_copy (local_sdp);
gst_webrtc_bin_enqueue_task (webrtc, (GstWebRTCBinFunc) _set_description_task,
sd, (GDestroyNotify) _free_set_description_data);
return;
bad_input:
{
gst_promise_reply (promise, NULL);
g_return_if_reached ();
}
}
static void
_add_ice_candidate_task (GstWebRTCBin * webrtc, IceCandidateItem * item)
{
if (!webrtc->current_local_description || !webrtc->current_remote_description) {
IceCandidateItem *new = g_new0 (IceCandidateItem, 1);
new->mlineindex = item->mlineindex;
new->candidate = g_strdup (item->candidate);
g_array_append_val (webrtc->priv->pending_ice_candidates, new);
} else {
_add_ice_candidate (webrtc, item);
}
}
static void
_free_ice_candidate_item (IceCandidateItem * item)
{
_clear_ice_candidate_item (&item);
}
static void
gst_webrtc_bin_add_ice_candidate (GstWebRTCBin * webrtc, guint mline,
const gchar * attr)
{
IceCandidateItem *item;
item = g_new0 (IceCandidateItem, 1);
item->mlineindex = mline;
if (!g_ascii_strncasecmp (attr, "a=candidate:", 12))
item->candidate = g_strdup (attr);
else if (!g_ascii_strncasecmp (attr, "candidate:", 10))
item->candidate = g_strdup_printf ("a=%s", attr);
gst_webrtc_bin_enqueue_task (webrtc,
(GstWebRTCBinFunc) _add_ice_candidate_task, item,
(GDestroyNotify) _free_ice_candidate_item);
}
static void
_on_ice_candidate_task (GstWebRTCBin * webrtc, IceCandidateItem * item)
{
const gchar *cand = item->candidate;
if (!g_ascii_strncasecmp (cand, "a=candidate:", 12)) {
/* stripping away "a=" */
cand += 2;
}
GST_TRACE_OBJECT (webrtc, "produced ICE candidate for mline:%u and %s",
item->mlineindex, cand);
PC_UNLOCK (webrtc);
g_signal_emit (webrtc, gst_webrtc_bin_signals[ON_ICE_CANDIDATE_SIGNAL],
0, item->mlineindex, cand);
PC_LOCK (webrtc);
}
static void
_on_ice_candidate (GstWebRTCICE * ice, guint session_id,
gchar * candidate, GstWebRTCBin * webrtc)
{
IceCandidateItem *item = g_new0 (IceCandidateItem, 1);
/* FIXME: bundle support */
item->mlineindex = session_id;
item->candidate = g_strdup (candidate);
gst_webrtc_bin_enqueue_task (webrtc,
(GstWebRTCBinFunc) _on_ice_candidate_task, item,
(GDestroyNotify) _free_ice_candidate_item);
}
/* https://www.w3.org/TR/webrtc/#dfn-stats-selection-algorithm */
static GstStructure *
_get_stats_from_selector (GstWebRTCBin * webrtc, gpointer selector)
{
if (selector)
GST_FIXME_OBJECT (webrtc, "Implement stats selection");
return gst_structure_copy (webrtc->priv->stats);
}
struct get_stats
{
GstPad *pad;
GstPromise *promise;
};
static void
_free_get_stats (struct get_stats *stats)
{
if (stats->pad)
gst_object_unref (stats->pad);
if (stats->promise)
gst_promise_unref (stats->promise);
g_free (stats);
}
/* https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-getstats() */
static void
_get_stats_task (GstWebRTCBin * webrtc, struct get_stats *stats)
{
GstStructure *s;
gpointer selector = NULL;
gst_webrtc_bin_update_stats (webrtc);
if (stats->pad) {
GstWebRTCBinPad *wpad = GST_WEBRTC_BIN_PAD (stats->pad);
if (wpad->trans) {
if (GST_PAD_DIRECTION (wpad) == GST_PAD_SRC) {
selector = wpad->trans->receiver;
} else {
selector = wpad->trans->sender;
}
}
}
s = _get_stats_from_selector (webrtc, selector);
gst_promise_reply (stats->promise, s);
}
static void
gst_webrtc_bin_get_stats (GstWebRTCBin * webrtc, GstPad * pad,
GstPromise * promise)
{
struct get_stats *stats;
g_return_if_fail (promise != NULL);
g_return_if_fail (pad == NULL || GST_IS_WEBRTC_BIN_PAD (pad));
stats = g_new0 (struct get_stats, 1);
stats->promise = gst_promise_ref (promise);
/* FIXME: check that pad exists in element */
if (pad)
stats->pad = gst_object_ref (pad);
gst_webrtc_bin_enqueue_task (webrtc, (GstWebRTCBinFunc) _get_stats_task,
stats, (GDestroyNotify) _free_get_stats);
}
static GstWebRTCRTPTransceiver *
gst_webrtc_bin_add_transceiver (GstWebRTCBin * webrtc,
GstWebRTCRTPTransceiverDirection direction, GstCaps * caps)
{
WebRTCTransceiver *trans;
GstWebRTCRTPTransceiver *rtp_trans;
g_return_val_if_fail (direction != GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE,
NULL);
trans = _create_webrtc_transceiver (webrtc);
rtp_trans = GST_WEBRTC_RTP_TRANSCEIVER (trans);
rtp_trans->direction = direction;
if (caps)
rtp_trans->codec_preferences = gst_caps_ref (caps);
return gst_object_ref (trans);
}
static void
_deref_and_unref (GstObject ** object)
{
if (object)
gst_object_unref (*object);
}
static GArray *
gst_webrtc_bin_get_transceivers (GstWebRTCBin * webrtc)
{
GArray *arr = g_array_new (FALSE, TRUE, sizeof (gpointer));
int i;
g_array_set_clear_func (arr, (GDestroyNotify) _deref_and_unref);
for (i = 0; i < webrtc->priv->transceivers->len; i++) {
GstWebRTCRTPTransceiver *trans =
g_array_index (webrtc->priv->transceivers, GstWebRTCRTPTransceiver *,
i);
gst_object_ref (trans);
g_array_append_val (arr, trans);
}
return arr;
}
/* === rtpbin signal implementations === */
static void
on_rtpbin_pad_added (GstElement * rtpbin, GstPad * new_pad,
GstWebRTCBin * webrtc)
{
gchar *new_pad_name = NULL;
new_pad_name = gst_pad_get_name (new_pad);
GST_TRACE_OBJECT (webrtc, "new rtpbin pad %s", new_pad_name);
if (g_str_has_prefix (new_pad_name, "recv_rtp_src_")) {
guint32 session_id = 0, ssrc = 0, pt = 0;
GstWebRTCRTPTransceiver *rtp_trans;
WebRTCTransceiver *trans;
TransportStream *stream;
GstWebRTCBinPad *pad;
if (sscanf (new_pad_name, "recv_rtp_src_%u_%u_%u", &session_id, &ssrc, &pt)) {
g_critical ("Invalid rtpbin pad name \'%s\'", new_pad_name);
return;
}
stream = _find_transport_for_session (webrtc, session_id);
if (!stream)
g_warn_if_reached ();
/* FIXME: bundle! */
rtp_trans = _find_transceiver_for_mline (webrtc, session_id);
if (!rtp_trans)
g_warn_if_reached ();
trans = WEBRTC_TRANSCEIVER (rtp_trans);
g_assert (trans->stream == stream);
pad = _find_pad_for_transceiver (webrtc, GST_PAD_SRC, rtp_trans);
GST_TRACE_OBJECT (webrtc, "found pad %" GST_PTR_FORMAT
" for rtpbin pad name %s", pad, new_pad_name);
if (!pad)
g_warn_if_reached ();
gst_ghost_pad_set_target (GST_GHOST_PAD (pad), GST_PAD (new_pad));
if (webrtc->priv->running)
gst_pad_set_active (GST_PAD (pad), TRUE);
gst_element_add_pad (GST_ELEMENT (webrtc), GST_PAD (pad));
_remove_pending_pad (webrtc, pad);
gst_object_unref (pad);
}
g_free (new_pad_name);
}
/* only used for the receiving streams */
static GstCaps *
on_rtpbin_request_pt_map (GstElement * rtpbin, guint session_id, guint pt,
GstWebRTCBin * webrtc)
{
TransportStream *stream;
GstCaps *ret;
GST_DEBUG_OBJECT (webrtc, "getting pt map for pt %d in session %d", pt,
session_id);
stream = _find_transport_for_session (webrtc, session_id);
if (!stream)
goto unknown_session;
if ((ret = _transport_stream_get_caps_for_pt (stream, pt)))
gst_caps_ref (ret);
GST_TRACE_OBJECT (webrtc, "Found caps %" GST_PTR_FORMAT " for pt %d in "
"session %d", ret, pt, session_id);
return ret;
unknown_session:
{
GST_DEBUG_OBJECT (webrtc, "unknown session %d", session_id);
return NULL;
}
}
static GstElement *
on_rtpbin_request_aux_sender (GstElement * rtpbin, guint session_id,
GstWebRTCBin * webrtc)
{
return NULL;
}
static GstElement *
on_rtpbin_request_aux_receiver (GstElement * rtpbin, guint session_id,
GstWebRTCBin * webrtc)
{
return NULL;
}
static void
on_rtpbin_ssrc_active (GstElement * rtpbin, guint session_id, guint ssrc,
GstWebRTCBin * webrtc)
{
}
static void
on_rtpbin_new_jitterbuffer (GstElement * rtpbin, GstElement * jitterbuffer,
guint session_id, guint ssrc, GstWebRTCBin * webrtc)
{
}
static GstElement *
_create_rtpbin (GstWebRTCBin * webrtc)
{
GstElement *rtpbin;
if (!(rtpbin = gst_element_factory_make ("rtpbin", "rtpbin")))
return NULL;
/* mandated by WebRTC */
gst_util_set_object_arg (G_OBJECT (rtpbin), "rtp-profile", "savpf");
g_signal_connect (rtpbin, "pad-added", G_CALLBACK (on_rtpbin_pad_added),
webrtc);
g_signal_connect (rtpbin, "request-pt-map",
G_CALLBACK (on_rtpbin_request_pt_map), webrtc);
g_signal_connect (rtpbin, "request-aux-sender",
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, "on-ssrc-active",
G_CALLBACK (on_rtpbin_ssrc_active), webrtc);
g_signal_connect (rtpbin, "new-jitterbuffer",
G_CALLBACK (on_rtpbin_new_jitterbuffer), webrtc);
return rtpbin;
}
static GstStateChangeReturn
gst_webrtc_bin_change_state (GstElement * element, GstStateChange transition)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (element);
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG ("changing state: %s => %s",
gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:{
GstElement *nice;
if (!webrtc->rtpbin) {
/* FIXME: is this the right thing for a missing plugin? */
GST_ELEMENT_ERROR (webrtc, CORE, MISSING_PLUGIN, (NULL),
("%s", "rtpbin element is not available"));
return GST_STATE_CHANGE_FAILURE;
}
nice = gst_element_factory_make ("nicesrc", NULL);
if (!nice) {
/* FIXME: is this the right thing for a missing plugin? */
GST_ELEMENT_ERROR (webrtc, CORE, MISSING_PLUGIN, (NULL),
("%s", "libnice elements are not available"));
return GST_STATE_CHANGE_FAILURE;
}
gst_object_unref (nice);
nice = gst_element_factory_make ("nicesink", NULL);
if (!nice) {
/* FIXME: is this the right thing for a missing plugin? */
GST_ELEMENT_ERROR (webrtc, CORE, MISSING_PLUGIN, (NULL),
("%s", "libnice elements are not available"));
return GST_STATE_CHANGE_FAILURE;
}
gst_object_unref (nice);
_update_need_negotiation (webrtc);
break;
}
case GST_STATE_CHANGE_READY_TO_PAUSED:
webrtc->priv->running = TRUE;
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* Mangle the return value to NO_PREROLL as that's what really is
* occurring here however cannot be propagated correctly due to nicesrc
* requiring that it be in PLAYING already in order to send/receive
* correctly :/ */
ret = GST_STATE_CHANGE_NO_PREROLL;
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
webrtc->priv->running = FALSE;
break;
default:
break;
}
return ret;
}
static GstPad *
gst_webrtc_bin_request_new_pad (GstElement * element, GstPadTemplate * templ,
const gchar * name, const GstCaps * caps)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (element);
GstWebRTCBinPad *pad = NULL;
GstPluginFeature *feature;
guint serial;
feature = gst_registry_lookup_feature (gst_registry_get (), "nicesrc");
if (feature) {
gst_object_unref (feature);
} else {
GST_ELEMENT_ERROR (element, CORE, MISSING_PLUGIN, NULL,
("%s", "libnice elements are not available"));
return NULL;
}
feature = gst_registry_lookup_feature (gst_registry_get (), "nicesink");
if (feature) {
gst_object_unref (feature);
} else {
GST_ELEMENT_ERROR (element, CORE, MISSING_PLUGIN, NULL,
("%s", "libnice elements are not available"));
return NULL;
}
if (templ->direction == GST_PAD_SINK ||
g_strcmp0 (templ->name_template, "sink_%u") == 0) {
GstWebRTCRTPTransceiver *trans;
GST_OBJECT_LOCK (webrtc);
if (name == NULL || strlen (name) < 6 || !g_str_has_prefix (name, "sink_")) {
/* no name given when requesting the pad, use next available int */
serial = webrtc->priv->max_sink_pad_serial++;
} else {
/* parse serial number from requested padname */
serial = g_ascii_strtoull (&name[5], NULL, 10);
if (serial > webrtc->priv->max_sink_pad_serial)
webrtc->priv->max_sink_pad_serial = serial;
}
GST_OBJECT_UNLOCK (webrtc);
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;
}
pad->trans = gst_object_ref (trans);
_connect_input_stream (webrtc, pad);
/* TODO: update negotiation-needed */
_add_pad (webrtc, pad);
}
return GST_PAD (pad);
}
static void
gst_webrtc_bin_release_pad (GstElement * element, GstPad * pad)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (element);
GstWebRTCBinPad *webrtc_pad = GST_WEBRTC_BIN_PAD (pad);
if (webrtc_pad->trans)
gst_object_unref (webrtc_pad->trans);
webrtc_pad->trans = NULL;
_remove_pad (webrtc, webrtc_pad);
}
static void
gst_webrtc_bin_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (object);
switch (prop_id) {
case PROP_STUN_SERVER:
case PROP_TURN_SERVER:
g_object_set_property (G_OBJECT (webrtc->priv->ice), pspec->name, value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_webrtc_bin_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (object);
PC_LOCK (webrtc);
switch (prop_id) {
case PROP_CONNECTION_STATE:
g_value_set_enum (value, webrtc->peer_connection_state);
break;
case PROP_SIGNALING_STATE:
g_value_set_enum (value, webrtc->signaling_state);
break;
case PROP_ICE_GATHERING_STATE:
g_value_set_enum (value, webrtc->ice_gathering_state);
break;
case PROP_ICE_CONNECTION_STATE:
g_value_set_enum (value, webrtc->ice_connection_state);
break;
case PROP_LOCAL_DESCRIPTION:
if (webrtc->pending_local_description)
g_value_set_boxed (value, webrtc->pending_local_description);
else if (webrtc->current_local_description)
g_value_set_boxed (value, webrtc->current_local_description);
else
g_value_set_boxed (value, NULL);
break;
case PROP_CURRENT_LOCAL_DESCRIPTION:
g_value_set_boxed (value, webrtc->current_local_description);
break;
case PROP_PENDING_LOCAL_DESCRIPTION:
g_value_set_boxed (value, webrtc->pending_local_description);
break;
case PROP_REMOTE_DESCRIPTION:
if (webrtc->pending_remote_description)
g_value_set_boxed (value, webrtc->pending_remote_description);
else if (webrtc->current_remote_description)
g_value_set_boxed (value, webrtc->current_remote_description);
else
g_value_set_boxed (value, NULL);
break;
case PROP_CURRENT_REMOTE_DESCRIPTION:
g_value_set_boxed (value, webrtc->current_remote_description);
break;
case PROP_PENDING_REMOTE_DESCRIPTION:
g_value_set_boxed (value, webrtc->pending_remote_description);
break;
case PROP_STUN_SERVER:
case PROP_TURN_SERVER:
g_object_get_property (G_OBJECT (webrtc->priv->ice), pspec->name, value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
PC_UNLOCK (webrtc);
}
static void
_free_pending_pad (GstPad * pad)
{
gst_object_unref (pad);
}
static void
gst_webrtc_bin_dispose (GObject * object)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (object);
_stop_thread (webrtc);
if (webrtc->priv->ice)
gst_object_unref (webrtc->priv->ice);
webrtc->priv->ice = NULL;
if (webrtc->priv->ice_stream_map)
g_array_free (webrtc->priv->ice_stream_map, TRUE);
webrtc->priv->ice_stream_map = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_webrtc_bin_finalize (GObject * object)
{
GstWebRTCBin *webrtc = GST_WEBRTC_BIN (object);
if (webrtc->priv->transports)
g_array_free (webrtc->priv->transports, TRUE);
webrtc->priv->transports = NULL;
if (webrtc->priv->transceivers)
g_array_free (webrtc->priv->transceivers, TRUE);
webrtc->priv->transceivers = NULL;
if (webrtc->priv->pending_ice_candidates)
g_array_free (webrtc->priv->pending_ice_candidates, TRUE);
webrtc->priv->pending_ice_candidates = NULL;
if (webrtc->priv->session_mid_map)
g_array_free (webrtc->priv->session_mid_map, TRUE);
webrtc->priv->session_mid_map = NULL;
if (webrtc->priv->pending_pads)
g_list_free_full (webrtc->priv->pending_pads,
(GDestroyNotify) _free_pending_pad);
webrtc->priv->pending_pads = NULL;
if (webrtc->current_local_description)
gst_webrtc_session_description_free (webrtc->current_local_description);
webrtc->current_local_description = NULL;
if (webrtc->pending_local_description)
gst_webrtc_session_description_free (webrtc->pending_local_description);
webrtc->pending_local_description = NULL;
if (webrtc->current_remote_description)
gst_webrtc_session_description_free (webrtc->current_remote_description);
webrtc->current_remote_description = NULL;
if (webrtc->pending_remote_description)
gst_webrtc_session_description_free (webrtc->pending_remote_description);
webrtc->pending_remote_description = NULL;
if (webrtc->priv->stats)
gst_structure_free (webrtc->priv->stats);
webrtc->priv->stats = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_webrtc_bin_class_init (GstWebRTCBinClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GstElementClass *element_class = (GstElementClass *) klass;
g_type_class_add_private (klass, sizeof (GstWebRTCBinPrivate));
element_class->request_new_pad = gst_webrtc_bin_request_new_pad;
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 (element_class, &src_template);
gst_element_class_set_metadata (element_class, "WebRTC Bin",
"Filter/Network/WebRTC", "A bin for webrtc connections",
"Matthew Waters <matthew@centricular.com>");
gobject_class->get_property = gst_webrtc_bin_get_property;
gobject_class->set_property = gst_webrtc_bin_set_property;
gobject_class->dispose = gst_webrtc_bin_dispose;
gobject_class->finalize = gst_webrtc_bin_finalize;
g_object_class_install_property (gobject_class,
PROP_LOCAL_DESCRIPTION,
g_param_spec_boxed ("local-description", "Local Description",
"The local SDP description to use for this connection",
GST_TYPE_WEBRTC_SESSION_DESCRIPTION,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_REMOTE_DESCRIPTION,
g_param_spec_boxed ("remote-description", "Remote Description",
"The remote SDP description to use for this connection",
GST_TYPE_WEBRTC_SESSION_DESCRIPTION,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_STUN_SERVER,
g_param_spec_string ("stun-server", "STUN Server",
"The STUN server of the form stun://hostname:port",
NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_TURN_SERVER,
g_param_spec_string ("turn-server", "TURN Server",
"The TURN server of the form turn(s)://username:password@host:port",
NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_CONNECTION_STATE,
g_param_spec_enum ("connection-state", "Connection State",
"The overall connection state of this element",
GST_TYPE_WEBRTC_PEER_CONNECTION_STATE,
GST_WEBRTC_PEER_CONNECTION_STATE_NEW,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_SIGNALING_STATE,
g_param_spec_enum ("signaling-state", "Signaling State",
"The signaling state of this element",
GST_TYPE_WEBRTC_SIGNALING_STATE,
GST_WEBRTC_SIGNALING_STATE_STABLE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_ICE_CONNECTION_STATE,
g_param_spec_enum ("ice-connection-state", "ICE connection state",
"The collective connection state of all ICETransport's",
GST_TYPE_WEBRTC_ICE_CONNECTION_STATE,
GST_WEBRTC_ICE_CONNECTION_STATE_NEW,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_ICE_GATHERING_STATE,
g_param_spec_enum ("ice-gathering-state", "ICE gathering state",
"The collective gathering state of all ICETransport's",
GST_TYPE_WEBRTC_ICE_GATHERING_STATE,
GST_WEBRTC_ICE_GATHERING_STATE_NEW,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
/**
* GstWebRTCBin::create-offer:
* @object: the #GstWebRtcBin
* @options: create-offer options
* @promise: a #GstPromise which will contain the offer
*/
gst_webrtc_bin_signals[CREATE_OFFER_SIGNAL] =
g_signal_new_class_handler ("create-offer", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_create_offer), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2, GST_TYPE_STRUCTURE,
GST_TYPE_PROMISE);
/**
* GstWebRTCBin::create-answer:
* @object: the #GstWebRtcBin
* @options: create-answer options
* @promise: a #GstPromise which will contain the answer
*/
gst_webrtc_bin_signals[CREATE_ANSWER_SIGNAL] =
g_signal_new_class_handler ("create-answer", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_create_answer), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2, GST_TYPE_STRUCTURE,
GST_TYPE_PROMISE);
/**
* GstWebRTCBin::set-local-description:
* @object: the #GstWebRtcBin
* @type: the type of description being set
* @sdp: a #GstSDPMessage description
* @promise (allow-none): a #GstPromise to be notified when it's set
*/
gst_webrtc_bin_signals[SET_LOCAL_DESCRIPTION_SIGNAL] =
g_signal_new_class_handler ("set-local-description",
G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_set_local_description), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2,
GST_TYPE_WEBRTC_SESSION_DESCRIPTION, GST_TYPE_PROMISE);
/**
* GstWebRTCBin::set-remote-description:
* @object: the #GstWebRtcBin
* @type: the type of description being set
* @sdp: a #GstSDPMessage description
* @promise (allow-none): a #GstPromise to be notified when it's set
*/
gst_webrtc_bin_signals[SET_REMOTE_DESCRIPTION_SIGNAL] =
g_signal_new_class_handler ("set-remote-description",
G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_set_remote_description), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2,
GST_TYPE_WEBRTC_SESSION_DESCRIPTION, GST_TYPE_PROMISE);
/**
* GstWebRTCBin::add-ice-candidate:
* @object: the #GstWebRtcBin
* @ice-candidate: an ice candidate
*/
gst_webrtc_bin_signals[ADD_ICE_CANDIDATE_SIGNAL] =
g_signal_new_class_handler ("add-ice-candidate",
G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_add_ice_candidate), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING);
/**
* GstWebRTCBin::get-stats:
* @object: the #GstWebRtcBin
* @promise: a #GstPromise for the result
*
* The @promise will contain the result of retrieving the session statistics.
* The structure will be named 'application/x-webrtc-stats and contain the
* following based on the webrtc-stats spec available from
* https://www.w3.org/TR/webrtc-stats/. As the webrtc-stats spec is a draft
* and is constantly changing these statistics may be changed to fit with
* the latest spec.
*
* Each field key is a unique identifer for each RTCStats
* (https://www.w3.org/TR/webrtc/#rtcstats-dictionary) value (another
* GstStructure) in the RTCStatsReport
* (https://www.w3.org/TR/webrtc/#rtcstatsreport-object). Each supported
* field in the RTCStats subclass is outlined below.
*
* Each statistics structure contains the following values as defined by
* the RTCStats dictionary (https://www.w3.org/TR/webrtc/#rtcstats-dictionary).
*
* "timestamp" G_TYPE_DOUBLE timestamp the statistics were generated
* "type" GST_TYPE_WEBRTC_STATS_TYPE the type of statistics reported
* "id" G_TYPE_STRING unique identifier
*
* RTCCodecStats supported fields (https://w3c.github.io/webrtc-stats/#codec-dict*)
*
* "payload-type" G_TYPE_UINT the rtp payload number in use
* "clock-rate" G_TYPE_UINT the rtp clock-rate
*
* RTCRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#streamstats-dict*)
*
* "ssrc" G_TYPE_STRING the rtp sequence src in use
* "transport-id" G_TYPE_STRING identifier for the associated RTCTransportStats for this stream
* "codec-id" G_TYPE_STRING identifier for the associated RTCCodecStats for this stream
* "fir-count" G_TYPE_UINT FIR requests received by the sender (only for local statistics)
* "pli-count" G_TYPE_UINT PLI requests received by the sender (only for local statistics)
* "nack-count" G_TYPE_UINT NACK requests received by the sender (only for local statistics)
*
* RTCReceivedStreamStats supported fields (https://w3c.github.io/webrtc-stats/#receivedrtpstats-dict*)
*
* "packets-received" G_TYPE_UINT64 number of packets received (only for local inbound)
* "bytes-received" G_TYPE_UINT64 number of bytes received (only for local inbound)
* "packets-lost" G_TYPE_UINT number of packets lost
* "jitter" G_TYPE_DOUBLE packet jitter measured in secondss
*
* RTCInboundRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#inboundrtpstats-dict*)
*
* "remote-id" G_TYPE_STRING identifier for the associated RTCRemoteOutboundRTPSTreamStats
*
* RTCRemoteInboundRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#remoteinboundrtpstats-dict*)
*
* "local-id" G_TYPE_STRING identifier for the associated RTCOutboundRTPSTreamStats
* "round-trip-time" G_TYPE_DOUBLE round trip time of packets measured in seconds
*
* RTCSentRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#sentrtpstats-dict*)
*
* "packets-sent" G_TYPE_UINT64 number of packets sent (only for local outbound)
* "bytes-sent" G_TYPE_UINT64 number of packets sent (only for local outbound)
*
* RTCOutboundRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*)
*
* "remote-id" G_TYPE_STRING identifier for the associated RTCRemoteInboundRTPSTreamStats
*
* RTCRemoteOutboundRTPStreamStats supported fields (https://w3c.github.io/webrtc-stats/#remoteoutboundrtpstats-dict*)
*
* "local-id" G_TYPE_STRING identifier for the associated RTCInboundRTPSTreamStats
*
*/
gst_webrtc_bin_signals[GET_STATS_SIGNAL] =
g_signal_new_class_handler ("get-stats",
G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_get_stats), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2, GST_TYPE_PAD,
GST_TYPE_PROMISE);
/**
* GstWebRTCBin::on-negotiation-needed:
* @object: the #GstWebRtcBin
*/
gst_webrtc_bin_signals[ON_NEGOTIATION_NEEDED_SIGNAL] =
g_signal_new ("on-negotiation-needed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
G_TYPE_NONE, 0);
/**
* GstWebRTCBin::on-ice-candidate:
* @object: the #GstWebRtcBin
* @candidate: the ICE candidate
*/
gst_webrtc_bin_signals[ON_ICE_CANDIDATE_SIGNAL] =
g_signal_new ("on-ice-candidate", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING);
/**
* GstWebRTCBin::add-transceiver:
* @object: the #GstWebRtcBin
* @direction: the direction of the new transceiver
* @caps: (allow none): the codec preferences for this transceiver
*
* Returns: the new #GstWebRTCRTPTransceiver
*/
gst_webrtc_bin_signals[ADD_TRANSCEIVER_SIGNAL] =
g_signal_new_class_handler ("add-transceiver", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_add_transceiver), NULL, NULL,
g_cclosure_marshal_generic, GST_TYPE_WEBRTC_RTP_TRANSCEIVER, 2,
GST_TYPE_WEBRTC_RTP_TRANSCEIVER_DIRECTION, GST_TYPE_CAPS);
/**
* GstWebRTCBin::get-transceivers:
* @object: the #GstWebRtcBin
*
* Returns: a #GArray of #GstWebRTCRTPTransceivers
*/
gst_webrtc_bin_signals[GET_TRANSCEIVERS_SIGNAL] =
g_signal_new_class_handler ("get-transceivers", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gst_webrtc_bin_get_transceivers), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_ARRAY, 0);
}
static void
_deref_unparent_and_unref (GObject ** object)
{
GstObject *obj = GST_OBJECT (*object);
GST_OBJECT_PARENT (obj) = NULL;
gst_object_unref (*object);
}
static void
_transport_free (GObject ** object)
{
TransportStream *stream = (TransportStream *) * object;
GstWebRTCBin *webrtc;
webrtc = GST_WEBRTC_BIN (GST_OBJECT_PARENT (stream));
if (stream->transport) {
g_signal_handlers_disconnect_by_data (stream->transport->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);
}
static void
gst_webrtc_bin_init (GstWebRTCBin * webrtc)
{
webrtc->priv =
G_TYPE_INSTANCE_GET_PRIVATE ((webrtc), GST_TYPE_WEBRTC_BIN,
GstWebRTCBinPrivate);
_start_thread (webrtc);
webrtc->rtpbin = _create_rtpbin (webrtc);
gst_bin_add (GST_BIN (webrtc), webrtc->rtpbin);
webrtc->priv->transceivers = g_array_new (FALSE, TRUE, sizeof (gpointer));
g_array_set_clear_func (webrtc->priv->transceivers,
(GDestroyNotify) _deref_unparent_and_unref);
webrtc->priv->transports = g_array_new (FALSE, TRUE, sizeof (gpointer));
g_array_set_clear_func (webrtc->priv->transports,
(GDestroyNotify) _transport_free);
webrtc->priv->session_mid_map =
g_array_new (FALSE, TRUE, sizeof (SessionMidItem));
g_array_set_clear_func (webrtc->priv->session_mid_map,
(GDestroyNotify) clear_session_mid_item);
webrtc->priv->ice = gst_webrtc_ice_new ();
g_signal_connect (webrtc->priv->ice, "on-ice-candidate",
G_CALLBACK (_on_ice_candidate), webrtc);
webrtc->priv->ice_stream_map =
g_array_new (FALSE, TRUE, sizeof (IceStreamItem));
webrtc->priv->pending_ice_candidates =
g_array_new (FALSE, TRUE, sizeof (IceCandidateItem *));
g_array_set_clear_func (webrtc->priv->pending_ice_candidates,
(GDestroyNotify) _clear_ice_candidate_item);
}