static GstPad *
kms_webrtc_rtp_connection_request_rtcp_src (KmsIRtpConnection * base_rtp_conn)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_rtp_conn);

  return gst_element_get_static_pad (self->priv->rtcp_tr->dtlssrtpdec,
      "rtcp_src");
}
static void
kms_webrtc_rtp_connection_add (KmsIRtpConnection * base_rtp_conn, GstBin * bin,
    gboolean active)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_rtp_conn);

  add_tr (self->priv->rtp_tr, bin, active);
  add_tr (self->priv->rtcp_tr, bin, active);
}
static void
kms_webrtc_rtp_connection_sink_sync_state_with_parent (KmsIRtpConnection *
    base_rtp_conn)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_rtp_conn);

  sync_tr_sink (self->priv->rtp_tr);
  sync_tr_sink (self->priv->rtcp_tr);
}
static gchar *
kms_webrtc_connection_get_certificate_pem (KmsWebRtcBaseConnection * base_conn)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_conn);
  gchar *pem;

  g_object_get (G_OBJECT (self->priv->rtp_tr->dtlssrtpdec), "pem", &pem, NULL);

  return pem;
}
示例#5
0
static void
kms_webrtc_rtp_connection_src_sync_state_with_parent (KmsIRtpConnection *
    base_rtp_conn)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_rtp_conn);
  GstElement *rtp_element = GST_ELEMENT (self->priv->rtp_tr->src);
  GstElement *rtcp_element = GST_ELEMENT (self->priv->rtcp_tr->src);

  gst_element_sync_state_with_parent_target_state (rtp_element);
  gst_element_sync_state_with_parent_target_state (rtcp_element);
}
static GstPad *
kms_webrtc_rtp_connection_request_rtcp_sink (KmsIRtpConnection * base_rtp_conn)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (base_rtp_conn);
  GstPad *pad;
  gchar *str;

  str = g_strdup_printf ("rtcp_sink_%d",
      g_atomic_int_add (&self->priv->rtcp_tr->rtcp_id, 1));

  pad = gst_element_get_request_pad (self->priv->rtcp_tr->dtlssrtpenc, str);
  g_free (str);

  return pad;
}
static void
kms_webrtc_connection_finalize (GObject * object)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (object);
  KmsWebRtcConnectionPrivate *priv = self->priv;

  GST_DEBUG_OBJECT (self, "finalize");

  kms_webrtc_transport_destroy (priv->rtp_tr);
  kms_webrtc_transport_destroy (priv->rtcp_tr);

  g_mutex_clear (&self->priv->mutex);

  /* chain up */
  G_OBJECT_CLASS (kms_webrtc_connection_parent_class)->finalize (object);
}
KmsWebRtcConnection *
kms_webrtc_connection_new (NiceAgent * agent, GMainContext * context,
    const gchar * name)
{
  GObject *obj;
  KmsWebRtcBaseConnection *base_conn;
  KmsWebRtcConnection *conn;
  KmsWebRtcConnectionPrivate *priv;

  obj = g_object_new (KMS_TYPE_WEBRTC_CONNECTION, NULL);
  base_conn = KMS_WEBRTC_BASE_CONNECTION (obj);
  conn = KMS_WEBRTC_CONNECTION (obj);
  priv = conn->priv;

  if (!kms_webrtc_base_connection_configure (base_conn, agent, name)) {
    g_object_unref (obj);
    return NULL;
  }

  priv->rtp_tr =
      kms_webrtc_transport_create (agent, base_conn->stream_id,
      NICE_COMPONENT_TYPE_RTP);
  priv->rtcp_tr =
      kms_webrtc_transport_create (agent, base_conn->stream_id,
      NICE_COMPONENT_TYPE_RTCP);

  if (priv->rtp_tr == NULL || priv->rtcp_tr == NULL) {
    GST_ERROR_OBJECT (obj, "Cannot create KmsWebRTCConnection.");
    g_object_unref (obj);
    return NULL;
  }

  g_signal_connect (priv->rtp_tr->dtlssrtpenc, "on-key-set",
      G_CALLBACK (rtp_connected_cb), conn);
  g_signal_connect (priv->rtcp_tr->dtlssrtpenc, "on-key-set",
      G_CALLBACK (rtcp_connected_cb), conn);

  nice_agent_attach_recv (agent, base_conn->stream_id,
      NICE_COMPONENT_TYPE_RTP, context, kms_webrtc_transport_nice_agent_recv_cb,
      NULL);
  nice_agent_attach_recv (agent, base_conn->stream_id, NICE_COMPONENT_TYPE_RTCP,
      context, kms_webrtc_transport_nice_agent_recv_cb, NULL);

  return conn;
}
static void
kms_webrtc_connection_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (object);

  switch (prop_id) {
    case PROP_ADDED:
      g_value_set_boolean (value, self->priv->added);
      break;
    case PROP_CONNECTED:
      g_value_set_boolean (value, self->priv->connected);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
示例#10
0
KmsWebRtcConnection *
kms_webrtc_connection_new (KmsIceBaseAgent * agent, GMainContext * context,
    const gchar * name, guint16 min_port, guint16 max_port,
    gchar * pem_certificate)
{
  GObject *obj;
  KmsWebRtcBaseConnection *base_conn;
  KmsWebRtcConnection *conn;
  KmsWebRtcConnectionPrivate *priv;

  obj = g_object_new (KMS_TYPE_WEBRTC_CONNECTION, "max-port", max_port,
      "min-port", min_port, NULL);
  base_conn = KMS_WEBRTC_BASE_CONNECTION (obj);
  conn = KMS_WEBRTC_CONNECTION (obj);
  priv = conn->priv;

  if (!kms_webrtc_base_connection_configure (base_conn, agent, name)) {
    g_object_unref (obj);
    return NULL;
  }

  priv->rtp_tr =
      kms_webrtc_transport_new (agent, base_conn->stream_id,
      NICE_COMPONENT_TYPE_RTP, pem_certificate);
  priv->rtcp_tr =
      kms_webrtc_transport_new (agent, base_conn->stream_id,
      NICE_COMPONENT_TYPE_RTCP, pem_certificate);

  if (priv->rtp_tr == NULL || priv->rtcp_tr == NULL) {
    GST_ERROR_OBJECT (obj, "Cannot create KmsWebRTCConnection.");
    g_object_unref (obj);
    return NULL;
  }

  g_signal_connect (priv->rtp_tr->sink->dtlssrtpenc, "on-key-set",
      G_CALLBACK (rtp_connected_cb), conn);
  g_signal_connect (priv->rtcp_tr->sink->dtlssrtpenc, "on-key-set",
      G_CALLBACK (rtcp_connected_cb), conn);

  return conn;
}
static void
kms_webrtc_rtp_connection_collect_latency_stats (KmsIRtpConnection * obj,
    gboolean enable)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (obj);
  KmsWebRtcBaseConnection *base = KMS_WEBRTC_BASE_CONNECTION (obj);

  KMS_WEBRTC_BASE_CONNECTION_LOCK (self);

  /* Only rtp stream is marked with metadata for statistics */

  if (enable) {
    kms_webrtc_transport_enable_latency_notification (self->priv->rtp_tr,
        base->cb, base->user_data, NULL);
  } else {
    kms_webrtc_transport_disable_latency_notification (self->priv->rtp_tr);
  }

  kms_webrtc_base_connection_collect_latency_stats (obj, enable);

  KMS_WEBRTC_BASE_CONNECTION_UNLOCK (self);
}
示例#12
0
static void
kms_webrtc_connection_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (object);

  switch (prop_id) {
    case PROP_ADDED:
      g_value_set_boolean (value, self->priv->added);
      break;
    case PROP_CONNECTED:
      g_value_set_boolean (value, self->priv->connected);
      break;
    case PROP_IS_CLIENT:{
      gboolean is_client;

      g_object_get (G_OBJECT (self->priv->rtp_tr->sink->dtlssrtpenc),
          "is-client", &is_client, NULL);
      g_value_set_boolean (value, is_client);
      break;
    }
    case PROP_MIN_PORT:
      g_value_set_uint (value, self->parent.min_port);
      break;
    case PROP_MAX_PORT:
      g_value_set_uint (value, self->parent.max_port);
      break;
    case PROP_TRANSPORT:
      g_value_set_object (value, self->priv->rtp_tr);
      break;
    case PROP_RTCP_TRANSPORT:
      g_value_set_object (value, self->priv->rtcp_tr);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
示例#13
0
static void
kms_webrtc_connection_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  KmsWebRtcConnection *self = KMS_WEBRTC_CONNECTION (object);

  switch (prop_id) {
    case PROP_ADDED:
      self->priv->added = g_value_get_boolean (value);
      break;
    case PROP_CONNECTED:
      self->priv->connected = g_value_get_boolean (value);
      break;
    case PROP_MIN_PORT:
      self->parent.min_port = g_value_get_uint (value);
      break;
    case PROP_MAX_PORT:
      self->parent.max_port = g_value_get_uint (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}