gst/rtsp-server/rtsp-media.c

   1 /* GStreamer
   2  * Copyright (C) 2008 Wim Taymans <wim.taymans at gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19 /**
  20  * SECTION:rtsp-media
  21  * @short_description: The media pipeline
  22  * @see_also: #GstRTSPMediaFactory, #GstRTSPStream, #GstRTSPSession,
  23  *     #GstRTSPSessionMedia
  24  *
  25  * a #GstRTSPMedia contains the complete GStreamer pipeline to manage the
  26  * streaming to the clients. The actual data transfer is done by the
  27  * #GstRTSPStream objects that are created and exposed by the #GstRTSPMedia.
  28  *
  29  * The #GstRTSPMedia is usually created from a #GstRTSPMediaFactory when the
  30  * client does a DESCRIBE or SETUP of a resource.
  31  *
  32  * A media is created with gst_rtsp_media_new() that takes the element that will
  33  * provide the streaming elements. For each of the streams, a new #GstRTSPStream
  34  * object needs to be made with the gst_rtsp_media_create_stream() which takes
  35  * the payloader element and the source pad that produces the RTP stream.
  36  *
  37  * The pipeline of the media is set to PAUSED with gst_rtsp_media_prepare(). The
  38  * prepare method will add rtpbin and sinks and sources to send and receive RTP
  39  * and RTCP packets from the clients. Each stream srcpad is connected to an
  40  * input into the internal rtpbin.
  41  *
  42  * It is also possible to dynamically create #GstRTSPStream objects during the
  43  * prepare phase. With gst_rtsp_media_get_status() you can check the status of
  44  * the prepare phase.
  45  *
  46  * After the media is prepared, it is ready for streaming. It will usually be
  47  * managed in a session with gst_rtsp_session_manage_media(). See
  48  * #GstRTSPSession and #GstRTSPSessionMedia.
  49  *
  50  * The state of the media can be controlled with gst_rtsp_media_set_state ().
  51  * Seeking can be done with gst_rtsp_media_seek().
  52  *
  53  * With gst_rtsp_media_unprepare() the pipeline is stopped and shut down. When
  54  * gst_rtsp_media_set_eos_shutdown() an EOS will be sent to the pipeline to
  55  * cleanly shut down.
  56  *
  57  * With gst_rtsp_media_set_shared(), the media can be shared between multiple
  58  * clients. With gst_rtsp_media_set_reusable() you can control if the pipeline
  59  * can be prepared again after an unprepare.
  60  *
  61  * Last reviewed on 2013-07-11 (1.0.0)
  62  */
  63
  64 #include <string.h>
  65 #include <stdlib.h>
  66
  67 #include <gst/app/gstappsrc.h>
  68 #include <gst/app/gstappsink.h>
  69
  70 #include "rtsp-media.h"
  71
  72 #define GST_RTSP_MEDIA_GET_PRIVATE(obj)  \
  73      (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTSP_MEDIA, GstRTSPMediaPrivate))
  74
  75 struct _GstRTSPMediaPrivate
  76 {
  77   GMutex lock;
  78   GCond cond;
  79
  80   /* protected by lock */
  81   GstRTSPPermissions *permissions;
  82   gboolean shared;
  83   gboolean suspend_mode;
  84   gboolean reusable;
  85   GstRTSPProfile profiles;
  86   GstRTSPLowerTrans protocols;
  87   gboolean reused;
  88   gboolean eos_shutdown;
  89   guint buffer_size;
  90   GstRTSPAddressPool *pool;
  91   gboolean blocked;
  92
  93   GstElement *element;
  94   GRecMutex state_lock;         /* locking order: state lock, lock */
  95   GPtrArray *streams;           /* protected by lock */
  96   GList *dynamic;               /* protected by lock */
  97   GstRTSPMediaStatus status;    /* protected by lock */
  98   gint prepare_count;
  99   gint n_active;
 100   gboolean adding;
 101
 102   /* the pipeline for the media */
 103   GstElement *pipeline;
 104   GstElement *fakesink;         /* protected by lock */
 105   GSource *source;
 106   guint id;
 107   GstRTSPThread *thread;
 108
 109   gboolean time_provider;
 110   GstNetTimeProvider *nettime;
 111
 112   gboolean is_live;
 113   gboolean seekable;
 114   gboolean buffering;
 115   GstState target_state;
 116
 117   /* RTP session manager */
 118   GstElement *rtpbin;
 119
 120   /* the range of media */
 121   GstRTSPTimeRange range;       /* protected by lock */
 122   GstClockTime range_start;
 123   GstClockTime range_stop;
 124 };
 125
 126 #define DEFAULT_SHARED          FALSE
 127 #define DEFAULT_SUSPEND_MODE    GST_RTSP_SUSPEND_MODE_NONE
 128 #define DEFAULT_REUSABLE        FALSE
 129 #define DEFAULT_PROFILES        GST_RTSP_PROFILE_AVP
 130 #define DEFAULT_PROTOCOLS       GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_UDP_MCAST | \
 131                                         GST_RTSP_LOWER_TRANS_TCP
 132 #define DEFAULT_EOS_SHUTDOWN    FALSE
 133 #define DEFAULT_BUFFER_SIZE     0x80000
 134 #define DEFAULT_TIME_PROVIDER   FALSE
 135
 136 /* define to dump received RTCP packets */
 137 #undef DUMP_STATS
 138
 139 enum
 140 {
 141   PROP_0,
 142   PROP_SHARED,
 143   PROP_SUSPEND_MODE,
 144   PROP_REUSABLE,
 145   PROP_PROFILES,
 146   PROP_PROTOCOLS,
 147   PROP_EOS_SHUTDOWN,
 148   PROP_BUFFER_SIZE,
 149   PROP_ELEMENT,
 150   PROP_TIME_PROVIDER,
 151   PROP_LAST
 152 };
 153
 154 enum
 155 {
 156   SIGNAL_NEW_STREAM,
 157   SIGNAL_REMOVED_STREAM,
 158   SIGNAL_PREPARED,
 159   SIGNAL_UNPREPARED,
 160   SIGNAL_TARGET_STATE,
 161   SIGNAL_NEW_STATE,
 162   SIGNAL_LAST
 163 };
 164
 165 GST_DEBUG_CATEGORY_STATIC (rtsp_media_debug);
 166 #define GST_CAT_DEFAULT rtsp_media_debug
 167
 168 static void gst_rtsp_media_get_property (GObject * object, guint propid,
 169     GValue * value, GParamSpec * pspec);
 170 static void gst_rtsp_media_set_property (GObject * object, guint propid,
 171     const GValue * value, GParamSpec * pspec);
 172 static void gst_rtsp_media_finalize (GObject * obj);
 173
 174 static gboolean default_handle_message (GstRTSPMedia * media,
 175     GstMessage * message);
 176 static void finish_unprepare (GstRTSPMedia * media);
 177 static gboolean default_unprepare (GstRTSPMedia * media);
 178 static gboolean default_convert_range (GstRTSPMedia * media,
 179     GstRTSPTimeRange * range, GstRTSPRangeUnit unit);
 180 static gboolean default_query_position (GstRTSPMedia * media,
 181     gint64 * position);
 182 static gboolean default_query_stop (GstRTSPMedia * media, gint64 * stop);
 183 static GstElement *default_create_rtpbin (GstRTSPMedia * media);
 184 static gboolean default_setup_sdp (GstRTSPMedia * media, GstSDPMessage * sdp,
 185     GstSDPInfo * info);
 186
 187 static gboolean wait_preroll (GstRTSPMedia * media);
 188
 189 static guint gst_rtsp_media_signals[SIGNAL_LAST] = { 0 };
 190
 191 #define C_ENUM(v) ((gint) v)
 192
 193 #define GST_TYPE_RTSP_SUSPEND_MODE (gst_rtsp_suspend_mode_get_type())
 194 GType
 195 gst_rtsp_suspend_mode_get_type (void)
 196 {
 197   static gsize id = 0;
 198   static const GEnumValue values[] = {
 199     {C_ENUM (GST_RTSP_SUSPEND_MODE_NONE), "GST_RTSP_SUSPEND_MODE_NONE", "none"},
 200     {C_ENUM (GST_RTSP_SUSPEND_MODE_PAUSE), "GST_RTSP_SUSPEND_MODE_PAUSE",
 201         "pause"},
 202     {C_ENUM (GST_RTSP_SUSPEND_MODE_RESET), "GST_RTSP_SUSPEND_MODE_RESET",
 203         "reset"},
 204     {0, NULL, NULL}
 205   };
 206
 207   if (g_once_init_enter (&id)) {
 208     GType tmp = g_enum_register_static ("GstRTSPSuspendMode", values);
 209     g_once_init_leave (&id, tmp);
 210   }
 211   return (GType) id;
 212 }
 213
 214 G_DEFINE_TYPE (GstRTSPMedia, gst_rtsp_media, G_TYPE_OBJECT);
 215
 216 static void
 217 gst_rtsp_media_class_init (GstRTSPMediaClass * klass)
 218 {
 219   GObjectClass *gobject_class;
 220
 221   g_type_class_add_private (klass, sizeof (GstRTSPMediaPrivate));
 222
 223   gobject_class = G_OBJECT_CLASS (klass);
 224
 225   gobject_class->get_property = gst_rtsp_media_get_property;
 226   gobject_class->set_property = gst_rtsp_media_set_property;
 227   gobject_class->finalize = gst_rtsp_media_finalize;
 228
 229   g_object_class_install_property (gobject_class, PROP_SHARED,
 230       g_param_spec_boolean ("shared", "Shared",
 231           "If this media pipeline can be shared", DEFAULT_SHARED,
 232           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 233
 234   g_object_class_install_property (gobject_class, PROP_SUSPEND_MODE,
 235       g_param_spec_enum ("suspend-mode", "Suspend Mode",
 236           "How to suspend the media in PAUSED", GST_TYPE_RTSP_SUSPEND_MODE,
 237           DEFAULT_SUSPEND_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 238
 239   g_object_class_install_property (gobject_class, PROP_REUSABLE,
 240       g_param_spec_boolean ("reusable", "Reusable",
 241           "If this media pipeline can be reused after an unprepare",
 242           DEFAULT_REUSABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 243
 244 #ifdef GST_TYPE_RTSP_PROFILE
 245   g_object_class_install_property (gobject_class, PROP_PROFILES,
 246       g_param_spec_flags ("profiles", "Profiles",
 247           "Allowed transfer profiles", GST_TYPE_RTSP_PROFILE,
 248           DEFAULT_PROFILES, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 249 #endif
 250
 251   g_object_class_install_property (gobject_class, PROP_PROTOCOLS,
 252       g_param_spec_flags ("protocols", "Protocols",
 253           "Allowed lower transport protocols", GST_TYPE_RTSP_LOWER_TRANS,
 254           DEFAULT_PROTOCOLS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 255
 256   g_object_class_install_property (gobject_class, PROP_EOS_SHUTDOWN,
 257       g_param_spec_boolean ("eos-shutdown", "EOS Shutdown",
 258           "Send an EOS event to the pipeline before unpreparing",
 259           DEFAULT_EOS_SHUTDOWN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 260
 261   g_object_class_install_property (gobject_class, PROP_BUFFER_SIZE,
 262       g_param_spec_uint ("buffer-size", "Buffer Size",
 263           "The kernel UDP buffer size to use", 0, G_MAXUINT,
 264           DEFAULT_BUFFER_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 265
 266   g_object_class_install_property (gobject_class, PROP_ELEMENT,
 267       g_param_spec_object ("element", "The Element",
 268           "The GstBin to use for streaming the media", GST_TYPE_ELEMENT,
 269           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
 270
 271   g_object_class_install_property (gobject_class, PROP_TIME_PROVIDER,
 272       g_param_spec_boolean ("time-provider", "Time Provider",
 273           "Use a NetTimeProvider for clients",
 274           DEFAULT_TIME_PROVIDER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 275
 276   gst_rtsp_media_signals[SIGNAL_NEW_STREAM] =
 277       g_signal_new ("new-stream", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 278       G_STRUCT_OFFSET (GstRTSPMediaClass, new_stream), NULL, NULL,
 279       g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_RTSP_STREAM);
 280
 281   gst_rtsp_media_signals[SIGNAL_REMOVED_STREAM] =
 282       g_signal_new ("removed-stream", G_TYPE_FROM_CLASS (klass),
 283       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPMediaClass, removed_stream),
 284       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1,
 285       GST_TYPE_RTSP_STREAM);
 286
 287   gst_rtsp_media_signals[SIGNAL_PREPARED] =
 288       g_signal_new ("prepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 289       G_STRUCT_OFFSET (GstRTSPMediaClass, prepared), NULL, NULL,
 290       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 291
 292   gst_rtsp_media_signals[SIGNAL_UNPREPARED] =
 293       g_signal_new ("unprepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 294       G_STRUCT_OFFSET (GstRTSPMediaClass, unprepared), NULL, NULL,
 295       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 296
 297   gst_rtsp_media_signals[SIGNAL_TARGET_STATE] =
 298       g_signal_new ("target-state", G_TYPE_FROM_CLASS (klass),
 299       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTSPMediaClass, new_state), NULL,
 300       NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 301
 302   gst_rtsp_media_signals[SIGNAL_NEW_STATE] =
 303       g_signal_new ("new-state", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 304       G_STRUCT_OFFSET (GstRTSPMediaClass, new_state), NULL, NULL,
 305       g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 306
 307   GST_DEBUG_CATEGORY_INIT (rtsp_media_debug, "rtspmedia", 0, "GstRTSPMedia");
 308
 309   klass->handle_message = default_handle_message;
 310   klass->unprepare = default_unprepare;
 311   klass->convert_range = default_convert_range;
 312   klass->query_position = default_query_position;
 313   klass->query_stop = default_query_stop;
 314   klass->create_rtpbin = default_create_rtpbin;
 315   klass->setup_sdp = default_setup_sdp;
 316 }
 317
 318 static void
 319 gst_rtsp_media_init (GstRTSPMedia * media)
 320 {
 321   GstRTSPMediaPrivate *priv = GST_RTSP_MEDIA_GET_PRIVATE (media);
 322
 323   media->priv = priv;
 324
 325   priv->streams = g_ptr_array_new_with_free_func (g_object_unref);
 326   g_mutex_init (&priv->lock);
 327   g_cond_init (&priv->cond);
 328   g_rec_mutex_init (&priv->state_lock);
 329
 330   priv->shared = DEFAULT_SHARED;
 331   priv->suspend_mode = DEFAULT_SUSPEND_MODE;
 332   priv->reusable = DEFAULT_REUSABLE;
 333   priv->profiles = DEFAULT_PROFILES;
 334   priv->protocols = DEFAULT_PROTOCOLS;
 335   priv->eos_shutdown = DEFAULT_EOS_SHUTDOWN;
 336   priv->buffer_size = DEFAULT_BUFFER_SIZE;
 337   priv->time_provider = DEFAULT_TIME_PROVIDER;
 338 }
 339
 340 static void
 341 gst_rtsp_media_finalize (GObject * obj)
 342 {
 343   GstRTSPMediaPrivate *priv;
 344   GstRTSPMedia *media;
 345
 346   media = GST_RTSP_MEDIA (obj);
 347   priv = media->priv;
 348
 349   GST_INFO ("finalize media %p", media);
 350
 351   if (priv->permissions)
 352     gst_rtsp_permissions_unref (priv->permissions);
 353
 354   g_ptr_array_unref (priv->streams);
 355
 356   g_list_free_full (priv->dynamic, gst_object_unref);
 357
 358   if (priv->pipeline)
 359     gst_object_unref (priv->pipeline);
 360   if (priv->nettime)
 361     gst_object_unref (priv->nettime);
 362   gst_object_unref (priv->element);
 363   if (priv->pool)
 364     g_object_unref (priv->pool);
 365   g_mutex_clear (&priv->lock);
 366   g_cond_clear (&priv->cond);
 367   g_rec_mutex_clear (&priv->state_lock);
 368
 369   G_OBJECT_CLASS (gst_rtsp_media_parent_class)->finalize (obj);
 370 }
 371
 372 static void
 373 gst_rtsp_media_get_property (GObject * object, guint propid,
 374     GValue * value, GParamSpec * pspec)
 375 {
 376   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 377
 378   switch (propid) {
 379     case PROP_ELEMENT:
 380       g_value_set_object (value, media->priv->element);
 381       break;
 382     case PROP_SHARED:
 383       g_value_set_boolean (value, gst_rtsp_media_is_shared (media));
 384       break;
 385     case PROP_SUSPEND_MODE:
 386       g_value_set_enum (value, gst_rtsp_media_get_suspend_mode (media));
 387       break;
 388     case PROP_REUSABLE:
 389       g_value_set_boolean (value, gst_rtsp_media_is_reusable (media));
 390       break;
 391     case PROP_PROFILES:
 392       g_value_set_flags (value, gst_rtsp_media_get_profiles (media));
 393       break;
 394     case PROP_PROTOCOLS:
 395       g_value_set_flags (value, gst_rtsp_media_get_protocols (media));
 396       break;
 397     case PROP_EOS_SHUTDOWN:
 398       g_value_set_boolean (value, gst_rtsp_media_is_eos_shutdown (media));
 399       break;
 400     case PROP_BUFFER_SIZE:
 401       g_value_set_uint (value, gst_rtsp_media_get_buffer_size (media));
 402       break;
 403     case PROP_TIME_PROVIDER:
 404       g_value_set_boolean (value, gst_rtsp_media_is_time_provider (media));
 405       break;
 406     default:
 407       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 408   }
 409 }
 410
 411 static void
 412 gst_rtsp_media_set_property (GObject * object, guint propid,
 413     const GValue * value, GParamSpec * pspec)
 414 {
 415   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 416
 417   switch (propid) {
 418     case PROP_ELEMENT:
 419       media->priv->element = g_value_get_object (value);
 420       gst_object_ref_sink (media->priv->element);
 421       break;
 422     case PROP_SHARED:
 423       gst_rtsp_media_set_shared (media, g_value_get_boolean (value));
 424       break;
 425     case PROP_SUSPEND_MODE:
 426       gst_rtsp_media_set_suspend_mode (media, g_value_get_enum (value));
 427       break;
 428     case PROP_REUSABLE:
 429       gst_rtsp_media_set_reusable (media, g_value_get_boolean (value));
 430       break;
 431     case PROP_PROFILES:
 432       gst_rtsp_media_set_profiles (media, g_value_get_flags (value));
 433       break;
 434     case PROP_PROTOCOLS:
 435       gst_rtsp_media_set_protocols (media, g_value_get_flags (value));
 436       break;
 437     case PROP_EOS_SHUTDOWN:
 438       gst_rtsp_media_set_eos_shutdown (media, g_value_get_boolean (value));
 439       break;
 440     case PROP_BUFFER_SIZE:
 441       gst_rtsp_media_set_buffer_size (media, g_value_get_uint (value));
 442       break;
 443     case PROP_TIME_PROVIDER:
 444       gst_rtsp_media_use_time_provider (media, g_value_get_boolean (value));
 445       break;
 446     default:
 447       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 448   }
 449 }
 450
 451 static gboolean
 452 default_query_position (GstRTSPMedia * media, gint64 * position)
 453 {
 454   return gst_element_query_position (media->priv->pipeline, GST_FORMAT_TIME,
 455       position);
 456 }
 457
 458 static gboolean
 459 default_query_stop (GstRTSPMedia * media, gint64 * stop)
 460 {
 461   GstQuery *query;
 462   gboolean res;
 463
 464   query = gst_query_new_segment (GST_FORMAT_TIME);
 465   if ((res = gst_element_query (media->priv->pipeline, query))) {
 466     GstFormat format;
 467     gst_query_parse_segment (query, NULL, &format, NULL, stop);
 468     if (format != GST_FORMAT_TIME)
 469       *stop = -1;
 470   }
 471   gst_query_unref (query);
 472   return res;
 473 }
 474
 475 static GstElement *
 476 default_create_rtpbin (GstRTSPMedia * media)
 477 {
 478   GstElement *rtpbin;
 479
 480   rtpbin = gst_element_factory_make ("rtpbin", NULL);
 481
 482   return rtpbin;
 483 }
 484
 485 /* must be called with state lock */
 486 static void
 487 collect_media_stats (GstRTSPMedia * media)
 488 {
 489   GstRTSPMediaPrivate *priv = media->priv;
 490   gint64 position, stop;
 491
 492   if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED &&
 493       priv->status != GST_RTSP_MEDIA_STATUS_PREPARING)
 494     return;
 495
 496   priv->range.unit = GST_RTSP_RANGE_NPT;
 497
 498   GST_INFO ("collect media stats");
 499
 500   if (priv->is_live) {
 501     priv->range.min.type = GST_RTSP_TIME_NOW;
 502     priv->range.min.seconds = -1;
 503     priv->range_start = -1;
 504     priv->range.max.type = GST_RTSP_TIME_END;
 505     priv->range.max.seconds = -1;
 506     priv->range_stop = -1;
 507   } else {
 508     GstRTSPMediaClass *klass;
 509     gboolean ret;
 510
 511     klass = GST_RTSP_MEDIA_GET_CLASS (media);
 512
 513     /* get the position */
 514     ret = FALSE;
 515     if (klass->query_position)
 516       ret = klass->query_position (media, &position);
 517
 518     if (!ret) {
 519       GST_INFO ("position query failed");
 520       position = 0;
 521     }
 522
 523     /* get the current segment stop */
 524     ret = FALSE;
 525     if (klass->query_stop)
 526       ret = klass->query_stop (media, &stop);
 527
 528     if (!ret) {
 529       GST_INFO ("stop query failed");
 530       stop = -1;
 531     }
 532
 533     GST_INFO ("stats: position %" GST_TIME_FORMAT ", stop %"
 534         GST_TIME_FORMAT, GST_TIME_ARGS (position), GST_TIME_ARGS (stop));
 535
 536     if (position == -1) {
 537       priv->range.min.type = GST_RTSP_TIME_NOW;
 538       priv->range.min.seconds = -1;
 539       priv->range_start = -1;
 540     } else {
 541       priv->range.min.type = GST_RTSP_TIME_SECONDS;
 542       priv->range.min.seconds = ((gdouble) position) / GST_SECOND;
 543       priv->range_start = position;
 544     }
 545     if (stop == -1) {
 546       priv->range.max.type = GST_RTSP_TIME_END;
 547       priv->range.max.seconds = -1;
 548       priv->range_stop = -1;
 549     } else {
 550       priv->range.max.type = GST_RTSP_TIME_SECONDS;
 551       priv->range.max.seconds = ((gdouble) stop) / GST_SECOND;
 552       priv->range_stop = stop;
 553     }
 554   }
 555 }
 556
 557 /**
 558  * gst_rtsp_media_new:
 559  * @element: (transfer full): a #GstElement
 560  *
 561  * Create a new #GstRTSPMedia instance. @element is the bin element that
 562  * provides the different streams. The #GstRTSPMedia object contains the
 563  * element to produce RTP data for one or more related (audio/video/..)
 564  * streams.
 565  *
 566  * Ownership is taken of @element.
 567  *
 568  * Returns: a new #GstRTSPMedia object.
 569  */
 570 GstRTSPMedia *
 571 gst_rtsp_media_new (GstElement * element)
 572 {
 573   GstRTSPMedia *result;
 574
 575   g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
 576
 577   result = g_object_new (GST_TYPE_RTSP_MEDIA, "element", element, NULL);
 578
 579   return result;
 580 }
 581
 582 /**
 583  * gst_rtsp_media_get_element:
 584  * @media: a #GstRTSPMedia
 585  *
 586  * Get the element that was used when constructing @media.
 587  *
 588  * Returns: (transfer full): a #GstElement. Unref after usage.
 589  */
 590 GstElement *
 591 gst_rtsp_media_get_element (GstRTSPMedia * media)
 592 {
 593   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 594
 595   return gst_object_ref (media->priv->element);
 596 }
 597
 598 /**
 599  * gst_rtsp_media_take_pipeline:
 600  * @media: a #GstRTSPMedia
 601  * @pipeline: (transfer full): a #GstPipeline
 602  *
 603  * Set @pipeline as the #GstPipeline for @media. Ownership is
 604  * taken of @pipeline.
 605  */
 606 void
 607 gst_rtsp_media_take_pipeline (GstRTSPMedia * media, GstPipeline * pipeline)
 608 {
 609   GstRTSPMediaPrivate *priv;
 610   GstElement *old;
 611   GstNetTimeProvider *nettime;
 612
 613   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 614   g_return_if_fail (GST_IS_PIPELINE (pipeline));
 615
 616   priv = media->priv;
 617
 618   g_mutex_lock (&priv->lock);
 619   old = priv->pipeline;
 620   priv->pipeline = GST_ELEMENT_CAST (pipeline);
 621   nettime = priv->nettime;
 622   priv->nettime = NULL;
 623   g_mutex_unlock (&priv->lock);
 624
 625   if (old)
 626     gst_object_unref (old);
 627
 628   if (nettime)
 629     gst_object_unref (nettime);
 630
 631   gst_bin_add (GST_BIN_CAST (pipeline), priv->element);
 632 }
 633
 634 /**
 635  * gst_rtsp_media_set_permissions:
 636  * @media: a #GstRTSPMedia
 637  * @permissions: a #GstRTSPPermissions
 638  *
 639  * Set @permissions on @media.
 640  */
 641 void
 642 gst_rtsp_media_set_permissions (GstRTSPMedia * media,
 643     GstRTSPPermissions * permissions)
 644 {
 645   GstRTSPMediaPrivate *priv;
 646
 647   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 648
 649   priv = media->priv;
 650
 651   g_mutex_lock (&priv->lock);
 652   if (priv->permissions)
 653     gst_rtsp_permissions_unref (priv->permissions);
 654   if ((priv->permissions = permissions))
 655     gst_rtsp_permissions_ref (permissions);
 656   g_mutex_unlock (&priv->lock);
 657 }
 658
 659 /**
 660  * gst_rtsp_media_get_permissions:
 661  * @media: a #GstRTSPMedia
 662  *
 663  * Get the permissions object from @media.
 664  *
 665  * Returns: (transfer full): a #GstRTSPPermissions object, unref after usage.
 666  */
 667 GstRTSPPermissions *
 668 gst_rtsp_media_get_permissions (GstRTSPMedia * media)
 669 {
 670   GstRTSPMediaPrivate *priv;
 671   GstRTSPPermissions *result;
 672
 673   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 674
 675   priv = media->priv;
 676
 677   g_mutex_lock (&priv->lock);
 678   if ((result = priv->permissions))
 679     gst_rtsp_permissions_ref (result);
 680   g_mutex_unlock (&priv->lock);
 681
 682   return result;
 683 }
 684
 685 /**
 686  * gst_rtsp_media_set_suspend_mode:
 687  * @media: a #GstRTSPMedia
 688  * @mode: the new #GstRTSPSuspendMode
 689  *
 690  * Control how @ media will be suspended after the SDP has been generated and
 691  * after a PAUSE request has been performed.
 692  *
 693  * Media must be unprepared when setting the suspend mode.
 694  */
 695 void
 696 gst_rtsp_media_set_suspend_mode (GstRTSPMedia * media, GstRTSPSuspendMode mode)
 697 {
 698   GstRTSPMediaPrivate *priv;
 699
 700   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 701
 702   priv = media->priv;
 703
 704   g_rec_mutex_lock (&priv->state_lock);
 705   if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARED)
 706     goto was_prepared;
 707   priv->suspend_mode = mode;
 708   g_rec_mutex_unlock (&priv->state_lock);
 709
 710   return;
 711
 712   /* ERRORS */
 713 was_prepared:
 714   {
 715     GST_WARNING ("media %p was prepared", media);
 716     g_rec_mutex_unlock (&priv->state_lock);
 717   }
 718 }
 719
 720 /**
 721  * gst_rtsp_media_get_suspend_mode:
 722  * @media: a #GstRTSPMedia
 723  *
 724  * Get how @media will be suspended.
 725  *
 726  * Returns: #GstRTSPSuspendMode.
 727  */
 728 GstRTSPSuspendMode
 729 gst_rtsp_media_get_suspend_mode (GstRTSPMedia * media)
 730 {
 731   GstRTSPMediaPrivate *priv;
 732   GstRTSPSuspendMode res;
 733
 734   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), GST_RTSP_SUSPEND_MODE_NONE);
 735
 736   priv = media->priv;
 737
 738   g_rec_mutex_lock (&priv->state_lock);
 739   res = priv->suspend_mode;
 740   g_rec_mutex_unlock (&priv->state_lock);
 741
 742   return res;
 743 }
 744
 745 /**
 746  * gst_rtsp_media_set_shared:
 747  * @media: a #GstRTSPMedia
 748  * @shared: the new value
 749  *
 750  * Set or unset if the pipeline for @media can be shared will multiple clients.
 751  * When @shared is %TRUE, client requests for this media will share the media
 752  * pipeline.
 753  */
 754 void
 755 gst_rtsp_media_set_shared (GstRTSPMedia * media, gboolean shared)
 756 {
 757   GstRTSPMediaPrivate *priv;
 758
 759   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 760
 761   priv = media->priv;
 762
 763   g_mutex_lock (&priv->lock);
 764   priv->shared = shared;
 765   g_mutex_unlock (&priv->lock);
 766 }
 767
 768 /**
 769  * gst_rtsp_media_is_shared:
 770  * @media: a #GstRTSPMedia
 771  *
 772  * Check if the pipeline for @media can be shared between multiple clients.
 773  *
 774  * Returns: %TRUE if the media can be shared between clients.
 775  */
 776 gboolean
 777 gst_rtsp_media_is_shared (GstRTSPMedia * media)
 778 {
 779   GstRTSPMediaPrivate *priv;
 780   gboolean res;
 781
 782   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 783
 784   priv = media->priv;
 785
 786   g_mutex_lock (&priv->lock);
 787   res = priv->shared;
 788   g_mutex_unlock (&priv->lock);
 789
 790   return res;
 791 }
 792
 793 /**
 794  * gst_rtsp_media_set_reusable:
 795  * @media: a #GstRTSPMedia
 796  * @reusable: the new value
 797  *
 798  * Set or unset if the pipeline for @media can be reused after the pipeline has
 799  * been unprepared.
 800  */
 801 void
 802 gst_rtsp_media_set_reusable (GstRTSPMedia * media, gboolean reusable)
 803 {
 804   GstRTSPMediaPrivate *priv;
 805
 806   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 807
 808   priv = media->priv;
 809
 810   g_mutex_lock (&priv->lock);
 811   priv->reusable = reusable;
 812   g_mutex_unlock (&priv->lock);
 813 }
 814
 815 /**
 816  * gst_rtsp_media_is_reusable:
 817  * @media: a #GstRTSPMedia
 818  *
 819  * Check if the pipeline for @media can be reused after an unprepare.
 820  *
 821  * Returns: %TRUE if the media can be reused
 822  */
 823 gboolean
 824 gst_rtsp_media_is_reusable (GstRTSPMedia * media)
 825 {
 826   GstRTSPMediaPrivate *priv;
 827   gboolean res;
 828
 829   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 830
 831   priv = media->priv;
 832
 833   g_mutex_lock (&priv->lock);
 834   res = priv->reusable;
 835   g_mutex_unlock (&priv->lock);
 836
 837   return res;
 838 }
 839
 840 static void
 841 do_set_profiles (GstRTSPStream * stream, GstRTSPProfile * profiles)
 842 {
 843   gst_rtsp_stream_set_profiles (stream, *profiles);
 844 }
 845
 846 /**
 847  * gst_rtsp_media_set_profiles:
 848  * @media: a #GstRTSPMedia
 849  * @profiles: the new flags
 850  *
 851  * Configure the allowed lower transport for @media.
 852  */
 853 void
 854 gst_rtsp_media_set_profiles (GstRTSPMedia * media, GstRTSPProfile profiles)
 855 {
 856   GstRTSPMediaPrivate *priv;
 857
 858   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 859
 860   priv = media->priv;
 861
 862   g_mutex_lock (&priv->lock);
 863   priv->profiles = profiles;
 864   g_ptr_array_foreach (priv->streams, (GFunc) do_set_profiles, &profiles);
 865   g_mutex_unlock (&priv->lock);
 866 }
 867
 868 /**
 869  * gst_rtsp_media_get_profiles:
 870  * @media: a #GstRTSPMedia
 871  *
 872  * Get the allowed profiles of @media.
 873  *
 874  * Returns: a #GstRTSPProfile
 875  */
 876 GstRTSPProfile
 877 gst_rtsp_media_get_profiles (GstRTSPMedia * media)
 878 {
 879   GstRTSPMediaPrivate *priv;
 880   GstRTSPProfile res;
 881
 882   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), GST_RTSP_PROFILE_UNKNOWN);
 883
 884   priv = media->priv;
 885
 886   g_mutex_lock (&priv->lock);
 887   res = priv->profiles;
 888   g_mutex_unlock (&priv->lock);
 889
 890   return res;
 891 }
 892
 893 static void
 894 do_set_protocols (GstRTSPStream * stream, GstRTSPLowerTrans * protocols)
 895 {
 896   gst_rtsp_stream_set_protocols (stream, *protocols);
 897 }
 898
 899 /**
 900  * gst_rtsp_media_set_protocols:
 901  * @media: a #GstRTSPMedia
 902  * @protocols: the new flags
 903  *
 904  * Configure the allowed lower transport for @media.
 905  */
 906 void
 907 gst_rtsp_media_set_protocols (GstRTSPMedia * media, GstRTSPLowerTrans protocols)
 908 {
 909   GstRTSPMediaPrivate *priv;
 910
 911   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 912
 913   priv = media->priv;
 914
 915   g_mutex_lock (&priv->lock);
 916   priv->protocols = protocols;
 917   g_ptr_array_foreach (priv->streams, (GFunc) do_set_protocols, &protocols);
 918   g_mutex_unlock (&priv->lock);
 919 }
 920
 921 /**
 922  * gst_rtsp_media_get_protocols:
 923  * @media: a #GstRTSPMedia
 924  *
 925  * Get the allowed protocols of @media.
 926  *
 927  * Returns: a #GstRTSPLowerTrans
 928  */
 929 GstRTSPLowerTrans
 930 gst_rtsp_media_get_protocols (GstRTSPMedia * media)
 931 {
 932   GstRTSPMediaPrivate *priv;
 933   GstRTSPLowerTrans res;
 934
 935   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media),
 936       GST_RTSP_LOWER_TRANS_UNKNOWN);
 937
 938   priv = media->priv;
 939
 940   g_mutex_lock (&priv->lock);
 941   res = priv->protocols;
 942   g_mutex_unlock (&priv->lock);
 943
 944   return res;
 945 }
 946
 947 /**
 948  * gst_rtsp_media_set_eos_shutdown:
 949  * @media: a #GstRTSPMedia
 950  * @eos_shutdown: the new value
 951  *
 952  * Set or unset if an EOS event will be sent to the pipeline for @media before
 953  * it is unprepared.
 954  */
 955 void
 956 gst_rtsp_media_set_eos_shutdown (GstRTSPMedia * media, gboolean eos_shutdown)
 957 {
 958   GstRTSPMediaPrivate *priv;
 959
 960   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 961
 962   priv = media->priv;
 963
 964   g_mutex_lock (&priv->lock);
 965   priv->eos_shutdown = eos_shutdown;
 966   g_mutex_unlock (&priv->lock);
 967 }
 968
 969 /**
 970  * gst_rtsp_media_is_eos_shutdown:
 971  * @media: a #GstRTSPMedia
 972  *
 973  * Check if the pipeline for @media will send an EOS down the pipeline before
 974  * unpreparing.
 975  *
 976  * Returns: %TRUE if the media will send EOS before unpreparing.
 977  */
 978 gboolean
 979 gst_rtsp_media_is_eos_shutdown (GstRTSPMedia * media)
 980 {
 981   GstRTSPMediaPrivate *priv;
 982   gboolean res;
 983
 984   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 985
 986   priv = media->priv;
 987
 988   g_mutex_lock (&priv->lock);
 989   res = priv->eos_shutdown;
 990   g_mutex_unlock (&priv->lock);
 991
 992   return res;
 993 }
 994
 995 /**
 996  * gst_rtsp_media_set_buffer_size:
 997  * @media: a #GstRTSPMedia
 998  * @size: the new value
 999  *
1000  * Set the kernel UDP buffer size.
1001  */
1002 void
1003 gst_rtsp_media_set_buffer_size (GstRTSPMedia * media, guint size)
1004 {
1005   GstRTSPMediaPrivate *priv;
1006
1007   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
1008
1009   GST_LOG_OBJECT (media, "set buffer size %u", size);
1010
1011   priv = media->priv;
1012
1013   g_mutex_lock (&priv->lock);
1014   priv->buffer_size = size;
1015   g_mutex_unlock (&priv->lock);
1016 }
1017
1018 /**
1019  * gst_rtsp_media_get_buffer_size:
1020  * @media: a #GstRTSPMedia
1021  *
1022  * Get the kernel UDP buffer size.
1023  *
1024  * Returns: the kernel UDP buffer size.
1025  */
1026 guint
1027 gst_rtsp_media_get_buffer_size (GstRTSPMedia * media)
1028 {
1029   GstRTSPMediaPrivate *priv;
1030   guint res;
1031
1032   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
1033
1034   priv = media->priv;
1035
1036   g_mutex_unlock (&priv->lock);
1037   res = priv->buffer_size;
1038   g_mutex_unlock (&priv->lock);
1039
1040   return res;
1041 }
1042
1043 /**
1044  * gst_rtsp_media_use_time_provider:
1045  * @media: a #GstRTSPMedia
1046  * @time_provider: if a #GstNetTimeProvider should be used
1047  *
1048  * Set @media to provide a #GstNetTimeProvider.
1049  */
1050 void
1051 gst_rtsp_media_use_time_provider (GstRTSPMedia * media, gboolean time_provider)
1052 {
1053   GstRTSPMediaPrivate *priv;
1054
1055   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
1056
1057   priv = media->priv;
1058
1059   g_mutex_lock (&priv->lock);
1060   priv->time_provider = time_provider;
1061   g_mutex_unlock (&priv->lock);
1062 }
1063
1064 /**
1065  * gst_rtsp_media_is_time_provider:
1066  * @media: a #GstRTSPMedia
1067  *
1068  * Check if @media can provide a #GstNetTimeProvider for its pipeline clock.
1069  *
1070  * Use gst_rtsp_media_get_time_provider() to get the network clock.
1071  *
1072  * Returns: %TRUE if @media can provide a #GstNetTimeProvider.
1073  */
1074 gboolean
1075 gst_rtsp_media_is_time_provider (GstRTSPMedia * media)
1076 {
1077   GstRTSPMediaPrivate *priv;
1078   gboolean res;
1079
1080   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
1081
1082   priv = media->priv;
1083
1084   g_mutex_unlock (&priv->lock);
1085   res = priv->time_provider;
1086   g_mutex_unlock (&priv->lock);
1087
1088   return res;
1089 }
1090
1091 /**
1092  * gst_rtsp_media_set_address_pool:
1093  * @media: a #GstRTSPMedia
1094  * @pool: a #GstRTSPAddressPool
1095  *
1096  * configure @pool to be used as the address pool of @media.
1097  */
1098 void
1099 gst_rtsp_media_set_address_pool (GstRTSPMedia * media,
1100     GstRTSPAddressPool * pool)
1101 {
1102   GstRTSPMediaPrivate *priv;
1103   GstRTSPAddressPool *old;
1104
1105   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
1106
1107   priv = media->priv;
1108
1109   GST_LOG_OBJECT (media, "set address pool %p", pool);
1110
1111   g_mutex_lock (&priv->lock);
1112   if ((old = priv->pool) != pool)
1113     priv->pool = pool ? g_object_ref (pool) : NULL;
1114   else
1115     old = NULL;
1116   g_ptr_array_foreach (priv->streams, (GFunc) gst_rtsp_stream_set_address_pool,
1117       pool);
1118   g_mutex_unlock (&priv->lock);
1119
1120   if (old)
1121     g_object_unref (old);
1122 }
1123
1124 /**
1125  * gst_rtsp_media_get_address_pool:
1126  * @media: a #GstRTSPMedia
1127  *
1128  * Get the #GstRTSPAddressPool used as the address pool of @media.
1129  *
1130  * Returns: (transfer full): the #GstRTSPAddressPool of @media. g_object_unref() after
1131  * usage.
1132  */
1133 GstRTSPAddressPool *
1134 gst_rtsp_media_get_address_pool (GstRTSPMedia * media)
1135 {
1136   GstRTSPMediaPrivate *priv;
1137   GstRTSPAddressPool *result;
1138
1139   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
1140
1141   priv = media->priv;
1142
1143   g_mutex_lock (&priv->lock);
1144   if ((result = priv->pool))
1145     g_object_ref (result);
1146   g_mutex_unlock (&priv->lock);
1147
1148   return result;
1149 }
1150
1151 /**
1152  * gst_rtsp_media_collect_streams:
1153  * @media: a #GstRTSPMedia
1154  *
1155  * Find all payloader elements, they should be named pay\%d in the
1156  * element of @media, and create #GstRTSPStreams for them.
1157  *
1158  * Collect all dynamic elements, named dynpay\%d, and add them to
1159  * the list of dynamic elements.
1160  */
1161 void
1162 gst_rtsp_media_collect_streams (GstRTSPMedia * media)
1163 {
1164   GstRTSPMediaPrivate *priv;
1165   GstElement *element, *elem;
1166   GstPad *pad;
1167   gint i;
1168   gboolean have_elem;
1169
1170   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
1171
1172   priv = media->priv;
1173   element = priv->element;
1174
1175   have_elem = TRUE;
1176   for (i = 0; have_elem; i++) {
1177     gchar *name;
1178
1179     have_elem = FALSE;
1180
1181     name = g_strdup_printf ("pay%d", i);
1182     if ((elem = gst_bin_get_by_name (GST_BIN (element), name))) {
1183       GST_INFO ("found stream %d with payloader %p", i, elem);
1184
1185       /* take the pad of the payloader */
1186       pad = gst_element_get_static_pad (elem, "src");
1187       /* create the stream */
1188       gst_rtsp_media_create_stream (media, elem, pad);
1189       gst_object_unref (pad);
1190       gst_object_unref (elem);
1191
1192       have_elem = TRUE;
1193     }
1194     g_free (name);
1195
1196     name = g_strdup_printf ("dynpay%d", i);
1197     if ((elem = gst_bin_get_by_name (GST_BIN (element), name))) {
1198       /* a stream that will dynamically create pads to provide RTP packets */
1199
1200       GST_INFO ("found dynamic element %d, %p", i, elem);
1201
1202       g_mutex_lock (&priv->lock);
1203       priv->dynamic = g_list_prepend (priv->dynamic, elem);
1204       g_mutex_unlock (&priv->lock);
1205
1206       have_elem = TRUE;
1207     }
1208     g_free (name);
1209   }
1210 }
1211
1212 /**
1213  * gst_rtsp_media_create_stream:
1214  * @media: a #GstRTSPMedia
1215  * @payloader: a #GstElement
1216  * @srcpad: a source #GstPad
1217  *
1218  * Create a new stream in @media that provides RTP data on @srcpad.
1219  * @srcpad should be a pad of an element inside @media->element.
1220  *
1221  * Returns: (transfer none): a new #GstRTSPStream that remains valid for as long
1222  *          as @media exists.
1223  */
1224 GstRTSPStream *
1225 gst_rtsp_media_create_stream (GstRTSPMedia * media, GstElement * payloader,
1226     GstPad * pad)
1227 {
1228   GstRTSPMediaPrivate *priv;
1229   GstRTSPStream *stream;
1230   GstPad *srcpad;
1231   gchar *name;
1232   gint idx;
1233
1234   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
1235   g_return_val_if_fail (GST_IS_ELEMENT (payloader), NULL);
1236   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1237   g_return_val_if_fail (GST_PAD_IS_SRC (pad), NULL);
1238
1239   priv = media->priv;
1240
1241   g_mutex_lock (&priv->lock);
1242   idx = priv->streams->len;
1243
1244   GST_DEBUG ("media %p: creating stream with index %d", media, idx);
1245
1246   name = g_strdup_printf ("src_%u", idx);
1247   srcpad = gst_ghost_pad_new (name, pad);
1248   gst_pad_set_active (srcpad, TRUE);
1249   gst_element_add_pad (priv->element, srcpad);
1250   g_free (name);
1251
1252   stream = gst_rtsp_stream_new (idx, payloader, srcpad);
1253   if (priv->pool)
1254     gst_rtsp_stream_set_address_pool (stream, priv->pool);
1255   gst_rtsp_stream_set_protocols (stream, priv->protocols);
1256
1257   g_ptr_array_add (priv->streams, stream);
1258   g_mutex_unlock (&priv->lock);
1259
1260   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STREAM], 0, stream,
1261       NULL);
1262
1263   return stream;
1264 }
1265
1266 static void
1267 gst_rtsp_media_remove_stream (GstRTSPMedia * media, GstRTSPStream * stream)
1268 {
1269   GstRTSPMediaPrivate *priv;
1270   GstPad *srcpad;
1271
1272   priv = media->priv;
1273
1274   g_mutex_lock (&priv->lock);
1275   /* remove the ghostpad */
1276   srcpad = gst_rtsp_stream_get_srcpad (stream);
1277   gst_element_remove_pad (priv->element, srcpad);
1278   gst_object_unref (srcpad);
1279   /* now remove the stream */
1280   g_object_ref (stream);
1281   g_ptr_array_remove (priv->streams, stream);
1282   g_mutex_unlock (&priv->lock);
1283
1284   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_REMOVED_STREAM], 0,
1285       stream, NULL);
1286
1287   g_object_unref (stream);
1288 }
1289
1290 /**
1291  * gst_rtsp_media_n_streams:
1292  * @media: a #GstRTSPMedia
1293  *
1294  * Get the number of streams in this media.
1295  *
1296  * Returns: The number of streams.
1297  */
1298 guint
1299 gst_rtsp_media_n_streams (GstRTSPMedia * media)
1300 {
1301   GstRTSPMediaPrivate *priv;
1302   guint res;
1303
1304   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
1305
1306   priv = media->priv;
1307
1308   g_mutex_lock (&priv->lock);
1309   res = priv->streams->len;
1310   g_mutex_unlock (&priv->lock);
1311
1312   return res;
1313 }
1314
1315 /**
1316  * gst_rtsp_media_get_stream:
1317  * @media: a #GstRTSPMedia
1318  * @idx: the stream index
1319  *
1320  * Retrieve the stream with index @idx from @media.
1321  *
1322  * Returns: (transfer none): the #GstRTSPStream at index @idx or %NULL when a stream with
1323  * that index did not exist.
1324  */
1325 GstRTSPStream *
1326 gst_rtsp_media_get_stream (GstRTSPMedia * media, guint idx)
1327 {
1328   GstRTSPMediaPrivate *priv;
1329   GstRTSPStream *res;
1330
1331   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
1332
1333   priv = media->priv;
1334
1335   g_mutex_lock (&priv->lock);
1336   if (idx < priv->streams->len)
1337     res = g_ptr_array_index (priv->streams, idx);
1338   else
1339     res = NULL;
1340   g_mutex_unlock (&priv->lock);
1341
1342   return res;
1343 }
1344
1345 /**
1346  * gst_rtsp_media_find_stream:
1347  * @media: a #GstRTSPMedia
1348  * @control: the control of the stream
1349  *
1350  * Find a stream in @media with @control as the control uri.
1351  *
1352  * Returns: (transfer none): the #GstRTSPStream with control uri @control
1353  * or %NULL when a stream with that control did not exist.
1354  */
1355 GstRTSPStream *
1356 gst_rtsp_media_find_stream (GstRTSPMedia * media, const gchar * control)
1357 {
1358   GstRTSPMediaPrivate *priv;
1359   GstRTSPStream *res;
1360   gint i;
1361
1362   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
1363   g_return_val_if_fail (control != NULL, NULL);
1364
1365   priv = media->priv;
1366
1367   res = NULL;
1368
1369   g_mutex_lock (&priv->lock);
1370   for (i = 0; i < priv->streams->len; i++) {
1371     GstRTSPStream *test;
1372
1373     test = g_ptr_array_index (priv->streams, i);
1374     if (gst_rtsp_stream_has_control (test, control)) {
1375       res = test;
1376       break;
1377     }
1378   }
1379   g_mutex_unlock (&priv->lock);
1380
1381   return res;
1382 }
1383
1384 /* called with state-lock */
1385 static gboolean
1386 default_convert_range (GstRTSPMedia * media, GstRTSPTimeRange * range,
1387     GstRTSPRangeUnit unit)
1388 {
1389   return gst_rtsp_range_convert_units (range, unit);
1390 }
1391
1392 /**
1393  * gst_rtsp_media_get_range_string:
1394  * @media: a #GstRTSPMedia
1395  * @play: for the PLAY request
1396  * @unit: the unit to use for the string
1397  *
1398  * Get the current range as a string. @media must be prepared with
1399  * gst_rtsp_media_prepare ().
1400  *
1401  * Returns: The range as a string, g_free() after usage.
1402  */
1403 gchar *
1404 gst_rtsp_media_get_range_string (GstRTSPMedia * media, gboolean play,
1405     GstRTSPRangeUnit unit)
1406 {
1407   GstRTSPMediaClass *klass;
1408   GstRTSPMediaPrivate *priv;
1409   gchar *result;
1410   GstRTSPTimeRange range;
1411
1412   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1413   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
1414   g_return_val_if_fail (klass->convert_range != NULL, FALSE);
1415
1416   priv = media->priv;
1417
1418   g_rec_mutex_lock (&priv->state_lock);
1419   if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED &&
1420       priv->status != GST_RTSP_MEDIA_STATUS_SUSPENDED)
1421     goto not_prepared;
1422
1423   g_mutex_lock (&priv->lock);
1424
1425   /* Update the range value with current position/duration */
1426   collect_media_stats (media);
1427
1428   /* make copy */
1429   range = priv->range;
1430
1431   if (!play && priv->n_active > 0) {
1432     range.min.type = GST_RTSP_TIME_NOW;
1433     range.min.seconds = -1;
1434   }
1435   g_mutex_unlock (&priv->lock);
1436   g_rec_mutex_unlock (&priv->state_lock);
1437
1438   if (!klass->convert_range (media, &range, unit))
1439     goto conversion_failed;
1440
1441   result = gst_rtsp_range_to_string (&range);
1442
1443   return result;
1444
1445   /* ERRORS */
1446 not_prepared:
1447   {
1448     GST_WARNING ("media %p was not prepared", media);
1449     g_rec_mutex_unlock (&priv->state_lock);
1450     return NULL;
1451   }
1452 conversion_failed:
1453   {
1454     GST_WARNING ("range conversion to unit %d failed", unit);
1455     return NULL;
1456   }
1457 }
1458
1459 static void
1460 stream_update_blocked (GstRTSPStream * stream, GstRTSPMedia * media)
1461 {
1462   gst_rtsp_stream_set_blocked (stream, media->priv->blocked);
1463 }
1464
1465 static void
1466 media_streams_set_blocked (GstRTSPMedia * media, gboolean blocked)
1467 {
1468   GstRTSPMediaPrivate *priv = media->priv;
1469
1470   GST_DEBUG ("media %p set blocked %d", media, blocked);
1471   priv->blocked = blocked;
1472   g_ptr_array_foreach (priv->streams, (GFunc) stream_update_blocked, media);
1473 }
1474
1475 /**
1476  * gst_rtsp_media_seek:
1477  * @media: a #GstRTSPMedia
1478  * @range: a #GstRTSPTimeRange
1479  *
1480  * Seek the pipeline of @media to @range. @media must be prepared with
1481  * gst_rtsp_media_prepare().
1482  *
1483  * Returns: %TRUE on success.
1484  */
1485 gboolean
1486 gst_rtsp_media_seek (GstRTSPMedia * media, GstRTSPTimeRange * range)
1487 {
1488   GstRTSPMediaClass *klass;
1489   GstRTSPMediaPrivate *priv;
1490   GstSeekFlags flags;
1491   gboolean res;
1492   GstClockTime start, stop;
1493   GstSeekType start_type, stop_type;
1494   GstQuery *query;
1495
1496   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1497
1498   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
1499   g_return_val_if_fail (range != NULL, FALSE);
1500   g_return_val_if_fail (klass->convert_range != NULL, FALSE);
1501
1502   priv = media->priv;
1503
1504   g_rec_mutex_lock (&priv->state_lock);
1505   if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
1506     goto not_prepared;
1507
1508   /* Update the seekable state of the pipeline in case it changed */
1509   query = gst_query_new_seeking (GST_FORMAT_TIME);
1510   if (gst_element_query (priv->pipeline, query)) {
1511     GstFormat format;
1512     gboolean seekable;
1513     gint64 start, end;
1514
1515     gst_query_parse_seeking (query, &format, &seekable, &start, &end);
1516     priv->seekable = seekable;
1517   }
1518   gst_query_unref (query);
1519
1520   if (!priv->seekable)
1521     goto not_seekable;
1522
1523   /* depends on the current playing state of the pipeline. We might need to
1524    * queue this until we get EOS. */
1525   flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT;
1526
1527   start_type = stop_type = GST_SEEK_TYPE_NONE;
1528
1529   if (!klass->convert_range (media, range, GST_RTSP_RANGE_NPT))
1530     goto not_supported;
1531   gst_rtsp_range_get_times (range, &start, &stop);
1532
1533   GST_INFO ("got %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
1534       GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
1535   GST_INFO ("current %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
1536       GST_TIME_ARGS (priv->range_start), GST_TIME_ARGS (priv->range_stop));
1537
1538   if (priv->range_start == start)
1539     start = GST_CLOCK_TIME_NONE;
1540   else if (start != GST_CLOCK_TIME_NONE)
1541     start_type = GST_SEEK_TYPE_SET;
1542
1543   if (priv->range_stop == stop)
1544     stop = GST_CLOCK_TIME_NONE;
1545   else if (stop != GST_CLOCK_TIME_NONE)
1546     stop_type = GST_SEEK_TYPE_SET;
1547
1548   if (start != GST_CLOCK_TIME_NONE || stop != GST_CLOCK_TIME_NONE) {
1549     GST_INFO ("seeking to %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
1550         GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
1551
1552     priv->status = GST_RTSP_MEDIA_STATUS_PREPARING;
1553     if (priv->blocked)
1554       media_streams_set_blocked (media, TRUE);
1555
1556     res = gst_element_seek (priv->pipeline, 1.0, GST_FORMAT_TIME,
1557         flags, start_type, start, stop_type, stop);
1558
1559     /* and block for the seek to complete */
1560     GST_INFO ("done seeking %d", res);
1561     g_rec_mutex_unlock (&priv->state_lock);
1562
1563     /* wait until pipeline is prerolled again, this will also collect stats */
1564     if (!wait_preroll (media))
1565       goto preroll_failed;
1566
1567     g_rec_mutex_lock (&priv->state_lock);
1568     GST_INFO ("prerolled again");
1569   } else {
1570     GST_INFO ("no seek needed");
1571     res = TRUE;
1572   }
1573   g_rec_mutex_unlock (&priv->state_lock);
1574
1575   return res;
1576
1577   /* ERRORS */
1578 not_prepared:
1579   {
1580     g_rec_mutex_unlock (&priv->state_lock);
1581     GST_INFO ("media %p is not prepared", media);
1582     return FALSE;
1583   }
1584 not_seekable:
1585   {
1586     g_rec_mutex_unlock (&priv->state_lock);
1587     GST_INFO ("pipeline is not seekable");
1588     return FALSE;
1589   }
1590 not_supported:
1591   {
1592     g_rec_mutex_unlock (&priv->state_lock);
1593     GST_WARNING ("conversion to npt not supported");
1594     return FALSE;
1595   }
1596 preroll_failed:
1597   {
1598     GST_WARNING ("failed to preroll after seek");
1599     return FALSE;
1600   }
1601 }
1602
1603 static void
1604 gst_rtsp_media_set_status (GstRTSPMedia * media, GstRTSPMediaStatus status)
1605 {
1606   GstRTSPMediaPrivate *priv = media->priv;
1607
1608   g_mutex_lock (&priv->lock);
1609   priv->status = status;
1610   GST_DEBUG ("setting new status to %d", status);
1611   g_cond_broadcast (&priv->cond);
1612   g_mutex_unlock (&priv->lock);
1613 }
1614
1615 /**
1616  * gst_rtsp_media_get_status:
1617  * @media: a #GstRTSPMedia
1618  *
1619  * Get the status of @media. When @media is busy preparing, this function waits
1620  * until @media is prepared or in error.
1621  *
1622  * Returns: the status of @media.
1623  */
1624 GstRTSPMediaStatus
1625 gst_rtsp_media_get_status (GstRTSPMedia * media)
1626 {
1627   GstRTSPMediaPrivate *priv = media->priv;
1628   GstRTSPMediaStatus result;
1629   gint64 end_time;
1630
1631   g_mutex_lock (&priv->lock);
1632   end_time = g_get_monotonic_time () + 20 * G_TIME_SPAN_SECOND;
1633   /* while we are preparing, wait */
1634   while (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING) {
1635     GST_DEBUG ("waiting for status change");
1636     if (!g_cond_wait_until (&priv->cond, &priv->lock, end_time)) {
1637       GST_DEBUG ("timeout, assuming error status");
1638       priv->status = GST_RTSP_MEDIA_STATUS_ERROR;
1639     }
1640   }
1641   /* could be success or error */
1642   result = priv->status;
1643   GST_DEBUG ("got status %d", result);
1644   g_mutex_unlock (&priv->lock);
1645
1646   return result;
1647 }
1648
1649 static void
1650 stream_collect_blocking (GstRTSPStream * stream, gboolean * blocked)
1651 {
1652   *blocked &= gst_rtsp_stream_is_blocking (stream);
1653 }
1654
1655 static gboolean
1656 media_streams_blocking (GstRTSPMedia * media)
1657 {
1658   gboolean blocking = TRUE;
1659
1660   g_ptr_array_foreach (media->priv->streams, (GFunc) stream_collect_blocking,
1661       &blocking);
1662
1663   return blocking;
1664 }
1665
1666 static GstStateChangeReturn
1667 set_state (GstRTSPMedia * media, GstState state)
1668 {
1669   GstRTSPMediaPrivate *priv = media->priv;
1670   GstStateChangeReturn ret;
1671
1672   GST_INFO ("set state to %s for media %p", gst_element_state_get_name (state),
1673       media);
1674   ret = gst_element_set_state (priv->pipeline, state);
1675
1676   return ret;
1677 }
1678
1679 static GstStateChangeReturn
1680 set_target_state (GstRTSPMedia * media, GstState state, gboolean do_state)
1681 {
1682   GstRTSPMediaPrivate *priv = media->priv;
1683   GstStateChangeReturn ret;
1684
1685   GST_INFO ("set target state to %s for media %p",
1686       gst_element_state_get_name (state), media);
1687   priv->target_state = state;
1688
1689   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_TARGET_STATE], 0,
1690       priv->target_state, NULL);
1691
1692   if (do_state)
1693     ret = set_state (media, state);
1694   else
1695     ret = GST_STATE_CHANGE_SUCCESS;
1696
1697   return ret;
1698 }
1699
1700 /* called with state-lock */
1701 static gboolean
1702 default_handle_message (GstRTSPMedia * media, GstMessage * message)
1703 {
1704   GstRTSPMediaPrivate *priv = media->priv;
1705   GstMessageType type;
1706
1707   type = GST_MESSAGE_TYPE (message);
1708
1709   switch (type) {
1710     case GST_MESSAGE_STATE_CHANGED:
1711       break;
1712     case GST_MESSAGE_BUFFERING:
1713     {
1714       gint percent;
1715
1716       gst_message_parse_buffering (message, &percent);
1717
1718       /* no state management needed for live pipelines */
1719       if (priv->is_live)
1720         break;
1721
1722       if (percent == 100) {
1723         /* a 100% message means buffering is done */
1724         priv->buffering = FALSE;
1725         /* if the desired state is playing, go back */
1726         if (priv->target_state == GST_STATE_PLAYING) {
1727           GST_INFO ("Buffering done, setting pipeline to PLAYING");
1728           set_state (media, GST_STATE_PLAYING);
1729         } else {
1730           GST_INFO ("Buffering done");
1731         }
1732       } else {
1733         /* buffering busy */
1734         if (priv->buffering == FALSE) {
1735           if (priv->target_state == GST_STATE_PLAYING) {
1736             /* we were not buffering but PLAYING, PAUSE  the pipeline. */
1737             GST_INFO ("Buffering, setting pipeline to PAUSED ...");
1738             set_state (media, GST_STATE_PAUSED);
1739           } else {
1740             GST_INFO ("Buffering ...");
1741           }
1742         }
1743         priv->buffering = TRUE;
1744       }
1745       break;
1746     }
1747     case GST_MESSAGE_LATENCY:
1748     {
1749       gst_bin_recalculate_latency (GST_BIN_CAST (priv->pipeline));
1750       break;
1751     }
1752     case GST_MESSAGE_ERROR:
1753     {
1754       GError *gerror;
1755       gchar *debug;
1756
1757       gst_message_parse_error (message, &gerror, &debug);
1758       GST_WARNING ("%p: got error %s (%s)", media, gerror->message, debug);
1759       g_error_free (gerror);
1760       g_free (debug);
1761
1762       gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
1763       break;
1764     }
1765     case GST_MESSAGE_WARNING:
1766     {
1767       GError *gerror;
1768       gchar *debug;
1769
1770       gst_message_parse_warning (message, &gerror, &debug);
1771       GST_WARNING ("%p: got warning %s (%s)", media, gerror->message, debug);
1772       g_error_free (gerror);
1773       g_free (debug);
1774       break;
1775     }
1776     case GST_MESSAGE_ELEMENT:
1777     {
1778       const GstStructure *s;
1779
1780       s = gst_message_get_structure (message);
1781       if (gst_structure_has_name (s, "GstRTSPStreamBlocking")) {
1782         GST_DEBUG ("media received blocking message");
1783         if (priv->blocked && media_streams_blocking (media)) {
1784           GST_DEBUG ("media is blocking");
1785           collect_media_stats (media);
1786
1787           if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING)
1788             gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
1789         }
1790       }
1791       break;
1792     }
1793     case GST_MESSAGE_STREAM_STATUS:
1794       break;
1795     case GST_MESSAGE_ASYNC_DONE:
1796       if (priv->adding) {
1797         /* when we are dynamically adding pads, the addition of the udpsrc will
1798          * temporarily produce ASYNC_DONE messages. We have to ignore them and
1799          * wait for the final ASYNC_DONE after everything prerolled */
1800         GST_INFO ("%p: ignoring ASYNC_DONE", media);
1801       } else {
1802         GST_INFO ("%p: got ASYNC_DONE", media);
1803         collect_media_stats (media);
1804
1805         if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING)
1806           gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
1807       }
1808       break;
1809     case GST_MESSAGE_EOS:
1810       GST_INFO ("%p: got EOS", media);
1811
1812       if (priv->status == GST_RTSP_MEDIA_STATUS_UNPREPARING) {
1813         GST_DEBUG ("shutting down after EOS");
1814         finish_unprepare (media);
1815       }
1816       break;
1817     default:
1818       GST_INFO ("%p: got message type %d (%s)", media, type,
1819           gst_message_type_get_name (type));
1820       break;
1821   }
1822   return TRUE;
1823 }
1824
1825 static gboolean
1826 bus_message (GstBus * bus, GstMessage * message, GstRTSPMedia * media)
1827 {
1828   GstRTSPMediaPrivate *priv = media->priv;
1829   GstRTSPMediaClass *klass;
1830   gboolean ret;
1831
1832   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1833
1834   g_rec_mutex_lock (&priv->state_lock);
1835   if (klass->handle_message)
1836     ret = klass->handle_message (media, message);
1837   else
1838     ret = FALSE;
1839   g_rec_mutex_unlock (&priv->state_lock);
1840
1841   return ret;
1842 }
1843
1844 static void
1845 watch_destroyed (GstRTSPMedia * media)
1846 {
1847   GST_DEBUG_OBJECT (media, "source destroyed");
1848   g_object_unref (media);
1849 }
1850
1851 static GstElement *
1852 find_payload_element (GstElement * payloader)
1853 {
1854   GstElement *pay = NULL;
1855
1856   if (GST_IS_BIN (payloader)) {
1857     GstIterator *iter;
1858     GValue item = { 0 };
1859
1860     iter = gst_bin_iterate_recurse (GST_BIN (payloader));
1861     while (gst_iterator_next (iter, &item) == GST_ITERATOR_OK) {
1862       GstElement *element = (GstElement *) g_value_get_object (&item);
1863       GstElementClass *eclass = GST_ELEMENT_GET_CLASS (element);
1864       const gchar *klass;
1865
1866       klass =
1867           gst_element_class_get_metadata (eclass, GST_ELEMENT_METADATA_KLASS);
1868       if (klass == NULL)
1869         continue;
1870
1871       if (strstr (klass, "Payloader") && strstr (klass, "RTP")) {
1872         pay = gst_object_ref (element);
1873         g_value_unset (&item);
1874         break;
1875       }
1876       g_value_unset (&item);
1877     }
1878     gst_iterator_free (iter);
1879   } else {
1880     pay = g_object_ref (payloader);
1881   }
1882
1883   return pay;
1884 }
1885
1886 /* called from streaming threads */
1887 static void
1888 pad_added_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
1889 {
1890   GstRTSPMediaPrivate *priv = media->priv;
1891   GstRTSPStream *stream;
1892   GstElement *pay;
1893
1894   /* find the real payload element */
1895   pay = find_payload_element (element);
1896   stream = gst_rtsp_media_create_stream (media, pay, pad);
1897   gst_object_unref (pay);
1898
1899   g_object_set_data (G_OBJECT (pad), "gst-rtsp-dynpad-stream", stream);
1900
1901   GST_INFO ("pad added %s:%s, stream %p", GST_DEBUG_PAD_NAME (pad), stream);
1902
1903   g_rec_mutex_lock (&priv->state_lock);
1904   /* we will be adding elements below that will cause ASYNC_DONE to be
1905    * posted in the bus. We want to ignore those messages until the
1906    * pipeline really prerolled. */
1907   priv->adding = TRUE;
1908
1909   /* join the element in the PAUSED state because this callback is
1910    * called from the streaming thread and it is PAUSED */
1911   gst_rtsp_stream_join_bin (stream, GST_BIN (priv->pipeline),
1912       priv->rtpbin, GST_STATE_PAUSED);
1913
1914   priv->adding = FALSE;
1915   g_rec_mutex_unlock (&priv->state_lock);
1916 }
1917
1918 static void
1919 pad_removed_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
1920 {
1921   GstRTSPMediaPrivate *priv = media->priv;
1922   GstRTSPStream *stream;
1923
1924   stream = g_object_get_data (G_OBJECT (pad), "gst-rtsp-dynpad-stream");
1925   if (stream == NULL)
1926     return;
1927
1928   GST_INFO ("pad removed %s:%s, stream %p", GST_DEBUG_PAD_NAME (pad), stream);
1929
1930   g_rec_mutex_lock (&priv->state_lock);
1931   gst_rtsp_stream_leave_bin (stream, GST_BIN (priv->pipeline), priv->rtpbin);
1932   g_rec_mutex_unlock (&priv->state_lock);
1933
1934   gst_rtsp_media_remove_stream (media, stream);
1935 }
1936
1937 static void
1938 remove_fakesink (GstRTSPMediaPrivate * priv)
1939 {
1940   GstElement *fakesink;
1941
1942   g_mutex_lock (&priv->lock);
1943   if ((fakesink = priv->fakesink))
1944     gst_object_ref (fakesink);
1945   priv->fakesink = NULL;
1946   g_mutex_unlock (&priv->lock);
1947
1948   if (fakesink) {
1949     gst_bin_remove (GST_BIN (priv->pipeline), fakesink);
1950     gst_element_set_state (fakesink, GST_STATE_NULL);
1951     gst_object_unref (fakesink);
1952     GST_INFO ("removed fakesink");
1953   }
1954 }
1955
1956 static void
1957 no_more_pads_cb (GstElement * element, GstRTSPMedia * media)
1958 {
1959   GstRTSPMediaPrivate *priv = media->priv;
1960
1961   GST_INFO ("no more pads");
1962   remove_fakesink (priv);
1963 }
1964
1965 typedef struct _DynPaySignalHandlers DynPaySignalHandlers;
1966
1967 struct _DynPaySignalHandlers
1968 {
1969   gulong pad_added_handler;
1970   gulong pad_removed_handler;
1971   gulong no_more_pads_handler;
1972 };
1973
1974 static gboolean
1975 start_preroll (GstRTSPMedia * media)
1976 {
1977   GstRTSPMediaPrivate *priv = media->priv;
1978   GstStateChangeReturn ret;
1979
1980   GST_INFO ("setting pipeline to PAUSED for media %p", media);
1981   /* first go to PAUSED */
1982   ret = set_target_state (media, GST_STATE_PAUSED, TRUE);
1983
1984   switch (ret) {
1985     case GST_STATE_CHANGE_SUCCESS:
1986       GST_INFO ("SUCCESS state change for media %p", media);
1987       priv->seekable = TRUE;
1988       break;
1989     case GST_STATE_CHANGE_ASYNC:
1990       GST_INFO ("ASYNC state change for media %p", media);
1991       priv->seekable = TRUE;
1992       break;
1993     case GST_STATE_CHANGE_NO_PREROLL:
1994       /* we need to go to PLAYING */
1995       GST_INFO ("NO_PREROLL state change: live media %p", media);
1996       /* FIXME we disable seeking for live streams for now. We should perform a
1997        * seeking query in preroll instead */
1998       priv->seekable = FALSE;
1999       priv->is_live = TRUE;
2000       /* start blocked  to make sure nothing goes to the sink */
2001       media_streams_set_blocked (media, TRUE);
2002       ret = set_state (media, GST_STATE_PLAYING);
2003       if (ret == GST_STATE_CHANGE_FAILURE)
2004         goto state_failed;
2005       break;
2006     case GST_STATE_CHANGE_FAILURE:
2007       goto state_failed;
2008   }
2009
2010   return TRUE;
2011
2012 state_failed:
2013   {
2014     GST_WARNING ("failed to preroll pipeline");
2015     return FALSE;
2016   }
2017 }
2018
2019 static gboolean
2020 wait_preroll (GstRTSPMedia * media)
2021 {
2022   GstRTSPMediaStatus status;
2023
2024   GST_DEBUG ("wait to preroll pipeline");
2025
2026   /* wait until pipeline is prerolled */
2027   status = gst_rtsp_media_get_status (media);
2028   if (status == GST_RTSP_MEDIA_STATUS_ERROR)
2029     goto preroll_failed;
2030
2031   return TRUE;
2032
2033 preroll_failed:
2034   {
2035     GST_WARNING ("failed to preroll pipeline");
2036     return FALSE;
2037   }
2038 }
2039
2040 static gboolean
2041 start_prepare (GstRTSPMedia * media)
2042 {
2043   GstRTSPMediaPrivate *priv = media->priv;
2044   guint i;
2045   GList *walk;
2046
2047   /* link streams we already have, other streams might appear when we have
2048    * dynamic elements */
2049   for (i = 0; i < priv->streams->len; i++) {
2050     GstRTSPStream *stream;
2051
2052     stream = g_ptr_array_index (priv->streams, i);
2053
2054     gst_rtsp_stream_join_bin (stream, GST_BIN (priv->pipeline),
2055         priv->rtpbin, GST_STATE_NULL);
2056   }
2057
2058   for (walk = priv->dynamic; walk; walk = g_list_next (walk)) {
2059     GstElement *elem = walk->data;
2060     DynPaySignalHandlers *handlers = g_slice_new (DynPaySignalHandlers);
2061
2062     GST_INFO ("adding callbacks for dynamic element %p", elem);
2063
2064     handlers->pad_added_handler = g_signal_connect (elem, "pad-added",
2065         (GCallback) pad_added_cb, media);
2066     handlers->pad_removed_handler = g_signal_connect (elem, "pad-removed",
2067         (GCallback) pad_removed_cb, media);
2068     handlers->no_more_pads_handler = g_signal_connect (elem, "no-more-pads",
2069         (GCallback) no_more_pads_cb, media);
2070
2071     g_object_set_data (G_OBJECT (elem), "gst-rtsp-dynpay-handlers", handlers);
2072
2073     /* we add a fakesink here in order to make the state change async. We remove
2074      * the fakesink again in the no-more-pads callback. */
2075     priv->fakesink = gst_element_factory_make ("fakesink", "fakesink");
2076     gst_bin_add (GST_BIN (priv->pipeline), priv->fakesink);
2077   }
2078
2079   if (!start_preroll (media))
2080     goto preroll_failed;
2081
2082   return FALSE;
2083
2084 preroll_failed:
2085   {
2086     GST_WARNING ("failed to preroll pipeline");
2087     gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
2088     return FALSE;
2089   }
2090 }
2091
2092 /**
2093  * gst_rtsp_media_prepare:
2094  * @media: a #GstRTSPMedia
2095  * @thread: a #GstRTSPThread to run the bus handler or %NULL
2096  *
2097  * Prepare @media for streaming. This function will create the objects
2098  * to manage the streaming. A pipeline must have been set on @media with
2099  * gst_rtsp_media_take_pipeline().
2100  *
2101  * It will preroll the pipeline and collect vital information about the streams
2102  * such as the duration.
2103  *
2104  * Returns: %TRUE on success.
2105  */
2106 gboolean
2107 gst_rtsp_media_prepare (GstRTSPMedia * media, GstRTSPThread * thread)
2108 {
2109   GstRTSPMediaPrivate *priv;
2110   GstBus *bus;
2111   GSource *source;
2112   GstRTSPMediaClass *klass;
2113
2114   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2115   g_return_val_if_fail (GST_IS_RTSP_THREAD (thread), FALSE);
2116
2117   priv = media->priv;
2118
2119   g_rec_mutex_lock (&priv->state_lock);
2120   priv->prepare_count++;
2121
2122   if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARED ||
2123       priv->status == GST_RTSP_MEDIA_STATUS_SUSPENDED)
2124     goto was_prepared;
2125
2126   if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARING)
2127     goto wait_status;
2128
2129   if (priv->status != GST_RTSP_MEDIA_STATUS_UNPREPARED)
2130     goto not_unprepared;
2131
2132   if (!priv->reusable && priv->reused)
2133     goto is_reused;
2134
2135   klass = GST_RTSP_MEDIA_GET_CLASS (media);
2136
2137   if (!klass->create_rtpbin)
2138     goto no_create_rtpbin;
2139
2140   priv->rtpbin = klass->create_rtpbin (media);
2141   if (priv->rtpbin != NULL) {
2142     gboolean success = TRUE;
2143
2144     if (klass->setup_rtpbin)
2145       success = klass->setup_rtpbin (media, priv->rtpbin);
2146
2147     if (success == FALSE) {
2148       gst_object_unref (priv->rtpbin);
2149       priv->rtpbin = NULL;
2150     }
2151   }
2152   if (priv->rtpbin == NULL)
2153     goto no_rtpbin;
2154
2155   GST_INFO ("preparing media %p", media);
2156
2157   /* reset some variables */
2158   priv->is_live = FALSE;
2159   priv->seekable = FALSE;
2160   priv->buffering = FALSE;
2161   priv->thread = thread;
2162   /* we're preparing now */
2163   priv->status = GST_RTSP_MEDIA_STATUS_PREPARING;
2164
2165   bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (priv->pipeline));
2166
2167   /* add the pipeline bus to our custom mainloop */
2168   priv->source = gst_bus_create_watch (bus);
2169   gst_object_unref (bus);
2170
2171   g_source_set_callback (priv->source, (GSourceFunc) bus_message,
2172       g_object_ref (media), (GDestroyNotify) watch_destroyed);
2173
2174   priv->id = g_source_attach (priv->source, thread->context);
2175
2176   /* add stuff to the bin */
2177   gst_bin_add (GST_BIN (priv->pipeline), priv->rtpbin);
2178
2179   /* do remainder in context */
2180   source = g_idle_source_new ();
2181   g_source_set_callback (source, (GSourceFunc) start_prepare, media, NULL);
2182   g_source_attach (source, thread->context);
2183   g_source_unref (source);
2184
2185 wait_status:
2186   g_rec_mutex_unlock (&priv->state_lock);
2187
2188   /* now wait for all pads to be prerolled, FIXME, we should somehow be
2189    * able to do this async so that we don't block the server thread. */
2190   if (!wait_preroll (media))
2191     goto preroll_failed;
2192
2193   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_PREPARED], 0, NULL);
2194
2195   GST_INFO ("object %p is prerolled", media);
2196
2197   return TRUE;
2198
2199   /* OK */
2200 was_prepared:
2201   {
2202     GST_LOG ("media %p was prepared", media);
2203     g_rec_mutex_unlock (&priv->state_lock);
2204     return TRUE;
2205   }
2206   /* ERRORS */
2207 not_unprepared:
2208   {
2209     GST_WARNING ("media %p was not unprepared", media);
2210     priv->prepare_count--;
2211     g_rec_mutex_unlock (&priv->state_lock);
2212     return FALSE;
2213   }
2214 is_reused:
2215   {
2216     priv->prepare_count--;
2217     g_rec_mutex_unlock (&priv->state_lock);
2218     GST_WARNING ("can not reuse media %p", media);
2219     return FALSE;
2220   }
2221 no_create_rtpbin:
2222   {
2223     priv->prepare_count--;
2224     g_rec_mutex_unlock (&priv->state_lock);
2225     GST_ERROR ("no create_rtpbin function");
2226     g_critical ("no create_rtpbin vmethod function set");
2227     return FALSE;
2228   }
2229 no_rtpbin:
2230   {
2231     priv->prepare_count--;
2232     g_rec_mutex_unlock (&priv->state_lock);
2233     GST_WARNING ("no rtpbin element");
2234     g_warning ("failed to create element 'rtpbin', check your installation");
2235     return FALSE;
2236   }
2237 preroll_failed:
2238   {
2239     GST_WARNING ("failed to preroll pipeline");
2240     gst_rtsp_media_unprepare (media);
2241     return FALSE;
2242   }
2243 }
2244
2245 /* must be called with state-lock */
2246 static void
2247 finish_unprepare (GstRTSPMedia * media)
2248 {
2249   GstRTSPMediaPrivate *priv = media->priv;
2250   gint i;
2251   GList *walk;
2252
2253   GST_DEBUG ("shutting down");
2254
2255   set_state (media, GST_STATE_NULL);
2256   remove_fakesink (priv);
2257
2258   for (i = 0; i < priv->streams->len; i++) {
2259     GstRTSPStream *stream;
2260
2261     GST_INFO ("Removing elements of stream %d from pipeline", i);
2262
2263     stream = g_ptr_array_index (priv->streams, i);
2264
2265     gst_rtsp_stream_leave_bin (stream, GST_BIN (priv->pipeline), priv->rtpbin);
2266   }
2267
2268   /* remove the pad signal handlers */
2269   for (walk = priv->dynamic; walk; walk = g_list_next (walk)) {
2270     GstElement *elem = walk->data;
2271     DynPaySignalHandlers *handlers;
2272
2273     handlers =
2274         g_object_steal_data (G_OBJECT (elem), "gst-rtsp-dynpay-handlers");
2275     g_assert (handlers != NULL);
2276
2277     g_signal_handler_disconnect (G_OBJECT (elem), handlers->pad_added_handler);
2278     g_signal_handler_disconnect (G_OBJECT (elem),
2279         handlers->pad_removed_handler);
2280     g_signal_handler_disconnect (G_OBJECT (elem),
2281         handlers->no_more_pads_handler);
2282
2283     g_slice_free (DynPaySignalHandlers, handlers);
2284   }
2285
2286   gst_bin_remove (GST_BIN (priv->pipeline), priv->rtpbin);
2287   priv->rtpbin = NULL;
2288
2289   if (priv->nettime)
2290     gst_object_unref (priv->nettime);
2291   priv->nettime = NULL;
2292
2293   priv->reused = TRUE;
2294   priv->status = GST_RTSP_MEDIA_STATUS_UNPREPARED;
2295
2296   /* when the media is not reusable, this will effectively unref the media and
2297    * recreate it */
2298   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_UNPREPARED], 0, NULL);
2299
2300   /* the source has the last ref to the media */
2301   if (priv->source) {
2302     GST_DEBUG ("destroy source");
2303     g_source_destroy (priv->source);
2304     g_source_unref (priv->source);
2305   }
2306   if (priv->thread) {
2307     GST_DEBUG ("stop thread");
2308     gst_rtsp_thread_stop (priv->thread);
2309   }
2310 }
2311
2312 /* called with state-lock */
2313 static gboolean
2314 default_unprepare (GstRTSPMedia * media)
2315 {
2316   GstRTSPMediaPrivate *priv = media->priv;
2317
2318   if (priv->eos_shutdown) {
2319     GST_DEBUG ("sending EOS for shutdown");
2320     /* ref so that we don't disappear */
2321     gst_element_send_event (priv->pipeline, gst_event_new_eos ());
2322     /* we need to go to playing again for the EOS to propagate, normally in this
2323      * state, nothing is receiving data from us anymore so this is ok. */
2324     set_state (media, GST_STATE_PLAYING);
2325     priv->status = GST_RTSP_MEDIA_STATUS_UNPREPARING;
2326   } else {
2327     finish_unprepare (media);
2328   }
2329   return TRUE;
2330 }
2331
2332 /**
2333  * gst_rtsp_media_unprepare:
2334  * @media: a #GstRTSPMedia
2335  *
2336  * Unprepare @media. After this call, the media should be prepared again before
2337  * it can be used again. If the media is set to be non-reusable, a new instance
2338  * must be created.
2339  *
2340  * Returns: %TRUE on success.
2341  */
2342 gboolean
2343 gst_rtsp_media_unprepare (GstRTSPMedia * media)
2344 {
2345   GstRTSPMediaPrivate *priv;
2346   gboolean success;
2347
2348   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2349
2350   priv = media->priv;
2351
2352   g_rec_mutex_lock (&priv->state_lock);
2353   if (priv->status == GST_RTSP_MEDIA_STATUS_UNPREPARED)
2354     goto was_unprepared;
2355
2356   priv->prepare_count--;
2357   if (priv->prepare_count > 0)
2358     goto is_busy;
2359
2360   GST_INFO ("unprepare media %p", media);
2361   set_target_state (media, GST_STATE_NULL, FALSE);
2362   success = TRUE;
2363
2364   if (priv->status == GST_RTSP_MEDIA_STATUS_PREPARED) {
2365     GstRTSPMediaClass *klass;
2366
2367     klass = GST_RTSP_MEDIA_GET_CLASS (media);
2368     if (klass->unprepare)
2369       success = klass->unprepare (media);
2370   } else {
2371     finish_unprepare (media);
2372   }
2373   g_rec_mutex_unlock (&priv->state_lock);
2374
2375   return success;
2376
2377 was_unprepared:
2378   {
2379     g_rec_mutex_unlock (&priv->state_lock);
2380     GST_INFO ("media %p was already unprepared", media);
2381     return TRUE;
2382   }
2383 is_busy:
2384   {
2385     GST_INFO ("media %p still prepared %d times", media, priv->prepare_count);
2386     g_rec_mutex_unlock (&priv->state_lock);
2387     return TRUE;
2388   }
2389 }
2390
2391 /* should be called with state-lock */
2392 static GstClock *
2393 get_clock_unlocked (GstRTSPMedia * media)
2394 {
2395   if (media->priv->status != GST_RTSP_MEDIA_STATUS_PREPARED) {
2396     GST_DEBUG_OBJECT (media, "media was not prepared");
2397     return NULL;
2398   }
2399   return gst_pipeline_get_clock (GST_PIPELINE_CAST (media->priv->pipeline));
2400 }
2401
2402 /**
2403  * gst_rtsp_media_get_clock:
2404  * @media: a #GstRTSPMedia
2405  *
2406  * Get the clock that is used by the pipeline in @media.
2407  *
2408  * @media must be prepared before this method returns a valid clock object.
2409  *
2410  * Returns: (transfer full): the #GstClock used by @media. unref after usage.
2411  */
2412 GstClock *
2413 gst_rtsp_media_get_clock (GstRTSPMedia * media)
2414 {
2415   GstClock *clock;
2416   GstRTSPMediaPrivate *priv;
2417
2418   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
2419
2420   priv = media->priv;
2421
2422   g_rec_mutex_lock (&priv->state_lock);
2423   clock = get_clock_unlocked (media);
2424   g_rec_mutex_unlock (&priv->state_lock);
2425
2426   return clock;
2427 }
2428
2429 /**
2430  * gst_rtsp_media_get_base_time:
2431  * @media: a #GstRTSPMedia
2432  *
2433  * Get the base_time that is used by the pipeline in @media.
2434  *
2435  * @media must be prepared before this method returns a valid base_time.
2436  *
2437  * Returns: the base_time used by @media.
2438  */
2439 GstClockTime
2440 gst_rtsp_media_get_base_time (GstRTSPMedia * media)
2441 {
2442   GstClockTime result;
2443   GstRTSPMediaPrivate *priv;
2444
2445   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), GST_CLOCK_TIME_NONE);
2446
2447   priv = media->priv;
2448
2449   g_rec_mutex_lock (&priv->state_lock);
2450   if (media->priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
2451     goto not_prepared;
2452
2453   result = gst_element_get_base_time (media->priv->pipeline);
2454   g_rec_mutex_unlock (&priv->state_lock);
2455
2456   return result;
2457
2458   /* ERRORS */
2459 not_prepared:
2460   {
2461     g_rec_mutex_unlock (&priv->state_lock);
2462     GST_DEBUG_OBJECT (media, "media was not prepared");
2463     return GST_CLOCK_TIME_NONE;
2464   }
2465 }
2466
2467 /**
2468  * gst_rtsp_media_get_time_provider:
2469  * @media: a #GstRTSPMedia
2470  * @address: an address or %NULL
2471  * @port: a port or 0
2472  *
2473  * Get the #GstNetTimeProvider for the clock used by @media. The time provider
2474  * will listen on @address and @port for client time requests.
2475  *
2476  * Returns: (transfer full): the #GstNetTimeProvider of @media.
2477  */
2478 GstNetTimeProvider *
2479 gst_rtsp_media_get_time_provider (GstRTSPMedia * media, const gchar * address,
2480     guint16 port)
2481 {
2482   GstRTSPMediaPrivate *priv;
2483   GstNetTimeProvider *provider = NULL;
2484
2485   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
2486
2487   priv = media->priv;
2488
2489   g_rec_mutex_lock (&priv->state_lock);
2490   if (priv->time_provider) {
2491     if ((provider = priv->nettime) == NULL) {
2492       GstClock *clock;
2493
2494       if (priv->time_provider && (clock = get_clock_unlocked (media))) {
2495         provider = gst_net_time_provider_new (clock, address, port);
2496         gst_object_unref (clock);
2497
2498         priv->nettime = provider;
2499       }
2500     }
2501   }
2502   g_rec_mutex_unlock (&priv->state_lock);
2503
2504   if (provider)
2505     gst_object_ref (provider);
2506
2507   return provider;
2508 }
2509
2510 static gboolean
2511 default_setup_sdp (GstRTSPMedia * media, GstSDPMessage * sdp, GstSDPInfo * info)
2512 {
2513   return gst_rtsp_sdp_from_media (sdp, info, media);
2514 }
2515
2516 /**
2517  * gst_rtsp_media_setup_sdp:
2518  * @sdp: a #GstSDPMessage
2519  * @info: info
2520  * @media: a #GstRTSPMedia
2521  *
2522  * Add @media specific info to @sdp. @info is used to configure the connection
2523  * information in the SDP.
2524  *
2525  * Returns: TRUE on success.
2526  */
2527 gboolean
2528 gst_rtsp_media_setup_sdp (GstRTSPMedia * media, GstSDPMessage * sdp,
2529     GstSDPInfo * info)
2530 {
2531   GstRTSPMediaPrivate *priv;
2532   GstRTSPMediaClass *klass;
2533   gboolean res;
2534
2535   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2536   g_return_val_if_fail (sdp != NULL, FALSE);
2537   g_return_val_if_fail (info != NULL, FALSE);
2538
2539   priv = media->priv;
2540
2541   g_rec_mutex_lock (&priv->state_lock);
2542
2543   klass = GST_RTSP_MEDIA_GET_CLASS (media);
2544
2545   if (!klass->setup_sdp)
2546     goto no_setup_sdp;
2547
2548   res = klass->setup_sdp (media, sdp, info);
2549
2550   g_rec_mutex_unlock (&priv->state_lock);
2551
2552   return res;
2553
2554   /* ERRORS */
2555 no_setup_sdp:
2556   {
2557     g_rec_mutex_unlock (&priv->state_lock);
2558     GST_ERROR ("no setup_sdp function");
2559     g_critical ("no setup_sdp vmethod function set");
2560     return FALSE;
2561   }
2562 }
2563
2564 /**
2565  * gst_rtsp_media_suspend:
2566  * @media: a #GstRTSPMedia
2567  *
2568  * Suspend @media. The state of the pipeline managed by @media is set to
2569  * GST_STATE_NULL but all streams are kept. @media can be prepared again
2570  * with gst_rtsp_media_undo_reset()
2571  *
2572  * @media must be prepared with gst_rtsp_media_prepare();
2573  *
2574  * Returns: %TRUE on success.
2575  */
2576 gboolean
2577 gst_rtsp_media_suspend (GstRTSPMedia * media)
2578 {
2579   GstRTSPMediaPrivate *priv = media->priv;
2580   GstStateChangeReturn ret;
2581
2582   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2583
2584   GST_FIXME ("suspend for dynamic pipelines needs fixing");
2585
2586   g_rec_mutex_lock (&priv->state_lock);
2587   if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED)
2588     goto not_prepared;
2589
2590   /* don't attempt to suspend when something is busy */
2591   if (priv->n_active > 0)
2592     goto done;
2593
2594   switch (priv->suspend_mode) {
2595     case GST_RTSP_SUSPEND_MODE_NONE:
2596       GST_DEBUG ("media %p no suspend", media);
2597       break;
2598     case GST_RTSP_SUSPEND_MODE_PAUSE:
2599       GST_DEBUG ("media %p suspend to PAUSED", media);
2600       ret = set_target_state (media, GST_STATE_PAUSED, TRUE);
2601       if (ret == GST_STATE_CHANGE_FAILURE)
2602         goto state_failed;
2603       break;
2604     case GST_RTSP_SUSPEND_MODE_RESET:
2605       GST_DEBUG ("media %p suspend to NULL", media);
2606       ret = set_target_state (media, GST_STATE_NULL, TRUE);
2607       if (ret == GST_STATE_CHANGE_FAILURE)
2608         goto state_failed;
2609       break;
2610     default:
2611       break;
2612   }
2613   /* let the streams do the state changes freely, if any */
2614   media_streams_set_blocked (media, FALSE);
2615   priv->status = GST_RTSP_MEDIA_STATUS_SUSPENDED;
2616 done:
2617   g_rec_mutex_unlock (&priv->state_lock);
2618
2619   return TRUE;
2620
2621   /* ERRORS */
2622 not_prepared:
2623   {
2624     g_rec_mutex_unlock (&priv->state_lock);
2625     GST_WARNING ("media %p was not prepared", media);
2626     return FALSE;
2627   }
2628 state_failed:
2629   {
2630     g_rec_mutex_unlock (&priv->state_lock);
2631     gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
2632     GST_WARNING ("failed changing pipeline's state for media %p", media);
2633     return FALSE;
2634   }
2635 }
2636
2637 /**
2638  * gst_rtsp_media_unsuspend:
2639  * @media: a #GstRTSPMedia
2640  *
2641  * Unsuspend @media if it was in a suspended state. This method does nothing
2642  * when the media was not in the suspended state.
2643  *
2644  * Returns: %TRUE on success.
2645  */
2646 gboolean
2647 gst_rtsp_media_unsuspend (GstRTSPMedia * media)
2648 {
2649   GstRTSPMediaPrivate *priv = media->priv;
2650
2651   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2652
2653   g_rec_mutex_lock (&priv->state_lock);
2654   if (priv->status != GST_RTSP_MEDIA_STATUS_SUSPENDED)
2655     goto done;
2656
2657   switch (priv->suspend_mode) {
2658     case GST_RTSP_SUSPEND_MODE_NONE:
2659       priv->status = GST_RTSP_MEDIA_STATUS_PREPARED;
2660       break;
2661     case GST_RTSP_SUSPEND_MODE_PAUSE:
2662       priv->status = GST_RTSP_MEDIA_STATUS_PREPARED;
2663       break;
2664     case GST_RTSP_SUSPEND_MODE_RESET:
2665     {
2666       priv->status = GST_RTSP_MEDIA_STATUS_PREPARING;
2667       if (!start_preroll (media))
2668         goto start_failed;
2669       g_rec_mutex_unlock (&priv->state_lock);
2670
2671       if (!wait_preroll (media))
2672         goto preroll_failed;
2673
2674       g_rec_mutex_lock (&priv->state_lock);
2675     }
2676     default:
2677       break;
2678   }
2679 done:
2680   g_rec_mutex_unlock (&priv->state_lock);
2681
2682   return TRUE;
2683
2684   /* ERRORS */
2685 start_failed:
2686   {
2687     g_rec_mutex_unlock (&priv->state_lock);
2688     GST_WARNING ("failed to preroll pipeline");
2689     gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
2690     return FALSE;
2691   }
2692 preroll_failed:
2693   {
2694     GST_WARNING ("failed to preroll pipeline");
2695     return FALSE;
2696   }
2697 }
2698
2699 /* must be called with state-lock */
2700 static void
2701 media_set_pipeline_state_locked (GstRTSPMedia * media, GstState state)
2702 {
2703   GstRTSPMediaPrivate *priv = media->priv;
2704
2705   if (state == GST_STATE_NULL) {
2706     gst_rtsp_media_unprepare (media);
2707   } else {
2708     GST_INFO ("state %s media %p", gst_element_state_get_name (state), media);
2709     set_target_state (media, state, FALSE);
2710     /* when we are buffering, don't update the state yet, this will be done
2711      * when buffering finishes */
2712     if (priv->buffering) {
2713       GST_INFO ("Buffering busy, delay state change");
2714     } else {
2715       if (state == GST_STATE_PLAYING)
2716         /* make sure pads are not blocking anymore when going to PLAYING */
2717         media_streams_set_blocked (media, FALSE);
2718
2719       set_state (media, state);
2720
2721       /* and suspend after pause */
2722       if (state == GST_STATE_PAUSED)
2723         gst_rtsp_media_suspend (media);
2724     }
2725   }
2726 }
2727
2728 /**
2729  * gst_rtsp_media_set_pipeline_state:
2730  * @media: a #GstRTSPMedia
2731  * @state: the target state of the pipeline
2732  *
2733  * Set the state of the pipeline managed by @media to @state
2734  */
2735 void
2736 gst_rtsp_media_set_pipeline_state (GstRTSPMedia * media, GstState state)
2737 {
2738   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
2739
2740   g_rec_mutex_lock (&media->priv->state_lock);
2741   media_set_pipeline_state_locked (media, state);
2742   g_rec_mutex_unlock (&media->priv->state_lock);
2743 }
2744
2745 /**
2746  * gst_rtsp_media_set_state:
2747  * @media: a #GstRTSPMedia
2748  * @state: the target state of the media
2749  * @transports: (element-type GstRtspServer.RTSPStreamTransport): a #GPtrArray
2750  * of #GstRTSPStreamTransport pointers
2751  *
2752  * Set the state of @media to @state and for the transports in @transports.
2753  *
2754  * @media must be prepared with gst_rtsp_media_prepare();
2755  *
2756  * Returns: %TRUE on success.
2757  */
2758 gboolean
2759 gst_rtsp_media_set_state (GstRTSPMedia * media, GstState state,
2760     GPtrArray * transports)
2761 {
2762   GstRTSPMediaPrivate *priv;
2763   gint i;
2764   gboolean activate, deactivate, do_state;
2765   gint old_active;
2766
2767   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
2768   g_return_val_if_fail (transports != NULL, FALSE);
2769
2770   priv = media->priv;
2771
2772   g_rec_mutex_lock (&priv->state_lock);
2773   if (priv->status == GST_RTSP_MEDIA_STATUS_ERROR)
2774     goto error_status;
2775   if (priv->status != GST_RTSP_MEDIA_STATUS_PREPARED &&
2776       priv->status != GST_RTSP_MEDIA_STATUS_SUSPENDED)
2777     goto not_prepared;
2778
2779   /* NULL and READY are the same */
2780   if (state == GST_STATE_READY)
2781     state = GST_STATE_NULL;
2782
2783   activate = deactivate = FALSE;
2784
2785   GST_INFO ("going to state %s media %p", gst_element_state_get_name (state),
2786       media);
2787
2788   switch (state) {
2789     case GST_STATE_NULL:
2790     case GST_STATE_PAUSED:
2791       /* we're going from PLAYING to PAUSED, READY or NULL, deactivate */
2792       if (priv->target_state == GST_STATE_PLAYING)
2793         deactivate = TRUE;
2794       break;
2795     case GST_STATE_PLAYING:
2796       /* we're going to PLAYING, activate */
2797       activate = TRUE;
2798       break;
2799     default:
2800       break;
2801   }
2802   old_active = priv->n_active;
2803
2804   for (i = 0; i < transports->len; i++) {
2805     GstRTSPStreamTransport *trans;
2806
2807     /* we need a non-NULL entry in the array */
2808     trans = g_ptr_array_index (transports, i);
2809     if (trans == NULL)
2810       continue;
2811
2812     if (activate) {
2813       if (gst_rtsp_stream_transport_set_active (trans, TRUE))
2814         priv->n_active++;
2815     } else if (deactivate) {
2816       if (gst_rtsp_stream_transport_set_active (trans, FALSE))
2817         priv->n_active--;
2818     }
2819   }
2820
2821   /* we just activated the first media, do the playing state change */
2822   if (old_active == 0 && activate)
2823     do_state = TRUE;
2824   /* if we have no more active media, do the downward state changes */
2825   else if (priv->n_active == 0)
2826     do_state = TRUE;
2827   else
2828     do_state = FALSE;
2829
2830   GST_INFO ("state %d active %d media %p do_state %d", state, priv->n_active,
2831       media, do_state);
2832
2833   if (priv->target_state != state) {
2834     if (do_state)
2835       media_set_pipeline_state_locked (media, state);
2836
2837     g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STATE], 0, state,
2838         NULL);
2839   }
2840
2841   /* remember where we are */
2842   if (state != GST_STATE_NULL && (state == GST_STATE_PAUSED ||
2843           old_active != priv->n_active))
2844     collect_media_stats (media);
2845
2846   g_rec_mutex_unlock (&priv->state_lock);
2847
2848   return TRUE;
2849
2850   /* ERRORS */
2851 not_prepared:
2852   {
2853     GST_WARNING ("media %p was not prepared", media);
2854     g_rec_mutex_unlock (&priv->state_lock);
2855     return FALSE;
2856   }
2857 error_status:
2858   {
2859     GST_WARNING ("media %p in error status while changing to state %d",
2860         media, state);
2861     if (state == GST_STATE_NULL) {
2862       for (i = 0; i < transports->len; i++) {
2863         GstRTSPStreamTransport *trans;
2864
2865         /* we need a non-NULL entry in the array */
2866         trans = g_ptr_array_index (transports, i);
2867         if (trans == NULL)
2868           continue;
2869
2870         gst_rtsp_stream_transport_set_active (trans, FALSE);
2871       }
2872       priv->n_active = 0;
2873     }
2874     g_rec_mutex_unlock (&priv->state_lock);
2875     return FALSE;
2876   }
2877 }