* protocols can be controlled with the #GstRTSPSrc:protocols property.
*
* rtspsrc currently understands SDP as the format of the session description.
- * For each stream listed in the SDP a new rtp_stream%d pad will be created
+ * For each stream listed in the SDP a new rtp_stream\%d pad will be created
* with caps derived from the SDP media description. This is a caps of mime type
* "application/x-rtp" that can be connected to any available RTP depayloader
* element.
* ]| Establish a connection to an RTSP server and send the raw RTP packets to a
* fakesink.
* </refsect2>
- *
- * Last reviewed on 2006-08-18 (0.10.5)
*/
#ifdef HAVE_CONFIG_H
#include <gst/net/gstnet.h>
#include <gst/sdp/gstsdpmessage.h>
-#include <gst/rtp/gstrtppayloads.h>
+#include <gst/sdp/gstmikey.h>
+#include <gst/rtp/rtp.h>
#include "gst/gst-i18n-plugin.h"
SIGNAL_ON_SDP,
SIGNAL_SELECT_STREAM,
SIGNAL_NEW_MANAGER,
+ SIGNAL_REQUEST_RTCP_KEY,
LAST_SIGNAL
};
return buffer_mode_type;
}
+enum _GstRtspSrcNtpTimeSource
+{
+ NTP_TIME_SOURCE_NTP,
+ NTP_TIME_SOURCE_UNIX,
+ NTP_TIME_SOURCE_RUNNING_TIME,
+ NTP_TIME_SOURCE_CLOCK_TIME
+};
+
+#define GST_TYPE_RTSP_SRC_NTP_TIME_SOURCE (gst_rtsp_src_ntp_time_source_get_type())
+static GType
+gst_rtsp_src_ntp_time_source_get_type (void)
+{
+ static GType ntp_time_source_type = 0;
+ static const GEnumValue ntp_time_source_values[] = {
+ {NTP_TIME_SOURCE_NTP, "NTP time based on realtime clock", "ntp"},
+ {NTP_TIME_SOURCE_UNIX, "UNIX time based on realtime clock", "unix"},
+ {NTP_TIME_SOURCE_RUNNING_TIME,
+ "Running time based on pipeline clock",
+ "running-time"},
+ {NTP_TIME_SOURCE_CLOCK_TIME, "Pipeline clock time", "clock-time"},
+ {0, NULL, NULL},
+ };
+
+ if (!ntp_time_source_type) {
+ ntp_time_source_type =
+ g_enum_register_static ("GstRTSPSrcNtpTimeSource",
+ ntp_time_source_values);
+ }
+ return ntp_time_source_type;
+}
+
+#define AES_128_KEY_LEN 16
+#define AES_256_KEY_LEN 32
+
+#define HMAC_32_KEY_LEN 4
+#define HMAC_80_KEY_LEN 10
+
#define DEFAULT_LOCATION NULL
#define DEFAULT_PROTOCOLS GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP
#define DEFAULT_DEBUG FALSE
#define DEFAULT_USE_PIPELINE_CLOCK FALSE
#define DEFAULT_TLS_VALIDATION_FLAGS G_TLS_CERTIFICATE_VALIDATE_ALL
#define DEFAULT_TLS_DATABASE NULL
+#define DEFAULT_TLS_INTERACTION NULL
+#define DEFAULT_DO_RETRANSMISSION TRUE
+#define DEFAULT_NTP_TIME_SOURCE NTP_TIME_SOURCE_NTP
+#define DEFAULT_USER_AGENT "GStreamer/" PACKAGE_VERSION
+#define DEFAULT_MAX_RTCP_RTP_TIME_DIFF 1000
enum
{
PROP_SDES,
PROP_TLS_VALIDATION_FLAGS,
PROP_TLS_DATABASE,
- PROP_LAST
+ PROP_TLS_INTERACTION,
+ PROP_DO_RETRANSMISSION,
+ PROP_NTP_TIME_SOURCE,
+ PROP_USER_AGENT,
+ PROP_MAX_RTCP_RTP_TIME_DIFF
};
#define GST_TYPE_RTSP_NAT_METHOD (gst_rtsp_nat_method_get_type())
G_DEFINE_TYPE_WITH_CODE (GstRTSPSrc, gst_rtspsrc, GST_TYPE_BIN,
G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_rtspsrc_uri_handler_init));
+#ifndef GST_DISABLE_GST_DEBUG
+static inline const char *
+cmd_to_string (guint cmd)
+{
+ switch (cmd) {
+ case CMD_OPEN:
+ return "OPEN";
+ case CMD_PLAY:
+ return "PLAY";
+ case CMD_PAUSE:
+ return "PAUSE";
+ case CMD_CLOSE:
+ return "CLOSE";
+ case CMD_WAIT:
+ return "WAIT";
+ case CMD_RECONNECT:
+ return "RECONNECT";
+ case CMD_LOOP:
+ return "LOOP";
+ }
+
+ return "unknown";
+}
+#endif
+
static gboolean
default_select_stream (GstRTSPSrc * src, guint id, GstCaps * caps)
{
g_object_class_install_property (gobject_class, PROP_USE_PIPELINE_CLOCK,
g_param_spec_boolean ("use-pipeline-clock", "Use pipeline clock",
- "Use the pipeline running-time to set the NTP time in the RTCP SR messages",
+ "Use the pipeline running-time to set the NTP time in the RTCP SR messages"
+ "(DEPRECATED: Use ntp-time-source property)",
DEFAULT_USE_PIPELINE_CLOCK,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED));
g_object_class_install_property (gobject_class, PROP_SDES,
g_param_spec_boxed ("sdes", "SDES",
G_TYPE_TLS_DATABASE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
+ * GstRTSPSrc::tls-interaction:
+ *
+ * A #GTlsInteraction object to be used when the connection or certificate
+ * database need to interact with the user. This will be used to prompt the
+ * user for passwords where necessary.
+ *
+ * Since: 1.6
+ */
+ g_object_class_install_property (gobject_class, PROP_TLS_INTERACTION,
+ g_param_spec_object ("tls-interaction", "TLS interaction",
+ "A GTlsInteraction object to promt the user for password or certificate",
+ G_TYPE_TLS_INTERACTION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ /**
+ * GstRTSPSrc::do-retransmission:
+ *
+ * Attempt to ask the server to retransmit lost packets according to RFC4588.
+ *
+ * Note: currently only works with SSRC-multiplexed retransmission streams
+ *
+ * Since: 1.6
+ */
+ g_object_class_install_property (gobject_class, PROP_DO_RETRANSMISSION,
+ g_param_spec_boolean ("do-retransmission", "Retransmission",
+ "Ask the server to retransmit lost packets",
+ DEFAULT_DO_RETRANSMISSION,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ /**
+ * GstRTSPSrc::ntp-time-source:
+ *
+ * allows to select the time source that should be used
+ * for the NTP time in RTCP packets
+ *
+ * Since: 1.6
+ */
+ g_object_class_install_property (gobject_class, PROP_NTP_TIME_SOURCE,
+ g_param_spec_enum ("ntp-time-source", "NTP Time Source",
+ "NTP time source for RTCP packets",
+ GST_TYPE_RTSP_SRC_NTP_TIME_SOURCE, DEFAULT_NTP_TIME_SOURCE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ /**
+ * GstRTSPSrc::user-agent:
+ *
+ * The string to set in the User-Agent header.
+ *
+ * Since: 1.6
+ */
+ g_object_class_install_property (gobject_class, PROP_USER_AGENT,
+ g_param_spec_string ("user-agent", "User Agent",
+ "The User-Agent string to send to the server",
+ DEFAULT_USER_AGENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_MAX_RTCP_RTP_TIME_DIFF,
+ g_param_spec_int ("max-rtcp-rtp-time-diff", "Max RTCP RTP Time Diff",
+ "Maximum amount of time in ms that the RTP time in RTCP SRs "
+ "is allowed to be ahead (-1 disabled)", -1, G_MAXINT,
+ DEFAULT_MAX_RTCP_RTP_TIME_DIFF,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ /**
* GstRTSPSrc::handle-request:
* @rtspsrc: a #GstRTSPSrc
* @request: a #GstRTSPMessage
G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_CLEANUP, 0, NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
+ /**
+ * GstRTSPSrc::request-rtcp-key:
+ * @rtspsrc: a #GstRTSPSrc
+ * @num: the stream number
+ *
+ * Signal emited to get the crypto parameters relevant to the RTCP
+ * stream. User should provide the key and the RTCP encryption ciphers
+ * and authentication, and return them wrapped in a GstCaps.
+ *
+ * Since: 1.4
+ */
+ gst_rtspsrc_signals[SIGNAL_REQUEST_RTCP_KEY] =
+ g_signal_new ("request-rtcp-key", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, GST_TYPE_CAPS, 1, G_TYPE_UINT);
+
gstelement_class->send_event = gst_rtspsrc_send_event;
gstelement_class->provide_clock = gst_rtspsrc_provide_clock;
gstelement_class->change_state = gst_rtspsrc_change_state;
src->sdes = NULL;
src->tls_validation_flags = DEFAULT_TLS_VALIDATION_FLAGS;
src->tls_database = DEFAULT_TLS_DATABASE;
+ src->tls_interaction = DEFAULT_TLS_INTERACTION;
+ src->do_retransmission = DEFAULT_DO_RETRANSMISSION;
+ src->ntp_time_source = DEFAULT_NTP_TIME_SOURCE;
+ src->user_agent = g_strdup (DEFAULT_USER_AGENT);
+ src->max_rtcp_rtp_time_diff = DEFAULT_MAX_RTCP_RTP_TIME_DIFF;
/* get a list of all extensions */
src->extensions = gst_rtsp_ext_list_get ();
g_free (rtspsrc->user_id);
g_free (rtspsrc->user_pw);
g_free (rtspsrc->multi_iface);
+ g_free (rtspsrc->user_agent);
if (rtspsrc->sdp) {
gst_sdp_message_free (rtspsrc->sdp);
if (rtspsrc->tls_database)
g_object_unref (rtspsrc->tls_database);
+ if (rtspsrc->tls_interaction)
+ g_object_unref (rtspsrc->tls_interaction);
+
/* free locks */
g_rec_mutex_clear (&rtspsrc->stream_rec_lock);
g_rec_mutex_clear (&rtspsrc->state_rec_lock);
gst_rtspsrc_set_proxy (rtspsrc, g_value_get_string (value));
break;
case PROP_PROXY_ID:
- if (rtspsrc->prop_proxy_id)
- g_free (rtspsrc->prop_proxy_id);
+ g_free (rtspsrc->prop_proxy_id);
rtspsrc->prop_proxy_id = g_value_dup_string (value);
break;
case PROP_PROXY_PW:
- if (rtspsrc->prop_proxy_pw)
- g_free (rtspsrc->prop_proxy_pw);
+ g_free (rtspsrc->prop_proxy_pw);
rtspsrc->prop_proxy_pw = g_value_dup_string (value);
break;
case PROP_RTP_BLOCKSIZE:
rtspsrc->rtp_blocksize = g_value_get_uint (value);
break;
case PROP_USER_ID:
- if (rtspsrc->user_id)
- g_free (rtspsrc->user_id);
+ g_free (rtspsrc->user_id);
rtspsrc->user_id = g_value_dup_string (value);
break;
case PROP_USER_PW:
- if (rtspsrc->user_pw)
- g_free (rtspsrc->user_pw);
+ g_free (rtspsrc->user_pw);
rtspsrc->user_pw = g_value_dup_string (value);
break;
case PROP_BUFFER_MODE:
const gchar *str;
str = g_value_get_string (value);
- if (str) {
- sscanf (str, "%u-%u",
- &rtspsrc->client_port_range.min, &rtspsrc->client_port_range.max);
- } else {
+ if (sscanf (str, "%u-%u", &rtspsrc->client_port_range.min,
+ &rtspsrc->client_port_range.max) != 2) {
rtspsrc->client_port_range.min = 0;
rtspsrc->client_port_range.max = 0;
}
g_clear_object (&rtspsrc->tls_database);
rtspsrc->tls_database = g_value_dup_object (value);
break;
+ case PROP_TLS_INTERACTION:
+ g_clear_object (&rtspsrc->tls_interaction);
+ rtspsrc->tls_interaction = g_value_dup_object (value);
+ break;
+ case PROP_DO_RETRANSMISSION:
+ rtspsrc->do_retransmission = g_value_get_boolean (value);
+ break;
+ case PROP_NTP_TIME_SOURCE:
+ rtspsrc->ntp_time_source = g_value_get_enum (value);
+ break;
+ case PROP_USER_AGENT:
+ g_free (rtspsrc->user_agent);
+ rtspsrc->user_agent = g_value_dup_string (value);
+ break;
+ case PROP_MAX_RTCP_RTP_TIME_DIFF:
+ rtspsrc->max_rtcp_rtp_time_diff = g_value_get_int (value);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_TLS_DATABASE:
g_value_set_object (value, rtspsrc->tls_database);
break;
+ case PROP_TLS_INTERACTION:
+ g_value_set_object (value, rtspsrc->tls_interaction);
+ break;
+ case PROP_DO_RETRANSMISSION:
+ g_value_set_boolean (value, rtspsrc->do_retransmission);
+ break;
+ case PROP_NTP_TIME_SOURCE:
+ g_value_set_enum (value, rtspsrc->ntp_time_source);
+ break;
+ case PROP_USER_AGENT:
+ g_value_set_string (value, rtspsrc->user_agent);
+ break;
+ case PROP_MAX_RTCP_RTP_TIME_DIFF:
+ g_value_set_int (value, rtspsrc->max_rtcp_rtp_time_diff);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
-
/* m=<media> <UDP port> RTP/AVP <payload>
*/
static void
{
guint i, len;
const gchar *proto;
+ GstCaps *global_caps;
/* get proto */
proto = gst_sdp_media_get_proto (media);
else
goto unknown_proto;
+ /* Parse global SDP attributes once */
+ global_caps = gst_caps_new_empty_simple ("application/x-unknown");
+ GST_DEBUG ("mapping sdp session level attributes to caps");
+ gst_rtspsrc_sdp_attributes_to_caps (sdp->attributes, global_caps);
+ GST_DEBUG ("mapping sdp media level attributes to caps");
+ gst_rtspsrc_sdp_attributes_to_caps (media->attributes, global_caps);
+
len = gst_sdp_media_formats_len (media);
for (i = 0; i < len; i++) {
gint pt;
- GstCaps *caps;
+ GstCaps *caps, *outcaps;
GstStructure *s;
const gchar *enc;
PtMapItem item;
if (strcmp (enc, "X-ASF-PF") == 0)
stream->container = TRUE;
}
- GST_DEBUG ("mapping sdp session level attributes to caps");
- gst_rtspsrc_sdp_attributes_to_caps (sdp->attributes, caps);
- GST_DEBUG ("mapping sdp media level attributes to caps");
- gst_rtspsrc_sdp_attributes_to_caps (media->attributes, caps);
+
+ /* 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);
/* the first pt will be the default */
if (stream->ptmap->len == 0)
stream->default_pt = pt;
item.pt = pt;
- item.caps = caps;
+ item.caps = outcaps;
+
g_array_append_val (stream->ptmap, item);
}
+
+ gst_caps_unref (global_caps);
return;
no_proto:
stream->discont = TRUE;
stream->seqbase = -1;
stream->timebase = -1;
+ stream->send_ssrc = g_random_int ();
stream->profile = GST_RTSP_PROFILE_AVP;
stream->ptmap = g_array_new (FALSE, FALSE, sizeof (PtMapItem));
g_array_set_clear_func (stream->ptmap, (GDestroyNotify) clear_ptmap_item);
gst_element_set_state (stream->udpsrc[i], GST_STATE_NULL);
gst_bin_remove (GST_BIN_CAST (src), stream->udpsrc[i]);
gst_object_unref (stream->udpsrc[i]);
- stream->udpsrc[i] = NULL;
}
- if (stream->channelpad[i]) {
+ if (stream->channelpad[i])
gst_object_unref (stream->channelpad[i]);
- stream->channelpad[i] = NULL;
- }
+
if (stream->udpsink[i]) {
gst_element_set_state (stream->udpsink[i], GST_STATE_NULL);
gst_bin_remove (GST_BIN_CAST (src), stream->udpsink[i]);
gst_object_unref (stream->udpsink[i]);
- stream->udpsink[i] = NULL;
}
}
if (stream->fakesrc) {
gst_element_set_state (stream->fakesrc, GST_STATE_NULL);
gst_bin_remove (GST_BIN_CAST (src), stream->fakesrc);
gst_object_unref (stream->fakesrc);
- stream->fakesrc = NULL;
}
if (stream->srcpad) {
gst_pad_set_active (stream->srcpad, FALSE);
- if (stream->added) {
+ if (stream->added)
gst_element_remove_pad (GST_ELEMENT_CAST (src), stream->srcpad);
- stream->added = FALSE;
- }
- stream->srcpad = NULL;
}
- if (stream->rtcppad) {
+ if (stream->srtpenc)
+ gst_object_unref (stream->srtpenc);
+ if (stream->srtpdec)
+ gst_object_unref (stream->srtpdec);
+ if (stream->srtcpparams)
+ gst_caps_unref (stream->srtcpparams);
+ if (stream->rtcppad)
gst_object_unref (stream->rtcppad);
- stream->rtcppad = NULL;
- }
- if (stream->session) {
+ if (stream->session)
g_object_unref (stream->session);
- stream->session = NULL;
- }
+ if (stream->rtx_pt_map)
+ gst_structure_free (stream->rtx_pt_map);
g_free (stream);
}
gst_sdp_message_free (src->sdp);
src->sdp = NULL;
}
- if (src->start_segment) {
- gst_event_unref (src->start_segment);
- src->start_segment = NULL;
- }
+
+ src->need_segment = FALSE;
+
if (src->provided_clock) {
gst_object_unref (src->provided_clock);
src->provided_clock = NULL;
return TRUE;
}
+static gboolean
+parse_keymgmt (const gchar * keymgmt, GstCaps * caps)
+{
+ gboolean res = FALSE;
+ gsize size;
+ guchar *data;
+ GstMIKEYMessage *msg;
+ const GstMIKEYPayload *payload;
+ const gchar *srtp_cipher;
+ const gchar *srtp_auth;
+
+ {
+ gchar *orig_value;
+ gchar *p, *kmpid;
+
+ p = orig_value = g_strdup (keymgmt);
+
+ SKIP_SPACES (p);
+ if (*p == '\0') {
+ g_free (orig_value);
+ return FALSE;
+ }
+
+ PARSE_STRING (p, " ", kmpid);
+ if (kmpid == NULL || !g_str_equal (kmpid, "mikey")) {
+ g_free (orig_value);
+ return FALSE;
+ }
+ data = g_base64_decode (p, &size);
+
+ g_free (orig_value); /* Don't need this any more */
+ }
+
+ if (data == NULL)
+ return FALSE;
+
+ msg = gst_mikey_message_new_from_data (data, size, NULL, NULL);
+ g_free (data);
+ if (msg == NULL)
+ return FALSE;
+
+ srtp_cipher = "aes-128-icm";
+ srtp_auth = "hmac-sha1-80";
+
+ /* check the Security policy if any */
+ if ((payload = gst_mikey_message_find_payload (msg, GST_MIKEY_PT_SP, 0))) {
+ GstMIKEYPayloadSP *p = (GstMIKEYPayloadSP *) payload;
+ guint len, i;
+
+ if (p->proto != GST_MIKEY_SEC_PROTO_SRTP)
+ goto done;
+
+ len = gst_mikey_payload_sp_get_n_params (payload);
+ for (i = 0; i < len; i++) {
+ const GstMIKEYPayloadSPParam *param =
+ gst_mikey_payload_sp_get_param (payload, i);
+
+ switch (param->type) {
+ case GST_MIKEY_SP_SRTP_ENC_ALG:
+ switch (param->val[0]) {
+ case 0:
+ srtp_cipher = "null";
+ break;
+ case 2:
+ case 1:
+ srtp_cipher = "aes-128-icm";
+ break;
+ default:
+ break;
+ }
+ break;
+ case GST_MIKEY_SP_SRTP_ENC_KEY_LEN:
+ switch (param->val[0]) {
+ case AES_128_KEY_LEN:
+ srtp_cipher = "aes-128-icm";
+ break;
+ case AES_256_KEY_LEN:
+ srtp_cipher = "aes-256-icm";
+ break;
+ default:
+ break;
+ }
+ break;
+ case GST_MIKEY_SP_SRTP_AUTH_ALG:
+ switch (param->val[0]) {
+ case 0:
+ srtp_auth = "null";
+ break;
+ case 2:
+ case 1:
+ srtp_auth = "hmac-sha1-80";
+ break;
+ default:
+ break;
+ }
+ break;
+ case GST_MIKEY_SP_SRTP_AUTH_KEY_LEN:
+ switch (param->val[0]) {
+ case HMAC_32_KEY_LEN:
+ srtp_auth = "hmac-sha1-32";
+ break;
+ case HMAC_80_KEY_LEN:
+ srtp_auth = "hmac-sha1-80";
+ break;
+ default:
+ break;
+ }
+ break;
+ case GST_MIKEY_SP_SRTP_SRTP_ENC:
+ break;
+ case GST_MIKEY_SP_SRTP_SRTCP_ENC:
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ if (!(payload = gst_mikey_message_find_payload (msg, GST_MIKEY_PT_KEMAC, 0)))
+ goto done;
+ else {
+ GstMIKEYPayloadKEMAC *p = (GstMIKEYPayloadKEMAC *) payload;
+ const GstMIKEYPayload *sub;
+ GstMIKEYPayloadKeyData *pkd;
+ GstBuffer *buf;
+
+ if (p->enc_alg != GST_MIKEY_ENC_NULL || p->mac_alg != GST_MIKEY_MAC_NULL)
+ goto done;
+
+ if (!(sub = gst_mikey_payload_kemac_get_sub (payload, 0)))
+ goto done;
+
+ if (sub->type != GST_MIKEY_PT_KEY_DATA)
+ goto done;
+
+ pkd = (GstMIKEYPayloadKeyData *) sub;
+ buf =
+ gst_buffer_new_wrapped (g_memdup (pkd->key_data, pkd->key_len),
+ pkd->key_len);
+ gst_caps_set_simple (caps, "srtp-key", GST_TYPE_BUFFER, buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ gst_caps_set_simple (caps,
+ "srtp-cipher", G_TYPE_STRING, srtp_cipher,
+ "srtp-auth", G_TYPE_STRING, srtp_auth,
+ "srtcp-cipher", G_TYPE_STRING, srtp_cipher,
+ "srtcp-auth", G_TYPE_STRING, srtp_auth, NULL);
+
+ res = TRUE;
+done:
+ gst_mikey_message_unref (msg);
+
+ return res;
+}
+
/*
* Mapping SDP attributes to caps
*
continue;
if (!strcmp (key, "range"))
continue;
+ if (!strcmp (key, "framesize"))
+ continue;
+ if (g_str_equal (key, "key-mgmt")) {
+ parse_keymgmt (attr->value, caps);
+ continue;
+ }
/* string must be valid UTF8 */
if (!g_utf8_validate (attr->value, -1, NULL))
* Mapping of caps to and from SDP fields:
*
* a=rtpmap:<payload> <encoding_name>/<clock_rate>[/<encoding_params>]
+ * a=framesize:<payload> <width>-<height>
* a=fmtp:<payload> <param>[=<value>];...
*/
static GstCaps *
GstCaps *caps;
const gchar *rtpmap;
const gchar *fmtp;
+ const gchar *framesize;
gchar *name = NULL;
gint rate = -1;
gchar *params = NULL;
for (i = 0; pairs[i]; i++) {
gchar *valpos;
const gchar *val, *key;
+ gint j;
+ const gchar *reserved_keys[] =
+ { "media", "payload", "clock-rate", "encoding-name",
+ "encoding-params"
+ };
/* the key may not have a '=', the value can have other '='s */
valpos = strstr (pairs[i], "=");
}
/* strip the key of spaces, convert key to lowercase but not the value. */
key = g_strstrip (pairs[i]);
+
+ /* skip keys from the fmtp, which we already use ourselves for the
+ * caps. Some software is adding random things like clock-rate into
+ * the fmtp, and we would otherwise here set a string-typed clock-rate
+ * in the caps... and thus fail to create valid RTP caps
+ */
+ for (j = 0; j < G_N_ELEMENTS (reserved_keys); j++) {
+ if (g_ascii_strcasecmp (reserved_keys[j], key) == 0) {
+ key = "";
+ break;
+ }
+ }
+
if (strlen (key) > 1) {
tmp = g_ascii_strdown (key, -1);
gst_structure_set (s, tmp, G_TYPE_STRING, val, NULL);
g_strfreev (pairs);
}
}
+
+ /* parse framesize: field */
+ if ((framesize = gst_sdp_media_get_attribute_val (media, "framesize"))) {
+ gchar *p;
+
+ /* p is now of the format <payload> <width>-<height> */
+ p = (gchar *) framesize;
+
+ PARSE_INT (p, " ", payload);
+ if (payload != -1 && payload == pt) {
+ gst_structure_set (s, "a-framesize", G_TYPE_STRING, p, NULL);
+ }
+ }
return caps;
/* ERRORS */
g_object_set (G_OBJECT (udpsrc0), "buffer-size", src->udp_buffer_size,
NULL);
- ret = gst_element_set_state (udpsrc0, GST_STATE_PAUSED);
+ ret = gst_element_set_state (udpsrc0, GST_STATE_READY);
if (ret == GST_STATE_CHANGE_FAILURE) {
if (tmp_rtp != 0) {
GST_DEBUG_OBJECT (src, "Unable to make udpsrc from RTP port %d", tmp_rtp);
g_object_set (G_OBJECT (udpsrc1), "port", tmp_rtcp, "reuse", FALSE, NULL);
GST_DEBUG_OBJECT (src, "starting RTCP on port %d", tmp_rtcp);
- ret = gst_element_set_state (udpsrc1, GST_STATE_PAUSED);
+ ret = gst_element_set_state (udpsrc1, GST_STATE_READY);
/* tmp_rtcp port is busy already : retry to make rtp/rtcp pair */
if (ret == GST_STATE_CHANGE_FAILURE) {
GST_DEBUG_OBJECT (src, "Unable to make udpsrc from RTCP port %d", tmp_rtcp);
GST_DEBUG_OBJECT (src, "retaining position %" GST_TIME_FORMAT,
GST_TIME_ARGS (pos));
src->last_pos = pos;
- return;
+ goto out;
}
}
}
src->last_pos = 0;
-}
-static gboolean
-gst_rtspsrc_do_seek (GstRTSPSrc * src, GstSegment * segment)
-{
- src->state = GST_RTSP_STATE_SEEKING;
- /* PLAY will add the range header now. */
- src->need_range = TRUE;
+out:
- return TRUE;
+ gst_query_unref (query);
}
static gboolean
}
src->skip = skip;
- gst_rtspsrc_do_seek (src, &seeksegment);
+ src->state = GST_RTSP_STATE_SEEKING;
+
+ /* PLAY will add the range header now. */
+ src->need_range = TRUE;
/* and continue playing */
if (playing)
seekable = seekable && src->seekable && src->segment.duration &&
GST_CLOCK_TIME_IS_VALID (src->segment.duration);
- /* FIXME ?? should we have 0 and segment.duration here; see demuxers */
- gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,
- src->segment.start, src->segment.stop);
+ gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0,
+ src->segment.duration);
res = TRUE;
}
break;
}
}
+static gboolean
+copy_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data)
+{
+ GstPad *gpad = GST_PAD_CAST (user_data);
+
+ GST_DEBUG_OBJECT (gpad, "store sticky event %" GST_PTR_FORMAT, *event);
+ gst_pad_store_sticky_event (gpad, *event);
+
+ return TRUE;
+}
+
/* this callback is called when the session manager generated a new src pad with
* payloaded RTP packets. We simply ghost the pad here. */
static void
gst_pad_set_event_function (stream->srcpad, gst_rtspsrc_handle_src_event);
gst_pad_set_query_function (stream->srcpad, gst_rtspsrc_handle_src_query);
gst_pad_set_active (stream->srcpad, TRUE);
+ gst_pad_sticky_events_foreach (pad, copy_sticky_events, stream->srcpad);
gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad);
if (all_added) {
}
}
+static GstCaps *
+request_key (GstElement * srtpdec, guint ssrc, GstRTSPStream * stream)
+{
+ GST_DEBUG ("request key %u", ssrc);
+ return gst_caps_ref (stream_get_caps_for_pt (stream, stream->default_pt));
+}
+
+static GstElement *
+request_rtp_decoder (GstElement * rtpbin, guint session, GstRTSPStream * stream)
+{
+ GST_DEBUG ("decoder session %u, stream %p, %d", session, stream, stream->id);
+ if (stream->id != session)
+ return NULL;
+
+ if (stream->profile != GST_RTSP_PROFILE_SAVP &&
+ stream->profile != GST_RTSP_PROFILE_SAVPF)
+ return NULL;
+
+ if (stream->srtpdec == NULL) {
+ gchar *name;
+
+ name = g_strdup_printf ("srtpdec_%u", session);
+ stream->srtpdec = gst_element_factory_make ("srtpdec", name);
+ g_free (name);
+
+ g_signal_connect (stream->srtpdec, "request-key",
+ (GCallback) request_key, stream);
+ }
+ return gst_object_ref (stream->srtpdec);
+}
+
+static GstElement *
+request_rtcp_encoder (GstElement * rtpbin, guint session,
+ GstRTSPStream * stream)
+{
+ gchar *name;
+ GstPad *pad;
+
+ GST_DEBUG ("decoder session %u, stream %p, %d", session, stream, stream->id);
+ if (stream->id != session)
+ return NULL;
+
+ if (stream->profile != GST_RTSP_PROFILE_SAVP &&
+ stream->profile != GST_RTSP_PROFILE_SAVPF)
+ return NULL;
+
+ if (stream->srtpenc == NULL) {
+ GstStructure *s;
+
+ name = g_strdup_printf ("srtpenc_%u", session);
+ stream->srtpenc = gst_element_factory_make ("srtpenc", name);
+ g_free (name);
+
+ /* get RTCP crypto parameters from caps */
+ s = gst_caps_get_structure (stream->srtcpparams, 0);
+ if (s) {
+ GstBuffer *buf;
+ const gchar *str;
+ GType ciphertype, authtype;
+ GValue rtcp_cipher = G_VALUE_INIT, rtcp_auth = G_VALUE_INIT;
+
+ ciphertype = g_type_from_name ("GstSrtpCipherType");
+ authtype = g_type_from_name ("GstSrtpAuthType");
+ g_value_init (&rtcp_cipher, ciphertype);
+ g_value_init (&rtcp_auth, authtype);
+
+ str = gst_structure_get_string (s, "srtcp-cipher");
+ gst_value_deserialize (&rtcp_cipher, str);
+ str = gst_structure_get_string (s, "srtcp-auth");
+ gst_value_deserialize (&rtcp_auth, str);
+ gst_structure_get (s, "srtp-key", GST_TYPE_BUFFER, &buf, NULL);
+
+ g_object_set_property (G_OBJECT (stream->srtpenc), "rtcp-cipher",
+ &rtcp_cipher);
+ g_object_set_property (G_OBJECT (stream->srtpenc), "rtcp-auth",
+ &rtcp_auth);
+ g_object_set (stream->srtpenc, "key", buf, NULL);
+
+ g_value_unset (&rtcp_cipher);
+ g_value_unset (&rtcp_auth);
+ gst_buffer_unref (buf);
+ }
+ }
+ name = g_strdup_printf ("rtcp_sink_%d", session);
+ pad = gst_element_get_request_pad (stream->srtpenc, name);
+ g_free (name);
+ gst_object_unref (pad);
+
+ return gst_object_ref (stream->srtpenc);
+}
+
+static GstElement *
+request_aux_receiver (GstElement * rtpbin, guint sessid, GstRTSPSrc * src)
+{
+ GstElement *rtx, *bin;
+ GstPad *pad;
+ gchar *name;
+ GstRTSPStream *stream;
+
+ stream = find_stream (src, &sessid, (gpointer) find_stream_by_id);
+ if (!stream) {
+ GST_WARNING_OBJECT (src, "Stream %u not found", sessid);
+ return NULL;
+ }
+
+ GST_INFO_OBJECT (src, "creating retransmision receiver for session %u "
+ "with map %" GST_PTR_FORMAT, sessid, stream->rtx_pt_map);
+ bin = gst_bin_new (NULL);
+ rtx = gst_element_factory_make ("rtprtxreceive", NULL);
+ g_object_set (rtx, "payload-type-map", stream->rtx_pt_map, NULL);
+ gst_bin_add (GST_BIN (bin), rtx);
+
+ pad = gst_element_get_static_pad (rtx, "src");
+ name = g_strdup_printf ("src_%u", sessid);
+ gst_element_add_pad (bin, gst_ghost_pad_new (name, pad));
+ g_free (name);
+ gst_object_unref (pad);
+
+ pad = gst_element_get_static_pad (rtx, "sink");
+ name = g_strdup_printf ("sink_%u", sessid);
+ gst_element_add_pad (bin, gst_ghost_pad_new (name, pad));
+ g_free (name);
+ gst_object_unref (pad);
+
+ return bin;
+}
+
+static void
+add_retransmission (GstRTSPSrc * src, GstRTSPTransport * transport)
+{
+ GList *walk;
+ guint signal_id;
+ gboolean do_retransmission = FALSE;
+
+ if (transport->trans != GST_RTSP_TRANS_RTP)
+ return;
+ if (transport->profile != GST_RTSP_PROFILE_AVPF &&
+ transport->profile != GST_RTSP_PROFILE_SAVPF)
+ return;
+
+ signal_id = g_signal_lookup ("request-aux-receiver",
+ G_OBJECT_TYPE (src->manager));
+ /* there's already something connected */
+ if (g_signal_handler_find (src->manager, G_SIGNAL_MATCH_ID, signal_id, 0,
+ NULL, NULL, NULL) != 0) {
+ GST_DEBUG_OBJECT (src, "Not adding RTX AUX element as "
+ "\"request-aux-receiver\" signal is "
+ "already used by the application");
+ return;
+ }
+
+ /* build the retransmission payload type map */
+ for (walk = src->streams; walk; walk = g_list_next (walk)) {
+ GstRTSPStream *stream = (GstRTSPStream *) walk->data;
+ gboolean do_retransmission_stream = FALSE;
+ int i;
+
+ if (stream->rtx_pt_map)
+ gst_structure_free (stream->rtx_pt_map);
+ stream->rtx_pt_map = gst_structure_new_empty ("application/x-rtp-pt-map");
+
+ for (i = 0; i < stream->ptmap->len; i++) {
+ PtMapItem *item = &g_array_index (stream->ptmap, PtMapItem, i);
+ GstStructure *s = gst_caps_get_structure (item->caps, 0);
+ const gchar *encoding;
+
+ /* we only care about RTX streams */
+ if ((encoding = gst_structure_get_string (s, "encoding-name"))
+ && g_strcmp0 (encoding, "RTX") == 0) {
+ const gchar *stream_pt_s;
+ gint rtx_pt;
+
+ if (gst_structure_get_int (s, "payload", &rtx_pt)
+ && (stream_pt_s = gst_structure_get_string (s, "apt"))) {
+
+ if (rtx_pt != 0) {
+ gst_structure_set (stream->rtx_pt_map, stream_pt_s, G_TYPE_UINT,
+ rtx_pt, NULL);
+ do_retransmission_stream = TRUE;
+ }
+ }
+ }
+ }
+
+ if (do_retransmission_stream) {
+ GST_DEBUG_OBJECT (src, "built retransmission payload map for stream "
+ "id %i: %" GST_PTR_FORMAT, stream->id, stream->rtx_pt_map);
+ do_retransmission = TRUE;
+ } else {
+ GST_DEBUG_OBJECT (src, "no retransmission payload map for stream "
+ "id %i", stream->id);
+ gst_structure_free (stream->rtx_pt_map);
+ stream->rtx_pt_map = NULL;
+ }
+ }
+
+ if (do_retransmission) {
+ GST_DEBUG_OBJECT (src, "Enabling retransmissions");
+
+ g_object_set (src->manager, "do-retransmission", TRUE, NULL);
+
+ /* enable RFC4588 retransmission handling by setting rtprtxreceive
+ * as the "aux" element of rtpbin */
+ g_signal_connect (src->manager, "request-aux-receiver",
+ (GCallback) request_aux_receiver, src);
+ } else {
+ GST_DEBUG_OBJECT (src,
+ "Not enabling retransmissions as no stream had a retransmission payload map");
+ }
+}
+
/* try to get and configure a manager */
static gboolean
gst_rtspsrc_stream_configure_manager (GstRTSPSrc * src, GstRTSPStream * stream,
g_object_set (src->manager, "ntp-sync", src->ntp_sync, NULL);
}
- if (g_object_class_find_property (klass, "use-pipeline-clock")) {
- g_object_set (src->manager, "use-pipeline-clock",
- src->use_pipeline_clock, NULL);
+ if (src->use_pipeline_clock) {
+ if (g_object_class_find_property (klass, "use-pipeline-clock")) {
+ g_object_set (src->manager, "use-pipeline-clock", TRUE, NULL);
+ }
+ } else {
+ if (g_object_class_find_property (klass, "ntp-time-source")) {
+ g_object_set (src->manager, "ntp-time-source", src->ntp_time_source,
+ NULL);
+ }
}
if (src->sdes && g_object_class_find_property (klass, "sdes")) {
NULL);
}
+ if (g_object_class_find_property (klass, "max-rtcp-rtp-time-diff")) {
+ g_object_set (src->manager, "max-rtcp-rtp-time-diff",
+ src->max_rtcp_rtp_time_diff, NULL);
+ }
+
/* buffer mode pauses are handled by adding offsets to buffer times,
* but some depayloaders may have a hard time syncing output times
* with such input times, e.g. container ones, most notably ASF */
* so slaving in jitterbuffer does not make much sense
* (and might mess things up due to bursts) */
if (GST_CLOCK_TIME_IS_VALID (src->segment.duration) &&
- src->segment.duration && !stream->container) {
+ src->segment.duration && stream->container) {
src->use_buffering = TRUE;
} else {
src->use_buffering = FALSE;
g_signal_emit (src, gst_rtspsrc_signals[SIGNAL_NEW_MANAGER], 0,
src->manager);
+
+ if (src->do_retransmission)
+ add_retransmission (src, transport);
}
+ g_signal_connect (src->manager, "request-rtp-decoder",
+ (GCallback) request_rtp_decoder, stream);
+ g_signal_connect (src->manager, "request-rtcp-decoder",
+ (GCallback) request_rtp_decoder, stream);
+ g_signal_connect (src->manager, "request-rtcp-encoder",
+ (GCallback) request_rtcp_encoder, stream);
/* we stream directly to the manager, get some pads. Each RTSP stream goes
* into a separate RTP session. */
g_signal_emit_by_name (src->manager, "get-internal-session", stream->id,
&rtpsession);
if (rtpsession) {
+ GstRTPProfile rtp_profile;
+
GST_INFO_OBJECT (src, "configure bandwidth in session %p", rtpsession);
stream->session = rtpsession;
NULL);
}
+ switch (stream->profile) {
+ case GST_RTSP_PROFILE_AVPF:
+ rtp_profile = GST_RTP_PROFILE_AVPF;
+ break;
+ case GST_RTSP_PROFILE_SAVP:
+ rtp_profile = GST_RTP_PROFILE_SAVP;
+ break;
+ case GST_RTSP_PROFILE_SAVPF:
+ rtp_profile = GST_RTP_PROFILE_SAVPF;
+ break;
+ case GST_RTSP_PROFILE_AVP:
+ default:
+ rtp_profile = GST_RTP_PROFILE_AVP;
+ break;
+ }
+
+ g_object_set (rtpsession, "rtp-profile", rtp_profile, NULL);
+
g_object_set (rtpsession, "probation", src->probation, NULL);
+ g_object_set (rtpsession, "internal-ssrc", stream->send_ssrc, NULL);
+
g_signal_connect (rtpsession, "on-bye-ssrc", (GCallback) on_bye_ssrc,
stream);
g_signal_connect (rtpsession, "on-bye-timeout", (GCallback) on_timeout,
/* change state */
gst_element_set_locked_state (stream->udpsrc[0], TRUE);
- gst_element_set_state (stream->udpsrc[0], GST_STATE_PAUSED);
+ gst_element_set_state (stream->udpsrc[0], GST_STATE_READY);
}
/* creating another UDP source for RTCP */
if (stream->udpsrc[1] == NULL)
goto no_element;
- caps = gst_caps_new_empty_simple ("application/x-rtcp");
+ if (stream->profile == GST_RTSP_PROFILE_SAVP ||
+ stream->profile == GST_RTSP_PROFILE_SAVPF)
+ caps = gst_caps_new_empty_simple ("application/x-srtcp");
+ else
+ caps = gst_caps_new_empty_simple ("application/x-rtcp");
g_object_set (stream->udpsrc[1], "caps", caps, NULL);
gst_caps_unref (caps);
g_object_set (G_OBJECT (stream->udpsrc[0]), "multicast-iface",
src->multi_iface, NULL);
- gst_element_set_state (stream->udpsrc[1], GST_STATE_PAUSED);
+ gst_element_set_state (stream->udpsrc[1], GST_STATE_READY);
}
return TRUE;
/* we manage the UDP elements now. For unicast, the UDP sources where
* allocated in the stream when we suggested a transport. */
if (stream->udpsrc[0]) {
+ GstCaps *caps;
+
gst_element_set_locked_state (stream->udpsrc[0], TRUE);
gst_bin_add (GST_BIN_CAST (src), stream->udpsrc[0]);
g_object_set (G_OBJECT (stream->udpsrc[0]), "timeout",
src->udp_timeout * 1000, NULL);
+ if ((caps = stream_get_caps_for_pt (stream, stream->default_pt)))
+ g_object_set (stream->udpsrc[0], "caps", caps, NULL);
+
/* get output pad of the UDP source. */
*outpad = gst_element_get_static_pad (stream->udpsrc[0], "src");
* configure all the streams to let the application autoplug decoders. */
stream->blockid =
gst_pad_add_probe (stream->blockedpad,
- GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM, pad_blocked, src, NULL);
+ GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_BUFFER |
+ GST_PAD_PROBE_TYPE_BUFFER_LIST, pad_blocked, src, NULL);
if (stream->channelpad[0]) {
GST_DEBUG_OBJECT (src, "connecting UDP source 0 to manager");
gst_element_set_locked_state (stream->udpsrc[1], TRUE);
gst_bin_add (GST_BIN_CAST (src), stream->udpsrc[1]);
- caps = gst_caps_new_empty_simple ("application/x-rtcp");
+ if (stream->profile == GST_RTSP_PROFILE_SAVP ||
+ stream->profile == GST_RTSP_PROFILE_SAVPF)
+ caps = gst_caps_new_empty_simple ("application/x-srtcp");
+ else
+ caps = gst_caps_new_empty_simple ("application/x-rtcp");
g_object_set (stream->udpsrc[1], "caps", caps, NULL);
gst_caps_unref (caps);
s = gst_caps_get_structure (item->caps, 0);
gst_structure_set_name (s, media_type);
+ /* set ssrc if known */
+ if (transport->ssrc)
+ gst_structure_set (s, "ssrc", G_TYPE_UINT, transport->ssrc, NULL);
}
/* try to get and configure a manager, channelpad[0-1] will be configured with
item->caps = caps;
GST_DEBUG_OBJECT (src, "stream %p, pt %d, caps %" GST_PTR_FORMAT, stream,
item->pt, caps);
+
+ if (item->pt == stream->default_pt && stream->udpsrc[0]) {
+ g_object_set (stream->udpsrc[0], "caps", caps, NULL);
+ }
}
}
if (reset_manager && src->manager) {
if ((res = gst_rtsp_connection_create (info->url, &info->connection)) < 0)
goto could_not_create;
- if (info->url_str)
- g_free (info->url_str);
+ g_free (info->url_str);
info->url_str = gst_rtsp_url_get_request_uri (info->url);
GST_DEBUG_OBJECT (src, "sanitized uri %s", info->url_str);
if (src->tls_database)
gst_rtsp_connection_set_tls_database (info->connection,
src->tls_database);
+
+ if (src->tls_interaction)
+ gst_rtsp_connection_set_tls_interaction (info->connection,
+ src->tls_interaction);
}
if (info->url->transports & GST_RTSP_LOWER_TRANS_HTTP)
GST_RTSP_STATE_UNLOCK (src);
}
+static GstRTSPResult
+gst_rtspsrc_init_request (GstRTSPSrc * src, GstRTSPMessage * msg,
+ GstRTSPMethod method, const gchar * uri)
+{
+ GstRTSPResult res;
+
+ res = gst_rtsp_message_init_request (msg, method, uri);
+ if (res < 0)
+ return res;
+
+ /* set user-agent */
+ if (src->user_agent)
+ gst_rtsp_message_add_header (msg, GST_RTSP_HDR_USER_AGENT, src->user_agent);
+
+ return res;
+}
+
/* FIXME, handle server request, reply with OK, for now */
static GstRTSPResult
gst_rtspsrc_handle_request (GstRTSPSrc * src, GstRTSPConnection * conn,
if (control == NULL)
goto no_control;
- res = gst_rtsp_message_init_request (&request, method, control);
+ res = gst_rtspsrc_init_request (src, &request, method, control);
if (res < 0)
goto send_error;
guint size;
GstBuffer *buf;
gboolean is_rtcp;
- GstEvent *event;
channel = message->type_data.data.channel;
for (streams = src->streams; streams; streams = g_list_next (streams)) {
GstRTSPStream *ostream = (GstRTSPStream *) streams->data;
+ GstCaps *caps;
stream_id =
g_strdup_printf ("%s/%d", g_checksum_get_string (cs), ostream->id);
g_free (stream_id);
gst_rtspsrc_stream_push_event (src, ostream, event);
+
+ if ((caps = stream_get_caps_for_pt (ostream, ostream->default_pt))) {
+ /* only streams that have a connection to the outside world */
+ if (ostream->setup) {
+ if (ostream->udpsrc[0]) {
+ gst_element_send_event (ostream->udpsrc[0],
+ gst_event_new_caps (caps));
+ } else if (ostream->channelpad[0]) {
+ if (GST_PAD_IS_SRC (ostream->channelpad[0]))
+ gst_pad_push_event (ostream->channelpad[0],
+ gst_event_new_caps (caps));
+ else
+ gst_pad_send_event (ostream->channelpad[0],
+ gst_event_new_caps (caps));
+ }
+
+ caps = gst_caps_new_empty_simple ("application/x-rtcp");
+
+ if (ostream->udpsrc[1]) {
+ gst_element_send_event (ostream->udpsrc[1],
+ gst_event_new_caps (caps));
+ } else if (ostream->channelpad[1]) {
+ if (GST_PAD_IS_SRC (ostream->channelpad[1]))
+ gst_pad_push_event (ostream->channelpad[1],
+ gst_event_new_caps (caps));
+ else
+ gst_pad_send_event (ostream->channelpad[1],
+ gst_event_new_caps (caps));
+ }
+
+ gst_caps_unref (caps);
+ }
+ }
}
g_checksum_free (cs);
gst_rtspsrc_activate_streams (src);
src->need_activate = FALSE;
- }
- if ((event = src->start_segment) != NULL) {
- src->start_segment = NULL;
- gst_rtspsrc_push_event (src, event);
+ src->need_segment = TRUE;
}
if (src->base_time == -1) {
GST_OBJECT_UNLOCK (src);
}
+ /* If needed send a new segment, don't forget we are live and buffer are
+ * timestamped with running time */
+ if (src->need_segment) {
+ GstSegment segment;
+ src->need_segment = FALSE;
+ gst_segment_init (&segment, GST_FORMAT_TIME);
+ gst_rtspsrc_push_event (src, gst_event_new_segment (&segment));
+ }
+
if (stream->discont && !is_rtcp) {
/* mark first RTP buffer as discont */
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
/* start new request */
gst_rtspsrc_loop_start_cmd (src, cmd);
- GST_DEBUG_OBJECT (src, "sending cmd %d", cmd);
+ GST_DEBUG_OBJECT (src, "sending cmd %s", cmd_to_string (cmd));
GST_OBJECT_LOCK (src);
old = src->pending_cmd;
src->pending_cmd = CMD_WAIT;
GST_OBJECT_UNLOCK (src);
/* cancel previous request */
- GST_DEBUG_OBJECT (src, "cancel previous request %d", old);
+ GST_DEBUG_OBJECT (src, "cancel previous request %s", cmd_to_string (old));
gst_rtspsrc_loop_cancel_cmd (src, old);
GST_OBJECT_LOCK (src);
}
src->pending_cmd = cmd;
/* interrupt if allowed */
if (src->busy_cmd & mask) {
- GST_DEBUG_OBJECT (src, "connection flush busy %d", src->busy_cmd);
+ GST_DEBUG_OBJECT (src, "connection flush busy %s",
+ cmd_to_string (src->busy_cmd));
gst_rtspsrc_connection_flush (src, TRUE);
flushed = TRUE;
} else {
- GST_DEBUG_OBJECT (src, "not interrupting busy cmd %d", src->busy_cmd);
+ GST_DEBUG_OBJECT (src, "not interrupting busy cmd %s",
+ cmd_to_string (src->busy_cmd));
}
if (src->task)
gst_task_start (src->task);
} else
value = NULL;
- if (item && (strcmp (item, "stale") == 0) &&
- value && (strcmp (value, "TRUE") == 0))
+ if (value && strcmp (item, "stale") == 0 && strcmp (value, "TRUE") == 0)
*stale = TRUE;
gst_rtsp_connection_set_auth_param (conn, item, value);
g_free (item);
switch (int_code) {
case GST_RTSP_STS_UNAUTHORIZED:
+ case GST_RTSP_STS_NOT_FOUND:
if (gst_rtspsrc_setup_auth (src, response)) {
/* Try the request/response again after configuring the auth info
* and loop again */
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), ("%s",
response->type_data.response.reason));
break;
+ case GST_RTSP_STS_UNAUTHORIZED:
+ GST_ELEMENT_ERROR (src, RESOURCE, NOT_AUTHORIZED, (NULL), ("%s",
+ response->type_data.response.reason));
+ break;
case GST_RTSP_STS_MOVED_PERMANENTLY:
case GST_RTSP_STS_MOVE_TEMPORARILY:
{
/* masks to be kept in sync with the hardcoded protocol order of preference
* in code below */
-static guint protocol_masks[] = {
+static const guint protocol_masks[] = {
GST_RTSP_LOWER_TRANS_UDP,
GST_RTSP_LOWER_TRANS_UDP_MCAST,
GST_RTSP_LOWER_TRANS_TCP,
}
}
+static guint8
+enc_key_length_from_cipher_name (const gchar * cipher)
+{
+ if (g_strcmp0 (cipher, "aes-128-icm") == 0)
+ return AES_128_KEY_LEN;
+ else if (g_strcmp0 (cipher, "aes-256-icm") == 0)
+ return AES_256_KEY_LEN;
+ else {
+ GST_ERROR ("encryption algorithm '%s' not supported", cipher);
+ return 0;
+ }
+}
+
+static guint8
+auth_key_length_from_auth_name (const gchar * auth)
+{
+ if (g_strcmp0 (auth, "hmac-sha1-32") == 0)
+ return HMAC_32_KEY_LEN;
+ else if (g_strcmp0 (auth, "hmac-sha1-80") == 0)
+ return HMAC_80_KEY_LEN;
+ else {
+ GST_ERROR ("authentication algorithm '%s' not supported", auth);
+ return 0;
+ }
+}
+
+static GstCaps *
+signal_get_srtcp_params (GstRTSPSrc * src, GstRTSPStream * stream)
+{
+ GstCaps *caps = NULL;
+
+ g_signal_emit (src, gst_rtspsrc_signals[SIGNAL_REQUEST_RTCP_KEY], 0,
+ stream->id, &caps);
+
+ if (caps != NULL)
+ GST_DEBUG_OBJECT (src, "SRTP parameters received");
+
+ return caps;
+}
+
+static GstCaps *
+default_srtcp_params (void)
+{
+ guint i;
+ GstCaps *caps;
+ GstBuffer *buf;
+ guint8 *key_data;
+#define KEY_SIZE 30
+ guint data_size = GST_ROUND_UP_4 (KEY_SIZE);
+
+ /* create a random key */
+ key_data = g_malloc (data_size);
+ for (i = 0; i < data_size; i += 4)
+ GST_WRITE_UINT32_BE (key_data + i, g_random_int ());
+
+ buf = gst_buffer_new_wrapped (key_data, KEY_SIZE);
+
+ caps = gst_caps_new_simple ("application/x-srtp",
+ "srtp-key", GST_TYPE_BUFFER, buf,
+ "srtcp-cipher", G_TYPE_STRING, "aes-128-icm",
+ "srtcp-auth", G_TYPE_STRING, "hmac-sha1-80", NULL);
+
+ gst_buffer_unref (buf);
+
+ return caps;
+}
+
+static gchar *
+gst_rtspsrc_stream_make_keymgmt (GstRTSPSrc * src, GstRTSPStream * stream)
+{
+ GBytes *bytes;
+ gchar *result, *base64;
+ const guint8 *data;
+ gsize size;
+ GstMIKEYMessage *msg;
+ GstMIKEYPayload *payload, *pkd;
+ guint8 byte;
+ GstStructure *s;
+ GstMapInfo info;
+ GstBuffer *srtpkey;
+ const GValue *val;
+ const gchar *srtcpcipher, *srtcpauth;
+
+ stream->srtcpparams = signal_get_srtcp_params (src, stream);
+ if (stream->srtcpparams == NULL)
+ stream->srtcpparams = default_srtcp_params ();
+
+ s = gst_caps_get_structure (stream->srtcpparams, 0);
+
+ srtcpcipher = gst_structure_get_string (s, "srtcp-cipher");
+ srtcpauth = gst_structure_get_string (s, "srtcp-auth");
+ val = gst_structure_get_value (s, "srtp-key");
+
+ if (srtcpcipher == NULL || srtcpauth == NULL || val == NULL) {
+ GST_ERROR_OBJECT (src, "could not find the right SRTP parameters in caps");
+ return NULL;
+ }
+
+ srtpkey = gst_value_get_buffer (val);
+
+ 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, g_random_int (), GST_MIKEY_MAP_TYPE_SRTP);
+ /* add policy '0' for our SSRC */
+ gst_mikey_message_add_cs_srtp (msg, 0, stream->send_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 */
+ 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 (srtcpcipher);
+ 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 (srtcpauth);
+ 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 KEMAC */
+ 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);
+ 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);
+
+ result = g_strdup_printf ("prot=mikey;uri=\"%s\";data=\"%s\"",
+ stream->conninfo.location, base64);
+ g_free (base64);
+
+ return result;
+}
+
+
/* Perform the SETUP request for all the streams.
*
* We ask the server for a specific transport, which initially includes all the
/* create SETUP request */
res =
- gst_rtsp_message_init_request (&request, GST_RTSP_SETUP,
+ gst_rtspsrc_init_request (src, &request, GST_RTSP_SETUP,
stream->conninfo.location);
if (res < 0) {
g_free (transports);
/* select transport */
gst_rtsp_message_take_header (&request, GST_RTSP_HDR_TRANSPORT, transports);
+ /* set up keys */
+ if (stream->profile == GST_RTSP_PROFILE_SAVP ||
+ stream->profile == GST_RTSP_PROFILE_SAVPF) {
+ hval = gst_rtspsrc_stream_make_keymgmt (src, stream);
+ gst_rtsp_message_take_header (&request, GST_RTSP_HDR_KEYMGMT, hval);
+ }
+
/* if the user wants a non default RTP packet size we add the blocksize
* parameter */
if (src->rtp_blocksize > 0) {
stream->id));
/* handle the code ourselves */
- if ((res = gst_rtspsrc_send (src, conn, &request, &response, &code) < 0))
+ res = gst_rtspsrc_send (src, conn, &request, &response, &code);
+ if (res < 0)
goto send_error;
switch (code) {
break;
}
- if (!stream->container || (!src->interleaved && !retry)) {
+ if (!src->interleaved || !retry) {
/* now configure the stream with the selected transport */
if (!gst_rtspsrc_stream_configure_transport (stream, &transport)) {
GST_DEBUG_OBJECT (src,
/* create OPTIONS */
GST_DEBUG_OBJECT (src, "create options...");
res =
- gst_rtsp_message_init_request (&request, GST_RTSP_OPTIONS,
+ gst_rtspsrc_init_request (src, &request, GST_RTSP_OPTIONS,
src->conninfo.url_str);
if (res < 0)
goto create_request_failed;
/* create DESCRIBE */
GST_DEBUG_OBJECT (src, "create describe...");
res =
- gst_rtsp_message_init_request (&request, GST_RTSP_DESCRIBE,
+ gst_rtspsrc_init_request (src, &request, GST_RTSP_DESCRIBE,
src->conninfo.url_str);
if (res < 0)
goto create_request_failed;
}
/* it could be that the DESCRIBE method was not implemented */
- if (!src->methods & GST_RTSP_DESCRIBE)
+ if (!(src->methods & GST_RTSP_DESCRIBE))
goto no_describe;
/* check if reply is SDP */
/* could not be set but since the request returned OK, we assume it
* was SDP, else check it. */
if (respcont) {
- if (!g_ascii_strcasecmp (respcont, "application/sdp") == 0)
+ if (g_ascii_strcasecmp (respcont, "application/sdp") != 0)
goto wrong_content_type;
}
/* do TEARDOWN */
res =
- gst_rtsp_message_init_request (&request, GST_RTSP_TEARDOWN, setup_url);
+ gst_rtspsrc_init_request (src, &request, GST_RTSP_TEARDOWN, setup_url);
if (res < 0)
goto create_request_failed;
if (src->manager)
g_signal_emit_by_name (src->manager, "reset-sync", NULL);
- gst_rtspsrc_set_state (src, GST_STATE_PLAYING);
-
/* construct a control url */
control = get_aggregate_control (src);
}
/* do play */
- res = gst_rtsp_message_init_request (&request, GST_RTSP_PLAY, setup_url);
+ res = gst_rtspsrc_init_request (src, &request, GST_RTSP_PLAY, setup_url);
if (res < 0)
goto create_request_failed;
gst_rtsp_message_take_header (&request, GST_RTSP_HDR_RANGE, hval);
/* store the newsegment event so it can be sent from the streaming thread. */
- if (src->start_segment)
- gst_event_unref (src->start_segment);
- src->start_segment = gst_event_new_segment (&src->segment);
+ src->need_segment = TRUE;
}
if (segment->rate != 1.0) {
* the manager object when we set a new Range header (we did a seek) */
gst_rtspsrc_configure_caps (src, segment, src->need_range);
+ /* set to PLAYING after we have configured the caps, otherwise we
+ * might end up calling request_key (with SRTP) while caps are still
+ * being configured. */
+ gst_rtspsrc_set_state (src, GST_STATE_PLAYING);
+
/* set again when needed */
src->need_range = FALSE;
("Sending PAUSE request"));
if ((res =
- gst_rtsp_message_init_request (&request, GST_RTSP_PAUSE,
+ gst_rtspsrc_init_request (src, &request, GST_RTSP_PAUSE,
setup_url)) < 0)
goto create_request_failed;
src->pending_cmd = CMD_LOOP;
else
src->pending_cmd = CMD_WAIT;
- GST_DEBUG_OBJECT (src, "got command %d", cmd);
+ GST_DEBUG_OBJECT (src, "got command %s", cmd_to_string (cmd));
/* we got the message command, so ensure communication is possible again */
gst_rtspsrc_connection_flush (src, FALSE);
{
GstRTSPSrc *src;
GstRTSPResult res;
+ GstSDPResult sres;
GstRTSPUrl *newurl = NULL;
GstSDPMessage *sdp = NULL;
goto was_ok;
if (g_str_has_prefix (uri, "rtsp-sdp://")) {
- if ((res = gst_sdp_message_new (&sdp) < 0))
+ sres = gst_sdp_message_new (&sdp);
+ if (sres < 0)
goto sdp_failed;
GST_DEBUG_OBJECT (src, "parsing SDP message");
- if ((res = gst_sdp_message_parse_uri (uri, sdp) < 0))
+ sres = gst_sdp_message_parse_uri (uri, sdp);
+ if (sres < 0)
goto invalid_sdp;
} else {
/* try to parse */
}
sdp_failed:
{
- GST_ERROR_OBJECT (src, "Could not create new SDP (%d)", res);
+ GST_ERROR_OBJECT (src, "Could not create new SDP (%d)", sres);
g_set_error_literal (error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
"Could not create SDP");
return FALSE;
}
invalid_sdp:
{
- GST_ERROR_OBJECT (src, "Not a valid SDP (%d) '%s'", res,
+ GST_ERROR_OBJECT (src, "Not a valid SDP (%d) '%s'", sres,
GST_STR_NULL (uri));
gst_sdp_message_free (sdp);
g_set_error_literal (error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,