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