Merge branch 'upstream/1.16' into tizen_gst_1.16.2
[platform/upstream/gst-plugins-good.git] / 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 }