static gboolean
kms_sdp_rtp_media_handler_add_offer_attributes (KmsSdpMediaHandler * handler,
GstSDPMedia * offer, GError ** error)
{
KmsSdpRtpMediaHandler *self = KMS_SDP_RTP_MEDIA_HANDLER (handler);
if (self->priv->rtcp_entry) {
gchar *val, *addr, *addr_type;
g_object_get (self, "addr", &addr, "addr_type", &addr_type, NULL);
if (addr != NULL) {
val = g_strdup_printf ("%d IN %s %s", DEFAULT_RTCP_ENTRY_PORT, addr_type,
addr);
} else {
val = g_strdup_printf ("%d", DEFAULT_RTCP_ENTRY_PORT);
}
gst_sdp_media_add_attribute (offer, "rtcp", val);
g_free (addr_type);
g_free (addr);
g_free (val);
}
if (self->priv->rtcp_mux) {
gst_sdp_media_add_attribute (offer, "rtcp-mux", "");
}
return
KMS_SDP_MEDIA_HANDLER_CLASS (parent_class)->add_offer_attributes (handler,
offer, error);
}
static GstSDPMedia *
reject_media_answer (const GstSDPMedia * offered)
{
GstSDPMedia *media;
const gchar *mid;
guint i, len;
gst_sdp_media_new (&media);
/* [rfc3264] To reject an offered stream, the port number in the */
/* corresponding stream in the answer MUST be set to zero. Any */
/* media formats listed are ignored. */
gst_sdp_media_set_media (media, gst_sdp_media_get_media (offered));
gst_sdp_media_set_port_info (media, 0, 1);
gst_sdp_media_set_proto (media, gst_sdp_media_get_proto (offered));
len = gst_sdp_media_formats_len (offered);
for (i = 0; i < len; i++) {
const gchar *format;
format = gst_sdp_media_get_format (offered, i);
gst_sdp_media_insert_format (media, i, format);
}
/* [rfc5888] mid attribute must be present in answer as well */
mid = gst_sdp_media_get_attribute_val (offered, "mid");
if (mid == NULL) {
return media;
}
gst_sdp_media_add_attribute (media, "mid", mid);
return media;
}
static gboolean
kms_sdp_rtp_avpf_media_handler_filter_rtcp_fb_attrs (KmsSdpMediaHandler *
handler, const GstSDPMedia * offer, GstSDPMedia * answer, GError ** error)
{
KmsSdpRtpAvpfMediaHandler *self = KMS_SDP_RTP_AVPF_MEDIA_HANDLER (handler);
guint i;
for (i = 0;; i++) {
const gchar *val;
gchar **opts;
val = gst_sdp_media_get_attribute_val_n (offer, SDP_MEDIA_RTCP_FB, i);
if (val == NULL) {
return TRUE;
}
opts = g_strsplit (val, " ", 0);
if (!format_supported (answer, opts[0] /* format */ )) {
/* Ignore rtcp-fb attribute */
g_strfreev (opts);
continue;
}
if (g_strcmp0 (opts[1] /* rtcp-fb-val */ , SDP_MEDIA_RTCP_FB_NACK) == 0
&& !self->priv->nack) {
/* ignore rtcp-fb nack attribute */
g_strfreev (opts);
continue;
}
if (g_strcmp0 (opts[1] /* rtcp-fb-val */ , SDP_MEDIA_RTCP_FB_GOOG_REMB) == 0
&& !self->priv->remb) {
/* ignore rtcp-fb goog-remb attribute */
g_strfreev (opts);
continue;
}
if (!supported_rtcp_fb_val (opts[1] /* rtcp-fb-val */ )) {
/* ignore unsupported rtcp-fb attribute */
g_strfreev (opts);
continue;
}
if (gst_sdp_media_add_attribute (answer, SDP_MEDIA_RTCP_FB,
val) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"Cannot add media attribute 'a=%s:%s'", SDP_MEDIA_RTCP_FB, val);
g_strfreev (opts);
return FALSE;
}
g_strfreev (opts);
}
return TRUE;
}
GST_END_TEST
GST_START_TEST (modify)
{
GstSDPMessage *message;
glong length = -1;
const GstSDPMedia *media;
const gchar *old_val;
const gchar *result;
GstSDPAttribute attr;
gst_sdp_message_new (&message);
gst_sdp_message_parse_buffer ((guint8 *) sdp, length, message);
/* modify session attribute */
fail_unless (gst_sdp_message_add_attribute (message,
"test_attr_session", "param1=val1") == GST_SDP_OK);
old_val = gst_sdp_message_get_attribute_val (message, "test_attr_session");
fail_unless (old_val != NULL);
attr.key = g_strdup ("test_attr_session");
attr.value = g_strdup_printf ("%s;param2=val2", old_val);
fail_unless (gst_sdp_message_replace_attribute (message, 0,
&attr) == GST_SDP_OK);
result = gst_sdp_message_get_attribute_val (message, "test_attr_session");
fail_unless (result != NULL);
fail_unless (g_strcmp0 (result, "param1=val1;param2=val2") == 0);
/* modify media attribute */
media = gst_sdp_message_get_media (message, 0);
fail_unless (media != NULL);
fail_unless (gst_sdp_media_add_attribute ((GstSDPMedia *) media,
"test_attr_media", "param3=val3") == GST_SDP_OK);
old_val =
gst_sdp_media_get_attribute_val ((GstSDPMedia *) media,
"test_attr_media");
fail_unless (old_val != NULL);
attr.key = g_strdup ("test_attr_media");
attr.value = g_strdup ("myparam=myval");
fail_unless (gst_sdp_media_replace_attribute ((GstSDPMedia *) media,
0, &attr) == GST_SDP_OK);
result =
gst_sdp_media_get_attribute_val ((GstSDPMedia *) media,
"test_attr_media");
fail_unless (result != NULL);
fail_unless (g_strcmp0 (result, "myparam=myval") == 0);
gst_sdp_message_free (message);
}
static void
sdp_media_add_ice_candidate (GstSDPMedia * media, NiceAgent * agent,
NiceCandidate * cand)
{
gchar *str;
str = nice_agent_generate_local_candidate_sdp (agent, cand);
gst_sdp_media_add_attribute (media, SDP_CANDIDATE_ATTR,
str + SDP_CANDIDATE_ATTR_LEN);
g_free (str);
}
gboolean
kms_webrtc_session_set_ice_credentials (KmsWebrtcSession * self,
SdpMediaConfig * mconf)
{
GstSDPMedia *media = kms_sdp_media_config_get_sdp_media (mconf);
KmsWebRtcBaseConnection *conn;
gchar *ufrag, *pwd;
conn = kms_webrtc_session_get_connection (self, mconf);
if (conn == NULL) {
return FALSE;
}
kms_ice_base_agent_get_local_credentials (self->agent, conn->stream_id,
&ufrag, &pwd);
gst_sdp_media_add_attribute (media, SDP_ICE_UFRAG_ATTR, ufrag);
g_free (ufrag);
gst_sdp_media_add_attribute (media, SDP_ICE_PWD_ATTR, pwd);
g_free (pwd);
return TRUE;
}
static void
sdp_media_add_ice_candidate (GstSDPMedia * media, KmsIceBaseAgent * agent,
KmsIceCandidate * cand)
{
gchar *str;
str = kms_ice_base_agent_generate_local_candidate_sdp (agent, cand);
if (str != NULL) {
gst_sdp_media_add_attribute (media, SDP_CANDIDATE_ATTR,
str + SDP_CANDIDATE_ATTR_LEN);
g_free (str);
}
}
gboolean
kms_webrtc_session_set_crypto_info (KmsWebrtcSession * self,
SdpMediaConfig * mconf)
{
GstSDPMedia *media = kms_sdp_media_config_get_sdp_media (mconf);
gchar *fingerprint;
/* Crypto info */
fingerprint = kms_webrtc_session_generate_fingerprint_sdp_attr (self, mconf);
if (fingerprint == NULL) {
return FALSE;
}
gst_sdp_media_add_attribute (media, "fingerprint", fingerprint);
g_free (fingerprint);
return TRUE;
}
static gboolean
kms_sdp_sdes_ext_add_crypto_attr (KmsISdpMediaExtension * ext,
GstSDPMedia * media, guint tag, const gchar * key, SrtpCryptoSuite crypto,
const gchar * lifetime, const guint * mki, const guint * len,
GError ** error)
{
const gchar *crypto_str;
gboolean ret = TRUE;
gchar *val, *tmp;
crypto_str = srtp_crypto_suite_to_str (crypto);
if (crypto_str == NULL) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_INVALID_PARAMETER,
"Invalid crypto suite provided (%u)", crypto);
return FALSE;
}
val = g_strdup_printf ("%u %s %s:%s", tag, crypto_str, KEY_METHOD, key);
if (lifetime != NULL) {
tmp = val;
val = g_strdup_printf ("%s|%s", tmp, lifetime);
g_free (tmp);
}
if (mki != NULL && len != NULL) {
tmp = val;
val = g_strdup_printf ("%s|%u:%u", tmp, *mki, *len);
g_free (tmp);
}
if (gst_sdp_media_add_attribute (media, CRYPTO_ATTR, val) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_INVALID_PARAMETER,
"Can not add " CRYPTO_ATTR " attribute [%u]", tag);
ret = FALSE;
}
g_free (val);
return ret;
}
static gboolean
instersect_rtp_avpf_media_attr (const GstSDPAttribute * attr,
gpointer user_data)
{
struct intersect_data *data = (struct intersect_data *) user_data;
if (!KMS_SDP_MEDIA_HANDLER_GET_CLASS (data->handler)->
can_insert_attribute (data->handler, data->offer, attr, data->answer)) {
return FALSE;
}
if (gst_sdp_media_add_attribute (data->answer, attr->key,
attr->value) != GST_SDP_OK) {
GST_WARNING ("Cannot add attribute '%s'", attr->key);
return FALSE;
}
return TRUE;
}
static gboolean
add_media_to_sdp_message (SdpMediaConfig * mconf, GstSDPMessage * msg,
GError ** error)
{
GstSDPMedia *cpy;
if (gst_sdp_message_get_attribute_val (msg, "group") != NULL &&
gst_sdp_media_get_attribute_val (mconf->media, "mid") == NULL) {
/* When group attribute is present, the mid attribute */
/* in media is mandatory */
gst_sdp_media_add_attribute (mconf->media, "mid", mconf->mid);
}
if (gst_sdp_media_copy (mconf->media, &cpy) != GST_SDP_OK) {
g_set_error_literal (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"can not create media entry");
return FALSE;
}
gst_sdp_message_add_media (msg, cpy);
gst_sdp_media_free (cpy);
return TRUE;
}
static gboolean
kms_sdp_rtp_avpf_media_handler_rtcp_fb_attrs (KmsSdpMediaHandler * handler,
GstSDPMedia * media, const gchar * fmt, const gchar * enc, GError ** error)
{
KmsSdpRtpAvpfMediaHandler *self = KMS_SDP_RTP_AVPF_MEDIA_HANDLER (handler);
gchar *attr;
/* Add rtcp-fb attributes */
if (!self->priv->nack) {
goto no_nack;
}
attr = g_strdup_printf ("%s %s", fmt, SDP_MEDIA_RTCP_FB_NACK);
if (gst_sdp_media_add_attribute (media, SDP_MEDIA_RTCP_FB,
attr) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"Cannot add media attribute 'a=%s'", attr);
g_free (attr);
return FALSE;
}
g_free (attr);
attr = g_strdup_printf ("%s %s %s", fmt /* format */ , SDP_MEDIA_RTCP_FB_NACK,
SDP_MEDIA_RTCP_FB_PLI);
if (gst_sdp_media_add_attribute (media, SDP_MEDIA_RTCP_FB,
attr) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"Can add media attribute a=%s", attr);
g_free (attr);
return FALSE;
}
g_free (attr);
no_nack:
if (!self->priv->remb) {
goto no_remb;
}
if (g_str_has_prefix (enc, "VP8")) {
/* Chrome adds goog-remb attribute */
attr = g_strdup_printf ("%s %s", fmt, SDP_MEDIA_RTCP_FB_GOOG_REMB);
if (gst_sdp_media_add_attribute (media, SDP_MEDIA_RTCP_FB,
attr) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"Cannot add media attribute 'a=%s'", attr);
g_free (attr);
return FALSE;
}
g_free (attr);
}
no_remb:
attr =
g_strdup_printf ("%s %s %s", fmt, SDP_MEDIA_RTCP_FB_CCM,
SDP_MEDIA_RTCP_FB_FIR);
if (gst_sdp_media_add_attribute (media, SDP_MEDIA_RTCP_FB,
attr) != GST_SDP_OK) {
g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_UNEXPECTED_ERROR,
"Cannot add media attribute 'a=%s'", attr);
g_free (attr);
return FALSE;
}
g_free (attr);
return TRUE;
}
static void
make_media (GstSDPMessage * sdp, GstSDPInfo * info, GstRTSPMedia * media,
GstRTSPStream * stream, GstStructure * s, GstRTSPProfile profile)
{
GstSDPMedia *smedia;
const gchar *caps_str, *caps_enc, *caps_params;
gchar *tmp;
gint caps_pt, caps_rate;
guint n_fields, j;
gboolean first;
GString *fmtp;
GstRTSPLowerTrans ltrans;
GSocketFamily family;
const gchar *addrtype, *proto;
gchar *address;
guint ttl;
GstClockTime rtx_time;
gst_sdp_media_new (&smedia);
/* get media type and payload for the m= line */
caps_str = gst_structure_get_string (s, "media");
gst_sdp_media_set_media (smedia, caps_str);
gst_structure_get_int (s, "payload", &caps_pt);
tmp = g_strdup_printf ("%d", caps_pt);
gst_sdp_media_add_format (smedia, tmp);
g_free (tmp);
gst_sdp_media_set_port_info (smedia, 0, 1);
switch (profile) {
case GST_RTSP_PROFILE_AVP:
proto = "RTP/AVP";
break;
case GST_RTSP_PROFILE_AVPF:
proto = "RTP/AVPF";
break;
case GST_RTSP_PROFILE_SAVP:
proto = "RTP/SAVP";
break;
case GST_RTSP_PROFILE_SAVPF:
proto = "RTP/SAVPF";
break;
default:
proto = "udp";
break;
}
gst_sdp_media_set_proto (smedia, proto);
if (info->is_ipv6) {
addrtype = "IP6";
family = G_SOCKET_FAMILY_IPV6;
} else {
addrtype = "IP4";
family = G_SOCKET_FAMILY_IPV4;
}
ltrans = gst_rtsp_stream_get_protocols (stream);
if (ltrans == GST_RTSP_LOWER_TRANS_UDP_MCAST) {
GstRTSPAddress *addr;
addr = gst_rtsp_stream_get_multicast_address (stream, family);
if (addr == NULL)
goto no_multicast;
address = g_strdup (addr->address);
ttl = addr->ttl;
gst_rtsp_address_free (addr);
} else {
ttl = 16;
if (info->is_ipv6)
address = g_strdup ("::");
else
address = g_strdup ("0.0.0.0");
}
/* for the c= line */
gst_sdp_media_add_connection (smedia, "IN", addrtype, address, ttl, 1);
g_free (address);
/* get clock-rate, media type and params for the rtpmap attribute */
gst_structure_get_int (s, "clock-rate", &caps_rate);
caps_enc = gst_structure_get_string (s, "encoding-name");
caps_params = gst_structure_get_string (s, "encoding-params");
if (caps_enc) {
if (caps_params)
tmp = g_strdup_printf ("%d %s/%d/%s", caps_pt, caps_enc, caps_rate,
caps_params);
else
tmp = g_strdup_printf ("%d %s/%d", caps_pt, caps_enc, caps_rate);
gst_sdp_media_add_attribute (smedia, "rtpmap", tmp);
g_free (tmp);
}
/* the config uri */
tmp = gst_rtsp_stream_get_control (stream);
gst_sdp_media_add_attribute (smedia, "control", tmp);
g_free (tmp);
/* check for srtp */
do {
GstBuffer *srtpkey;
const GValue *val;
const gchar *srtpcipher, *srtpauth, *srtcpcipher, *srtcpauth;
GstMIKEYMessage *msg;
GstMIKEYPayload *payload, *pkd;
GBytes *bytes;
GstMapInfo info;
const guint8 *data;
gsize size;
gchar *base64;
guint8 byte;
guint32 ssrc;
val = gst_structure_get_value (s, "srtp-key");
if (val == NULL)
break;
srtpkey = gst_value_get_buffer (val);
if (srtpkey == NULL)
break;
srtpcipher = gst_structure_get_string (s, "srtp-cipher");
srtpauth = gst_structure_get_string (s, "srtp-auth");
srtcpcipher = gst_structure_get_string (s, "srtcp-cipher");
srtcpauth = gst_structure_get_string (s, "srtcp-auth");
if (srtpcipher == NULL || srtpauth == NULL || srtcpcipher == NULL ||
srtcpauth == NULL)
break;
msg = gst_mikey_message_new ();
/* unencrypted MIKEY message, we send this over TLS so this is allowed */
gst_mikey_message_set_info (msg, GST_MIKEY_VERSION, GST_MIKEY_TYPE_PSK_INIT,
FALSE, GST_MIKEY_PRF_MIKEY_1, 0, GST_MIKEY_MAP_TYPE_SRTP);
/* add policy '0' for our SSRC */
gst_rtsp_stream_get_ssrc (stream, &ssrc);
gst_mikey_message_add_cs_srtp (msg, 0, ssrc, 0);
/* timestamp is now */
gst_mikey_message_add_t_now_ntp_utc (msg);
/* add some random data */
gst_mikey_message_add_rand_len (msg, 16);
/* the policy '0' is SRTP with the above discovered algorithms */
payload = gst_mikey_payload_new (GST_MIKEY_PT_SP);
gst_mikey_payload_sp_set (payload, 0, GST_MIKEY_SEC_PROTO_SRTP);
/* only AES-CM is supported */
byte = 1;
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_ENC_ALG, 1,
&byte);
/* Encryption key length */
byte = enc_key_length_from_cipher_name (srtpcipher);
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_ENC_KEY_LEN, 1,
&byte);
/* only HMAC-SHA1 */
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_AUTH_ALG, 1,
&byte);
/* Authentication key length */
byte = auth_key_length_from_auth_name (srtpauth);
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_AUTH_KEY_LEN, 1,
&byte);
/* we enable encryption on RTP and RTCP */
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_SRTP_ENC, 1,
&byte);
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_SRTCP_ENC, 1,
&byte);
/* we enable authentication on RTP and RTCP */
gst_mikey_payload_sp_add_param (payload, GST_MIKEY_SP_SRTP_SRTP_AUTH, 1,
&byte);
gst_mikey_message_add_payload (msg, payload);
/* make unencrypted KEMAC */
payload = gst_mikey_payload_new (GST_MIKEY_PT_KEMAC);
gst_mikey_payload_kemac_set (payload, GST_MIKEY_ENC_NULL,
GST_MIKEY_MAC_NULL);
/* add the key in key data */
pkd = gst_mikey_payload_new (GST_MIKEY_PT_KEY_DATA);
gst_buffer_map (srtpkey, &info, GST_MAP_READ);
gst_mikey_payload_key_data_set_key (pkd, GST_MIKEY_KD_TEK, info.size,
info.data);
gst_buffer_unmap (srtpkey, &info);
/* add key data to KEMAC */
gst_mikey_payload_kemac_add_sub (payload, pkd);
gst_mikey_message_add_payload (msg, payload);
/* now serialize this to bytes */
bytes = gst_mikey_message_to_bytes (msg, NULL, NULL);
gst_mikey_message_unref (msg);
/* and make it into base64 */
data = g_bytes_get_data (bytes, &size);
base64 = g_base64_encode (data, size);
g_bytes_unref (bytes);
tmp = g_strdup_printf ("mikey %s", base64);
g_free (base64);
gst_sdp_media_add_attribute (smedia, "key-mgmt", tmp);
g_free (tmp);
} while (FALSE);
/* collect all other properties and add them to fmtp or attributes */
fmtp = g_string_new ("");
g_string_append_printf (fmtp, "%d ", caps_pt);
first = TRUE;
n_fields = gst_structure_n_fields (s);
for (j = 0; j < n_fields; j++) {
const gchar *fname, *fval;
fname = gst_structure_nth_field_name (s, j);
/* filter out standard properties */
if (!strcmp (fname, "media"))
continue;
if (!strcmp (fname, "payload"))
continue;
if (!strcmp (fname, "clock-rate"))
continue;
if (!strcmp (fname, "encoding-name"))
continue;
if (!strcmp (fname, "encoding-params"))
continue;
if (!strcmp (fname, "ssrc"))
continue;
if (!strcmp (fname, "timestamp-offset"))
continue;
if (!strcmp (fname, "seqnum-offset"))
continue;
if (g_str_has_prefix (fname, "srtp-"))
continue;
if (g_str_has_prefix (fname, "srtcp-"))
continue;
/* handled later */
if (g_str_has_prefix (fname, "x-gst-rtsp-server-rtx-time"))
continue;
if (!strcmp (fname, "a-framesize")) {
/* a-framesize attribute */
if ((fval = gst_structure_get_string (s, fname))) {
tmp = g_strdup_printf ("%d %s", caps_pt, fval);
gst_sdp_media_add_attribute (smedia, fname + 2, tmp);
g_free (tmp);
}
continue;
}
if (g_str_has_prefix (fname, "a-")) {
/* attribute */
if ((fval = gst_structure_get_string (s, fname)))
gst_sdp_media_add_attribute (smedia, fname + 2, fval);
continue;
}
if (g_str_has_prefix (fname, "x-")) {
/* attribute */
if ((fval = gst_structure_get_string (s, fname)))
gst_sdp_media_add_attribute (smedia, fname, fval);
continue;
}
if ((fval = gst_structure_get_string (s, fname))) {
g_string_append_printf (fmtp, "%s%s=%s", first ? "" : ";", fname, fval);
first = FALSE;
}
}
if (!first) {
tmp = g_string_free (fmtp, FALSE);
gst_sdp_media_add_attribute (smedia, "fmtp", tmp);
g_free (tmp);
} else {
g_string_free (fmtp, TRUE);
}
update_sdp_from_tags (stream, smedia);
if ((rtx_time = gst_rtsp_stream_get_retransmission_time (stream))) {
/* ssrc multiplexed retransmit functionality */
guint rtx_pt = gst_rtsp_stream_get_retransmission_pt (stream);
if (rtx_pt == 0) {
g_warning ("failed to find an available dynamic payload type. "
"Not adding retransmission");
} else {
gchar *tmp;
tmp = g_strdup_printf ("%d", rtx_pt);
gst_sdp_media_add_format (smedia, tmp);
g_free (tmp);
tmp = g_strdup_printf ("%d rtx/%d", rtx_pt, caps_rate);
gst_sdp_media_add_attribute (smedia, "rtpmap", tmp);
g_free (tmp);
tmp =
g_strdup_printf ("%d apt=%d;rtx-time=%" G_GINT64_FORMAT, rtx_pt,
caps_pt, GST_TIME_AS_MSECONDS (rtx_time));
gst_sdp_media_add_attribute (smedia, "fmtp", tmp);
g_free (tmp);
}
}
gst_sdp_message_add_media (sdp, smedia);
gst_sdp_media_free (smedia);
return;
/* ERRORS */
no_multicast:
{
gst_sdp_media_free (smedia);
g_warning ("ignoring stream %d without multicast address",
gst_rtsp_stream_get_index (stream));
return;
}
}
BoolLog SDPMedia::add_to_sdp_description(GstSDPMessage* sdp_description,
unsigned int index,
const std::string& ip_addr) const {
if (0 == port_ || nullptr == caps_structure_) {
return BoolLog(false, "missing information for adding media to sdp description");
}
/* get media type and payload for the m= line */
std::string caps_str(gst_structure_get_string(caps_structure_, "media"));
gst_sdp_media_set_media(media_, caps_str.c_str());
gint caps_pt = 0;
gst_structure_get_int(caps_structure_, "payload", &caps_pt);
gst_sdp_media_add_format(media_, std::to_string(caps_pt).c_str());
gst_sdp_media_set_port_info(media_, port_, 1);
gst_sdp_media_set_proto(media_, "RTP/AVP");
/* for the c= line */
gst_sdp_media_add_connection(media_, "IN", "IP4", ip_addr.c_str(), 16, 0);
// sendonly
gst_sdp_media_add_attribute(media_, "sendonly", "");
/* get clock-rate, media type and params for the rtpmap attribute */
gint caps_rate = 0;
gst_structure_get_int(caps_structure_, "clock-rate", &caps_rate);
std::string caps_enc(gst_structure_get_string(caps_structure_, "encoding-name"));
std::string rtpmap(std::to_string(caps_pt) + " " + caps_enc + "/" + std::to_string(caps_rate));
const gchar* caps_params = gst_structure_get_string(caps_structure_, "encoding-params");
if (nullptr != caps_params) {
rtpmap.append("/");
rtpmap.append(caps_params);
}
gst_sdp_media_add_attribute(media_, "rtpmap", rtpmap.c_str());
/* the config uri */
std::string control("stream=" + std::to_string(index));
gst_sdp_media_add_attribute(media_, "control", control.c_str());
/* collect all other properties and add them to fmtp */
std::string fmtp = std::to_string(caps_pt);
fmtp.append(" ");
bool first = true;
guint n_fields = gst_structure_n_fields(caps_structure_);
for (uint j = 0; j < n_fields; j++) {
const gchar* fname_c = gst_structure_nth_field_name(caps_structure_, j);
if (nullptr == fname_c) continue;
std::string fname(fname_c);
/* filter out standard properties */
if (fname.compare("media") == 0 || fname.compare("payload") == 0 ||
fname.compare("clock-rate") == 0 || fname.compare("encoding-name") == 0 ||
fname.compare("encoding-params") == 0 || fname.compare("ssrc") == 0 ||
fname.compare("clock-base") == 0 || fname.compare("seqnum-base") == 0)
continue;
const gchar* struct_str = gst_structure_get_string(caps_structure_, fname.c_str());
if (nullptr == struct_str) continue;
std::string val = std::string(struct_str);
if (0 == fname.compare("sprop-parameter-sets")) {
auto equal_pos = val.find('=');
if (std::string::npos != equal_pos) {
// removing buggy trailing = at the end of sprop-parameter-sets
val = std::string(val, 0, equal_pos);
}
auto comma_pos = val.find(',');
if (std::string::npos != comma_pos) {
// removing buggy trailing comma and the rest from sprop-parameter-sets
val = std::string(val, 0, comma_pos);
}
}
std::string fname_value(fname + "=" + val);
if (gst_structure_get_string(caps_structure_, fname.c_str())) {
if (!first)
fmtp.append(";");
else
first = false;
fmtp.append(fname_value);
}
}
if (!first) gst_sdp_media_add_attribute(media_, "fmtp", fmtp.c_str());
for (auto& it : ice_candidate_values_) {
gst_sdp_media_add_attribute(media_, "candidate", it.c_str());
}
gst_sdp_message_add_media(sdp_description, media_);
return BoolLog(true);
}
/**
* gst_rtsp_sdp_from_media:
* @sdp: a #GstSDPMessage
* @info: info
* @media: a #GstRTSPMedia
*
* Add @media specific info to @sdp. @info is used to configure the connection
* information in the SDP.
*
* Returns: TRUE on success.
*/
gboolean
gst_rtsp_sdp_from_media (GstSDPMessage * sdp, GstSDPInfo * info,
GstRTSPMedia * media)
{
guint i, n_streams;
gchar *rangestr;
n_streams = gst_rtsp_media_n_streams (media);
rangestr = gst_rtsp_media_get_range_string (media, FALSE, GST_RTSP_RANGE_NPT);
if (rangestr == NULL)
goto not_prepared;
gst_sdp_message_add_attribute (sdp, "range", rangestr);
g_free (rangestr);
for (i = 0; i < n_streams; i++) {
GstRTSPStream *stream;
GstSDPMedia *smedia;
GstStructure *s;
const gchar *caps_str, *caps_enc, *caps_params;
gchar *tmp;
gint caps_pt, caps_rate;
guint n_fields, j;
gboolean first;
GString *fmtp;
GstCaps *caps;
stream = gst_rtsp_media_get_stream (media, i);
caps = gst_rtsp_stream_get_caps (stream);
if (caps == NULL) {
g_warning ("ignoring stream %d without media type", i);
continue;
}
s = gst_caps_get_structure (caps, 0);
if (s == NULL) {
gst_caps_unref (caps);
g_warning ("ignoring stream %d without media type", i);
continue;
}
gst_sdp_media_new (&smedia);
/* get media type and payload for the m= line */
caps_str = gst_structure_get_string (s, "media");
gst_sdp_media_set_media (smedia, caps_str);
gst_structure_get_int (s, "payload", &caps_pt);
tmp = g_strdup_printf ("%d", caps_pt);
gst_sdp_media_add_format (smedia, tmp);
g_free (tmp);
gst_sdp_media_set_port_info (smedia, 0, 1);
gst_sdp_media_set_proto (smedia, "RTP/AVP");
/* for the c= line */
if (info->is_ipv6) {
gst_sdp_media_add_connection (smedia, "IN", "IP6", "::", 16, 0);
} else {
gst_sdp_media_add_connection (smedia, "IN", "IP4", "0.0.0.0", 16, 0);
}
/* get clock-rate, media type and params for the rtpmap attribute */
gst_structure_get_int (s, "clock-rate", &caps_rate);
caps_enc = gst_structure_get_string (s, "encoding-name");
caps_params = gst_structure_get_string (s, "encoding-params");
if (caps_enc) {
if (caps_params)
tmp = g_strdup_printf ("%d %s/%d/%s", caps_pt, caps_enc, caps_rate,
caps_params);
else
tmp = g_strdup_printf ("%d %s/%d", caps_pt, caps_enc, caps_rate);
gst_sdp_media_add_attribute (smedia, "rtpmap", tmp);
g_free (tmp);
}
/* the config uri */
tmp = gst_rtsp_stream_get_control (stream);
gst_sdp_media_add_attribute (smedia, "control", tmp);
g_free (tmp);
/* collect all other properties and add them to fmtp or attributes */
fmtp = g_string_new ("");
g_string_append_printf (fmtp, "%d ", caps_pt);
first = TRUE;
n_fields = gst_structure_n_fields (s);
for (j = 0; j < n_fields; j++) {
const gchar *fname, *fval;
fname = gst_structure_nth_field_name (s, j);
/* filter out standard properties */
if (!strcmp (fname, "media"))
continue;
if (!strcmp (fname, "payload"))
continue;
if (!strcmp (fname, "clock-rate"))
continue;
if (!strcmp (fname, "encoding-name"))
continue;
if (!strcmp (fname, "encoding-params"))
continue;
if (!strcmp (fname, "ssrc"))
continue;
if (!strcmp (fname, "clock-base"))
continue;
if (!strcmp (fname, "seqnum-base"))
continue;
if (g_str_has_prefix (fname, "a-")) {
/* attribute */
if ((fval = gst_structure_get_string (s, fname)))
gst_sdp_media_add_attribute (smedia, fname + 2, fval);
continue;
}
if (g_str_has_prefix (fname, "x-")) {
/* attribute */
if ((fval = gst_structure_get_string (s, fname)))
gst_sdp_media_add_attribute (smedia, fname, fval);
continue;
}
if ((fval = gst_structure_get_string (s, fname))) {
g_string_append_printf (fmtp, "%s%s=%s", first ? "" : ";", fname, fval);
first = FALSE;
}
}
if (!first) {
tmp = g_string_free (fmtp, FALSE);
gst_sdp_media_add_attribute (smedia, "fmtp", tmp);
g_free (tmp);
} else {
g_string_free (fmtp, TRUE);
}
update_sdp_from_tags (stream, smedia);
gst_sdp_message_add_media (sdp, smedia);
gst_sdp_media_free (smedia);
gst_caps_unref (caps);
}
{
GstNetTimeProvider *provider;
if ((provider =
gst_rtsp_media_get_time_provider (media, info->server_ip, 0))) {
GstClock *clock;
gchar *address, *str;
gint port;
g_object_get (provider, "clock", &clock, "address", &address, "port",
&port, NULL);
str = g_strdup_printf ("GstNetTimeProvider %s %s:%d %" G_GUINT64_FORMAT,
g_type_name (G_TYPE_FROM_INSTANCE (clock)), address, port,
gst_clock_get_time (clock));
gst_sdp_message_add_attribute (sdp, "x-gst-clock", str);
g_free (str);
gst_object_unref (clock);
g_free (address);
gst_object_unref (provider);
}
}
return TRUE;
/* ERRORS */
not_prepared:
{
GST_ERROR ("media %p is not prepared", media);
return FALSE;
}
}
static gint create_and_send_ANNOUNCE_message2(GstRTSPsink* sink, GTimeVal *timeout, char **szSessionNumber) {
const gchar *url_client_ip_str = "0.0.0.0";//"192.168.2.104";
const gchar *url_server_str_full = g_strdup_printf("rtsp://%s:%d/%s", sink->host, sink->port, sink->stream_name); //"rtsp://192.168.2.108:1935/live/1";
//conn = sink->conn;
GstRTSPMessage msg = { 0 };
GstSDPMessage *sdp;
GstRTSPMethod method;
GstRTSPResult res;
guint num_ports = 1;
guint rtp_port = 5006;
char *szPayloadType = g_strdup_printf("%d", sink->payload);
method = GST_RTSP_ANNOUNCE ;
res = gst_rtsp_message_init_request(&msg, method, url_server_str_full);
if (res < 0)
return res;
/* set user-agent */
if (sink->user_agent)
gst_rtsp_message_add_header(&msg, GST_RTSP_HDR_USER_AGENT, sink->user_agent);
gst_rtsp_message_add_header(&msg, GST_RTSP_HDR_CONTENT_TYPE, "application/sdp");
// allocate sdp messege buffer...
res = gst_sdp_message_new(&sdp);
//v=..
res = gst_sdp_message_set_version(sdp, "0");
//o=...
res = gst_sdp_message_set_origin(sdp, "-", "0", "0", "IN", "IP4", "0.0.0.0");
//s=..
if (sink->session_name)
res = gst_sdp_message_set_session_name(sdp, "Unnamed");
//i=..
if (sink->information)
res = gst_sdp_message_set_information(sdp, "N/A");
//c=...
res = gst_sdp_message_set_connection(sdp, "IN", "IP4", url_client_ip_str, 0, 0);
//a=...
res = gst_sdp_message_add_attribute(sdp, "recvonly", NULL);
// create media
GstSDPMedia *media;
res = gst_sdp_media_new(&media);
res = gst_sdp_media_init(media);
//m=...
res = gst_sdp_media_set_media(media, "video");
res = gst_sdp_media_set_port_info(media, rtp_port, num_ports);
res = gst_sdp_media_set_proto(media, "RTP/AVP");
res = gst_sdp_media_add_format(media, szPayloadType);
//a=...
char *rtpmap = g_strdup_printf("%s %s/%d", szPayloadType, sink->encoding_name, sink->clock_rate);
res = gst_sdp_media_add_attribute(media, "rtpmap", rtpmap);
res = gst_sdp_media_add_attribute(media, "fmtp", szPayloadType);
res = gst_sdp_media_add_attribute(media, "control", "streamid=0");
// insert media into sdp
res = gst_sdp_message_add_media(sdp, media);
gchar * sdp_str = gst_sdp_message_as_text(sdp);
int size = g_utf8_strlen(sdp_str, 500);
gst_sdp_message_free(sdp);
gst_sdp_media_free(media);
res = gst_rtsp_message_set_body(&msg, sdp_str, size);
sink->responce = &msg;
// Send our packet receive server answer and check some basic checks.
if ((res = sendReceiveAndCheck(sink->conn, timeout, &msg, sink->debug)) != GST_RTSP_OK) {
return res;
}
// get session number
*szSessionNumber = extractSessionNumberFromMessage(&msg);
return GST_RTSP_OK;
}
