outputselector: Don't adjust segment->start to the current time when switching pads
[platform/upstream/gstreamer.git] / plugins / elements / gstoutputselector.c
1 /* GStreamer output selector
2  * Copyright (C) 2008 Nokia Corporation. (contact <stefan.kost@nokia.com>)
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 /**
21  * SECTION:element-output-selector
22  * @see_also: #GstOutputSelector, #GstInputSelector
23  *
24  * Direct input stream to one out of N output pads.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include <string.h>
32
33 #include "gstoutputselector.h"
34
35 GST_DEBUG_CATEGORY_STATIC (output_selector_debug);
36 #define GST_CAT_DEFAULT output_selector_debug
37
38 static GstStaticPadTemplate gst_output_selector_sink_factory =
39 GST_STATIC_PAD_TEMPLATE ("sink",
40     GST_PAD_SINK,
41     GST_PAD_ALWAYS,
42     GST_STATIC_CAPS_ANY);
43
44 static GstStaticPadTemplate gst_output_selector_src_factory =
45 GST_STATIC_PAD_TEMPLATE ("src_%u",
46     GST_PAD_SRC,
47     GST_PAD_REQUEST,
48     GST_STATIC_CAPS_ANY);
49
50 enum GstOutputSelectorPadNegotiationMode
51 {
52   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE,
53   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL,
54   GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE
55 };
56 #define GST_TYPE_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE (gst_output_selector_pad_negotiation_mode_get_type())
57 static GType
58 gst_output_selector_pad_negotiation_mode_get_type (void)
59 {
60   static GType pad_negotiation_mode_type = 0;
61   static GEnumValue pad_negotiation_modes[] = {
62     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE, "None", "none"},
63     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL, "All", "all"},
64     {GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE, "Active", "active"},
65     {0, NULL, NULL}
66   };
67
68   if (!pad_negotiation_mode_type) {
69     pad_negotiation_mode_type =
70         g_enum_register_static ("GstOutputSelectorPadNegotiationMode",
71         pad_negotiation_modes);
72   }
73   return pad_negotiation_mode_type;
74 }
75
76
77 enum
78 {
79   PROP_0,
80   PROP_ACTIVE_PAD,
81   PROP_RESEND_LATEST,
82   PROP_PAD_NEGOTIATION_MODE
83 };
84
85 #define DEFAULT_PAD_NEGOTIATION_MODE GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL
86
87 #define _do_init \
88 GST_DEBUG_CATEGORY_INIT (output_selector_debug, \
89         "output-selector", 0, "Output stream selector");
90 #define gst_output_selector_parent_class parent_class
91 G_DEFINE_TYPE_WITH_CODE (GstOutputSelector, gst_output_selector,
92     GST_TYPE_ELEMENT, _do_init);
93
94 static void gst_output_selector_dispose (GObject * object);
95 static void gst_output_selector_set_property (GObject * object,
96     guint prop_id, const GValue * value, GParamSpec * pspec);
97 static void gst_output_selector_get_property (GObject * object,
98     guint prop_id, GValue * value, GParamSpec * pspec);
99 static GstPad *gst_output_selector_request_new_pad (GstElement * element,
100     GstPadTemplate * templ, const gchar * unused, const GstCaps * caps);
101 static void gst_output_selector_release_pad (GstElement * element,
102     GstPad * pad);
103 static GstFlowReturn gst_output_selector_chain (GstPad * pad,
104     GstObject * parent, GstBuffer * buf);
105 static GstStateChangeReturn gst_output_selector_change_state (GstElement *
106     element, GstStateChange transition);
107 static gboolean gst_output_selector_event (GstPad * pad, GstObject * parent,
108     GstEvent * event);
109 static gboolean gst_output_selector_query (GstPad * pad, GstObject * parent,
110     GstQuery * query);
111 static void gst_output_selector_switch_pad_negotiation_mode (GstOutputSelector *
112     sel, gint mode);
113
114 static void
115 gst_output_selector_class_init (GstOutputSelectorClass * klass)
116 {
117   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
118   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
119
120   gobject_class->dispose = gst_output_selector_dispose;
121
122   gobject_class->set_property = gst_output_selector_set_property;
123   gobject_class->get_property = gst_output_selector_get_property;
124
125   g_object_class_install_property (gobject_class, PROP_ACTIVE_PAD,
126       g_param_spec_object ("active-pad", "Active pad",
127           "Currently active src pad", GST_TYPE_PAD,
128           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
129   g_object_class_install_property (gobject_class, PROP_RESEND_LATEST,
130       g_param_spec_boolean ("resend-latest", "Resend latest buffer",
131           "Resend latest buffer after a switch to a new pad", FALSE,
132           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
133   g_object_class_install_property (gobject_class, PROP_PAD_NEGOTIATION_MODE,
134       g_param_spec_enum ("pad-negotiation-mode", "Pad negotiation mode",
135           "The mode to be used for pad negotiation",
136           GST_TYPE_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE,
137           DEFAULT_PAD_NEGOTIATION_MODE,
138           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
139
140   gst_element_class_set_static_metadata (gstelement_class, "Output selector",
141       "Generic", "1-to-N output stream selector",
142       "Stefan Kost <stefan.kost@nokia.com>");
143   gst_element_class_add_pad_template (gstelement_class,
144       gst_static_pad_template_get (&gst_output_selector_sink_factory));
145   gst_element_class_add_pad_template (gstelement_class,
146       gst_static_pad_template_get (&gst_output_selector_src_factory));
147
148   gstelement_class->request_new_pad =
149       GST_DEBUG_FUNCPTR (gst_output_selector_request_new_pad);
150   gstelement_class->release_pad =
151       GST_DEBUG_FUNCPTR (gst_output_selector_release_pad);
152
153   gstelement_class->change_state = gst_output_selector_change_state;
154 }
155
156 static void
157 gst_output_selector_init (GstOutputSelector * sel)
158 {
159   sel->sinkpad =
160       gst_pad_new_from_static_template (&gst_output_selector_sink_factory,
161       "sink");
162   gst_pad_set_chain_function (sel->sinkpad,
163       GST_DEBUG_FUNCPTR (gst_output_selector_chain));
164   gst_pad_set_event_function (sel->sinkpad,
165       GST_DEBUG_FUNCPTR (gst_output_selector_event));
166   gst_pad_set_query_function (sel->sinkpad,
167       GST_DEBUG_FUNCPTR (gst_output_selector_query));
168
169   gst_element_add_pad (GST_ELEMENT (sel), sel->sinkpad);
170
171   /* srcpad management */
172   sel->active_srcpad = NULL;
173   sel->nb_srcpads = 0;
174   gst_segment_init (&sel->segment, GST_FORMAT_UNDEFINED);
175   sel->pending_srcpad = NULL;
176
177   sel->resend_latest = FALSE;
178   sel->latest_buffer = NULL;
179   gst_output_selector_switch_pad_negotiation_mode (sel,
180       DEFAULT_PAD_NEGOTIATION_MODE);
181 }
182
183 static void
184 gst_output_selector_reset (GstOutputSelector * osel)
185 {
186   if (osel->pending_srcpad != NULL) {
187     gst_object_unref (osel->pending_srcpad);
188     osel->pending_srcpad = NULL;
189   }
190   if (osel->latest_buffer != NULL) {
191     gst_buffer_unref (osel->latest_buffer);
192     osel->latest_buffer = NULL;
193   }
194   gst_segment_init (&osel->segment, GST_FORMAT_UNDEFINED);
195 }
196
197 static void
198 gst_output_selector_dispose (GObject * object)
199 {
200   GstOutputSelector *osel = GST_OUTPUT_SELECTOR (object);
201
202   gst_output_selector_reset (osel);
203
204   G_OBJECT_CLASS (parent_class)->dispose (object);
205 }
206
207 static void
208 gst_output_selector_set_property (GObject * object, guint prop_id,
209     const GValue * value, GParamSpec * pspec)
210 {
211   GstOutputSelector *sel = GST_OUTPUT_SELECTOR (object);
212
213   switch (prop_id) {
214     case PROP_ACTIVE_PAD:
215     {
216       GstPad *next_pad;
217
218       next_pad = g_value_get_object (value);
219
220       GST_INFO_OBJECT (sel, "Activating pad %s:%s",
221           GST_DEBUG_PAD_NAME (next_pad));
222
223       GST_OBJECT_LOCK (object);
224       if (next_pad != sel->active_srcpad) {
225         /* switch to new srcpad in next chain run */
226         if (sel->pending_srcpad != NULL) {
227           GST_INFO ("replacing pending switch");
228           gst_object_unref (sel->pending_srcpad);
229         }
230         if (next_pad)
231           gst_object_ref (next_pad);
232         sel->pending_srcpad = next_pad;
233       } else {
234         GST_INFO ("pad already active");
235         if (sel->pending_srcpad != NULL) {
236           gst_object_unref (sel->pending_srcpad);
237           sel->pending_srcpad = NULL;
238         }
239       }
240       GST_OBJECT_UNLOCK (object);
241       break;
242     }
243     case PROP_RESEND_LATEST:{
244       sel->resend_latest = g_value_get_boolean (value);
245       break;
246     }
247     case PROP_PAD_NEGOTIATION_MODE:{
248       gst_output_selector_switch_pad_negotiation_mode (sel,
249           g_value_get_enum (value));
250       break;
251     }
252     default:
253       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
254       break;
255   }
256 }
257
258 static void
259 gst_output_selector_get_property (GObject * object, guint prop_id,
260     GValue * value, GParamSpec * pspec)
261 {
262   GstOutputSelector *sel = GST_OUTPUT_SELECTOR (object);
263
264   switch (prop_id) {
265     case PROP_ACTIVE_PAD:
266       GST_OBJECT_LOCK (object);
267       g_value_set_object (value,
268           sel->pending_srcpad ? sel->pending_srcpad : sel->active_srcpad);
269       GST_OBJECT_UNLOCK (object);
270       break;
271     case PROP_RESEND_LATEST:{
272       GST_OBJECT_LOCK (object);
273       g_value_set_boolean (value, sel->resend_latest);
274       GST_OBJECT_UNLOCK (object);
275       break;
276     }
277     case PROP_PAD_NEGOTIATION_MODE:
278       g_value_set_enum (value, sel->pad_negotiation_mode);
279       break;
280     default:
281       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
282       break;
283   }
284 }
285
286 static GstPad *
287 gst_output_selector_get_active (GstOutputSelector * sel)
288 {
289   GstPad *active = NULL;
290
291   GST_OBJECT_LOCK (sel);
292   if (sel->pending_srcpad)
293     active = gst_object_ref (sel->pending_srcpad);
294   else if (sel->active_srcpad)
295     active = gst_object_ref (sel->active_srcpad);
296   GST_OBJECT_UNLOCK (sel);
297
298   return active;
299 }
300
301 static void
302 gst_output_selector_switch_pad_negotiation_mode (GstOutputSelector * sel,
303     gint mode)
304 {
305   sel->pad_negotiation_mode = mode;
306 }
307
308 static gboolean
309 forward_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data)
310 {
311   GstPad *srcpad = GST_PAD_CAST (user_data);
312
313   gst_pad_push_event (srcpad, gst_event_ref (*event));
314
315   return TRUE;
316 }
317
318 static GstPad *
319 gst_output_selector_request_new_pad (GstElement * element,
320     GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
321 {
322   gchar *padname;
323   GstPad *srcpad;
324   GstOutputSelector *osel;
325
326   osel = GST_OUTPUT_SELECTOR (element);
327
328   GST_DEBUG_OBJECT (osel, "requesting pad");
329
330   GST_OBJECT_LOCK (osel);
331   padname = g_strdup_printf ("src_%u", osel->nb_srcpads++);
332   srcpad = gst_pad_new_from_template (templ, padname);
333   GST_OBJECT_UNLOCK (osel);
334
335   gst_pad_set_active (srcpad, TRUE);
336
337   /* Forward sticky events to the new srcpad */
338   gst_pad_sticky_events_foreach (osel->sinkpad, forward_sticky_events, srcpad);
339
340   gst_element_add_pad (GST_ELEMENT (osel), srcpad);
341
342   /* Set the first requested src pad as active by default */
343   if (osel->active_srcpad == NULL) {
344     osel->active_srcpad = srcpad;
345   }
346   g_free (padname);
347
348   return srcpad;
349 }
350
351 static void
352 gst_output_selector_release_pad (GstElement * element, GstPad * pad)
353 {
354   GstOutputSelector *osel;
355
356   osel = GST_OUTPUT_SELECTOR (element);
357
358   GST_DEBUG_OBJECT (osel, "releasing pad");
359
360   gst_pad_set_active (pad, FALSE);
361
362   gst_element_remove_pad (GST_ELEMENT_CAST (osel), pad);
363 }
364
365 static gboolean
366 gst_output_selector_switch (GstOutputSelector * osel)
367 {
368   gboolean res = FALSE;
369   GstEvent *ev = NULL;
370   GstSegment *seg = NULL;
371
372   /* Switch */
373   GST_OBJECT_LOCK (GST_OBJECT (osel));
374   GST_INFO_OBJECT (osel, "switching to pad %" GST_PTR_FORMAT,
375       osel->pending_srcpad);
376   if (gst_pad_is_linked (osel->pending_srcpad)) {
377     osel->active_srcpad = osel->pending_srcpad;
378     res = TRUE;
379   }
380   gst_object_unref (osel->pending_srcpad);
381   osel->pending_srcpad = NULL;
382   GST_OBJECT_UNLOCK (GST_OBJECT (osel));
383
384   /* Send SEGMENT event and latest buffer if switching succeeded
385    * and we already have a valid segment configured */
386   if (res) {
387     if (osel->segment.format != GST_FORMAT_UNDEFINED) {
388       /* Send SEGMENT to the pad we are going to switch to */
389       seg = &osel->segment;
390       /* If resending then mark segment start and position accordingly */
391       if (osel->resend_latest && osel->latest_buffer &&
392           GST_BUFFER_TIMESTAMP_IS_VALID (osel->latest_buffer)) {
393         seg->position = GST_BUFFER_TIMESTAMP (osel->latest_buffer);
394       }
395
396       ev = gst_event_new_segment (seg);
397
398       if (!gst_pad_push_event (osel->active_srcpad, ev)) {
399         GST_WARNING_OBJECT (osel,
400             "newsegment handling failed in %" GST_PTR_FORMAT,
401             osel->active_srcpad);
402       }
403     }
404
405     /* Resend latest buffer to newly switched pad */
406     if (osel->resend_latest && osel->latest_buffer) {
407       GST_INFO ("resending latest buffer");
408       gst_pad_push (osel->active_srcpad, gst_buffer_ref (osel->latest_buffer));
409     }
410   } else {
411     GST_WARNING_OBJECT (osel, "switch failed, pad not linked");
412   }
413
414   return res;
415 }
416
417 static GstFlowReturn
418 gst_output_selector_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
419 {
420   GstFlowReturn res;
421   GstOutputSelector *osel;
422   GstClockTime position, duration;
423
424   osel = GST_OUTPUT_SELECTOR (parent);
425
426   /*
427    * The _switch function might push a buffer if 'resend-latest' is true.
428    *
429    * Elements/Applications (e.g. camerabin) might use pad probes to
430    * switch output-selector's active pad. If we simply switch and don't
431    * recheck any pending pad switch the following codepath could end
432    * up pushing a buffer on a non-active pad. This is bad.
433    *
434    * So we always should check the pending_srcpad before going further down
435    * the chain and pushing the new buffer
436    */
437   while (osel->pending_srcpad) {
438     /* Do the switch */
439     gst_output_selector_switch (osel);
440   }
441
442   if (osel->latest_buffer) {
443     gst_buffer_unref (osel->latest_buffer);
444     osel->latest_buffer = NULL;
445   }
446
447   if (osel->resend_latest) {
448     /* Keep reference to latest buffer to resend it after switch */
449     osel->latest_buffer = gst_buffer_ref (buf);
450   }
451
452   /* Keep track of last stop and use it in SEGMENT start after
453      switching to a new src pad */
454   position = GST_BUFFER_TIMESTAMP (buf);
455   if (GST_CLOCK_TIME_IS_VALID (position)) {
456     duration = GST_BUFFER_DURATION (buf);
457     if (GST_CLOCK_TIME_IS_VALID (duration)) {
458       position += duration;
459     }
460     GST_LOG_OBJECT (osel, "setting last stop %" GST_TIME_FORMAT,
461         GST_TIME_ARGS (position));
462     osel->segment.position = position;
463   }
464
465   GST_LOG_OBJECT (osel, "pushing buffer to %" GST_PTR_FORMAT,
466       osel->active_srcpad);
467   res = gst_pad_push (osel->active_srcpad, buf);
468
469   return res;
470 }
471
472 static GstStateChangeReturn
473 gst_output_selector_change_state (GstElement * element,
474     GstStateChange transition)
475 {
476   GstOutputSelector *sel;
477   GstStateChangeReturn result;
478
479   sel = GST_OUTPUT_SELECTOR (element);
480
481   switch (transition) {
482     case GST_STATE_CHANGE_READY_TO_PAUSED:
483       break;
484     default:
485       break;
486   }
487
488   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
489
490   switch (transition) {
491     case GST_STATE_CHANGE_PAUSED_TO_READY:
492       gst_output_selector_reset (sel);
493       break;
494     default:
495       break;
496   }
497
498   return result;
499 }
500
501 static gboolean
502 gst_output_selector_event (GstPad * pad, GstObject * parent, GstEvent * event)
503 {
504   gboolean res = TRUE;
505   GstOutputSelector *sel;
506   GstPad *active = NULL;
507
508   sel = GST_OUTPUT_SELECTOR (parent);
509
510   switch (GST_EVENT_TYPE (event)) {
511     case GST_EVENT_CAPS:
512     {
513       switch (sel->pad_negotiation_mode) {
514         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL:
515           /* Send caps to all src pads */
516           res = gst_pad_event_default (pad, parent, event);
517           break;
518         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE:
519           gst_event_unref (event);
520           break;
521         default:
522           active = gst_output_selector_get_active (sel);
523           if (active) {
524             res = gst_pad_push_event (active, event);
525             gst_object_unref (active);
526           } else {
527             gst_event_unref (event);
528           }
529           break;
530       }
531       break;
532     }
533     case GST_EVENT_SEGMENT:
534     {
535       gst_event_copy_segment (event, &sel->segment);
536
537       GST_DEBUG_OBJECT (sel, "configured SEGMENT %" GST_SEGMENT_FORMAT,
538           &sel->segment);
539
540       /* Send newsegment to all src pads */
541       res = gst_pad_event_default (pad, parent, event);
542       break;
543     }
544     default:
545     {
546       if (GST_EVENT_IS_STICKY (event)) {
547         res = gst_pad_event_default (pad, parent, event);
548       } else {
549         /* Send other events to pending or active src pad */
550         active = gst_output_selector_get_active (sel);
551         if (active) {
552           res = gst_pad_push_event (active, event);
553           gst_object_unref (active);
554         } else {
555           gst_event_unref (event);
556         }
557       }
558       break;
559     }
560   }
561
562   return res;
563 }
564
565 static gboolean
566 gst_output_selector_query (GstPad * pad, GstObject * parent, GstQuery * query)
567 {
568   gboolean res = TRUE;
569   GstOutputSelector *sel;
570   GstPad *active = NULL;
571
572   sel = GST_OUTPUT_SELECTOR (parent);
573
574   switch (GST_QUERY_TYPE (query)) {
575     case GST_QUERY_CAPS:
576     {
577       switch (sel->pad_negotiation_mode) {
578         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL:
579           /* Send caps to all src pads */
580           res = gst_pad_proxy_query_caps (pad, query);
581           break;
582         case GST_OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE:
583           res = FALSE;
584           break;
585         default:
586           active = gst_output_selector_get_active (sel);
587           if (active) {
588             res = gst_pad_peer_query (active, query);
589             gst_object_unref (active);
590           } else {
591             res = FALSE;
592           }
593           break;
594       }
595       break;
596     }
597     default:
598       res = gst_pad_query_default (pad, parent, query);
599       break;
600   }
601   return res;
602 }