win32/common/gstenumtypes.c

   1
   2
   3
   4 #include "gst_private.h"
   5 #include <gst/gst.h>
   6 #define C_ENUM(v) ((gint) v)
   7 #define C_FLAGS(v) ((guint) v)
   8
   9
  10 /* enumerations from "gstobject.h" */
  11 GType
  12 gst_object_flags_get_type (void)
  13 {
  14   static gsize id = 0;
  15   static const GFlagsValue values[] = {
  16     {C_FLAGS (GST_OBJECT_FLAG_LAST), "GST_OBJECT_FLAG_LAST", "last"},
  17     {0, NULL, NULL}
  18   };
  19
  20   if (g_once_init_enter (&id)) {
  21     GType tmp = g_flags_register_static ("GstObjectFlags", values);
  22     g_once_init_leave (&id, tmp);
  23   }
  24
  25   return (GType) id;
  26 }
  27
  28 /* enumerations from "gstallocator.h" */
  29 GType
  30 gst_allocator_flags_get_type (void)
  31 {
  32   static gsize id = 0;
  33   static const GFlagsValue values[] = {
  34     {C_FLAGS (GST_ALLOCATOR_FLAG_CUSTOM_ALLOC),
  35         "GST_ALLOCATOR_FLAG_CUSTOM_ALLOC", "custom-alloc"},
  36     {C_FLAGS (GST_ALLOCATOR_FLAG_LAST), "GST_ALLOCATOR_FLAG_LAST", "last"},
  37     {0, NULL, NULL}
  38   };
  39
  40   if (g_once_init_enter (&id)) {
  41     GType tmp = g_flags_register_static ("GstAllocatorFlags", values);
  42     g_once_init_leave (&id, tmp);
  43   }
  44
  45   return (GType) id;
  46 }
  47
  48 /* enumerations from "gstbin.h" */
  49 GType
  50 gst_bin_flags_get_type (void)
  51 {
  52   static gsize id = 0;
  53   static const GFlagsValue values[] = {
  54     {C_FLAGS (GST_BIN_FLAG_NO_RESYNC), "GST_BIN_FLAG_NO_RESYNC", "no-resync"},
  55     {C_FLAGS (GST_BIN_FLAG_LAST), "GST_BIN_FLAG_LAST", "last"},
  56     {0, NULL, NULL}
  57   };
  58
  59   if (g_once_init_enter (&id)) {
  60     GType tmp = g_flags_register_static ("GstBinFlags", values);
  61     g_once_init_leave (&id, tmp);
  62   }
  63
  64   return (GType) id;
  65 }
  66
  67 /* enumerations from "gstbuffer.h" */
  68 GType
  69 gst_buffer_flags_get_type (void)
  70 {
  71   static gsize id = 0;
  72   static const GFlagsValue values[] = {
  73     {C_FLAGS (GST_BUFFER_FLAG_LIVE), "GST_BUFFER_FLAG_LIVE", "live"},
  74     {C_FLAGS (GST_BUFFER_FLAG_DECODE_ONLY), "GST_BUFFER_FLAG_DECODE_ONLY",
  75         "decode-only"},
  76     {C_FLAGS (GST_BUFFER_FLAG_DISCONT), "GST_BUFFER_FLAG_DISCONT", "discont"},
  77     {C_FLAGS (GST_BUFFER_FLAG_RESYNC), "GST_BUFFER_FLAG_RESYNC", "resync"},
  78     {C_FLAGS (GST_BUFFER_FLAG_CORRUPTED), "GST_BUFFER_FLAG_CORRUPTED",
  79         "corrupted"},
  80     {C_FLAGS (GST_BUFFER_FLAG_MARKER), "GST_BUFFER_FLAG_MARKER", "marker"},
  81     {C_FLAGS (GST_BUFFER_FLAG_HEADER), "GST_BUFFER_FLAG_HEADER", "header"},
  82     {C_FLAGS (GST_BUFFER_FLAG_GAP), "GST_BUFFER_FLAG_GAP", "gap"},
  83     {C_FLAGS (GST_BUFFER_FLAG_DROPPABLE), "GST_BUFFER_FLAG_DROPPABLE",
  84         "droppable"},
  85     {C_FLAGS (GST_BUFFER_FLAG_DELTA_UNIT), "GST_BUFFER_FLAG_DELTA_UNIT",
  86         "delta-unit"},
  87     {C_FLAGS (GST_BUFFER_FLAG_LAST), "GST_BUFFER_FLAG_LAST", "last"},
  88     {0, NULL, NULL}
  89   };
  90
  91   if (g_once_init_enter (&id)) {
  92     GType tmp = g_flags_register_static ("GstBufferFlags", values);
  93     g_once_init_leave (&id, tmp);
  94   }
  95
  96   return (GType) id;
  97 }
  98
  99 GType
 100 gst_buffer_copy_flags_get_type (void)
 101 {
 102   static gsize id = 0;
 103   static const GFlagsValue values[] = {
 104     {C_FLAGS (GST_BUFFER_COPY_NONE), "GST_BUFFER_COPY_NONE", "none"},
 105     {C_FLAGS (GST_BUFFER_COPY_FLAGS), "GST_BUFFER_COPY_FLAGS", "flags"},
 106     {C_FLAGS (GST_BUFFER_COPY_TIMESTAMPS), "GST_BUFFER_COPY_TIMESTAMPS",
 107         "timestamps"},
 108     {C_FLAGS (GST_BUFFER_COPY_META), "GST_BUFFER_COPY_META", "meta"},
 109     {C_FLAGS (GST_BUFFER_COPY_MEMORY), "GST_BUFFER_COPY_MEMORY", "memory"},
 110     {C_FLAGS (GST_BUFFER_COPY_MERGE), "GST_BUFFER_COPY_MERGE", "merge"},
 111     {C_FLAGS (GST_BUFFER_COPY_DEEP), "GST_BUFFER_COPY_DEEP", "deep"},
 112     {0, NULL, NULL}
 113   };
 114
 115   if (g_once_init_enter (&id)) {
 116     GType tmp = g_flags_register_static ("GstBufferCopyFlags", values);
 117     g_once_init_leave (&id, tmp);
 118   }
 119
 120   return (GType) id;
 121 }
 122
 123 /* enumerations from "gstbufferpool.h" */
 124 GType
 125 gst_buffer_pool_acquire_flags_get_type (void)
 126 {
 127   static gsize id = 0;
 128   static const GFlagsValue values[] = {
 129     {C_FLAGS (GST_BUFFER_POOL_ACQUIRE_FLAG_NONE),
 130         "GST_BUFFER_POOL_ACQUIRE_FLAG_NONE", "none"},
 131     {C_FLAGS (GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT),
 132         "GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT", "key-unit"},
 133     {C_FLAGS (GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT),
 134         "GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT", "dontwait"},
 135     {C_FLAGS (GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT),
 136         "GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT", "discont"},
 137     {C_FLAGS (GST_BUFFER_POOL_ACQUIRE_FLAG_LAST),
 138         "GST_BUFFER_POOL_ACQUIRE_FLAG_LAST", "last"},
 139     {0, NULL, NULL}
 140   };
 141
 142   if (g_once_init_enter (&id)) {
 143     GType tmp = g_flags_register_static ("GstBufferPoolAcquireFlags", values);
 144     g_once_init_leave (&id, tmp);
 145   }
 146
 147   return (GType) id;
 148 }
 149
 150 /* enumerations from "gstbus.h" */
 151 GType
 152 gst_bus_flags_get_type (void)
 153 {
 154   static gsize id = 0;
 155   static const GFlagsValue values[] = {
 156     {C_FLAGS (GST_BUS_FLUSHING), "GST_BUS_FLUSHING", "flushing"},
 157     {C_FLAGS (GST_BUS_FLAG_LAST), "GST_BUS_FLAG_LAST", "flag-last"},
 158     {0, NULL, NULL}
 159   };
 160
 161   if (g_once_init_enter (&id)) {
 162     GType tmp = g_flags_register_static ("GstBusFlags", values);
 163     g_once_init_leave (&id, tmp);
 164   }
 165
 166   return (GType) id;
 167 }
 168
 169 GType
 170 gst_bus_sync_reply_get_type (void)
 171 {
 172   static gsize id = 0;
 173   static const GEnumValue values[] = {
 174     {C_ENUM (GST_BUS_DROP), "GST_BUS_DROP", "drop"},
 175     {C_ENUM (GST_BUS_PASS), "GST_BUS_PASS", "pass"},
 176     {C_ENUM (GST_BUS_ASYNC), "GST_BUS_ASYNC", "async"},
 177     {0, NULL, NULL}
 178   };
 179
 180   if (g_once_init_enter (&id)) {
 181     GType tmp = g_enum_register_static ("GstBusSyncReply", values);
 182     g_once_init_leave (&id, tmp);
 183   }
 184
 185   return (GType) id;
 186 }
 187
 188 /* enumerations from "gstcaps.h" */
 189 GType
 190 gst_caps_flags_get_type (void)
 191 {
 192   static gsize id = 0;
 193   static const GFlagsValue values[] = {
 194     {C_FLAGS (GST_CAPS_FLAG_ANY), "GST_CAPS_FLAG_ANY", "any"},
 195     {0, NULL, NULL}
 196   };
 197
 198   if (g_once_init_enter (&id)) {
 199     GType tmp = g_flags_register_static ("GstCapsFlags", values);
 200     g_once_init_leave (&id, tmp);
 201   }
 202
 203   return (GType) id;
 204 }
 205
 206 GType
 207 gst_caps_intersect_mode_get_type (void)
 208 {
 209   static gsize id = 0;
 210   static const GEnumValue values[] = {
 211     {C_ENUM (GST_CAPS_INTERSECT_ZIG_ZAG), "GST_CAPS_INTERSECT_ZIG_ZAG",
 212         "zig-zag"},
 213     {C_ENUM (GST_CAPS_INTERSECT_FIRST), "GST_CAPS_INTERSECT_FIRST", "first"},
 214     {0, NULL, NULL}
 215   };
 216
 217   if (g_once_init_enter (&id)) {
 218     GType tmp = g_enum_register_static ("GstCapsIntersectMode", values);
 219     g_once_init_leave (&id, tmp);
 220   }
 221
 222   return (GType) id;
 223 }
 224
 225 /* enumerations from "gstclock.h" */
 226 GType
 227 gst_clock_return_get_type (void)
 228 {
 229   static gsize id = 0;
 230   static const GEnumValue values[] = {
 231     {C_ENUM (GST_CLOCK_OK), "GST_CLOCK_OK", "ok"},
 232     {C_ENUM (GST_CLOCK_EARLY), "GST_CLOCK_EARLY", "early"},
 233     {C_ENUM (GST_CLOCK_UNSCHEDULED), "GST_CLOCK_UNSCHEDULED", "unscheduled"},
 234     {C_ENUM (GST_CLOCK_BUSY), "GST_CLOCK_BUSY", "busy"},
 235     {C_ENUM (GST_CLOCK_BADTIME), "GST_CLOCK_BADTIME", "badtime"},
 236     {C_ENUM (GST_CLOCK_ERROR), "GST_CLOCK_ERROR", "error"},
 237     {C_ENUM (GST_CLOCK_UNSUPPORTED), "GST_CLOCK_UNSUPPORTED", "unsupported"},
 238     {C_ENUM (GST_CLOCK_DONE), "GST_CLOCK_DONE", "done"},
 239     {0, NULL, NULL}
 240   };
 241
 242   if (g_once_init_enter (&id)) {
 243     GType tmp = g_enum_register_static ("GstClockReturn", values);
 244     g_once_init_leave (&id, tmp);
 245   }
 246
 247   return (GType) id;
 248 }
 249
 250 GType
 251 gst_clock_entry_type_get_type (void)
 252 {
 253   static gsize id = 0;
 254   static const GEnumValue values[] = {
 255     {C_ENUM (GST_CLOCK_ENTRY_SINGLE), "GST_CLOCK_ENTRY_SINGLE", "single"},
 256     {C_ENUM (GST_CLOCK_ENTRY_PERIODIC), "GST_CLOCK_ENTRY_PERIODIC", "periodic"},
 257     {0, NULL, NULL}
 258   };
 259
 260   if (g_once_init_enter (&id)) {
 261     GType tmp = g_enum_register_static ("GstClockEntryType", values);
 262     g_once_init_leave (&id, tmp);
 263   }
 264
 265   return (GType) id;
 266 }
 267
 268 GType
 269 gst_clock_flags_get_type (void)
 270 {
 271   static gsize id = 0;
 272   static const GFlagsValue values[] = {
 273     {C_FLAGS (GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC),
 274         "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC", "can-do-single-sync"},
 275     {C_FLAGS (GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC),
 276         "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC", "can-do-single-async"},
 277     {C_FLAGS (GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC),
 278         "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC", "can-do-periodic-sync"},
 279     {C_FLAGS (GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC),
 280         "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC", "can-do-periodic-async"},
 281     {C_FLAGS (GST_CLOCK_FLAG_CAN_SET_RESOLUTION),
 282         "GST_CLOCK_FLAG_CAN_SET_RESOLUTION", "can-set-resolution"},
 283     {C_FLAGS (GST_CLOCK_FLAG_CAN_SET_MASTER), "GST_CLOCK_FLAG_CAN_SET_MASTER",
 284         "can-set-master"},
 285     {C_FLAGS (GST_CLOCK_FLAG_LAST), "GST_CLOCK_FLAG_LAST", "last"},
 286     {0, NULL, NULL}
 287   };
 288
 289   if (g_once_init_enter (&id)) {
 290     GType tmp = g_flags_register_static ("GstClockFlags", values);
 291     g_once_init_leave (&id, tmp);
 292   }
 293
 294   return (GType) id;
 295 }
 296
 297 /* enumerations from "gstdebugutils.h" */
 298 GType
 299 gst_debug_graph_details_get_type (void)
 300 {
 301   static gsize id = 0;
 302   static const GFlagsValue values[] = {
 303     {C_FLAGS (GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE),
 304         "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE", "media-type"},
 305     {C_FLAGS (GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS),
 306         "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS", "caps-details"},
 307     {C_FLAGS (GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS),
 308         "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS", "non-default-params"},
 309     {C_FLAGS (GST_DEBUG_GRAPH_SHOW_STATES), "GST_DEBUG_GRAPH_SHOW_STATES",
 310         "states"},
 311     {C_FLAGS (GST_DEBUG_GRAPH_SHOW_ALL), "GST_DEBUG_GRAPH_SHOW_ALL", "all"},
 312     {0, NULL, NULL}
 313   };
 314
 315   if (g_once_init_enter (&id)) {
 316     GType tmp = g_flags_register_static ("GstDebugGraphDetails", values);
 317     g_once_init_leave (&id, tmp);
 318   }
 319
 320   return (GType) id;
 321 }
 322
 323 /* enumerations from "gstelement.h" */
 324 GType
 325 gst_state_get_type (void)
 326 {
 327   static gsize id = 0;
 328   static const GEnumValue values[] = {
 329     {C_ENUM (GST_STATE_VOID_PENDING), "GST_STATE_VOID_PENDING", "void-pending"},
 330     {C_ENUM (GST_STATE_NULL), "GST_STATE_NULL", "null"},
 331     {C_ENUM (GST_STATE_READY), "GST_STATE_READY", "ready"},
 332     {C_ENUM (GST_STATE_PAUSED), "GST_STATE_PAUSED", "paused"},
 333     {C_ENUM (GST_STATE_PLAYING), "GST_STATE_PLAYING", "playing"},
 334     {0, NULL, NULL}
 335   };
 336
 337   if (g_once_init_enter (&id)) {
 338     GType tmp = g_enum_register_static ("GstState", values);
 339     g_once_init_leave (&id, tmp);
 340   }
 341
 342   return (GType) id;
 343 }
 344
 345 GType
 346 gst_state_change_return_get_type (void)
 347 {
 348   static gsize id = 0;
 349   static const GEnumValue values[] = {
 350     {C_ENUM (GST_STATE_CHANGE_FAILURE), "GST_STATE_CHANGE_FAILURE", "failure"},
 351     {C_ENUM (GST_STATE_CHANGE_SUCCESS), "GST_STATE_CHANGE_SUCCESS", "success"},
 352     {C_ENUM (GST_STATE_CHANGE_ASYNC), "GST_STATE_CHANGE_ASYNC", "async"},
 353     {C_ENUM (GST_STATE_CHANGE_NO_PREROLL), "GST_STATE_CHANGE_NO_PREROLL",
 354         "no-preroll"},
 355     {0, NULL, NULL}
 356   };
 357
 358   if (g_once_init_enter (&id)) {
 359     GType tmp = g_enum_register_static ("GstStateChangeReturn", values);
 360     g_once_init_leave (&id, tmp);
 361   }
 362
 363   return (GType) id;
 364 }
 365
 366 GType
 367 gst_state_change_get_type (void)
 368 {
 369   static gsize id = 0;
 370   static const GEnumValue values[] = {
 371     {C_ENUM (GST_STATE_CHANGE_NULL_TO_READY), "GST_STATE_CHANGE_NULL_TO_READY",
 372         "null-to-ready"},
 373     {C_ENUM (GST_STATE_CHANGE_READY_TO_PAUSED),
 374         "GST_STATE_CHANGE_READY_TO_PAUSED", "ready-to-paused"},
 375     {C_ENUM (GST_STATE_CHANGE_PAUSED_TO_PLAYING),
 376         "GST_STATE_CHANGE_PAUSED_TO_PLAYING", "paused-to-playing"},
 377     {C_ENUM (GST_STATE_CHANGE_PLAYING_TO_PAUSED),
 378         "GST_STATE_CHANGE_PLAYING_TO_PAUSED", "playing-to-paused"},
 379     {C_ENUM (GST_STATE_CHANGE_PAUSED_TO_READY),
 380         "GST_STATE_CHANGE_PAUSED_TO_READY", "paused-to-ready"},
 381     {C_ENUM (GST_STATE_CHANGE_READY_TO_NULL), "GST_STATE_CHANGE_READY_TO_NULL",
 382         "ready-to-null"},
 383     {0, NULL, NULL}
 384   };
 385
 386   if (g_once_init_enter (&id)) {
 387     GType tmp = g_enum_register_static ("GstStateChange", values);
 388     g_once_init_leave (&id, tmp);
 389   }
 390
 391   return (GType) id;
 392 }
 393
 394 GType
 395 gst_element_flags_get_type (void)
 396 {
 397   static gsize id = 0;
 398   static const GFlagsValue values[] = {
 399     {C_FLAGS (GST_ELEMENT_FLAG_LOCKED_STATE), "GST_ELEMENT_FLAG_LOCKED_STATE",
 400         "locked-state"},
 401     {C_FLAGS (GST_ELEMENT_FLAG_SINK), "GST_ELEMENT_FLAG_SINK", "sink"},
 402     {C_FLAGS (GST_ELEMENT_FLAG_SOURCE), "GST_ELEMENT_FLAG_SOURCE", "source"},
 403     {C_FLAGS (GST_ELEMENT_FLAG_PROVIDE_CLOCK), "GST_ELEMENT_FLAG_PROVIDE_CLOCK",
 404         "provide-clock"},
 405     {C_FLAGS (GST_ELEMENT_FLAG_REQUIRE_CLOCK), "GST_ELEMENT_FLAG_REQUIRE_CLOCK",
 406         "require-clock"},
 407     {C_FLAGS (GST_ELEMENT_FLAG_INDEXABLE), "GST_ELEMENT_FLAG_INDEXABLE",
 408         "indexable"},
 409     {C_FLAGS (GST_ELEMENT_FLAG_LAST), "GST_ELEMENT_FLAG_LAST", "last"},
 410     {0, NULL, NULL}
 411   };
 412
 413   if (g_once_init_enter (&id)) {
 414     GType tmp = g_flags_register_static ("GstElementFlags", values);
 415     g_once_init_leave (&id, tmp);
 416   }
 417
 418   return (GType) id;
 419 }
 420
 421 /* enumerations from "gsterror.h" */
 422 GType
 423 gst_core_error_get_type (void)
 424 {
 425   static gsize id = 0;
 426   static const GEnumValue values[] = {
 427     {C_ENUM (GST_CORE_ERROR_FAILED), "GST_CORE_ERROR_FAILED", "failed"},
 428     {C_ENUM (GST_CORE_ERROR_TOO_LAZY), "GST_CORE_ERROR_TOO_LAZY", "too-lazy"},
 429     {C_ENUM (GST_CORE_ERROR_NOT_IMPLEMENTED), "GST_CORE_ERROR_NOT_IMPLEMENTED",
 430         "not-implemented"},
 431     {C_ENUM (GST_CORE_ERROR_STATE_CHANGE), "GST_CORE_ERROR_STATE_CHANGE",
 432         "state-change"},
 433     {C_ENUM (GST_CORE_ERROR_PAD), "GST_CORE_ERROR_PAD", "pad"},
 434     {C_ENUM (GST_CORE_ERROR_THREAD), "GST_CORE_ERROR_THREAD", "thread"},
 435     {C_ENUM (GST_CORE_ERROR_NEGOTIATION), "GST_CORE_ERROR_NEGOTIATION",
 436         "negotiation"},
 437     {C_ENUM (GST_CORE_ERROR_EVENT), "GST_CORE_ERROR_EVENT", "event"},
 438     {C_ENUM (GST_CORE_ERROR_SEEK), "GST_CORE_ERROR_SEEK", "seek"},
 439     {C_ENUM (GST_CORE_ERROR_CAPS), "GST_CORE_ERROR_CAPS", "caps"},
 440     {C_ENUM (GST_CORE_ERROR_TAG), "GST_CORE_ERROR_TAG", "tag"},
 441     {C_ENUM (GST_CORE_ERROR_MISSING_PLUGIN), "GST_CORE_ERROR_MISSING_PLUGIN",
 442         "missing-plugin"},
 443     {C_ENUM (GST_CORE_ERROR_CLOCK), "GST_CORE_ERROR_CLOCK", "clock"},
 444     {C_ENUM (GST_CORE_ERROR_DISABLED), "GST_CORE_ERROR_DISABLED", "disabled"},
 445     {C_ENUM (GST_CORE_ERROR_NUM_ERRORS), "GST_CORE_ERROR_NUM_ERRORS",
 446         "num-errors"},
 447     {0, NULL, NULL}
 448   };
 449
 450   if (g_once_init_enter (&id)) {
 451     GType tmp = g_enum_register_static ("GstCoreError", values);
 452     g_once_init_leave (&id, tmp);
 453   }
 454
 455   return (GType) id;
 456 }
 457
 458 GType
 459 gst_library_error_get_type (void)
 460 {
 461   static gsize id = 0;
 462   static const GEnumValue values[] = {
 463     {C_ENUM (GST_LIBRARY_ERROR_FAILED), "GST_LIBRARY_ERROR_FAILED", "failed"},
 464     {C_ENUM (GST_LIBRARY_ERROR_TOO_LAZY), "GST_LIBRARY_ERROR_TOO_LAZY",
 465         "too-lazy"},
 466     {C_ENUM (GST_LIBRARY_ERROR_INIT), "GST_LIBRARY_ERROR_INIT", "init"},
 467     {C_ENUM (GST_LIBRARY_ERROR_SHUTDOWN), "GST_LIBRARY_ERROR_SHUTDOWN",
 468         "shutdown"},
 469     {C_ENUM (GST_LIBRARY_ERROR_SETTINGS), "GST_LIBRARY_ERROR_SETTINGS",
 470         "settings"},
 471     {C_ENUM (GST_LIBRARY_ERROR_ENCODE), "GST_LIBRARY_ERROR_ENCODE", "encode"},
 472     {C_ENUM (GST_LIBRARY_ERROR_NUM_ERRORS), "GST_LIBRARY_ERROR_NUM_ERRORS",
 473         "num-errors"},
 474     {0, NULL, NULL}
 475   };
 476
 477   if (g_once_init_enter (&id)) {
 478     GType tmp = g_enum_register_static ("GstLibraryError", values);
 479     g_once_init_leave (&id, tmp);
 480   }
 481
 482   return (GType) id;
 483 }
 484
 485 GType
 486 gst_resource_error_get_type (void)
 487 {
 488   static gsize id = 0;
 489   static const GEnumValue values[] = {
 490     {C_ENUM (GST_RESOURCE_ERROR_FAILED), "GST_RESOURCE_ERROR_FAILED", "failed"},
 491     {C_ENUM (GST_RESOURCE_ERROR_TOO_LAZY), "GST_RESOURCE_ERROR_TOO_LAZY",
 492         "too-lazy"},
 493     {C_ENUM (GST_RESOURCE_ERROR_NOT_FOUND), "GST_RESOURCE_ERROR_NOT_FOUND",
 494         "not-found"},
 495     {C_ENUM (GST_RESOURCE_ERROR_BUSY), "GST_RESOURCE_ERROR_BUSY", "busy"},
 496     {C_ENUM (GST_RESOURCE_ERROR_OPEN_READ), "GST_RESOURCE_ERROR_OPEN_READ",
 497         "open-read"},
 498     {C_ENUM (GST_RESOURCE_ERROR_OPEN_WRITE), "GST_RESOURCE_ERROR_OPEN_WRITE",
 499         "open-write"},
 500     {C_ENUM (GST_RESOURCE_ERROR_OPEN_READ_WRITE),
 501         "GST_RESOURCE_ERROR_OPEN_READ_WRITE", "open-read-write"},
 502     {C_ENUM (GST_RESOURCE_ERROR_CLOSE), "GST_RESOURCE_ERROR_CLOSE", "close"},
 503     {C_ENUM (GST_RESOURCE_ERROR_READ), "GST_RESOURCE_ERROR_READ", "read"},
 504     {C_ENUM (GST_RESOURCE_ERROR_WRITE), "GST_RESOURCE_ERROR_WRITE", "write"},
 505     {C_ENUM (GST_RESOURCE_ERROR_SEEK), "GST_RESOURCE_ERROR_SEEK", "seek"},
 506     {C_ENUM (GST_RESOURCE_ERROR_SYNC), "GST_RESOURCE_ERROR_SYNC", "sync"},
 507     {C_ENUM (GST_RESOURCE_ERROR_SETTINGS), "GST_RESOURCE_ERROR_SETTINGS",
 508         "settings"},
 509     {C_ENUM (GST_RESOURCE_ERROR_NO_SPACE_LEFT),
 510         "GST_RESOURCE_ERROR_NO_SPACE_LEFT", "no-space-left"},
 511     {C_ENUM (GST_RESOURCE_ERROR_NUM_ERRORS), "GST_RESOURCE_ERROR_NUM_ERRORS",
 512         "num-errors"},
 513     {0, NULL, NULL}
 514   };
 515
 516   if (g_once_init_enter (&id)) {
 517     GType tmp = g_enum_register_static ("GstResourceError", values);
 518     g_once_init_leave (&id, tmp);
 519   }
 520
 521   return (GType) id;
 522 }
 523
 524 GType
 525 gst_stream_error_get_type (void)
 526 {
 527   static gsize id = 0;
 528   static const GEnumValue values[] = {
 529     {C_ENUM (GST_STREAM_ERROR_FAILED), "GST_STREAM_ERROR_FAILED", "failed"},
 530     {C_ENUM (GST_STREAM_ERROR_TOO_LAZY), "GST_STREAM_ERROR_TOO_LAZY",
 531         "too-lazy"},
 532     {C_ENUM (GST_STREAM_ERROR_NOT_IMPLEMENTED),
 533         "GST_STREAM_ERROR_NOT_IMPLEMENTED", "not-implemented"},
 534     {C_ENUM (GST_STREAM_ERROR_TYPE_NOT_FOUND),
 535         "GST_STREAM_ERROR_TYPE_NOT_FOUND", "type-not-found"},
 536     {C_ENUM (GST_STREAM_ERROR_WRONG_TYPE), "GST_STREAM_ERROR_WRONG_TYPE",
 537         "wrong-type"},
 538     {C_ENUM (GST_STREAM_ERROR_CODEC_NOT_FOUND),
 539         "GST_STREAM_ERROR_CODEC_NOT_FOUND", "codec-not-found"},
 540     {C_ENUM (GST_STREAM_ERROR_DECODE), "GST_STREAM_ERROR_DECODE", "decode"},
 541     {C_ENUM (GST_STREAM_ERROR_ENCODE), "GST_STREAM_ERROR_ENCODE", "encode"},
 542     {C_ENUM (GST_STREAM_ERROR_DEMUX), "GST_STREAM_ERROR_DEMUX", "demux"},
 543     {C_ENUM (GST_STREAM_ERROR_MUX), "GST_STREAM_ERROR_MUX", "mux"},
 544     {C_ENUM (GST_STREAM_ERROR_FORMAT), "GST_STREAM_ERROR_FORMAT", "format"},
 545     {C_ENUM (GST_STREAM_ERROR_DECRYPT), "GST_STREAM_ERROR_DECRYPT", "decrypt"},
 546     {C_ENUM (GST_STREAM_ERROR_DECRYPT_NOKEY), "GST_STREAM_ERROR_DECRYPT_NOKEY",
 547         "decrypt-nokey"},
 548     {C_ENUM (GST_STREAM_ERROR_NUM_ERRORS), "GST_STREAM_ERROR_NUM_ERRORS",
 549         "num-errors"},
 550     {0, NULL, NULL}
 551   };
 552
 553   if (g_once_init_enter (&id)) {
 554     GType tmp = g_enum_register_static ("GstStreamError", values);
 555     g_once_init_leave (&id, tmp);
 556   }
 557
 558   return (GType) id;
 559 }
 560
 561 /* enumerations from "gstevent.h" */
 562 GType
 563 gst_event_type_flags_get_type (void)
 564 {
 565   static gsize id = 0;
 566   static const GFlagsValue values[] = {
 567     {C_FLAGS (GST_EVENT_TYPE_UPSTREAM), "GST_EVENT_TYPE_UPSTREAM", "upstream"},
 568     {C_FLAGS (GST_EVENT_TYPE_DOWNSTREAM), "GST_EVENT_TYPE_DOWNSTREAM",
 569         "downstream"},
 570     {C_FLAGS (GST_EVENT_TYPE_SERIALIZED), "GST_EVENT_TYPE_SERIALIZED",
 571         "serialized"},
 572     {C_FLAGS (GST_EVENT_TYPE_STICKY), "GST_EVENT_TYPE_STICKY", "sticky"},
 573     {C_FLAGS (GST_EVENT_TYPE_STICKY_MULTI), "GST_EVENT_TYPE_STICKY_MULTI",
 574         "sticky-multi"},
 575     {0, NULL, NULL}
 576   };
 577
 578   if (g_once_init_enter (&id)) {
 579     GType tmp = g_flags_register_static ("GstEventTypeFlags", values);
 580     g_once_init_leave (&id, tmp);
 581   }
 582
 583   return (GType) id;
 584 }
 585
 586 GType
 587 gst_event_type_get_type (void)
 588 {
 589   static gsize id = 0;
 590   static const GEnumValue values[] = {
 591     {C_ENUM (GST_EVENT_UNKNOWN), "GST_EVENT_UNKNOWN", "unknown"},
 592     {C_ENUM (GST_EVENT_FLUSH_START), "GST_EVENT_FLUSH_START", "flush-start"},
 593     {C_ENUM (GST_EVENT_FLUSH_STOP), "GST_EVENT_FLUSH_STOP", "flush-stop"},
 594     {C_ENUM (GST_EVENT_STREAM_START), "GST_EVENT_STREAM_START", "stream-start"},
 595     {C_ENUM (GST_EVENT_CAPS), "GST_EVENT_CAPS", "caps"},
 596     {C_ENUM (GST_EVENT_SEGMENT), "GST_EVENT_SEGMENT", "segment"},
 597     {C_ENUM (GST_EVENT_TAG), "GST_EVENT_TAG", "tag"},
 598     {C_ENUM (GST_EVENT_BUFFERSIZE), "GST_EVENT_BUFFERSIZE", "buffersize"},
 599     {C_ENUM (GST_EVENT_SINK_MESSAGE), "GST_EVENT_SINK_MESSAGE", "sink-message"},
 600     {C_ENUM (GST_EVENT_EOS), "GST_EVENT_EOS", "eos"},
 601     {C_ENUM (GST_EVENT_TOC), "GST_EVENT_TOC", "toc"},
 602     {C_ENUM (GST_EVENT_CONTEXT), "GST_EVENT_CONTEXT", "context"},
 603     {C_ENUM (GST_EVENT_SEGMENT_DONE), "GST_EVENT_SEGMENT_DONE", "segment-done"},
 604     {C_ENUM (GST_EVENT_GAP), "GST_EVENT_GAP", "gap"},
 605     {C_ENUM (GST_EVENT_QOS), "GST_EVENT_QOS", "qos"},
 606     {C_ENUM (GST_EVENT_SEEK), "GST_EVENT_SEEK", "seek"},
 607     {C_ENUM (GST_EVENT_NAVIGATION), "GST_EVENT_NAVIGATION", "navigation"},
 608     {C_ENUM (GST_EVENT_LATENCY), "GST_EVENT_LATENCY", "latency"},
 609     {C_ENUM (GST_EVENT_STEP), "GST_EVENT_STEP", "step"},
 610     {C_ENUM (GST_EVENT_RECONFIGURE), "GST_EVENT_RECONFIGURE", "reconfigure"},
 611     {C_ENUM (GST_EVENT_TOC_SELECT), "GST_EVENT_TOC_SELECT", "toc-select"},
 612     {C_ENUM (GST_EVENT_CUSTOM_UPSTREAM), "GST_EVENT_CUSTOM_UPSTREAM",
 613         "custom-upstream"},
 614     {C_ENUM (GST_EVENT_CUSTOM_DOWNSTREAM), "GST_EVENT_CUSTOM_DOWNSTREAM",
 615         "custom-downstream"},
 616     {C_ENUM (GST_EVENT_CUSTOM_DOWNSTREAM_OOB),
 617         "GST_EVENT_CUSTOM_DOWNSTREAM_OOB", "custom-downstream-oob"},
 618     {C_ENUM (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY),
 619         "GST_EVENT_CUSTOM_DOWNSTREAM_STICKY", "custom-downstream-sticky"},
 620     {C_ENUM (GST_EVENT_CUSTOM_BOTH), "GST_EVENT_CUSTOM_BOTH", "custom-both"},
 621     {C_ENUM (GST_EVENT_CUSTOM_BOTH_OOB), "GST_EVENT_CUSTOM_BOTH_OOB",
 622         "custom-both-oob"},
 623     {0, NULL, NULL}
 624   };
 625
 626   if (g_once_init_enter (&id)) {
 627     GType tmp = g_enum_register_static ("GstEventType", values);
 628     g_once_init_leave (&id, tmp);
 629   }
 630
 631   return (GType) id;
 632 }
 633
 634 GType
 635 gst_qos_type_get_type (void)
 636 {
 637   static gsize id = 0;
 638   static const GEnumValue values[] = {
 639     {C_ENUM (GST_QOS_TYPE_OVERFLOW), "GST_QOS_TYPE_OVERFLOW", "overflow"},
 640     {C_ENUM (GST_QOS_TYPE_UNDERFLOW), "GST_QOS_TYPE_UNDERFLOW", "underflow"},
 641     {C_ENUM (GST_QOS_TYPE_THROTTLE), "GST_QOS_TYPE_THROTTLE", "throttle"},
 642     {0, NULL, NULL}
 643   };
 644
 645   if (g_once_init_enter (&id)) {
 646     GType tmp = g_enum_register_static ("GstQOSType", values);
 647     g_once_init_leave (&id, tmp);
 648   }
 649
 650   return (GType) id;
 651 }
 652
 653 GType
 654 gst_stream_flags_get_type (void)
 655 {
 656   static gsize id = 0;
 657   static const GFlagsValue values[] = {
 658     {C_FLAGS (GST_STREAM_FLAG_NONE), "GST_STREAM_FLAG_NONE", "none"},
 659     {C_FLAGS (GST_STREAM_FLAG_SPARSE), "GST_STREAM_FLAG_SPARSE", "sparse"},
 660     {C_FLAGS (GST_STREAM_FLAG_SELECT), "GST_STREAM_FLAG_SELECT", "select"},
 661     {C_FLAGS (GST_STREAM_FLAG_UNSELECT), "GST_STREAM_FLAG_UNSELECT",
 662         "unselect"},
 663     {0, NULL, NULL}
 664   };
 665
 666   if (g_once_init_enter (&id)) {
 667     GType tmp = g_flags_register_static ("GstStreamFlags", values);
 668     g_once_init_leave (&id, tmp);
 669   }
 670
 671   return (GType) id;
 672 }
 673
 674 /* enumerations from "gstformat.h" */
 675 GType
 676 gst_format_get_type (void)
 677 {
 678   static gsize id = 0;
 679   static const GEnumValue values[] = {
 680     {C_ENUM (GST_FORMAT_UNDEFINED), "GST_FORMAT_UNDEFINED", "undefined"},
 681     {C_ENUM (GST_FORMAT_DEFAULT), "GST_FORMAT_DEFAULT", "default"},
 682     {C_ENUM (GST_FORMAT_BYTES), "GST_FORMAT_BYTES", "bytes"},
 683     {C_ENUM (GST_FORMAT_TIME), "GST_FORMAT_TIME", "time"},
 684     {C_ENUM (GST_FORMAT_BUFFERS), "GST_FORMAT_BUFFERS", "buffers"},
 685     {C_ENUM (GST_FORMAT_PERCENT), "GST_FORMAT_PERCENT", "percent"},
 686     {0, NULL, NULL}
 687   };
 688
 689   if (g_once_init_enter (&id)) {
 690     GType tmp = g_enum_register_static ("GstFormat", values);
 691     g_once_init_leave (&id, tmp);
 692   }
 693
 694   return (GType) id;
 695 }
 696
 697 /* enumerations from "gstinfo.h" */
 698 GType
 699 gst_debug_level_get_type (void)
 700 {
 701   static gsize id = 0;
 702   static const GEnumValue values[] = {
 703     {C_ENUM (GST_LEVEL_NONE), "GST_LEVEL_NONE", "none"},
 704     {C_ENUM (GST_LEVEL_ERROR), "GST_LEVEL_ERROR", "error"},
 705     {C_ENUM (GST_LEVEL_WARNING), "GST_LEVEL_WARNING", "warning"},
 706     {C_ENUM (GST_LEVEL_FIXME), "GST_LEVEL_FIXME", "fixme"},
 707     {C_ENUM (GST_LEVEL_INFO), "GST_LEVEL_INFO", "info"},
 708     {C_ENUM (GST_LEVEL_DEBUG), "GST_LEVEL_DEBUG", "debug"},
 709     {C_ENUM (GST_LEVEL_LOG), "GST_LEVEL_LOG", "log"},
 710     {C_ENUM (GST_LEVEL_TRACE), "GST_LEVEL_TRACE", "trace"},
 711     {C_ENUM (GST_LEVEL_MEMDUMP), "GST_LEVEL_MEMDUMP", "memdump"},
 712     {C_ENUM (GST_LEVEL_COUNT), "GST_LEVEL_COUNT", "count"},
 713     {0, NULL, NULL}
 714   };
 715
 716   if (g_once_init_enter (&id)) {
 717     GType tmp = g_enum_register_static ("GstDebugLevel", values);
 718     g_once_init_leave (&id, tmp);
 719   }
 720
 721   return (GType) id;
 722 }
 723
 724 GType
 725 gst_debug_color_flags_get_type (void)
 726 {
 727   static gsize id = 0;
 728   static const GEnumValue values[] = {
 729     {C_ENUM (GST_DEBUG_FG_BLACK), "GST_DEBUG_FG_BLACK", "fg-black"},
 730     {C_ENUM (GST_DEBUG_FG_RED), "GST_DEBUG_FG_RED", "fg-red"},
 731     {C_ENUM (GST_DEBUG_FG_GREEN), "GST_DEBUG_FG_GREEN", "fg-green"},
 732     {C_ENUM (GST_DEBUG_FG_YELLOW), "GST_DEBUG_FG_YELLOW", "fg-yellow"},
 733     {C_ENUM (GST_DEBUG_FG_BLUE), "GST_DEBUG_FG_BLUE", "fg-blue"},
 734     {C_ENUM (GST_DEBUG_FG_MAGENTA), "GST_DEBUG_FG_MAGENTA", "fg-magenta"},
 735     {C_ENUM (GST_DEBUG_FG_CYAN), "GST_DEBUG_FG_CYAN", "fg-cyan"},
 736     {C_ENUM (GST_DEBUG_FG_WHITE), "GST_DEBUG_FG_WHITE", "fg-white"},
 737     {C_ENUM (GST_DEBUG_BG_BLACK), "GST_DEBUG_BG_BLACK", "bg-black"},
 738     {C_ENUM (GST_DEBUG_BG_RED), "GST_DEBUG_BG_RED", "bg-red"},
 739     {C_ENUM (GST_DEBUG_BG_GREEN), "GST_DEBUG_BG_GREEN", "bg-green"},
 740     {C_ENUM (GST_DEBUG_BG_YELLOW), "GST_DEBUG_BG_YELLOW", "bg-yellow"},
 741     {C_ENUM (GST_DEBUG_BG_BLUE), "GST_DEBUG_BG_BLUE", "bg-blue"},
 742     {C_ENUM (GST_DEBUG_BG_MAGENTA), "GST_DEBUG_BG_MAGENTA", "bg-magenta"},
 743     {C_ENUM (GST_DEBUG_BG_CYAN), "GST_DEBUG_BG_CYAN", "bg-cyan"},
 744     {C_ENUM (GST_DEBUG_BG_WHITE), "GST_DEBUG_BG_WHITE", "bg-white"},
 745     {C_ENUM (GST_DEBUG_BOLD), "GST_DEBUG_BOLD", "bold"},
 746     {C_ENUM (GST_DEBUG_UNDERLINE), "GST_DEBUG_UNDERLINE", "underline"},
 747     {0, NULL, NULL}
 748   };
 749
 750   if (g_once_init_enter (&id)) {
 751     GType tmp = g_enum_register_static ("GstDebugColorFlags", values);
 752     g_once_init_leave (&id, tmp);
 753   }
 754
 755   return (GType) id;
 756 }
 757
 758 GType
 759 gst_debug_color_mode_get_type (void)
 760 {
 761   static gsize id = 0;
 762   static const GEnumValue values[] = {
 763     {C_ENUM (GST_DEBUG_COLOR_MODE_OFF), "GST_DEBUG_COLOR_MODE_OFF", "off"},
 764     {C_ENUM (GST_DEBUG_COLOR_MODE_ON), "GST_DEBUG_COLOR_MODE_ON", "on"},
 765     {C_ENUM (GST_DEBUG_COLOR_MODE_UNIX), "GST_DEBUG_COLOR_MODE_UNIX", "unix"},
 766     {0, NULL, NULL}
 767   };
 768
 769   if (g_once_init_enter (&id)) {
 770     GType tmp = g_enum_register_static ("GstDebugColorMode", values);
 771     g_once_init_leave (&id, tmp);
 772   }
 773
 774   return (GType) id;
 775 }
 776
 777 /* enumerations from "gstiterator.h" */
 778 GType
 779 gst_iterator_result_get_type (void)
 780 {
 781   static gsize id = 0;
 782   static const GEnumValue values[] = {
 783     {C_ENUM (GST_ITERATOR_DONE), "GST_ITERATOR_DONE", "done"},
 784     {C_ENUM (GST_ITERATOR_OK), "GST_ITERATOR_OK", "ok"},
 785     {C_ENUM (GST_ITERATOR_RESYNC), "GST_ITERATOR_RESYNC", "resync"},
 786     {C_ENUM (GST_ITERATOR_ERROR), "GST_ITERATOR_ERROR", "error"},
 787     {0, NULL, NULL}
 788   };
 789
 790   if (g_once_init_enter (&id)) {
 791     GType tmp = g_enum_register_static ("GstIteratorResult", values);
 792     g_once_init_leave (&id, tmp);
 793   }
 794
 795   return (GType) id;
 796 }
 797
 798 GType
 799 gst_iterator_item_get_type (void)
 800 {
 801   static gsize id = 0;
 802   static const GEnumValue values[] = {
 803     {C_ENUM (GST_ITERATOR_ITEM_SKIP), "GST_ITERATOR_ITEM_SKIP", "skip"},
 804     {C_ENUM (GST_ITERATOR_ITEM_PASS), "GST_ITERATOR_ITEM_PASS", "pass"},
 805     {C_ENUM (GST_ITERATOR_ITEM_END), "GST_ITERATOR_ITEM_END", "end"},
 806     {0, NULL, NULL}
 807   };
 808
 809   if (g_once_init_enter (&id)) {
 810     GType tmp = g_enum_register_static ("GstIteratorItem", values);
 811     g_once_init_leave (&id, tmp);
 812   }
 813
 814   return (GType) id;
 815 }
 816
 817 /* enumerations from "gstmessage.h" */
 818 GType
 819 gst_message_type_get_type (void)
 820 {
 821   static gsize id = 0;
 822   static const GFlagsValue values[] = {
 823     {C_FLAGS (GST_MESSAGE_UNKNOWN), "GST_MESSAGE_UNKNOWN", "unknown"},
 824     {C_FLAGS (GST_MESSAGE_EOS), "GST_MESSAGE_EOS", "eos"},
 825     {C_FLAGS (GST_MESSAGE_ERROR), "GST_MESSAGE_ERROR", "error"},
 826     {C_FLAGS (GST_MESSAGE_WARNING), "GST_MESSAGE_WARNING", "warning"},
 827     {C_FLAGS (GST_MESSAGE_INFO), "GST_MESSAGE_INFO", "info"},
 828     {C_FLAGS (GST_MESSAGE_TAG), "GST_MESSAGE_TAG", "tag"},
 829     {C_FLAGS (GST_MESSAGE_BUFFERING), "GST_MESSAGE_BUFFERING", "buffering"},
 830     {C_FLAGS (GST_MESSAGE_STATE_CHANGED), "GST_MESSAGE_STATE_CHANGED",
 831         "state-changed"},
 832     {C_FLAGS (GST_MESSAGE_STATE_DIRTY), "GST_MESSAGE_STATE_DIRTY",
 833         "state-dirty"},
 834     {C_FLAGS (GST_MESSAGE_STEP_DONE), "GST_MESSAGE_STEP_DONE", "step-done"},
 835     {C_FLAGS (GST_MESSAGE_CLOCK_PROVIDE), "GST_MESSAGE_CLOCK_PROVIDE",
 836         "clock-provide"},
 837     {C_FLAGS (GST_MESSAGE_CLOCK_LOST), "GST_MESSAGE_CLOCK_LOST", "clock-lost"},
 838     {C_FLAGS (GST_MESSAGE_NEW_CLOCK), "GST_MESSAGE_NEW_CLOCK", "new-clock"},
 839     {C_FLAGS (GST_MESSAGE_STRUCTURE_CHANGE), "GST_MESSAGE_STRUCTURE_CHANGE",
 840         "structure-change"},
 841     {C_FLAGS (GST_MESSAGE_STREAM_STATUS), "GST_MESSAGE_STREAM_STATUS",
 842         "stream-status"},
 843     {C_FLAGS (GST_MESSAGE_APPLICATION), "GST_MESSAGE_APPLICATION",
 844         "application"},
 845     {C_FLAGS (GST_MESSAGE_ELEMENT), "GST_MESSAGE_ELEMENT", "element"},
 846     {C_FLAGS (GST_MESSAGE_SEGMENT_START), "GST_MESSAGE_SEGMENT_START",
 847         "segment-start"},
 848     {C_FLAGS (GST_MESSAGE_SEGMENT_DONE), "GST_MESSAGE_SEGMENT_DONE",
 849         "segment-done"},
 850     {C_FLAGS (GST_MESSAGE_DURATION_CHANGED), "GST_MESSAGE_DURATION_CHANGED",
 851         "duration-changed"},
 852     {C_FLAGS (GST_MESSAGE_LATENCY), "GST_MESSAGE_LATENCY", "latency"},
 853     {C_FLAGS (GST_MESSAGE_ASYNC_START), "GST_MESSAGE_ASYNC_START",
 854         "async-start"},
 855     {C_FLAGS (GST_MESSAGE_ASYNC_DONE), "GST_MESSAGE_ASYNC_DONE", "async-done"},
 856     {C_FLAGS (GST_MESSAGE_REQUEST_STATE), "GST_MESSAGE_REQUEST_STATE",
 857         "request-state"},
 858     {C_FLAGS (GST_MESSAGE_STEP_START), "GST_MESSAGE_STEP_START", "step-start"},
 859     {C_FLAGS (GST_MESSAGE_QOS), "GST_MESSAGE_QOS", "qos"},
 860     {C_FLAGS (GST_MESSAGE_PROGRESS), "GST_MESSAGE_PROGRESS", "progress"},
 861     {C_FLAGS (GST_MESSAGE_TOC), "GST_MESSAGE_TOC", "toc"},
 862     {C_FLAGS (GST_MESSAGE_RESET_TIME), "GST_MESSAGE_RESET_TIME", "reset-time"},
 863     {C_FLAGS (GST_MESSAGE_STREAM_START), "GST_MESSAGE_STREAM_START",
 864         "stream-start"},
 865     {C_FLAGS (GST_MESSAGE_NEED_CONTEXT), "GST_MESSAGE_NEED_CONTEXT",
 866         "need-context"},
 867     {C_FLAGS (GST_MESSAGE_HAVE_CONTEXT), "GST_MESSAGE_HAVE_CONTEXT",
 868         "have-context"},
 869     {C_FLAGS (GST_MESSAGE_ANY), "GST_MESSAGE_ANY", "any"},
 870     {0, NULL, NULL}
 871   };
 872
 873   if (g_once_init_enter (&id)) {
 874     GType tmp = g_flags_register_static ("GstMessageType", values);
 875     g_once_init_leave (&id, tmp);
 876   }
 877
 878   return (GType) id;
 879 }
 880
 881 GType
 882 gst_structure_change_type_get_type (void)
 883 {
 884   static gsize id = 0;
 885   static const GEnumValue values[] = {
 886     {C_ENUM (GST_STRUCTURE_CHANGE_TYPE_PAD_LINK),
 887         "GST_STRUCTURE_CHANGE_TYPE_PAD_LINK", "link"},
 888     {C_ENUM (GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK),
 889         "GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK", "unlink"},
 890     {0, NULL, NULL}
 891   };
 892
 893   if (g_once_init_enter (&id)) {
 894     GType tmp = g_enum_register_static ("GstStructureChangeType", values);
 895     g_once_init_leave (&id, tmp);
 896   }
 897
 898   return (GType) id;
 899 }
 900
 901 GType
 902 gst_stream_status_type_get_type (void)
 903 {
 904   static gsize id = 0;
 905   static const GEnumValue values[] = {
 906     {C_ENUM (GST_STREAM_STATUS_TYPE_CREATE), "GST_STREAM_STATUS_TYPE_CREATE",
 907         "create"},
 908     {C_ENUM (GST_STREAM_STATUS_TYPE_ENTER), "GST_STREAM_STATUS_TYPE_ENTER",
 909         "enter"},
 910     {C_ENUM (GST_STREAM_STATUS_TYPE_LEAVE), "GST_STREAM_STATUS_TYPE_LEAVE",
 911         "leave"},
 912     {C_ENUM (GST_STREAM_STATUS_TYPE_DESTROY), "GST_STREAM_STATUS_TYPE_DESTROY",
 913         "destroy"},
 914     {C_ENUM (GST_STREAM_STATUS_TYPE_START), "GST_STREAM_STATUS_TYPE_START",
 915         "start"},
 916     {C_ENUM (GST_STREAM_STATUS_TYPE_PAUSE), "GST_STREAM_STATUS_TYPE_PAUSE",
 917         "pause"},
 918     {C_ENUM (GST_STREAM_STATUS_TYPE_STOP), "GST_STREAM_STATUS_TYPE_STOP",
 919         "stop"},
 920     {0, NULL, NULL}
 921   };
 922
 923   if (g_once_init_enter (&id)) {
 924     GType tmp = g_enum_register_static ("GstStreamStatusType", values);
 925     g_once_init_leave (&id, tmp);
 926   }
 927
 928   return (GType) id;
 929 }
 930
 931 GType
 932 gst_progress_type_get_type (void)
 933 {
 934   static gsize id = 0;
 935   static const GEnumValue values[] = {
 936     {C_ENUM (GST_PROGRESS_TYPE_START), "GST_PROGRESS_TYPE_START", "start"},
 937     {C_ENUM (GST_PROGRESS_TYPE_CONTINUE), "GST_PROGRESS_TYPE_CONTINUE",
 938         "continue"},
 939     {C_ENUM (GST_PROGRESS_TYPE_COMPLETE), "GST_PROGRESS_TYPE_COMPLETE",
 940         "complete"},
 941     {C_ENUM (GST_PROGRESS_TYPE_CANCELED), "GST_PROGRESS_TYPE_CANCELED",
 942         "canceled"},
 943     {C_ENUM (GST_PROGRESS_TYPE_ERROR), "GST_PROGRESS_TYPE_ERROR", "error"},
 944     {0, NULL, NULL}
 945   };
 946
 947   if (g_once_init_enter (&id)) {
 948     GType tmp = g_enum_register_static ("GstProgressType", values);
 949     g_once_init_leave (&id, tmp);
 950   }
 951
 952   return (GType) id;
 953 }
 954
 955 /* enumerations from "gstmeta.h" */
 956 GType
 957 gst_meta_flags_get_type (void)
 958 {
 959   static gsize id = 0;
 960   static const GFlagsValue values[] = {
 961     {C_FLAGS (GST_META_FLAG_NONE), "GST_META_FLAG_NONE", "none"},
 962     {C_FLAGS (GST_META_FLAG_READONLY), "GST_META_FLAG_READONLY", "readonly"},
 963     {C_FLAGS (GST_META_FLAG_POOLED), "GST_META_FLAG_POOLED", "pooled"},
 964     {C_FLAGS (GST_META_FLAG_LOCKED), "GST_META_FLAG_LOCKED", "locked"},
 965     {C_FLAGS (GST_META_FLAG_LAST), "GST_META_FLAG_LAST", "last"},
 966     {0, NULL, NULL}
 967   };
 968
 969   if (g_once_init_enter (&id)) {
 970     GType tmp = g_flags_register_static ("GstMetaFlags", values);
 971     g_once_init_leave (&id, tmp);
 972   }
 973
 974   return (GType) id;
 975 }
 976
 977 /* enumerations from "gstmemory.h" */
 978 GType
 979 gst_memory_flags_get_type (void)
 980 {
 981   static gsize id = 0;
 982   static const GFlagsValue values[] = {
 983     {C_FLAGS (GST_MEMORY_FLAG_READONLY), "GST_MEMORY_FLAG_READONLY",
 984         "readonly"},
 985     {C_FLAGS (GST_MEMORY_FLAG_NO_SHARE), "GST_MEMORY_FLAG_NO_SHARE",
 986         "no-share"},
 987     {C_FLAGS (GST_MEMORY_FLAG_ZERO_PREFIXED), "GST_MEMORY_FLAG_ZERO_PREFIXED",
 988         "zero-prefixed"},
 989     {C_FLAGS (GST_MEMORY_FLAG_ZERO_PADDED), "GST_MEMORY_FLAG_ZERO_PADDED",
 990         "zero-padded"},
 991     {C_FLAGS (GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS),
 992         "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS", "physically-contiguous"},
 993     {C_FLAGS (GST_MEMORY_FLAG_NOT_MAPPABLE), "GST_MEMORY_FLAG_NOT_MAPPABLE",
 994         "not-mappable"},
 995     {C_FLAGS (GST_MEMORY_FLAG_LAST), "GST_MEMORY_FLAG_LAST", "last"},
 996     {0, NULL, NULL}
 997   };
 998
 999   if (g_once_init_enter (&id)) {
1000     GType tmp = g_flags_register_static ("GstMemoryFlags", values);
1001     g_once_init_leave (&id, tmp);
1002   }
1003
1004   return (GType) id;
1005 }
1006
1007 GType
1008 gst_map_flags_get_type (void)
1009 {
1010   static gsize id = 0;
1011   static const GFlagsValue values[] = {
1012     {C_FLAGS (GST_MAP_READ), "GST_MAP_READ", "read"},
1013     {C_FLAGS (GST_MAP_WRITE), "GST_MAP_WRITE", "write"},
1014     {C_FLAGS (GST_MAP_FLAG_LAST), "GST_MAP_FLAG_LAST", "flag-last"},
1015     {0, NULL, NULL}
1016   };
1017
1018   if (g_once_init_enter (&id)) {
1019     GType tmp = g_flags_register_static ("GstMapFlags", values);
1020     g_once_init_leave (&id, tmp);
1021   }
1022
1023   return (GType) id;
1024 }
1025
1026 /* enumerations from "gstminiobject.h" */
1027 GType
1028 gst_mini_object_flags_get_type (void)
1029 {
1030   static gsize id = 0;
1031   static const GFlagsValue values[] = {
1032     {C_FLAGS (GST_MINI_OBJECT_FLAG_LOCKABLE), "GST_MINI_OBJECT_FLAG_LOCKABLE",
1033         "lockable"},
1034     {C_FLAGS (GST_MINI_OBJECT_FLAG_LOCK_READONLY),
1035         "GST_MINI_OBJECT_FLAG_LOCK_READONLY", "lock-readonly"},
1036     {C_FLAGS (GST_MINI_OBJECT_FLAG_LAST), "GST_MINI_OBJECT_FLAG_LAST", "last"},
1037     {0, NULL, NULL}
1038   };
1039
1040   if (g_once_init_enter (&id)) {
1041     GType tmp = g_flags_register_static ("GstMiniObjectFlags", values);
1042     g_once_init_leave (&id, tmp);
1043   }
1044
1045   return (GType) id;
1046 }
1047
1048 GType
1049 gst_lock_flags_get_type (void)
1050 {
1051   static gsize id = 0;
1052   static const GFlagsValue values[] = {
1053     {C_FLAGS (GST_LOCK_FLAG_READ), "GST_LOCK_FLAG_READ", "read"},
1054     {C_FLAGS (GST_LOCK_FLAG_WRITE), "GST_LOCK_FLAG_WRITE", "write"},
1055     {C_FLAGS (GST_LOCK_FLAG_EXCLUSIVE), "GST_LOCK_FLAG_EXCLUSIVE", "exclusive"},
1056     {C_FLAGS (GST_LOCK_FLAG_LAST), "GST_LOCK_FLAG_LAST", "last"},
1057     {0, NULL, NULL}
1058   };
1059
1060   if (g_once_init_enter (&id)) {
1061     GType tmp = g_flags_register_static ("GstLockFlags", values);
1062     g_once_init_leave (&id, tmp);
1063   }
1064
1065   return (GType) id;
1066 }
1067
1068 /* enumerations from "gstpad.h" */
1069 GType
1070 gst_pad_direction_get_type (void)
1071 {
1072   static gsize id = 0;
1073   static const GEnumValue values[] = {
1074     {C_ENUM (GST_PAD_UNKNOWN), "GST_PAD_UNKNOWN", "unknown"},
1075     {C_ENUM (GST_PAD_SRC), "GST_PAD_SRC", "src"},
1076     {C_ENUM (GST_PAD_SINK), "GST_PAD_SINK", "sink"},
1077     {0, NULL, NULL}
1078   };
1079
1080   if (g_once_init_enter (&id)) {
1081     GType tmp = g_enum_register_static ("GstPadDirection", values);
1082     g_once_init_leave (&id, tmp);
1083   }
1084
1085   return (GType) id;
1086 }
1087
1088 GType
1089 gst_pad_mode_get_type (void)
1090 {
1091   static gsize id = 0;
1092   static const GEnumValue values[] = {
1093     {C_ENUM (GST_PAD_MODE_NONE), "GST_PAD_MODE_NONE", "none"},
1094     {C_ENUM (GST_PAD_MODE_PUSH), "GST_PAD_MODE_PUSH", "push"},
1095     {C_ENUM (GST_PAD_MODE_PULL), "GST_PAD_MODE_PULL", "pull"},
1096     {0, NULL, NULL}
1097   };
1098
1099   if (g_once_init_enter (&id)) {
1100     GType tmp = g_enum_register_static ("GstPadMode", values);
1101     g_once_init_leave (&id, tmp);
1102   }
1103
1104   return (GType) id;
1105 }
1106
1107 GType
1108 gst_pad_link_return_get_type (void)
1109 {
1110   static gsize id = 0;
1111   static const GEnumValue values[] = {
1112     {C_ENUM (GST_PAD_LINK_OK), "GST_PAD_LINK_OK", "ok"},
1113     {C_ENUM (GST_PAD_LINK_WRONG_HIERARCHY), "GST_PAD_LINK_WRONG_HIERARCHY",
1114         "wrong-hierarchy"},
1115     {C_ENUM (GST_PAD_LINK_WAS_LINKED), "GST_PAD_LINK_WAS_LINKED", "was-linked"},
1116     {C_ENUM (GST_PAD_LINK_WRONG_DIRECTION), "GST_PAD_LINK_WRONG_DIRECTION",
1117         "wrong-direction"},
1118     {C_ENUM (GST_PAD_LINK_NOFORMAT), "GST_PAD_LINK_NOFORMAT", "noformat"},
1119     {C_ENUM (GST_PAD_LINK_NOSCHED), "GST_PAD_LINK_NOSCHED", "nosched"},
1120     {C_ENUM (GST_PAD_LINK_REFUSED), "GST_PAD_LINK_REFUSED", "refused"},
1121     {0, NULL, NULL}
1122   };
1123
1124   if (g_once_init_enter (&id)) {
1125     GType tmp = g_enum_register_static ("GstPadLinkReturn", values);
1126     g_once_init_leave (&id, tmp);
1127   }
1128
1129   return (GType) id;
1130 }
1131
1132 GType
1133 gst_flow_return_get_type (void)
1134 {
1135   static gsize id = 0;
1136   static const GEnumValue values[] = {
1137     {C_ENUM (GST_FLOW_CUSTOM_SUCCESS_2), "GST_FLOW_CUSTOM_SUCCESS_2",
1138         "custom-success-2"},
1139     {C_ENUM (GST_FLOW_CUSTOM_SUCCESS_1), "GST_FLOW_CUSTOM_SUCCESS_1",
1140         "custom-success-1"},
1141     {C_ENUM (GST_FLOW_CUSTOM_SUCCESS), "GST_FLOW_CUSTOM_SUCCESS",
1142         "custom-success"},
1143     {C_ENUM (GST_FLOW_OK), "GST_FLOW_OK", "ok"},
1144     {C_ENUM (GST_FLOW_NOT_LINKED), "GST_FLOW_NOT_LINKED", "not-linked"},
1145     {C_ENUM (GST_FLOW_FLUSHING), "GST_FLOW_FLUSHING", "flushing"},
1146     {C_ENUM (GST_FLOW_EOS), "GST_FLOW_EOS", "eos"},
1147     {C_ENUM (GST_FLOW_NOT_NEGOTIATED), "GST_FLOW_NOT_NEGOTIATED",
1148         "not-negotiated"},
1149     {C_ENUM (GST_FLOW_ERROR), "GST_FLOW_ERROR", "error"},
1150     {C_ENUM (GST_FLOW_NOT_SUPPORTED), "GST_FLOW_NOT_SUPPORTED",
1151         "not-supported"},
1152     {C_ENUM (GST_FLOW_CUSTOM_ERROR), "GST_FLOW_CUSTOM_ERROR", "custom-error"},
1153     {C_ENUM (GST_FLOW_CUSTOM_ERROR_1), "GST_FLOW_CUSTOM_ERROR_1",
1154         "custom-error-1"},
1155     {C_ENUM (GST_FLOW_CUSTOM_ERROR_2), "GST_FLOW_CUSTOM_ERROR_2",
1156         "custom-error-2"},
1157     {0, NULL, NULL}
1158   };
1159
1160   if (g_once_init_enter (&id)) {
1161     GType tmp = g_enum_register_static ("GstFlowReturn", values);
1162     g_once_init_leave (&id, tmp);
1163   }
1164
1165   return (GType) id;
1166 }
1167
1168 GType
1169 gst_pad_link_check_get_type (void)
1170 {
1171   static gsize id = 0;
1172   static const GFlagsValue values[] = {
1173     {C_FLAGS (GST_PAD_LINK_CHECK_NOTHING), "GST_PAD_LINK_CHECK_NOTHING",
1174         "nothing"},
1175     {C_FLAGS (GST_PAD_LINK_CHECK_HIERARCHY), "GST_PAD_LINK_CHECK_HIERARCHY",
1176         "hierarchy"},
1177     {C_FLAGS (GST_PAD_LINK_CHECK_TEMPLATE_CAPS),
1178         "GST_PAD_LINK_CHECK_TEMPLATE_CAPS", "template-caps"},
1179     {C_FLAGS (GST_PAD_LINK_CHECK_CAPS), "GST_PAD_LINK_CHECK_CAPS", "caps"},
1180     {C_FLAGS (GST_PAD_LINK_CHECK_DEFAULT), "GST_PAD_LINK_CHECK_DEFAULT",
1181         "default"},
1182     {0, NULL, NULL}
1183   };
1184
1185   if (g_once_init_enter (&id)) {
1186     GType tmp = g_flags_register_static ("GstPadLinkCheck", values);
1187     g_once_init_leave (&id, tmp);
1188   }
1189
1190   return (GType) id;
1191 }
1192
1193 GType
1194 gst_pad_probe_type_get_type (void)
1195 {
1196   static gsize id = 0;
1197   static const GFlagsValue values[] = {
1198     {C_FLAGS (GST_PAD_PROBE_TYPE_INVALID), "GST_PAD_PROBE_TYPE_INVALID",
1199         "invalid"},
1200     {C_FLAGS (GST_PAD_PROBE_TYPE_IDLE), "GST_PAD_PROBE_TYPE_IDLE", "idle"},
1201     {C_FLAGS (GST_PAD_PROBE_TYPE_BLOCK), "GST_PAD_PROBE_TYPE_BLOCK", "block"},
1202     {C_FLAGS (GST_PAD_PROBE_TYPE_BUFFER), "GST_PAD_PROBE_TYPE_BUFFER",
1203         "buffer"},
1204     {C_FLAGS (GST_PAD_PROBE_TYPE_BUFFER_LIST), "GST_PAD_PROBE_TYPE_BUFFER_LIST",
1205         "buffer-list"},
1206     {C_FLAGS (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM),
1207         "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM", "event-downstream"},
1208     {C_FLAGS (GST_PAD_PROBE_TYPE_EVENT_UPSTREAM),
1209         "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM", "event-upstream"},
1210     {C_FLAGS (GST_PAD_PROBE_TYPE_EVENT_FLUSH), "GST_PAD_PROBE_TYPE_EVENT_FLUSH",
1211         "event-flush"},
1212     {C_FLAGS (GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM),
1213         "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM", "query-downstream"},
1214     {C_FLAGS (GST_PAD_PROBE_TYPE_QUERY_UPSTREAM),
1215         "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM", "query-upstream"},
1216     {C_FLAGS (GST_PAD_PROBE_TYPE_PUSH), "GST_PAD_PROBE_TYPE_PUSH", "push"},
1217     {C_FLAGS (GST_PAD_PROBE_TYPE_PULL), "GST_PAD_PROBE_TYPE_PULL", "pull"},
1218     {C_FLAGS (GST_PAD_PROBE_TYPE_BLOCKING), "GST_PAD_PROBE_TYPE_BLOCKING",
1219         "blocking"},
1220     {C_FLAGS (GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM),
1221         "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM", "data-downstream"},
1222     {C_FLAGS (GST_PAD_PROBE_TYPE_DATA_UPSTREAM),
1223         "GST_PAD_PROBE_TYPE_DATA_UPSTREAM", "data-upstream"},
1224     {C_FLAGS (GST_PAD_PROBE_TYPE_DATA_BOTH), "GST_PAD_PROBE_TYPE_DATA_BOTH",
1225         "data-both"},
1226     {C_FLAGS (GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM),
1227         "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM", "block-downstream"},
1228     {C_FLAGS (GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM),
1229         "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM", "block-upstream"},
1230     {C_FLAGS (GST_PAD_PROBE_TYPE_EVENT_BOTH), "GST_PAD_PROBE_TYPE_EVENT_BOTH",
1231         "event-both"},
1232     {C_FLAGS (GST_PAD_PROBE_TYPE_QUERY_BOTH), "GST_PAD_PROBE_TYPE_QUERY_BOTH",
1233         "query-both"},
1234     {C_FLAGS (GST_PAD_PROBE_TYPE_ALL_BOTH), "GST_PAD_PROBE_TYPE_ALL_BOTH",
1235         "all-both"},
1236     {C_FLAGS (GST_PAD_PROBE_TYPE_SCHEDULING), "GST_PAD_PROBE_TYPE_SCHEDULING",
1237         "scheduling"},
1238     {0, NULL, NULL}
1239   };
1240
1241   if (g_once_init_enter (&id)) {
1242     GType tmp = g_flags_register_static ("GstPadProbeType", values);
1243     g_once_init_leave (&id, tmp);
1244   }
1245
1246   return (GType) id;
1247 }
1248
1249 GType
1250 gst_pad_probe_return_get_type (void)
1251 {
1252   static gsize id = 0;
1253   static const GEnumValue values[] = {
1254     {C_ENUM (GST_PAD_PROBE_DROP), "GST_PAD_PROBE_DROP", "drop"},
1255     {C_ENUM (GST_PAD_PROBE_OK), "GST_PAD_PROBE_OK", "ok"},
1256     {C_ENUM (GST_PAD_PROBE_REMOVE), "GST_PAD_PROBE_REMOVE", "remove"},
1257     {C_ENUM (GST_PAD_PROBE_PASS), "GST_PAD_PROBE_PASS", "pass"},
1258     {0, NULL, NULL}
1259   };
1260
1261   if (g_once_init_enter (&id)) {
1262     GType tmp = g_enum_register_static ("GstPadProbeReturn", values);
1263     g_once_init_leave (&id, tmp);
1264   }
1265
1266   return (GType) id;
1267 }
1268
1269 GType
1270 gst_pad_flags_get_type (void)
1271 {
1272   static gsize id = 0;
1273   static const GFlagsValue values[] = {
1274     {C_FLAGS (GST_PAD_FLAG_BLOCKED), "GST_PAD_FLAG_BLOCKED", "blocked"},
1275     {C_FLAGS (GST_PAD_FLAG_FLUSHING), "GST_PAD_FLAG_FLUSHING", "flushing"},
1276     {C_FLAGS (GST_PAD_FLAG_EOS), "GST_PAD_FLAG_EOS", "eos"},
1277     {C_FLAGS (GST_PAD_FLAG_BLOCKING), "GST_PAD_FLAG_BLOCKING", "blocking"},
1278     {C_FLAGS (GST_PAD_FLAG_NEED_PARENT), "GST_PAD_FLAG_NEED_PARENT",
1279         "need-parent"},
1280     {C_FLAGS (GST_PAD_FLAG_NEED_RECONFIGURE), "GST_PAD_FLAG_NEED_RECONFIGURE",
1281         "need-reconfigure"},
1282     {C_FLAGS (GST_PAD_FLAG_PENDING_EVENTS), "GST_PAD_FLAG_PENDING_EVENTS",
1283         "pending-events"},
1284     {C_FLAGS (GST_PAD_FLAG_FIXED_CAPS), "GST_PAD_FLAG_FIXED_CAPS",
1285         "fixed-caps"},
1286     {C_FLAGS (GST_PAD_FLAG_PROXY_CAPS), "GST_PAD_FLAG_PROXY_CAPS",
1287         "proxy-caps"},
1288     {C_FLAGS (GST_PAD_FLAG_PROXY_ALLOCATION), "GST_PAD_FLAG_PROXY_ALLOCATION",
1289         "proxy-allocation"},
1290     {C_FLAGS (GST_PAD_FLAG_PROXY_SCHEDULING), "GST_PAD_FLAG_PROXY_SCHEDULING",
1291         "proxy-scheduling"},
1292     {C_FLAGS (GST_PAD_FLAG_LAST), "GST_PAD_FLAG_LAST", "last"},
1293     {0, NULL, NULL}
1294   };
1295
1296   if (g_once_init_enter (&id)) {
1297     GType tmp = g_flags_register_static ("GstPadFlags", values);
1298     g_once_init_leave (&id, tmp);
1299   }
1300
1301   return (GType) id;
1302 }
1303
1304 /* enumerations from "gstpadtemplate.h" */
1305 GType
1306 gst_pad_presence_get_type (void)
1307 {
1308   static gsize id = 0;
1309   static const GEnumValue values[] = {
1310     {C_ENUM (GST_PAD_ALWAYS), "GST_PAD_ALWAYS", "always"},
1311     {C_ENUM (GST_PAD_SOMETIMES), "GST_PAD_SOMETIMES", "sometimes"},
1312     {C_ENUM (GST_PAD_REQUEST), "GST_PAD_REQUEST", "request"},
1313     {0, NULL, NULL}
1314   };
1315
1316   if (g_once_init_enter (&id)) {
1317     GType tmp = g_enum_register_static ("GstPadPresence", values);
1318     g_once_init_leave (&id, tmp);
1319   }
1320
1321   return (GType) id;
1322 }
1323
1324 GType
1325 gst_pad_template_flags_get_type (void)
1326 {
1327   static gsize id = 0;
1328   static const GFlagsValue values[] = {
1329     {C_FLAGS (GST_PAD_TEMPLATE_FLAG_LAST), "GST_PAD_TEMPLATE_FLAG_LAST",
1330         "last"},
1331     {0, NULL, NULL}
1332   };
1333
1334   if (g_once_init_enter (&id)) {
1335     GType tmp = g_flags_register_static ("GstPadTemplateFlags", values);
1336     g_once_init_leave (&id, tmp);
1337   }
1338
1339   return (GType) id;
1340 }
1341
1342 /* enumerations from "gstpipeline.h" */
1343 GType
1344 gst_pipeline_flags_get_type (void)
1345 {
1346   static gsize id = 0;
1347   static const GFlagsValue values[] = {
1348     {C_FLAGS (GST_PIPELINE_FLAG_FIXED_CLOCK), "GST_PIPELINE_FLAG_FIXED_CLOCK",
1349         "fixed-clock"},
1350     {C_FLAGS (GST_PIPELINE_FLAG_LAST), "GST_PIPELINE_FLAG_LAST", "last"},
1351     {0, NULL, NULL}
1352   };
1353
1354   if (g_once_init_enter (&id)) {
1355     GType tmp = g_flags_register_static ("GstPipelineFlags", values);
1356     g_once_init_leave (&id, tmp);
1357   }
1358
1359   return (GType) id;
1360 }
1361
1362 /* enumerations from "gstplugin.h" */
1363 GType
1364 gst_plugin_error_get_type (void)
1365 {
1366   static gsize id = 0;
1367   static const GEnumValue values[] = {
1368     {C_ENUM (GST_PLUGIN_ERROR_MODULE), "GST_PLUGIN_ERROR_MODULE", "module"},
1369     {C_ENUM (GST_PLUGIN_ERROR_DEPENDENCIES), "GST_PLUGIN_ERROR_DEPENDENCIES",
1370         "dependencies"},
1371     {C_ENUM (GST_PLUGIN_ERROR_NAME_MISMATCH), "GST_PLUGIN_ERROR_NAME_MISMATCH",
1372         "name-mismatch"},
1373     {0, NULL, NULL}
1374   };
1375
1376   if (g_once_init_enter (&id)) {
1377     GType tmp = g_enum_register_static ("GstPluginError", values);
1378     g_once_init_leave (&id, tmp);
1379   }
1380
1381   return (GType) id;
1382 }
1383
1384 GType
1385 gst_plugin_flags_get_type (void)
1386 {
1387   static gsize id = 0;
1388   static const GFlagsValue values[] = {
1389     {C_FLAGS (GST_PLUGIN_FLAG_CACHED), "GST_PLUGIN_FLAG_CACHED", "cached"},
1390     {C_FLAGS (GST_PLUGIN_FLAG_BLACKLISTED), "GST_PLUGIN_FLAG_BLACKLISTED",
1391         "blacklisted"},
1392     {0, NULL, NULL}
1393   };
1394
1395   if (g_once_init_enter (&id)) {
1396     GType tmp = g_flags_register_static ("GstPluginFlags", values);
1397     g_once_init_leave (&id, tmp);
1398   }
1399
1400   return (GType) id;
1401 }
1402
1403 GType
1404 gst_plugin_dependency_flags_get_type (void)
1405 {
1406   static gsize id = 0;
1407   static const GFlagsValue values[] = {
1408     {C_FLAGS (GST_PLUGIN_DEPENDENCY_FLAG_NONE),
1409         "GST_PLUGIN_DEPENDENCY_FLAG_NONE", "none"},
1410     {C_FLAGS (GST_PLUGIN_DEPENDENCY_FLAG_RECURSE),
1411         "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE", "recurse"},
1412     {C_FLAGS (GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY),
1413           "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY",
1414         "paths-are-default-only"},
1415     {C_FLAGS (GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX),
1416           "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX",
1417         "file-name-is-suffix"},
1418     {0, NULL, NULL}
1419   };
1420
1421   if (g_once_init_enter (&id)) {
1422     GType tmp = g_flags_register_static ("GstPluginDependencyFlags", values);
1423     g_once_init_leave (&id, tmp);
1424   }
1425
1426   return (GType) id;
1427 }
1428
1429 /* enumerations from "gstpluginfeature.h" */
1430 GType
1431 gst_rank_get_type (void)
1432 {
1433   static gsize id = 0;
1434   static const GEnumValue values[] = {
1435     {C_ENUM (GST_RANK_NONE), "GST_RANK_NONE", "none"},
1436     {C_ENUM (GST_RANK_MARGINAL), "GST_RANK_MARGINAL", "marginal"},
1437     {C_ENUM (GST_RANK_SECONDARY), "GST_RANK_SECONDARY", "secondary"},
1438     {C_ENUM (GST_RANK_PRIMARY), "GST_RANK_PRIMARY", "primary"},
1439     {0, NULL, NULL}
1440   };
1441
1442   if (g_once_init_enter (&id)) {
1443     GType tmp = g_enum_register_static ("GstRank", values);
1444     g_once_init_leave (&id, tmp);
1445   }
1446
1447   return (GType) id;
1448 }
1449
1450 /* enumerations from "gstquery.h" */
1451 GType
1452 gst_query_type_flags_get_type (void)
1453 {
1454   static gsize id = 0;
1455   static const GFlagsValue values[] = {
1456     {C_FLAGS (GST_QUERY_TYPE_UPSTREAM), "GST_QUERY_TYPE_UPSTREAM", "upstream"},
1457     {C_FLAGS (GST_QUERY_TYPE_DOWNSTREAM), "GST_QUERY_TYPE_DOWNSTREAM",
1458         "downstream"},
1459     {C_FLAGS (GST_QUERY_TYPE_SERIALIZED), "GST_QUERY_TYPE_SERIALIZED",
1460         "serialized"},
1461     {0, NULL, NULL}
1462   };
1463
1464   if (g_once_init_enter (&id)) {
1465     GType tmp = g_flags_register_static ("GstQueryTypeFlags", values);
1466     g_once_init_leave (&id, tmp);
1467   }
1468
1469   return (GType) id;
1470 }
1471
1472 GType
1473 gst_query_type_get_type (void)
1474 {
1475   static gsize id = 0;
1476   static const GEnumValue values[] = {
1477     {C_ENUM (GST_QUERY_UNKNOWN), "GST_QUERY_UNKNOWN", "unknown"},
1478     {C_ENUM (GST_QUERY_POSITION), "GST_QUERY_POSITION", "position"},
1479     {C_ENUM (GST_QUERY_DURATION), "GST_QUERY_DURATION", "duration"},
1480     {C_ENUM (GST_QUERY_LATENCY), "GST_QUERY_LATENCY", "latency"},
1481     {C_ENUM (GST_QUERY_JITTER), "GST_QUERY_JITTER", "jitter"},
1482     {C_ENUM (GST_QUERY_RATE), "GST_QUERY_RATE", "rate"},
1483     {C_ENUM (GST_QUERY_SEEKING), "GST_QUERY_SEEKING", "seeking"},
1484     {C_ENUM (GST_QUERY_SEGMENT), "GST_QUERY_SEGMENT", "segment"},
1485     {C_ENUM (GST_QUERY_CONVERT), "GST_QUERY_CONVERT", "convert"},
1486     {C_ENUM (GST_QUERY_FORMATS), "GST_QUERY_FORMATS", "formats"},
1487     {C_ENUM (GST_QUERY_BUFFERING), "GST_QUERY_BUFFERING", "buffering"},
1488     {C_ENUM (GST_QUERY_CUSTOM), "GST_QUERY_CUSTOM", "custom"},
1489     {C_ENUM (GST_QUERY_URI), "GST_QUERY_URI", "uri"},
1490     {C_ENUM (GST_QUERY_ALLOCATION), "GST_QUERY_ALLOCATION", "allocation"},
1491     {C_ENUM (GST_QUERY_SCHEDULING), "GST_QUERY_SCHEDULING", "scheduling"},
1492     {C_ENUM (GST_QUERY_ACCEPT_CAPS), "GST_QUERY_ACCEPT_CAPS", "accept-caps"},
1493     {C_ENUM (GST_QUERY_CAPS), "GST_QUERY_CAPS", "caps"},
1494     {C_ENUM (GST_QUERY_DRAIN), "GST_QUERY_DRAIN", "drain"},
1495     {C_ENUM (GST_QUERY_CONTEXT), "GST_QUERY_CONTEXT", "context"},
1496     {0, NULL, NULL}
1497   };
1498
1499   if (g_once_init_enter (&id)) {
1500     GType tmp = g_enum_register_static ("GstQueryType", values);
1501     g_once_init_leave (&id, tmp);
1502   }
1503
1504   return (GType) id;
1505 }
1506
1507 GType
1508 gst_buffering_mode_get_type (void)
1509 {
1510   static gsize id = 0;
1511   static const GEnumValue values[] = {
1512     {C_ENUM (GST_BUFFERING_STREAM), "GST_BUFFERING_STREAM", "stream"},
1513     {C_ENUM (GST_BUFFERING_DOWNLOAD), "GST_BUFFERING_DOWNLOAD", "download"},
1514     {C_ENUM (GST_BUFFERING_TIMESHIFT), "GST_BUFFERING_TIMESHIFT", "timeshift"},
1515     {C_ENUM (GST_BUFFERING_LIVE), "GST_BUFFERING_LIVE", "live"},
1516     {0, NULL, NULL}
1517   };
1518
1519   if (g_once_init_enter (&id)) {
1520     GType tmp = g_enum_register_static ("GstBufferingMode", values);
1521     g_once_init_leave (&id, tmp);
1522   }
1523
1524   return (GType) id;
1525 }
1526
1527 GType
1528 gst_scheduling_flags_get_type (void)
1529 {
1530   static gsize id = 0;
1531   static const GFlagsValue values[] = {
1532     {C_FLAGS (GST_SCHEDULING_FLAG_SEEKABLE), "GST_SCHEDULING_FLAG_SEEKABLE",
1533         "seekable"},
1534     {C_FLAGS (GST_SCHEDULING_FLAG_SEQUENTIAL), "GST_SCHEDULING_FLAG_SEQUENTIAL",
1535         "sequential"},
1536     {C_FLAGS (GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED),
1537         "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED", "bandwidth-limited"},
1538     {0, NULL, NULL}
1539   };
1540
1541   if (g_once_init_enter (&id)) {
1542     GType tmp = g_flags_register_static ("GstSchedulingFlags", values);
1543     g_once_init_leave (&id, tmp);
1544   }
1545
1546   return (GType) id;
1547 }
1548
1549 /* enumerations from "gstsegment.h" */
1550 GType
1551 gst_seek_type_get_type (void)
1552 {
1553   static gsize id = 0;
1554   static const GEnumValue values[] = {
1555     {C_ENUM (GST_SEEK_TYPE_NONE), "GST_SEEK_TYPE_NONE", "none"},
1556     {C_ENUM (GST_SEEK_TYPE_SET), "GST_SEEK_TYPE_SET", "set"},
1557     {C_ENUM (GST_SEEK_TYPE_END), "GST_SEEK_TYPE_END", "end"},
1558     {0, NULL, NULL}
1559   };
1560
1561   if (g_once_init_enter (&id)) {
1562     GType tmp = g_enum_register_static ("GstSeekType", values);
1563     g_once_init_leave (&id, tmp);
1564   }
1565
1566   return (GType) id;
1567 }
1568
1569 GType
1570 gst_seek_flags_get_type (void)
1571 {
1572   static gsize id = 0;
1573   static const GFlagsValue values[] = {
1574     {C_FLAGS (GST_SEEK_FLAG_NONE), "GST_SEEK_FLAG_NONE", "none"},
1575     {C_FLAGS (GST_SEEK_FLAG_FLUSH), "GST_SEEK_FLAG_FLUSH", "flush"},
1576     {C_FLAGS (GST_SEEK_FLAG_ACCURATE), "GST_SEEK_FLAG_ACCURATE", "accurate"},
1577     {C_FLAGS (GST_SEEK_FLAG_KEY_UNIT), "GST_SEEK_FLAG_KEY_UNIT", "key-unit"},
1578     {C_FLAGS (GST_SEEK_FLAG_SEGMENT), "GST_SEEK_FLAG_SEGMENT", "segment"},
1579     {C_FLAGS (GST_SEEK_FLAG_SKIP), "GST_SEEK_FLAG_SKIP", "skip"},
1580     {C_FLAGS (GST_SEEK_FLAG_SNAP_BEFORE), "GST_SEEK_FLAG_SNAP_BEFORE",
1581         "snap-before"},
1582     {C_FLAGS (GST_SEEK_FLAG_SNAP_AFTER), "GST_SEEK_FLAG_SNAP_AFTER",
1583         "snap-after"},
1584     {C_FLAGS (GST_SEEK_FLAG_SNAP_NEAREST), "GST_SEEK_FLAG_SNAP_NEAREST",
1585         "snap-nearest"},
1586     {0, NULL, NULL}
1587   };
1588
1589   if (g_once_init_enter (&id)) {
1590     GType tmp = g_flags_register_static ("GstSeekFlags", values);
1591     g_once_init_leave (&id, tmp);
1592   }
1593
1594   return (GType) id;
1595 }
1596
1597 GType
1598 gst_segment_flags_get_type (void)
1599 {
1600   static gsize id = 0;
1601   static const GFlagsValue values[] = {
1602     {C_FLAGS (GST_SEGMENT_FLAG_NONE), "GST_SEGMENT_FLAG_NONE", "none"},
1603     {C_FLAGS (GST_SEGMENT_FLAG_RESET), "GST_SEGMENT_FLAG_RESET", "reset"},
1604     {C_FLAGS (GST_SEGMENT_FLAG_SKIP), "GST_SEGMENT_FLAG_SKIP", "skip"},
1605     {C_FLAGS (GST_SEGMENT_FLAG_SEGMENT), "GST_SEGMENT_FLAG_SEGMENT", "segment"},
1606     {0, NULL, NULL}
1607   };
1608
1609   if (g_once_init_enter (&id)) {
1610     GType tmp = g_flags_register_static ("GstSegmentFlags", values);
1611     g_once_init_leave (&id, tmp);
1612   }
1613
1614   return (GType) id;
1615 }
1616
1617 /* enumerations from "gstsystemclock.h" */
1618 GType
1619 gst_clock_type_get_type (void)
1620 {
1621   static gsize id = 0;
1622   static const GEnumValue values[] = {
1623     {C_ENUM (GST_CLOCK_TYPE_REALTIME), "GST_CLOCK_TYPE_REALTIME", "realtime"},
1624     {C_ENUM (GST_CLOCK_TYPE_MONOTONIC), "GST_CLOCK_TYPE_MONOTONIC",
1625         "monotonic"},
1626     {C_ENUM (GST_CLOCK_TYPE_OTHER), "GST_CLOCK_TYPE_OTHER", "other"},
1627     {0, NULL, NULL}
1628   };
1629
1630   if (g_once_init_enter (&id)) {
1631     GType tmp = g_enum_register_static ("GstClockType", values);
1632     g_once_init_leave (&id, tmp);
1633   }
1634
1635   return (GType) id;
1636 }
1637
1638 /* enumerations from "gsttaglist.h" */
1639 GType
1640 gst_tag_merge_mode_get_type (void)
1641 {
1642   static gsize id = 0;
1643   static const GEnumValue values[] = {
1644     {C_ENUM (GST_TAG_MERGE_UNDEFINED), "GST_TAG_MERGE_UNDEFINED", "undefined"},
1645     {C_ENUM (GST_TAG_MERGE_REPLACE_ALL), "GST_TAG_MERGE_REPLACE_ALL",
1646         "replace-all"},
1647     {C_ENUM (GST_TAG_MERGE_REPLACE), "GST_TAG_MERGE_REPLACE", "replace"},
1648     {C_ENUM (GST_TAG_MERGE_APPEND), "GST_TAG_MERGE_APPEND", "append"},
1649     {C_ENUM (GST_TAG_MERGE_PREPEND), "GST_TAG_MERGE_PREPEND", "prepend"},
1650     {C_ENUM (GST_TAG_MERGE_KEEP), "GST_TAG_MERGE_KEEP", "keep"},
1651     {C_ENUM (GST_TAG_MERGE_KEEP_ALL), "GST_TAG_MERGE_KEEP_ALL", "keep-all"},
1652     {C_ENUM (GST_TAG_MERGE_COUNT), "GST_TAG_MERGE_COUNT", "count"},
1653     {0, NULL, NULL}
1654   };
1655
1656   if (g_once_init_enter (&id)) {
1657     GType tmp = g_enum_register_static ("GstTagMergeMode", values);
1658     g_once_init_leave (&id, tmp);
1659   }
1660
1661   return (GType) id;
1662 }
1663
1664 GType
1665 gst_tag_flag_get_type (void)
1666 {
1667   static gsize id = 0;
1668   static const GEnumValue values[] = {
1669     {C_ENUM (GST_TAG_FLAG_UNDEFINED), "GST_TAG_FLAG_UNDEFINED", "undefined"},
1670     {C_ENUM (GST_TAG_FLAG_META), "GST_TAG_FLAG_META", "meta"},
1671     {C_ENUM (GST_TAG_FLAG_ENCODED), "GST_TAG_FLAG_ENCODED", "encoded"},
1672     {C_ENUM (GST_TAG_FLAG_DECODED), "GST_TAG_FLAG_DECODED", "decoded"},
1673     {C_ENUM (GST_TAG_FLAG_COUNT), "GST_TAG_FLAG_COUNT", "count"},
1674     {0, NULL, NULL}
1675   };
1676
1677   if (g_once_init_enter (&id)) {
1678     GType tmp = g_enum_register_static ("GstTagFlag", values);
1679     g_once_init_leave (&id, tmp);
1680   }
1681
1682   return (GType) id;
1683 }
1684
1685 GType
1686 gst_tag_scope_get_type (void)
1687 {
1688   static gsize id = 0;
1689   static const GEnumValue values[] = {
1690     {C_ENUM (GST_TAG_SCOPE_STREAM), "GST_TAG_SCOPE_STREAM", "stream"},
1691     {C_ENUM (GST_TAG_SCOPE_GLOBAL), "GST_TAG_SCOPE_GLOBAL", "global"},
1692     {0, NULL, NULL}
1693   };
1694
1695   if (g_once_init_enter (&id)) {
1696     GType tmp = g_enum_register_static ("GstTagScope", values);
1697     g_once_init_leave (&id, tmp);
1698   }
1699
1700   return (GType) id;
1701 }
1702
1703 /* enumerations from "gsttask.h" */
1704 GType
1705 gst_task_state_get_type (void)
1706 {
1707   static gsize id = 0;
1708   static const GEnumValue values[] = {
1709     {C_ENUM (GST_TASK_STARTED), "GST_TASK_STARTED", "started"},
1710     {C_ENUM (GST_TASK_STOPPED), "GST_TASK_STOPPED", "stopped"},
1711     {C_ENUM (GST_TASK_PAUSED), "GST_TASK_PAUSED", "paused"},
1712     {0, NULL, NULL}
1713   };
1714
1715   if (g_once_init_enter (&id)) {
1716     GType tmp = g_enum_register_static ("GstTaskState", values);
1717     g_once_init_leave (&id, tmp);
1718   }
1719
1720   return (GType) id;
1721 }
1722
1723 /* enumerations from "gsttoc.h" */
1724 GType
1725 gst_toc_scope_get_type (void)
1726 {
1727   static gsize id = 0;
1728   static const GEnumValue values[] = {
1729     {C_ENUM (GST_TOC_SCOPE_GLOBAL), "GST_TOC_SCOPE_GLOBAL", "global"},
1730     {C_ENUM (GST_TOC_SCOPE_CURRENT), "GST_TOC_SCOPE_CURRENT", "current"},
1731     {0, NULL, NULL}
1732   };
1733
1734   if (g_once_init_enter (&id)) {
1735     GType tmp = g_enum_register_static ("GstTocScope", values);
1736     g_once_init_leave (&id, tmp);
1737   }
1738
1739   return (GType) id;
1740 }
1741
1742 GType
1743 gst_toc_entry_type_get_type (void)
1744 {
1745   static gsize id = 0;
1746   static const GEnumValue values[] = {
1747     {C_ENUM (GST_TOC_ENTRY_TYPE_ANGLE), "GST_TOC_ENTRY_TYPE_ANGLE", "angle"},
1748     {C_ENUM (GST_TOC_ENTRY_TYPE_VERSION), "GST_TOC_ENTRY_TYPE_VERSION",
1749         "version"},
1750     {C_ENUM (GST_TOC_ENTRY_TYPE_EDITION), "GST_TOC_ENTRY_TYPE_EDITION",
1751         "edition"},
1752     {C_ENUM (GST_TOC_ENTRY_TYPE_INVALID), "GST_TOC_ENTRY_TYPE_INVALID",
1753         "invalid"},
1754     {C_ENUM (GST_TOC_ENTRY_TYPE_TITLE), "GST_TOC_ENTRY_TYPE_TITLE", "title"},
1755     {C_ENUM (GST_TOC_ENTRY_TYPE_TRACK), "GST_TOC_ENTRY_TYPE_TRACK", "track"},
1756     {C_ENUM (GST_TOC_ENTRY_TYPE_CHAPTER), "GST_TOC_ENTRY_TYPE_CHAPTER",
1757         "chapter"},
1758     {0, NULL, NULL}
1759   };
1760
1761   if (g_once_init_enter (&id)) {
1762     GType tmp = g_enum_register_static ("GstTocEntryType", values);
1763     g_once_init_leave (&id, tmp);
1764   }
1765
1766   return (GType) id;
1767 }
1768
1769 /* enumerations from "gsttypefind.h" */
1770 GType
1771 gst_type_find_probability_get_type (void)
1772 {
1773   static gsize id = 0;
1774   static const GEnumValue values[] = {
1775     {C_ENUM (GST_TYPE_FIND_NONE), "GST_TYPE_FIND_NONE", "none"},
1776     {C_ENUM (GST_TYPE_FIND_MINIMUM), "GST_TYPE_FIND_MINIMUM", "minimum"},
1777     {C_ENUM (GST_TYPE_FIND_POSSIBLE), "GST_TYPE_FIND_POSSIBLE", "possible"},
1778     {C_ENUM (GST_TYPE_FIND_LIKELY), "GST_TYPE_FIND_LIKELY", "likely"},
1779     {C_ENUM (GST_TYPE_FIND_NEARLY_CERTAIN), "GST_TYPE_FIND_NEARLY_CERTAIN",
1780         "nearly-certain"},
1781     {C_ENUM (GST_TYPE_FIND_MAXIMUM), "GST_TYPE_FIND_MAXIMUM", "maximum"},
1782     {0, NULL, NULL}
1783   };
1784
1785   if (g_once_init_enter (&id)) {
1786     GType tmp = g_enum_register_static ("GstTypeFindProbability", values);
1787     g_once_init_leave (&id, tmp);
1788   }
1789
1790   return (GType) id;
1791 }
1792
1793 /* enumerations from "gsturi.h" */
1794 GType
1795 gst_uri_error_get_type (void)
1796 {
1797   static gsize id = 0;
1798   static const GEnumValue values[] = {
1799     {C_ENUM (GST_URI_ERROR_UNSUPPORTED_PROTOCOL),
1800         "GST_URI_ERROR_UNSUPPORTED_PROTOCOL", "unsupported-protocol"},
1801     {C_ENUM (GST_URI_ERROR_BAD_URI), "GST_URI_ERROR_BAD_URI", "bad-uri"},
1802     {C_ENUM (GST_URI_ERROR_BAD_STATE), "GST_URI_ERROR_BAD_STATE", "bad-state"},
1803     {C_ENUM (GST_URI_ERROR_BAD_REFERENCE), "GST_URI_ERROR_BAD_REFERENCE",
1804         "bad-reference"},
1805     {0, NULL, NULL}
1806   };
1807
1808   if (g_once_init_enter (&id)) {
1809     GType tmp = g_enum_register_static ("GstURIError", values);
1810     g_once_init_leave (&id, tmp);
1811   }
1812
1813   return (GType) id;
1814 }
1815
1816 GType
1817 gst_uri_type_get_type (void)
1818 {
1819   static gsize id = 0;
1820   static const GEnumValue values[] = {
1821     {C_ENUM (GST_URI_UNKNOWN), "GST_URI_UNKNOWN", "unknown"},
1822     {C_ENUM (GST_URI_SINK), "GST_URI_SINK", "sink"},
1823     {C_ENUM (GST_URI_SRC), "GST_URI_SRC", "src"},
1824     {0, NULL, NULL}
1825   };
1826
1827   if (g_once_init_enter (&id)) {
1828     GType tmp = g_enum_register_static ("GstURIType", values);
1829     g_once_init_leave (&id, tmp);
1830   }
1831
1832   return (GType) id;
1833 }
1834
1835 /* enumerations from "gstutils.h" */
1836 GType
1837 gst_search_mode_get_type (void)
1838 {
1839   static gsize id = 0;
1840   static const GEnumValue values[] = {
1841     {C_ENUM (GST_SEARCH_MODE_EXACT), "GST_SEARCH_MODE_EXACT", "exact"},
1842     {C_ENUM (GST_SEARCH_MODE_BEFORE), "GST_SEARCH_MODE_BEFORE", "before"},
1843     {C_ENUM (GST_SEARCH_MODE_AFTER), "GST_SEARCH_MODE_AFTER", "after"},
1844     {0, NULL, NULL}
1845   };
1846
1847   if (g_once_init_enter (&id)) {
1848     GType tmp = g_enum_register_static ("GstSearchMode", values);
1849     g_once_init_leave (&id, tmp);
1850   }
1851
1852   return (GType) id;
1853 }
1854
1855 /* enumerations from "gstparse.h" */
1856 GType
1857 gst_parse_error_get_type (void)
1858 {
1859   static gsize id = 0;
1860   static const GEnumValue values[] = {
1861     {C_ENUM (GST_PARSE_ERROR_SYNTAX), "GST_PARSE_ERROR_SYNTAX", "syntax"},
1862     {C_ENUM (GST_PARSE_ERROR_NO_SUCH_ELEMENT),
1863         "GST_PARSE_ERROR_NO_SUCH_ELEMENT", "no-such-element"},
1864     {C_ENUM (GST_PARSE_ERROR_NO_SUCH_PROPERTY),
1865         "GST_PARSE_ERROR_NO_SUCH_PROPERTY", "no-such-property"},
1866     {C_ENUM (GST_PARSE_ERROR_LINK), "GST_PARSE_ERROR_LINK", "link"},
1867     {C_ENUM (GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY),
1868         "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY", "could-not-set-property"},
1869     {C_ENUM (GST_PARSE_ERROR_EMPTY_BIN), "GST_PARSE_ERROR_EMPTY_BIN",
1870         "empty-bin"},
1871     {C_ENUM (GST_PARSE_ERROR_EMPTY), "GST_PARSE_ERROR_EMPTY", "empty"},
1872     {0, NULL, NULL}
1873   };
1874
1875   if (g_once_init_enter (&id)) {
1876     GType tmp = g_enum_register_static ("GstParseError", values);
1877     g_once_init_leave (&id, tmp);
1878   }
1879
1880   return (GType) id;
1881 }
1882
1883 GType
1884 gst_parse_flags_get_type (void)
1885 {
1886   static gsize id = 0;
1887   static const GFlagsValue values[] = {
1888     {C_FLAGS (GST_PARSE_FLAG_NONE), "GST_PARSE_FLAG_NONE", "none"},
1889     {C_FLAGS (GST_PARSE_FLAG_FATAL_ERRORS), "GST_PARSE_FLAG_FATAL_ERRORS",
1890         "fatal-errors"},
1891     {C_FLAGS (GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS),
1892         "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS", "no-single-element-bins"},
1893     {0, NULL, NULL}
1894   };
1895
1896   if (g_once_init_enter (&id)) {
1897     GType tmp = g_flags_register_static ("GstParseFlags", values);
1898     g_once_init_leave (&id, tmp);
1899   }
1900
1901   return (GType) id;
1902 }