*
* 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., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*/
#include <string.h>
#include "rtsp-media.h"
+#define GST_RTSP_MEDIA_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTSP_MEDIA, GstRTSPMediaPrivate))
+
+struct _GstRTSPMediaPrivate
+{
+ GMutex lock;
+ GCond cond;
+
+ /* protected by lock */
+ gboolean shared;
+ gboolean reusable;
+ GstRTSPLowerTrans protocols;
+ gboolean reused;
+ gboolean eos_shutdown;
+ guint buffer_size;
+ GstRTSPAuth *auth;
+ GstRTSPAddressPool *pool;
+
+ GstElement *element;
+ GRecMutex state_lock; /* locking order: state lock, lock */
+ GPtrArray *streams; /* protected by lock */
+ GList *dynamic; /* protected by lock */
+ GstRTSPMediaStatus status; /* protected by lock */
+ gint prepare_count;
+ gint n_active;
+ gboolean adding;
+
+ /* the pipeline for the media */
+ GstElement *pipeline;
+ GstElement *fakesink; /* protected by lock */
+ GSource *source;
+ guint id;
+
+ gboolean time_provider;
+ GstNetTimeProvider *nettime;
+
+ gboolean is_live;
+ gboolean seekable;
+ gboolean buffering;
+ GstState target_state;
+
+ /* RTP session manager */
+ GstElement *rtpbin;
+
+ /* the range of media */
+ GstRTSPTimeRange range; /* protected by lock */
+ GstClockTime range_start;
+ GstClockTime range_stop;
+};
+
#define DEFAULT_SHARED FALSE
#define DEFAULT_REUSABLE FALSE
#define DEFAULT_PROTOCOLS GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_TCP
//#define DEFAULT_PROTOCOLS GST_RTSP_LOWER_TRANS_UDP_MCAST
#define DEFAULT_EOS_SHUTDOWN FALSE
#define DEFAULT_BUFFER_SIZE 0x80000
-#define DEFAULT_MULTICAST_GROUP "224.2.0.1"
-#define DEFAULT_MTU 0
+#define DEFAULT_TIME_PROVIDER FALSE
/* define to dump received RTCP packets */
#undef DUMP_STATS
PROP_PROTOCOLS,
PROP_EOS_SHUTDOWN,
PROP_BUFFER_SIZE,
- PROP_MULTICAST_GROUP,
- PROP_MTU,
+ PROP_ELEMENT,
+ PROP_TIME_PROVIDER,
PROP_LAST
};
enum
{
+ SIGNAL_NEW_STREAM,
+ SIGNAL_REMOVED_STREAM,
SIGNAL_PREPARED,
SIGNAL_UNPREPARED,
SIGNAL_NEW_STATE,
GstMessage * message);
static void finish_unprepare (GstRTSPMedia * media);
static gboolean default_unprepare (GstRTSPMedia * media);
-static void unlock_streams (GstRTSPMedia * media);
+static gboolean
+default_convert_range (GstRTSPMedia * media, GstRTSPTimeRange * range,
+ GstRTSPRangeUnit unit);
static guint gst_rtsp_media_signals[SIGNAL_LAST] = { 0 };
{
GObjectClass *gobject_class;
+ g_type_class_add_private (klass, sizeof (GstRTSPMediaPrivate));
+
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->get_property = gst_rtsp_media_get_property;
"The kernel UDP buffer size to use", 0, G_MAXUINT,
DEFAULT_BUFFER_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
- g_object_class_install_property (gobject_class, PROP_MULTICAST_GROUP,
- g_param_spec_string ("multicast-group", "Multicast Group",
- "The Multicast group to send media to",
- DEFAULT_MULTICAST_GROUP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_ELEMENT,
+ g_param_spec_object ("element", "The Element",
+ "The GstBin to use for streaming the media", GST_TYPE_ELEMENT,
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_MTU,
- g_param_spec_uint ("mtu", "MTU",
- "The MTU for the payloaders (0 = default)",
- 0, G_MAXUINT, DEFAULT_MTU,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_EOS_SHUTDOWN,
+ g_param_spec_boolean ("time-provider", "Time Provider",
+ "Use a NetTimeProvider for clients",
+ DEFAULT_TIME_PROVIDER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ gst_rtsp_media_signals[SIGNAL_NEW_STREAM] =
+ g_signal_new ("new-stream", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstRTSPMediaClass, new_stream), NULL, NULL,
+ g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_RTSP_STREAM);
+
+ gst_rtsp_media_signals[SIGNAL_REMOVED_STREAM] =
+ g_signal_new ("removed-stream", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPMediaClass, removed_stream),
+ NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
+ GST_TYPE_RTSP_STREAM);
gst_rtsp_media_signals[SIGNAL_PREPARED] =
g_signal_new ("prepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
klass->handle_message = default_handle_message;
klass->unprepare = default_unprepare;
+ klass->convert_range = default_convert_range;
}
static void
gst_rtsp_media_init (GstRTSPMedia * media)
{
- media->streams = g_ptr_array_new_with_free_func (g_object_unref);
- g_mutex_init (&media->lock);
- g_cond_init (&media->cond);
-
- media->shared = DEFAULT_SHARED;
- media->reusable = DEFAULT_REUSABLE;
- media->protocols = DEFAULT_PROTOCOLS;
- media->eos_shutdown = DEFAULT_EOS_SHUTDOWN;
- media->buffer_size = DEFAULT_BUFFER_SIZE;
- media->multicast_group = g_strdup (DEFAULT_MULTICAST_GROUP);
+ GstRTSPMediaPrivate *priv = GST_RTSP_MEDIA_GET_PRIVATE (media);
+
+ media->priv = priv;
+
+ priv->streams = g_ptr_array_new_with_free_func (g_object_unref);
+ g_mutex_init (&priv->lock);
+ g_cond_init (&priv->cond);
+ g_rec_mutex_init (&priv->state_lock);
+
+ priv->shared = DEFAULT_SHARED;
+ priv->reusable = DEFAULT_REUSABLE;
+ priv->protocols = DEFAULT_PROTOCOLS;
+ priv->eos_shutdown = DEFAULT_EOS_SHUTDOWN;
+ priv->buffer_size = DEFAULT_BUFFER_SIZE;
+ priv->time_provider = DEFAULT_TIME_PROVIDER;
}
static void
gst_rtsp_media_finalize (GObject * obj)
{
+ GstRTSPMediaPrivate *priv;
GstRTSPMedia *media;
media = GST_RTSP_MEDIA (obj);
+ priv = media->priv;
GST_INFO ("finalize media %p", media);
- gst_rtsp_media_unprepare (media);
-
- g_ptr_array_unref (media->streams);
+ g_ptr_array_unref (priv->streams);
- g_list_free_full (media->dynamic, gst_object_unref);
+ g_list_free_full (priv->dynamic, gst_object_unref);
- if (media->source) {
- g_source_destroy (media->source);
- g_source_unref (media->source);
- }
- g_free (media->multicast_group);
- g_mutex_clear (&media->lock);
- g_cond_clear (&media->cond);
+ if (priv->pipeline)
+ gst_object_unref (priv->pipeline);
+ if (priv->nettime)
+ gst_object_unref (priv->nettime);
+ gst_object_unref (priv->element);
+ if (priv->auth)
+ g_object_unref (priv->auth);
+ if (priv->pool)
+ g_object_unref (priv->pool);
+ g_mutex_clear (&priv->lock);
+ g_cond_clear (&priv->cond);
+ g_rec_mutex_clear (&priv->state_lock);
G_OBJECT_CLASS (gst_rtsp_media_parent_class)->finalize (obj);
}
GstRTSPMedia *media = GST_RTSP_MEDIA (object);
switch (propid) {
+ case PROP_ELEMENT:
+ g_value_set_object (value, media->priv->element);
+ break;
case PROP_SHARED:
g_value_set_boolean (value, gst_rtsp_media_is_shared (media));
break;
case PROP_BUFFER_SIZE:
g_value_set_uint (value, gst_rtsp_media_get_buffer_size (media));
break;
- case PROP_MULTICAST_GROUP:
- g_value_take_string (value, gst_rtsp_media_get_multicast_group (media));
- break;
- case PROP_MTU:
- g_value_set_uint (value, gst_rtsp_media_get_mtu (media));
+ case PROP_TIME_PROVIDER:
+ g_value_set_boolean (value, gst_rtsp_media_is_time_provider (media));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
GstRTSPMedia *media = GST_RTSP_MEDIA (object);
switch (propid) {
+ case PROP_ELEMENT:
+ media->priv->element = g_value_get_object (value);
+ gst_object_ref_sink (media->priv->element);
+ break;
case PROP_SHARED:
gst_rtsp_media_set_shared (media, g_value_get_boolean (value));
break;
case PROP_BUFFER_SIZE:
gst_rtsp_media_set_buffer_size (media, g_value_get_uint (value));
break;
- case PROP_MULTICAST_GROUP:
- gst_rtsp_media_set_multicast_group (media, g_value_get_string (value));
- break;
- case PROP_MTU:
- gst_rtsp_media_set_mtu (media, g_value_get_uint (value));
+ case PROP_TIME_PROVIDER:
+ gst_rtsp_media_use_time_provider (media, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
return NULL;
}
+/* must be called with state lock */
static void
collect_media_stats (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv = media->priv;
gint64 position, duration;
- media->range.unit = GST_RTSP_RANGE_NPT;
+ if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED &&
+ priv->status != GST_RTSP_MEDIA_STATUS_PREPARING)
+ return;
+
+ priv->range.unit = GST_RTSP_RANGE_NPT;
+
+ GST_INFO ("collect media stats");
- if (media->is_live) {
- media->range.min.type = GST_RTSP_TIME_NOW;
- media->range.min.seconds = -1;
- media->range.max.type = GST_RTSP_TIME_END;
- media->range.max.seconds = -1;
+ if (priv->is_live) {
+ priv->range.min.type = GST_RTSP_TIME_NOW;
+ priv->range.min.seconds = -1;
+ priv->range_start = -1;
+ priv->range.max.type = GST_RTSP_TIME_END;
+ priv->range.max.seconds = -1;
+ priv->range_stop = -1;
} else {
/* get the position */
- if (!gst_element_query_position (media->pipeline, GST_FORMAT_TIME,
+ if (!gst_element_query_position (priv->pipeline, GST_FORMAT_TIME,
&position)) {
GST_INFO ("position query failed");
position = 0;
}
/* get the duration */
- if (!gst_element_query_duration (media->pipeline, GST_FORMAT_TIME,
+ if (!gst_element_query_duration (priv->pipeline, GST_FORMAT_TIME,
&duration)) {
GST_INFO ("duration query failed");
duration = -1;
GST_TIME_FORMAT, GST_TIME_ARGS (position), GST_TIME_ARGS (duration));
if (position == -1) {
- media->range.min.type = GST_RTSP_TIME_NOW;
- media->range.min.seconds = -1;
+ priv->range.min.type = GST_RTSP_TIME_NOW;
+ priv->range.min.seconds = -1;
+ priv->range_start = -1;
} else {
- media->range.min.type = GST_RTSP_TIME_SECONDS;
- media->range.min.seconds = ((gdouble) position) / GST_SECOND;
+ priv->range.min.type = GST_RTSP_TIME_SECONDS;
+ priv->range.min.seconds = ((gdouble) position) / GST_SECOND;
+ priv->range_start = position;
}
if (duration == -1) {
- media->range.max.type = GST_RTSP_TIME_END;
- media->range.max.seconds = -1;
+ priv->range.max.type = GST_RTSP_TIME_END;
+ priv->range.max.seconds = -1;
+ priv->range_stop = -1;
} else {
- media->range.max.type = GST_RTSP_TIME_SECONDS;
- media->range.max.seconds = ((gdouble) duration) / GST_SECOND;
+ priv->range.max.type = GST_RTSP_TIME_SECONDS;
+ priv->range.max.seconds = ((gdouble) duration) / GST_SECOND;
+ priv->range_stop = duration;
}
}
}
/**
* gst_rtsp_media_new:
+ * @element: (transfer full): a #GstElement
*
- * Create a new #GstRTSPMedia instance. The #GstRTSPMedia object contains the
+ * Create a new #GstRTSPMedia instance. @element is the bin element that
+ * provides the different streams. The #GstRTSPMedia object contains the
* element to produce RTP data for one or more related (audio/video/..)
* streams.
*
+ * Ownership is taken of @element.
+ *
* Returns: a new #GstRTSPMedia object.
*/
GstRTSPMedia *
-gst_rtsp_media_new (void)
+gst_rtsp_media_new (GstElement * element)
{
GstRTSPMedia *result;
- result = g_object_new (GST_TYPE_RTSP_MEDIA, NULL);
+ g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
+
+ result = g_object_new (GST_TYPE_RTSP_MEDIA, "element", element, NULL);
return result;
}
/**
+ * gst_rtsp_media_take_element:
+ * @media: a #GstRTSPMedia
+ * @pipeline: (transfer full): a #GstPipeline
+ *
+ * Set @pipeline as the #GstPipeline for @media. Ownership is
+ * taken of @pipeline.
+ */
+void
+gst_rtsp_media_take_pipeline (GstRTSPMedia * media, GstPipeline * pipeline)
+{
+ GstRTSPMediaPrivate *priv;
+ GstElement *old;
+ GstNetTimeProvider *nettime;
+
+ g_return_if_fail (GST_IS_RTSP_MEDIA (media));
+ g_return_if_fail (GST_IS_PIPELINE (pipeline));
+
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ old = priv->pipeline;
+ priv->pipeline = GST_ELEMENT_CAST (pipeline);
+ nettime = priv->nettime;
+ priv->nettime = NULL;
+ g_mutex_unlock (&priv->lock);
+
+ if (old)
+ gst_object_unref (old);
+
+ if (nettime)
+ gst_object_unref (nettime);
+
+ gst_bin_add (GST_BIN_CAST (pipeline), priv->element);
+}
+
+/**
* gst_rtsp_media_set_shared:
* @media: a #GstRTSPMedia
* @shared: the new value
void
gst_rtsp_media_set_shared (GstRTSPMedia * media, gboolean shared)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->shared = shared;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->shared = shared;
+ g_mutex_unlock (&priv->lock);
}
/**
gboolean
gst_rtsp_media_is_shared (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ gboolean res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
- return media->shared;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ res = priv->shared;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
void
gst_rtsp_media_set_reusable (GstRTSPMedia * media, gboolean reusable)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->reusable = reusable;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->reusable = reusable;
+ g_mutex_unlock (&priv->lock);
}
/**
gboolean
gst_rtsp_media_is_reusable (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ gboolean res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
- return media->reusable;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ res = priv->reusable;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
void
gst_rtsp_media_set_protocols (GstRTSPMedia * media, GstRTSPLowerTrans protocols)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->protocols = protocols;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->protocols = protocols;
+ g_mutex_unlock (&priv->lock);
}
/**
GstRTSPLowerTrans
gst_rtsp_media_get_protocols (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ GstRTSPLowerTrans res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media),
GST_RTSP_LOWER_TRANS_UNKNOWN);
- return media->protocols;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ res = priv->protocols;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
void
gst_rtsp_media_set_eos_shutdown (GstRTSPMedia * media, gboolean eos_shutdown)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->eos_shutdown = eos_shutdown;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->eos_shutdown = eos_shutdown;
+ g_mutex_unlock (&priv->lock);
}
/**
gboolean
gst_rtsp_media_is_eos_shutdown (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ gboolean res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
- return media->eos_shutdown;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ res = priv->eos_shutdown;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
void
gst_rtsp_media_set_buffer_size (GstRTSPMedia * media, guint size)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->buffer_size = size;
+ GST_LOG_OBJECT (media, "set buffer size %u", size);
+
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->buffer_size = size;
+ g_mutex_unlock (&priv->lock);
}
/**
guint
gst_rtsp_media_get_buffer_size (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ guint res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
- return media->buffer_size;
+ priv = media->priv;
+
+ g_mutex_unlock (&priv->lock);
+ res = priv->buffer_size;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
- * gst_rtsp_media_set_multicast_group:
+ * gst_rtsp_media_use_time_provider:
* @media: a #GstRTSPMedia
- * @mc: the new multicast group
*
- * Set the multicast group that media from @media will be streamed to.
+ * Set @media to provide a GstNetTimeProvider.
*/
void
-gst_rtsp_media_set_multicast_group (GstRTSPMedia * media, const gchar * mc)
+gst_rtsp_media_use_time_provider (GstRTSPMedia * media, gboolean time_provider)
{
+ GstRTSPMediaPrivate *priv;
+
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- g_mutex_lock (&media->lock);
- g_free (media->multicast_group);
- media->multicast_group = g_strdup (mc);
- g_mutex_unlock (&media->lock);
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->time_provider = time_provider;
+ g_mutex_unlock (&priv->lock);
}
/**
- * gst_rtsp_media_get_multicast_group:
+ * gst_rtsp_media_is_time_provider:
* @media: a #GstRTSPMedia
*
- * Get the multicast group that media from @media will be streamed to.
+ * Check if @media can provide a #GstNetTimeProvider for its pipeline clock.
*
- * Returns: the multicast group
+ * Use gst_rtsp_media_get_time_provider() to get the network clock.
+ *
+ * Returns: %TRUE if @media can provide a #GstNetTimeProvider.
*/
-gchar *
-gst_rtsp_media_get_multicast_group (GstRTSPMedia * media)
+gboolean
+gst_rtsp_media_is_time_provider (GstRTSPMedia * media)
{
- gchar *result;
+ GstRTSPMediaPrivate *priv;
+ gboolean res;
- g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
- g_mutex_lock (&media->lock);
- result = g_strdup (media->multicast_group);
- g_mutex_unlock (&media->lock);
+ priv = media->priv;
- return result;
+ g_mutex_unlock (&priv->lock);
+ res = priv->time_provider;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
void
gst_rtsp_media_set_auth (GstRTSPMedia * media, GstRTSPAuth * auth)
{
+ GstRTSPMediaPrivate *priv;
GstRTSPAuth *old;
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- old = media->auth;
+ priv = media->priv;
- if (old != auth) {
- if (auth)
- g_object_ref (auth);
- media->auth = auth;
- if (old)
- g_object_unref (old);
- }
+ GST_LOG_OBJECT (media, "set auth %p", auth);
+
+ g_mutex_lock (&priv->lock);
+ if ((old = priv->auth) != auth)
+ priv->auth = auth ? g_object_ref (auth) : NULL;
+ else
+ old = NULL;
+ g_mutex_unlock (&priv->lock);
+
+ if (old)
+ g_object_unref (old);
}
/**
GstRTSPAuth *
gst_rtsp_media_get_auth (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
GstRTSPAuth *result;
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
- if ((result = media->auth))
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ if ((result = priv->auth))
g_object_ref (result);
+ g_mutex_unlock (&priv->lock);
return result;
}
/**
- * gst_rtsp_media_set_mtu:
+ * gst_rtsp_media_set_address_pool:
* @media: a #GstRTSPMedia
- * @mtu: a new MTU
+ * @pool: a #GstRTSPAddressPool
*
- * Set maximum size of one RTP packet on the payloaders.
- * The @mtu will be set on all streams.
+ * configure @pool to be used as the address pool of @media.
*/
void
-gst_rtsp_media_set_mtu (GstRTSPMedia * media, guint mtu)
+gst_rtsp_media_set_address_pool (GstRTSPMedia * media,
+ GstRTSPAddressPool * pool)
{
- gint i;
+ GstRTSPMediaPrivate *priv;
+ GstRTSPAddressPool *old;
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- media->mtu = mtu;
- for (i = 0; i < media->streams->len; i++) {
- GstRTSPStream *stream;
+ priv = media->priv;
- GST_INFO ("Setting mtu %u for stream %d", mtu, i);
+ GST_LOG_OBJECT (media, "set address pool %p", pool);
- stream = g_ptr_array_index (media->streams, i);
- gst_rtsp_stream_set_mtu (stream, mtu);
- }
+ g_mutex_lock (&priv->lock);
+ if ((old = priv->pool) != pool)
+ priv->pool = pool ? g_object_ref (pool) : NULL;
+ else
+ old = NULL;
+ g_ptr_array_foreach (priv->streams, (GFunc) gst_rtsp_stream_set_address_pool,
+ pool);
+ g_mutex_unlock (&priv->lock);
+
+ if (old)
+ g_object_unref (old);
}
/**
- * gst_rtsp_media_get_mtu:
+ * gst_rtsp_media_get_address_pool:
* @media: a #GstRTSPMedia
*
- * Get the configured MTU.
+ * Get the #GstRTSPAddressPool used as the address pool of @media.
+ *
+ * Returns: (transfer full): the #GstRTSPAddressPool of @media. g_object_unref() after
+ * usage.
*/
-guint
-gst_rtsp_media_get_mtu (GstRTSPMedia * media)
+GstRTSPAddressPool *
+gst_rtsp_media_get_address_pool (GstRTSPMedia * media)
{
- g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
+ GstRTSPMediaPrivate *priv;
+ GstRTSPAddressPool *result;
+
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
+
+ priv = media->priv;
- return media->mtu;
+ g_mutex_lock (&priv->lock);
+ if ((result = priv->pool))
+ g_object_ref (result);
+ g_mutex_unlock (&priv->lock);
+
+ return result;
}
/**
void
gst_rtsp_media_collect_streams (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
GstElement *element, *elem;
GstPad *pad;
gint i;
g_return_if_fail (GST_IS_RTSP_MEDIA (media));
- element = media->element;
+ priv = media->priv;
+ element = priv->element;
have_elem = TRUE;
for (i = 0; have_elem; i++) {
pad = gst_element_get_static_pad (elem, "src");
/* create the stream */
gst_rtsp_media_create_stream (media, elem, pad);
- g_object_unref (pad);
-
+ gst_object_unref (pad);
gst_object_unref (elem);
have_elem = TRUE;
GST_INFO ("found dynamic element %d, %p", i, elem);
- media->dynamic = g_list_prepend (media->dynamic, elem);
+ g_mutex_lock (&priv->lock);
+ priv->dynamic = g_list_prepend (priv->dynamic, elem);
+ g_mutex_unlock (&priv->lock);
have_elem = TRUE;
}
* Create a new stream in @media that provides RTP data on @srcpad.
* @srcpad should be a pad of an element inside @media->element.
*
- * Returns: a new #GstRTSPStream that remains valid for as long
+ * Returns: (transfer none): a new #GstRTSPStream that remains valid for as long
* as @media exists.
*/
GstRTSPStream *
gst_rtsp_media_create_stream (GstRTSPMedia * media, GstElement * payloader,
GstPad * pad)
{
+ GstRTSPMediaPrivate *priv;
GstRTSPStream *stream;
GstPad *srcpad;
gchar *name;
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
g_return_val_if_fail (GST_PAD_IS_SRC (pad), NULL);
- idx = media->streams->len;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ idx = priv->streams->len;
+
+ GST_DEBUG ("media %p: creating stream with index %d", media, idx);
name = g_strdup_printf ("src_%u", idx);
srcpad = gst_ghost_pad_new (name, pad);
gst_pad_set_active (srcpad, TRUE);
- gst_element_add_pad (media->element, srcpad);
+ gst_element_add_pad (priv->element, srcpad);
g_free (name);
stream = gst_rtsp_stream_new (idx, payloader, srcpad);
- if (media->mtu)
- gst_rtsp_stream_set_mtu (stream, media->mtu);
+ if (priv->pool)
+ gst_rtsp_stream_set_address_pool (stream, priv->pool);
+
+ g_ptr_array_add (priv->streams, stream);
+ g_mutex_unlock (&priv->lock);
- g_ptr_array_add (media->streams, stream);
+ g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STREAM], 0, stream,
+ NULL);
return stream;
}
+static void
+gst_rtsp_media_remove_stream (GstRTSPMedia * media, GstRTSPStream * stream)
+{
+ GstRTSPMediaPrivate *priv;
+ GstPad *srcpad;
+
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ /* remove the ghostpad */
+ srcpad = gst_rtsp_stream_get_srcpad (stream);
+ gst_element_remove_pad (priv->element, srcpad);
+ gst_object_unref (srcpad);
+ /* now remove the stream */
+ g_object_ref (stream);
+ g_ptr_array_remove (priv->streams, stream);
+ g_mutex_unlock (&priv->lock);
+
+ g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_REMOVED_STREAM], 0,
+ stream, NULL);
+
+ g_object_unref (stream);
+}
+
/**
* gst_rtsp_media_n_streams:
* @media: a #GstRTSPMedia
guint
gst_rtsp_media_n_streams (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
+ guint res;
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
- return media->streams->len;
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ res = priv->streams->len;
+ g_mutex_unlock (&priv->lock);
+
+ return res;
}
/**
*
* Retrieve the stream with index @idx from @media.
*
- * Returns: the #GstRTSPStream at index @idx or %NULL when a stream with
+ * Returns: (transfer none): the #GstRTSPStream at index @idx or %NULL when a stream with
* that index did not exist.
*/
GstRTSPStream *
gst_rtsp_media_get_stream (GstRTSPMedia * media, guint idx)
{
+ GstRTSPMediaPrivate *priv;
GstRTSPStream *res;
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
- if (idx < media->streams->len)
- res = g_ptr_array_index (media->streams, idx);
+ priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ if (idx < priv->streams->len)
+ res = g_ptr_array_index (priv->streams, idx);
else
res = NULL;
+ g_mutex_unlock (&priv->lock);
return res;
}
* gst_rtsp_media_get_range_string:
* @media: a #GstRTSPMedia
* @play: for the PLAY request
+ * @unit: the unit to use for the string
*
- * Get the current range as a string.
+ * Get the current range as a string. @media must be prepared with
+ * gst_rtsp_media_prepare ().
*
* Returns: The range as a string, g_free() after usage.
*/
gchar *
-gst_rtsp_media_get_range_string (GstRTSPMedia * media, gboolean play)
+gst_rtsp_media_get_range_string (GstRTSPMedia * media, gboolean play,
+ GstRTSPRangeUnit unit)
{
+ GstRTSPMediaClass *klass;
+ GstRTSPMediaPrivate *priv;
gchar *result;
GstRTSPTimeRange range;
+ klass = GST_RTSP_MEDIA_GET_CLASS (media);
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
+ g_return_val_if_fail (klass->convert_range != NULL, FALSE);
+
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
+ goto not_prepared;
+
+ g_mutex_lock (&priv->lock);
/* make copy */
- range = media->range;
+ range = priv->range;
- if (!play && media->n_active > 0) {
+ if (!play && priv->n_active > 0) {
range.min.type = GST_RTSP_TIME_NOW;
range.min.seconds = -1;
}
+ g_mutex_unlock (&priv->lock);
+ g_rec_mutex_unlock (&priv->state_lock);
+
+ if (!klass->convert_range (media, &range, unit)) {
+ goto conversion_failed;
+ }
result = gst_rtsp_range_to_string (&range);
return result;
+
+ /* ERRORS */
+not_prepared:
+ {
+ GST_WARNING ("media %p was not prepared", media);
+ g_rec_mutex_unlock (&priv->state_lock);
+ return NULL;
+ }
+conversion_failed:
+ {
+ GST_WARNING ("range conversion to unit %d failed", unit);
+ g_rec_mutex_unlock (&priv->state_lock);
+ return NULL;
+ }
}
/**
* @media: a #GstRTSPMedia
* @range: a #GstRTSPTimeRange
*
- * Seek the pipeline to @range.
+ * Seek the pipeline of @media to @range. @media must be prepared with
+ * gst_rtsp_media_prepare().
*
* Returns: %TRUE on success.
*/
gboolean
gst_rtsp_media_seek (GstRTSPMedia * media, GstRTSPTimeRange * range)
{
+ GstRTSPMediaClass *klass;
+ GstRTSPMediaPrivate *priv;
GstSeekFlags flags;
gboolean res;
- gint64 start, stop;
+ GstClockTime start, stop;
GstSeekType start_type, stop_type;
+ klass = GST_RTSP_MEDIA_GET_CLASS (media);
+
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
g_return_val_if_fail (range != NULL, FALSE);
+ g_return_val_if_fail (klass->convert_range != NULL, FALSE);
- if (!media->seekable) {
- GST_INFO ("pipeline is not seekable");
- return TRUE;
- }
+ priv = media->priv;
- if (range->unit != GST_RTSP_RANGE_NPT)
- goto not_supported;
+ g_rec_mutex_lock (&priv->state_lock);
+ if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
+ goto not_prepared;
+
+ if (!priv->seekable)
+ goto not_seekable;
/* depends on the current playing state of the pipeline. We might need to
* queue this until we get EOS. */
start_type = stop_type = GST_SEEK_TYPE_NONE;
- switch (range->min.type) {
- case GST_RTSP_TIME_NOW:
- start = -1;
- break;
- case GST_RTSP_TIME_SECONDS:
- /* only seek when something changed */
- if (media->range.min.seconds == range->min.seconds) {
- start = -1;
- } else {
- start = range->min.seconds * GST_SECOND;
- start_type = GST_SEEK_TYPE_SET;
- }
- break;
- case GST_RTSP_TIME_END:
- default:
- goto weird_type;
- }
- switch (range->max.type) {
- case GST_RTSP_TIME_SECONDS:
- /* only seek when something changed */
- if (media->range.max.seconds == range->max.seconds) {
- stop = -1;
- } else {
- stop = range->max.seconds * GST_SECOND;
- stop_type = GST_SEEK_TYPE_SET;
- }
- break;
- case GST_RTSP_TIME_END:
- stop = -1;
- stop_type = GST_SEEK_TYPE_SET;
- break;
- case GST_RTSP_TIME_NOW:
- default:
- goto weird_type;
- }
+ if (!klass->convert_range (media, range, GST_RTSP_RANGE_NPT))
+ goto not_supported;
+ gst_rtsp_range_get_times (range, &start, &stop);
+
+ GST_INFO ("got %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
+ GST_INFO ("current %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (priv->range_start), GST_TIME_ARGS (priv->range_stop));
- if (start != -1 || stop != -1) {
+ if (priv->range_start == start)
+ start = GST_CLOCK_TIME_NONE;
+ else if (start != GST_CLOCK_TIME_NONE)
+ start_type = GST_SEEK_TYPE_SET;
+
+ if (priv->range_stop == stop)
+ stop = GST_CLOCK_TIME_NONE;
+ else if (stop != GST_CLOCK_TIME_NONE)
+ stop_type = GST_SEEK_TYPE_SET;
+
+ if (start != GST_CLOCK_TIME_NONE || stop != GST_CLOCK_TIME_NONE) {
GST_INFO ("seeking to %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
- res = gst_element_seek (media->pipeline, 1.0, GST_FORMAT_TIME,
+ res = gst_element_seek (priv->pipeline, 1.0, GST_FORMAT_TIME,
flags, start_type, start, stop_type, stop);
/* and block for the seek to complete */
GST_INFO ("done seeking %d", res);
- gst_element_get_state (media->pipeline, NULL, NULL, -1);
+ gst_element_get_state (priv->pipeline, NULL, NULL, -1);
GST_INFO ("prerolled again");
collect_media_stats (media);
GST_INFO ("no seek needed");
res = TRUE;
}
+ g_rec_mutex_unlock (&priv->state_lock);
return res;
/* ERRORS */
-not_supported:
+not_prepared:
{
- GST_WARNING ("seek unit %d not supported", range->unit);
+ g_rec_mutex_unlock (&priv->state_lock);
+ GST_INFO ("media %p is not prepared", media);
return FALSE;
}
-weird_type:
+not_seekable:
{
- GST_WARNING ("weird range type %d not supported", range->min.type);
- return FALSE;
+ g_rec_mutex_unlock (&priv->state_lock);
+ GST_INFO ("pipeline is not seekable");
+ return TRUE;
}
-}
-
-static void
-unlock_streams (GstRTSPMedia * media)
-{
- guint i;
-
- /* unlock the udp src elements */
- for (i = 0; i < media->streams->len; i++) {
- GstRTSPStream *stream;
-
- stream = g_ptr_array_index (media->streams, i);
-
- gst_element_set_locked_state (stream->udpsrc[0], FALSE);
- gst_element_set_locked_state (stream->udpsrc[1], FALSE);
+not_supported:
+ {
+ g_rec_mutex_unlock (&priv->state_lock);
+ GST_WARNING ("conversion to npt not supported");
+ return FALSE;
}
}
static void
gst_rtsp_media_set_status (GstRTSPMedia * media, GstRTSPMediaStatus status)
{
- g_mutex_lock (&media->lock);
- /* never overwrite the error status */
- if (media->status != GST_RTSP_MEDIA_STATUS_ERROR)
- media->status = status;
+ GstRTSPMediaPrivate *priv = media->priv;
+
+ g_mutex_lock (&priv->lock);
+ priv->status = status;
GST_DEBUG ("setting new status to %d", status);
- g_cond_broadcast (&media->cond);
- g_mutex_unlock (&media->lock);
+ g_cond_broadcast (&priv->cond);
+ g_mutex_unlock (&priv->lock);
}
-static GstRTSPMediaStatus
+/**
+ * gst_rtsp_media_get_status:
+ * @media: a #GstRTSPMedia
+ *
+ * Get the status of @media. When @media is busy preparing, this function waits
+ * until @media is prepared or in error.
+ *
+ * Returns: the status of @media.
+ */
+GstRTSPMediaStatus
gst_rtsp_media_get_status (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv = media->priv;
GstRTSPMediaStatus result;
gint64 end_time;
- g_mutex_lock (&media->lock);
+ g_mutex_lock (&priv->lock);
end_time = g_get_monotonic_time () + 20 * G_TIME_SPAN_SECOND;
/* while we are preparing, wait */
- while (media->status == GST_RTSP_MEDIA_STATUS_PREPARING) {
+ while (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING) {
GST_DEBUG ("waiting for status change");
- if (!g_cond_wait_until (&media->cond, &media->lock, end_time)) {
+ if (!g_cond_wait_until (&priv->cond, &priv->lock, end_time)) {
GST_DEBUG ("timeout, assuming error status");
- media->status = GST_RTSP_MEDIA_STATUS_ERROR;
+ priv->status = GST_RTSP_MEDIA_STATUS_ERROR;
}
}
/* could be success or error */
- result = media->status;
+ result = priv->status;
GST_DEBUG ("got status %d", result);
- g_mutex_unlock (&media->lock);
+ g_mutex_unlock (&priv->lock);
return result;
}
+/* called with state-lock */
static gboolean
default_handle_message (GstRTSPMedia * media, GstMessage * message)
{
+ GstRTSPMediaPrivate *priv = media->priv;
GstMessageType type;
type = GST_MESSAGE_TYPE (message);
gst_message_parse_buffering (message, &percent);
/* no state management needed for live pipelines */
- if (media->is_live)
+ if (priv->is_live)
break;
if (percent == 100) {
/* a 100% message means buffering is done */
- media->buffering = FALSE;
+ priv->buffering = FALSE;
/* if the desired state is playing, go back */
- if (media->target_state == GST_STATE_PLAYING) {
+ if (priv->target_state == GST_STATE_PLAYING) {
GST_INFO ("Buffering done, setting pipeline to PLAYING");
- gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
+ gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
} else {
GST_INFO ("Buffering done");
}
} else {
/* buffering busy */
- if (media->buffering == FALSE) {
- if (media->target_state == GST_STATE_PLAYING) {
+ if (priv->buffering == FALSE) {
+ if (priv->target_state == GST_STATE_PLAYING) {
/* we were not buffering but PLAYING, PAUSE the pipeline. */
GST_INFO ("Buffering, setting pipeline to PAUSED ...");
- gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
+ gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
} else {
GST_INFO ("Buffering ...");
}
}
- media->buffering = TRUE;
+ priv->buffering = TRUE;
}
break;
}
case GST_MESSAGE_LATENCY:
{
- gst_bin_recalculate_latency (GST_BIN_CAST (media->pipeline));
+ gst_bin_recalculate_latency (GST_BIN_CAST (priv->pipeline));
break;
}
case GST_MESSAGE_ERROR:
case GST_MESSAGE_STREAM_STATUS:
break;
case GST_MESSAGE_ASYNC_DONE:
- if (!media->adding) {
+ if (priv->adding) {
/* when we are dynamically adding pads, the addition of the udpsrc will
* temporarily produce ASYNC_DONE messages. We have to ignore them and
* wait for the final ASYNC_DONE after everything prerolled */
+ GST_INFO ("%p: ignoring ASYNC_DONE", media);
+ } else {
GST_INFO ("%p: got ASYNC_DONE", media);
collect_media_stats (media);
- gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
- } else {
- GST_INFO ("%p: ignoring ASYNC_DONE", media);
+ if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING)
+ gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
}
break;
case GST_MESSAGE_EOS:
GST_INFO ("%p: got EOS", media);
- if (media->status == GST_RTSP_MEDIA_STATUS_UNPREPARING) {
+
+ if (priv->status == GST_RTSP_MEDIA_STATUS_UNPREPARING) {
GST_DEBUG ("shutting down after EOS");
finish_unprepare (media);
- g_object_unref (media);
}
break;
default:
- GST_INFO ("%p: got message type %s", media,
+ GST_INFO ("%p: got message type %d (%s)", media, type,
gst_message_type_get_name (type));
break;
}
static gboolean
bus_message (GstBus * bus, GstMessage * message, GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv = media->priv;
GstRTSPMediaClass *klass;
gboolean ret;
klass = GST_RTSP_MEDIA_GET_CLASS (media);
+ g_rec_mutex_lock (&priv->state_lock);
if (klass->handle_message)
ret = klass->handle_message (media, message);
else
ret = FALSE;
+ g_rec_mutex_unlock (&priv->state_lock);
return ret;
}
+static void
+watch_destroyed (GstRTSPMedia * media)
+{
+ GST_DEBUG_OBJECT (media, "source destroyed");
+ g_object_unref (media);
+}
+
/* called from streaming threads */
static void
pad_added_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv = media->priv;
GstRTSPStream *stream;
- gint i;
+ /* FIXME, element is likely not a payloader, find the payloader here */
stream = gst_rtsp_media_create_stream (media, element, pad);
- GST_INFO ("pad added %s:%s, stream %d", GST_DEBUG_PAD_NAME (pad),
- stream->idx);
- media->adding = TRUE;
+ g_object_set_data (G_OBJECT (pad), "gst-rtsp-dynpad-stream", stream);
- gst_rtsp_stream_join_bin (stream, GST_BIN (media->pipeline), media->rtpbin);
+ GST_INFO ("pad added %s:%s, stream %p", GST_DEBUG_PAD_NAME (pad), stream);
- for (i = 0; i < 2; i++) {
- gst_element_set_state (stream->udpsink[i], GST_STATE_PAUSED);
- gst_element_set_state (stream->appsink[i], GST_STATE_PAUSED);
- gst_element_set_state (stream->appqueue[i], GST_STATE_PAUSED);
- gst_element_set_state (stream->tee[i], GST_STATE_PAUSED);
- gst_element_set_state (stream->selector[i], GST_STATE_PAUSED);
- gst_element_set_state (stream->appsrc[i], GST_STATE_PAUSED);
- }
+ g_rec_mutex_lock (&priv->state_lock);
+ /* we will be adding elements below that will cause ASYNC_DONE to be
+ * posted in the bus. We want to ignore those messages until the
+ * pipeline really prerolled. */
+ priv->adding = TRUE;
+
+ /* join the element in the PAUSED state because this callback is
+ * called from the streaming thread and it is PAUSED */
+ gst_rtsp_stream_join_bin (stream, GST_BIN (priv->pipeline),
+ priv->rtpbin, GST_STATE_PAUSED);
- media->adding = FALSE;
+ priv->adding = FALSE;
+ g_rec_mutex_unlock (&priv->state_lock);
}
static void
-no_more_pads_cb (GstElement * element, GstRTSPMedia * media)
+pad_removed_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
{
- GST_INFO ("no more pads");
- if (media->fakesink) {
- gst_object_ref (media->fakesink);
- gst_bin_remove (GST_BIN (media->pipeline), media->fakesink);
- gst_element_set_state (media->fakesink, GST_STATE_NULL);
- gst_object_unref (media->fakesink);
- media->fakesink = NULL;
+ GstRTSPMediaPrivate *priv = media->priv;
+ GstRTSPStream *stream;
+
+ stream = g_object_get_data (G_OBJECT (pad), "gst-rtsp-dynpad-stream");
+ if (stream == NULL)
+ return;
+
+ GST_INFO ("pad removed %s:%s, stream %p", GST_DEBUG_PAD_NAME (pad), stream);
+
+ g_rec_mutex_lock (&priv->state_lock);
+ gst_rtsp_stream_leave_bin (stream, GST_BIN (priv->pipeline), priv->rtpbin);
+ g_rec_mutex_unlock (&priv->state_lock);
+
+ gst_rtsp_media_remove_stream (media, stream);
+}
+
+static void
+remove_fakesink (GstRTSPMediaPrivate * priv)
+{
+ GstElement *fakesink;
+
+ g_mutex_lock (&priv->lock);
+ if ((fakesink = priv->fakesink))
+ gst_object_ref (fakesink);
+ priv->fakesink = NULL;
+ g_mutex_unlock (&priv->lock);
+
+ if (fakesink) {
+ gst_bin_remove (GST_BIN (priv->pipeline), fakesink);
+ gst_element_set_state (fakesink, GST_STATE_NULL);
+ gst_object_unref (fakesink);
GST_INFO ("removed fakesink");
}
}
+static void
+no_more_pads_cb (GstElement * element, GstRTSPMedia * media)
+{
+ GstRTSPMediaPrivate *priv = media->priv;
+
+ GST_INFO ("no more pads");
+ remove_fakesink (priv);
+}
+
+typedef struct _DynPaySignalHandlers DynPaySignalHandlers;
+
+struct _DynPaySignalHandlers
+{
+ gulong pad_added_handler;
+ gulong pad_removed_handler;
+ gulong no_more_pads_handler;
+};
+
/**
* gst_rtsp_media_prepare:
* @media: a #GstRTSPMedia
*
- * Prepare @media for streaming. This function will create the pipeline and
- * other objects to manage the streaming.
+ * Prepare @media for streaming. This function will create the objects
+ * to manage the streaming. A pipeline must have been set on @media with
+ * gst_rtsp_media_take_pipeline().
*
* It will preroll the pipeline and collect vital information about the streams
* such as the duration.
gboolean
gst_rtsp_media_prepare (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
GstStateChangeReturn ret;
GstRTSPMediaStatus status;
guint i;
GstBus *bus;
GList *walk;
- if (media->status == GST_RTSP_MEDIA_STATUS_PREPARED)
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
+
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ priv->prepare_count++;
+
+ if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARED)
goto was_prepared;
- if (!media->reusable && media->reused)
+ if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING)
+ goto wait_status;
+
+ if (priv->status != GST_RTSP_MEDIA_STATUS_UNPREPARED)
+ goto not_unprepared;
+
+ if (!priv->reusable && priv->reused)
goto is_reused;
- media->rtpbin = gst_element_factory_make ("rtpbin", NULL);
- if (media->rtpbin == NULL)
+ priv->rtpbin = gst_element_factory_make ("rtpbin", NULL);
+ if (priv->rtpbin == NULL)
goto no_rtpbin;
GST_INFO ("preparing media %p", media);
/* reset some variables */
- media->is_live = FALSE;
- media->seekable = FALSE;
- media->buffering = FALSE;
+ priv->is_live = FALSE;
+ priv->seekable = FALSE;
+ priv->buffering = FALSE;
/* we're preparing now */
- media->status = GST_RTSP_MEDIA_STATUS_PREPARING;
+ priv->status = GST_RTSP_MEDIA_STATUS_PREPARING;
- bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (media->pipeline));
+ bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (priv->pipeline));
/* add the pipeline bus to our custom mainloop */
- media->source = gst_bus_create_watch (bus);
+ priv->source = gst_bus_create_watch (bus);
gst_object_unref (bus);
- g_source_set_callback (media->source, (GSourceFunc) bus_message, media, NULL);
+ g_source_set_callback (priv->source, (GSourceFunc) bus_message,
+ g_object_ref (media), (GDestroyNotify) watch_destroyed);
klass = GST_RTSP_MEDIA_GET_CLASS (media);
- media->id = g_source_attach (media->source, klass->context);
+ priv->id = g_source_attach (priv->source, klass->context);
/* add stuff to the bin */
- gst_bin_add (GST_BIN (media->pipeline), media->rtpbin);
+ gst_bin_add (GST_BIN (priv->pipeline), priv->rtpbin);
/* link streams we already have, other streams might appear when we have
* dynamic elements */
- for (i = 0; i < media->streams->len; i++) {
+ for (i = 0; i < priv->streams->len; i++) {
GstRTSPStream *stream;
- stream = g_ptr_array_index (media->streams, i);
+ stream = g_ptr_array_index (priv->streams, i);
- gst_rtsp_stream_join_bin (stream, GST_BIN (media->pipeline), media->rtpbin);
+ gst_rtsp_stream_join_bin (stream, GST_BIN (priv->pipeline),
+ priv->rtpbin, GST_STATE_NULL);
}
- for (walk = media->dynamic; walk; walk = g_list_next (walk)) {
+ for (walk = priv->dynamic; walk; walk = g_list_next (walk)) {
GstElement *elem = walk->data;
+ DynPaySignalHandlers *handlers = g_slice_new (DynPaySignalHandlers);
GST_INFO ("adding callbacks for dynamic element %p", elem);
- g_signal_connect (elem, "pad-added", (GCallback) pad_added_cb, media);
- g_signal_connect (elem, "no-more-pads", (GCallback) no_more_pads_cb, media);
+ handlers->pad_added_handler = g_signal_connect (elem, "pad-added",
+ (GCallback) pad_added_cb, media);
+ handlers->pad_removed_handler = g_signal_connect (elem, "pad-removed",
+ (GCallback) pad_removed_cb, media);
+ handlers->no_more_pads_handler = g_signal_connect (elem, "no-more-pads",
+ (GCallback) no_more_pads_cb, media);
+
+ g_object_set_data (G_OBJECT (elem), "gst-rtsp-dynpay-handlers", handlers);
/* we add a fakesink here in order to make the state change async. We remove
* the fakesink again in the no-more-pads callback. */
- media->fakesink = gst_element_factory_make ("fakesink", "fakesink");
- gst_bin_add (GST_BIN (media->pipeline), media->fakesink);
+ priv->fakesink = gst_element_factory_make ("fakesink", "fakesink");
+ gst_bin_add (GST_BIN (priv->pipeline), priv->fakesink);
}
GST_INFO ("setting pipeline to PAUSED for media %p", media);
/* first go to PAUSED */
- ret = gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
- media->target_state = GST_STATE_PAUSED;
+ ret = gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
+ priv->target_state = GST_STATE_PAUSED;
switch (ret) {
case GST_STATE_CHANGE_SUCCESS:
GST_INFO ("SUCCESS state change for media %p", media);
- media->seekable = TRUE;
+ priv->seekable = TRUE;
break;
case GST_STATE_CHANGE_ASYNC:
GST_INFO ("ASYNC state change for media %p", media);
- media->seekable = TRUE;
+ priv->seekable = TRUE;
break;
case GST_STATE_CHANGE_NO_PREROLL:
/* we need to go to PLAYING */
GST_INFO ("NO_PREROLL state change: live media %p", media);
/* FIXME we disable seeking for live streams for now. We should perform a
- * seeking query in preroll instead and do a seeking query. */
- media->seekable = FALSE;
- media->is_live = TRUE;
- ret = gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
+ * seeking query in preroll instead */
+ priv->seekable = FALSE;
+ priv->is_live = TRUE;
+ ret = gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
goto state_failed;
break;
case GST_STATE_CHANGE_FAILURE:
goto state_failed;
}
+wait_status:
+ g_rec_mutex_unlock (&priv->state_lock);
- /* now wait for all pads to be prerolled */
+ /* now wait for all pads to be prerolled, FIXME, we should somehow be
+ * able to do this async so that we don't block the server thread. */
status = gst_rtsp_media_get_status (media);
if (status == GST_RTSP_MEDIA_STATUS_ERROR)
goto state_failed;
/* OK */
was_prepared:
{
+ GST_LOG ("media %p was prepared", media);
+ g_rec_mutex_unlock (&priv->state_lock);
return TRUE;
}
/* ERRORS */
+not_unprepared:
+ {
+ GST_WARNING ("media %p was not unprepared", media);
+ priv->prepare_count--;
+ g_rec_mutex_unlock (&priv->state_lock);
+ return FALSE;
+ }
is_reused:
{
+ priv->prepare_count--;
+ g_rec_mutex_unlock (&priv->state_lock);
GST_WARNING ("can not reuse media %p", media);
return FALSE;
}
no_rtpbin:
{
+ priv->prepare_count--;
+ g_rec_mutex_unlock (&priv->state_lock);
GST_WARNING ("no rtpbin element");
g_warning ("failed to create element 'rtpbin', check your installation");
return FALSE;
{
GST_WARNING ("failed to preroll pipeline");
gst_rtsp_media_unprepare (media);
+ g_rec_mutex_unlock (&priv->state_lock);
return FALSE;
}
}
+/* must be called with state-lock */
+static void
+finish_unprepare (GstRTSPMedia * media)
+{
+ GstRTSPMediaPrivate *priv = media->priv;
+ gint i;
+ GList *walk;
+
+ GST_DEBUG ("shutting down");
+
+ gst_element_set_state (priv->pipeline, GST_STATE_NULL);
+ remove_fakesink (priv);
+
+ for (i = 0; i < priv->streams->len; i++) {
+ GstRTSPStream *stream;
+
+ GST_INFO ("Removing elements of stream %d from pipeline", i);
+
+ stream = g_ptr_array_index (priv->streams, i);
+
+ gst_rtsp_stream_leave_bin (stream, GST_BIN (priv->pipeline), priv->rtpbin);
+ }
+
+ /* remove the pad signal handlers */
+ for (walk = priv->dynamic; walk; walk = g_list_next (walk)) {
+ GstElement *elem = walk->data;
+ DynPaySignalHandlers *handlers;
+
+ handlers =
+ g_object_steal_data (G_OBJECT (elem), "gst-rtsp-dynpay-handlers");
+ g_assert (handlers != NULL);
+
+ g_signal_handler_disconnect (G_OBJECT (elem), handlers->pad_added_handler);
+ g_signal_handler_disconnect (G_OBJECT (elem),
+ handlers->pad_removed_handler);
+ g_signal_handler_disconnect (G_OBJECT (elem),
+ handlers->no_more_pads_handler);
+
+ g_slice_free (DynPaySignalHandlers, handlers);
+ }
+
+ gst_bin_remove (GST_BIN (priv->pipeline), priv->rtpbin);
+ priv->rtpbin = NULL;
+
+ if (priv->nettime)
+ gst_object_unref (priv->nettime);
+ priv->nettime = NULL;
+
+ priv->reused = TRUE;
+ priv->status = GST_RTSP_MEDIA_STATUS_UNPREPARED;
+
+ /* when the media is not reusable, this will effectively unref the media and
+ * recreate it */
+ g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_UNPREPARED], 0, NULL);
+
+ /* the source has the last ref to the media */
+ if (priv->source) {
+ GST_DEBUG ("destroy source");
+ g_source_destroy (priv->source);
+ g_source_unref (priv->source);
+ }
+}
+
+/* called with state-lock */
+static gboolean
+default_unprepare (GstRTSPMedia * media)
+{
+ GstRTSPMediaPrivate *priv = media->priv;
+
+ if (priv->eos_shutdown) {
+ GST_DEBUG ("sending EOS for shutdown");
+ /* ref so that we don't disappear */
+ gst_element_send_event (priv->pipeline, gst_event_new_eos ());
+ /* we need to go to playing again for the EOS to propagate, normally in this
+ * state, nothing is receiving data from us anymore so this is ok. */
+ gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
+ priv->status = GST_RTSP_MEDIA_STATUS_UNPREPARING;
+ } else {
+ finish_unprepare (media);
+ }
+ return TRUE;
+}
+
/**
* gst_rtsp_media_unprepare:
* @media: a #GstRTSPMedia
gboolean
gst_rtsp_media_unprepare (GstRTSPMedia * media)
{
+ GstRTSPMediaPrivate *priv;
gboolean success;
- if (media->status == GST_RTSP_MEDIA_STATUS_UNPREPARED)
- return TRUE;
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
+
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ if (priv->status == GST_RTSP_MEDIA_STATUS_UNPREPARED)
+ goto was_unprepared;
+
+ priv->prepare_count--;
+ if (priv->prepare_count > 0)
+ goto is_busy;
GST_INFO ("unprepare media %p", media);
- media->target_state = GST_STATE_NULL;
+ priv->target_state = GST_STATE_NULL;
success = TRUE;
- if (media->status == GST_RTSP_MEDIA_STATUS_PREPARED) {
+ if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARED) {
GstRTSPMediaClass *klass;
klass = GST_RTSP_MEDIA_GET_CLASS (media);
} else {
finish_unprepare (media);
}
+ g_rec_mutex_unlock (&priv->state_lock);
- media->reused = TRUE;
+ return success;
- /* when the media is not reusable, this will effectively unref the media and
- * recreate it */
- g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_UNPREPARED], 0, NULL);
+was_unprepared:
+ {
+ g_rec_mutex_unlock (&priv->state_lock);
+ GST_INFO ("media %p was already unprepared", media);
+ return TRUE;
+ }
+is_busy:
+ {
+ GST_INFO ("media %p still prepared %d times", media, priv->prepare_count);
+ g_rec_mutex_unlock (&priv->state_lock);
+ return TRUE;
+ }
+}
- return success;
+/* should be called with state-lock */
+static GstClock *
+get_clock_unlocked (GstRTSPMedia * media)
+{
+ if (media->priv->status != GST_RTSP_MEDIA_STATUS_PREPARED) {
+ GST_DEBUG_OBJECT (media, "media was not prepared");
+ return NULL;
+ }
+ return gst_pipeline_get_clock (GST_PIPELINE_CAST (media->priv->pipeline));
}
-static void
-finish_unprepare (GstRTSPMedia * media)
+/**
+ * gst_rtsp_media_get_clock:
+ * @media: a #GstRTSPMedia
+ *
+ * Get the clock that is used by the pipeline in @media.
+ *
+ * @media must be prepared before this method returns a valid clock object.
+ *
+ * Returns: the #GstClock used by @media. unref after usage.
+ */
+GstClock *
+gst_rtsp_media_get_clock (GstRTSPMedia * media)
{
- gint i;
+ GstClock *clock;
+ GstRTSPMediaPrivate *priv;
- GST_DEBUG ("shutting down");
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
- unlock_streams (media);
- gst_element_set_state (media->pipeline, GST_STATE_NULL);
+ priv = media->priv;
- for (i = 0; i < media->streams->len; i++) {
- GstRTSPStream *stream;
+ g_rec_mutex_lock (&priv->state_lock);
+ clock = get_clock_unlocked (media);
+ g_rec_mutex_unlock (&priv->state_lock);
- GST_INFO ("Removing elements of stream %d from pipeline", i);
+ return clock;
+}
- stream = g_ptr_array_index (media->streams, i);
+/**
+ * gst_rtsp_media_get_base_time:
+ * @media: a #GstRTSPMedia
+ *
+ * Get the base_time that is used by the pipeline in @media.
+ *
+ * @media must be prepared before this method returns a valid base_time.
+ *
+ * Returns: the base_time used by @media.
+ */
+GstClockTime
+gst_rtsp_media_get_base_time (GstRTSPMedia * media)
+{
+ GstClockTime result;
+ GstRTSPMediaPrivate *priv;
- gst_rtsp_stream_leave_bin (stream, GST_BIN (media->pipeline),
- media->rtpbin);
- }
- g_ptr_array_set_size (media->streams, 0);
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), GST_CLOCK_TIME_NONE);
+
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ if (media->priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
+ goto not_prepared;
- gst_bin_remove (GST_BIN (media->pipeline), media->rtpbin);
+ result = gst_element_get_base_time (media->priv->pipeline);
+ g_rec_mutex_unlock (&priv->state_lock);
- gst_object_unref (media->pipeline);
- media->pipeline = NULL;
+ return result;
- media->status = GST_RTSP_MEDIA_STATUS_UNPREPARED;
+ /* ERRORS */
+not_prepared:
+ {
+ g_rec_mutex_unlock (&priv->state_lock);
+ GST_DEBUG_OBJECT (media, "media was not prepared");
+ return GST_CLOCK_TIME_NONE;
+ }
}
-static gboolean
-default_unprepare (GstRTSPMedia * media)
+/**
+ * gst_rtsp_media_get_time_provider:
+ * @media: a #GstRTSPMedia
+ * @address: an address or NULL
+ * @port: a port or 0
+ *
+ * Get the #GstNetTimeProvider for the clock used by @media. The time provider
+ * will listen on @address and @port for client time requests.
+ *
+ * Returns: the #GstNetTimeProvider of @media.
+ */
+GstNetTimeProvider *
+gst_rtsp_media_get_time_provider (GstRTSPMedia * media, const gchar * address,
+ guint16 port)
{
- if (media->eos_shutdown) {
- GST_DEBUG ("sending EOS for shutdown");
- /* ref so that we don't disappear */
- g_object_ref (media);
- gst_element_send_event (media->pipeline, gst_event_new_eos ());
- /* we need to go to playing again for the EOS to propagate, normally in this
- * state, nothing is receiving data from us anymore so this is ok. */
- gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
- media->status = GST_RTSP_MEDIA_STATUS_UNPREPARING;
- } else {
- finish_unprepare (media);
+ GstRTSPMediaPrivate *priv;
+ GstNetTimeProvider *provider = NULL;
+
+ g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
+
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ if (priv->time_provider) {
+ if ((provider = priv->nettime) == NULL) {
+ GstClock *clock;
+
+ if (priv->time_provider && (clock = get_clock_unlocked (media))) {
+ provider = gst_net_time_provider_new (clock, address, port);
+ gst_object_unref (clock);
+
+ priv->nettime = provider;
+ }
+ }
}
- return TRUE;
+ g_rec_mutex_unlock (&priv->state_lock);
+
+ if (provider)
+ gst_object_ref (provider);
+
+ return provider;
}
/**
*
* Set the state of @media to @state and for the transports in @transports.
*
+ * @media must be prepared with gst_rtsp_media_prepare();
+ *
* Returns: %TRUE on success.
*/
gboolean
gst_rtsp_media_set_state (GstRTSPMedia * media, GstState state,
GPtrArray * transports)
{
+ GstRTSPMediaPrivate *priv;
gint i;
- gboolean add, remove, do_state;
+ gboolean activate, deactivate, do_state;
gint old_active;
g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
g_return_val_if_fail (transports != NULL, FALSE);
+ priv = media->priv;
+
+ g_rec_mutex_lock (&priv->state_lock);
+ if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
+ goto not_prepared;
+
/* NULL and READY are the same */
if (state == GST_STATE_READY)
state = GST_STATE_NULL;
- add = remove = FALSE;
+ activate = deactivate = FALSE;
GST_INFO ("going to state %s media %p", gst_element_state_get_name (state),
media);
switch (state) {
case GST_STATE_NULL:
- /* unlock the streams so that they follow the state changes from now on */
- unlock_streams (media);
- /* fallthrough */
case GST_STATE_PAUSED:
- /* we're going from PLAYING to PAUSED, READY or NULL, remove */
- if (media->target_state == GST_STATE_PLAYING)
- remove = TRUE;
+ /* we're going from PLAYING to PAUSED, READY or NULL, deactivate */
+ if (priv->target_state == GST_STATE_PLAYING)
+ deactivate = TRUE;
break;
case GST_STATE_PLAYING:
- /* we're going to PLAYING, add */
- add = TRUE;
+ /* we're going to PLAYING, activate */
+ activate = TRUE;
break;
default:
break;
}
- old_active = media->n_active;
+ old_active = priv->n_active;
for (i = 0; i < transports->len; i++) {
GstRTSPStreamTransport *trans;
if (trans == NULL)
continue;
- /* we need a transport */
- if (!trans->transport)
- continue;
-
- if (add) {
- if (gst_rtsp_stream_add_transport (trans->stream, trans))
- media->n_active++;
- } else if (remove) {
- if (gst_rtsp_stream_remove_transport (trans->stream, trans))
- media->n_active--;
+ if (activate) {
+ if (gst_rtsp_stream_transport_set_active (trans, TRUE))
+ priv->n_active++;
+ } else if (deactivate) {
+ if (gst_rtsp_stream_transport_set_active (trans, FALSE))
+ priv->n_active--;
}
}
- /* we just added the first media, do the playing state change */
- if (old_active == 0 && add)
+ /* we just activated the first media, do the playing state change */
+ if (old_active == 0 && activate)
do_state = TRUE;
/* if we have no more active media, do the downward state changes */
- else if (media->n_active == 0)
+ else if (priv->n_active == 0)
do_state = TRUE;
else
do_state = FALSE;
- GST_INFO ("state %d active %d media %p do_state %d", state, media->n_active,
+ GST_INFO ("state %d active %d media %p do_state %d", state, priv->n_active,
media, do_state);
- if (media->target_state != state) {
+ if (priv->target_state != state) {
if (do_state) {
if (state == GST_STATE_NULL) {
gst_rtsp_media_unprepare (media);
} else {
GST_INFO ("state %s media %p", gst_element_state_get_name (state),
media);
- media->target_state = state;
- gst_element_set_state (media->pipeline, state);
+ priv->target_state = state;
+ /* when we are buffering, don't update the state yet, this will be done
+ * when buffering finishes */
+ if (priv->buffering) {
+ GST_INFO ("Buffering busy, delay state change");
+ } else {
+ gst_element_set_state (priv->pipeline, state);
+ }
}
}
g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STATE], 0, state,
/* remember where we are */
if (state != GST_STATE_NULL && (state == GST_STATE_PAUSED ||
- old_active != media->n_active))
+ old_active != priv->n_active))
collect_media_stats (media);
+ g_rec_mutex_unlock (&priv->state_lock);
+
return TRUE;
+
+ /* ERRORS */
+not_prepared:
+ {
+ GST_WARNING ("media %p was not prepared", media);
+ g_rec_mutex_unlock (&priv->state_lock);
+ return FALSE;
+ }
+}
+
+/* called with state-lock */
+static gboolean
+default_convert_range (GstRTSPMedia * media, GstRTSPTimeRange * range,
+ GstRTSPRangeUnit unit)
+{
+ return gst_rtsp_range_convert_units (range, unit);
}
projects / platform / upstream / gstreamer.git / blobdiff