win32/common/gstenumtypes.c

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