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., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, 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
  34 /* define to dump received RTCP packets */
  35 #undef DUMP_STATS
  36
  37 enum
  38 {
  39   PROP_0,
  40   PROP_SHARED,
  41   PROP_REUSABLE,
  42   PROP_PROTOCOLS,
  43   PROP_EOS_SHUTDOWN,
  44   PROP_LAST
  45 };
  46
  47 enum
  48 {
  49   SIGNAL_PREPARED,
  50   SIGNAL_UNPREPARED,
  51   SIGNAL_NEW_STATE,
  52   SIGNAL_LAST
  53 };
  54
  55 GST_DEBUG_CATEGORY_EXTERN (rtsp_media_debug);
  56 #define GST_CAT_DEFAULT rtsp_media_debug
  57
  58 static GQuark ssrc_stream_map_key;
  59
  60 static void gst_rtsp_media_get_property (GObject * object, guint propid,
  61     GValue * value, GParamSpec * pspec);
  62 static void gst_rtsp_media_set_property (GObject * object, guint propid,
  63     const GValue * value, GParamSpec * pspec);
  64 static void gst_rtsp_media_finalize (GObject * obj);
  65
  66 static gpointer do_loop (GstRTSPMediaClass * klass);
  67 static gboolean default_handle_message (GstRTSPMedia * media,
  68     GstMessage * message);
  69 static gboolean default_unprepare (GstRTSPMedia * media);
  70 static void unlock_streams (GstRTSPMedia * media);
  71
  72 static guint gst_rtsp_media_signals[SIGNAL_LAST] = { 0 };
  73
  74 G_DEFINE_TYPE (GstRTSPMedia, gst_rtsp_media, G_TYPE_OBJECT);
  75
  76 static void
  77 gst_rtsp_media_class_init (GstRTSPMediaClass * klass)
  78 {
  79   GObjectClass *gobject_class;
  80   GError *error = NULL;
  81
  82   gobject_class = G_OBJECT_CLASS (klass);
  83
  84   gobject_class->get_property = gst_rtsp_media_get_property;
  85   gobject_class->set_property = gst_rtsp_media_set_property;
  86   gobject_class->finalize = gst_rtsp_media_finalize;
  87
  88   g_object_class_install_property (gobject_class, PROP_SHARED,
  89       g_param_spec_boolean ("shared", "Shared",
  90           "If this media pipeline can be shared", DEFAULT_SHARED,
  91           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  92
  93   g_object_class_install_property (gobject_class, PROP_REUSABLE,
  94       g_param_spec_boolean ("reusable", "Reusable",
  95           "If this media pipeline can be reused after an unprepare",
  96           DEFAULT_REUSABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  97
  98   g_object_class_install_property (gobject_class, PROP_PROTOCOLS,
  99       g_param_spec_flags ("protocols", "Protocols",
 100           "Allowed lower transport protocols", GST_TYPE_RTSP_LOWER_TRANS,
 101           DEFAULT_PROTOCOLS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 102
 103   g_object_class_install_property (gobject_class, PROP_EOS_SHUTDOWN,
 104       g_param_spec_boolean ("eos-shutdown", "EOS Shutdown",
 105           "Send an EOS event to the pipeline before unpreparing",
 106           DEFAULT_EOS_SHUTDOWN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 107
 108   gst_rtsp_media_signals[SIGNAL_PREPARED] =
 109       g_signal_new ("prepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 110       G_STRUCT_OFFSET (GstRTSPMediaClass, prepared), NULL, NULL,
 111       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 112
 113   gst_rtsp_media_signals[SIGNAL_UNPREPARED] =
 114       g_signal_new ("unprepared", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 115       G_STRUCT_OFFSET (GstRTSPMediaClass, unprepared), NULL, NULL,
 116       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
 117
 118   gst_rtsp_media_signals[SIGNAL_NEW_STATE] =
 119       g_signal_new ("new-state", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 120       G_STRUCT_OFFSET (GstRTSPMediaClass, new_state), NULL, NULL,
 121       g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 0, G_TYPE_INT);
 122
 123   klass->context = g_main_context_new ();
 124   klass->loop = g_main_loop_new (klass->context, TRUE);
 125
 126   klass->thread = g_thread_create ((GThreadFunc) do_loop, klass, TRUE, &error);
 127   if (error != NULL) {
 128     g_critical ("could not start bus thread: %s", error->message);
 129   }
 130   klass->handle_message = default_handle_message;
 131   klass->unprepare = default_unprepare;
 132
 133   ssrc_stream_map_key = g_quark_from_static_string ("GstRTSPServer.stream");
 134 }
 135
 136 static void
 137 gst_rtsp_media_init (GstRTSPMedia * media)
 138 {
 139   media->streams = g_array_new (FALSE, TRUE, sizeof (GstRTSPMediaStream *));
 140   media->lock = g_mutex_new ();
 141   media->cond = g_cond_new ();
 142
 143   media->shared = DEFAULT_SHARED;
 144   media->reusable = DEFAULT_REUSABLE;
 145   media->protocols = DEFAULT_PROTOCOLS;
 146   media->eos_shutdown = DEFAULT_EOS_SHUTDOWN;
 147 }
 148
 149 /* FIXME. this should be done in multiudpsink */
 150 typedef struct
 151 {
 152   gint count;
 153   gchar *dest;
 154   gint min, max;
 155 } RTSPDestination;
 156
 157 static gint
 158 dest_compare (RTSPDestination * a, RTSPDestination * b)
 159 {
 160   if ((a->min == b->min) && (a->max == b->max)
 161       && (strcmp (a->dest, b->dest) == 0))
 162     return 0;
 163
 164   return 1;
 165 }
 166
 167 static RTSPDestination *
 168 create_destination (const gchar * dest, gint min, gint max)
 169 {
 170   RTSPDestination *res;
 171
 172   res = g_slice_new (RTSPDestination);
 173   res->count = 1;
 174   res->dest = g_strdup (dest);
 175   res->min = min;
 176   res->max = max;
 177
 178   return res;
 179 }
 180
 181 static void
 182 free_destination (RTSPDestination * dest)
 183 {
 184   g_free (dest->dest);
 185   g_slice_free (RTSPDestination, dest);
 186 }
 187
 188 void
 189 gst_rtsp_media_trans_cleanup (GstRTSPMediaTrans * trans)
 190 {
 191   if (trans->transport) {
 192     gst_rtsp_transport_free (trans->transport);
 193     trans->transport = NULL;
 194   }
 195   if (trans->rtpsource) {
 196     g_object_set_qdata (trans->rtpsource, ssrc_stream_map_key, NULL);
 197     trans->rtpsource = NULL;
 198   }
 199 }
 200
 201 static void
 202 gst_rtsp_media_stream_free (GstRTSPMediaStream * stream)
 203 {
 204   if (stream->session)
 205     g_object_unref (stream->session);
 206
 207   if (stream->caps)
 208     gst_caps_unref (stream->caps);
 209
 210   if (stream->send_rtp_sink)
 211     gst_object_unref (stream->send_rtp_sink);
 212   if (stream->send_rtp_src)
 213     gst_object_unref (stream->send_rtp_src);
 214   if (stream->send_rtcp_src)
 215     gst_object_unref (stream->send_rtcp_src);
 216   if (stream->recv_rtcp_sink)
 217     gst_object_unref (stream->recv_rtcp_sink);
 218   if (stream->recv_rtp_sink)
 219     gst_object_unref (stream->recv_rtp_sink);
 220
 221   g_list_free (stream->transports);
 222
 223   g_list_foreach (stream->destinations, (GFunc) free_destination, NULL);
 224   g_list_free (stream->destinations);
 225
 226   g_free (stream);
 227 }
 228
 229 static void
 230 gst_rtsp_media_finalize (GObject * obj)
 231 {
 232   GstRTSPMedia *media;
 233   guint i;
 234
 235   media = GST_RTSP_MEDIA (obj);
 236
 237   GST_INFO ("finalize media %p", media);
 238
 239   if (media->pipeline) {
 240     unlock_streams (media);
 241     gst_element_set_state (media->pipeline, GST_STATE_NULL);
 242     gst_object_unref (media->pipeline);
 243   }
 244
 245   for (i = 0; i < media->streams->len; i++) {
 246     GstRTSPMediaStream *stream;
 247
 248     stream = g_array_index (media->streams, GstRTSPMediaStream *, i);
 249
 250     gst_rtsp_media_stream_free (stream);
 251   }
 252   g_array_free (media->streams, TRUE);
 253
 254   g_list_foreach (media->dynamic, (GFunc) gst_object_unref, NULL);
 255   g_list_free (media->dynamic);
 256
 257   if (media->source) {
 258     g_source_destroy (media->source);
 259     g_source_unref (media->source);
 260   }
 261   g_mutex_free (media->lock);
 262   g_cond_free (media->cond);
 263
 264   G_OBJECT_CLASS (gst_rtsp_media_parent_class)->finalize (obj);
 265 }
 266
 267 static void
 268 gst_rtsp_media_get_property (GObject * object, guint propid,
 269     GValue * value, GParamSpec * pspec)
 270 {
 271   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 272
 273   switch (propid) {
 274     case PROP_SHARED:
 275       g_value_set_boolean (value, gst_rtsp_media_is_shared (media));
 276       break;
 277     case PROP_REUSABLE:
 278       g_value_set_boolean (value, gst_rtsp_media_is_reusable (media));
 279       break;
 280     case PROP_PROTOCOLS:
 281       g_value_set_flags (value, gst_rtsp_media_get_protocols (media));
 282       break;
 283     case PROP_EOS_SHUTDOWN:
 284       g_value_set_boolean (value, gst_rtsp_media_is_eos_shutdown (media));
 285       break;
 286     default:
 287       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 288   }
 289 }
 290
 291 static void
 292 gst_rtsp_media_set_property (GObject * object, guint propid,
 293     const GValue * value, GParamSpec * pspec)
 294 {
 295   GstRTSPMedia *media = GST_RTSP_MEDIA (object);
 296
 297   switch (propid) {
 298     case PROP_SHARED:
 299       gst_rtsp_media_set_shared (media, g_value_get_boolean (value));
 300       break;
 301     case PROP_REUSABLE:
 302       gst_rtsp_media_set_reusable (media, g_value_get_boolean (value));
 303       break;
 304     case PROP_PROTOCOLS:
 305       gst_rtsp_media_set_protocols (media, g_value_get_flags (value));
 306       break;
 307     case PROP_EOS_SHUTDOWN:
 308       gst_rtsp_media_set_eos_shutdown (media, g_value_get_boolean (value));
 309       break;
 310     default:
 311       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 312   }
 313 }
 314
 315 static gpointer
 316 do_loop (GstRTSPMediaClass * klass)
 317 {
 318   GST_INFO ("enter mainloop");
 319   g_main_loop_run (klass->loop);
 320   GST_INFO ("exit mainloop");
 321
 322   return NULL;
 323 }
 324
 325 static void
 326 collect_media_stats (GstRTSPMedia * media)
 327 {
 328   GstFormat format;
 329   gint64 position, duration;
 330
 331   media->range.unit = GST_RTSP_RANGE_NPT;
 332
 333   if (media->is_live) {
 334     media->range.min.type = GST_RTSP_TIME_NOW;
 335     media->range.min.seconds = -1;
 336     media->range.max.type = GST_RTSP_TIME_END;
 337     media->range.max.seconds = -1;
 338   } else {
 339     /* get the position */
 340     format = GST_FORMAT_TIME;
 341     if (!gst_element_query_position (media->pipeline, &format, &position)) {
 342       GST_INFO ("position query failed");
 343       position = 0;
 344     }
 345
 346     /* get the duration */
 347     format = GST_FORMAT_TIME;
 348     if (!gst_element_query_duration (media->pipeline, &format, &duration)) {
 349       GST_INFO ("duration query failed");
 350       duration = -1;
 351     }
 352
 353     GST_INFO ("stats: position %" GST_TIME_FORMAT ", duration %"
 354         GST_TIME_FORMAT, GST_TIME_ARGS (position), GST_TIME_ARGS (duration));
 355
 356     if (position == -1 || media->active > 0) {
 357       media->range.min.type = GST_RTSP_TIME_NOW;
 358       media->range.min.seconds = -1;
 359     } else {
 360       media->range.min.type = GST_RTSP_TIME_SECONDS;
 361       media->range.min.seconds = ((gdouble) position) / GST_SECOND;
 362     }
 363     if (duration == -1) {
 364       media->range.max.type = GST_RTSP_TIME_END;
 365       media->range.max.seconds = -1;
 366     } else {
 367       media->range.max.type = GST_RTSP_TIME_SECONDS;
 368       media->range.max.seconds = ((gdouble) duration) / GST_SECOND;
 369     }
 370   }
 371 }
 372
 373 /**
 374  * gst_rtsp_media_new:
 375  *
 376  * Create a new #GstRTSPMedia instance. The #GstRTSPMedia object contains the
 377  * element to produde RTP data for one or more related (audio/video/..)
 378  * streams.
 379  *
 380  * Returns: a new #GstRTSPMedia object.
 381  */
 382 GstRTSPMedia *
 383 gst_rtsp_media_new (void)
 384 {
 385   GstRTSPMedia *result;
 386
 387   result = g_object_new (GST_TYPE_RTSP_MEDIA, NULL);
 388
 389   return result;
 390 }
 391
 392 /**
 393  * gst_rtsp_media_set_shared:
 394  * @media: a #GstRTSPMedia
 395  * @shared: the new value
 396  *
 397  * Set or unset if the pipeline for @media can be shared will multiple clients.
 398  * When @shared is %TRUE, client requests for this media will share the media
 399  * pipeline.
 400  */
 401 void
 402 gst_rtsp_media_set_shared (GstRTSPMedia * media, gboolean shared)
 403 {
 404   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 405
 406   media->shared = shared;
 407 }
 408
 409 /**
 410  * gst_rtsp_media_is_shared:
 411  * @media: a #GstRTSPMedia
 412  *
 413  * Check if the pipeline for @media can be shared between multiple clients.
 414  *
 415  * Returns: %TRUE if the media can be shared between clients.
 416  */
 417 gboolean
 418 gst_rtsp_media_is_shared (GstRTSPMedia * media)
 419 {
 420   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 421
 422   return media->shared;
 423 }
 424
 425 /**
 426  * gst_rtsp_media_set_reusable:
 427  * @media: a #GstRTSPMedia
 428  * @reusable: the new value
 429  *
 430  * Set or unset if the pipeline for @media can be reused after the pipeline has
 431  * been unprepared.
 432  */
 433 void
 434 gst_rtsp_media_set_reusable (GstRTSPMedia * media, gboolean reusable)
 435 {
 436   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 437
 438   media->reusable = reusable;
 439 }
 440
 441 /**
 442  * gst_rtsp_media_is_reusable:
 443  * @media: a #GstRTSPMedia
 444  *
 445  * Check if the pipeline for @media can be reused after an unprepare.
 446  *
 447  * Returns: %TRUE if the media can be reused
 448  */
 449 gboolean
 450 gst_rtsp_media_is_reusable (GstRTSPMedia * media)
 451 {
 452   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 453
 454   return media->reusable;
 455 }
 456
 457 /**
 458  * gst_rtsp_media_set_protocols:
 459  * @media: a #GstRTSPMedia
 460  * @protocols: the new flags
 461  *
 462  * Configure the allowed lower transport for @media.
 463  */
 464 void
 465 gst_rtsp_media_set_protocols (GstRTSPMedia * media, GstRTSPLowerTrans protocols)
 466 {
 467   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 468
 469   media->protocols = protocols;
 470 }
 471
 472 /**
 473  * gst_rtsp_media_get_protocols:
 474  * @media: a #GstRTSPMedia
 475  *
 476  * Get the allowed protocols of @media.
 477  *
 478  * Returns: a #GstRTSPLowerTrans
 479  */
 480 GstRTSPLowerTrans
 481 gst_rtsp_media_get_protocols (GstRTSPMedia * media)
 482 {
 483   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media),
 484       GST_RTSP_LOWER_TRANS_UNKNOWN);
 485
 486   return media->protocols;
 487 }
 488
 489 /**
 490  * gst_rtsp_media_set_eos_shutdown:
 491  * @media: a #GstRTSPMedia
 492  * @eos_shutdown: the new value
 493  *
 494  * Set or unset if an EOS event will be sent to the pipeline for @media before
 495  * it is unprepared.
 496  */
 497 void
 498 gst_rtsp_media_set_eos_shutdown (GstRTSPMedia * media, gboolean eos_shutdown)
 499 {
 500   g_return_if_fail (GST_IS_RTSP_MEDIA (media));
 501
 502   media->eos_shutdown = eos_shutdown;
 503 }
 504
 505 /**
 506  * gst_rtsp_media_is_eos_shutdown:
 507  * @media: a #GstRTSPMedia
 508  *
 509  * Check if the pipeline for @media will send an EOS down the pipeline before
 510  * unpreparing.
 511  *
 512  * Returns: %TRUE if the media will send EOS before unpreparing.
 513  */
 514 gboolean
 515 gst_rtsp_media_is_eos_shutdown (GstRTSPMedia * media)
 516 {
 517   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 518
 519   return media->eos_shutdown;
 520 }
 521
 522 /**
 523  * gst_rtsp_media_n_streams:
 524  * @media: a #GstRTSPMedia
 525  *
 526  * Get the number of streams in this media.
 527  *
 528  * Returns: The number of streams.
 529  */
 530 guint
 531 gst_rtsp_media_n_streams (GstRTSPMedia * media)
 532 {
 533   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), 0);
 534
 535   return media->streams->len;
 536 }
 537
 538 /**
 539  * gst_rtsp_media_get_stream:
 540  * @media: a #GstRTSPMedia
 541  * @idx: the stream index
 542  *
 543  * Retrieve the stream with index @idx from @media.
 544  *
 545  * Returns: the #GstRTSPMediaStream at index @idx or %NULL when a stream with
 546  * that index did not exist.
 547  */
 548 GstRTSPMediaStream *
 549 gst_rtsp_media_get_stream (GstRTSPMedia * media, guint idx)
 550 {
 551   GstRTSPMediaStream *res;
 552
 553   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), NULL);
 554
 555   if (idx < media->streams->len)
 556     res = g_array_index (media->streams, GstRTSPMediaStream *, idx);
 557   else
 558     res = NULL;
 559
 560   return res;
 561 }
 562
 563 /**
 564  * gst_rtsp_media_seek:
 565  * @media: a #GstRTSPMedia
 566  * @range: a #GstRTSPTimeRange
 567  *
 568  * Seek the pipeline to @range.
 569  *
 570  * Returns: %TRUE on success.
 571  */
 572 gboolean
 573 gst_rtsp_media_seek (GstRTSPMedia * media, GstRTSPTimeRange * range)
 574 {
 575   GstSeekFlags flags;
 576   gboolean res;
 577   gint64 start, stop;
 578   GstSeekType start_type, stop_type;
 579
 580   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
 581   g_return_val_if_fail (range != NULL, FALSE);
 582
 583   if (range->unit != GST_RTSP_RANGE_NPT)
 584     goto not_supported;
 585
 586   /* depends on the current playing state of the pipeline. We might need to
 587    * queue this until we get EOS. */
 588   flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_KEY_UNIT;
 589
 590   start_type = stop_type = GST_SEEK_TYPE_NONE;
 591
 592   switch (range->min.type) {
 593     case GST_RTSP_TIME_NOW:
 594       start = -1;
 595       break;
 596     case GST_RTSP_TIME_SECONDS:
 597       /* only seek when something changed */
 598       if (media->range.min.seconds == range->min.seconds) {
 599         start = -1;
 600       } else {
 601         start = range->min.seconds * GST_SECOND;
 602         start_type = GST_SEEK_TYPE_SET;
 603       }
 604       break;
 605     case GST_RTSP_TIME_END:
 606     default:
 607       goto weird_type;
 608   }
 609   switch (range->max.type) {
 610     case GST_RTSP_TIME_SECONDS:
 611       /* only seek when something changed */
 612       if (media->range.max.seconds == range->max.seconds) {
 613         stop = -1;
 614       } else {
 615         stop = range->max.seconds * GST_SECOND;
 616         stop_type = GST_SEEK_TYPE_SET;
 617       }
 618       break;
 619     case GST_RTSP_TIME_END:
 620       stop = -1;
 621       stop_type = GST_SEEK_TYPE_SET;
 622       break;
 623     case GST_RTSP_TIME_NOW:
 624     default:
 625       goto weird_type;
 626   }
 627
 628   if (start != -1 || stop != -1) {
 629     GST_INFO ("seeking to %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
 630         GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
 631
 632     res = gst_element_seek (media->pipeline, 1.0, GST_FORMAT_TIME,
 633         flags, start_type, start, stop_type, stop);
 634
 635     /* and block for the seek to complete */
 636     GST_INFO ("done seeking %d", res);
 637     gst_element_get_state (media->pipeline, NULL, NULL, -1);
 638     GST_INFO ("prerolled again");
 639
 640     collect_media_stats (media);
 641   } else {
 642     GST_INFO ("no seek needed");
 643     res = TRUE;
 644   }
 645
 646   return res;
 647
 648   /* ERRORS */
 649 not_supported:
 650   {
 651     GST_WARNING ("seek unit %d not supported", range->unit);
 652     return FALSE;
 653   }
 654 weird_type:
 655   {
 656     GST_WARNING ("weird range type %d not supported", range->min.type);
 657     return FALSE;
 658   }
 659 }
 660
 661 /**
 662  * gst_rtsp_media_stream_rtp:
 663  * @stream: a #GstRTSPMediaStream
 664  * @buffer: a #GstBuffer
 665  *
 666  * Handle an RTP buffer for the stream. This method is usually called when a
 667  * message has been received from a client using the TCP transport.
 668  *
 669  * This function takes ownership of @buffer.
 670  *
 671  * Returns: a GstFlowReturn.
 672  */
 673 GstFlowReturn
 674 gst_rtsp_media_stream_rtp (GstRTSPMediaStream * stream, GstBuffer * buffer)
 675 {
 676   GstFlowReturn ret;
 677
 678   ret = gst_app_src_push_buffer (GST_APP_SRC_CAST (stream->appsrc[0]), buffer);
 679
 680   return ret;
 681 }
 682
 683 /**
 684  * gst_rtsp_media_stream_rtcp:
 685  * @stream: a #GstRTSPMediaStream
 686  * @buffer: a #GstBuffer
 687  *
 688  * Handle an RTCP buffer for the stream. This method is usually called when a
 689  * message has been received from a client using the TCP transport.
 690  *
 691  * This function takes ownership of @buffer.
 692  *
 693  * Returns: a GstFlowReturn.
 694  */
 695 GstFlowReturn
 696 gst_rtsp_media_stream_rtcp (GstRTSPMediaStream * stream, GstBuffer * buffer)
 697 {
 698   GstFlowReturn ret;
 699
 700   ret = gst_app_src_push_buffer (GST_APP_SRC_CAST (stream->appsrc[1]), buffer);
 701
 702   return ret;
 703 }
 704
 705 /* Allocate the udp ports and sockets */
 706 static gboolean
 707 alloc_udp_ports (GstRTSPMedia * media, GstRTSPMediaStream * stream)
 708 {
 709   GstStateChangeReturn ret;
 710   GstElement *udpsrc0, *udpsrc1;
 711   GstElement *udpsink0, *udpsink1;
 712   gint tmp_rtp, tmp_rtcp;
 713   guint count;
 714   gint rtpport, rtcpport, sockfd;
 715   const gchar *host;
 716
 717   udpsrc0 = NULL;
 718   udpsrc1 = NULL;
 719   udpsink0 = NULL;
 720   udpsink1 = NULL;
 721   count = 0;
 722
 723   /* Start with random port */
 724   tmp_rtp = 0;
 725
 726   if (media->is_ipv6)
 727     host = "udp://[::0]";
 728   else
 729     host = "udp://0.0.0.0";
 730
 731   /* try to allocate 2 UDP ports, the RTP port should be an even
 732    * number and the RTCP port should be the next (uneven) port */
 733 again:
 734   udpsrc0 = gst_element_make_from_uri (GST_URI_SRC, host, NULL);
 735   if (udpsrc0 == NULL)
 736     goto no_udp_protocol;
 737   g_object_set (G_OBJECT (udpsrc0), "port", tmp_rtp, NULL);
 738
 739   ret = gst_element_set_state (udpsrc0, GST_STATE_PAUSED);
 740   if (ret == GST_STATE_CHANGE_FAILURE) {
 741     if (tmp_rtp != 0) {
 742       tmp_rtp += 2;
 743       if (++count > 20)
 744         goto no_ports;
 745
 746       gst_element_set_state (udpsrc0, GST_STATE_NULL);
 747       gst_object_unref (udpsrc0);
 748
 749       goto again;
 750     }
 751     goto no_udp_protocol;
 752   }
 753
 754   g_object_get (G_OBJECT (udpsrc0), "port", &tmp_rtp, NULL);
 755
 756   /* check if port is even */
 757   if ((tmp_rtp & 1) != 0) {
 758     /* port not even, close and allocate another */
 759     if (++count > 20)
 760       goto no_ports;
 761
 762     gst_element_set_state (udpsrc0, GST_STATE_NULL);
 763     gst_object_unref (udpsrc0);
 764
 765     tmp_rtp++;
 766     goto again;
 767   }
 768
 769   /* allocate port+1 for RTCP now */
 770   udpsrc1 = gst_element_make_from_uri (GST_URI_SRC, host, NULL);
 771   if (udpsrc1 == NULL)
 772     goto no_udp_rtcp_protocol;
 773
 774   /* set port */
 775   tmp_rtcp = tmp_rtp + 1;
 776   g_object_set (G_OBJECT (udpsrc1), "port", tmp_rtcp, NULL);
 777
 778   ret = gst_element_set_state (udpsrc1, GST_STATE_PAUSED);
 779   /* tmp_rtcp port is busy already : retry to make rtp/rtcp pair */
 780   if (ret == GST_STATE_CHANGE_FAILURE) {
 781
 782     if (++count > 20)
 783       goto no_ports;
 784
 785     gst_element_set_state (udpsrc0, GST_STATE_NULL);
 786     gst_object_unref (udpsrc0);
 787
 788     gst_element_set_state (udpsrc1, GST_STATE_NULL);
 789     gst_object_unref (udpsrc1);
 790
 791     tmp_rtp += 2;
 792     goto again;
 793   }
 794
 795   /* all fine, do port check */
 796   g_object_get (G_OBJECT (udpsrc0), "port", &rtpport, NULL);
 797   g_object_get (G_OBJECT (udpsrc1), "port", &rtcpport, NULL);
 798
 799   /* this should not happen... */
 800   if (rtpport != tmp_rtp || rtcpport != tmp_rtcp)
 801     goto port_error;
 802
 803   udpsink0 = gst_element_factory_make ("multiudpsink", NULL);
 804   if (!udpsink0)
 805     goto no_udp_protocol;
 806
 807   g_object_get (G_OBJECT (udpsrc0), "sock", &sockfd, NULL);
 808   g_object_set (G_OBJECT (udpsink0), "sockfd", sockfd, NULL);
 809   g_object_set (G_OBJECT (udpsink0), "closefd", FALSE, NULL);
 810
 811   udpsink1 = gst_element_factory_make ("multiudpsink", NULL);
 812   if (!udpsink1)
 813     goto no_udp_protocol;
 814
 815   if (g_object_class_find_property (G_OBJECT_GET_CLASS (udpsink0),
 816           "send-duplicates")) {
 817     g_object_set (G_OBJECT (udpsink0), "send-duplicates", FALSE, NULL);
 818     g_object_set (G_OBJECT (udpsink1), "send-duplicates", FALSE, NULL);
 819     stream->filter_duplicates = FALSE;
 820   } else {
 821     GST_WARNING ("multiudpsink version found without send-duplicates property");
 822     stream->filter_duplicates = TRUE;
 823   }
 824
 825   g_object_get (G_OBJECT (udpsrc1), "sock", &sockfd, NULL);
 826   g_object_set (G_OBJECT (udpsink1), "sockfd", sockfd, NULL);
 827   g_object_set (G_OBJECT (udpsink1), "closefd", FALSE, NULL);
 828   g_object_set (G_OBJECT (udpsink1), "sync", FALSE, NULL);
 829   g_object_set (G_OBJECT (udpsink1), "async", FALSE, NULL);
 830
 831   g_object_set (G_OBJECT (udpsink0), "auto-multicast", FALSE, NULL);
 832   g_object_set (G_OBJECT (udpsink0), "loop", FALSE, NULL);
 833   g_object_set (G_OBJECT (udpsink1), "auto-multicast", FALSE, NULL);
 834   g_object_set (G_OBJECT (udpsink1), "loop", FALSE, NULL);
 835
 836   /* we keep these elements, we configure all in configure_transport when the
 837    * server told us to really use the UDP ports. */
 838   stream->udpsrc[0] = udpsrc0;
 839   stream->udpsrc[1] = udpsrc1;
 840   stream->udpsink[0] = udpsink0;
 841   stream->udpsink[1] = udpsink1;
 842   stream->server_port.min = rtpport;
 843   stream->server_port.max = rtcpport;
 844
 845   return TRUE;
 846
 847   /* ERRORS */
 848 no_udp_protocol:
 849   {
 850     goto cleanup;
 851   }
 852 no_ports:
 853   {
 854     goto cleanup;
 855   }
 856 no_udp_rtcp_protocol:
 857   {
 858     goto cleanup;
 859   }
 860 port_error:
 861   {
 862     goto cleanup;
 863   }
 864 cleanup:
 865   {
 866     if (udpsrc0) {
 867       gst_element_set_state (udpsrc0, GST_STATE_NULL);
 868       gst_object_unref (udpsrc0);
 869     }
 870     if (udpsrc1) {
 871       gst_element_set_state (udpsrc1, GST_STATE_NULL);
 872       gst_object_unref (udpsrc1);
 873     }
 874     if (udpsink0) {
 875       gst_element_set_state (udpsink0, GST_STATE_NULL);
 876       gst_object_unref (udpsink0);
 877     }
 878     if (udpsink1) {
 879       gst_element_set_state (udpsink1, GST_STATE_NULL);
 880       gst_object_unref (udpsink1);
 881     }
 882     return FALSE;
 883   }
 884 }
 885
 886 /* executed from streaming thread */
 887 static void
 888 caps_notify (GstPad * pad, GParamSpec * unused, GstRTSPMediaStream * stream)
 889 {
 890   gchar *capsstr;
 891   GstCaps *newcaps, *oldcaps;
 892
 893   if ((newcaps = GST_PAD_CAPS (pad)))
 894     gst_caps_ref (newcaps);
 895
 896   oldcaps = stream->caps;
 897   stream->caps = newcaps;
 898
 899   if (oldcaps)
 900     gst_caps_unref (oldcaps);
 901
 902   capsstr = gst_caps_to_string (newcaps);
 903   GST_INFO ("stream %p received caps %p, %s", stream, newcaps, capsstr);
 904   g_free (capsstr);
 905 }
 906
 907 static void
 908 dump_structure (const GstStructure * s)
 909 {
 910   gchar *sstr;
 911
 912   sstr = gst_structure_to_string (s);
 913   GST_INFO ("structure: %s", sstr);
 914   g_free (sstr);
 915 }
 916
 917 static GstRTSPMediaTrans *
 918 find_transport (GstRTSPMediaStream * stream, const gchar * rtcp_from)
 919 {
 920   GList *walk;
 921   GstRTSPMediaTrans *result = NULL;
 922   const gchar *tmp;
 923   gchar *dest;
 924   guint port;
 925
 926   if (rtcp_from == NULL)
 927     return NULL;
 928
 929   tmp = g_strrstr (rtcp_from, ":");
 930   if (tmp == NULL)
 931     return NULL;
 932
 933   port = atoi (tmp + 1);
 934   dest = g_strndup (rtcp_from, tmp - rtcp_from);
 935
 936   GST_INFO ("finding %s:%d", dest, port);
 937
 938   for (walk = stream->transports; walk; walk = g_list_next (walk)) {
 939     GstRTSPMediaTrans *trans = walk->data;
 940     gint min, max;
 941
 942     min = trans->transport->client_port.min;
 943     max = trans->transport->client_port.max;
 944
 945     if ((strcmp (trans->transport->destination, dest) == 0) && (min == port
 946             || max == port)) {
 947       result = trans;
 948       break;
 949     }
 950   }
 951   g_free (dest);
 952
 953   return result;
 954 }
 955
 956 static void
 957 on_new_ssrc (GObject * session, GObject * source, GstRTSPMediaStream * stream)
 958 {
 959   GstStructure *stats;
 960   GstRTSPMediaTrans *trans;
 961
 962   GST_INFO ("%p: new source %p", stream, source);
 963
 964   /* see if we have a stream to match with the origin of the RTCP packet */
 965   trans = g_object_get_qdata (source, ssrc_stream_map_key);
 966   if (trans == NULL) {
 967     g_object_get (source, "stats", &stats, NULL);
 968     if (stats) {
 969       const gchar *rtcp_from;
 970
 971       dump_structure (stats);
 972
 973       rtcp_from = gst_structure_get_string (stats, "rtcp-from");
 974       if ((trans = find_transport (stream, rtcp_from))) {
 975         GST_INFO ("%p: found transport %p for source  %p", stream, trans,
 976             source);
 977
 978         /* keep ref to the source */
 979         trans->rtpsource = source;
 980
 981         g_object_set_qdata (source, ssrc_stream_map_key, trans);
 982       }
 983       gst_structure_free (stats);
 984     }
 985   } else {
 986     GST_INFO ("%p: source %p for transport %p", stream, source, trans);
 987   }
 988 }
 989
 990 static void
 991 on_ssrc_sdes (GObject * session, GObject * source, GstRTSPMediaStream * stream)
 992 {
 993   GST_INFO ("%p: new SDES %p", stream, source);
 994 }
 995
 996 static void
 997 on_ssrc_active (GObject * session, GObject * source,
 998     GstRTSPMediaStream * stream)
 999 {
1000   GstRTSPMediaTrans *trans;
1001
1002   trans = g_object_get_qdata (source, ssrc_stream_map_key);
1003
1004   GST_INFO ("%p: source %p in transport %p is active", stream, source, trans);
1005
1006   if (trans && trans->keep_alive)
1007     trans->keep_alive (trans->ka_user_data);
1008
1009 #ifdef DUMP_STATS
1010   {
1011     GstStructure *stats;
1012     g_object_get (source, "stats", &stats, NULL);
1013     if (stats) {
1014       dump_structure (stats);
1015       gst_structure_free (stats);
1016     }
1017   }
1018 #endif
1019 }
1020
1021 static void
1022 on_bye_ssrc (GObject * session, GObject * source, GstRTSPMediaStream * stream)
1023 {
1024   GST_INFO ("%p: source %p bye", stream, source);
1025 }
1026
1027 static void
1028 on_bye_timeout (GObject * session, GObject * source,
1029     GstRTSPMediaStream * stream)
1030 {
1031   GstRTSPMediaTrans *trans;
1032
1033   GST_INFO ("%p: source %p bye timeout", stream, source);
1034
1035   if ((trans = g_object_get_qdata (source, ssrc_stream_map_key))) {
1036     trans->rtpsource = NULL;
1037     trans->timeout = TRUE;
1038   }
1039 }
1040
1041 static void
1042 on_timeout (GObject * session, GObject * source, GstRTSPMediaStream * stream)
1043 {
1044   GstRTSPMediaTrans *trans;
1045
1046   GST_INFO ("%p: source %p timeout", stream, source);
1047
1048   if ((trans = g_object_get_qdata (source, ssrc_stream_map_key))) {
1049     trans->rtpsource = NULL;
1050     trans->timeout = TRUE;
1051   }
1052 }
1053
1054 static GstFlowReturn
1055 handle_new_buffer (GstAppSink * sink, gpointer user_data)
1056 {
1057   GList *walk;
1058   GstBuffer *buffer;
1059   GstRTSPMediaStream *stream;
1060
1061   buffer = gst_app_sink_pull_buffer (sink);
1062   if (!buffer)
1063     return GST_FLOW_OK;
1064
1065   stream = (GstRTSPMediaStream *) user_data;
1066
1067   for (walk = stream->transports; walk; walk = g_list_next (walk)) {
1068     GstRTSPMediaTrans *tr = (GstRTSPMediaTrans *) walk->data;
1069
1070     if (GST_ELEMENT_CAST (sink) == stream->appsink[0]) {
1071       if (tr->send_rtp)
1072         tr->send_rtp (buffer, tr->transport->interleaved.min, tr->user_data);
1073     } else {
1074       if (tr->send_rtcp)
1075         tr->send_rtcp (buffer, tr->transport->interleaved.max, tr->user_data);
1076     }
1077   }
1078   gst_buffer_unref (buffer);
1079
1080   return GST_FLOW_OK;
1081 }
1082
1083 static GstAppSinkCallbacks sink_cb = {
1084   NULL,                         /* not interested in EOS */
1085   NULL,                         /* not interested in preroll buffers */
1086   handle_new_buffer
1087 };
1088
1089 /* prepare the pipeline objects to handle @stream in @media */
1090 static gboolean
1091 setup_stream (GstRTSPMediaStream * stream, guint idx, GstRTSPMedia * media)
1092 {
1093   gchar *name;
1094   GstPad *pad, *teepad, *selpad;
1095   GstPadLinkReturn ret;
1096   gint i;
1097
1098   /* allocate udp ports, we will have 4 of them, 2 for receiving RTP/RTCP and 2
1099    * for sending RTP/RTCP. The sender and receiver ports are shared between the
1100    * elements */
1101   if (!alloc_udp_ports (media, stream))
1102     return FALSE;
1103
1104   /* add the ports to the pipeline */
1105   for (i = 0; i < 2; i++) {
1106     gst_bin_add (GST_BIN_CAST (media->pipeline), stream->udpsink[i]);
1107     gst_bin_add (GST_BIN_CAST (media->pipeline), stream->udpsrc[i]);
1108   }
1109
1110   /* create elements for the TCP transfer */
1111   for (i = 0; i < 2; i++) {
1112     stream->appsrc[i] = gst_element_factory_make ("appsrc", NULL);
1113     stream->appsink[i] = gst_element_factory_make ("appsink", NULL);
1114     g_object_set (stream->appsink[i], "async", FALSE, "sync", FALSE, NULL);
1115     g_object_set (stream->appsink[i], "emit-signals", FALSE, NULL);
1116     g_object_set (stream->appsink[i], "preroll-queue-len", 1, NULL);
1117     gst_bin_add (GST_BIN_CAST (media->pipeline), stream->appsink[i]);
1118     gst_bin_add (GST_BIN_CAST (media->pipeline), stream->appsrc[i]);
1119     gst_app_sink_set_callbacks (GST_APP_SINK_CAST (stream->appsink[i]),
1120         &sink_cb, stream, NULL);
1121   }
1122
1123   /* hook up the stream to the RTP session elements. */
1124   name = g_strdup_printf ("send_rtp_sink_%d", idx);
1125   stream->send_rtp_sink = gst_element_get_request_pad (media->rtpbin, name);
1126   g_free (name);
1127   name = g_strdup_printf ("send_rtp_src_%d", idx);
1128   stream->send_rtp_src = gst_element_get_static_pad (media->rtpbin, name);
1129   g_free (name);
1130   name = g_strdup_printf ("send_rtcp_src_%d", idx);
1131   stream->send_rtcp_src = gst_element_get_request_pad (media->rtpbin, name);
1132   g_free (name);
1133   name = g_strdup_printf ("recv_rtcp_sink_%d", idx);
1134   stream->recv_rtcp_sink = gst_element_get_request_pad (media->rtpbin, name);
1135   g_free (name);
1136   name = g_strdup_printf ("recv_rtp_sink_%d", idx);
1137   stream->recv_rtp_sink = gst_element_get_request_pad (media->rtpbin, name);
1138   g_free (name);
1139
1140   /* get the session */
1141   g_signal_emit_by_name (media->rtpbin, "get-internal-session", idx,
1142       &stream->session);
1143
1144   g_signal_connect (stream->session, "on-new-ssrc", (GCallback) on_new_ssrc,
1145       stream);
1146   g_signal_connect (stream->session, "on-ssrc-sdes", (GCallback) on_ssrc_sdes,
1147       stream);
1148   g_signal_connect (stream->session, "on-ssrc-active",
1149       (GCallback) on_ssrc_active, stream);
1150   g_signal_connect (stream->session, "on-bye-ssrc", (GCallback) on_bye_ssrc,
1151       stream);
1152   g_signal_connect (stream->session, "on-bye-timeout",
1153       (GCallback) on_bye_timeout, stream);
1154   g_signal_connect (stream->session, "on-timeout", (GCallback) on_timeout,
1155       stream);
1156
1157   /* link the RTP pad to the session manager */
1158   ret = gst_pad_link (stream->srcpad, stream->send_rtp_sink);
1159   if (ret != GST_PAD_LINK_OK)
1160     goto link_failed;
1161
1162   /* make tee for RTP and link to stream */
1163   stream->tee[0] = gst_element_factory_make ("tee", NULL);
1164   gst_bin_add (GST_BIN_CAST (media->pipeline), stream->tee[0]);
1165
1166   pad = gst_element_get_static_pad (stream->tee[0], "sink");
1167   gst_pad_link (stream->send_rtp_src, pad);
1168   gst_object_unref (pad);
1169
1170   /* link RTP sink, we're pretty sure this will work. */
1171   teepad = gst_element_get_request_pad (stream->tee[0], "src%d");
1172   pad = gst_element_get_static_pad (stream->udpsink[0], "sink");
1173   gst_pad_link (teepad, pad);
1174   gst_object_unref (pad);
1175   gst_object_unref (teepad);
1176
1177   teepad = gst_element_get_request_pad (stream->tee[0], "src%d");
1178   pad = gst_element_get_static_pad (stream->appsink[0], "sink");
1179   gst_pad_link (teepad, pad);
1180   gst_object_unref (pad);
1181   gst_object_unref (teepad);
1182
1183   /* make tee for RTCP */
1184   stream->tee[1] = gst_element_factory_make ("tee", NULL);
1185   gst_bin_add (GST_BIN_CAST (media->pipeline), stream->tee[1]);
1186
1187   pad = gst_element_get_static_pad (stream->tee[1], "sink");
1188   gst_pad_link (stream->send_rtcp_src, pad);
1189   gst_object_unref (pad);
1190
1191   /* link RTCP elements */
1192   teepad = gst_element_get_request_pad (stream->tee[1], "src%d");
1193   pad = gst_element_get_static_pad (stream->udpsink[1], "sink");
1194   gst_pad_link (teepad, pad);
1195   gst_object_unref (pad);
1196   gst_object_unref (teepad);
1197
1198   teepad = gst_element_get_request_pad (stream->tee[1], "src%d");
1199   pad = gst_element_get_static_pad (stream->appsink[1], "sink");
1200   gst_pad_link (teepad, pad);
1201   gst_object_unref (pad);
1202   gst_object_unref (teepad);
1203
1204   /* make selector for the RTP receivers */
1205   stream->selector[0] = gst_element_factory_make ("input-selector", NULL);
1206   g_object_set (stream->selector[0], "select-all", TRUE, NULL);
1207   gst_bin_add (GST_BIN_CAST (media->pipeline), stream->selector[0]);
1208
1209   pad = gst_element_get_static_pad (stream->selector[0], "src");
1210   gst_pad_link (pad, stream->recv_rtp_sink);
1211   gst_object_unref (pad);
1212
1213   selpad = gst_element_get_request_pad (stream->selector[0], "sink%d");
1214   pad = gst_element_get_static_pad (stream->udpsrc[0], "src");
1215   gst_pad_link (pad, selpad);
1216   gst_object_unref (pad);
1217   gst_object_unref (selpad);
1218
1219   selpad = gst_element_get_request_pad (stream->selector[0], "sink%d");
1220   pad = gst_element_get_static_pad (stream->appsrc[0], "src");
1221   gst_pad_link (pad, selpad);
1222   gst_object_unref (pad);
1223   gst_object_unref (selpad);
1224
1225   /* make selector for the RTCP receivers */
1226   stream->selector[1] = gst_element_factory_make ("input-selector", NULL);
1227   g_object_set (stream->selector[1], "select-all", TRUE, NULL);
1228   gst_bin_add (GST_BIN_CAST (media->pipeline), stream->selector[1]);
1229
1230   pad = gst_element_get_static_pad (stream->selector[1], "src");
1231   gst_pad_link (pad, stream->recv_rtcp_sink);
1232   gst_object_unref (pad);
1233
1234   selpad = gst_element_get_request_pad (stream->selector[1], "sink%d");
1235   pad = gst_element_get_static_pad (stream->udpsrc[1], "src");
1236   gst_pad_link (pad, selpad);
1237   gst_object_unref (pad);
1238   gst_object_unref (selpad);
1239
1240   selpad = gst_element_get_request_pad (stream->selector[1], "sink%d");
1241   pad = gst_element_get_static_pad (stream->appsrc[1], "src");
1242   gst_pad_link (pad, selpad);
1243   gst_object_unref (pad);
1244   gst_object_unref (selpad);
1245
1246   /* we set and keep these to playing so that they don't cause NO_PREROLL return
1247    * values */
1248   gst_element_set_state (stream->udpsrc[0], GST_STATE_PLAYING);
1249   gst_element_set_state (stream->udpsrc[1], GST_STATE_PLAYING);
1250   gst_element_set_locked_state (stream->udpsrc[0], TRUE);
1251   gst_element_set_locked_state (stream->udpsrc[1], TRUE);
1252
1253   /* be notified of caps changes */
1254   stream->caps_sig = g_signal_connect (stream->send_rtp_sink, "notify::caps",
1255       (GCallback) caps_notify, stream);
1256
1257   stream->prepared = TRUE;
1258
1259   return TRUE;
1260
1261   /* ERRORS */
1262 link_failed:
1263   {
1264     GST_WARNING ("failed to link stream %d", idx);
1265     return FALSE;
1266   }
1267 }
1268
1269 static void
1270 unlock_streams (GstRTSPMedia * media)
1271 {
1272   guint i, n_streams;
1273
1274   /* unlock the udp src elements */
1275   n_streams = gst_rtsp_media_n_streams (media);
1276   for (i = 0; i < n_streams; i++) {
1277     GstRTSPMediaStream *stream;
1278
1279     stream = gst_rtsp_media_get_stream (media, i);
1280
1281     gst_element_set_locked_state (stream->udpsrc[0], FALSE);
1282     gst_element_set_locked_state (stream->udpsrc[1], FALSE);
1283   }
1284 }
1285
1286 static void
1287 gst_rtsp_media_set_status (GstRTSPMedia * media, GstRTSPMediaStatus status)
1288 {
1289   g_mutex_lock (media->lock);
1290   /* never overwrite the error status */
1291   if (media->status != GST_RTSP_MEDIA_STATUS_ERROR)
1292     media->status = status;
1293   GST_DEBUG ("setting new status to %d", status);
1294   g_cond_broadcast (media->cond);
1295   g_mutex_unlock (media->lock);
1296 }
1297
1298 static GstRTSPMediaStatus
1299 gst_rtsp_media_get_status (GstRTSPMedia * media)
1300 {
1301   GstRTSPMediaStatus result;
1302   GTimeVal timeout;
1303
1304   g_mutex_lock (media->lock);
1305   g_get_current_time (&timeout);
1306   g_time_val_add (&timeout, 20 * G_USEC_PER_SEC);
1307   /* while we are preparing, wait */
1308   while (media->status == GST_RTSP_MEDIA_STATUS_PREPARING) {
1309     GST_DEBUG ("waiting for status change");
1310     if (!g_cond_timed_wait (media->cond, media->lock, &timeout)) {
1311       GST_DEBUG ("timeout, assuming error status");
1312       media->status = GST_RTSP_MEDIA_STATUS_ERROR;
1313     }
1314   }
1315   /* could be success or error */
1316   result = media->status;
1317   GST_DEBUG ("got status %d", result);
1318   g_mutex_unlock (media->lock);
1319
1320   return result;
1321 }
1322
1323 static gboolean
1324 default_handle_message (GstRTSPMedia * media, GstMessage * message)
1325 {
1326   GstMessageType type;
1327
1328   type = GST_MESSAGE_TYPE (message);
1329
1330   switch (type) {
1331     case GST_MESSAGE_STATE_CHANGED:
1332       break;
1333     case GST_MESSAGE_BUFFERING:
1334     {
1335       gint percent;
1336
1337       gst_message_parse_buffering (message, &percent);
1338
1339       /* no state management needed for live pipelines */
1340       if (media->is_live)
1341         break;
1342
1343       if (percent == 100) {
1344         /* a 100% message means buffering is done */
1345         media->buffering = FALSE;
1346         /* if the desired state is playing, go back */
1347         if (media->target_state == GST_STATE_PLAYING) {
1348           GST_INFO ("Buffering done, setting pipeline to PLAYING");
1349           gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1350         } else {
1351           GST_INFO ("Buffering done");
1352         }
1353       } else {
1354         /* buffering busy */
1355         if (media->buffering == FALSE) {
1356           if (media->target_state == GST_STATE_PLAYING) {
1357             /* we were not buffering but PLAYING, PAUSE  the pipeline. */
1358             GST_INFO ("Buffering, setting pipeline to PAUSED ...");
1359             gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
1360           } else {
1361             GST_INFO ("Buffering ...");
1362           }
1363         }
1364         media->buffering = TRUE;
1365       }
1366       break;
1367     }
1368     case GST_MESSAGE_LATENCY:
1369     {
1370       gst_bin_recalculate_latency (GST_BIN_CAST (media->pipeline));
1371       break;
1372     }
1373     case GST_MESSAGE_ERROR:
1374     {
1375       GError *gerror;
1376       gchar *debug;
1377
1378       gst_message_parse_error (message, &gerror, &debug);
1379       GST_WARNING ("%p: got error %s (%s)", media, gerror->message, debug);
1380       g_error_free (gerror);
1381       g_free (debug);
1382
1383       gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_ERROR);
1384       break;
1385     }
1386     case GST_MESSAGE_WARNING:
1387     {
1388       GError *gerror;
1389       gchar *debug;
1390
1391       gst_message_parse_warning (message, &gerror, &debug);
1392       GST_WARNING ("%p: got warning %s (%s)", media, gerror->message, debug);
1393       g_error_free (gerror);
1394       g_free (debug);
1395       break;
1396     }
1397     case GST_MESSAGE_ELEMENT:
1398       break;
1399     case GST_MESSAGE_STREAM_STATUS:
1400       break;
1401     case GST_MESSAGE_ASYNC_DONE:
1402       if (!media->adding) {
1403         /* when we are dynamically adding pads, the addition of the udpsrc will
1404          * temporarily produce ASYNC_DONE messages. We have to ignore them and
1405          * wait for the final ASYNC_DONE after everything prerolled */
1406         GST_INFO ("%p: got ASYNC_DONE", media);
1407         collect_media_stats (media);
1408
1409         gst_rtsp_media_set_status (media, GST_RTSP_MEDIA_STATUS_PREPARED);
1410       } else {
1411         GST_INFO ("%p: ignoring ASYNC_DONE", media);
1412       }
1413       break;
1414     case GST_MESSAGE_EOS:
1415       GST_INFO ("%p: got EOS", media);
1416       if (media->eos_pending) {
1417         GST_DEBUG ("shutting down after EOS");
1418         gst_element_set_state (media->pipeline, GST_STATE_NULL);
1419         media->eos_pending = FALSE;
1420         g_object_unref (media);
1421       }
1422       break;
1423     default:
1424       GST_INFO ("%p: got message type %s", media,
1425           gst_message_type_get_name (type));
1426       break;
1427   }
1428   return TRUE;
1429 }
1430
1431 static gboolean
1432 bus_message (GstBus * bus, GstMessage * message, GstRTSPMedia * media)
1433 {
1434   GstRTSPMediaClass *klass;
1435   gboolean ret;
1436
1437   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1438
1439   if (klass->handle_message)
1440     ret = klass->handle_message (media, message);
1441   else
1442     ret = FALSE;
1443
1444   return ret;
1445 }
1446
1447 /* called from streaming threads */
1448 static void
1449 pad_added_cb (GstElement * element, GstPad * pad, GstRTSPMedia * media)
1450 {
1451   GstRTSPMediaStream *stream;
1452   gchar *name;
1453   gint i;
1454
1455   i = media->streams->len + 1;
1456
1457   GST_INFO ("pad added %s:%s, stream %d", GST_DEBUG_PAD_NAME (pad), i);
1458
1459   stream = g_new0 (GstRTSPMediaStream, 1);
1460   stream->payloader = element;
1461
1462   name = g_strdup_printf ("dynpay%d", i);
1463
1464   media->adding = TRUE;
1465
1466   /* ghost the pad of the payloader to the element */
1467   stream->srcpad = gst_ghost_pad_new (name, pad);
1468   gst_pad_set_active (stream->srcpad, TRUE);
1469   gst_element_add_pad (media->element, stream->srcpad);
1470   g_free (name);
1471
1472   /* add stream now */
1473   g_array_append_val (media->streams, stream);
1474
1475   setup_stream (stream, i, media);
1476
1477   for (i = 0; i < 2; i++) {
1478     gst_element_set_state (stream->udpsink[i], GST_STATE_PAUSED);
1479     gst_element_set_state (stream->appsink[i], GST_STATE_PAUSED);
1480     gst_element_set_state (stream->tee[i], GST_STATE_PAUSED);
1481     gst_element_set_state (stream->selector[i], GST_STATE_PAUSED);
1482     gst_element_set_state (stream->appsrc[i], GST_STATE_PAUSED);
1483   }
1484   media->adding = FALSE;
1485 }
1486
1487 static void
1488 no_more_pads_cb (GstElement * element, GstRTSPMedia * media)
1489 {
1490   GST_INFO ("no more pads");
1491   if (media->fakesink) {
1492     gst_object_ref (media->fakesink);
1493     gst_bin_remove (GST_BIN (media->pipeline), media->fakesink);
1494     gst_element_set_state (media->fakesink, GST_STATE_NULL);
1495     gst_object_unref (media->fakesink);
1496     media->fakesink = NULL;
1497     GST_INFO ("removed fakesink");
1498   }
1499 }
1500
1501 /**
1502  * gst_rtsp_media_prepare:
1503  * @media: a #GstRTSPMedia
1504  *
1505  * Prepare @media for streaming. This function will create the pipeline and
1506  * other objects to manage the streaming.
1507  *
1508  * It will preroll the pipeline and collect vital information about the streams
1509  * such as the duration.
1510  *
1511  * Returns: %TRUE on success.
1512  */
1513 gboolean
1514 gst_rtsp_media_prepare (GstRTSPMedia * media)
1515 {
1516   GstStateChangeReturn ret;
1517   GstRTSPMediaStatus status;
1518   guint i, n_streams;
1519   GstRTSPMediaClass *klass;
1520   GstBus *bus;
1521   GList *walk;
1522
1523   if (media->status == GST_RTSP_MEDIA_STATUS_PREPARED)
1524     goto was_prepared;
1525
1526   if (!media->reusable && media->reused)
1527     goto is_reused;
1528
1529   GST_INFO ("preparing media %p", media);
1530
1531   /* reset some variables */
1532   media->is_live = FALSE;
1533   media->buffering = FALSE;
1534   /* we're preparing now */
1535   media->status = GST_RTSP_MEDIA_STATUS_PREPARING;
1536
1537   bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (media->pipeline));
1538
1539   /* add the pipeline bus to our custom mainloop */
1540   media->source = gst_bus_create_watch (bus);
1541   gst_object_unref (bus);
1542
1543   g_source_set_callback (media->source, (GSourceFunc) bus_message, media, NULL);
1544
1545   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1546   media->id = g_source_attach (media->source, klass->context);
1547
1548   media->rtpbin = gst_element_factory_make ("gstrtpbin", NULL);
1549
1550   /* add stuff to the bin */
1551   gst_bin_add (GST_BIN (media->pipeline), media->rtpbin);
1552
1553   /* link streams we already have, other streams might appear when we have
1554    * dynamic elements */
1555   n_streams = gst_rtsp_media_n_streams (media);
1556   for (i = 0; i < n_streams; i++) {
1557     GstRTSPMediaStream *stream;
1558
1559     stream = gst_rtsp_media_get_stream (media, i);
1560
1561     setup_stream (stream, i, media);
1562   }
1563
1564   for (walk = media->dynamic; walk; walk = g_list_next (walk)) {
1565     GstElement *elem = walk->data;
1566
1567     GST_INFO ("adding callbacks for dynamic element %p", elem);
1568
1569     g_signal_connect (elem, "pad-added", (GCallback) pad_added_cb, media);
1570     g_signal_connect (elem, "no-more-pads", (GCallback) no_more_pads_cb, media);
1571
1572     /* we add a fakesink here in order to make the state change async. We remove
1573      * the fakesink again in the no-more-pads callback. */
1574     media->fakesink = gst_element_factory_make ("fakesink", "fakesink");
1575     gst_bin_add (GST_BIN (media->pipeline), media->fakesink);
1576   }
1577
1578   GST_INFO ("setting pipeline to PAUSED for media %p", media);
1579   /* first go to PAUSED */
1580   ret = gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
1581   media->target_state = GST_STATE_PAUSED;
1582
1583   switch (ret) {
1584     case GST_STATE_CHANGE_SUCCESS:
1585       GST_INFO ("SUCCESS state change for media %p", media);
1586       break;
1587     case GST_STATE_CHANGE_ASYNC:
1588       GST_INFO ("ASYNC state change for media %p", media);
1589       break;
1590     case GST_STATE_CHANGE_NO_PREROLL:
1591       /* we need to go to PLAYING */
1592       GST_INFO ("NO_PREROLL state change: live media %p", media);
1593       media->is_live = TRUE;
1594       ret = gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1595       if (ret == GST_STATE_CHANGE_FAILURE)
1596         goto state_failed;
1597       break;
1598     case GST_STATE_CHANGE_FAILURE:
1599       goto state_failed;
1600   }
1601
1602   /* now wait for all pads to be prerolled */
1603   status = gst_rtsp_media_get_status (media);
1604   if (status == GST_RTSP_MEDIA_STATUS_ERROR)
1605     goto state_failed;
1606
1607   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_PREPARED], 0, NULL);
1608
1609   GST_INFO ("object %p is prerolled", media);
1610
1611   return TRUE;
1612
1613   /* OK */
1614 was_prepared:
1615   {
1616     return TRUE;
1617   }
1618   /* ERRORS */
1619 is_reused:
1620   {
1621     GST_WARNING ("can not reuse media %p", media);
1622     return FALSE;
1623   }
1624 state_failed:
1625   {
1626     GST_WARNING ("failed to preroll pipeline");
1627     unlock_streams (media);
1628     gst_element_set_state (media->pipeline, GST_STATE_NULL);
1629     gst_rtsp_media_unprepare (media);
1630     return FALSE;
1631   }
1632 }
1633
1634 /**
1635  * gst_rtsp_media_unprepare:
1636  * @media: a #GstRTSPMedia
1637  *
1638  * Unprepare @media. After this call, the media should be prepared again before
1639  * it can be used again. If the media is set to be non-reusable, a new instance
1640  * must be created.
1641  *
1642  * Returns: %TRUE on success.
1643  */
1644 gboolean
1645 gst_rtsp_media_unprepare (GstRTSPMedia * media)
1646 {
1647   GstRTSPMediaClass *klass;
1648   gboolean success;
1649
1650   if (media->status == GST_RTSP_MEDIA_STATUS_UNPREPARED)
1651     return TRUE;
1652
1653   GST_INFO ("unprepare media %p", media);
1654   media->target_state = GST_STATE_NULL;
1655
1656   klass = GST_RTSP_MEDIA_GET_CLASS (media);
1657   if (klass->unprepare)
1658     success = klass->unprepare (media);
1659   else
1660     success = TRUE;
1661
1662   media->status = GST_RTSP_MEDIA_STATUS_UNPREPARED;
1663   media->reused = TRUE;
1664
1665   /* when the media is not reusable, this will effectively unref the media and
1666    * recreate it */
1667   g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_UNPREPARED], 0, NULL);
1668
1669   return success;
1670 }
1671
1672 static gboolean
1673 default_unprepare (GstRTSPMedia * media)
1674 {
1675   if (media->eos_shutdown) {
1676     GST_DEBUG ("sending EOS for shutdown");
1677     /* ref so that we don't disappear */
1678     g_object_ref (media);
1679     media->eos_pending = TRUE;
1680     gst_element_send_event (media->pipeline, gst_event_new_eos ());
1681     /* we need to go to playing again for the EOS to propagate, normally in this
1682      * state, nothing is receiving data from us anymore so this is ok. */
1683     gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
1684   } else {
1685     GST_DEBUG ("shutting down");
1686     gst_element_set_state (media->pipeline, GST_STATE_NULL);
1687   }
1688   return TRUE;
1689 }
1690
1691 static void
1692 add_udp_destination (GstRTSPMedia * media, GstRTSPMediaStream * stream,
1693     gchar * dest, gint min, gint max)
1694 {
1695   gboolean do_add = TRUE;
1696   RTSPDestination *ndest;
1697
1698   if (stream->filter_duplicates) {
1699     RTSPDestination fdest;
1700     GList *find;
1701
1702     fdest.dest = dest;
1703     fdest.min = min;
1704     fdest.max = max;
1705
1706     /* first see if we already added this destination */
1707     find =
1708         g_list_find_custom (stream->destinations, &fdest,
1709         (GCompareFunc) dest_compare);
1710     if (find) {
1711       ndest = (RTSPDestination *) find->data;
1712
1713       GST_INFO ("already streaming to %s:%d-%d with %d clients", dest, min, max,
1714           ndest->count);
1715       ndest->count++;
1716       do_add = FALSE;
1717     }
1718   }
1719
1720   if (do_add) {
1721     GST_INFO ("adding %s:%d-%d", dest, min, max);
1722     g_signal_emit_by_name (stream->udpsink[0], "add", dest, min, NULL);
1723     g_signal_emit_by_name (stream->udpsink[1], "add", dest, max, NULL);
1724
1725     if (stream->filter_duplicates) {
1726       ndest = create_destination (dest, min, max);
1727       stream->destinations = g_list_prepend (stream->destinations, ndest);
1728     }
1729   }
1730 }
1731
1732 static void
1733 remove_udp_destination (GstRTSPMedia * media, GstRTSPMediaStream * stream,
1734     gchar * dest, gint min, gint max)
1735 {
1736   gboolean do_remove = TRUE;
1737   RTSPDestination *ndest = NULL;
1738   GList *find = NULL;
1739
1740   if (stream->filter_duplicates) {
1741     RTSPDestination fdest;
1742
1743     fdest.dest = dest;
1744     fdest.min = min;
1745     fdest.max = max;
1746
1747     /* first see if we already added this destination */
1748     find =
1749         g_list_find_custom (stream->destinations, &fdest,
1750         (GCompareFunc) dest_compare);
1751     if (!find)
1752       return;
1753
1754     ndest = (RTSPDestination *) find->data;
1755     if (--ndest->count > 0) {
1756       do_remove = FALSE;
1757       GST_INFO ("still streaming to %s:%d-%d with %d clients", dest, min, max,
1758           ndest->count);
1759     }
1760   }
1761
1762   if (do_remove) {
1763     GST_INFO ("removing %s:%d-%d", dest, min, max);
1764     g_signal_emit_by_name (stream->udpsink[0], "remove", dest, min, NULL);
1765     g_signal_emit_by_name (stream->udpsink[1], "remove", dest, max, NULL);
1766
1767     if (stream->filter_duplicates) {
1768       stream->destinations = g_list_delete_link (stream->destinations, find);
1769       free_destination (ndest);
1770     }
1771   }
1772 }
1773
1774 /**
1775  * gst_rtsp_media_set_state:
1776  * @media: a #GstRTSPMedia
1777  * @state: the target state of the media
1778  * @transports: a #GArray of #GstRTSPMediaTrans pointers
1779  *
1780  * Set the state of @media to @state and for the transports in @transports.
1781  *
1782  * Returns: %TRUE on success.
1783  */
1784 gboolean
1785 gst_rtsp_media_set_state (GstRTSPMedia * media, GstState state,
1786     GArray * transports)
1787 {
1788   gint i;
1789   GstStateChangeReturn ret;
1790   gboolean add, remove, do_state;
1791   gint old_active;
1792
1793   g_return_val_if_fail (GST_IS_RTSP_MEDIA (media), FALSE);
1794   g_return_val_if_fail (transports != NULL, FALSE);
1795
1796   /* NULL and READY are the same */
1797   if (state == GST_STATE_READY)
1798     state = GST_STATE_NULL;
1799
1800   add = remove = FALSE;
1801
1802   GST_INFO ("going to state %s media %p", gst_element_state_get_name (state),
1803       media);
1804
1805   switch (state) {
1806     case GST_STATE_NULL:
1807       /* unlock the streams so that they follow the state changes from now on */
1808       unlock_streams (media);
1809       /* fallthrough */
1810     case GST_STATE_PAUSED:
1811       /* we're going from PLAYING to PAUSED, READY or NULL, remove */
1812       if (media->target_state == GST_STATE_PLAYING)
1813         remove = TRUE;
1814       break;
1815     case GST_STATE_PLAYING:
1816       /* we're going to PLAYING, add */
1817       add = TRUE;
1818       break;
1819     default:
1820       break;
1821   }
1822   old_active = media->active;
1823
1824   for (i = 0; i < transports->len; i++) {
1825     GstRTSPMediaTrans *tr;
1826     GstRTSPMediaStream *stream;
1827     GstRTSPTransport *trans;
1828
1829     /* we need a non-NULL entry in the array */
1830     tr = g_array_index (transports, GstRTSPMediaTrans *, i);
1831     if (tr == NULL)
1832       continue;
1833
1834     /* we need a transport */
1835     if (!(trans = tr->transport))
1836       continue;
1837
1838     /* get the stream and add the destinations */
1839     stream = gst_rtsp_media_get_stream (media, tr->idx);
1840     switch (trans->lower_transport) {
1841       case GST_RTSP_LOWER_TRANS_UDP:
1842       case GST_RTSP_LOWER_TRANS_UDP_MCAST:
1843       {
1844         gchar *dest;
1845         gint min, max;
1846
1847         dest = trans->destination;
1848         if (trans->lower_transport == GST_RTSP_LOWER_TRANS_UDP_MCAST) {
1849           min = trans->port.min;
1850           max = trans->port.max;
1851         } else {
1852           min = trans->client_port.min;
1853           max = trans->client_port.max;
1854         }
1855
1856         if (add && !tr->active) {
1857           add_udp_destination (media, stream, dest, min, max);
1858           stream->transports = g_list_prepend (stream->transports, tr);
1859           tr->active = TRUE;
1860           media->active++;
1861         } else if (remove && tr->active) {
1862           remove_udp_destination (media, stream, dest, min, max);
1863           stream->transports = g_list_remove (stream->transports, tr);
1864           tr->active = FALSE;
1865           media->active--;
1866         }
1867         break;
1868       }
1869       case GST_RTSP_LOWER_TRANS_TCP:
1870         if (add && !tr->active) {
1871           GST_INFO ("adding TCP %s", trans->destination);
1872           stream->transports = g_list_prepend (stream->transports, tr);
1873           tr->active = TRUE;
1874           media->active++;
1875         } else if (remove && tr->active) {
1876           GST_INFO ("removing TCP %s", trans->destination);
1877           stream->transports = g_list_remove (stream->transports, tr);
1878           tr->active = FALSE;
1879           media->active--;
1880         }
1881         break;
1882       default:
1883         GST_INFO ("Unknown transport %d", trans->lower_transport);
1884         break;
1885     }
1886   }
1887
1888   /* we just added the first media, do the playing state change */
1889   if (old_active == 0 && add)
1890     do_state = TRUE;
1891   /* if we have no more active media, do the downward state changes */
1892   else if (media->active == 0)
1893     do_state = TRUE;
1894   else
1895     do_state = FALSE;
1896
1897   GST_INFO ("state %d active %d media %p do_state %d", state, media->active,
1898       media, do_state);
1899
1900   if (media->target_state != state) {
1901     if (do_state) {
1902       if (state == GST_STATE_NULL) {
1903         gst_rtsp_media_unprepare (media);
1904       } else {
1905         GST_INFO ("state %s media %p", gst_element_state_get_name (state),
1906             media);
1907         media->target_state = state;
1908         ret = gst_element_set_state (media->pipeline, state);
1909       }
1910     }
1911     g_signal_emit (media, gst_rtsp_media_signals[SIGNAL_NEW_STATE], 0, state,
1912         NULL);
1913   }
1914
1915   /* remember where we are */
1916   if (state == GST_STATE_PAUSED || old_active != media->active)
1917     collect_media_stats (media);
1918
1919   return TRUE;
1920 }
1921
1922 /**
1923  * gst_rtsp_media_remove_elements:
1924  * @media: a #GstRTSPMedia
1925  *
1926  * Remove all elements and the pipeline controlled by @media.
1927  */
1928 void
1929 gst_rtsp_media_remove_elements (GstRTSPMedia * media)
1930 {
1931   gint i, j;
1932
1933   unlock_streams (media);
1934
1935   for (i = 0; i < media->streams->len; i++) {
1936     GstRTSPMediaStream *stream;
1937
1938     GST_INFO ("Removing elements of stream %d from pipeline", i);
1939
1940     stream = g_array_index (media->streams, GstRTSPMediaStream *, i);
1941
1942     gst_pad_unlink (stream->srcpad, stream->send_rtp_sink);
1943
1944     g_signal_handler_disconnect (stream->send_rtp_sink, stream->caps_sig);
1945
1946     for (j = 0; j < 2; j++) {
1947       gst_element_set_state (stream->udpsrc[j], GST_STATE_NULL);
1948       gst_element_set_state (stream->udpsink[j], GST_STATE_NULL);
1949       gst_element_set_state (stream->appsrc[j], GST_STATE_NULL);
1950       gst_element_set_state (stream->appsink[j], GST_STATE_NULL);
1951       gst_element_set_state (stream->tee[j], GST_STATE_NULL);
1952       gst_element_set_state (stream->selector[j], GST_STATE_NULL);
1953
1954       gst_bin_remove (GST_BIN (media->pipeline), stream->udpsrc[j]);
1955       gst_bin_remove (GST_BIN (media->pipeline), stream->udpsink[j]);
1956       gst_bin_remove (GST_BIN (media->pipeline), stream->appsrc[j]);
1957       gst_bin_remove (GST_BIN (media->pipeline), stream->appsink[j]);
1958       gst_bin_remove (GST_BIN (media->pipeline), stream->tee[j]);
1959       gst_bin_remove (GST_BIN (media->pipeline), stream->selector[j]);
1960     }
1961     if (stream->caps)
1962       gst_caps_unref (stream->caps);
1963     stream->caps = NULL;
1964     gst_rtsp_media_stream_free (stream);
1965   }
1966   g_array_remove_range (media->streams, 0, media->streams->len);
1967
1968   gst_element_set_state (media->rtpbin, GST_STATE_NULL);
1969   gst_bin_remove (GST_BIN (media->pipeline), media->rtpbin);
1970
1971   gst_object_unref (media->pipeline);
1972   media->pipeline = NULL;
1973 }