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