win32/common/gstenumtypes.c

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