1 /* singledecodebin.c generated by valac, the Vala compiler
2 * generated from singledecodebin.vala, do not modify */
4 /* Ported to Vala from singledecodebin.py in Pitivi:
6 * Copyright (c) 2005, Edward Hervey <bilboed@bilboed.com>
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.
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.
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.
25 #include <glib-object.h>
31 #define _g_free0(var) (var = (g_free (var), NULL))
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))
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)))
48 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
50 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
52 struct _SingleDecodeBin {
53 GstBin parent_instance;
54 SingleDecodeBinPrivate * priv;
57 struct _SingleDecodeBinClass {
58 GstBinClass parent_class;
61 struct _SingleDecodeBinPrivate {
65 GeeArrayList* dynamics;
66 GeeArrayList* validelements;
67 GstElementFactory** factories;
68 gint factories_length1;
69 gint _factories_size_;
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
82 LOGGING_LEVEL_CRITICAL,
91 static gpointer single_decode_bin_parent_class = NULL;
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))
98 SINGLE_DECODE_BIN_DUMMY_PROPERTY
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);
136 #line 29 "singledecodebin.vala"
137 gboolean is_raw (GstCaps* caps) {
138 #line 139 "singledecodebin.c"
139 gboolean result = FALSE;
144 char** _tmp0_ = NULL;
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_);
153 char** val_collection;
154 int val_collection_length1;
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) {
162 val = g_strdup (val_collection[val_it]);
164 #line 33 "singledecodebin.vala"
165 if (g_str_has_prefix (rep, val)) {
166 #line 167 "singledecodebin.c"
170 valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
171 #line 34 "singledecodebin.vala"
173 #line 174 "singledecodebin.c"
181 valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL);
182 #line 35 "singledecodebin.vala"
184 #line 185 "singledecodebin.c"
188 static gpointer _gst_caps_ref0 (gpointer self) {
189 return self ? gst_caps_ref (self) : NULL;
193 static gpointer _gst_object_ref0 (gpointer self) {
194 return self ? gst_object_ref (self) : NULL;
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;
206 GstElementFactory** _tmp8_;
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);
216 #line 62 "singledecodebin.vala"
218 #line 219 "singledecodebin.c"
220 #line 62 "singledecodebin.vala"
221 _tmp0_ = (_tmp1_ = gst_caps_new_any (), _gst_caps_unref0 (_tmp0_), _tmp1_);
222 #line 223 "singledecodebin.c"
225 #line 62 "singledecodebin.vala"
226 _tmp0_ = (_tmp2_ = _gst_caps_ref0 (caps), _gst_caps_unref0 (_tmp0_), _tmp2_);
227 #line 228 "singledecodebin.c"
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"
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);
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);
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);
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_);
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"
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);
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);
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"
317 #line 92 "singledecodebin.vala"
318 static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b) {
319 #line 320 "singledecodebin.c"
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"
331 #line 332 "singledecodebin.c"
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"
347 #line 348 "singledecodebin.c"
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);
356 (*array)[(*length)++] = value;
357 (*array)[*length] = NULL;
361 static void _g_list_free_gst_object_unref (GList* self) {
362 g_list_foreach (self, (GFunc) gst_object_unref, NULL);
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_);
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"
395 GstPluginFeature* _tmp1_;
396 GstElementFactory* factory;
397 gboolean _tmp2_ = FALSE;
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"
407 #line 408 "singledecodebin.c"
409 #line 107 "singledecodebin.vala"
410 _tmp2_ = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) < 64;
411 #line 412 "singledecodebin.c"
413 #line 107 "singledecodebin.vala"
415 #line 416 "singledecodebin.c"
416 _gst_object_unref0 (plugin_feature);
417 _gst_object_unref0 (factory);
418 #line 108 "singledecodebin.vala"
420 #line 421 "singledecodebin.c"
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"
428 #line 429 "singledecodebin.c"
430 #line 110 "singledecodebin.vala"
431 _tmp4_ = string_contains (klass, "Decoder");
432 #line 433 "singledecodebin.c"
434 #line 110 "singledecodebin.vala"
436 #line 110 "singledecodebin.vala"
438 #line 439 "singledecodebin.c"
440 #line 110 "singledecodebin.vala"
441 _tmp3_ = string_contains (klass, "Parse");
442 #line 443 "singledecodebin.c"
444 #line 110 "singledecodebin.vala"
446 #line 111 "singledecodebin.vala"
447 _vala_array_add2 (&factories, &factories_length1, &_factories_size_, _gst_object_ref0 (factory));
448 #line 449 "singledecodebin.c"
450 _gst_object_unref0 (plugin_feature);
451 _gst_object_unref0 (factory);
455 #line 103 "singledecodebin.vala"
456 __g_list_free_gst_object_unref0 (plugin_feature_collection);
457 #line 458 "singledecodebin.c"
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"
466 #line 467 "singledecodebin.c"
467 _gst_object_unref0 (registry);
468 factories = (_vala_array_free (factories, factories_length1, (GDestroyNotify) gst_object_unref), NULL);
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;
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"
485 GstElementFactory** factory_collection;
486 int factory_collection_length1;
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]);
497 #line 125 "singledecodebin.vala"
498 templates = gst_element_factory_get_static_pad_templates (factory);
499 #line 500 "singledecodebin.c"
501 GList* template_collection;
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"
512 #line 127 "singledecodebin.vala"
513 if (template.direction == GST_PAD_SINK) {
514 #line 515 "singledecodebin.c"
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"
528 #line 529 "singledecodebin.c"
530 _gst_caps_unref0 (intersect);
535 _gst_object_unref0 (factory);
540 #line 136 "singledecodebin.vala"
542 #line 543 "singledecodebin.c"
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);
551 (*array)[(*length)++] = value;
552 (*array)[*length] = NULL;
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);
561 (*array)[(*length)++] = value;
562 (*array)[*length] = NULL;
566 #line 142 "singledecodebin.vala"
567 static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element) {
568 #line 569 "singledecodebin.c"
570 gint _to_connect_size_;
571 gint to_connect_length1;
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"
582 #line 583 "singledecodebin.c"
584 GList* template_collection;
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"
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"
603 #line 604 "singledecodebin.c"
605 #line 149 "singledecodebin.vala"
606 if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_ALWAYS) {
607 #line 608 "singledecodebin.c"
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);
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"
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"
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"
635 #line 156 "singledecodebin.vala"
637 #line 638 "singledecodebin.c"
639 _gst_object_unref0 (pad);
642 _gst_object_unref0 (template);
646 #line 160 "singledecodebin.vala"
648 #line 649 "singledecodebin.c"
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"
656 #line 163 "singledecodebin.vala"
657 single_decode_bin_controlDynamicElement (self, element);
658 #line 659 "singledecodebin.c"
661 GstPad** pad_collection;
662 int pad_collection_length1;
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) {
670 pad = _gst_object_ref0 (pad_collection[pad_it]);
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);
681 to_connect = (_vala_array_free (to_connect, to_connect_length1, (GDestroyNotify) gst_object_unref), NULL);
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"
698 #line 172 "singledecodebin.vala"
700 #line 701 "singledecodebin.c"
702 #line 174 "singledecodebin.vala"
703 potential_src_pads = 0;
704 #line 705 "singledecodebin.c"
706 GList* template_collection;
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"
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"
726 #line 727 "singledecodebin.c"
728 #line 179 "singledecodebin.vala"
729 if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_REQUEST) {
730 #line 179 "singledecodebin.vala"
732 #line 733 "singledecodebin.c"
736 #line 180 "singledecodebin.vala"
737 _tmp1_ = string_contains (_tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_), "%");
738 #line 739 "singledecodebin.c"
741 #line 179 "singledecodebin.vala"
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"
749 #line 750 "singledecodebin.c"
751 #line 183 "singledecodebin.vala"
752 potential_src_pads = potential_src_pads + 1;
753 #line 754 "singledecodebin.c"
755 _gst_object_unref0 (template);
759 result = potential_src_pads > 1;
760 #line 186 "singledecodebin.vala"
762 #line 763 "singledecodebin.c"
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;
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"
794 #line 795 "singledecodebin.c"
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;
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"
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"
822 #line 206 "singledecodebin.vala"
824 #line 825 "singledecodebin.c"
826 GeeIterator* _factory_it;
827 _factory_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (factories));
828 #line 207 "singledecodebin.vala"
830 #line 831 "singledecodebin.c"
831 GstElementFactory* factory;
835 #line 207 "singledecodebin.vala"
836 if (!gee_iterator_next (_factory_it)) {
837 #line 207 "singledecodebin.vala"
839 #line 840 "singledecodebin.c"
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"
854 #line 855 "singledecodebin.c"
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"
866 #line 867 "singledecodebin.c"
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"
884 #line 885 "singledecodebin.c"
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"
898 #line 899 "singledecodebin.c"
900 _g_object_unref0 (_factory_it);
903 _gst_object_unref0 (pad);
904 #line 233 "singledecodebin.vala"
906 #line 907 "singledecodebin.c"
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"
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"
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"
940 #line 941 "singledecodebin.c"
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"
948 #line 949 "singledecodebin.c"
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"
961 #line 259 "singledecodebin.vala"
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"
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"
975 #line 976 "singledecodebin.c"
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"
987 #line 988 "singledecodebin.c"
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);
999 #line 282 "singledecodebin.vala"
1000 static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad) {
1001 #line 1002 "singledecodebin.c"
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"
1015 #line 1016 "singledecodebin.c"
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"
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"
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"
1044 #line 300 "singledecodebin.vala"
1045 static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element) {
1046 #line 1047 "singledecodebin.c"
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"
1062 #line 303 "singledecodebin.vala"
1063 if (element == self->priv->typefind) {
1064 #line 304 "singledecodebin.vala"
1066 #line 1067 "singledecodebin.c"
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);
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"
1090 GList* pad_collection;
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) {
1097 #line 315 "singledecodebin.vala"
1098 pad = _gst_object_ref0 ((GstPad*) pad_it->data);
1099 #line 1100 "singledecodebin.c"
1101 #line 316 "singledecodebin.vala"
1102 if (gst_pad_is_linked (pad)) {
1103 #line 1104 "singledecodebin.c"
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"
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"
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"
1132 _gst_object_unref0 (peer);
1134 _gst_object_unref0 (pad);
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"
1154 #line 332 "singledecodebin.vala"
1155 self->priv->srcpad = (_tmp0_ = NULL, _gst_object_unref0 (self->priv->srcpad), _tmp0_);
1156 #line 1157 "singledecodebin.c"
1158 GeeIterator* _element_it;
1159 _element_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->validelements));
1160 #line 333 "singledecodebin.vala"
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"
1168 #line 1169 "singledecodebin.c"
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);
1179 _g_object_unref0 (_element_it);
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"
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"
1203 #line 346 "singledecodebin.vala"
1205 #line 1206 "singledecodebin.c"
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"
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"
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_);
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"
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_);
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"
1267 static void single_decode_bin_base_init (SingleDecodeBinClass * klass) {
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);
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;
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);
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);
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);
1322 return single_decode_bin_type_id__volatile;
1326 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1327 if ((array != NULL) && (destroy_func != NULL)) {
1329 for (i = 0; i < array_length; i = i + 1) {
1330 if (((gpointer*) array)[i] != NULL) {
1331 destroy_func (((gpointer*) array)[i]);
1338 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1339 _vala_array_destroy (array, array_length, destroy_func);