1 /* GStreamer concat element
3 * Copyright (c) 2014 Sebastian Dröge <sebastian@centricular.com>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
22 * SECTION:element-concat
23 * @see_also: #GstFunnel
25 * Concatenates streams together to one continous stream.
27 * All streams but the current one are blocked until the current one
28 * finished with %GST_EVENT_EOS. Then the next stream is enabled, while
29 * keeping the running time continous for %GST_FORMAT_TIME segments or
30 * keeping the segment continous for %GST_FORMAT_BYTES segments.
32 * Streams are switched in the order in which the sinkpads were requested.
34 * By default, the stream segment's base values are adjusted to ensure
35 * the segment transitions between streams are continuous. In some cases,
36 * it may be desirable to turn off these adjustments (for example, because
37 * another downstream element like a streamsynchronizer adjusts the base
38 * values on its own). The adjust-base property can be used for this purpose.
41 * <title>Example launch line</title>
43 * gst-launch-1.0 concat name=c ! xvimagesink videotestsrc num-buffers=100 ! c. videotestsrc num-buffers=100 pattern=ball ! c.
44 * ]| Plays two video streams one after another.
52 #include "gstconcat.h"
54 GST_DEBUG_CATEGORY_STATIC (gst_concat_debug);
55 #define GST_CAT_DEFAULT gst_concat_debug
57 G_GNUC_INTERNAL GType gst_concat_pad_get_type (void);
59 #define GST_TYPE_CONCAT_PAD (gst_concat_pad_get_type())
60 #define GST_CONCAT_PAD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CONCAT_PAD, GstConcatPad))
61 #define GST_CONCAT_PAD_CAST(obj) ((GstConcatPad *)(obj))
62 #define GST_CONCAT_PAD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CONCAT_PAD, GstConcatPadClass))
63 #define GST_IS_CONCAT_PAD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CONCAT_PAD))
64 #define GST_IS_CONCAT_PAD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CONCAT_PAD))
66 typedef struct _GstConcatPad GstConcatPad;
67 typedef struct _GstConcatPadClass GstConcatPadClass;
75 /* Protected by the concat lock */
79 struct _GstConcatPadClass
84 G_DEFINE_TYPE (GstConcatPad, gst_concat_pad, GST_TYPE_PAD);
87 gst_concat_pad_class_init (GstConcatPadClass * klass)
92 gst_concat_pad_init (GstConcatPad * self)
94 gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED);
95 self->flushing = FALSE;
98 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink_%u",
101 GST_STATIC_CAPS_ANY);
103 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
106 GST_STATIC_CAPS_ANY);
115 #define DEFAULT_ADJUST_BASE TRUE
118 GST_DEBUG_CATEGORY_INIT (gst_concat_debug, "concat", 0, "concat element");
119 #define gst_concat_parent_class parent_class
120 G_DEFINE_TYPE_WITH_CODE (GstConcat, gst_concat, GST_TYPE_ELEMENT, _do_init);
122 static void gst_concat_dispose (GObject * object);
123 static void gst_concat_finalize (GObject * object);
124 static void gst_concat_get_property (GObject * object,
125 guint prop_id, GValue * value, GParamSpec * pspec);
126 static void gst_concat_set_property (GObject * object,
127 guint prop_id, const GValue * value, GParamSpec * pspec);
129 static GstStateChangeReturn gst_concat_change_state (GstElement * element,
130 GstStateChange transition);
131 static GstPad *gst_concat_request_new_pad (GstElement * element,
132 GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
133 static void gst_concat_release_pad (GstElement * element, GstPad * pad);
135 static GstFlowReturn gst_concat_sink_chain (GstPad * pad, GstObject * parent,
137 static gboolean gst_concat_sink_event (GstPad * pad, GstObject * parent,
139 static gboolean gst_concat_sink_query (GstPad * pad, GstObject * parent,
142 static gboolean gst_concat_src_event (GstPad * pad, GstObject * parent,
144 static gboolean gst_concat_src_query (GstPad * pad, GstObject * parent,
147 static gboolean gst_concat_switch_pad (GstConcat * self);
149 static void gst_concat_notify_active_pad (GstConcat * self);
151 static GParamSpec *pspec_active_pad = NULL;
154 gst_concat_class_init (GstConcatClass * klass)
156 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
157 GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
159 gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_concat_dispose);
160 gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_concat_finalize);
162 gobject_class->get_property = gst_concat_get_property;
163 gobject_class->set_property = gst_concat_set_property;
165 pspec_active_pad = g_param_spec_object ("active-pad", "Active pad",
166 "Currently active src pad", GST_TYPE_PAD, G_PARAM_READABLE |
167 G_PARAM_STATIC_STRINGS);
168 g_object_class_install_property (gobject_class, PROP_ACTIVE_PAD,
170 g_object_class_install_property (gobject_class, PROP_ADJUST_BASE,
171 g_param_spec_boolean ("adjust-base", "Adjust segment base",
172 "Adjust the base value of segments to ensure they are adjacent",
173 DEFAULT_ADJUST_BASE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
175 gst_element_class_set_static_metadata (gstelement_class,
176 "Concat", "Generic", "Concatenate multiple streams",
177 "Sebastian Dröge <sebastian@centricular.com>");
179 gst_element_class_add_static_pad_template (gstelement_class, &sink_template);
180 gst_element_class_add_static_pad_template (gstelement_class, &src_template);
182 gstelement_class->request_new_pad =
183 GST_DEBUG_FUNCPTR (gst_concat_request_new_pad);
184 gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_concat_release_pad);
185 gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_concat_change_state);
189 gst_concat_init (GstConcat * self)
191 g_mutex_init (&self->lock);
192 g_cond_init (&self->cond);
194 self->srcpad = gst_pad_new_from_static_template (&src_template, "src");
195 gst_pad_set_event_function (self->srcpad,
196 GST_DEBUG_FUNCPTR (gst_concat_src_event));
197 gst_pad_set_query_function (self->srcpad,
198 GST_DEBUG_FUNCPTR (gst_concat_src_query));
199 gst_pad_use_fixed_caps (self->srcpad);
201 gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
203 self->adjust_base = DEFAULT_ADJUST_BASE;
207 gst_concat_dispose (GObject * object)
209 GstConcat *self = GST_CONCAT (object);
212 gst_object_replace ((GstObject **) & self->current_sinkpad, NULL);
215 for (item = GST_ELEMENT_PADS (object); item; item = g_list_next (item)) {
216 GstPad *pad = GST_PAD (item->data);
218 if (GST_PAD_IS_SINK (pad)) {
219 gst_element_release_request_pad (GST_ELEMENT (object), pad);
224 G_OBJECT_CLASS (parent_class)->dispose (object);
228 gst_concat_finalize (GObject * object)
230 GstConcat *self = GST_CONCAT (object);
232 g_mutex_clear (&self->lock);
233 g_cond_clear (&self->cond);
235 G_OBJECT_CLASS (parent_class)->finalize (object);
239 gst_concat_get_property (GObject * object, guint prop_id, GValue * value,
242 GstConcat *self = GST_CONCAT (object);
245 case PROP_ACTIVE_PAD:{
246 g_mutex_lock (&self->lock);
247 g_value_set_object (value, self->current_sinkpad);
248 g_mutex_unlock (&self->lock);
251 case PROP_ADJUST_BASE:{
252 g_mutex_lock (&self->lock);
253 g_value_set_boolean (value, self->adjust_base);
254 g_mutex_unlock (&self->lock);
258 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
264 gst_concat_set_property (GObject * object, guint prop_id, const GValue * value,
267 GstConcat *self = GST_CONCAT (object);
270 case PROP_ADJUST_BASE:{
271 g_mutex_lock (&self->lock);
272 self->adjust_base = g_value_get_boolean (value);
273 g_mutex_unlock (&self->lock);
277 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
283 gst_concat_request_new_pad (GstElement * element, GstPadTemplate * templ,
284 const gchar * name, const GstCaps * caps)
286 GstConcat *self = GST_CONCAT (element);
289 gboolean do_notify = FALSE;
291 GST_DEBUG_OBJECT (element, "requesting pad");
293 g_mutex_lock (&self->lock);
294 pad_name = g_strdup_printf ("sink_%u", self->pad_count);
296 g_mutex_unlock (&self->lock);
298 sinkpad = GST_PAD_CAST (g_object_new (GST_TYPE_CONCAT_PAD,
299 "name", pad_name, "direction", templ->direction, "template", templ,
303 gst_pad_set_chain_function (sinkpad,
304 GST_DEBUG_FUNCPTR (gst_concat_sink_chain));
305 gst_pad_set_event_function (sinkpad,
306 GST_DEBUG_FUNCPTR (gst_concat_sink_event));
307 gst_pad_set_query_function (sinkpad,
308 GST_DEBUG_FUNCPTR (gst_concat_sink_query));
309 GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_CAPS);
310 GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_ALLOCATION);
312 gst_pad_set_active (sinkpad, TRUE);
314 g_mutex_lock (&self->lock);
315 self->sinkpads = g_list_prepend (self->sinkpads, gst_object_ref (sinkpad));
316 if (!self->current_sinkpad) {
318 self->current_sinkpad = gst_object_ref (sinkpad);
320 g_mutex_unlock (&self->lock);
322 gst_element_add_pad (element, sinkpad);
325 gst_concat_notify_active_pad (self);
331 gst_concat_release_pad (GstElement * element, GstPad * pad)
333 GstConcat *self = GST_CONCAT (element);
334 GstConcatPad *spad = GST_CONCAT_PAD_CAST (pad);
336 gboolean current_pad_removed = FALSE;
337 gboolean eos = FALSE;
338 gboolean do_notify = FALSE;
340 GST_DEBUG_OBJECT (self, "releasing pad");
342 g_mutex_lock (&self->lock);
343 spad->flushing = TRUE;
344 g_cond_broadcast (&self->cond);
345 g_mutex_unlock (&self->lock);
347 gst_pad_set_active (pad, FALSE);
349 /* Now the pad is definitely not running anymore */
351 g_mutex_lock (&self->lock);
352 if (self->current_sinkpad == GST_PAD_CAST (spad)) {
353 eos = !gst_concat_switch_pad (self);
354 current_pad_removed = TRUE;
358 for (l = self->sinkpads; l; l = l->next) {
359 if ((gpointer) spad == l->data) {
360 gst_object_unref (spad);
361 self->sinkpads = g_list_delete_link (self->sinkpads, l);
365 g_mutex_unlock (&self->lock);
367 gst_element_remove_pad (GST_ELEMENT_CAST (self), pad);
370 gst_concat_notify_active_pad (self);
372 if (GST_STATE (self) > GST_STATE_READY) {
373 if (current_pad_removed && !eos)
374 gst_element_post_message (GST_ELEMENT_CAST (self),
375 gst_message_new_duration_changed (GST_OBJECT_CAST (self)));
377 /* FIXME: Sending EOS from application thread */
379 gst_pad_push_event (self->srcpad, gst_event_new_eos ());
383 /* Returns FALSE if flushing
384 * Must be called from the pad's streaming thread
387 gst_concat_pad_wait (GstConcatPad * spad, GstConcat * self)
389 g_mutex_lock (&self->lock);
390 if (spad->flushing) {
391 g_mutex_unlock (&self->lock);
392 GST_DEBUG_OBJECT (spad, "Flushing");
396 while (spad != GST_CONCAT_PAD_CAST (self->current_sinkpad)) {
397 GST_TRACE_OBJECT (spad, "Not the current sinkpad - waiting");
398 g_cond_wait (&self->cond, &self->lock);
399 if (spad->flushing) {
400 g_mutex_unlock (&self->lock);
401 GST_DEBUG_OBJECT (spad, "Flushing");
405 /* This pad can only become not the current sinkpad from
406 * a) This streaming thread (we hold the stream lock)
407 * b) Releasing the pad (takes the stream lock, see above)
409 * Unlocking here is thus safe and we can safely push
410 * serialized data to our srcpad
412 GST_DEBUG_OBJECT (spad, "Now the current sinkpad");
413 g_mutex_unlock (&self->lock);
419 gst_concat_sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
422 GstConcat *self = GST_CONCAT (parent);
423 GstConcatPad *spad = GST_CONCAT_PAD (pad);
425 GST_LOG_OBJECT (pad, "received buffer %p", buffer);
427 if (!gst_concat_pad_wait (spad, self))
428 return GST_FLOW_FLUSHING;
430 if (self->last_stop == GST_CLOCK_TIME_NONE)
431 self->last_stop = spad->segment.start;
433 if (self->format == GST_FORMAT_TIME) {
434 GstClockTime start_time = GST_BUFFER_TIMESTAMP (buffer);
435 GstClockTime end_time = GST_CLOCK_TIME_NONE;
437 if (start_time != GST_CLOCK_TIME_NONE)
438 end_time = start_time;
439 if (GST_BUFFER_DURATION_IS_VALID (buffer))
440 end_time += GST_BUFFER_DURATION (buffer);
442 if (end_time != GST_CLOCK_TIME_NONE && end_time > self->last_stop)
443 self->last_stop = end_time;
445 self->last_stop += gst_buffer_get_size (buffer);
448 ret = gst_pad_push (self->srcpad, buffer);
450 GST_LOG_OBJECT (pad, "handled buffer %s", gst_flow_get_name (ret));
455 /* Returns FALSE if no further pad, must be called with concat lock */
457 gst_concat_switch_pad (GstConcat * self)
464 segment = GST_CONCAT_PAD (self->current_sinkpad)->segment;
466 last_stop = self->last_stop;
467 if (last_stop == GST_CLOCK_TIME_NONE)
468 last_stop = segment.stop;
469 if (last_stop == GST_CLOCK_TIME_NONE)
470 last_stop = segment.start;
471 g_assert (last_stop != GST_CLOCK_TIME_NONE);
473 if (last_stop > segment.stop)
474 last_stop = segment.stop;
476 if (segment.format == GST_FORMAT_TIME)
478 gst_segment_to_running_time (&segment, segment.format, last_stop);
480 last_stop += segment.start;
482 self->current_start_offset += last_stop;
484 for (l = self->sinkpads; l; l = l->next) {
485 if ((gpointer) self->current_sinkpad == l->data) {
487 GST_DEBUG_OBJECT (self,
488 "Switching from pad %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT,
489 self->current_sinkpad, l ? l->data : NULL);
490 gst_object_unref (self->current_sinkpad);
491 self->current_sinkpad = l ? gst_object_ref (l->data) : NULL;
492 g_cond_broadcast (&self->cond);
497 next = self->current_sinkpad != NULL;
499 self->last_stop = GST_CLOCK_TIME_NONE;
505 gst_concat_notify_active_pad (GstConcat * self)
507 g_object_notify_by_pspec ((GObject *) self, pspec_active_pad);
511 gst_concat_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
513 GstConcat *self = GST_CONCAT (parent);
514 GstConcatPad *spad = GST_CONCAT_PAD_CAST (pad);
517 GST_LOG_OBJECT (pad, "received event %" GST_PTR_FORMAT, event);
519 switch (GST_EVENT_TYPE (event)) {
520 case GST_EVENT_STREAM_START:{
521 if (!gst_concat_pad_wait (spad, self)) {
523 gst_event_unref (event);
525 ret = gst_pad_event_default (pad, parent, event);
529 case GST_EVENT_SEGMENT:{
530 gboolean adjust_base;
532 /* Drop segment event, we create our own one */
533 gst_event_copy_segment (event, &spad->segment);
534 gst_event_unref (event);
536 g_mutex_lock (&self->lock);
537 adjust_base = self->adjust_base;
538 if (self->format == GST_FORMAT_UNDEFINED) {
539 if (spad->segment.format != GST_FORMAT_TIME
540 && spad->segment.format != GST_FORMAT_BYTES) {
541 g_mutex_unlock (&self->lock);
542 GST_ELEMENT_ERROR (self, CORE, FAILED, (NULL),
543 ("Can only operate in TIME or BYTES format"));
547 self->format = spad->segment.format;
548 GST_DEBUG_OBJECT (self, "Operating in %s format",
549 gst_format_get_name (self->format));
550 g_mutex_unlock (&self->lock);
551 } else if (self->format != spad->segment.format) {
552 g_mutex_unlock (&self->lock);
553 GST_ELEMENT_ERROR (self, CORE, FAILED, (NULL),
554 ("Operating in %s format but new pad has %s",
555 gst_format_get_name (self->format),
556 gst_format_get_name (spad->segment.format)));
559 g_mutex_unlock (&self->lock);
562 if (!gst_concat_pad_wait (spad, self)) {
565 GstSegment segment = spad->segment;
568 /* We know no duration */
569 segment.duration = -1;
571 /* Update segment values to be continous with last stream */
572 if (self->format == GST_FORMAT_TIME) {
573 segment.base += self->current_start_offset;
575 /* Shift start/stop byte position */
576 segment.start += self->current_start_offset;
577 if (segment.stop != -1)
578 segment.stop += self->current_start_offset;
582 gst_pad_push_event (self->srcpad, gst_event_new_segment (&segment));
587 gst_event_unref (event);
589 if (!gst_concat_pad_wait (spad, self)) {
594 g_mutex_lock (&self->lock);
595 next = gst_concat_switch_pad (self);
596 g_mutex_unlock (&self->lock);
599 gst_concat_notify_active_pad (self);
602 gst_pad_push_event (self->srcpad, gst_event_new_eos ());
604 gst_element_post_message (GST_ELEMENT_CAST (self),
605 gst_message_new_duration_changed (GST_OBJECT_CAST (self)));
610 case GST_EVENT_FLUSH_START:{
613 g_mutex_lock (&self->lock);
614 spad->flushing = TRUE;
615 g_cond_broadcast (&self->cond);
616 forward = (self->current_sinkpad == GST_PAD_CAST (spad));
617 g_mutex_unlock (&self->lock);
620 ret = gst_pad_event_default (pad, parent, event);
622 gst_event_unref (event);
625 case GST_EVENT_FLUSH_STOP:{
628 gst_segment_init (&spad->segment, GST_FORMAT_UNDEFINED);
629 spad->flushing = FALSE;
631 g_mutex_lock (&self->lock);
632 forward = (self->current_sinkpad == GST_PAD_CAST (spad));
633 g_mutex_unlock (&self->lock);
638 gst_event_parse_flush_stop (event, &reset_time);
640 GST_DEBUG_OBJECT (self,
641 "resetting start offset to 0 after flushing with reset_time = TRUE");
642 self->current_start_offset = 0;
644 ret = gst_pad_event_default (pad, parent, event);
646 gst_event_unref (event);
651 /* Wait for other serialized events before forwarding */
652 if (GST_EVENT_IS_SERIALIZED (event) && !gst_concat_pad_wait (spad, self)) {
653 gst_event_unref (event);
656 ret = gst_pad_event_default (pad, parent, event);
666 gst_concat_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
668 GstConcat *self = GST_CONCAT (parent);
669 GstConcatPad *spad = GST_CONCAT_PAD_CAST (pad);
672 GST_LOG_OBJECT (pad, "received query %" GST_PTR_FORMAT, query);
674 switch (GST_QUERY_TYPE (query)) {
676 /* Wait for other serialized queries before forwarding */
677 if (GST_QUERY_IS_SERIALIZED (query) && !gst_concat_pad_wait (spad, self)) {
680 ret = gst_pad_query_default (pad, parent, query);
689 gst_concat_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
691 GstConcat *self = GST_CONCAT (parent);
694 GST_LOG_OBJECT (pad, "received event %" GST_PTR_FORMAT, event);
696 switch (GST_EVENT_TYPE (event)) {
697 case GST_EVENT_SEEK:{
698 GstPad *sinkpad = NULL;
700 g_mutex_lock (&self->lock);
701 if ((sinkpad = self->current_sinkpad))
702 gst_object_ref (sinkpad);
703 g_mutex_unlock (&self->lock);
705 ret = gst_pad_push_event (sinkpad, event);
706 gst_object_unref (sinkpad);
708 gst_event_unref (event);
715 GstClockTimeDiff diff;
716 GstClockTime timestamp;
719 gst_event_parse_qos (event, &type, &proportion, &diff, ×tamp);
720 gst_event_unref (event);
722 if (timestamp != GST_CLOCK_TIME_NONE
723 && timestamp > self->current_start_offset) {
724 timestamp -= self->current_start_offset;
725 event = gst_event_new_qos (type, proportion, diff, timestamp);
726 ret = gst_pad_push_event (self->current_sinkpad, event);
732 case GST_EVENT_FLUSH_STOP:{
735 gst_event_parse_flush_stop (event, &reset_time);
737 GST_DEBUG_OBJECT (self,
738 "resetting start offset to 0 after flushing with reset_time = TRUE");
739 self->current_start_offset = 0;
742 ret = gst_pad_event_default (pad, parent, event);
746 ret = gst_pad_event_default (pad, parent, event);
754 gst_concat_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
758 GST_LOG_OBJECT (pad, "received query %" GST_PTR_FORMAT, query);
760 switch (GST_QUERY_TYPE (query)) {
762 ret = gst_pad_query_default (pad, parent, query);
770 reset_pad (const GValue * data, gpointer user_data)
772 GstPad *pad = g_value_get_object (data);
773 GstConcatPad *spad = GST_CONCAT_PAD_CAST (pad);
775 gst_segment_init (&spad->segment, GST_FORMAT_UNDEFINED);
776 spad->flushing = FALSE;
780 unblock_pad (const GValue * data, gpointer user_data)
782 GstPad *pad = g_value_get_object (data);
783 GstConcatPad *spad = GST_CONCAT_PAD_CAST (pad);
785 spad->flushing = TRUE;
788 static GstStateChangeReturn
789 gst_concat_change_state (GstElement * element, GstStateChange transition)
791 GstConcat *self = GST_CONCAT (element);
792 GstStateChangeReturn ret;
794 switch (transition) {
795 case GST_STATE_CHANGE_READY_TO_PAUSED:{
796 GstIterator *iter = gst_element_iterate_sink_pads (element);
797 GstIteratorResult res;
799 self->format = GST_FORMAT_UNDEFINED;
800 self->current_start_offset = 0;
801 self->last_stop = GST_CLOCK_TIME_NONE;
804 res = gst_iterator_foreach (iter, reset_pad, NULL);
805 } while (res == GST_ITERATOR_RESYNC);
807 gst_iterator_free (iter);
809 if (res == GST_ITERATOR_ERROR)
810 return GST_STATE_CHANGE_FAILURE;
813 case GST_STATE_CHANGE_PAUSED_TO_READY:{
814 GstIterator *iter = gst_element_iterate_sink_pads (element);
815 GstIteratorResult res;
817 g_mutex_lock (&self->lock);
819 res = gst_iterator_foreach (iter, unblock_pad, NULL);
820 } while (res == GST_ITERATOR_RESYNC);
822 gst_iterator_free (iter);
823 g_cond_broadcast (&self->cond);
824 g_mutex_unlock (&self->lock);
826 if (res == GST_ITERATOR_ERROR)
827 return GST_STATE_CHANGE_FAILURE;
835 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);