X-Git-Url: http://git.maemo.org/git/?p=fillmore;a=blobdiff_plain;f=src%2Fmarina%2Fmarina%2Fsingledecodebin.c;fp=src%2Fmarina%2Fmarina%2Fsingledecodebin.c;h=f3fc84ce1397f051b575b336c6ac9fb74023d175;hp=0000000000000000000000000000000000000000;hb=a712cd772f4f3db8bed7037bb95c4de94767b230;hpb=2f0296582bf5d3f51db40d299f434fc8240ca6a5

diff --git a/src/marina/marina/singledecodebin.c b/src/marina/marina/singledecodebin.c
new file mode 100644
index 0000000..f3fc84c
--- /dev/null
+++ b/src/marina/marina/singledecodebin.c
@@ -0,0 +1,1345 @@
+/* singledecodebin.c generated by valac, the Vala compiler
+ * generated from singledecodebin.vala, do not modify */
+
+/* Ported to Vala from singledecodebin.py in Pitivi:
+ *
+ * Copyright (c) 2005, Edward Hervey <bilboed@bilboed.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gst/gst.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gee.h>
+
+#define _g_free0(var) (var = (g_free (var), NULL))
+
+#define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ())
+#define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin))
+#define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
+#define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN))
+#define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN))
+#define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
+
+typedef struct _SingleDecodeBin SingleDecodeBin;
+typedef struct _SingleDecodeBinClass SingleDecodeBinClass;
+typedef struct _SingleDecodeBinPrivate SingleDecodeBinPrivate;
+#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
+#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define __g_list_free_gst_object_unref0(var) ((var == NULL) ? NULL : (var = (_g_list_free_gst_object_unref (var), NULL)))
+
+#define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
+
+#define LOGGING_TYPE_LEVEL (logging_level_get_type ())
+
+struct _SingleDecodeBin {
+	GstBin parent_instance;
+	SingleDecodeBinPrivate * priv;
+};
+
+struct _SingleDecodeBinClass {
+	GstBinClass parent_class;
+};
+
+struct _SingleDecodeBinPrivate {
+	GstCaps* caps;
+	GstElement* typefind;
+	GstGhostPad* srcpad;
+	GeeArrayList* dynamics;
+	GeeArrayList* validelements;
+	GstElementFactory** factories;
+	gint factories_length1;
+	gint _factories_size_;
+};
+
+typedef enum  {
+	LOGGING_FACILITY_SIGNAL_HANDLERS,
+	LOGGING_FACILITY_DEVELOPER_WARNINGS,
+	LOGGING_FACILITY_GRAPH,
+	LOGGING_FACILITY_LOADING,
+	LOGGING_FACILITY_IMPORT,
+	LOGGING_FACILITY_SINGLEDECODEBIN
+} LoggingFacility;
+
+typedef enum  {
+	LOGGING_LEVEL_CRITICAL,
+	LOGGING_LEVEL_HIGH,
+	LOGGING_LEVEL_MEDIUM,
+	LOGGING_LEVEL_LOW,
+	LOGGING_LEVEL_INFO,
+	LOGGING_LEVEL_VERBOSE
+} LoggingLevel;
+
+
+static gpointer single_decode_bin_parent_class = NULL;
+
+void qsort (void* p, gsize num, gsize size, GCompareFunc func);
+gboolean is_raw (GstCaps* caps);
+GType single_decode_bin_get_type (void);
+#define SINGLE_DECODE_BIN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinPrivate))
+enum  {
+	SINGLE_DECODE_BIN_DUMMY_PROPERTY
+};
+#define SINGLE_DECODE_BIN_QUEUE_SIZE ((gint64) (1 * GST_SECOND))
+GstElement* make_element (const char* name, GError** error);
+static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data);
+static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1);
+SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error);
+SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error);
+static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad);
+static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
+static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element);
+static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self);
+static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element);
+static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b);
+static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value);
+static void _g_list_free_gst_object_unref (GList* self);
+static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps);
+static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value);
+static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value);
+GType logging_facility_get_type (void);
+GType logging_level_get_type (void);
+void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
+static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps);
+static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element);
+static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element);
+static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad);
+static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories);
+static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad);
+static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element);
+static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element);
+static void single_decode_bin_cleanUp (SingleDecodeBin* self);
+static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition);
+static void single_decode_bin_finalize (GObject* obj);
+static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
+static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
+
+
+
+#line 29 "singledecodebin.vala"
+gboolean is_raw (GstCaps* caps) {
+#line 139 "singledecodebin.c"
+	gboolean result = FALSE;
+	char* rep;
+	char** _tmp1_;
+	gint _valid_size_;
+	gint valid_length1;
+	char** _tmp0_ = NULL;
+	char** valid;
+#line 29 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
+#line 30 "singledecodebin.vala"
+	rep = gst_caps_to_string (caps);
+#line 151 "singledecodebin.c"
+	valid = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("video/x-raw"), _tmp0_[1] = g_strdup ("audio/x-raw"), _tmp0_[2] = g_strdup ("text/plain"), _tmp0_[3] = g_strdup ("text/x-pango-markup"), _tmp0_), valid_length1 = 4, _valid_size_ = valid_length1, _tmp1_);
+	{
+		char** val_collection;
+		int val_collection_length1;
+		int val_it;
+#line 32 "singledecodebin.vala"
+		val_collection = valid;
+#line 159 "singledecodebin.c"
+		val_collection_length1 = valid_length1;
+		for (val_it = 0; val_it < valid_length1; val_it = val_it + 1) {
+			char* val;
+			val = g_strdup (val_collection[val_it]);
+			{
+#line 33 "singledecodebin.vala"
+				if (g_str_has_prefix (rep, val)) {
+#line 167 "singledecodebin.c"
+					result = TRUE;
+					_g_free0 (val);
+					_g_free0 (rep);
+					valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
+#line 34 "singledecodebin.vala"
+					return result;
+#line 174 "singledecodebin.c"
+				}
+				_g_free0 (val);
+			}
+		}
+	}
+	result = FALSE;
+	_g_free0 (rep);
+	valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
+#line 35 "singledecodebin.vala"
+	return result;
+#line 185 "singledecodebin.c"
+}
+
+
+static gpointer _gst_caps_ref0 (gpointer self) {
+	return self ? gst_caps_ref (self) : NULL;
+}
+
+
+static gpointer _gst_object_ref0 (gpointer self) {
+	return self ? gst_object_ref (self) : NULL;
+}
+
+
+#line 61 "singledecodebin.vala"
+SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error) {
+#line 201 "singledecodebin.c"
+	GError * _inner_error_;
+	SingleDecodeBin * self;
+	GstCaps* _tmp0_;
+	GstCaps* _tmp3_;
+	GstElement* _tmp4_;
+	GstElementFactory** _tmp8_;
+	gint _tmp7_;
+#line 61 "singledecodebin.vala"
+	g_return_val_if_fail ((caps == NULL) || GST_IS_CAPS (caps), NULL);
+#line 61 "singledecodebin.vala"
+	g_return_val_if_fail (name != NULL, NULL);
+#line 213 "singledecodebin.c"
+	_inner_error_ = NULL;
+	self = g_object_newv (object_type, 0, NULL);
+	_tmp0_ = NULL;
+#line 62 "singledecodebin.vala"
+	if (caps == NULL) {
+#line 219 "singledecodebin.c"
+		GstCaps* _tmp1_;
+#line 62 "singledecodebin.vala"
+		_tmp0_ = (_tmp1_ = gst_caps_new_any (), _gst_caps_unref0 (_tmp0_), _tmp1_);
+#line 223 "singledecodebin.c"
+	} else {
+		GstCaps* _tmp2_;
+#line 62 "singledecodebin.vala"
+		_tmp0_ = (_tmp2_ = _gst_caps_ref0 (caps), _gst_caps_unref0 (_tmp0_), _tmp2_);
+#line 228 "singledecodebin.c"
+	}
+#line 62 "singledecodebin.vala"
+	self->priv->caps = (_tmp3_ = _gst_caps_ref0 (_tmp0_), _gst_caps_unref0 (self->priv->caps), _tmp3_);
+#line 64 "singledecodebin.vala"
+	self->priv->typefind = (_tmp4_ = gst_element_factory_make ("typefind", "internal-typefind"), _gst_object_unref0 (self->priv->typefind), _tmp4_);
+#line 65 "singledecodebin.vala"
+	gst_bin_add (GST_BIN (self), _gst_object_ref0 (self->priv->typefind));
+#line 67 "singledecodebin.vala"
+	if (uri != NULL) {
+#line 238 "singledecodebin.c"
+		GstElement* file_src;
+#line 68 "singledecodebin.vala"
+		file_src = make_element ("filesrc", &_inner_error_);
+#line 242 "singledecodebin.c"
+		if (_inner_error_ != NULL) {
+			g_propagate_error (error, _inner_error_);
+			_gst_caps_unref0 (_tmp0_);
+			gst_object_unref (self);
+			return NULL;
+		}
+#line 70 "singledecodebin.vala"
+		g_object_set (G_OBJECT (file_src), "location", uri, NULL);
+#line 71 "singledecodebin.vala"
+		gst_bin_add (GST_BIN (self), _gst_object_ref0 (file_src));
+#line 73 "singledecodebin.vala"
+		gst_element_link (file_src, self->priv->typefind);
+#line 255 "singledecodebin.c"
+		_gst_object_unref0 (file_src);
+	} else {
+		GstPad* _tmp5_;
+		GstGhostPad* _tmp6_;
+		GstGhostPad* sinkpad;
+#line 75 "singledecodebin.vala"
+		sinkpad = (_tmp6_ = (GstGhostPad*) gst_ghost_pad_new ("sink", _tmp5_ = gst_element_get_pad (self->priv->typefind, "sink")), _gst_object_unref0 (_tmp5_), _tmp6_);
+#line 76 "singledecodebin.vala"
+		gst_pad_set_active (GST_PAD (sinkpad), TRUE);
+#line 77 "singledecodebin.vala"
+		gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (sinkpad)));
+#line 267 "singledecodebin.c"
+		_gst_object_unref0 (sinkpad);
+	}
+#line 79 "singledecodebin.vala"
+	g_signal_connect (self->priv->typefind, "have-type", (GCallback) single_decode_bin_typefindHaveTypeCb, self);
+#line 81 "singledecodebin.vala"
+	self->priv->factories = (_tmp8_ = single_decode_bin_getSortedFactoryList (self, &_tmp7_), self->priv->factories = (_vala_array_free (self->priv->factories, self->priv->factories_length1, (GDestroyNotify) gst_object_unref), NULL), self->priv->factories_length1 = _tmp7_, self->priv->_factories_size_ = self->priv->factories_length1, _tmp8_);
+#line 274 "singledecodebin.c"
+	_gst_caps_unref0 (_tmp0_);
+	return self;
+}
+
+
+#line 61 "singledecodebin.vala"
+SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error) {
+#line 61 "singledecodebin.vala"
+	return single_decode_bin_construct (TYPE_SINGLE_DECODE_BIN, caps, name, uri, error);
+#line 284 "singledecodebin.c"
+}
+
+
+#line 360 "singledecodebin.vala"
+static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
+#line 290 "singledecodebin.c"
+	single_decode_bin_dynamicPadAddedCb (self, _sender, pad);
+}
+
+
+#line 366 "singledecodebin.vala"
+static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self) {
+#line 297 "singledecodebin.c"
+	single_decode_bin_dynamicNoMorePadsCb (self, _sender);
+}
+
+
+#line 86 "singledecodebin.vala"
+static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element) {
+#line 86 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 86 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 87 "singledecodebin.vala"
+	gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->dynamics), element);
+#line 88 "singledecodebin.vala"
+	g_signal_connect_object (element, "pad-added", (GCallback) _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added, self, 0);
+#line 89 "singledecodebin.vala"
+	g_signal_connect_object (element, "no-more-pads", (GCallback) _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads, self, 0);
+#line 314 "singledecodebin.c"
+}
+
+
+#line 92 "singledecodebin.vala"
+static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b) {
+#line 320 "singledecodebin.c"
+	gint result = 0;
+	GstPluginFeature* p1;
+	GstPluginFeature* p2;
+#line 93 "singledecodebin.vala"
+	p1 = *((GstPluginFeature**) a);
+#line 94 "singledecodebin.vala"
+	p2 = *((GstPluginFeature**) b);
+#line 328 "singledecodebin.c"
+	result = (gint) (gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p2)) - gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p1)));
+#line 95 "singledecodebin.vala"
+	return result;
+#line 332 "singledecodebin.c"
+}
+
+
+#line 1144 "glib-2.0.vapi"
+static gboolean string_contains (const char* self, const char* needle) {
+#line 338 "singledecodebin.c"
+	gboolean result = FALSE;
+#line 1144 "glib-2.0.vapi"
+	g_return_val_if_fail (self != NULL, FALSE);
+#line 1144 "glib-2.0.vapi"
+	g_return_val_if_fail (needle != NULL, FALSE);
+#line 344 "singledecodebin.c"
+	result = strstr (self, needle) != NULL;
+#line 1145 "glib-2.0.vapi"
+	return result;
+#line 348 "singledecodebin.c"
+}
+
+
+static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value) {
+	if ((*length) == (*size)) {
+		*size = (*size) ? (2 * (*size)) : 4;
+		*array = g_renew (GstElementFactory*, *array, (*size) + 1);
+	}
+	(*array)[(*length)++] = value;
+	(*array)[*length] = NULL;
+}
+
+
+static void _g_list_free_gst_object_unref (GList* self) {
+	g_list_foreach (self, (GFunc) gst_object_unref, NULL);
+	g_list_free (self);
+}
+
+
+#line 99 "singledecodebin.vala"
+static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1) {
+#line 370 "singledecodebin.c"
+	GstElementFactory** result = NULL;
+	GstRegistry* registry;
+	GstElementFactory** _tmp0_;
+	gint _factories_size_;
+	gint factories_length1;
+	GstElementFactory** factories;
+	GstElementFactory** _tmp5_;
+#line 99 "singledecodebin.vala"
+	g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
+#line 100 "singledecodebin.vala"
+	registry = _gst_object_ref0 (gst_registry_get_default ());
+#line 382 "singledecodebin.c"
+	factories = (_tmp0_ = g_new0 (GstElementFactory*, 0 + 1), factories_length1 = 0, _factories_size_ = factories_length1, _tmp0_);
+	{
+		GList* plugin_feature_collection;
+		GList* plugin_feature_it;
+#line 103 "singledecodebin.vala"
+		plugin_feature_collection = gst_registry_get_feature_list (registry, GST_TYPE_ELEMENT_FACTORY);
+#line 389 "singledecodebin.c"
+		for (plugin_feature_it = plugin_feature_collection; plugin_feature_it != NULL; plugin_feature_it = plugin_feature_it->next) {
+			GstPluginFeature* plugin_feature;
+#line 103 "singledecodebin.vala"
+			plugin_feature = _gst_object_ref0 ((GstPluginFeature*) plugin_feature_it->data);
+#line 394 "singledecodebin.c"
+			{
+				GstPluginFeature* _tmp1_;
+				GstElementFactory* factory;
+				gboolean _tmp2_ = FALSE;
+				char* klass;
+				gboolean _tmp3_ = FALSE;
+				gboolean _tmp4_ = FALSE;
+#line 106 "singledecodebin.vala"
+				factory = _gst_object_ref0 ((_tmp1_ = plugin_feature, GST_IS_ELEMENT_FACTORY (_tmp1_) ? ((GstElementFactory*) _tmp1_) : NULL));
+#line 107 "singledecodebin.vala"
+				if (factory == NULL) {
+#line 107 "singledecodebin.vala"
+					_tmp2_ = TRUE;
+#line 408 "singledecodebin.c"
+				} else {
+#line 107 "singledecodebin.vala"
+					_tmp2_ = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) < 64;
+#line 412 "singledecodebin.c"
+				}
+#line 107 "singledecodebin.vala"
+				if (_tmp2_) {
+#line 416 "singledecodebin.c"
+					_gst_object_unref0 (plugin_feature);
+					_gst_object_unref0 (factory);
+#line 108 "singledecodebin.vala"
+					continue;
+#line 421 "singledecodebin.c"
+				}
+#line 109 "singledecodebin.vala"
+				klass = g_strdup (gst_element_factory_get_klass (factory));
+#line 110 "singledecodebin.vala"
+				if (string_contains (klass, "Demuxer")) {
+#line 110 "singledecodebin.vala"
+					_tmp4_ = TRUE;
+#line 429 "singledecodebin.c"
+				} else {
+#line 110 "singledecodebin.vala"
+					_tmp4_ = string_contains (klass, "Decoder");
+#line 433 "singledecodebin.c"
+				}
+#line 110 "singledecodebin.vala"
+				if (_tmp4_) {
+#line 110 "singledecodebin.vala"
+					_tmp3_ = TRUE;
+#line 439 "singledecodebin.c"
+				} else {
+#line 110 "singledecodebin.vala"
+					_tmp3_ = string_contains (klass, "Parse");
+#line 443 "singledecodebin.c"
+				}
+#line 110 "singledecodebin.vala"
+				if (_tmp3_) {
+#line 111 "singledecodebin.vala"
+					_vala_array_add2 (&factories, &factories_length1, &_factories_size_, _gst_object_ref0 (factory));
+#line 449 "singledecodebin.c"
+				}
+				_gst_object_unref0 (plugin_feature);
+				_gst_object_unref0 (factory);
+				_g_free0 (klass);
+			}
+		}
+#line 103 "singledecodebin.vala"
+		__g_list_free_gst_object_unref0 (plugin_feature_collection);
+#line 458 "singledecodebin.c"
+	}
+#line 114 "singledecodebin.vala"
+	qsort (factories, (gsize) factories_length1, (gsize) sizeof (GstElementFactory*), (GCompareFunc) single_decode_bin_factory_compare);
+#line 462 "singledecodebin.c"
+	result = (_tmp5_ = factories, *result_length1 = factories_length1, _tmp5_);
+	_gst_object_unref0 (registry);
+#line 116 "singledecodebin.vala"
+	return result;
+#line 467 "singledecodebin.c"
+	_gst_object_unref0 (registry);
+	factories = (_vala_array_free (factories, factories_length1, (GDestroyNotify) gst_object_unref), NULL);
+}
+
+
+#line 121 "singledecodebin.vala"
+static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps) {
+#line 475 "singledecodebin.c"
+	GeeArrayList* result = NULL;
+	GeeArrayList* res;
+#line 121 "singledecodebin.vala"
+	g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
+#line 121 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
+#line 122 "singledecodebin.vala"
+	res = gee_array_list_new (GST_TYPE_ELEMENT_FACTORY, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
+#line 484 "singledecodebin.c"
+	{
+		GstElementFactory** factory_collection;
+		int factory_collection_length1;
+		int factory_it;
+#line 124 "singledecodebin.vala"
+		factory_collection = self->priv->factories;
+#line 491 "singledecodebin.c"
+		factory_collection_length1 = self->priv->factories_length1;
+		for (factory_it = 0; factory_it < self->priv->factories_length1; factory_it = factory_it + 1) {
+			GstElementFactory* factory;
+			factory = _gst_object_ref0 (factory_collection[factory_it]);
+			{
+				GList* templates;
+#line 125 "singledecodebin.vala"
+				templates = gst_element_factory_get_static_pad_templates (factory);
+#line 500 "singledecodebin.c"
+				{
+					GList* template_collection;
+					GList* template_it;
+#line 126 "singledecodebin.vala"
+					template_collection = templates;
+#line 506 "singledecodebin.c"
+					for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
+						GstStaticPadTemplate template;
+#line 126 "singledecodebin.vala"
+						template = *((GstStaticPadTemplate*) template_it->data);
+#line 511 "singledecodebin.c"
+						{
+#line 127 "singledecodebin.vala"
+							if (template.direction == GST_PAD_SINK) {
+#line 515 "singledecodebin.c"
+								GstCaps* _tmp0_;
+								GstCaps* _tmp1_;
+								GstCaps* intersect;
+#line 128 "singledecodebin.vala"
+								intersect = (_tmp1_ = gst_caps_intersect (caps, _tmp0_ = gst_static_caps_get (&template.static_caps)), _gst_caps_unref0 (_tmp0_), _tmp1_);
+#line 129 "singledecodebin.vala"
+								if (!gst_caps_is_empty (intersect)) {
+#line 130 "singledecodebin.vala"
+									gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (res), factory);
+#line 525 "singledecodebin.c"
+									_gst_caps_unref0 (intersect);
+#line 131 "singledecodebin.vala"
+									break;
+#line 529 "singledecodebin.c"
+								}
+								_gst_caps_unref0 (intersect);
+							}
+						}
+					}
+				}
+				_gst_object_unref0 (factory);
+			}
+		}
+	}
+	result = res;
+#line 136 "singledecodebin.vala"
+	return result;
+#line 543 "singledecodebin.c"
+}
+
+
+static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value) {
+	if ((*length) == (*size)) {
+		*size = (*size) ? (2 * (*size)) : 4;
+		*array = g_renew (GstPad*, *array, (*size) + 1);
+	}
+	(*array)[(*length)++] = value;
+	(*array)[*length] = NULL;
+}
+
+
+static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value) {
+	if ((*length) == (*size)) {
+		*size = (*size) ? (2 * (*size)) : 4;
+		*array = g_renew (GstPad*, *array, (*size) + 1);
+	}
+	(*array)[(*length)++] = value;
+	(*array)[*length] = NULL;
+}
+
+
+#line 142 "singledecodebin.vala"
+static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element) {
+#line 569 "singledecodebin.c"
+	GstPad** _tmp0_;
+	gint _to_connect_size_;
+	gint to_connect_length1;
+	GstPad** to_connect;
+	gboolean is_dynamic;
+#line 142 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 142 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 579 "singledecodebin.c"
+	to_connect = (_tmp0_ = g_new0 (GstPad*, 0 + 1), to_connect_length1 = 0, _to_connect_size_ = to_connect_length1, _tmp0_);
+#line 144 "singledecodebin.vala"
+	is_dynamic = FALSE;
+#line 583 "singledecodebin.c"
+	{
+		GList* template_collection;
+		GList* template_it;
+#line 146 "singledecodebin.vala"
+		template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)));
+#line 589 "singledecodebin.c"
+		for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
+			GstPadTemplate* template;
+#line 146 "singledecodebin.vala"
+			template = _gst_object_ref0 ((GstPadTemplate*) template_it->data);
+#line 594 "singledecodebin.c"
+			{
+				GstPadDirection _tmp1_;
+				GstPadPresence _tmp2_;
+#line 147 "singledecodebin.vala"
+				if ((g_object_get (template, "direction", &_tmp1_, NULL), _tmp1_) != GST_PAD_SRC) {
+#line 600 "singledecodebin.c"
+					_gst_object_unref0 (template);
+#line 148 "singledecodebin.vala"
+					continue;
+#line 604 "singledecodebin.c"
+				}
+#line 149 "singledecodebin.vala"
+				if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_ALWAYS) {
+#line 608 "singledecodebin.c"
+					char* _tmp4_;
+					char* _tmp3_ = NULL;
+					GstPad* _tmp5_;
+					GstPad* pad;
+#line 150 "singledecodebin.vala"
+					pad = (_tmp5_ = gst_element_get_pad (element, _tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_)), _g_free0 (_tmp4_), _tmp5_);
+#line 151 "singledecodebin.vala"
+					_vala_array_add3 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad));
+#line 617 "singledecodebin.c"
+					_gst_object_unref0 (pad);
+				} else {
+					GstPadPresence _tmp6_;
+#line 152 "singledecodebin.vala"
+					if ((g_object_get (template, "presence", &_tmp6_, NULL), _tmp6_) == GST_PAD_SOMETIMES) {
+#line 623 "singledecodebin.c"
+						char* _tmp8_;
+						char* _tmp7_ = NULL;
+						GstPad* _tmp9_;
+						GstPad* pad;
+#line 153 "singledecodebin.vala"
+						pad = (_tmp9_ = gst_element_get_pad (element, _tmp8_ = (g_object_get (template, "name-template", &_tmp7_, NULL), _tmp7_)), _g_free0 (_tmp8_), _tmp9_);
+#line 154 "singledecodebin.vala"
+						if (pad != NULL) {
+#line 155 "singledecodebin.vala"
+							_vala_array_add4 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad));
+#line 634 "singledecodebin.c"
+						} else {
+#line 156 "singledecodebin.vala"
+							is_dynamic = TRUE;
+#line 638 "singledecodebin.c"
+						}
+						_gst_object_unref0 (pad);
+					}
+				}
+				_gst_object_unref0 (template);
+			}
+		}
+	}
+#line 160 "singledecodebin.vala"
+	if (is_dynamic) {
+#line 649 "singledecodebin.c"
+		char* _tmp11_;
+		char* _tmp10_;
+#line 161 "singledecodebin.vala"
+		logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp11_ = g_strdup_printf ("%s is a dynamic element", _tmp10_ = gst_object_get_name (GST_OBJECT (element))));
+#line 654 "singledecodebin.c"
+		_g_free0 (_tmp11_);
+		_g_free0 (_tmp10_);
+#line 163 "singledecodebin.vala"
+		single_decode_bin_controlDynamicElement (self, element);
+#line 659 "singledecodebin.c"
+	}
+	{
+		GstPad** pad_collection;
+		int pad_collection_length1;
+		int pad_it;
+#line 166 "singledecodebin.vala"
+		pad_collection = to_connect;
+#line 667 "singledecodebin.c"
+		pad_collection_length1 = to_connect_length1;
+		for (pad_it = 0; pad_it < to_connect_length1; pad_it = pad_it + 1) {
+			GstPad* pad;
+			pad = _gst_object_ref0 (pad_collection[pad_it]);
+			{
+				GstCaps* _tmp12_;
+#line 167 "singledecodebin.vala"
+				single_decode_bin_closePadLink (self, element, pad, _tmp12_ = gst_pad_get_caps (pad));
+#line 676 "singledecodebin.c"
+				_gst_caps_unref0 (_tmp12_);
+				_gst_object_unref0 (pad);
+			}
+		}
+	}
+	to_connect = (_vala_array_free (to_connect, to_connect_length1, (GDestroyNotify) gst_object_unref), NULL);
+}
+
+
+#line 170 "singledecodebin.vala"
+static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element) {
+#line 688 "singledecodebin.c"
+	gboolean result = FALSE;
+	gint potential_src_pads;
+#line 170 "singledecodebin.vala"
+	g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), FALSE);
+#line 170 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
+#line 171 "singledecodebin.vala"
+	if (!string_contains (gst_element_factory_get_klass (gst_element_get_factory (element)), "Demux")) {
+#line 697 "singledecodebin.c"
+		result = FALSE;
+#line 172 "singledecodebin.vala"
+		return result;
+#line 701 "singledecodebin.c"
+	}
+#line 174 "singledecodebin.vala"
+	potential_src_pads = 0;
+#line 705 "singledecodebin.c"
+	{
+		GList* template_collection;
+		GList* template_it;
+#line 175 "singledecodebin.vala"
+		template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)));
+#line 711 "singledecodebin.c"
+		for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
+			GstPadTemplate* template;
+#line 175 "singledecodebin.vala"
+			template = _gst_object_ref0 ((GstPadTemplate*) template_it->data);
+#line 716 "singledecodebin.c"
+			{
+				GstPadDirection _tmp0_;
+				gboolean _tmp1_ = FALSE;
+				GstPadPresence _tmp2_;
+#line 176 "singledecodebin.vala"
+				if ((g_object_get (template, "direction", &_tmp0_, NULL), _tmp0_) != GST_PAD_SRC) {
+#line 723 "singledecodebin.c"
+					_gst_object_unref0 (template);
+#line 177 "singledecodebin.vala"
+					continue;
+#line 727 "singledecodebin.c"
+				}
+#line 179 "singledecodebin.vala"
+				if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_REQUEST) {
+#line 179 "singledecodebin.vala"
+					_tmp1_ = TRUE;
+#line 733 "singledecodebin.c"
+				} else {
+					char* _tmp4_;
+					char* _tmp3_ = NULL;
+#line 180 "singledecodebin.vala"
+					_tmp1_ = string_contains (_tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_), "%");
+#line 739 "singledecodebin.c"
+					_g_free0 (_tmp4_);
+				}
+#line 179 "singledecodebin.vala"
+				if (_tmp1_) {
+#line 181 "singledecodebin.vala"
+					potential_src_pads = potential_src_pads + 2;
+#line 746 "singledecodebin.c"
+					_gst_object_unref0 (template);
+#line 182 "singledecodebin.vala"
+					break;
+#line 750 "singledecodebin.c"
+				} else {
+#line 183 "singledecodebin.vala"
+					potential_src_pads = potential_src_pads + 1;
+#line 754 "singledecodebin.c"
+				}
+				_gst_object_unref0 (template);
+			}
+		}
+	}
+	result = potential_src_pads > 1;
+#line 186 "singledecodebin.vala"
+	return result;
+#line 763 "singledecodebin.c"
+}
+
+
+#line 189 "singledecodebin.vala"
+static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad) {
+#line 769 "singledecodebin.c"
+	GstPad* result = NULL;
+	GstElement* queue;
+	GValue _tmp1_;
+	GValue _tmp0_ = {0};
+	GstPad* _tmp2_;
+#line 189 "singledecodebin.vala"
+	g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
+#line 189 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_PAD (pad), NULL);
+#line 190 "singledecodebin.vala"
+	queue = gst_element_factory_make ("queue", NULL);
+#line 191 "singledecodebin.vala"
+	g_object_set_property (G_OBJECT (queue), "max_size_time", (_tmp1_ = (g_value_init (&_tmp0_, G_TYPE_INT64), g_value_set_int64 (&_tmp0_, SINGLE_DECODE_BIN_QUEUE_SIZE), _tmp0_), &_tmp1_));
+#line 192 "singledecodebin.vala"
+	gst_bin_add (GST_BIN (self), _gst_object_ref0 (queue));
+#line 193 "singledecodebin.vala"
+	gst_element_sync_state_with_parent (queue);
+#line 194 "singledecodebin.vala"
+	gst_pad_link (pad, _tmp2_ = gst_element_get_pad (queue, "sink"));
+#line 789 "singledecodebin.c"
+	_gst_object_unref0 (_tmp2_);
+	result = gst_element_get_pad (queue, "src");
+	_gst_object_unref0 (queue);
+#line 195 "singledecodebin.vala"
+	return result;
+#line 795 "singledecodebin.c"
+}
+
+
+#line 200 "singledecodebin.vala"
+static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories) {
+#line 801 "singledecodebin.c"
+	GstElement* result = NULL;
+	GstPad* pad;
+	GstElement* _result_;
+#line 200 "singledecodebin.vala"
+	g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
+#line 200 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_ELEMENT (source), NULL);
+#line 200 "singledecodebin.vala"
+	g_return_val_if_fail (GST_IS_PAD (in_pad), NULL);
+#line 200 "singledecodebin.vala"
+	g_return_val_if_fail (GEE_IS_ARRAY_LIST (factories), NULL);
+#line 202 "singledecodebin.vala"
+	pad = _gst_object_ref0 (in_pad);
+#line 203 "singledecodebin.vala"
+	if (single_decode_bin_isDemuxer (self, source)) {
+#line 817 "singledecodebin.c"
+		GstPad* _tmp0_;
+#line 204 "singledecodebin.vala"
+		pad = (_tmp0_ = single_decode_bin_plugDecodingQueue (self, in_pad), _gst_object_unref0 (pad), _tmp0_);
+#line 821 "singledecodebin.c"
+	}
+#line 206 "singledecodebin.vala"
+	_result_ = NULL;
+#line 825 "singledecodebin.c"
+	{
+		GeeIterator* _factory_it;
+		_factory_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (factories));
+#line 207 "singledecodebin.vala"
+		while (TRUE) {
+#line 831 "singledecodebin.c"
+			GstElementFactory* factory;
+			GstElement* element;
+			GstPad* sinkpad;
+			GstElement* _tmp1_;
+#line 207 "singledecodebin.vala"
+			if (!gee_iterator_next (_factory_it)) {
+#line 207 "singledecodebin.vala"
+				break;
+#line 840 "singledecodebin.c"
+			}
+#line 207 "singledecodebin.vala"
+			factory = (GstElementFactory*) gee_iterator_get (_factory_it);
+#line 208 "singledecodebin.vala"
+			element = gst_element_factory_create (factory, NULL);
+#line 209 "singledecodebin.vala"
+			if (element == NULL) {
+#line 210 "singledecodebin.vala"
+				g_warning ("singledecodebin.vala:210: couldn't create element from factory");
+#line 850 "singledecodebin.c"
+				_gst_object_unref0 (factory);
+				_gst_object_unref0 (element);
+#line 211 "singledecodebin.vala"
+				continue;
+#line 855 "singledecodebin.c"
+			}
+#line 214 "singledecodebin.vala"
+			sinkpad = gst_element_get_pad (element, "sink");
+#line 215 "singledecodebin.vala"
+			if (sinkpad == NULL) {
+#line 861 "singledecodebin.c"
+				_gst_object_unref0 (factory);
+				_gst_object_unref0 (element);
+				_gst_object_unref0 (sinkpad);
+#line 216 "singledecodebin.vala"
+				continue;
+#line 867 "singledecodebin.c"
+			}
+#line 218 "singledecodebin.vala"
+			gst_bin_add (GST_BIN (self), _gst_object_ref0 (element));
+#line 219 "singledecodebin.vala"
+			gst_element_set_state (element, GST_STATE_READY);
+#line 220 "singledecodebin.vala"
+			if (gst_pad_link (pad, sinkpad) != GST_PAD_LINK_OK) {
+#line 221 "singledecodebin.vala"
+				gst_element_set_state (element, GST_STATE_NULL);
+#line 222 "singledecodebin.vala"
+				gst_bin_remove (GST_BIN (self), element);
+#line 879 "singledecodebin.c"
+				_gst_object_unref0 (factory);
+				_gst_object_unref0 (element);
+				_gst_object_unref0 (sinkpad);
+#line 223 "singledecodebin.vala"
+				continue;
+#line 885 "singledecodebin.c"
+			}
+#line 226 "singledecodebin.vala"
+			single_decode_bin_closeLink (self, element);
+#line 227 "singledecodebin.vala"
+			gst_element_set_state (element, GST_STATE_PAUSED);
+#line 229 "singledecodebin.vala"
+			_result_ = (_tmp1_ = _gst_object_ref0 (element), _gst_object_unref0 (_result_), _tmp1_);
+#line 893 "singledecodebin.c"
+			_gst_object_unref0 (factory);
+			_gst_object_unref0 (element);
+			_gst_object_unref0 (sinkpad);
+#line 230 "singledecodebin.vala"
+			break;
+#line 899 "singledecodebin.c"
+		}
+		_g_object_unref0 (_factory_it);
+	}
+	result = _result_;
+	_gst_object_unref0 (pad);
+#line 233 "singledecodebin.vala"
+	return result;
+#line 907 "singledecodebin.c"
+}
+
+
+#line 239 "singledecodebin.vala"
+static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps) {
+#line 913 "singledecodebin.c"
+	char* _tmp3_;
+	char* _tmp2_;
+	char* _tmp1_;
+	char* _tmp0_;
+	GstCaps* _tmp4_;
+	gboolean _tmp5_;
+#line 239 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 239 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 239 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_PAD (pad));
+#line 239 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_CAPS (caps));
+#line 240 "singledecodebin.vala"
+	logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("element:%s, pad:%s, caps:%s", _tmp0_ = gst_object_get_name (GST_OBJECT (element)), _tmp1_ = gst_object_get_name (GST_OBJECT (pad)), _tmp2_ = gst_caps_to_string (caps)));
+#line 930 "singledecodebin.c"
+	_g_free0 (_tmp3_);
+	_g_free0 (_tmp2_);
+	_g_free0 (_tmp1_);
+	_g_free0 (_tmp0_);
+#line 244 "singledecodebin.vala"
+	if (gst_caps_is_empty (caps)) {
+#line 245 "singledecodebin.vala"
+		logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_INFO, "unknown type");
+#line 246 "singledecodebin.vala"
+		return;
+#line 941 "singledecodebin.c"
+	}
+#line 248 "singledecodebin.vala"
+	if (gst_caps_is_any (caps)) {
+#line 249 "singledecodebin.vala"
+		logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "type is not known yet, waiting");
+#line 250 "singledecodebin.vala"
+		return;
+#line 949 "singledecodebin.c"
+	}
+#line 253 "singledecodebin.vala"
+	gst_pad_get_direction (pad);
+#line 255 "singledecodebin.vala"
+	if ((_tmp5_ = !gst_caps_is_empty (_tmp4_ = gst_caps_intersect (caps, self->priv->caps)), _gst_caps_unref0 (_tmp4_), _tmp5_)) {
+#line 257 "singledecodebin.vala"
+		if (self->priv->srcpad == NULL) {
+#line 258 "singledecodebin.vala"
+			single_decode_bin_wrapUp (self, element, pad);
+#line 959 "singledecodebin.c"
+		}
+	} else {
+#line 259 "singledecodebin.vala"
+		if (is_raw (caps)) {
+#line 260 "singledecodebin.vala"
+			logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "We hit a raw caps which isn't the wanted one");
+#line 966 "singledecodebin.c"
+		} else {
+			GeeArrayList* facts;
+			GstElement* _tmp6_;
+#line 265 "singledecodebin.vala"
+			if (gst_caps_get_size (caps) > 1) {
+#line 266 "singledecodebin.vala"
+				logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "many possible types, delaying");
+#line 268 "singledecodebin.vala"
+				return;
+#line 976 "singledecodebin.c"
+			}
+#line 270 "singledecodebin.vala"
+			facts = single_decode_bin_findCompatibleFactory (self, caps);
+#line 271 "singledecodebin.vala"
+			if (gee_collection_get_size (GEE_COLLECTION (facts)) == 0) {
+#line 272 "singledecodebin.vala"
+				logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "unknown type");
+#line 984 "singledecodebin.c"
+				_g_object_unref0 (facts);
+#line 274 "singledecodebin.vala"
+				return;
+#line 988 "singledecodebin.c"
+			}
+#line 276 "singledecodebin.vala"
+			_tmp6_ = single_decode_bin_tryToLink1 (self, element, pad, facts);
+#line 992 "singledecodebin.c"
+			_gst_object_unref0 (_tmp6_);
+			_g_object_unref0 (facts);
+		}
+	}
+}
+
+
+#line 282 "singledecodebin.vala"
+static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad) {
+#line 1002 "singledecodebin.c"
+	char* _tmp1_;
+	char* _tmp0_;
+	GstGhostPad* _tmp2_;
+#line 282 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 282 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 282 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_PAD (pad));
+#line 283 "singledecodebin.vala"
+	if (self->priv->srcpad != NULL) {
+#line 284 "singledecodebin.vala"
+		return;
+#line 1016 "singledecodebin.c"
+	}
+#line 285 "singledecodebin.vala"
+	single_decode_bin_markValidElements (self, element);
+#line 286 "singledecodebin.vala"
+	single_decode_bin_removeUnusedElements (self, self->priv->typefind);
+#line 287 "singledecodebin.vala"
+	logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("ghosting pad %s", _tmp0_ = gst_object_get_name (GST_OBJECT (pad))));
+#line 1024 "singledecodebin.c"
+	_g_free0 (_tmp1_);
+	_g_free0 (_tmp0_);
+#line 289 "singledecodebin.vala"
+	self->priv->srcpad = (_tmp2_ = (GstGhostPad*) gst_ghost_pad_new ("src", pad), _gst_object_unref0 (self->priv->srcpad), _tmp2_);
+#line 290 "singledecodebin.vala"
+	if (gst_caps_is_fixed (self->priv->caps)) {
+#line 291 "singledecodebin.vala"
+		gst_pad_set_caps (GST_PAD (self->priv->srcpad), self->priv->caps);
+#line 1033 "singledecodebin.c"
+	}
+#line 293 "singledecodebin.vala"
+	gst_pad_set_active (GST_PAD (self->priv->srcpad), TRUE);
+#line 295 "singledecodebin.vala"
+	gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (self->priv->srcpad)));
+#line 296 "singledecodebin.vala"
+	gst_element_post_message (GST_ELEMENT (self), gst_message_new_state_dirty (GST_OBJECT (self)));
+#line 1041 "singledecodebin.c"
+}
+
+
+#line 300 "singledecodebin.vala"
+static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element) {
+#line 1047 "singledecodebin.c"
+	char* _tmp1_;
+	char* _tmp0_;
+	GstPad* pad;
+	GstPad* _tmp2_;
+	GstElement* _tmp3_;
+	GstElement* parent;
+#line 300 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 300 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 301 "singledecodebin.vala"
+	logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("element:%s", _tmp0_ = gst_object_get_name (GST_OBJECT (element))));
+#line 1060 "singledecodebin.c"
+	_g_free0 (_tmp1_);
+	_g_free0 (_tmp0_);
+#line 303 "singledecodebin.vala"
+	if (element == self->priv->typefind) {
+#line 304 "singledecodebin.vala"
+		return;
+#line 1067 "singledecodebin.c"
+	}
+#line 305 "singledecodebin.vala"
+	gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->validelements), element);
+#line 308 "singledecodebin.vala"
+	pad = _gst_object_ref0 (GST_PAD ((GstPad*) g_list_first (element->sinkpads)->data));
+#line 309 "singledecodebin.vala"
+	parent = (_tmp3_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp2_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp2_), _tmp3_);
+#line 310 "singledecodebin.vala"
+	single_decode_bin_markValidElements (self, parent);
+#line 1077 "singledecodebin.c"
+	_gst_object_unref0 (pad);
+	_gst_object_unref0 (parent);
+}
+
+
+#line 314 "singledecodebin.vala"
+static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element) {
+#line 314 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 314 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 1089 "singledecodebin.c"
+	{
+		GList* pad_collection;
+		GList* pad_it;
+#line 315 "singledecodebin.vala"
+		pad_collection = element->srcpads;
+#line 1095 "singledecodebin.c"
+		for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) {
+			GstPad* pad;
+#line 315 "singledecodebin.vala"
+			pad = _gst_object_ref0 ((GstPad*) pad_it->data);
+#line 1100 "singledecodebin.c"
+			{
+#line 316 "singledecodebin.vala"
+				if (gst_pad_is_linked (pad)) {
+#line 1104 "singledecodebin.c"
+					GstPad* _tmp0_;
+					GstElement* _tmp1_;
+					GstElement* peer;
+#line 317 "singledecodebin.vala"
+					peer = (_tmp1_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp0_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp0_), _tmp1_);
+#line 318 "singledecodebin.vala"
+					single_decode_bin_removeUnusedElements (self, peer);
+#line 319 "singledecodebin.vala"
+					if (!gee_abstract_collection_contains (GEE_ABSTRACT_COLLECTION (self->priv->validelements), peer)) {
+#line 1114 "singledecodebin.c"
+						char* _tmp3_;
+						char* _tmp2_;
+						GstPad* _tmp4_;
+#line 320 "singledecodebin.vala"
+						logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("removing %s", _tmp2_ = gst_object_get_name (GST_OBJECT (peer))));
+#line 1120 "singledecodebin.c"
+						_g_free0 (_tmp3_);
+						_g_free0 (_tmp2_);
+#line 322 "singledecodebin.vala"
+						gst_pad_unlink (pad, _tmp4_ = gst_pad_get_peer (pad));
+#line 1125 "singledecodebin.c"
+						_gst_object_unref0 (_tmp4_);
+#line 323 "singledecodebin.vala"
+						gst_element_set_state (peer, GST_STATE_NULL);
+#line 324 "singledecodebin.vala"
+						gst_bin_remove (GST_BIN (self), peer);
+#line 1131 "singledecodebin.c"
+					}
+					_gst_object_unref0 (peer);
+				}
+				_gst_object_unref0 (pad);
+			}
+		}
+	}
+}
+
+
+#line 329 "singledecodebin.vala"
+static void single_decode_bin_cleanUp (SingleDecodeBin* self) {
+#line 1144 "singledecodebin.c"
+	GstGhostPad* _tmp0_;
+	GeeArrayList* _tmp1_;
+#line 329 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 330 "singledecodebin.vala"
+	if (self->priv->srcpad != NULL) {
+#line 331 "singledecodebin.vala"
+		gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (self->priv->srcpad));
+#line 1153 "singledecodebin.c"
+	}
+#line 332 "singledecodebin.vala"
+	self->priv->srcpad = (_tmp0_ = NULL, _gst_object_unref0 (self->priv->srcpad), _tmp0_);
+#line 1157 "singledecodebin.c"
+	{
+		GeeIterator* _element_it;
+		_element_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->validelements));
+#line 333 "singledecodebin.vala"
+		while (TRUE) {
+#line 1163 "singledecodebin.c"
+			GstElement* element;
+#line 333 "singledecodebin.vala"
+			if (!gee_iterator_next (_element_it)) {
+#line 333 "singledecodebin.vala"
+				break;
+#line 1169 "singledecodebin.c"
+			}
+#line 333 "singledecodebin.vala"
+			element = (GstElement*) gee_iterator_get (_element_it);
+#line 334 "singledecodebin.vala"
+			gst_element_set_state (element, GST_STATE_NULL);
+#line 335 "singledecodebin.vala"
+			gst_bin_remove (GST_BIN (self), element);
+#line 1177 "singledecodebin.c"
+			_gst_object_unref0 (element);
+		}
+		_g_object_unref0 (_element_it);
+	}
+#line 337 "singledecodebin.vala"
+	self->priv->validelements = (_tmp1_ = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL), _g_object_unref0 (self->priv->validelements), _tmp1_);
+#line 1184 "singledecodebin.c"
+}
+
+
+#line 342 "singledecodebin.vala"
+static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition) {
+#line 1190 "singledecodebin.c"
+	SingleDecodeBin * self;
+	GstStateChangeReturn result = 0;
+	GstStateChangeReturn res;
+	self = SINGLE_DECODE_BIN (base);
+#line 343 "singledecodebin.vala"
+	res = GST_ELEMENT_CLASS (single_decode_bin_parent_class)->change_state (GST_ELEMENT (GST_BIN (self)), transition);
+#line 344 "singledecodebin.vala"
+	if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) {
+#line 345 "singledecodebin.vala"
+		single_decode_bin_cleanUp (self);
+#line 1201 "singledecodebin.c"
+	}
+	result = res;
+#line 346 "singledecodebin.vala"
+	return result;
+#line 1206 "singledecodebin.c"
+}
+
+
+#line 351 "singledecodebin.vala"
+static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data) {
+#line 1212 "singledecodebin.c"
+	char* _tmp1_;
+	char* _tmp0_;
+	GstPad* _tmp2_;
+#line 351 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (t));
+#line 351 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_CAPS (caps));
+#line 351 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (data));
+#line 353 "singledecodebin.vala"
+	logging_emit (G_OBJECT (data), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("probability:%d, caps:%s", probability, _tmp0_ = gst_caps_to_string (caps)));
+#line 1224 "singledecodebin.c"
+	_g_free0 (_tmp1_);
+	_g_free0 (_tmp0_);
+#line 355 "singledecodebin.vala"
+	single_decode_bin_closePadLink (data, t, _tmp2_ = gst_element_get_pad (t, "src"), caps);
+#line 1229 "singledecodebin.c"
+	_gst_object_unref0 (_tmp2_);
+}
+
+
+#line 360 "singledecodebin.vala"
+static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad) {
+#line 360 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 360 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 360 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_PAD (pad));
+#line 361 "singledecodebin.vala"
+	logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicPadAddedCb");
+#line 362 "singledecodebin.vala"
+	if (self->priv->srcpad == NULL) {
+#line 1246 "singledecodebin.c"
+		GstCaps* _tmp0_;
+#line 363 "singledecodebin.vala"
+		single_decode_bin_closePadLink (self, element, pad, _tmp0_ = gst_pad_get_caps (pad));
+#line 1250 "singledecodebin.c"
+		_gst_caps_unref0 (_tmp0_);
+	}
+}
+
+
+#line 366 "singledecodebin.vala"
+static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element) {
+#line 366 "singledecodebin.vala"
+	g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
+#line 366 "singledecodebin.vala"
+	g_return_if_fail (GST_IS_ELEMENT (element));
+#line 367 "singledecodebin.vala"
+	logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicNoMorePadsCb");
+#line 1264 "singledecodebin.c"
+}
+
+
+static void single_decode_bin_base_init (SingleDecodeBinClass * klass) {
+	{
+		GstPadTemplate* sink_pad;
+		GstPadTemplate* src_pad;
+#line 52 "singledecodebin.vala"
+		sink_pad = gst_pad_template_new ("sinkpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ());
+#line 54 "singledecodebin.vala"
+		src_pad = gst_pad_template_new ("srcpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ());
+#line 57 "singledecodebin.vala"
+		gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), src_pad);
+#line 58 "singledecodebin.vala"
+		gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), sink_pad);
+#line 1280 "singledecodebin.c"
+		_gst_object_unref0 (sink_pad);
+		_gst_object_unref0 (src_pad);
+	}
+}
+
+
+static void single_decode_bin_class_init (SingleDecodeBinClass * klass) {
+	single_decode_bin_parent_class = g_type_class_peek_parent (klass);
+	g_type_class_add_private (klass, sizeof (SingleDecodeBinPrivate));
+	GST_ELEMENT_CLASS (klass)->change_state = single_decode_bin_real_change_state;
+	G_OBJECT_CLASS (klass)->finalize = single_decode_bin_finalize;
+}
+
+
+static void single_decode_bin_instance_init (SingleDecodeBin * self) {
+	self->priv = SINGLE_DECODE_BIN_GET_PRIVATE (self);
+	self->priv->dynamics = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
+	self->priv->validelements = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
+}
+
+
+static void single_decode_bin_finalize (GObject* obj) {
+	SingleDecodeBin * self;
+	self = SINGLE_DECODE_BIN (obj);
+	_gst_caps_unref0 (self->priv->caps);
+	_gst_object_unref0 (self->priv->typefind);
+	_gst_object_unref0 (self->priv->srcpad);
+	_g_object_unref0 (self->priv->dynamics);
+	_g_object_unref0 (self->priv->validelements);
+	self->priv->factories = (_vala_array_free (self->priv->factories, self->priv->factories_length1, (GDestroyNotify) gst_object_unref), NULL);
+	G_OBJECT_CLASS (single_decode_bin_parent_class)->finalize (obj);
+}
+
+
+GType single_decode_bin_get_type (void) {
+	static volatile gsize single_decode_bin_type_id__volatile = 0;
+	if (g_once_init_enter (&single_decode_bin_type_id__volatile)) {
+		static const GTypeInfo g_define_type_info = { sizeof (SingleDecodeBinClass), (GBaseInitFunc) single_decode_bin_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) single_decode_bin_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SingleDecodeBin), 0, (GInstanceInitFunc) single_decode_bin_instance_init, NULL };
+		GType single_decode_bin_type_id;
+		single_decode_bin_type_id = g_type_register_static (GST_TYPE_BIN, "SingleDecodeBin", &g_define_type_info, 0);
+		g_once_init_leave (&single_decode_bin_type_id__volatile, single_decode_bin_type_id);
+	}
+	return single_decode_bin_type_id__volatile;
+}
+
+
+static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
+	if ((array != NULL) && (destroy_func != NULL)) {
+		int i;
+		for (i = 0; i < array_length; i = i + 1) {
+			if (((gpointer*) array)[i] != NULL) {
+				destroy_func (((gpointer*) array)[i]);
+			}
+		}
+	}
+}
+
+
+static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
+	_vala_array_destroy (array, array_length, destroy_func);
+	g_free (array);
+}
+
+
+
+