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