gst/rtpmanager/gstrtpptdemux.c

   1 /*
   2  * RTP Demux element
   3  *
   4  * Copyright (C) 2005 Nokia Corporation.
   5  * @author Kai Vehmanen <kai.vehmanen@nokia.com>
   6  *
   7  * Loosely based on GStreamer gstdecodebin
   8  * Copyright (C) <2004> Wim Taymans <wim.taymans@gmail.com>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public
  21  * License along with this library; if not, write to the
  22  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  23  * Boston, MA 02110-1301, USA.
  24  */
  25
  26 /**
  27  * SECTION:element-rtpptdemux
  28  *
  29  * rtpptdemux acts as a demuxer for RTP packets based on the payload type of
  30  * the packets. Its main purpose is to allow an application to easily receive
  31  * and decode an RTP stream with multiple payload types.
  32  *
  33  * For each payload type that is detected, a new pad will be created and the
  34  * #GstRtpPtDemux::new-payload-type signal will be emitted. When the payload for
  35  * the RTP stream changes, the #GstRtpPtDemux::payload-type-change signal will be
  36  * emitted.
  37  *
  38  * The element will try to set complete and unique application/x-rtp caps
  39  * on the output pads based on the result of the #GstRtpPtDemux::request-pt-map
  40  * signal.
  41  *
  42  * <refsect2>
  43  * <title>Example pipelines</title>
  44  * |[
  45  * gst-launch-1.0 udpsrc caps="application/x-rtp" ! rtpptdemux ! fakesink
  46  * ]| Takes an RTP stream and send the RTP packets with the first detected
  47  * payload type to fakesink, discarding the other payload types.
  48  * </refsect2>
  49  */
  50
  51 /*
  52  * Contributors:
  53  * Andre Moreira Magalhaes <andre.magalhaes@indt.org.br>
  54  */
  55 /*
  56  * Status:
  57  *  - works with the test_rtpdemux.c tool
  58  *
  59  * Check:
  60  *  - is emitting a signal enough, or should we
  61  *    use GstEvent to notify downstream elements
  62  *    of the new packet... no?
  63  *
  64  * Notes:
  65  *  - emits event both for new PTs, and whenever
  66  *    a PT is changed
  67  */
  68
  69 #ifdef HAVE_CONFIG_H
  70 #include "config.h"
  71 #endif
  72
  73 #include <string.h>
  74 #include <gst/gst.h>
  75 #include <gst/rtp/gstrtpbuffer.h>
  76
  77 #include "gstrtpptdemux.h"
  78
  79 /* generic templates */
  80 static GstStaticPadTemplate rtp_pt_demux_sink_template =
  81 GST_STATIC_PAD_TEMPLATE ("sink",
  82     GST_PAD_SINK,
  83     GST_PAD_ALWAYS,
  84     GST_STATIC_CAPS ("application/x-rtp")
  85     );
  86
  87 static GstStaticPadTemplate rtp_pt_demux_src_template =
  88 GST_STATIC_PAD_TEMPLATE ("src_%u",
  89     GST_PAD_SRC,
  90     GST_PAD_SOMETIMES,
  91     GST_STATIC_CAPS ("application/x-rtp, " "payload = (int) [ 0, 255 ]")
  92     );
  93
  94 GST_DEBUG_CATEGORY_STATIC (gst_rtp_pt_demux_debug);
  95 #define GST_CAT_DEFAULT gst_rtp_pt_demux_debug
  96
  97 /*
  98  * Item for storing GstPad<->pt pairs.
  99  */
 100 struct _GstRtpPtDemuxPad
 101 {
 102   GstPad *pad;        /**< pointer to the actual pad */
 103   gint pt;             /**< RTP payload-type attached to pad */
 104   gboolean newcaps;
 105 };
 106
 107 /* signals */
 108 enum
 109 {
 110   SIGNAL_REQUEST_PT_MAP,
 111   SIGNAL_NEW_PAYLOAD_TYPE,
 112   SIGNAL_PAYLOAD_TYPE_CHANGE,
 113   SIGNAL_CLEAR_PT_MAP,
 114   LAST_SIGNAL
 115 };
 116
 117 enum
 118 {
 119   PROP_0,
 120   PROP_IGNORED_PTS,
 121 };
 122
 123 #define gst_rtp_pt_demux_parent_class parent_class
 124 G_DEFINE_TYPE (GstRtpPtDemux, gst_rtp_pt_demux, GST_TYPE_ELEMENT);
 125
 126 static void gst_rtp_pt_demux_finalize (GObject * object);
 127
 128 static void gst_rtp_pt_demux_release (GstRtpPtDemux * ptdemux);
 129 static gboolean gst_rtp_pt_demux_setup (GstRtpPtDemux * ptdemux);
 130
 131 static gboolean gst_rtp_pt_demux_sink_event (GstPad * pad, GstObject * parent,
 132     GstEvent * event);
 133 static GstFlowReturn gst_rtp_pt_demux_chain (GstPad * pad, GstObject * parent,
 134     GstBuffer * buf);
 135 static GstStateChangeReturn gst_rtp_pt_demux_change_state (GstElement * element,
 136     GstStateChange transition);
 137 static void gst_rtp_pt_demux_clear_pt_map (GstRtpPtDemux * rtpdemux);
 138
 139 static GstPad *find_pad_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt);
 140
 141 static gboolean gst_rtp_pt_demux_src_event (GstPad * pad, GstObject * parent,
 142     GstEvent * event);
 143
 144
 145 static guint gst_rtp_pt_demux_signals[LAST_SIGNAL] = { 0 };
 146
 147 static void
 148 gst_rtp_pt_demux_set_property (GObject * object, guint prop_id,
 149     const GValue * value, GParamSpec * pspec)
 150 {
 151   GstRtpPtDemux *rtpptdemux = GST_RTP_PT_DEMUX (object);
 152
 153   switch (prop_id) {
 154     case PROP_IGNORED_PTS:
 155       g_value_copy (value, &rtpptdemux->ignored_pts);
 156       break;
 157     default:
 158       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 159       break;
 160   }
 161 }
 162
 163 static void
 164 gst_rtp_pt_demux_get_property (GObject * object, guint prop_id,
 165     GValue * value, GParamSpec * pspec)
 166 {
 167   GstRtpPtDemux *rtpptdemux = GST_RTP_PT_DEMUX (object);
 168
 169   switch (prop_id) {
 170     case PROP_IGNORED_PTS:
 171       g_value_copy (&rtpptdemux->ignored_pts, value);
 172       break;
 173     default:
 174       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 175       break;
 176   }
 177 }
 178
 179 static void
 180 gst_rtp_pt_demux_class_init (GstRtpPtDemuxClass * klass)
 181 {
 182   GObjectClass *gobject_klass;
 183   GstElementClass *gstelement_klass;
 184
 185   gobject_klass = (GObjectClass *) klass;
 186   gstelement_klass = (GstElementClass *) klass;
 187
 188   /**
 189    * GstRtpPtDemux::request-pt-map:
 190    * @demux: the object which received the signal
 191    * @pt: the payload type
 192    *
 193    * Request the payload type as #GstCaps for @pt.
 194    */
 195   gst_rtp_pt_demux_signals[SIGNAL_REQUEST_PT_MAP] =
 196       g_signal_new ("request-pt-map", G_TYPE_FROM_CLASS (klass),
 197       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass, request_pt_map),
 198       NULL, NULL, g_cclosure_marshal_generic, GST_TYPE_CAPS, 1, G_TYPE_UINT);
 199
 200   /**
 201    * GstRtpPtDemux::new-payload-type:
 202    * @demux: the object which received the signal
 203    * @pt: the payload type
 204    * @pad: the pad with the new payload
 205    *
 206    * Emited when a new payload type pad has been created in @demux.
 207    */
 208   gst_rtp_pt_demux_signals[SIGNAL_NEW_PAYLOAD_TYPE] =
 209       g_signal_new ("new-payload-type", G_TYPE_FROM_CLASS (klass),
 210       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass, new_payload_type),
 211       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, G_TYPE_UINT,
 212       GST_TYPE_PAD);
 213
 214   /**
 215    * GstRtpPtDemux::payload-type-change:
 216    * @demux: the object which received the signal
 217    * @pt: the new payload type
 218    *
 219    * Emited when the payload type changed.
 220    */
 221   gst_rtp_pt_demux_signals[SIGNAL_PAYLOAD_TYPE_CHANGE] =
 222       g_signal_new ("payload-type-change", G_TYPE_FROM_CLASS (klass),
 223       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass,
 224           payload_type_change), NULL, NULL, g_cclosure_marshal_VOID__UINT,
 225       G_TYPE_NONE, 1, G_TYPE_UINT);
 226
 227   /**
 228    * GstRtpPtDemux::clear-pt-map:
 229    * @demux: the object which received the signal
 230    *
 231    * The application can call this signal to instruct the element to discard the
 232    * currently cached payload type map.
 233    */
 234   gst_rtp_pt_demux_signals[SIGNAL_CLEAR_PT_MAP] =
 235       g_signal_new ("clear-pt-map", G_TYPE_FROM_CLASS (klass),
 236       G_SIGNAL_ACTION | G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass,
 237           clear_pt_map), NULL, NULL, g_cclosure_marshal_VOID__VOID,
 238       G_TYPE_NONE, 0, G_TYPE_NONE);
 239
 240   gobject_klass->set_property = gst_rtp_pt_demux_set_property;
 241   gobject_klass->get_property = gst_rtp_pt_demux_get_property;
 242
 243   /**
 244    * GstRtpPtDemux:ignored-payload-types:
 245    *
 246    * If specified, packets with an ignored payload type will be dropped,
 247    * instead of causing a new pad to be exposed for these to be pushed on.
 248    *
 249    * This is for example useful to drop FEC protection packets, as they
 250    * need to go through the #GstRtpJitterBuffer, but cease to be useful
 251    * past that point, #GstRtpBin will make use of this property for that
 252    * purpose.
 253    *
 254    * Since: 1.14
 255    */
 256   g_object_class_install_property (gobject_klass, PROP_IGNORED_PTS,
 257       gst_param_spec_array ("ignored-payload-types",
 258           "Ignored payload types",
 259           "Packets with these payload types will be dropped",
 260           g_param_spec_int ("payload-types", "payload-types", "Payload types",
 261               0, G_MAXINT, 0,
 262               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
 263           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 264
 265   gobject_klass->finalize = gst_rtp_pt_demux_finalize;
 266
 267   gstelement_klass->change_state =
 268       GST_DEBUG_FUNCPTR (gst_rtp_pt_demux_change_state);
 269
 270   klass->clear_pt_map = GST_DEBUG_FUNCPTR (gst_rtp_pt_demux_clear_pt_map);
 271
 272   gst_element_class_add_static_pad_template (gstelement_klass,
 273       &rtp_pt_demux_sink_template);
 274   gst_element_class_add_static_pad_template (gstelement_klass,
 275       &rtp_pt_demux_src_template);
 276
 277   gst_element_class_set_static_metadata (gstelement_klass, "RTP Demux",
 278       "Demux/Network/RTP",
 279       "Parses codec streams transmitted in the same RTP session",
 280       "Kai Vehmanen <kai.vehmanen@nokia.com>");
 281
 282   GST_DEBUG_CATEGORY_INIT (gst_rtp_pt_demux_debug,
 283       "rtpptdemux", 0, "RTP codec demuxer");
 284
 285   GST_DEBUG_REGISTER_FUNCPTR (gst_rtp_pt_demux_chain);
 286 }
 287
 288 static void
 289 gst_rtp_pt_demux_init (GstRtpPtDemux * ptdemux)
 290 {
 291   GstElementClass *klass = GST_ELEMENT_GET_CLASS (ptdemux);
 292
 293   ptdemux->sink =
 294       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
 295           "sink"), "sink");
 296   g_assert (ptdemux->sink != NULL);
 297
 298   gst_pad_set_chain_function (ptdemux->sink, gst_rtp_pt_demux_chain);
 299   gst_pad_set_event_function (ptdemux->sink, gst_rtp_pt_demux_sink_event);
 300
 301   gst_element_add_pad (GST_ELEMENT (ptdemux), ptdemux->sink);
 302
 303   g_value_init (&ptdemux->ignored_pts, GST_TYPE_ARRAY);
 304 }
 305
 306 static void
 307 gst_rtp_pt_demux_finalize (GObject * object)
 308 {
 309   gst_rtp_pt_demux_release (GST_RTP_PT_DEMUX (object));
 310
 311   g_value_unset (&GST_RTP_PT_DEMUX (object)->ignored_pts);
 312
 313   G_OBJECT_CLASS (parent_class)->finalize (object);
 314 }
 315
 316 static GstCaps *
 317 gst_rtp_pt_demux_get_caps (GstRtpPtDemux * rtpdemux, guint pt)
 318 {
 319   GstCaps *caps;
 320   GValue ret = { 0 };
 321   GValue args[2] = { {0}, {0} };
 322   GstCaps *sink_caps;
 323
 324   /* figure out the caps */
 325   g_value_init (&args[0], GST_TYPE_ELEMENT);
 326   g_value_set_object (&args[0], rtpdemux);
 327   g_value_init (&args[1], G_TYPE_UINT);
 328   g_value_set_uint (&args[1], pt);
 329
 330   g_value_init (&ret, GST_TYPE_CAPS);
 331   g_value_set_boxed (&ret, NULL);
 332
 333   g_signal_emitv (args, gst_rtp_pt_demux_signals[SIGNAL_REQUEST_PT_MAP], 0,
 334       &ret);
 335
 336   g_value_unset (&args[0]);
 337   g_value_unset (&args[1]);
 338   caps = g_value_dup_boxed (&ret);
 339   g_value_unset (&ret);
 340
 341   sink_caps = gst_pad_get_current_caps (rtpdemux->sink);
 342
 343   if (sink_caps) {
 344     if (caps == NULL) {
 345       caps = gst_caps_ref (sink_caps);
 346     } else {
 347       GstStructure *s1;
 348       GstStructure *s2;
 349       guint ssrc;
 350
 351       caps = gst_caps_make_writable (caps);
 352       s1 = gst_caps_get_structure (sink_caps, 0);
 353       s2 = gst_caps_get_structure (caps, 0);
 354
 355       gst_structure_get_uint (s1, "ssrc", &ssrc);
 356       gst_structure_set (s2, "ssrc", G_TYPE_UINT, ssrc, NULL);
 357     }
 358
 359     gst_caps_unref (sink_caps);
 360   }
 361
 362   GST_DEBUG ("pt %d, got caps %" GST_PTR_FORMAT, pt, caps);
 363
 364   return caps;
 365 }
 366
 367 static void
 368 gst_rtp_pt_demux_clear_pt_map (GstRtpPtDemux * rtpdemux)
 369 {
 370   GSList *walk;
 371
 372   GST_OBJECT_LOCK (rtpdemux);
 373   GST_DEBUG ("clearing pt map");
 374   for (walk = rtpdemux->srcpads; walk; walk = g_slist_next (walk)) {
 375     GstRtpPtDemuxPad *pad = walk->data;
 376
 377     pad->newcaps = TRUE;
 378   }
 379   GST_OBJECT_UNLOCK (rtpdemux);
 380 }
 381
 382 static gboolean
 383 need_caps_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt)
 384 {
 385   GSList *walk;
 386   gboolean ret = FALSE;
 387
 388   GST_OBJECT_LOCK (rtpdemux);
 389   for (walk = rtpdemux->srcpads; walk; walk = g_slist_next (walk)) {
 390     GstRtpPtDemuxPad *pad = walk->data;
 391
 392     if (pad->pt == pt) {
 393       ret = pad->newcaps;
 394     }
 395   }
 396   GST_OBJECT_UNLOCK (rtpdemux);
 397
 398   return ret;
 399 }
 400
 401
 402 static void
 403 clear_newcaps_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt)
 404 {
 405   GSList *walk;
 406
 407   GST_OBJECT_LOCK (rtpdemux);
 408   for (walk = rtpdemux->srcpads; walk; walk = g_slist_next (walk)) {
 409     GstRtpPtDemuxPad *pad = walk->data;
 410
 411     if (pad->pt == pt) {
 412       pad->newcaps = FALSE;
 413       break;
 414     }
 415   }
 416   GST_OBJECT_UNLOCK (rtpdemux);
 417 }
 418
 419 static gboolean
 420 forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data)
 421 {
 422   GstPad *srcpad = GST_PAD_CAST (user_data);
 423
 424   /* Stream start and caps have already been pushed */
 425   if (GST_EVENT_TYPE (*event) >= GST_EVENT_SEGMENT)
 426     gst_pad_push_event (srcpad, gst_event_ref (*event));
 427
 428   return TRUE;
 429 }
 430
 431 static gboolean
 432 gst_rtp_pt_demux_pt_is_ignored (GstRtpPtDemux * ptdemux, guint8 pt)
 433 {
 434   gboolean ret = FALSE;
 435   guint i;
 436
 437   for (i = 0; i < gst_value_array_get_size (&ptdemux->ignored_pts); i++) {
 438     const GValue *tmp = gst_value_array_get_value (&ptdemux->ignored_pts, i);
 439
 440     if (g_value_get_int (tmp) == pt) {
 441       ret = TRUE;
 442       break;
 443     }
 444   }
 445
 446   return ret;
 447 }
 448
 449 static GstFlowReturn
 450 gst_rtp_pt_demux_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
 451 {
 452   GstFlowReturn ret = GST_FLOW_OK;
 453   GstRtpPtDemux *rtpdemux;
 454   guint8 pt;
 455   GstPad *srcpad;
 456   GstCaps *caps;
 457   GstRTPBuffer rtp = { NULL };
 458
 459   rtpdemux = GST_RTP_PT_DEMUX (parent);
 460
 461   if (!gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp))
 462     goto invalid_buffer;
 463
 464   pt = gst_rtp_buffer_get_payload_type (&rtp);
 465   gst_rtp_buffer_unmap (&rtp);
 466
 467   if (gst_rtp_pt_demux_pt_is_ignored (rtpdemux, pt))
 468     goto ignored;
 469
 470   GST_DEBUG_OBJECT (rtpdemux, "received buffer for pt %d", pt);
 471
 472   srcpad = find_pad_for_pt (rtpdemux, pt);
 473   if (srcpad == NULL) {
 474     /* new PT, create a src pad */
 475     GstRtpPtDemuxPad *rtpdemuxpad;
 476     GstElementClass *klass;
 477     GstPadTemplate *templ;
 478     gchar *padname;
 479
 480     caps = gst_rtp_pt_demux_get_caps (rtpdemux, pt);
 481     if (!caps)
 482       goto no_caps;
 483
 484     if (gst_rtp_pt_demux_pt_is_ignored (rtpdemux, pt))
 485       goto ignored;
 486
 487     klass = GST_ELEMENT_GET_CLASS (rtpdemux);
 488     templ = gst_element_class_get_pad_template (klass, "src_%u");
 489     padname = g_strdup_printf ("src_%u", pt);
 490     srcpad = gst_pad_new_from_template (templ, padname);
 491     gst_pad_use_fixed_caps (srcpad);
 492     g_free (padname);
 493     gst_pad_set_event_function (srcpad, gst_rtp_pt_demux_src_event);
 494
 495     GST_DEBUG ("Adding pt=%d to the list.", pt);
 496     rtpdemuxpad = g_slice_new0 (GstRtpPtDemuxPad);
 497     rtpdemuxpad->pt = pt;
 498     rtpdemuxpad->newcaps = FALSE;
 499     rtpdemuxpad->pad = srcpad;
 500     gst_object_ref (srcpad);
 501     GST_OBJECT_LOCK (rtpdemux);
 502     rtpdemux->srcpads = g_slist_append (rtpdemux->srcpads, rtpdemuxpad);
 503     GST_OBJECT_UNLOCK (rtpdemux);
 504
 505     gst_pad_set_active (srcpad, TRUE);
 506
 507
 508     /* First push the stream-start event, it must always come first */
 509     gst_pad_push_event (srcpad,
 510         gst_pad_get_sticky_event (rtpdemux->sink, GST_EVENT_STREAM_START, 0));
 511
 512     /* Then caps event is sent */
 513     caps = gst_caps_make_writable (caps);
 514     gst_caps_set_simple (caps, "payload", G_TYPE_INT, pt, NULL);
 515     gst_pad_set_caps (srcpad, caps);
 516     gst_caps_unref (caps);
 517
 518     /* First sticky events on sink pad are forwarded to the new src pad */
 519     gst_pad_sticky_events_foreach (rtpdemux->sink, forward_sticky_events,
 520         srcpad);
 521
 522     gst_element_add_pad (GST_ELEMENT_CAST (rtpdemux), srcpad);
 523
 524     GST_DEBUG ("emitting new-payload-type for pt %d", pt);
 525     g_signal_emit (G_OBJECT (rtpdemux),
 526         gst_rtp_pt_demux_signals[SIGNAL_NEW_PAYLOAD_TYPE], 0, pt, srcpad);
 527   }
 528
 529   if (pt != rtpdemux->last_pt) {
 530     gint emit_pt = pt;
 531
 532     /* our own signal with an extra flag that this is the only pad */
 533     rtpdemux->last_pt = pt;
 534     GST_DEBUG ("emitting payload-type-changed for pt %d", emit_pt);
 535     g_signal_emit (G_OBJECT (rtpdemux),
 536         gst_rtp_pt_demux_signals[SIGNAL_PAYLOAD_TYPE_CHANGE], 0, emit_pt);
 537   }
 538
 539   while (need_caps_for_pt (rtpdemux, pt)) {
 540     GST_DEBUG ("need new caps for %d", pt);
 541     caps = gst_rtp_pt_demux_get_caps (rtpdemux, pt);
 542     if (!caps)
 543       goto no_caps;
 544
 545     clear_newcaps_for_pt (rtpdemux, pt);
 546
 547     caps = gst_caps_make_writable (caps);
 548     gst_caps_set_simple (caps, "payload", G_TYPE_INT, pt, NULL);
 549     gst_pad_set_caps (srcpad, caps);
 550     gst_caps_unref (caps);
 551   }
 552
 553   /* push to srcpad */
 554   ret = gst_pad_push (srcpad, buf);
 555
 556   gst_object_unref (srcpad);
 557
 558   return ret;
 559
 560 ignored:
 561   {
 562     GST_DEBUG_OBJECT (rtpdemux, "Dropped buffer for pt %d", pt);
 563     gst_buffer_unref (buf);
 564     return GST_FLOW_OK;
 565   }
 566
 567   /* ERRORS */
 568 invalid_buffer:
 569   {
 570     /* this should not be fatal */
 571     GST_ELEMENT_WARNING (rtpdemux, STREAM, DEMUX, (NULL),
 572         ("Dropping invalid RTP payload"));
 573     gst_buffer_unref (buf);
 574     return GST_FLOW_ERROR;
 575   }
 576 no_caps:
 577   {
 578     GST_ELEMENT_ERROR (rtpdemux, STREAM, DECODE, (NULL),
 579         ("Could not get caps for payload"));
 580     gst_buffer_unref (buf);
 581     if (srcpad)
 582       gst_object_unref (srcpad);
 583     return GST_FLOW_ERROR;
 584   }
 585 }
 586
 587 static GstPad *
 588 find_pad_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt)
 589 {
 590   GstPad *respad = NULL;
 591   GSList *walk;
 592
 593   GST_OBJECT_LOCK (rtpdemux);
 594   for (walk = rtpdemux->srcpads; walk; walk = g_slist_next (walk)) {
 595     GstRtpPtDemuxPad *pad = walk->data;
 596
 597     if (pad->pt == pt) {
 598       respad = gst_object_ref (pad->pad);
 599       break;
 600     }
 601   }
 602   GST_OBJECT_UNLOCK (rtpdemux);
 603
 604   return respad;
 605 }
 606
 607 static gboolean
 608 gst_rtp_pt_demux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 609 {
 610   GstRtpPtDemux *rtpdemux;
 611   gboolean res = FALSE;
 612
 613   rtpdemux = GST_RTP_PT_DEMUX (parent);
 614
 615   switch (GST_EVENT_TYPE (event)) {
 616     case GST_EVENT_CAPS:
 617     {
 618       gst_rtp_pt_demux_clear_pt_map (rtpdemux);
 619       /* don't forward the event, we cleared the ptmap and on the next buffer we
 620        * will add the pt to the caps and push a new caps event */
 621       gst_event_unref (event);
 622       res = TRUE;
 623       break;
 624     }
 625     case GST_EVENT_CUSTOM_DOWNSTREAM:
 626     {
 627       const GstStructure *s;
 628
 629       s = gst_event_get_structure (event);
 630
 631       if (gst_structure_has_name (s, "GstRTPPacketLost")) {
 632         GstPad *srcpad = find_pad_for_pt (rtpdemux, rtpdemux->last_pt);
 633
 634         if (srcpad) {
 635           res = gst_pad_push_event (srcpad, event);
 636           gst_object_unref (srcpad);
 637         } else {
 638           gst_event_unref (event);
 639         }
 640
 641       } else {
 642         res = gst_pad_event_default (pad, parent, event);
 643       }
 644       break;
 645     }
 646     default:
 647       res = gst_pad_event_default (pad, parent, event);
 648       break;
 649   }
 650
 651   return res;
 652 }
 653
 654
 655 static gboolean
 656 gst_rtp_pt_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
 657 {
 658   GstRtpPtDemux *demux;
 659   const GstStructure *s;
 660
 661   demux = GST_RTP_PT_DEMUX (parent);
 662
 663   switch (GST_EVENT_TYPE (event)) {
 664     case GST_EVENT_CUSTOM_UPSTREAM:
 665     case GST_EVENT_CUSTOM_BOTH:
 666     case GST_EVENT_CUSTOM_BOTH_OOB:
 667       s = gst_event_get_structure (event);
 668       if (s && !gst_structure_has_field (s, "payload")) {
 669         GSList *walk;
 670
 671         GST_OBJECT_LOCK (demux);
 672         for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) {
 673           GstRtpPtDemuxPad *dpad = (GstRtpPtDemuxPad *) walk->data;
 674
 675           if (dpad->pad == pad) {
 676             GstStructure *ws;
 677
 678             event =
 679                 GST_EVENT_CAST (gst_mini_object_make_writable
 680                 (GST_MINI_OBJECT_CAST (event)));
 681             ws = gst_event_writable_structure (event);
 682             gst_structure_set (ws, "payload", G_TYPE_UINT, dpad->pt, NULL);
 683             break;
 684           }
 685         }
 686         GST_OBJECT_UNLOCK (demux);
 687       }
 688       break;
 689     default:
 690       break;
 691   }
 692
 693   return gst_pad_event_default (pad, parent, event);
 694 }
 695
 696 /*
 697  * Reserves resources for the object.
 698  */
 699 static gboolean
 700 gst_rtp_pt_demux_setup (GstRtpPtDemux * ptdemux)
 701 {
 702   ptdemux->srcpads = NULL;
 703   ptdemux->last_pt = 0xFFFF;
 704
 705   return TRUE;
 706 }
 707
 708 /*
 709  * Free resources for the object.
 710  */
 711 static void
 712 gst_rtp_pt_demux_release (GstRtpPtDemux * ptdemux)
 713 {
 714   GSList *tmppads;
 715   GSList *walk;
 716
 717   GST_OBJECT_LOCK (ptdemux);
 718   tmppads = ptdemux->srcpads;
 719   ptdemux->srcpads = NULL;
 720   GST_OBJECT_UNLOCK (ptdemux);
 721
 722   for (walk = tmppads; walk; walk = g_slist_next (walk)) {
 723     GstRtpPtDemuxPad *pad = walk->data;
 724
 725     gst_pad_set_active (pad->pad, FALSE);
 726     gst_element_remove_pad (GST_ELEMENT_CAST (ptdemux), pad->pad);
 727     g_slice_free (GstRtpPtDemuxPad, pad);
 728   }
 729   g_slist_free (tmppads);
 730 }
 731
 732 static GstStateChangeReturn
 733 gst_rtp_pt_demux_change_state (GstElement * element, GstStateChange transition)
 734 {
 735   GstStateChangeReturn ret;
 736   GstRtpPtDemux *ptdemux;
 737
 738   ptdemux = GST_RTP_PT_DEMUX (element);
 739
 740   switch (transition) {
 741     case GST_STATE_CHANGE_NULL_TO_READY:
 742       if (gst_rtp_pt_demux_setup (ptdemux) != TRUE)
 743         ret = GST_STATE_CHANGE_FAILURE;
 744       break;
 745     case GST_STATE_CHANGE_READY_TO_PAUSED:
 746     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 747     default:
 748       break;
 749   }
 750
 751   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 752
 753   switch (transition) {
 754     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 755     case GST_STATE_CHANGE_PAUSED_TO_READY:
 756       break;
 757     case GST_STATE_CHANGE_READY_TO_NULL:
 758       gst_rtp_pt_demux_release (ptdemux);
 759       break;
 760     default:
 761       break;
 762   }
 763
 764   return ret;
 765 }