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