git.maemo.org Git - fillmore/blob - src/marina/marina/singledecodebin.c

   1 /* singledecodebin.c generated by valac, the Vala compiler
   2  * generated from singledecodebin.vala, do not modify */
   3
   4 /* Ported to Vala from singledecodebin.py in Pitivi:
   5  *
   6  * Copyright (c) 2005, Edward Hervey <bilboed@bilboed.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this program; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <glib.h>
  25 #include <glib-object.h>
  26 #include <gst/gst.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <gee.h>
  30
  31 #define _g_free0(var) (var = (g_free (var), NULL))
  32
  33 #define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ())
  34 #define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin))
  35 #define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
  36 #define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN))
  37 #define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN))
  38 #define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
  39
  40 typedef struct _SingleDecodeBin SingleDecodeBin;
  41 typedef struct _SingleDecodeBinClass SingleDecodeBinClass;
  42 typedef struct _SingleDecodeBinPrivate SingleDecodeBinPrivate;
  43 #define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
  44 #define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
  45 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  46 #define __g_list_free_gst_object_unref0(var) ((var == NULL) ? NULL : (var = (_g_list_free_gst_object_unref (var), NULL)))
  47
  48 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
  49
  50 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
  51
  52 struct _SingleDecodeBin {
  53         GstBin parent_instance;
  54         SingleDecodeBinPrivate * priv;
  55 };
  56
  57 struct _SingleDecodeBinClass {
  58         GstBinClass parent_class;
  59 };
  60
  61 struct _SingleDecodeBinPrivate {
  62         GstCaps* caps;
  63         GstElement* typefind;
  64         GstGhostPad* srcpad;
  65         GeeArrayList* dynamics;
  66         GeeArrayList* validelements;
  67         GstElementFactory** factories;
  68         gint factories_length1;
  69         gint _factories_size_;
  70 };
  71
  72 typedef enum  {
  73         LOGGING_FACILITY_SIGNAL_HANDLERS,
  74         LOGGING_FACILITY_DEVELOPER_WARNINGS,
  75         LOGGING_FACILITY_GRAPH,
  76         LOGGING_FACILITY_LOADING,
  77         LOGGING_FACILITY_IMPORT,
  78         LOGGING_FACILITY_SINGLEDECODEBIN
  79 } LoggingFacility;
  80
  81 typedef enum  {
  82         LOGGING_LEVEL_CRITICAL,
  83         LOGGING_LEVEL_HIGH,
  84         LOGGING_LEVEL_MEDIUM,
  85         LOGGING_LEVEL_LOW,
  86         LOGGING_LEVEL_INFO,
  87         LOGGING_LEVEL_VERBOSE
  88 } LoggingLevel;
  89
  90
  91 static gpointer single_decode_bin_parent_class = NULL;
  92
  93 void qsort (void* p, gsize num, gsize size, GCompareFunc func);
  94 gboolean is_raw (GstCaps* caps);
  95 GType single_decode_bin_get_type (void);
  96 #define SINGLE_DECODE_BIN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinPrivate))
  97 enum  {
  98         SINGLE_DECODE_BIN_DUMMY_PROPERTY
  99 };
 100 #define SINGLE_DECODE_BIN_QUEUE_SIZE ((gint64) (1 * GST_SECOND))
 101 GstElement* make_element (const char* name, GError** error);
 102 static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data);
 103 static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1);
 104 SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error);
 105 SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error);
 106 static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad);
 107 static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
 108 static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element);
 109 static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self);
 110 static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element);
 111 static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b);
 112 static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value);
 113 static void _g_list_free_gst_object_unref (GList* self);
 114 static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps);
 115 static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value);
 116 static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value);
 117 GType logging_facility_get_type (void);
 118 GType logging_level_get_type (void);
 119 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 120 static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps);
 121 static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element);
 122 static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element);
 123 static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad);
 124 static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories);
 125 static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad);
 126 static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element);
 127 static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element);
 128 static void single_decode_bin_cleanUp (SingleDecodeBin* self);
 129 static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition);
 130 static void single_decode_bin_finalize (GObject* obj);
 131 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 132 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 133
 134
 135
 136 #line 29 "singledecodebin.vala"
 137 gboolean is_raw (GstCaps* caps) {
 138 #line 139 "singledecodebin.c"
 139         gboolean result = FALSE;
 140         char* rep;
 141         char** _tmp1_;
 142         gint _valid_size_;
 143         gint valid_length1;
 144         char** _tmp0_ = NULL;
 145         char** valid;
 146 #line 29 "singledecodebin.vala"
 147         g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 148 #line 30 "singledecodebin.vala"
 149         rep = gst_caps_to_string (caps);
 150 #line 151 "singledecodebin.c"
 151         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_);
 152         {
 153                 char** val_collection;
 154                 int val_collection_length1;
 155                 int val_it;
 156 #line 32 "singledecodebin.vala"
 157                 val_collection = valid;
 158 #line 159 "singledecodebin.c"
 159                 val_collection_length1 = valid_length1;
 160                 for (val_it = 0; val_it < valid_length1; val_it = val_it + 1) {
 161                         char* val;
 162                         val = g_strdup (val_collection[val_it]);
 163                         {
 164 #line 33 "singledecodebin.vala"
 165                                 if (g_str_has_prefix (rep, val)) {
 166 #line 167 "singledecodebin.c"
 167                                         result = TRUE;
 168                                         _g_free0 (val);
 169                                         _g_free0 (rep);
 170                                         valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
 171 #line 34 "singledecodebin.vala"
 172                                         return result;
 173 #line 174 "singledecodebin.c"
 174                                 }
 175                                 _g_free0 (val);
 176                         }
 177                 }
 178         }
 179         result = FALSE;
 180         _g_free0 (rep);
 181         valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
 182 #line 35 "singledecodebin.vala"
 183         return result;
 184 #line 185 "singledecodebin.c"
 185 }
 186
 187
 188 static gpointer _gst_caps_ref0 (gpointer self) {
 189         return self ? gst_caps_ref (self) : NULL;
 190 }
 191
 192
 193 static gpointer _gst_object_ref0 (gpointer self) {
 194         return self ? gst_object_ref (self) : NULL;
 195 }
 196
 197
 198 #line 61 "singledecodebin.vala"
 199 SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error) {
 200 #line 201 "singledecodebin.c"
 201         GError * _inner_error_;
 202         SingleDecodeBin * self;
 203         GstCaps* _tmp0_;
 204         GstCaps* _tmp3_;
 205         GstElement* _tmp4_;
 206         GstElementFactory** _tmp8_;
 207         gint _tmp7_;
 208 #line 61 "singledecodebin.vala"
 209         g_return_val_if_fail ((caps == NULL) || GST_IS_CAPS (caps), NULL);
 210 #line 61 "singledecodebin.vala"
 211         g_return_val_if_fail (name != NULL, NULL);
 212 #line 213 "singledecodebin.c"
 213         _inner_error_ = NULL;
 214         self = g_object_newv (object_type, 0, NULL);
 215         _tmp0_ = NULL;
 216 #line 62 "singledecodebin.vala"
 217         if (caps == NULL) {
 218 #line 219 "singledecodebin.c"
 219                 GstCaps* _tmp1_;
 220 #line 62 "singledecodebin.vala"
 221                 _tmp0_ = (_tmp1_ = gst_caps_new_any (), _gst_caps_unref0 (_tmp0_), _tmp1_);
 222 #line 223 "singledecodebin.c"
 223         } else {
 224                 GstCaps* _tmp2_;
 225 #line 62 "singledecodebin.vala"
 226                 _tmp0_ = (_tmp2_ = _gst_caps_ref0 (caps), _gst_caps_unref0 (_tmp0_), _tmp2_);
 227 #line 228 "singledecodebin.c"
 228         }
 229 #line 62 "singledecodebin.vala"
 230         self->priv->caps = (_tmp3_ = _gst_caps_ref0 (_tmp0_), _gst_caps_unref0 (self->priv->caps), _tmp3_);
 231 #line 64 "singledecodebin.vala"
 232         self->priv->typefind = (_tmp4_ = gst_element_factory_make ("typefind", "internal-typefind"), _gst_object_unref0 (self->priv->typefind), _tmp4_);
 233 #line 65 "singledecodebin.vala"
 234         gst_bin_add (GST_BIN (self), _gst_object_ref0 (self->priv->typefind));
 235 #line 67 "singledecodebin.vala"
 236         if (uri != NULL) {
 237 #line 238 "singledecodebin.c"
 238                 GstElement* file_src;
 239 #line 68 "singledecodebin.vala"
 240                 file_src = make_element ("filesrc", &_inner_error_);
 241 #line 242 "singledecodebin.c"
 242                 if (_inner_error_ != NULL) {
 243                         g_propagate_error (error, _inner_error_);
 244                         _gst_caps_unref0 (_tmp0_);
 245                         gst_object_unref (self);
 246                         return NULL;
 247                 }
 248 #line 70 "singledecodebin.vala"
 249                 g_object_set (G_OBJECT (file_src), "location", uri, NULL);
 250 #line 71 "singledecodebin.vala"
 251                 gst_bin_add (GST_BIN (self), _gst_object_ref0 (file_src));
 252 #line 73 "singledecodebin.vala"
 253                 gst_element_link (file_src, self->priv->typefind);
 254 #line 255 "singledecodebin.c"
 255                 _gst_object_unref0 (file_src);
 256         } else {
 257                 GstPad* _tmp5_;
 258                 GstGhostPad* _tmp6_;
 259                 GstGhostPad* sinkpad;
 260 #line 75 "singledecodebin.vala"
 261                 sinkpad = (_tmp6_ = (GstGhostPad*) gst_ghost_pad_new ("sink", _tmp5_ = gst_element_get_pad (self->priv->typefind, "sink")), _gst_object_unref0 (_tmp5_), _tmp6_);
 262 #line 76 "singledecodebin.vala"
 263                 gst_pad_set_active (GST_PAD (sinkpad), TRUE);
 264 #line 77 "singledecodebin.vala"
 265                 gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (sinkpad)));
 266 #line 267 "singledecodebin.c"
 267                 _gst_object_unref0 (sinkpad);
 268         }
 269 #line 79 "singledecodebin.vala"
 270         g_signal_connect (self->priv->typefind, "have-type", (GCallback) single_decode_bin_typefindHaveTypeCb, self);
 271 #line 81 "singledecodebin.vala"
 272         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_);
 273 #line 274 "singledecodebin.c"
 274         _gst_caps_unref0 (_tmp0_);
 275         return self;
 276 }
 277
 278
 279 #line 61 "singledecodebin.vala"
 280 SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error) {
 281 #line 61 "singledecodebin.vala"
 282         return single_decode_bin_construct (TYPE_SINGLE_DECODE_BIN, caps, name, uri, error);
 283 #line 284 "singledecodebin.c"
 284 }
 285
 286
 287 #line 360 "singledecodebin.vala"
 288 static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
 289 #line 290 "singledecodebin.c"
 290         single_decode_bin_dynamicPadAddedCb (self, _sender, pad);
 291 }
 292
 293
 294 #line 366 "singledecodebin.vala"
 295 static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self) {
 296 #line 297 "singledecodebin.c"
 297         single_decode_bin_dynamicNoMorePadsCb (self, _sender);
 298 }
 299
 300
 301 #line 86 "singledecodebin.vala"
 302 static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element) {
 303 #line 86 "singledecodebin.vala"
 304         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
 305 #line 86 "singledecodebin.vala"
 306         g_return_if_fail (GST_IS_ELEMENT (element));
 307 #line 87 "singledecodebin.vala"
 308         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->dynamics), element);
 309 #line 88 "singledecodebin.vala"
 310         g_signal_connect_object (element, "pad-added", (GCallback) _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added, self, 0);
 311 #line 89 "singledecodebin.vala"
 312         g_signal_connect_object (element, "no-more-pads", (GCallback) _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads, self, 0);
 313 #line 314 "singledecodebin.c"
 314 }
 315
 316
 317 #line 92 "singledecodebin.vala"
 318 static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b) {
 319 #line 320 "singledecodebin.c"
 320         gint result = 0;
 321         GstPluginFeature* p1;
 322         GstPluginFeature* p2;
 323 #line 93 "singledecodebin.vala"
 324         p1 = *((GstPluginFeature**) a);
 325 #line 94 "singledecodebin.vala"
 326         p2 = *((GstPluginFeature**) b);
 327 #line 328 "singledecodebin.c"
 328         result = (gint) (gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p2)) - gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p1)));
 329 #line 95 "singledecodebin.vala"
 330         return result;
 331 #line 332 "singledecodebin.c"
 332 }
 333
 334
 335 #line 1144 "glib-2.0.vapi"
 336 static gboolean string_contains (const char* self, const char* needle) {
 337 #line 338 "singledecodebin.c"
 338         gboolean result = FALSE;
 339 #line 1144 "glib-2.0.vapi"
 340         g_return_val_if_fail (self != NULL, FALSE);
 341 #line 1144 "glib-2.0.vapi"
 342         g_return_val_if_fail (needle != NULL, FALSE);
 343 #line 344 "singledecodebin.c"
 344         result = strstr (self, needle) != NULL;
 345 #line 1145 "glib-2.0.vapi"
 346         return result;
 347 #line 348 "singledecodebin.c"
 348 }
 349
 350
 351 static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value) {
 352         if ((*length) == (*size)) {
 353                 *size = (*size) ? (2 * (*size)) : 4;
 354                 *array = g_renew (GstElementFactory*, *array, (*size) + 1);
 355         }
 356         (*array)[(*length)++] = value;
 357         (*array)[*length] = NULL;
 358 }
 359
 360
 361 static void _g_list_free_gst_object_unref (GList* self) {
 362         g_list_foreach (self, (GFunc) gst_object_unref, NULL);
 363         g_list_free (self);
 364 }
 365
 366
 367 #line 99 "singledecodebin.vala"
 368 static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1) {
 369 #line 370 "singledecodebin.c"
 370         GstElementFactory** result = NULL;
 371         GstRegistry* registry;
 372         GstElementFactory** _tmp0_;
 373         gint _factories_size_;
 374         gint factories_length1;
 375         GstElementFactory** factories;
 376         GstElementFactory** _tmp5_;
 377 #line 99 "singledecodebin.vala"
 378         g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
 379 #line 100 "singledecodebin.vala"
 380         registry = _gst_object_ref0 (gst_registry_get_default ());
 381 #line 382 "singledecodebin.c"
 382         factories = (_tmp0_ = g_new0 (GstElementFactory*, 0 + 1), factories_length1 = 0, _factories_size_ = factories_length1, _tmp0_);
 383         {
 384                 GList* plugin_feature_collection;
 385                 GList* plugin_feature_it;
 386 #line 103 "singledecodebin.vala"
 387                 plugin_feature_collection = gst_registry_get_feature_list (registry, GST_TYPE_ELEMENT_FACTORY);
 388 #line 389 "singledecodebin.c"
 389                 for (plugin_feature_it = plugin_feature_collection; plugin_feature_it != NULL; plugin_feature_it = plugin_feature_it->next) {
 390                         GstPluginFeature* plugin_feature;
 391 #line 103 "singledecodebin.vala"
 392                         plugin_feature = _gst_object_ref0 ((GstPluginFeature*) plugin_feature_it->data);
 393 #line 394 "singledecodebin.c"
 394                         {
 395                                 GstPluginFeature* _tmp1_;
 396                                 GstElementFactory* factory;
 397                                 gboolean _tmp2_ = FALSE;
 398                                 char* klass;
 399                                 gboolean _tmp3_ = FALSE;
 400                                 gboolean _tmp4_ = FALSE;
 401 #line 106 "singledecodebin.vala"
 402                                 factory = _gst_object_ref0 ((_tmp1_ = plugin_feature, GST_IS_ELEMENT_FACTORY (_tmp1_) ? ((GstElementFactory*) _tmp1_) : NULL));
 403 #line 107 "singledecodebin.vala"
 404                                 if (factory == NULL) {
 405 #line 107 "singledecodebin.vala"
 406                                         _tmp2_ = TRUE;
 407 #line 408 "singledecodebin.c"
 408                                 } else {
 409 #line 107 "singledecodebin.vala"
 410                                         _tmp2_ = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) < 64;
 411 #line 412 "singledecodebin.c"
 412                                 }
 413 #line 107 "singledecodebin.vala"
 414                                 if (_tmp2_) {
 415 #line 416 "singledecodebin.c"
 416                                         _gst_object_unref0 (plugin_feature);
 417                                         _gst_object_unref0 (factory);
 418 #line 108 "singledecodebin.vala"
 419                                         continue;
 420 #line 421 "singledecodebin.c"
 421                                 }
 422 #line 109 "singledecodebin.vala"
 423                                 klass = g_strdup (gst_element_factory_get_klass (factory));
 424 #line 110 "singledecodebin.vala"
 425                                 if (string_contains (klass, "Demuxer")) {
 426 #line 110 "singledecodebin.vala"
 427                                         _tmp4_ = TRUE;
 428 #line 429 "singledecodebin.c"
 429                                 } else {
 430 #line 110 "singledecodebin.vala"
 431                                         _tmp4_ = string_contains (klass, "Decoder");
 432 #line 433 "singledecodebin.c"
 433                                 }
 434 #line 110 "singledecodebin.vala"
 435                                 if (_tmp4_) {
 436 #line 110 "singledecodebin.vala"
 437                                         _tmp3_ = TRUE;
 438 #line 439 "singledecodebin.c"
 439                                 } else {
 440 #line 110 "singledecodebin.vala"
 441                                         _tmp3_ = string_contains (klass, "Parse");
 442 #line 443 "singledecodebin.c"
 443                                 }
 444 #line 110 "singledecodebin.vala"
 445                                 if (_tmp3_) {
 446 #line 111 "singledecodebin.vala"
 447                                         _vala_array_add2 (&factories, &factories_length1, &_factories_size_, _gst_object_ref0 (factory));
 448 #line 449 "singledecodebin.c"
 449                                 }
 450                                 _gst_object_unref0 (plugin_feature);
 451                                 _gst_object_unref0 (factory);
 452                                 _g_free0 (klass);
 453                         }
 454                 }
 455 #line 103 "singledecodebin.vala"
 456                 __g_list_free_gst_object_unref0 (plugin_feature_collection);
 457 #line 458 "singledecodebin.c"
 458         }
 459 #line 114 "singledecodebin.vala"
 460         qsort (factories, (gsize) factories_length1, (gsize) sizeof (GstElementFactory*), (GCompareFunc) single_decode_bin_factory_compare);
 461 #line 462 "singledecodebin.c"
 462         result = (_tmp5_ = factories, *result_length1 = factories_length1, _tmp5_);
 463         _gst_object_unref0 (registry);
 464 #line 116 "singledecodebin.vala"
 465         return result;
 466 #line 467 "singledecodebin.c"
 467         _gst_object_unref0 (registry);
 468         factories = (_vala_array_free (factories, factories_length1, (GDestroyNotify) gst_object_unref), NULL);
 469 }
 470
 471
 472 #line 121 "singledecodebin.vala"
 473 static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps) {
 474 #line 475 "singledecodebin.c"
 475         GeeArrayList* result = NULL;
 476         GeeArrayList* res;
 477 #line 121 "singledecodebin.vala"
 478         g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
 479 #line 121 "singledecodebin.vala"
 480         g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 481 #line 122 "singledecodebin.vala"
 482         res = gee_array_list_new (GST_TYPE_ELEMENT_FACTORY, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
 483 #line 484 "singledecodebin.c"
 484         {
 485                 GstElementFactory** factory_collection;
 486                 int factory_collection_length1;
 487                 int factory_it;
 488 #line 124 "singledecodebin.vala"
 489                 factory_collection = self->priv->factories;
 490 #line 491 "singledecodebin.c"
 491                 factory_collection_length1 = self->priv->factories_length1;
 492                 for (factory_it = 0; factory_it < self->priv->factories_length1; factory_it = factory_it + 1) {
 493                         GstElementFactory* factory;
 494                         factory = _gst_object_ref0 (factory_collection[factory_it]);
 495                         {
 496                                 GList* templates;
 497 #line 125 "singledecodebin.vala"
 498                                 templates = gst_element_factory_get_static_pad_templates (factory);
 499 #line 500 "singledecodebin.c"
 500                                 {
 501                                         GList* template_collection;
 502                                         GList* template_it;
 503 #line 126 "singledecodebin.vala"
 504                                         template_collection = templates;
 505 #line 506 "singledecodebin.c"
 506                                         for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
 507                                                 GstStaticPadTemplate template;
 508 #line 126 "singledecodebin.vala"
 509                                                 template = *((GstStaticPadTemplate*) template_it->data);
 510 #line 511 "singledecodebin.c"
 511                                                 {
 512 #line 127 "singledecodebin.vala"
 513                                                         if (template.direction == GST_PAD_SINK) {
 514 #line 515 "singledecodebin.c"
 515                                                                 GstCaps* _tmp0_;
 516                                                                 GstCaps* _tmp1_;
 517                                                                 GstCaps* intersect;
 518 #line 128 "singledecodebin.vala"
 519                                                                 intersect = (_tmp1_ = gst_caps_intersect (caps, _tmp0_ = gst_static_caps_get (&template.static_caps)), _gst_caps_unref0 (_tmp0_), _tmp1_);
 520 #line 129 "singledecodebin.vala"
 521                                                                 if (!gst_caps_is_empty (intersect)) {
 522 #line 130 "singledecodebin.vala"
 523                                                                         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (res), factory);
 524 #line 525 "singledecodebin.c"
 525                                                                         _gst_caps_unref0 (intersect);
 526 #line 131 "singledecodebin.vala"
 527                                                                         break;
 528 #line 529 "singledecodebin.c"
 529                                                                 }
 530                                                                 _gst_caps_unref0 (intersect);
 531                                                         }
 532                                                 }
 533                                         }
 534                                 }
 535                                 _gst_object_unref0 (factory);
 536                         }
 537                 }
 538         }
 539         result = res;
 540 #line 136 "singledecodebin.vala"
 541         return result;
 542 #line 543 "singledecodebin.c"
 543 }
 544
 545
 546 static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value) {
 547         if ((*length) == (*size)) {
 548                 *size = (*size) ? (2 * (*size)) : 4;
 549                 *array = g_renew (GstPad*, *array, (*size) + 1);
 550         }
 551         (*array)[(*length)++] = value;
 552         (*array)[*length] = NULL;
 553 }
 554
 555
 556 static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value) {
 557         if ((*length) == (*size)) {
 558                 *size = (*size) ? (2 * (*size)) : 4;
 559                 *array = g_renew (GstPad*, *array, (*size) + 1);
 560         }
 561         (*array)[(*length)++] = value;
 562         (*array)[*length] = NULL;
 563 }
 564
 565
 566 #line 142 "singledecodebin.vala"
 567 static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element) {
 568 #line 569 "singledecodebin.c"
 569         GstPad** _tmp0_;
 570         gint _to_connect_size_;
 571         gint to_connect_length1;
 572         GstPad** to_connect;
 573         gboolean is_dynamic;
 574 #line 142 "singledecodebin.vala"
 575         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
 576 #line 142 "singledecodebin.vala"
 577         g_return_if_fail (GST_IS_ELEMENT (element));
 578 #line 579 "singledecodebin.c"
 579         to_connect = (_tmp0_ = g_new0 (GstPad*, 0 + 1), to_connect_length1 = 0, _to_connect_size_ = to_connect_length1, _tmp0_);
 580 #line 144 "singledecodebin.vala"
 581         is_dynamic = FALSE;
 582 #line 583 "singledecodebin.c"
 583         {
 584                 GList* template_collection;
 585                 GList* template_it;
 586 #line 146 "singledecodebin.vala"
 587                 template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)));
 588 #line 589 "singledecodebin.c"
 589                 for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
 590                         GstPadTemplate* template;
 591 #line 146 "singledecodebin.vala"
 592                         template = _gst_object_ref0 ((GstPadTemplate*) template_it->data);
 593 #line 594 "singledecodebin.c"
 594                         {
 595                                 GstPadDirection _tmp1_;
 596                                 GstPadPresence _tmp2_;
 597 #line 147 "singledecodebin.vala"
 598                                 if ((g_object_get (template, "direction", &_tmp1_, NULL), _tmp1_) != GST_PAD_SRC) {
 599 #line 600 "singledecodebin.c"
 600                                         _gst_object_unref0 (template);
 601 #line 148 "singledecodebin.vala"
 602                                         continue;
 603 #line 604 "singledecodebin.c"
 604                                 }
 605 #line 149 "singledecodebin.vala"
 606                                 if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_ALWAYS) {
 607 #line 608 "singledecodebin.c"
 608                                         char* _tmp4_;
 609                                         char* _tmp3_ = NULL;
 610                                         GstPad* _tmp5_;
 611                                         GstPad* pad;
 612 #line 150 "singledecodebin.vala"
 613                                         pad = (_tmp5_ = gst_element_get_pad (element, _tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_)), _g_free0 (_tmp4_), _tmp5_);
 614 #line 151 "singledecodebin.vala"
 615                                         _vala_array_add3 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad));
 616 #line 617 "singledecodebin.c"
 617                                         _gst_object_unref0 (pad);
 618                                 } else {
 619                                         GstPadPresence _tmp6_;
 620 #line 152 "singledecodebin.vala"
 621                                         if ((g_object_get (template, "presence", &_tmp6_, NULL), _tmp6_) == GST_PAD_SOMETIMES) {
 622 #line 623 "singledecodebin.c"
 623                                                 char* _tmp8_;
 624                                                 char* _tmp7_ = NULL;
 625                                                 GstPad* _tmp9_;
 626                                                 GstPad* pad;
 627 #line 153 "singledecodebin.vala"
 628                                                 pad = (_tmp9_ = gst_element_get_pad (element, _tmp8_ = (g_object_get (template, "name-template", &_tmp7_, NULL), _tmp7_)), _g_free0 (_tmp8_), _tmp9_);
 629 #line 154 "singledecodebin.vala"
 630                                                 if (pad != NULL) {
 631 #line 155 "singledecodebin.vala"
 632                                                         _vala_array_add4 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad));
 633 #line 634 "singledecodebin.c"
 634                                                 } else {
 635 #line 156 "singledecodebin.vala"
 636                                                         is_dynamic = TRUE;
 637 #line 638 "singledecodebin.c"
 638                                                 }
 639                                                 _gst_object_unref0 (pad);
 640                                         }
 641                                 }
 642                                 _gst_object_unref0 (template);
 643                         }
 644                 }
 645         }
 646 #line 160 "singledecodebin.vala"
 647         if (is_dynamic) {
 648 #line 649 "singledecodebin.c"
 649                 char* _tmp11_;
 650                 char* _tmp10_;
 651 #line 161 "singledecodebin.vala"
 652                 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))));
 653 #line 654 "singledecodebin.c"
 654                 _g_free0 (_tmp11_);
 655                 _g_free0 (_tmp10_);
 656 #line 163 "singledecodebin.vala"
 657                 single_decode_bin_controlDynamicElement (self, element);
 658 #line 659 "singledecodebin.c"
 659         }
 660         {
 661                 GstPad** pad_collection;
 662                 int pad_collection_length1;
 663                 int pad_it;
 664 #line 166 "singledecodebin.vala"
 665                 pad_collection = to_connect;
 666 #line 667 "singledecodebin.c"
 667                 pad_collection_length1 = to_connect_length1;
 668                 for (pad_it = 0; pad_it < to_connect_length1; pad_it = pad_it + 1) {
 669                         GstPad* pad;
 670                         pad = _gst_object_ref0 (pad_collection[pad_it]);
 671                         {
 672                                 GstCaps* _tmp12_;
 673 #line 167 "singledecodebin.vala"
 674                                 single_decode_bin_closePadLink (self, element, pad, _tmp12_ = gst_pad_get_caps (pad));
 675 #line 676 "singledecodebin.c"
 676                                 _gst_caps_unref0 (_tmp12_);
 677                                 _gst_object_unref0 (pad);
 678                         }
 679                 }
 680         }
 681         to_connect = (_vala_array_free (to_connect, to_connect_length1, (GDestroyNotify) gst_object_unref), NULL);
 682 }
 683
 684
 685 #line 170 "singledecodebin.vala"
 686 static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element) {
 687 #line 688 "singledecodebin.c"
 688         gboolean result = FALSE;
 689         gint potential_src_pads;
 690 #line 170 "singledecodebin.vala"
 691         g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), FALSE);
 692 #line 170 "singledecodebin.vala"
 693         g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
 694 #line 171 "singledecodebin.vala"
 695         if (!string_contains (gst_element_factory_get_klass (gst_element_get_factory (element)), "Demux")) {
 696 #line 697 "singledecodebin.c"
 697                 result = FALSE;
 698 #line 172 "singledecodebin.vala"
 699                 return result;
 700 #line 701 "singledecodebin.c"
 701         }
 702 #line 174 "singledecodebin.vala"
 703         potential_src_pads = 0;
 704 #line 705 "singledecodebin.c"
 705         {
 706                 GList* template_collection;
 707                 GList* template_it;
 708 #line 175 "singledecodebin.vala"
 709                 template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)));
 710 #line 711 "singledecodebin.c"
 711                 for (template_it = template_collection; template_it != NULL; template_it = template_it->next) {
 712                         GstPadTemplate* template;
 713 #line 175 "singledecodebin.vala"
 714                         template = _gst_object_ref0 ((GstPadTemplate*) template_it->data);
 715 #line 716 "singledecodebin.c"
 716                         {
 717                                 GstPadDirection _tmp0_;
 718                                 gboolean _tmp1_ = FALSE;
 719                                 GstPadPresence _tmp2_;
 720 #line 176 "singledecodebin.vala"
 721                                 if ((g_object_get (template, "direction", &_tmp0_, NULL), _tmp0_) != GST_PAD_SRC) {
 722 #line 723 "singledecodebin.c"
 723                                         _gst_object_unref0 (template);
 724 #line 177 "singledecodebin.vala"
 725                                         continue;
 726 #line 727 "singledecodebin.c"
 727                                 }
 728 #line 179 "singledecodebin.vala"
 729                                 if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_REQUEST) {
 730 #line 179 "singledecodebin.vala"
 731                                         _tmp1_ = TRUE;
 732 #line 733 "singledecodebin.c"
 733                                 } else {
 734                                         char* _tmp4_;
 735                                         char* _tmp3_ = NULL;
 736 #line 180 "singledecodebin.vala"
 737                                         _tmp1_ = string_contains (_tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_), "%");
 738 #line 739 "singledecodebin.c"
 739                                         _g_free0 (_tmp4_);
 740                                 }
 741 #line 179 "singledecodebin.vala"
 742                                 if (_tmp1_) {
 743 #line 181 "singledecodebin.vala"
 744                                         potential_src_pads = potential_src_pads + 2;
 745 #line 746 "singledecodebin.c"
 746                                         _gst_object_unref0 (template);
 747 #line 182 "singledecodebin.vala"
 748                                         break;
 749 #line 750 "singledecodebin.c"
 750                                 } else {
 751 #line 183 "singledecodebin.vala"
 752                                         potential_src_pads = potential_src_pads + 1;
 753 #line 754 "singledecodebin.c"
 754                                 }
 755                                 _gst_object_unref0 (template);
 756                         }
 757                 }
 758         }
 759         result = potential_src_pads > 1;
 760 #line 186 "singledecodebin.vala"
 761         return result;
 762 #line 763 "singledecodebin.c"
 763 }
 764
 765
 766 #line 189 "singledecodebin.vala"
 767 static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad) {
 768 #line 769 "singledecodebin.c"
 769         GstPad* result = NULL;
 770         GstElement* queue;
 771         GValue _tmp1_;
 772         GValue _tmp0_ = {0};
 773         GstPad* _tmp2_;
 774 #line 189 "singledecodebin.vala"
 775         g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
 776 #line 189 "singledecodebin.vala"
 777         g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 778 #line 190 "singledecodebin.vala"
 779         queue = gst_element_factory_make ("queue", NULL);
 780 #line 191 "singledecodebin.vala"
 781         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_));
 782 #line 192 "singledecodebin.vala"
 783         gst_bin_add (GST_BIN (self), _gst_object_ref0 (queue));
 784 #line 193 "singledecodebin.vala"
 785         gst_element_sync_state_with_parent (queue);
 786 #line 194 "singledecodebin.vala"
 787         gst_pad_link (pad, _tmp2_ = gst_element_get_pad (queue, "sink"));
 788 #line 789 "singledecodebin.c"
 789         _gst_object_unref0 (_tmp2_);
 790         result = gst_element_get_pad (queue, "src");
 791         _gst_object_unref0 (queue);
 792 #line 195 "singledecodebin.vala"
 793         return result;
 794 #line 795 "singledecodebin.c"
 795 }
 796
 797
 798 #line 200 "singledecodebin.vala"
 799 static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories) {
 800 #line 801 "singledecodebin.c"
 801         GstElement* result = NULL;
 802         GstPad* pad;
 803         GstElement* _result_;
 804 #line 200 "singledecodebin.vala"
 805         g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL);
 806 #line 200 "singledecodebin.vala"
 807         g_return_val_if_fail (GST_IS_ELEMENT (source), NULL);
 808 #line 200 "singledecodebin.vala"
 809         g_return_val_if_fail (GST_IS_PAD (in_pad), NULL);
 810 #line 200 "singledecodebin.vala"
 811         g_return_val_if_fail (GEE_IS_ARRAY_LIST (factories), NULL);
 812 #line 202 "singledecodebin.vala"
 813         pad = _gst_object_ref0 (in_pad);
 814 #line 203 "singledecodebin.vala"
 815         if (single_decode_bin_isDemuxer (self, source)) {
 816 #line 817 "singledecodebin.c"
 817                 GstPad* _tmp0_;
 818 #line 204 "singledecodebin.vala"
 819                 pad = (_tmp0_ = single_decode_bin_plugDecodingQueue (self, in_pad), _gst_object_unref0 (pad), _tmp0_);
 820 #line 821 "singledecodebin.c"
 821         }
 822 #line 206 "singledecodebin.vala"
 823         _result_ = NULL;
 824 #line 825 "singledecodebin.c"
 825         {
 826                 GeeIterator* _factory_it;
 827                 _factory_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (factories));
 828 #line 207 "singledecodebin.vala"
 829                 while (TRUE) {
 830 #line 831 "singledecodebin.c"
 831                         GstElementFactory* factory;
 832                         GstElement* element;
 833                         GstPad* sinkpad;
 834                         GstElement* _tmp1_;
 835 #line 207 "singledecodebin.vala"
 836                         if (!gee_iterator_next (_factory_it)) {
 837 #line 207 "singledecodebin.vala"
 838                                 break;
 839 #line 840 "singledecodebin.c"
 840                         }
 841 #line 207 "singledecodebin.vala"
 842                         factory = (GstElementFactory*) gee_iterator_get (_factory_it);
 843 #line 208 "singledecodebin.vala"
 844                         element = gst_element_factory_create (factory, NULL);
 845 #line 209 "singledecodebin.vala"
 846                         if (element == NULL) {
 847 #line 210 "singledecodebin.vala"
 848                                 g_warning ("singledecodebin.vala:210: couldn't create element from factory");
 849 #line 850 "singledecodebin.c"
 850                                 _gst_object_unref0 (factory);
 851                                 _gst_object_unref0 (element);
 852 #line 211 "singledecodebin.vala"
 853                                 continue;
 854 #line 855 "singledecodebin.c"
 855                         }
 856 #line 214 "singledecodebin.vala"
 857                         sinkpad = gst_element_get_pad (element, "sink");
 858 #line 215 "singledecodebin.vala"
 859                         if (sinkpad == NULL) {
 860 #line 861 "singledecodebin.c"
 861                                 _gst_object_unref0 (factory);
 862                                 _gst_object_unref0 (element);
 863                                 _gst_object_unref0 (sinkpad);
 864 #line 216 "singledecodebin.vala"
 865                                 continue;
 866 #line 867 "singledecodebin.c"
 867                         }
 868 #line 218 "singledecodebin.vala"
 869                         gst_bin_add (GST_BIN (self), _gst_object_ref0 (element));
 870 #line 219 "singledecodebin.vala"
 871                         gst_element_set_state (element, GST_STATE_READY);
 872 #line 220 "singledecodebin.vala"
 873                         if (gst_pad_link (pad, sinkpad) != GST_PAD_LINK_OK) {
 874 #line 221 "singledecodebin.vala"
 875                                 gst_element_set_state (element, GST_STATE_NULL);
 876 #line 222 "singledecodebin.vala"
 877                                 gst_bin_remove (GST_BIN (self), element);
 878 #line 879 "singledecodebin.c"
 879                                 _gst_object_unref0 (factory);
 880                                 _gst_object_unref0 (element);
 881                                 _gst_object_unref0 (sinkpad);
 882 #line 223 "singledecodebin.vala"
 883                                 continue;
 884 #line 885 "singledecodebin.c"
 885                         }
 886 #line 226 "singledecodebin.vala"
 887                         single_decode_bin_closeLink (self, element);
 888 #line 227 "singledecodebin.vala"
 889                         gst_element_set_state (element, GST_STATE_PAUSED);
 890 #line 229 "singledecodebin.vala"
 891                         _result_ = (_tmp1_ = _gst_object_ref0 (element), _gst_object_unref0 (_result_), _tmp1_);
 892 #line 893 "singledecodebin.c"
 893                         _gst_object_unref0 (factory);
 894                         _gst_object_unref0 (element);
 895                         _gst_object_unref0 (sinkpad);
 896 #line 230 "singledecodebin.vala"
 897                         break;
 898 #line 899 "singledecodebin.c"
 899                 }
 900                 _g_object_unref0 (_factory_it);
 901         }
 902         result = _result_;
 903         _gst_object_unref0 (pad);
 904 #line 233 "singledecodebin.vala"
 905         return result;
 906 #line 907 "singledecodebin.c"
 907 }
 908
 909
 910 #line 239 "singledecodebin.vala"
 911 static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps) {
 912 #line 913 "singledecodebin.c"
 913         char* _tmp3_;
 914         char* _tmp2_;
 915         char* _tmp1_;
 916         char* _tmp0_;
 917         GstCaps* _tmp4_;
 918         gboolean _tmp5_;
 919 #line 239 "singledecodebin.vala"
 920         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
 921 #line 239 "singledecodebin.vala"
 922         g_return_if_fail (GST_IS_ELEMENT (element));
 923 #line 239 "singledecodebin.vala"
 924         g_return_if_fail (GST_IS_PAD (pad));
 925 #line 239 "singledecodebin.vala"
 926         g_return_if_fail (GST_IS_CAPS (caps));
 927 #line 240 "singledecodebin.vala"
 928         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)));
 929 #line 930 "singledecodebin.c"
 930         _g_free0 (_tmp3_);
 931         _g_free0 (_tmp2_);
 932         _g_free0 (_tmp1_);
 933         _g_free0 (_tmp0_);
 934 #line 244 "singledecodebin.vala"
 935         if (gst_caps_is_empty (caps)) {
 936 #line 245 "singledecodebin.vala"
 937                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_INFO, "unknown type");
 938 #line 246 "singledecodebin.vala"
 939                 return;
 940 #line 941 "singledecodebin.c"
 941         }
 942 #line 248 "singledecodebin.vala"
 943         if (gst_caps_is_any (caps)) {
 944 #line 249 "singledecodebin.vala"
 945                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "type is not known yet, waiting");
 946 #line 250 "singledecodebin.vala"
 947                 return;
 948 #line 949 "singledecodebin.c"
 949         }
 950 #line 253 "singledecodebin.vala"
 951         gst_pad_get_direction (pad);
 952 #line 255 "singledecodebin.vala"
 953         if ((_tmp5_ = !gst_caps_is_empty (_tmp4_ = gst_caps_intersect (caps, self->priv->caps)), _gst_caps_unref0 (_tmp4_), _tmp5_)) {
 954 #line 257 "singledecodebin.vala"
 955                 if (self->priv->srcpad == NULL) {
 956 #line 258 "singledecodebin.vala"
 957                         single_decode_bin_wrapUp (self, element, pad);
 958 #line 959 "singledecodebin.c"
 959                 }
 960         } else {
 961 #line 259 "singledecodebin.vala"
 962                 if (is_raw (caps)) {
 963 #line 260 "singledecodebin.vala"
 964                         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "We hit a raw caps which isn't the wanted one");
 965 #line 966 "singledecodebin.c"
 966                 } else {
 967                         GeeArrayList* facts;
 968                         GstElement* _tmp6_;
 969 #line 265 "singledecodebin.vala"
 970                         if (gst_caps_get_size (caps) > 1) {
 971 #line 266 "singledecodebin.vala"
 972                                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "many possible types, delaying");
 973 #line 268 "singledecodebin.vala"
 974                                 return;
 975 #line 976 "singledecodebin.c"
 976                         }
 977 #line 270 "singledecodebin.vala"
 978                         facts = single_decode_bin_findCompatibleFactory (self, caps);
 979 #line 271 "singledecodebin.vala"
 980                         if (gee_collection_get_size (GEE_COLLECTION (facts)) == 0) {
 981 #line 272 "singledecodebin.vala"
 982                                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "unknown type");
 983 #line 984 "singledecodebin.c"
 984                                 _g_object_unref0 (facts);
 985 #line 274 "singledecodebin.vala"
 986                                 return;
 987 #line 988 "singledecodebin.c"
 988                         }
 989 #line 276 "singledecodebin.vala"
 990                         _tmp6_ = single_decode_bin_tryToLink1 (self, element, pad, facts);
 991 #line 992 "singledecodebin.c"
 992                         _gst_object_unref0 (_tmp6_);
 993                         _g_object_unref0 (facts);
 994                 }
 995         }
 996 }
 997
 998
 999 #line 282 "singledecodebin.vala"
1000 static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad) {
1001 #line 1002 "singledecodebin.c"
1002         char* _tmp1_;
1003         char* _tmp0_;
1004         GstGhostPad* _tmp2_;
1005 #line 282 "singledecodebin.vala"
1006         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1007 #line 282 "singledecodebin.vala"
1008         g_return_if_fail (GST_IS_ELEMENT (element));
1009 #line 282 "singledecodebin.vala"
1010         g_return_if_fail (GST_IS_PAD (pad));
1011 #line 283 "singledecodebin.vala"
1012         if (self->priv->srcpad != NULL) {
1013 #line 284 "singledecodebin.vala"
1014                 return;
1015 #line 1016 "singledecodebin.c"
1016         }
1017 #line 285 "singledecodebin.vala"
1018         single_decode_bin_markValidElements (self, element);
1019 #line 286 "singledecodebin.vala"
1020         single_decode_bin_removeUnusedElements (self, self->priv->typefind);
1021 #line 287 "singledecodebin.vala"
1022         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))));
1023 #line 1024 "singledecodebin.c"
1024         _g_free0 (_tmp1_);
1025         _g_free0 (_tmp0_);
1026 #line 289 "singledecodebin.vala"
1027         self->priv->srcpad = (_tmp2_ = (GstGhostPad*) gst_ghost_pad_new ("src", pad), _gst_object_unref0 (self->priv->srcpad), _tmp2_);
1028 #line 290 "singledecodebin.vala"
1029         if (gst_caps_is_fixed (self->priv->caps)) {
1030 #line 291 "singledecodebin.vala"
1031                 gst_pad_set_caps (GST_PAD (self->priv->srcpad), self->priv->caps);
1032 #line 1033 "singledecodebin.c"
1033         }
1034 #line 293 "singledecodebin.vala"
1035         gst_pad_set_active (GST_PAD (self->priv->srcpad), TRUE);
1036 #line 295 "singledecodebin.vala"
1037         gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (self->priv->srcpad)));
1038 #line 296 "singledecodebin.vala"
1039         gst_element_post_message (GST_ELEMENT (self), gst_message_new_state_dirty (GST_OBJECT (self)));
1040 #line 1041 "singledecodebin.c"
1041 }
1042
1043
1044 #line 300 "singledecodebin.vala"
1045 static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element) {
1046 #line 1047 "singledecodebin.c"
1047         char* _tmp1_;
1048         char* _tmp0_;
1049         GstPad* pad;
1050         GstPad* _tmp2_;
1051         GstElement* _tmp3_;
1052         GstElement* parent;
1053 #line 300 "singledecodebin.vala"
1054         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1055 #line 300 "singledecodebin.vala"
1056         g_return_if_fail (GST_IS_ELEMENT (element));
1057 #line 301 "singledecodebin.vala"
1058         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))));
1059 #line 1060 "singledecodebin.c"
1060         _g_free0 (_tmp1_);
1061         _g_free0 (_tmp0_);
1062 #line 303 "singledecodebin.vala"
1063         if (element == self->priv->typefind) {
1064 #line 304 "singledecodebin.vala"
1065                 return;
1066 #line 1067 "singledecodebin.c"
1067         }
1068 #line 305 "singledecodebin.vala"
1069         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->validelements), element);
1070 #line 308 "singledecodebin.vala"
1071         pad = _gst_object_ref0 (GST_PAD ((GstPad*) g_list_first (element->sinkpads)->data));
1072 #line 309 "singledecodebin.vala"
1073         parent = (_tmp3_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp2_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp2_), _tmp3_);
1074 #line 310 "singledecodebin.vala"
1075         single_decode_bin_markValidElements (self, parent);
1076 #line 1077 "singledecodebin.c"
1077         _gst_object_unref0 (pad);
1078         _gst_object_unref0 (parent);
1079 }
1080
1081
1082 #line 314 "singledecodebin.vala"
1083 static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element) {
1084 #line 314 "singledecodebin.vala"
1085         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1086 #line 314 "singledecodebin.vala"
1087         g_return_if_fail (GST_IS_ELEMENT (element));
1088 #line 1089 "singledecodebin.c"
1089         {
1090                 GList* pad_collection;
1091                 GList* pad_it;
1092 #line 315 "singledecodebin.vala"
1093                 pad_collection = element->srcpads;
1094 #line 1095 "singledecodebin.c"
1095                 for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) {
1096                         GstPad* pad;
1097 #line 315 "singledecodebin.vala"
1098                         pad = _gst_object_ref0 ((GstPad*) pad_it->data);
1099 #line 1100 "singledecodebin.c"
1100                         {
1101 #line 316 "singledecodebin.vala"
1102                                 if (gst_pad_is_linked (pad)) {
1103 #line 1104 "singledecodebin.c"
1104                                         GstPad* _tmp0_;
1105                                         GstElement* _tmp1_;
1106                                         GstElement* peer;
1107 #line 317 "singledecodebin.vala"
1108                                         peer = (_tmp1_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp0_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp0_), _tmp1_);
1109 #line 318 "singledecodebin.vala"
1110                                         single_decode_bin_removeUnusedElements (self, peer);
1111 #line 319 "singledecodebin.vala"
1112                                         if (!gee_abstract_collection_contains (GEE_ABSTRACT_COLLECTION (self->priv->validelements), peer)) {
1113 #line 1114 "singledecodebin.c"
1114                                                 char* _tmp3_;
1115                                                 char* _tmp2_;
1116                                                 GstPad* _tmp4_;
1117 #line 320 "singledecodebin.vala"
1118                                                 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))));
1119 #line 1120 "singledecodebin.c"
1120                                                 _g_free0 (_tmp3_);
1121                                                 _g_free0 (_tmp2_);
1122 #line 322 "singledecodebin.vala"
1123                                                 gst_pad_unlink (pad, _tmp4_ = gst_pad_get_peer (pad));
1124 #line 1125 "singledecodebin.c"
1125                                                 _gst_object_unref0 (_tmp4_);
1126 #line 323 "singledecodebin.vala"
1127                                                 gst_element_set_state (peer, GST_STATE_NULL);
1128 #line 324 "singledecodebin.vala"
1129                                                 gst_bin_remove (GST_BIN (self), peer);
1130 #line 1131 "singledecodebin.c"
1131                                         }
1132                                         _gst_object_unref0 (peer);
1133                                 }
1134                                 _gst_object_unref0 (pad);
1135                         }
1136                 }
1137         }
1138 }
1139
1140
1141 #line 329 "singledecodebin.vala"
1142 static void single_decode_bin_cleanUp (SingleDecodeBin* self) {
1143 #line 1144 "singledecodebin.c"
1144         GstGhostPad* _tmp0_;
1145         GeeArrayList* _tmp1_;
1146 #line 329 "singledecodebin.vala"
1147         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1148 #line 330 "singledecodebin.vala"
1149         if (self->priv->srcpad != NULL) {
1150 #line 331 "singledecodebin.vala"
1151                 gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (self->priv->srcpad));
1152 #line 1153 "singledecodebin.c"
1153         }
1154 #line 332 "singledecodebin.vala"
1155         self->priv->srcpad = (_tmp0_ = NULL, _gst_object_unref0 (self->priv->srcpad), _tmp0_);
1156 #line 1157 "singledecodebin.c"
1157         {
1158                 GeeIterator* _element_it;
1159                 _element_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->validelements));
1160 #line 333 "singledecodebin.vala"
1161                 while (TRUE) {
1162 #line 1163 "singledecodebin.c"
1163                         GstElement* element;
1164 #line 333 "singledecodebin.vala"
1165                         if (!gee_iterator_next (_element_it)) {
1166 #line 333 "singledecodebin.vala"
1167                                 break;
1168 #line 1169 "singledecodebin.c"
1169                         }
1170 #line 333 "singledecodebin.vala"
1171                         element = (GstElement*) gee_iterator_get (_element_it);
1172 #line 334 "singledecodebin.vala"
1173                         gst_element_set_state (element, GST_STATE_NULL);
1174 #line 335 "singledecodebin.vala"
1175                         gst_bin_remove (GST_BIN (self), element);
1176 #line 1177 "singledecodebin.c"
1177                         _gst_object_unref0 (element);
1178                 }
1179                 _g_object_unref0 (_element_it);
1180         }
1181 #line 337 "singledecodebin.vala"
1182         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_);
1183 #line 1184 "singledecodebin.c"
1184 }
1185
1186
1187 #line 342 "singledecodebin.vala"
1188 static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition) {
1189 #line 1190 "singledecodebin.c"
1190         SingleDecodeBin * self;
1191         GstStateChangeReturn result = 0;
1192         GstStateChangeReturn res;
1193         self = SINGLE_DECODE_BIN (base);
1194 #line 343 "singledecodebin.vala"
1195         res = GST_ELEMENT_CLASS (single_decode_bin_parent_class)->change_state (GST_ELEMENT (GST_BIN (self)), transition);
1196 #line 344 "singledecodebin.vala"
1197         if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) {
1198 #line 345 "singledecodebin.vala"
1199                 single_decode_bin_cleanUp (self);
1200 #line 1201 "singledecodebin.c"
1201         }
1202         result = res;
1203 #line 346 "singledecodebin.vala"
1204         return result;
1205 #line 1206 "singledecodebin.c"
1206 }
1207
1208
1209 #line 351 "singledecodebin.vala"
1210 static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data) {
1211 #line 1212 "singledecodebin.c"
1212         char* _tmp1_;
1213         char* _tmp0_;
1214         GstPad* _tmp2_;
1215 #line 351 "singledecodebin.vala"
1216         g_return_if_fail (GST_IS_ELEMENT (t));
1217 #line 351 "singledecodebin.vala"
1218         g_return_if_fail (GST_IS_CAPS (caps));
1219 #line 351 "singledecodebin.vala"
1220         g_return_if_fail (IS_SINGLE_DECODE_BIN (data));
1221 #line 353 "singledecodebin.vala"
1222         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)));
1223 #line 1224 "singledecodebin.c"
1224         _g_free0 (_tmp1_);
1225         _g_free0 (_tmp0_);
1226 #line 355 "singledecodebin.vala"
1227         single_decode_bin_closePadLink (data, t, _tmp2_ = gst_element_get_pad (t, "src"), caps);
1228 #line 1229 "singledecodebin.c"
1229         _gst_object_unref0 (_tmp2_);
1230 }
1231
1232
1233 #line 360 "singledecodebin.vala"
1234 static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad) {
1235 #line 360 "singledecodebin.vala"
1236         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1237 #line 360 "singledecodebin.vala"
1238         g_return_if_fail (GST_IS_ELEMENT (element));
1239 #line 360 "singledecodebin.vala"
1240         g_return_if_fail (GST_IS_PAD (pad));
1241 #line 361 "singledecodebin.vala"
1242         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicPadAddedCb");
1243 #line 362 "singledecodebin.vala"
1244         if (self->priv->srcpad == NULL) {
1245 #line 1246 "singledecodebin.c"
1246                 GstCaps* _tmp0_;
1247 #line 363 "singledecodebin.vala"
1248                 single_decode_bin_closePadLink (self, element, pad, _tmp0_ = gst_pad_get_caps (pad));
1249 #line 1250 "singledecodebin.c"
1250                 _gst_caps_unref0 (_tmp0_);
1251         }
1252 }
1253
1254
1255 #line 366 "singledecodebin.vala"
1256 static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element) {
1257 #line 366 "singledecodebin.vala"
1258         g_return_if_fail (IS_SINGLE_DECODE_BIN (self));
1259 #line 366 "singledecodebin.vala"
1260         g_return_if_fail (GST_IS_ELEMENT (element));
1261 #line 367 "singledecodebin.vala"
1262         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicNoMorePadsCb");
1263 #line 1264 "singledecodebin.c"
1264 }
1265
1266
1267 static void single_decode_bin_base_init (SingleDecodeBinClass * klass) {
1268         {
1269                 GstPadTemplate* sink_pad;
1270                 GstPadTemplate* src_pad;
1271 #line 52 "singledecodebin.vala"
1272                 sink_pad = gst_pad_template_new ("sinkpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ());
1273 #line 54 "singledecodebin.vala"
1274                 src_pad = gst_pad_template_new ("srcpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ());
1275 #line 57 "singledecodebin.vala"
1276                 gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), src_pad);
1277 #line 58 "singledecodebin.vala"
1278                 gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), sink_pad);
1279 #line 1280 "singledecodebin.c"
1280                 _gst_object_unref0 (sink_pad);
1281                 _gst_object_unref0 (src_pad);
1282         }
1283 }
1284
1285
1286 static void single_decode_bin_class_init (SingleDecodeBinClass * klass) {
1287         single_decode_bin_parent_class = g_type_class_peek_parent (klass);
1288         g_type_class_add_private (klass, sizeof (SingleDecodeBinPrivate));
1289         GST_ELEMENT_CLASS (klass)->change_state = single_decode_bin_real_change_state;
1290         G_OBJECT_CLASS (klass)->finalize = single_decode_bin_finalize;
1291 }
1292
1293
1294 static void single_decode_bin_instance_init (SingleDecodeBin * self) {
1295         self->priv = SINGLE_DECODE_BIN_GET_PRIVATE (self);
1296         self->priv->dynamics = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
1297         self->priv->validelements = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL);
1298 }
1299
1300
1301 static void single_decode_bin_finalize (GObject* obj) {
1302         SingleDecodeBin * self;
1303         self = SINGLE_DECODE_BIN (obj);
1304         _gst_caps_unref0 (self->priv->caps);
1305         _gst_object_unref0 (self->priv->typefind);
1306         _gst_object_unref0 (self->priv->srcpad);
1307         _g_object_unref0 (self->priv->dynamics);
1308         _g_object_unref0 (self->priv->validelements);
1309         self->priv->factories = (_vala_array_free (self->priv->factories, self->priv->factories_length1, (GDestroyNotify) gst_object_unref), NULL);
1310         G_OBJECT_CLASS (single_decode_bin_parent_class)->finalize (obj);
1311 }
1312
1313
1314 GType single_decode_bin_get_type (void) {
1315         static volatile gsize single_decode_bin_type_id__volatile = 0;
1316         if (g_once_init_enter (&single_decode_bin_type_id__volatile)) {
1317                 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 };
1318                 GType single_decode_bin_type_id;
1319                 single_decode_bin_type_id = g_type_register_static (GST_TYPE_BIN, "SingleDecodeBin", &g_define_type_info, 0);
1320                 g_once_init_leave (&single_decode_bin_type_id__volatile, single_decode_bin_type_id);
1321         }
1322         return single_decode_bin_type_id__volatile;
1323 }
1324
1325
1326 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1327         if ((array != NULL) && (destroy_func != NULL)) {
1328                 int i;
1329                 for (i = 0; i < array_length; i = i + 1) {
1330                         if (((gpointer*) array)[i] != NULL) {
1331                                 destroy_func (((gpointer*) array)[i]);
1332                         }
1333                 }
1334         }
1335 }
1336
1337
1338 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1339         _vala_array_destroy (array, array_length, destroy_func);
1340         g_free (array);
1341 }
1342
1343
1344
1345