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