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 #include <string.h>
  21 #include <stdlib.h>
  22
  23 #include <gst/app/gstappsrc.h>
  24 #include <gst/app/gstappsink.h>
  25
  26 #include "rtsp-media.h"
  27
  28 #define DEFAULT_SHARED          FALSE
  29 #define DEFAULT_REUSABLE        FALSE
  30 #define DEFAULT_PROTOCOLS       GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_TCP
  31 //#define DEFAULT_PROTOCOLS      GST_RTSP_LOWER_TRANS_UDP_MCAST
  32 #define DEFAULT_EOS_SHUTDOWN    FALSE
  33 #define DEFAULT_BUFFER_SIZE     0x80000
  34 #define DEFAULT_MTU             0
  35
  36 /* define to dump received RTCP packets */
  37 #undef DUMP_STATS
  38
  39 enum
  40 {
  41   PROP_0,
  42   PROP_SHARED,
  43   PROP_REUSABLE,
  44   PROP_PROTOCOLS,
  45   PROP_EOS_SHUTDOWN,
  46   PROP_BUFFER_SIZE,
  47   PROP_MTU,
  48   PROP_LAST
  49 };
  50
  51 enum
  52 {
  53   SIGNAL_PREPARED,
  54   SIGNAL_UNPREPARED,
  55   SIGNAL_NEW_STATE,
  56   SIGNAL_LAST
  57 };
  58
  59 GST_DEBUG_CATEGORY_STATIC (rtsp_media_debug);
  60 #define GST_CAT_DEFAULT rtsp_media_debug
  61
  62 static void gst_rtsp_media_get_property (GObject * object, guint propid,
  63     GValue * value, GParamSpec * pspec);
  64 static void gst_rtsp_media_set_property (GObject * object, guint propid,
  65     const GValue * value, GParamSpec * pspec);
  66 static void gst_rtsp_media_finalize (GObject * obj);
  67
  68 static gpointer do_loop (GstRTSPMediaClass * klass);
  69 static gboolean default_handle_message (GstRTSPMedia * media,
  70     GstMessage * message);
  71 static void finish_unprepare (GstRTSPMedia * media);
  72 static gboolean default_unprepare (GstRTSPMedia * media);
  73
  74 static guint gst_rtsp_media_signals[SIGNAL_LAST] = { 0 };
  75
  76 G_DEFINE_TYPE (GstRTSPMedia, gst_rtsp_media, G_TYPE_OBJECT);
  77
  78 static void
  79 gst_rtsp_media_class_init (GstRTSPMediaClass * klass)
  80 {
  81   GObjectClass *gobject_class;
  82
  83   gobject_class = G_OBJECT_CLASS (klass);
  84
  85   gobject_class->get_property = gst_rtsp_media_get_property;
  86   gobject_class->set_property = gst_rtsp_media_set_property;
  87   gobject_class->finalize = gst_rtsp_media_finalize;
  88
  89   g_object_class_install_property (gobject_class, PROP_SHARED,
  90       g_param_spec_boolean ("shared", "Shared",
  91           "If this media pipeline can be shared", DEFAULT_SHARED,
  92           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  93
  94   g_object_class_install_property (gobject_class, PROP_REUSABLE,
  95       g_param_spec_boolean ("reusable", "Reusable",
  96           "If this media pipeline can be reused after an unprepare",
  97           DEFAULT_REUSABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  98
  99   g_object_class_install_property (gobject_class, PROP_PROTOCOLS,
 100       g_param_spec_flags ("protocols", "Protocols",
 101           "Allowed lower transport protocols", GST_TYPE_RTSP_LOWER_TRANS,
 102           DEFAULT_PROTOCOLS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 103
 104   g_object_class_install_property (gobject_class, PROP_EOS_SHUTDOWN,
 105       g_param_spec_boolean ("eos-shutdown", "EOS Shutdown",
 106           "Send an EOS event to the pipeline before unpreparing",
 107           DEFAULT_EOS_SHUTDOWN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 108
 109   g_object_class_install_property (gobject_class, PROP_BUFFER_SIZE,
 110       g_param_spec_uint ("buffer-size", "Buffer Size",
 111           "The kernel UDP buffer size to use", 0, G_MAXUINT,
 112           DEFAULT_BUFFER_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 113
 114   g_object_class_install_property (gobject_class, PROP_MTU,
 115       g_param_spec_uint ("mtu", "MTU",
 116           "The MTU for the payloaders (0 = default)",
 117           0, G_MAXUINT, DEFAULT_MTU,
 118           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 119
 120   gst_rtsp_media_signals[SIGNAL_PREPARED] =
 121       g_signal_new ("prepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 122       G_STRUCT_OFFSET (GstRTSPMediaClass, prepared), NULL, NULL,
 123       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 124
 125   gst_rtsp_media_signals[SIGNAL_UNPREPARED] =
 126       g_signal_new ("unprepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 127       G_STRUCT_OFFSET (GstRTSPMediaClass, unprepared), NULL, NULL,
 128       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 129
 130   gst_rtsp_media_signals[SIGNAL_NEW_STATE] =
 131       g_signal_new ("new-state", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 132       G_STRUCT_OFFSET (GstRTSPMediaClass, new_state), NULL, NULL,
 133       g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 0, G_TYPE_INT);
 134
 135   klass->context = g_main_context_new ();
 136   klass->loop = g_main_loop_new (klass->context, TRUE);
 137
 138   GST_DEBUG_CATEGORY_INIT (rtsp_media_debug, "rtspmedia", 0, "GstRTSPMedia");
 139
 140   klass->thread = g_thread_new ("Bus Thread", (GThreadFunc) do_loop, klass);
 141
 142   klass->handle_message = default_handle_message;
 143   klass->unprepare = default_unprepare;
 144 }
 145
 146 static void
 147 gst_rtsp_media_init (GstRTSPMedia * media)
 148 {
 149   media->streams = g_ptr_array_new_with_free_func (g_object_unref);
 150   g_mutex_init (&media->lock);
 151   g_cond_init (&media->cond);
 152   g_rec_mutex_init (&media->state_lock);
 153
 154   media->shared = DEFAULT_SHARED;
 155   media->reusable = DEFAULT_REUSABLE;
 156   media->protocols = DEFAULT_PROTOCOLS;
 157   media->eos_shutdown = DEFAULT_EOS_SHUTDOWN;
 158   media->buffer_size = DEFAULT_BUFFER_SIZE;
 159 }
 160
 161 static void
 162 gst_rtsp_media_finalize (GObject * obj)
 163 {
 164   GstRTSPMedia *media;
 165
 166   media = GST_RTSP_MEDIA (obj);
 167
 168   GST_INFO ("finalize media %p", media);
 169
 170   gst_rtsp_media_unprepare (media);
 171
 172   g_ptr_array_unref (media->streams);
 173
 174   g_list_free_full (media->dynamic, gst_object_unref);
 175
 176   if (media->source) {
 177     g_source_destroy (media->source);
 178     g_source_unref (media->source);
 179   }
 180   if (media->auth)
 181     g_object_unref (media->auth);
 182   if (media->pool)
 183     g_object_unref (media->pool);
 184   g_mutex_clear (&media->lock);
 185   g_cond_clear (&media->cond);
 186   g_rec_mutex_clear (&media->state_lock);
 187
 188   G_OBJECT_CLASS (gst_rtsp_media_parent_class)->finalize (obj);
 189 }
 190
 191 static void
 192 gst_rtsp_media_get_property (GObject * object, guint propid,
 193     GValue * value, GParamSpec * pspec)
 194 {
 195   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 196
 197   switch (propid) {
 198     case PROP_SHARED:
 199       g_value_set_boolean (value, gst_rtsp_media_is_shared (media));
 200       break;
 201     case PROP_REUSABLE:
 202       g_value_set_boolean (value, gst_rtsp_media_is_reusable (media));
 203       break;
 204     case PROP_PROTOCOLS:
 205       g_value_set_flags (value, gst_rtsp_media_get_protocols (media));
 206       break;
 207     case PROP_EOS_SHUTDOWN:
 208       g_value_set_boolean (value, gst_rtsp_media_is_eos_shutdown (media));
 209       break;
 210     case PROP_BUFFER_SIZE:
 211       g_value_set_uint (value, gst_rtsp_media_get_buffer_size (media));
 212       break;
 213     case PROP_MTU:
 214       g_value_set_uint (value, gst_rtsp_media_get_mtu (media));
 215       break;
 216     default:
 217       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 218   }
 219 }
 220
 221 static void
 222 gst_rtsp_media_set_property (GObject * object, guint propid,
 223     const GValue * value, GParamSpec * pspec)
 224 {
 225   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 226
 227   switch (propid) {
 228     case PROP_SHARED:
 229       gst_rtsp_media_set_shared (media, g_value_get_boolean (value));
 230       break;
 231     case PROP_REUSABLE:
 232       gst_rtsp_media_set_reusable (media, g_value_get_boolean (value));
 233       break;
 234     case PROP_PROTOCOLS:
 235       gst_rtsp_media_set_protocols (media, g_value_get_flags (value));
 236       break;
 237     case PROP_EOS_SHUTDOWN:
 238       gst_rtsp_media_set_eos_shutdown (media, g_value_get_boolean (value));
 239       break;
 240     case PROP_BUFFER_SIZE:
 241       gst_rtsp_media_set_buffer_size (media, g_value_get_uint (value));
 242       break;
 243     case PROP_MTU:
 244       gst_rtsp_media_set_mtu (media, g_value_get_uint (value));
 245       break;
 246     default:
 247       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 248   }
 249 }
 250
 251 static gpointer
 252 do_loop (GstRTSPMediaClass * klass)
 253 {
 254   GST_INFO ("enter mainloop");
 255   g_main_loop_run (klass->loop);
 256   GST_INFO ("exit mainloop");
 257
 258   return NULL;
 259 }
 260
 261 /* must be called with state lock */
 262 static void
 263 collect_media_stats (GstRTSPMedia * media)
 264 {
 265   gint64 position, duration;
 266
 267   media->range.unit = GST_RTSP_RANGE_NPT;
 268
 269   GST_INFO ("collect media stats");
 270
 271   if (media->is_live) {
 272     media->range.min.type = GST_RTSP_TIME_NOW;
 273     media->range.min.seconds = -1;
 274     media->range.max.type = GST_RTSP_TIME_END;
 275     media->range.max.seconds = -1;
 276   } else {
 277     /* get the position */
 278     if (!gst_element_query_position (media->pipeline, GST_FORMAT_TIME,
 279             &position)) {
 280       GST_INFO ("position query failed");
 281       position = 0;
 282     }
 283
 284     /* get the duration */
 285     if (!gst_element_query_duration (media->pipeline, GST_FORMAT_TIME,
 286             &duration)) {
 287       GST_INFO ("duration query failed");
 288       duration = -1;
 289     }
 290
 291     GST_INFO ("stats: position %" GST_TIME_FORMAT ", duration %"
 292         GST_TIME_FORMAT, GST_TIME_ARGS (position), GST_TIME_ARGS (duration));
 293
 294     if (position == -1) {
 295       media->range.min.type = GST_RTSP_TIME_NOW;
 296       media->range.min.seconds = -1;
 297     } else {
 298       media->range.min.type = GST_RTSP_TIME_SECONDS;
 299       media->range.min.seconds = ((gdouble) position) / GST_SECOND;
 300     }
 301     if (duration == -1) {
 302       media->range.max.type = GST_RTSP_TIME_END;
 303       media->range.max.seconds = -1;
 304     } else {
 305       media->range.max.type = GST_RTSP_TIME_SECONDS;
 306       media->range.max.seconds = ((gdouble) duration) / GST_SECOND;
 307     }
 308   }
 309 }
 310
 311 /**
 312  * gst_rtsp_media_new:
 313  *
 314  * Create a new #GstRTSPMedia instance. The #GstRTSPMedia object contains the
 315  * element to produce RTP data for one or more related (audio/video/..)
 316  * streams.
 317  *
 318  * Returns: a new #GstRTSPMedia object.
 319  */
 320 GstRTSPMedia *
 321 gst_rtsp_media_new (void)
 322 {
 323   GstRTSPMedia *result;
 324
 325   result = g_object_new (GST_TYPE_RTSP_MEDIA, NULL);
 326
 327   return result;
 328 }
 329
 330 /**
 331  * gst_rtsp_media_set_shared:
 332  * @media: a #GstRTSPMedia
 333  * @shared: the new value
 334  *
 335  * Set or unset if the pipeline for @media can be shared will multiple clients.
 336  * When @shared is %TRUE, client requests for this media will share the media
 337  * pipeline.
 338  */
 339 void
 340 gst_rtsp_media_set_shared (GstRTSPMedia * media, gboolean shared)
 341 {
 342   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 343
 344   g_mutex_lock (&media->lock);
 345   media->shared = shared;
 346   g_mutex_unlock (&media->lock);
 347 }
 348
 349 /**
 350  * gst_rtsp_media_is_shared:
 351  * @media: a #GstRTSPMedia
 352  *
 353  * Check if the pipeline for @media can be shared between multiple clients.
 354  *
 355  * Returns: %TRUE if the media can be shared between clients.
 356  */
 357 gboolean
 358 gst_rtsp_media_is_shared (GstRTSPMedia * media)
 359 {
 360   gboolean res;
 361
 362   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 363
 364   g_mutex_lock (&media->lock);
 365   res = media->shared;
 366   g_mutex_unlock (&media->lock);
 367
 368   return res;
 369 }
 370
 371 /**
 372  * gst_rtsp_media_set_reusable:
 373  * @media: a #GstRTSPMedia
 374  * @reusable: the new value
 375  *
 376  * Set or unset if the pipeline for @media can be reused after the pipeline has
 377  * been unprepared.
 378  */
 379 void
 380 gst_rtsp_media_set_reusable (GstRTSPMedia * media, gboolean reusable)
 381 {
 382   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 383
 384   g_mutex_lock (&media->lock);
 385   media->reusable = reusable;
 386   g_mutex_unlock (&media->lock);
 387 }
 388
 389 /**
 390  * gst_rtsp_media_is_reusable:
 391  * @media: a #GstRTSPMedia
 392  *
 393  * Check if the pipeline for @media can be reused after an unprepare.
 394  *
 395  * Returns: %TRUE if the media can be reused
 396  */
 397 gboolean
 398 gst_rtsp_media_is_reusable (GstRTSPMedia * media)
 399 {
 400   gboolean res;
 401
 402   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 403
 404   g_mutex_lock (&media->lock);
 405   res = media->reusable;
 406   g_mutex_unlock (&media->lock);
 407
 408   return res;
 409 }
 410
 411 /**
 412  * gst_rtsp_media_set_protocols:
 413  * @media: a #GstRTSPMedia
 414  * @protocols: the new flags
 415  *
 416  * Configure the allowed lower transport for @media.
 417  */
 418 void
 419 gst_rtsp_media_set_protocols (GstRTSPMedia * media, GstRTSPLowerTrans protocols)
 420 {
 421   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 422
 423   g_mutex_lock (&media->lock);
 424   media->protocols = protocols;
 425   g_mutex_unlock (&media->lock);
 426 }
 427
 428 /**
 429  * gst_rtsp_media_get_protocols:
 430  * @media: a #GstRTSPMedia
 431  *
 432  * Get the allowed protocols of @media.
 433  *
 434  * Returns: a #GstRTSPLowerTrans
 435  */
 436 GstRTSPLowerTrans
 437 gst_rtsp_media_get_protocols (GstRTSPMedia * media)
 438 {
 439   GstRTSPLowerTrans res;
 440
 441   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media),
 442       GST_RTSP_LOWER_TRANS_UNKNOWN);
 443
 444   g_mutex_lock (&media->lock);
 445   res = media->protocols;
 446   g_mutex_unlock (&media->lock);
 447
 448   return res;
 449 }
 450
 451 /**
 452  * gst_rtsp_media_set_eos_shutdown:
 453  * @media: a #GstRTSPMedia
 454  * @eos_shutdown: the new value
 455  *
 456  * Set or unset if an EOS event will be sent to the pipeline for @media before
 457  * it is unprepared.
 458  */
 459 void
 460 gst_rtsp_media_set_eos_shutdown (GstRTSPMedia * media, gboolean eos_shutdown)
 461 {
 462   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 463
 464   g_mutex_lock (&media->lock);
 465   media->eos_shutdown = eos_shutdown;
 466   g_mutex_unlock (&media->lock);
 467 }
 468
 469 /**
 470  * gst_rtsp_media_is_eos_shutdown:
 471  * @media: a #GstRTSPMedia
 472  *
 473  * Check if the pipeline for @media will send an EOS down the pipeline before
 474  * unpreparing.
 475  *
 476  * Returns: %TRUE if the media will send EOS before unpreparing.
 477  */
 478 gboolean
 479 gst_rtsp_media_is_eos_shutdown (GstRTSPMedia * media)
 480 {
 481   gboolean res;
 482
 483   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 484
 485   g_mutex_lock (&media->lock);
 486   res = media->eos_shutdown;
 487   g_mutex_unlock (&media->lock);
 488
 489   return res;
 490 }
 491
 492 /**
 493  * gst_rtsp_media_set_buffer_size:
 494  * @media: a #GstRTSPMedia
 495  * @size: the new value
 496  *
 497  * Set the kernel UDP buffer size.
 498  */
 499 void
 500 gst_rtsp_media_set_buffer_size (GstRTSPMedia * media, guint size)
 501 {
 502   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 503
 504   g_mutex_lock (&media->lock);
 505   media->buffer_size = size;
 506   g_mutex_unlock (&media->lock);
 507 }
 508
 509 /**
 510  * gst_rtsp_media_get_buffer_size:
 511  * @media: a #GstRTSPMedia
 512  *
 513  * Get the kernel UDP buffer size.
 514  *
 515  * Returns: the kernel UDP buffer size.
 516  */
 517 guint
 518 gst_rtsp_media_get_buffer_size (GstRTSPMedia * media)
 519 {
 520   guint res;
 521
 522   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 523
 524   g_mutex_unlock (&media->lock);
 525   res = media->buffer_size;
 526   g_mutex_unlock (&media->lock);
 527
 528   return res;
 529 }
 530
 531 /**
 532  * gst_rtsp_media_set_auth:
 533  * @media: a #GstRTSPMedia
 534  * @auth: a #GstRTSPAuth
 535  *
 536  * configure @auth to be used as the authentication manager of @media.
 537  */
 538 void
 539 gst_rtsp_media_set_auth (GstRTSPMedia * media, GstRTSPAuth * auth)
 540 {
 541   GstRTSPAuth *old;
 542
 543   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 544
 545   g_mutex_lock (&media->lock);
 546   if ((old = media->auth) != auth)
 547     media->auth = auth ? g_object_ref (auth) : NULL;
 548   else
 549     old = NULL;
 550   g_mutex_unlock (&media->lock);
 551
 552   if (old)
 553     g_object_unref (old);
 554 }
 555
 556 /**
 557  * gst_rtsp_media_get_auth:
 558  * @media: a #GstRTSPMedia
 559  *
 560  * Get the #GstRTSPAuth used as the authentication manager of @media.
 561  *
 562  * Returns: (transfer full): the #GstRTSPAuth of @media. g_object_unref() after
 563  * usage.
 564  */
 565 GstRTSPAuth *
 566 gst_rtsp_media_get_auth (GstRTSPMedia * media)
 567 {
 568   GstRTSPAuth *result;
 569
 570   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 571
 572   g_mutex_lock (&media->lock);
 573   if ((result = media->auth))
 574     g_object_ref (result);
 575   g_mutex_unlock (&media->lock);
 576
 577   return result;
 578 }
 579
 580 /**
 581  * gst_rtsp_media_set_address_pool:
 582  * @media: a #GstRTSPMedia
 583  * @pool: a #GstRTSPAddressPool
 584  *
 585  * configure @pool to be used as the address pool of @media.
 586  */
 587 void
 588 gst_rtsp_media_set_address_pool (GstRTSPMedia * media,
 589     GstRTSPAddressPool * pool)
 590 {
 591   GstRTSPAddressPool *old;
 592
 593   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 594
 595   g_mutex_lock (&media->lock);
 596   if ((old = media->pool) != pool)
 597     media->pool = pool ? g_object_ref (pool) : NULL;
 598   else
 599     old = NULL;
 600   g_mutex_unlock (&media->lock);
 601
 602   if (old)
 603     g_object_unref (old);
 604 }
 605
 606 /**
 607  * gst_rtsp_media_get_address_pool:
 608  * @media: a #GstRTSPMedia
 609  *
 610  * Get the #GstRTSPAddressPool used as the address pool of @media.
 611  *
 612  * Returns: (transfer full): the #GstRTSPAddressPool of @media. g_object_unref() after
 613  * usage.
 614  */
 615 GstRTSPAddressPool *
 616 gst_rtsp_media_get_address_pool (GstRTSPMedia * media)
 617 {
 618   GstRTSPAddressPool *result;
 619
 620   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 621
 622   g_mutex_lock (&media->lock);
 623   if ((result = media->pool))
 624     g_object_ref (result);
 625   g_mutex_unlock (&media->lock);
 626
 627   return result;
 628 }
 629
 630 /**
 631  * gst_rtsp_media_set_mtu:
 632  * @media: a #GstRTSPMedia
 633  * @mtu: a new MTU
 634  *
 635  * Set maximum size of one RTP packet on the payloaders.
 636  * The @mtu will be set on all streams.
 637  */
 638 void
 639 gst_rtsp_media_set_mtu (GstRTSPMedia * media, guint mtu)
 640 {
 641   gint i;
 642
 643   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 644
 645   g_mutex_lock (&media->lock);
 646   media->mtu = mtu;
 647   for (i = 0; i < media->streams->len; i++) {
 648     GstRTSPStream *stream;
 649
 650     GST_INFO ("Setting mtu %u for stream %d", mtu, i);
 651
 652     stream = g_ptr_array_index (media->streams, i);
 653     gst_rtsp_stream_set_mtu (stream, mtu);
 654   }
 655   g_mutex_unlock (&media->lock);
 656 }
 657
 658 /**
 659  * gst_rtsp_media_get_mtu:
 660  * @media: a #GstRTSPMedia
 661  *
 662  * Get the configured MTU.
 663  */
 664 guint
 665 gst_rtsp_media_get_mtu (GstRTSPMedia * media)
 666 {
 667   guint res;
 668
 669   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
 670
 671   g_mutex_lock (&media->lock);
 672   res = media->mtu;
 673   g_mutex_unlock (&media->lock);
 674
 675   return res;
 676 }
 677
 678 /**
 679  * gst_rtsp_media_collect_streams:
 680  * @media: a #GstRTSPMedia
 681  *
 682  * Find all payloader elements, they should be named pay%d in the
 683  * element of @media, and create #GstRTSPStreams for them.
 684  *
 685  * Collect all dynamic elements, named dynpay%d, and add them to
 686  * the list of dynamic elements.
 687  */
 688 void
 689 gst_rtsp_media_collect_streams (GstRTSPMedia * media)
 690 {
 691   GstElement *element, *elem;
 692   GstPad *pad;
 693   gint i;
 694   gboolean have_elem;
 695
 696   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 697
 698   element = media->element;
 699
 700   have_elem = TRUE;
 701   for (i = 0; have_elem; i++) {
 702     gchar *name;
 703
 704     have_elem = FALSE;
 705
 706     name = g_strdup_printf ("pay%d", i);
 707     if ((elem = gst_bin_get_by_name (GST_BIN (element), name))) {
 708       GST_INFO ("found stream %d with payloader %p", i, elem);
 709
 710       /* take the pad of the payloader */
 711       pad = gst_element_get_static_pad (elem, "src");
 712       /* create the stream */
 713       gst_rtsp_media_create_stream (media, elem, pad);
 714       g_object_unref (pad);
 715
 716       gst_object_unref (elem);
 717
 718       have_elem = TRUE;
 719     }
 720     g_free (name);
 721
 722     name = g_strdup_printf ("dynpay%d", i);
 723     if ((elem = gst_bin_get_by_name (GST_BIN (element), name))) {
 724       /* a stream that will dynamically create pads to provide RTP packets */
 725
 726       GST_INFO ("found dynamic element %d, %p", i, elem);
 727
 728       g_mutex_lock (&media->lock);
 729       media->dynamic = g_list_prepend (media->dynamic, elem);
 730       g_mutex_unlock (&media->lock);
 731
 732       have_elem = TRUE;
 733     }
 734     g_free (name);
 735   }
 736 }
 737
 738 /**
 739  * gst_rtsp_media_create_stream:
 740  * @media: a #GstRTSPMedia
 741  * @payloader: a #GstElement
 742  * @srcpad: a source #GstPad
 743  *
 744  * Create a new stream in @media that provides RTP data on @srcpad.
 745  * @srcpad should be a pad of an element inside @media->element.
 746  *
 747  * Returns: (transfer none): a new #GstRTSPStream that remains valid for as long
 748  *          as @media exists.
 749  */
 750 GstRTSPStream *
 751 gst_rtsp_media_create_stream (GstRTSPMedia * media, GstElement * payloader,
 752     GstPad * pad)
 753 {
 754   GstRTSPStream *stream;
 755   GstPad *srcpad;
 756   gchar *name;
 757   gint idx;
 758
 759   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 760   g_return_val_if_fail (GST_IS_ELEMENT (payloader), NULL);
 761   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 762   g_return_val_if_fail (GST_PAD_IS_SRC (pad), NULL);
 763
 764   g_mutex_lock (&media->lock);
 765   idx = media->streams->len;
 766
 767   name = g_strdup_printf ("src_%u", idx);
 768   srcpad = gst_ghost_pad_new (name, pad);
 769   gst_pad_set_active (srcpad, TRUE);
 770   gst_element_add_pad (media->element, srcpad);
 771   g_free (name);
 772
 773   stream = gst_rtsp_stream_new (idx, payloader, srcpad);
 774   if (media->mtu)
 775     gst_rtsp_stream_set_mtu (stream, media->mtu);
 776
 777   g_ptr_array_add (media->streams, stream);
 778   g_mutex_unlock (&media->lock);
 779
 780   return stream;
 781 }
 782
 783 /**
 784  * gst_rtsp_media_n_streams:
 785  * @media: a #GstRTSPMedia
 786  *
 787  * Get the number of streams in this media.
 788  *
 789  * Returns: The number of streams.
 790  */
 791 guint
 792 gst_rtsp_media_n_streams (GstRTSPMedia * media)
 793 {
 794   guint res;
 795
 796   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
 797
 798   g_mutex_lock (&media->lock);
 799   res = media->streams->len;
 800   g_mutex_unlock (&media->lock);
 801
 802   return res;
 803 }
 804
 805 /**
 806  * gst_rtsp_media_get_stream:
 807  * @media: a #GstRTSPMedia
 808  * @idx: the stream index
 809  *
 810  * Retrieve the stream with index @idx from @media.
 811  *
 812  * Returns: (transfer none): the #GstRTSPStream at index @idx or %NULL when a stream with
 813  * that index did not exist.
 814  */
 815 GstRTSPStream *
 816 gst_rtsp_media_get_stream (GstRTSPMedia * media, guint idx)
 817 {
 818   GstRTSPStream *res;
 819
 820   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 821
 822   g_mutex_lock (&media->lock);
 823   if (idx < media->streams->len)
 824     res = g_ptr_array_index (media->streams, idx);
 825   else
 826     res = NULL;
 827   g_mutex_unlock (&media->lock);
 828
 829   return res;
 830 }
 831
 832 /**
 833  * gst_rtsp_media_get_range_string:
 834  * @media: a #GstRTSPMedia
 835  * @play: for the PLAY request
 836  *
 837  * Get the current range as a string.
 838  *
 839  * Returns: The range as a string, g_free() after usage.
 840  */
 841 gchar *
 842 gst_rtsp_media_get_range_string (GstRTSPMedia * media, gboolean play)
 843 {
 844   gchar *result;
 845   GstRTSPTimeRange range;
 846
 847   g_mutex_lock (&media->lock);
 848   /* make copy */
 849   range = media->range;
 850
 851   if (!play && media->n_active > 0) {
 852     range.min.type = GST_RTSP_TIME_NOW;
 853     range.min.seconds = -1;
 854   }
 855   g_mutex_unlock (&media->lock);
 856
 857   result = gst_rtsp_range_to_string (&range);
 858
 859   return result;
 860 }
 861
 862 /**
 863  * gst_rtsp_media_seek:
 864  * @media: a #GstRTSPMedia
 865  * @range: a #GstRTSPTimeRange
 866  *
 867  * Seek the pipeline to @range.
 868  *
 869  * Returns: %TRUE on success.
 870  */
 871 gboolean
 872 gst_rtsp_media_seek (GstRTSPMedia * media, GstRTSPTimeRange * range)
 873 {
 874   GstSeekFlags flags;
 875   gboolean res;
 876   gint64 start, stop;
 877   GstSeekType start_type, stop_type;
 878
 879   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 880   g_return_val_if_fail (range != NULL, FALSE);
 881
 882   g_rec_mutex_lock (&media->state_lock);
 883   if (!media->seekable)
 884     goto not_seekable;
 885
 886   if (range->unit != GST_RTSP_RANGE_NPT)
 887     goto not_supported;
 888
 889   /* depends on the current playing state of the pipeline. We might need to
 890    * queue this until we get EOS. */
 891   flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_KEY_UNIT;
 892
 893   start_type = stop_type = GST_SEEK_TYPE_NONE;
 894
 895   switch (range->min.type) {
 896     case GST_RTSP_TIME_NOW:
 897       start = -1;
 898       break;
 899     case GST_RTSP_TIME_SECONDS:
 900       /* only seek when something changed */
 901       if (media->range.min.seconds == range->min.seconds) {
 902         start = -1;
 903       } else {
 904         start = range->min.seconds * GST_SECOND;
 905         start_type = GST_SEEK_TYPE_SET;
 906       }
 907       break;
 908     case GST_RTSP_TIME_END:
 909     default:
 910       goto weird_type;
 911   }
 912   switch (range->max.type) {
 913     case GST_RTSP_TIME_SECONDS:
 914       /* only seek when something changed */
 915       if (media->range.max.seconds == range->max.seconds) {
 916         stop = -1;
 917       } else {
 918         stop = range->max.seconds * GST_SECOND;
 919         stop_type = GST_SEEK_TYPE_SET;
 920       }
 921       break;
 922     case GST_RTSP_TIME_END:
 923       stop = -1;
 924       stop_type = GST_SEEK_TYPE_SET;
 925       break;
 926     case GST_RTSP_TIME_NOW:
 927     default:
 928       goto weird_type;
 929   }
 930
 931   if (start != -1 || stop != -1) {
 932     GST_INFO ("seeking to %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
 933         GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
 934
 935     res = gst_element_seek (media->pipeline, 1.0, GST_FORMAT_TIME,
 936         flags, start_type, start, stop_type, stop);
 937
 938     /* and block for the seek to complete */
 939     GST_INFO ("done seeking %d", res);
 940     gst_element_get_state (media->pipeline, NULL, NULL, -1);
 941     GST_INFO ("prerolled again");
 942
 943     collect_media_stats (media);
 944   } else {
 945     GST_INFO ("no seek needed");
 946     res = TRUE;
 947   }
 948   g_rec_mutex_unlock (&media->state_lock);
 949
 950   return res;
 951
 952   /* ERRORS */
 953 not_seekable:
 954   {
 955     g_rec_mutex_unlock (&media->state_lock);
 956     GST_INFO ("pipeline is not seekable");
 957     return TRUE;
 958   }
 959 not_supported:
 960   {
 961     g_rec_mutex_unlock (&media->state_lock);
 962     GST_WARNING ("seek unit %d not supported", range->unit);
 963     return FALSE;
 964   }
 965 weird_type:
 966   {
 967     g_rec_mutex_unlock (&media->state_lock);
 968     GST_WARNING ("weird range type %d not supported", range->min.type);
 969     return FALSE;
 970   }
 971 }
 972
 973 static void
 974 gst_rtsp_media_set_status (GstRTSPMedia * media, GstRTSPMediaStatus status)
 975 {
 976   g_mutex_lock (&media->lock);
 977   /* never overwrite the error status */
 978   if (media->status != GST_RTSP_MEDIA_STATUS_ERROR)
 979     media->status = status;
 980   GST_DEBUG ("setting new status to %d", status);
 981   g_cond_broadcast (&media->cond);
 982   g_mutex_unlock (&media->lock);
 983 }
 984
 985 static GstRTSPMediaStatus
 986 gst_rtsp_media_get_status (GstRTSPMedia * media)
 987 {
 988   GstRTSPMediaStatus result;
 989   gint64 end_time;
 990
 991   g_mutex_lock (&media->lock);
 992   end_time = g_get_monotonic_time () + 20 * G_TIME_SPAN_SECOND;
 993   /* while we are preparing, wait */
 994   while (media->status == GST_RTSP_MEDIA_STATUS_PREPARING) {
 995     GST_DEBUG ("waiting for status change");
 996     if (!g_cond_wait_until (&media->cond, &media->lock, end_time)) {
 997       GST_DEBUG ("timeout, assuming error status");
 998       media->status = GST_RTSP_MEDIA_STATUS_ERROR;
 999     }
1000   }
1001   /* could be success or error */
1002   result = media->status;
1003   GST_DEBUG ("got status %d", result);
1004   g_mutex_unlock (&media->lock);
1005
1006   return result;
1007 }
1008
1009 /* called with state-lock */
1010 static gboolean
1011 default_handle_message (GstRTSPMedia * media, GstMessage * message)
1012 {
1013   GstMessageType type;
1014
1015   type = GST_MESSAGE_TYPE (message);
1016
1017   switch (type) {
1018     case GST_MESSAGE_STATE_CHANGED:
1019       break;
1020     case GST_MESSAGE_BUFFERING:
1021     {
1022       gint percent;
1023
1024       gst_message_parse_buffering (message, &percent);
1025
1026       /* no state management needed for live pipelines */
1027       if (media->is_live)
1028         break;
1029
1030       if (percent == 100) {
1031         /* a 100% message means buffering is done */
1032         media->buffering = FALSE;
1033         /* if the desired state is playing, go back */
1034         if (media->target_state == GST_STATE_PLAYING) {
1035           GST_INFO ("Buffering done, setting pipeline to PLAYING");
1036           gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1037         } else {
1038           GST_INFO ("Buffering done");
1039         }
1040       } else {
1041         /* buffering busy */
1042         if (media->buffering == FALSE) {
1043           if (media->target_state == GST_STATE_PLAYING) {
1044             /* we were not buffering but PLAYING, PAUSE  the pipeline. */
1045             GST_INFO ("Buffering, setting pipeline to PAUSED ...");
1046             gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
1047           } else {
1048             GST_INFO ("Buffering ...");
1049           }
1050         }
1051         media->buffering = TRUE;
1052       }
1053       break;
1054     }
1055     case GST_MESSAGE_LATENCY:
1056     {
1057       gst_bin_recalculate_latency (GST_BIN_CAST (media->pipeline));
1058       break;
1059     }
1060     case GST_MESSAGE_ERROR:
1061     {
1062       GError *gerror;
1063       gchar *debug;
1064
1065       gst_message_parse_error (message, &gerror, &debug);
1066       GST_WARNING ("%p: got error %s (%s)", media, gerror->message, debug);
1067       g_error_free (gerror);
1068       g_free (debug);
1069
1070       gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
1071       break;
1072     }
1073     case GST_MESSAGE_WARNING:
1074     {
1075       GError *gerror;
1076       gchar *debug;
1077
1078       gst_message_parse_warning (message, &gerror, &debug);
1079       GST_WARNING ("%p: got warning %s (%s)", media, gerror->message, debug);
1080       g_error_free (gerror);
1081       g_free (debug);
1082       break;
1083     }
1084     case GST_MESSAGE_ELEMENT:
1085       break;
1086     case GST_MESSAGE_STREAM_STATUS:
1087       break;
1088     case GST_MESSAGE_ASYNC_DONE:
1089       if (!media->adding) {
1090         /* when we are dynamically adding pads, the addition of the udpsrc will
1091          * temporarily produce ASYNC_DONE messages. We have to ignore them and
1092          * wait for the final ASYNC_DONE after everything prerolled */
1093         GST_INFO ("%p: got ASYNC_DONE", media);
1094         collect_media_stats (media);
1095
1096         gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
1097       } else {
1098         GST_INFO ("%p: ignoring ASYNC_DONE", media);
1099       }
1100       break;
1101     case GST_MESSAGE_EOS:
1102       GST_INFO ("%p: got EOS", media);
1103
1104       if (media->status == GST_RTSP_MEDIA_STATUS_UNPREPARING) {
1105         GST_DEBUG ("shutting down after EOS");
1106         finish_unprepare (media);
1107         g_object_unref (media);
1108       }
1109       break;
1110     default:
1111       GST_INFO ("%p: got message type %s", media,
1112           gst_message_type_get_name (type));
1113       break;
1114   }
1115   return TRUE;
1116 }
1117
1118 static gboolean
1119 bus_message (GstBus * bus, GstMessage * message, GstRTSPMedia * media)
1120 {
1121   GstRTSPMediaClass *klass;
1122   gboolean ret;
1123
1124   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1125
1126   g_rec_mutex_lock (&media->state_lock);
1127   if (klass->handle_message)
1128     ret = klass->handle_message (media, message);
1129   else
1130     ret = FALSE;
1131   g_rec_mutex_unlock (&media->state_lock);
1132
1133   return ret;
1134 }
1135
1136 /* called from streaming threads */
1137 static void
1138 pad_added_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
1139 {
1140   GstRTSPStream *stream;
1141
1142   /* FIXME, element is likely not a payloader, find the payloader here */
1143   stream = gst_rtsp_media_create_stream (media, element, pad);
1144
1145   GST_INFO ("pad added %s:%s, stream %d", GST_DEBUG_PAD_NAME (pad),
1146       stream->idx);
1147
1148   g_rec_mutex_lock (&media->state_lock);
1149   /* we will be adding elements below that will cause ASYNC_DONE to be
1150    * posted in the bus. We want to ignore those messages until the
1151    * pipeline really prerolled. */
1152   media->adding = TRUE;
1153
1154   /* join the element in the PAUSED state because this callback is
1155    * called from the streaming thread and it is PAUSED */
1156   gst_rtsp_stream_join_bin (stream, GST_BIN (media->pipeline),
1157       media->rtpbin, GST_STATE_PAUSED);
1158
1159   media->adding = FALSE;
1160   g_rec_mutex_unlock (&media->state_lock);
1161 }
1162
1163 static void
1164 no_more_pads_cb (GstElement * element, GstRTSPMedia * media)
1165 {
1166   GstElement *fakesink;
1167
1168   g_mutex_lock (&media->lock);
1169   GST_INFO ("no more pads");
1170   if ((fakesink = media->fakesink)) {
1171     gst_object_ref (fakesink);
1172     media->fakesink = NULL;
1173     g_mutex_unlock (&media->lock);
1174
1175     gst_bin_remove (GST_BIN (media->pipeline), fakesink);
1176     gst_element_set_state (fakesink, GST_STATE_NULL);
1177     gst_object_unref (fakesink);
1178     GST_INFO ("removed fakesink");
1179   }
1180 }
1181
1182 /**
1183  * gst_rtsp_media_prepare:
1184  * @media: a #GstRTSPMedia
1185  *
1186  * Prepare @media for streaming. This function will create the pipeline and
1187  * other objects to manage the streaming.
1188  *
1189  * It will preroll the pipeline and collect vital information about the streams
1190  * such as the duration.
1191  *
1192  * Returns: %TRUE on success.
1193  */
1194 gboolean
1195 gst_rtsp_media_prepare (GstRTSPMedia * media)
1196 {
1197   GstStateChangeReturn ret;
1198   GstRTSPMediaStatus status;
1199   guint i;
1200   GstRTSPMediaClass *klass;
1201   GstBus *bus;
1202   GList *walk;
1203
1204   g_rec_mutex_lock (&media->state_lock);
1205   if (media->status == GST_RTSP_MEDIA_STATUS_PREPARED)
1206     goto was_prepared;
1207
1208   if (media->status == GST_RTSP_MEDIA_STATUS_PREPARING)
1209     goto wait_status;
1210
1211   if (media->status != GST_RTSP_MEDIA_STATUS_UNPREPARED)
1212     goto not_unprepared;
1213
1214   if (!media->reusable && media->reused)
1215     goto is_reused;
1216
1217   media->rtpbin = gst_element_factory_make ("rtpbin", NULL);
1218   if (media->rtpbin == NULL)
1219     goto no_rtpbin;
1220
1221   GST_INFO ("preparing media %p", media);
1222
1223   /* reset some variables */
1224   media->is_live = FALSE;
1225   media->seekable = FALSE;
1226   media->buffering = FALSE;
1227   /* we're preparing now */
1228   media->status = GST_RTSP_MEDIA_STATUS_PREPARING;
1229
1230   bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (media->pipeline));
1231
1232   /* add the pipeline bus to our custom mainloop */
1233   media->source = gst_bus_create_watch (bus);
1234   gst_object_unref (bus);
1235
1236   g_source_set_callback (media->source, (GSourceFunc) bus_message, media, NULL);
1237
1238   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1239   media->id = g_source_attach (media->source, klass->context);
1240
1241   /* add stuff to the bin */
1242   gst_bin_add (GST_BIN (media->pipeline), media->rtpbin);
1243
1244   /* link streams we already have, other streams might appear when we have
1245    * dynamic elements */
1246   for (i = 0; i < media->streams->len; i++) {
1247     GstRTSPStream *stream;
1248
1249     stream = g_ptr_array_index (media->streams, i);
1250
1251     gst_rtsp_stream_join_bin (stream, GST_BIN (media->pipeline),
1252         media->rtpbin, GST_STATE_NULL);
1253   }
1254
1255   for (walk = media->dynamic; walk; walk = g_list_next (walk)) {
1256     GstElement *elem = walk->data;
1257
1258     GST_INFO ("adding callbacks for dynamic element %p", elem);
1259
1260     g_signal_connect (elem, "pad-added", (GCallback) pad_added_cb, media);
1261     g_signal_connect (elem, "no-more-pads", (GCallback) no_more_pads_cb, media);
1262
1263     /* we add a fakesink here in order to make the state change async. We remove
1264      * the fakesink again in the no-more-pads callback. */
1265     media->fakesink = gst_element_factory_make ("fakesink", "fakesink");
1266     gst_bin_add (GST_BIN (media->pipeline), media->fakesink);
1267   }
1268
1269   GST_INFO ("setting pipeline to PAUSED for media %p", media);
1270   /* first go to PAUSED */
1271   ret = gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
1272   media->target_state = GST_STATE_PAUSED;
1273
1274   switch (ret) {
1275     case GST_STATE_CHANGE_SUCCESS:
1276       GST_INFO ("SUCCESS state change for media %p", media);
1277       media->seekable = TRUE;
1278       break;
1279     case GST_STATE_CHANGE_ASYNC:
1280       GST_INFO ("ASYNC state change for media %p", media);
1281       media->seekable = TRUE;
1282       break;
1283     case GST_STATE_CHANGE_NO_PREROLL:
1284       /* we need to go to PLAYING */
1285       GST_INFO ("NO_PREROLL state change: live media %p", media);
1286       /* FIXME we disable seeking for live streams for now. We should perform a
1287        * seeking query in preroll instead */
1288       media->seekable = FALSE;
1289       media->is_live = TRUE;
1290       ret = gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1291       if (ret == GST_STATE_CHANGE_FAILURE)
1292         goto state_failed;
1293       break;
1294     case GST_STATE_CHANGE_FAILURE:
1295       goto state_failed;
1296   }
1297 wait_status:
1298   g_rec_mutex_unlock (&media->state_lock);
1299
1300   /* now wait for all pads to be prerolled, FIXME, we should somehow be
1301    * able to do this async so that we don't block the server thread. */
1302   status = gst_rtsp_media_get_status (media);
1303   if (status == GST_RTSP_MEDIA_STATUS_ERROR)
1304     goto state_failed;
1305
1306   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_PREPARED], 0, NULL);
1307
1308   GST_INFO ("object %p is prerolled", media);
1309
1310   return TRUE;
1311
1312   /* OK */
1313 was_prepared:
1314   {
1315     GST_LOG ("media %p was prepared", media);
1316     g_rec_mutex_unlock (&media->state_lock);
1317     return TRUE;
1318   }
1319   /* ERRORS */
1320 not_unprepared:
1321   {
1322     GST_WARNING ("media %p was not unprepared", media);
1323     g_rec_mutex_unlock (&media->state_lock);
1324     return FALSE;
1325   }
1326 is_reused:
1327   {
1328     g_rec_mutex_unlock (&media->state_lock);
1329     GST_WARNING ("can not reuse media %p", media);
1330     return FALSE;
1331   }
1332 no_rtpbin:
1333   {
1334     g_rec_mutex_unlock (&media->state_lock);
1335     GST_WARNING ("no rtpbin element");
1336     g_warning ("failed to create element 'rtpbin', check your installation");
1337     return FALSE;
1338   }
1339 state_failed:
1340   {
1341     GST_WARNING ("failed to preroll pipeline");
1342     gst_rtsp_media_unprepare (media);
1343     g_rec_mutex_unlock (&media->state_lock);
1344     return FALSE;
1345   }
1346 }
1347
1348 /* must be called with state-lock */
1349 static void
1350 finish_unprepare (GstRTSPMedia * media)
1351 {
1352   gint i;
1353
1354   GST_DEBUG ("shutting down");
1355
1356   gst_element_set_state (media->pipeline, GST_STATE_NULL);
1357
1358   for (i = 0; i < media->streams->len; i++) {
1359     GstRTSPStream *stream;
1360
1361     GST_INFO ("Removing elements of stream %d from pipeline", i);
1362
1363     stream = g_ptr_array_index (media->streams, i);
1364
1365     gst_rtsp_stream_leave_bin (stream, GST_BIN (media->pipeline),
1366         media->rtpbin);
1367   }
1368   g_ptr_array_set_size (media->streams, 0);
1369
1370   gst_bin_remove (GST_BIN (media->pipeline), media->rtpbin);
1371   media->rtpbin = NULL;
1372
1373   gst_object_unref (media->pipeline);
1374   media->pipeline = NULL;
1375
1376   media->reused = TRUE;
1377   media->status = GST_RTSP_MEDIA_STATUS_UNPREPARED;
1378
1379   /* when the media is not reusable, this will effectively unref the media and
1380    * recreate it */
1381   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_UNPREPARED], 0, NULL);
1382 }
1383
1384 /* called with state-lock */
1385 static gboolean
1386 default_unprepare (GstRTSPMedia * media)
1387 {
1388   if (media->eos_shutdown) {
1389     GST_DEBUG ("sending EOS for shutdown");
1390     /* ref so that we don't disappear */
1391     g_object_ref (media);
1392     gst_element_send_event (media->pipeline, gst_event_new_eos ());
1393     /* we need to go to playing again for the EOS to propagate, normally in this
1394      * state, nothing is receiving data from us anymore so this is ok. */
1395     gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1396     media->status = GST_RTSP_MEDIA_STATUS_UNPREPARING;
1397   } else {
1398     finish_unprepare (media);
1399   }
1400   return TRUE;
1401 }
1402
1403 /**
1404  * gst_rtsp_media_unprepare:
1405  * @media: a #GstRTSPMedia
1406  *
1407  * Unprepare @media. After this call, the media should be prepared again before
1408  * it can be used again. If the media is set to be non-reusable, a new instance
1409  * must be created.
1410  *
1411  * Returns: %TRUE on success.
1412  */
1413 gboolean
1414 gst_rtsp_media_unprepare (GstRTSPMedia * media)
1415 {
1416   gboolean success;
1417
1418   g_rec_mutex_lock (&media->state_lock);
1419   if (media->status == GST_RTSP_MEDIA_STATUS_UNPREPARED)
1420     goto was_unprepared;
1421
1422   GST_INFO ("unprepare media %p", media);
1423   media->target_state = GST_STATE_NULL;
1424   success = TRUE;
1425
1426   if (media->status == GST_RTSP_MEDIA_STATUS_PREPARED) {
1427     GstRTSPMediaClass *klass;
1428
1429     klass = GST_RTSP_MEDIA_GET_CLASS (media);
1430     if (klass->unprepare)
1431       success = klass->unprepare (media);
1432   } else {
1433     finish_unprepare (media);
1434   }
1435   g_rec_mutex_unlock (&media->state_lock);
1436
1437   return success;
1438
1439 was_unprepared:
1440   {
1441     g_rec_mutex_unlock (&media->state_lock);
1442     GST_INFO ("media %p was already unprepared", media);
1443     return TRUE;
1444   }
1445 }
1446
1447 /**
1448  * gst_rtsp_media_set_state:
1449  * @media: a #GstRTSPMedia
1450  * @state: the target state of the media
1451  * @transports: a #GPtrArray of #GstRTSPStreamTransport pointers
1452  *
1453  * Set the state of @media to @state and for the transports in @transports.
1454  *
1455  * Returns: %TRUE on success.
1456  */
1457 gboolean
1458 gst_rtsp_media_set_state (GstRTSPMedia * media, GstState state,
1459     GPtrArray * transports)
1460 {
1461   gint i;
1462   gboolean add, remove, do_state;
1463   gint old_active;
1464
1465   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
1466   g_return_val_if_fail (transports != NULL, FALSE);
1467
1468   g_rec_mutex_lock (&media->state_lock);
1469
1470   /* NULL and READY are the same */
1471   if (state == GST_STATE_READY)
1472     state = GST_STATE_NULL;
1473
1474   add = remove = FALSE;
1475
1476   GST_INFO ("going to state %s media %p", gst_element_state_get_name (state),
1477       media);
1478
1479   switch (state) {
1480     case GST_STATE_NULL:
1481     case GST_STATE_PAUSED:
1482       /* we're going from PLAYING to PAUSED, READY or NULL, remove */
1483       if (media->target_state == GST_STATE_PLAYING)
1484         remove = TRUE;
1485       break;
1486     case GST_STATE_PLAYING:
1487       /* we're going to PLAYING, add */
1488       add = TRUE;
1489       break;
1490     default:
1491       break;
1492   }
1493   old_active = media->n_active;
1494
1495   for (i = 0; i < transports->len; i++) {
1496     GstRTSPStreamTransport *trans;
1497
1498     /* we need a non-NULL entry in the array */
1499     trans = g_ptr_array_index (transports, i);
1500     if (trans == NULL)
1501       continue;
1502
1503     /* we need a transport */
1504     if (!trans->transport)
1505       continue;
1506
1507     if (add) {
1508       if (gst_rtsp_stream_add_transport (trans->stream, trans))
1509         media->n_active++;
1510     } else if (remove) {
1511       if (gst_rtsp_stream_remove_transport (trans->stream, trans))
1512         media->n_active--;
1513     }
1514   }
1515
1516   /* we just added the first media, do the playing state change */
1517   if (old_active == 0 && add)
1518     do_state = TRUE;
1519   /* if we have no more active media, do the downward state changes */
1520   else if (media->n_active == 0)
1521     do_state = TRUE;
1522   else
1523     do_state = FALSE;
1524
1525   GST_INFO ("state %d active %d media %p do_state %d", state, media->n_active,
1526       media, do_state);
1527
1528   if (media->target_state != state) {
1529     if (do_state) {
1530       if (state == GST_STATE_NULL) {
1531         gst_rtsp_media_unprepare (media);
1532       } else {
1533         GST_INFO ("state %s media %p", gst_element_state_get_name (state),
1534             media);
1535         media->target_state = state;
1536         gst_element_set_state (media->pipeline, state);
1537       }
1538     }
1539     g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STATE], 0, state,
1540         NULL);
1541   }
1542
1543   /* remember where we are */
1544   if (state != GST_STATE_NULL && (state == GST_STATE_PAUSED ||
1545           old_active != media->n_active))
1546     collect_media_stats (media);
1547
1548   g_rec_mutex_unlock (&media->state_lock);
1549
1550   return TRUE;
1551 }