win32/common/gstenumtypes.c

   1
   2 /* Generated data (by glib-mkenums) */
   3
   4 #include "gst_private.h"
   5 #include <gst/gst.h>
   6
   7 /* enumerations from "gstobject.h" */
   8 static void
   9 register_gst_object_flags (GType * id)
  10 {
  11   static const GFlagsValue values[] = {
  12     {GST_OBJECT_DISPOSING, "GST_OBJECT_DISPOSING", "disposing"},
  13     {GST_OBJECT_FLOATING, "GST_OBJECT_FLOATING", "floating"},
  14     {GST_OBJECT_FLAG_LAST, "GST_OBJECT_FLAG_LAST", "flag-last"},
  15     {0, NULL, NULL}
  16   };
  17   *id = g_flags_register_static ("GstObjectFlags", values);
  18 }
  19
  20 GType
  21 gst_object_flags_get_type (void)
  22 {
  23   static GType id;
  24   static GOnce once = G_ONCE_INIT;
  25
  26   g_once (&once, (GThreadFunc) register_gst_object_flags, &id);
  27   return id;
  28 }
  29
  30 /* enumerations from "gstbin.h" */
  31 static void
  32 register_gst_bin_flags (GType * id)
  33 {
  34   static const GFlagsValue values[] = {
  35     {GST_BIN_FLAG_LAST, "GST_BIN_FLAG_LAST", "last"},
  36     {0, NULL, NULL}
  37   };
  38   *id = g_flags_register_static ("GstBinFlags", values);
  39 }
  40
  41 GType
  42 gst_bin_flags_get_type (void)
  43 {
  44   static GType id;
  45   static GOnce once = G_ONCE_INIT;
  46
  47   g_once (&once, (GThreadFunc) register_gst_bin_flags, &id);
  48   return id;
  49 }
  50
  51 /* enumerations from "gstbuffer.h" */
  52 static void
  53 register_gst_buffer_flag (GType * id)
  54 {
  55   static const GFlagsValue values[] = {
  56     {GST_BUFFER_FLAG_READONLY, "GST_BUFFER_FLAG_READONLY", "readonly"},
  57     {GST_BUFFER_FLAG_PREROLL, "GST_BUFFER_FLAG_PREROLL", "preroll"},
  58     {GST_BUFFER_FLAG_DISCONT, "GST_BUFFER_FLAG_DISCONT", "discont"},
  59     {GST_BUFFER_FLAG_IN_CAPS, "GST_BUFFER_FLAG_IN_CAPS", "in-caps"},
  60     {GST_BUFFER_FLAG_GAP, "GST_BUFFER_FLAG_GAP", "gap"},
  61     {GST_BUFFER_FLAG_DELTA_UNIT, "GST_BUFFER_FLAG_DELTA_UNIT", "delta-unit"},
  62     {GST_BUFFER_FLAG_LAST, "GST_BUFFER_FLAG_LAST", "last"},
  63     {0, NULL, NULL}
  64   };
  65   *id = g_flags_register_static ("GstBufferFlag", values);
  66 }
  67
  68 GType
  69 gst_buffer_flag_get_type (void)
  70 {
  71   static GType id;
  72   static GOnce once = G_ONCE_INIT;
  73
  74   g_once (&once, (GThreadFunc) register_gst_buffer_flag, &id);
  75   return id;
  76 }
  77
  78 /* enumerations from "gstbus.h" */
  79 static void
  80 register_gst_bus_flags (GType * id)
  81 {
  82   static const GFlagsValue values[] = {
  83     {GST_BUS_FLUSHING, "GST_BUS_FLUSHING", "flushing"},
  84     {GST_BUS_FLAG_LAST, "GST_BUS_FLAG_LAST", "flag-last"},
  85     {0, NULL, NULL}
  86   };
  87   *id = g_flags_register_static ("GstBusFlags", values);
  88 }
  89
  90 GType
  91 gst_bus_flags_get_type (void)
  92 {
  93   static GType id;
  94   static GOnce once = G_ONCE_INIT;
  95
  96   g_once (&once, (GThreadFunc) register_gst_bus_flags, &id);
  97   return id;
  98 }
  99 static void
 100 register_gst_bus_sync_reply (GType * id)
 101 {
 102   static const GEnumValue values[] = {
 103     {GST_BUS_DROP, "GST_BUS_DROP", "drop"},
 104     {GST_BUS_PASS, "GST_BUS_PASS", "pass"},
 105     {GST_BUS_ASYNC, "GST_BUS_ASYNC", "async"},
 106     {0, NULL, NULL}
 107   };
 108   *id = g_enum_register_static ("GstBusSyncReply", values);
 109 }
 110
 111 GType
 112 gst_bus_sync_reply_get_type (void)
 113 {
 114   static GType id;
 115   static GOnce once = G_ONCE_INIT;
 116
 117   g_once (&once, (GThreadFunc) register_gst_bus_sync_reply, &id);
 118   return id;
 119 }
 120
 121 /* enumerations from "gstcaps.h" */
 122 static void
 123 register_gst_caps_flags (GType * id)
 124 {
 125   static const GFlagsValue values[] = {
 126     {GST_CAPS_FLAGS_ANY, "GST_CAPS_FLAGS_ANY", "any"},
 127     {0, NULL, NULL}
 128   };
 129   *id = g_flags_register_static ("GstCapsFlags", values);
 130 }
 131
 132 GType
 133 gst_caps_flags_get_type (void)
 134 {
 135   static GType id;
 136   static GOnce once = G_ONCE_INIT;
 137
 138   g_once (&once, (GThreadFunc) register_gst_caps_flags, &id);
 139   return id;
 140 }
 141
 142 /* enumerations from "gstclock.h" */
 143 static void
 144 register_gst_clock_return (GType * id)
 145 {
 146   static const GEnumValue values[] = {
 147     {GST_CLOCK_OK, "GST_CLOCK_OK", "ok"},
 148     {GST_CLOCK_EARLY, "GST_CLOCK_EARLY", "early"},
 149     {GST_CLOCK_UNSCHEDULED, "GST_CLOCK_UNSCHEDULED", "unscheduled"},
 150     {GST_CLOCK_BUSY, "GST_CLOCK_BUSY", "busy"},
 151     {GST_CLOCK_BADTIME, "GST_CLOCK_BADTIME", "badtime"},
 152     {GST_CLOCK_ERROR, "GST_CLOCK_ERROR", "error"},
 153     {GST_CLOCK_UNSUPPORTED, "GST_CLOCK_UNSUPPORTED", "unsupported"},
 154     {0, NULL, NULL}
 155   };
 156   *id = g_enum_register_static ("GstClockReturn", values);
 157 }
 158
 159 GType
 160 gst_clock_return_get_type (void)
 161 {
 162   static GType id;
 163   static GOnce once = G_ONCE_INIT;
 164
 165   g_once (&once, (GThreadFunc) register_gst_clock_return, &id);
 166   return id;
 167 }
 168 static void
 169 register_gst_clock_entry_type (GType * id)
 170 {
 171   static const GEnumValue values[] = {
 172     {GST_CLOCK_ENTRY_SINGLE, "GST_CLOCK_ENTRY_SINGLE", "single"},
 173     {GST_CLOCK_ENTRY_PERIODIC, "GST_CLOCK_ENTRY_PERIODIC", "periodic"},
 174     {0, NULL, NULL}
 175   };
 176   *id = g_enum_register_static ("GstClockEntryType", values);
 177 }
 178
 179 GType
 180 gst_clock_entry_type_get_type (void)
 181 {
 182   static GType id;
 183   static GOnce once = G_ONCE_INIT;
 184
 185   g_once (&once, (GThreadFunc) register_gst_clock_entry_type, &id);
 186   return id;
 187 }
 188 static void
 189 register_gst_clock_flags (GType * id)
 190 {
 191   static const GFlagsValue values[] = {
 192     {GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC, "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC",
 193           "can-do-single-sync"},
 194     {GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC, "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC",
 195           "can-do-single-async"},
 196     {GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC, "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC",
 197           "can-do-periodic-sync"},
 198     {GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC,
 199           "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC", "can-do-periodic-async"},
 200     {GST_CLOCK_FLAG_CAN_SET_RESOLUTION, "GST_CLOCK_FLAG_CAN_SET_RESOLUTION",
 201           "can-set-resolution"},
 202     {GST_CLOCK_FLAG_CAN_SET_MASTER, "GST_CLOCK_FLAG_CAN_SET_MASTER",
 203           "can-set-master"},
 204     {GST_CLOCK_FLAG_LAST, "GST_CLOCK_FLAG_LAST", "last"},
 205     {0, NULL, NULL}
 206   };
 207   *id = g_flags_register_static ("GstClockFlags", values);
 208 }
 209
 210 GType
 211 gst_clock_flags_get_type (void)
 212 {
 213   static GType id;
 214   static GOnce once = G_ONCE_INIT;
 215
 216   g_once (&once, (GThreadFunc) register_gst_clock_flags, &id);
 217   return id;
 218 }
 219
 220 /* enumerations from "gstelement.h" */
 221 static void
 222 register_gst_state (GType * id)
 223 {
 224   static const GEnumValue values[] = {
 225     {GST_STATE_VOID_PENDING, "GST_STATE_VOID_PENDING", "void-pending"},
 226     {GST_STATE_NULL, "GST_STATE_NULL", "null"},
 227     {GST_STATE_READY, "GST_STATE_READY", "ready"},
 228     {GST_STATE_PAUSED, "GST_STATE_PAUSED", "paused"},
 229     {GST_STATE_PLAYING, "GST_STATE_PLAYING", "playing"},
 230     {0, NULL, NULL}
 231   };
 232   *id = g_enum_register_static ("GstState", values);
 233 }
 234
 235 GType
 236 gst_state_get_type (void)
 237 {
 238   static GType id;
 239   static GOnce once = G_ONCE_INIT;
 240
 241   g_once (&once, (GThreadFunc) register_gst_state, &id);
 242   return id;
 243 }
 244 static void
 245 register_gst_state_change_return (GType * id)
 246 {
 247   static const GEnumValue values[] = {
 248     {GST_STATE_CHANGE_FAILURE, "GST_STATE_CHANGE_FAILURE", "failure"},
 249     {GST_STATE_CHANGE_SUCCESS, "GST_STATE_CHANGE_SUCCESS", "success"},
 250     {GST_STATE_CHANGE_ASYNC, "GST_STATE_CHANGE_ASYNC", "async"},
 251     {GST_STATE_CHANGE_NO_PREROLL, "GST_STATE_CHANGE_NO_PREROLL", "no-preroll"},
 252     {0, NULL, NULL}
 253   };
 254   *id = g_enum_register_static ("GstStateChangeReturn", values);
 255 }
 256
 257 GType
 258 gst_state_change_return_get_type (void)
 259 {
 260   static GType id;
 261   static GOnce once = G_ONCE_INIT;
 262
 263   g_once (&once, (GThreadFunc) register_gst_state_change_return, &id);
 264   return id;
 265 }
 266 static void
 267 register_gst_state_change (GType * id)
 268 {
 269   static const GEnumValue values[] = {
 270     {GST_STATE_CHANGE_NULL_TO_READY, "GST_STATE_CHANGE_NULL_TO_READY",
 271           "null-to-ready"},
 272     {GST_STATE_CHANGE_READY_TO_PAUSED, "GST_STATE_CHANGE_READY_TO_PAUSED",
 273           "ready-to-paused"},
 274     {GST_STATE_CHANGE_PAUSED_TO_PLAYING, "GST_STATE_CHANGE_PAUSED_TO_PLAYING",
 275           "paused-to-playing"},
 276     {GST_STATE_CHANGE_PLAYING_TO_PAUSED, "GST_STATE_CHANGE_PLAYING_TO_PAUSED",
 277           "playing-to-paused"},
 278     {GST_STATE_CHANGE_PAUSED_TO_READY, "GST_STATE_CHANGE_PAUSED_TO_READY",
 279           "paused-to-ready"},
 280     {GST_STATE_CHANGE_READY_TO_NULL, "GST_STATE_CHANGE_READY_TO_NULL",
 281           "ready-to-null"},
 282     {0, NULL, NULL}
 283   };
 284   *id = g_enum_register_static ("GstStateChange", values);
 285 }
 286
 287 GType
 288 gst_state_change_get_type (void)
 289 {
 290   static GType id;
 291   static GOnce once = G_ONCE_INIT;
 292
 293   g_once (&once, (GThreadFunc) register_gst_state_change, &id);
 294   return id;
 295 }
 296 static void
 297 register_gst_element_flags (GType * id)
 298 {
 299   static const GFlagsValue values[] = {
 300     {GST_ELEMENT_LOCKED_STATE, "GST_ELEMENT_LOCKED_STATE", "locked-state"},
 301     {GST_ELEMENT_IS_SINK, "GST_ELEMENT_IS_SINK", "is-sink"},
 302     {GST_ELEMENT_UNPARENTING, "GST_ELEMENT_UNPARENTING", "unparenting"},
 303     {GST_ELEMENT_FLAG_LAST, "GST_ELEMENT_FLAG_LAST", "flag-last"},
 304     {0, NULL, NULL}
 305   };
 306   *id = g_flags_register_static ("GstElementFlags", values);
 307 }
 308
 309 GType
 310 gst_element_flags_get_type (void)
 311 {
 312   static GType id;
 313   static GOnce once = G_ONCE_INIT;
 314
 315   g_once (&once, (GThreadFunc) register_gst_element_flags, &id);
 316   return id;
 317 }
 318
 319 /* enumerations from "gsterror.h" */
 320 static void
 321 register_gst_core_error (GType * id)
 322 {
 323   static const GEnumValue values[] = {
 324     {GST_CORE_ERROR_FAILED, "GST_CORE_ERROR_FAILED", "failed"},
 325     {GST_CORE_ERROR_TOO_LAZY, "GST_CORE_ERROR_TOO_LAZY", "too-lazy"},
 326     {GST_CORE_ERROR_NOT_IMPLEMENTED, "GST_CORE_ERROR_NOT_IMPLEMENTED",
 327           "not-implemented"},
 328     {GST_CORE_ERROR_STATE_CHANGE, "GST_CORE_ERROR_STATE_CHANGE",
 329           "state-change"},
 330     {GST_CORE_ERROR_PAD, "GST_CORE_ERROR_PAD", "pad"},
 331     {GST_CORE_ERROR_THREAD, "GST_CORE_ERROR_THREAD", "thread"},
 332     {GST_CORE_ERROR_NEGOTIATION, "GST_CORE_ERROR_NEGOTIATION", "negotiation"},
 333     {GST_CORE_ERROR_EVENT, "GST_CORE_ERROR_EVENT", "event"},
 334     {GST_CORE_ERROR_SEEK, "GST_CORE_ERROR_SEEK", "seek"},
 335     {GST_CORE_ERROR_CAPS, "GST_CORE_ERROR_CAPS", "caps"},
 336     {GST_CORE_ERROR_TAG, "GST_CORE_ERROR_TAG", "tag"},
 337     {GST_CORE_ERROR_MISSING_PLUGIN, "GST_CORE_ERROR_MISSING_PLUGIN",
 338           "missing-plugin"},
 339     {GST_CORE_ERROR_CLOCK, "GST_CORE_ERROR_CLOCK", "clock"},
 340     {GST_CORE_ERROR_NUM_ERRORS, "GST_CORE_ERROR_NUM_ERRORS", "num-errors"},
 341     {0, NULL, NULL}
 342   };
 343   *id = g_enum_register_static ("GstCoreError", values);
 344 }
 345
 346 GType
 347 gst_core_error_get_type (void)
 348 {
 349   static GType id;
 350   static GOnce once = G_ONCE_INIT;
 351
 352   g_once (&once, (GThreadFunc) register_gst_core_error, &id);
 353   return id;
 354 }
 355 static void
 356 register_gst_library_error (GType * id)
 357 {
 358   static const GEnumValue values[] = {
 359     {GST_LIBRARY_ERROR_FAILED, "GST_LIBRARY_ERROR_FAILED", "failed"},
 360     {GST_LIBRARY_ERROR_TOO_LAZY, "GST_LIBRARY_ERROR_TOO_LAZY", "too-lazy"},
 361     {GST_LIBRARY_ERROR_INIT, "GST_LIBRARY_ERROR_INIT", "init"},
 362     {GST_LIBRARY_ERROR_SHUTDOWN, "GST_LIBRARY_ERROR_SHUTDOWN", "shutdown"},
 363     {GST_LIBRARY_ERROR_SETTINGS, "GST_LIBRARY_ERROR_SETTINGS", "settings"},
 364     {GST_LIBRARY_ERROR_ENCODE, "GST_LIBRARY_ERROR_ENCODE", "encode"},
 365     {GST_LIBRARY_ERROR_NUM_ERRORS, "GST_LIBRARY_ERROR_NUM_ERRORS",
 366           "num-errors"},
 367     {0, NULL, NULL}
 368   };
 369   *id = g_enum_register_static ("GstLibraryError", values);
 370 }
 371
 372 GType
 373 gst_library_error_get_type (void)
 374 {
 375   static GType id;
 376   static GOnce once = G_ONCE_INIT;
 377
 378   g_once (&once, (GThreadFunc) register_gst_library_error, &id);
 379   return id;
 380 }
 381 static void
 382 register_gst_resource_error (GType * id)
 383 {
 384   static const GEnumValue values[] = {
 385     {GST_RESOURCE_ERROR_FAILED, "GST_RESOURCE_ERROR_FAILED", "failed"},
 386     {GST_RESOURCE_ERROR_TOO_LAZY, "GST_RESOURCE_ERROR_TOO_LAZY", "too-lazy"},
 387     {GST_RESOURCE_ERROR_NOT_FOUND, "GST_RESOURCE_ERROR_NOT_FOUND", "not-found"},
 388     {GST_RESOURCE_ERROR_BUSY, "GST_RESOURCE_ERROR_BUSY", "busy"},
 389     {GST_RESOURCE_ERROR_OPEN_READ, "GST_RESOURCE_ERROR_OPEN_READ", "open-read"},
 390     {GST_RESOURCE_ERROR_OPEN_WRITE, "GST_RESOURCE_ERROR_OPEN_WRITE",
 391           "open-write"},
 392     {GST_RESOURCE_ERROR_OPEN_READ_WRITE, "GST_RESOURCE_ERROR_OPEN_READ_WRITE",
 393           "open-read-write"},
 394     {GST_RESOURCE_ERROR_CLOSE, "GST_RESOURCE_ERROR_CLOSE", "close"},
 395     {GST_RESOURCE_ERROR_READ, "GST_RESOURCE_ERROR_READ", "read"},
 396     {GST_RESOURCE_ERROR_WRITE, "GST_RESOURCE_ERROR_WRITE", "write"},
 397     {GST_RESOURCE_ERROR_SEEK, "GST_RESOURCE_ERROR_SEEK", "seek"},
 398     {GST_RESOURCE_ERROR_SYNC, "GST_RESOURCE_ERROR_SYNC", "sync"},
 399     {GST_RESOURCE_ERROR_SETTINGS, "GST_RESOURCE_ERROR_SETTINGS", "settings"},
 400     {GST_RESOURCE_ERROR_NUM_ERRORS, "GST_RESOURCE_ERROR_NUM_ERRORS",
 401           "num-errors"},
 402     {0, NULL, NULL}
 403   };
 404   *id = g_enum_register_static ("GstResourceError", values);
 405 }
 406
 407 GType
 408 gst_resource_error_get_type (void)
 409 {
 410   static GType id;
 411   static GOnce once = G_ONCE_INIT;
 412
 413   g_once (&once, (GThreadFunc) register_gst_resource_error, &id);
 414   return id;
 415 }
 416 static void
 417 register_gst_stream_error (GType * id)
 418 {
 419   static const GEnumValue values[] = {
 420     {GST_STREAM_ERROR_FAILED, "GST_STREAM_ERROR_FAILED", "failed"},
 421     {GST_STREAM_ERROR_TOO_LAZY, "GST_STREAM_ERROR_TOO_LAZY", "too-lazy"},
 422     {GST_STREAM_ERROR_NOT_IMPLEMENTED, "GST_STREAM_ERROR_NOT_IMPLEMENTED",
 423           "not-implemented"},
 424     {GST_STREAM_ERROR_TYPE_NOT_FOUND, "GST_STREAM_ERROR_TYPE_NOT_FOUND",
 425           "type-not-found"},
 426     {GST_STREAM_ERROR_WRONG_TYPE, "GST_STREAM_ERROR_WRONG_TYPE", "wrong-type"},
 427     {GST_STREAM_ERROR_CODEC_NOT_FOUND, "GST_STREAM_ERROR_CODEC_NOT_FOUND",
 428           "codec-not-found"},
 429     {GST_STREAM_ERROR_DECODE, "GST_STREAM_ERROR_DECODE", "decode"},
 430     {GST_STREAM_ERROR_ENCODE, "GST_STREAM_ERROR_ENCODE", "encode"},
 431     {GST_STREAM_ERROR_DEMUX, "GST_STREAM_ERROR_DEMUX", "demux"},
 432     {GST_STREAM_ERROR_MUX, "GST_STREAM_ERROR_MUX", "mux"},
 433     {GST_STREAM_ERROR_FORMAT, "GST_STREAM_ERROR_FORMAT", "format"},
 434     {GST_STREAM_ERROR_NUM_ERRORS, "GST_STREAM_ERROR_NUM_ERRORS", "num-errors"},
 435     {0, NULL, NULL}
 436   };
 437   *id = g_enum_register_static ("GstStreamError", values);
 438 }
 439
 440 GType
 441 gst_stream_error_get_type (void)
 442 {
 443   static GType id;
 444   static GOnce once = G_ONCE_INIT;
 445
 446   g_once (&once, (GThreadFunc) register_gst_stream_error, &id);
 447   return id;
 448 }
 449
 450 /* enumerations from "gstevent.h" */
 451 static void
 452 register_gst_event_type_flags (GType * id)
 453 {
 454   static const GFlagsValue values[] = {
 455     {GST_EVENT_TYPE_UPSTREAM, "GST_EVENT_TYPE_UPSTREAM", "upstream"},
 456     {GST_EVENT_TYPE_DOWNSTREAM, "GST_EVENT_TYPE_DOWNSTREAM", "downstream"},
 457     {GST_EVENT_TYPE_SERIALIZED, "GST_EVENT_TYPE_SERIALIZED", "serialized"},
 458     {0, NULL, NULL}
 459   };
 460   *id = g_flags_register_static ("GstEventTypeFlags", values);
 461 }
 462
 463 GType
 464 gst_event_type_flags_get_type (void)
 465 {
 466   static GType id;
 467   static GOnce once = G_ONCE_INIT;
 468
 469   g_once (&once, (GThreadFunc) register_gst_event_type_flags, &id);
 470   return id;
 471 }
 472 static void
 473 register_gst_event_type (GType * id)
 474 {
 475   static const GEnumValue values[] = {
 476     {GST_EVENT_UNKNOWN, "GST_EVENT_UNKNOWN", "unknown"},
 477     {GST_EVENT_FLUSH_START, "GST_EVENT_FLUSH_START", "flush-start"},
 478     {GST_EVENT_FLUSH_STOP, "GST_EVENT_FLUSH_STOP", "flush-stop"},
 479     {GST_EVENT_EOS, "GST_EVENT_EOS", "eos"},
 480     {GST_EVENT_NEWSEGMENT, "GST_EVENT_NEWSEGMENT", "newsegment"},
 481     {GST_EVENT_TAG, "GST_EVENT_TAG", "tag"},
 482     {GST_EVENT_BUFFERSIZE, "GST_EVENT_BUFFERSIZE", "buffersize"},
 483     {GST_EVENT_QOS, "GST_EVENT_QOS", "qos"},
 484     {GST_EVENT_SEEK, "GST_EVENT_SEEK", "seek"},
 485     {GST_EVENT_NAVIGATION, "GST_EVENT_NAVIGATION", "navigation"},
 486     {GST_EVENT_CUSTOM_UPSTREAM, "GST_EVENT_CUSTOM_UPSTREAM", "custom-upstream"},
 487     {GST_EVENT_CUSTOM_DOWNSTREAM, "GST_EVENT_CUSTOM_DOWNSTREAM",
 488           "custom-downstream"},
 489     {GST_EVENT_CUSTOM_DOWNSTREAM_OOB, "GST_EVENT_CUSTOM_DOWNSTREAM_OOB",
 490           "custom-downstream-oob"},
 491     {GST_EVENT_CUSTOM_BOTH, "GST_EVENT_CUSTOM_BOTH", "custom-both"},
 492     {GST_EVENT_CUSTOM_BOTH_OOB, "GST_EVENT_CUSTOM_BOTH_OOB", "custom-both-oob"},
 493     {0, NULL, NULL}
 494   };
 495   *id = g_enum_register_static ("GstEventType", values);
 496 }
 497
 498 GType
 499 gst_event_type_get_type (void)
 500 {
 501   static GType id;
 502   static GOnce once = G_ONCE_INIT;
 503
 504   g_once (&once, (GThreadFunc) register_gst_event_type, &id);
 505   return id;
 506 }
 507 static void
 508 register_gst_seek_type (GType * id)
 509 {
 510   static const GEnumValue values[] = {
 511     {GST_SEEK_TYPE_NONE, "GST_SEEK_TYPE_NONE", "none"},
 512     {GST_SEEK_TYPE_CUR, "GST_SEEK_TYPE_CUR", "cur"},
 513     {GST_SEEK_TYPE_SET, "GST_SEEK_TYPE_SET", "set"},
 514     {GST_SEEK_TYPE_END, "GST_SEEK_TYPE_END", "end"},
 515     {0, NULL, NULL}
 516   };
 517   *id = g_enum_register_static ("GstSeekType", values);
 518 }
 519
 520 GType
 521 gst_seek_type_get_type (void)
 522 {
 523   static GType id;
 524   static GOnce once = G_ONCE_INIT;
 525
 526   g_once (&once, (GThreadFunc) register_gst_seek_type, &id);
 527   return id;
 528 }
 529 static void
 530 register_gst_seek_flags (GType * id)
 531 {
 532   static const GFlagsValue values[] = {
 533     {GST_SEEK_FLAG_NONE, "GST_SEEK_FLAG_NONE", "none"},
 534     {GST_SEEK_FLAG_FLUSH, "GST_SEEK_FLAG_FLUSH", "flush"},
 535     {GST_SEEK_FLAG_ACCURATE, "GST_SEEK_FLAG_ACCURATE", "accurate"},
 536     {GST_SEEK_FLAG_KEY_UNIT, "GST_SEEK_FLAG_KEY_UNIT", "key-unit"},
 537     {GST_SEEK_FLAG_SEGMENT, "GST_SEEK_FLAG_SEGMENT", "segment"},
 538     {0, NULL, NULL}
 539   };
 540   *id = g_flags_register_static ("GstSeekFlags", values);
 541 }
 542
 543 GType
 544 gst_seek_flags_get_type (void)
 545 {
 546   static GType id;
 547   static GOnce once = G_ONCE_INIT;
 548
 549   g_once (&once, (GThreadFunc) register_gst_seek_flags, &id);
 550   return id;
 551 }
 552
 553 /* enumerations from "gstformat.h" */
 554 static void
 555 register_gst_format (GType * id)
 556 {
 557   static const GEnumValue values[] = {
 558     {GST_FORMAT_UNDEFINED, "GST_FORMAT_UNDEFINED", "undefined"},
 559     {GST_FORMAT_DEFAULT, "GST_FORMAT_DEFAULT", "default"},
 560     {GST_FORMAT_BYTES, "GST_FORMAT_BYTES", "bytes"},
 561     {GST_FORMAT_TIME, "GST_FORMAT_TIME", "time"},
 562     {GST_FORMAT_BUFFERS, "GST_FORMAT_BUFFERS", "buffers"},
 563     {GST_FORMAT_PERCENT, "GST_FORMAT_PERCENT", "percent"},
 564     {0, NULL, NULL}
 565   };
 566   *id = g_enum_register_static ("GstFormat", values);
 567 }
 568
 569 GType
 570 gst_format_get_type (void)
 571 {
 572   static GType id;
 573   static GOnce once = G_ONCE_INIT;
 574
 575   g_once (&once, (GThreadFunc) register_gst_format, &id);
 576   return id;
 577 }
 578
 579 /* enumerations from "gstindex.h" */
 580 static void
 581 register_gst_index_certainty (GType * id)
 582 {
 583   static const GEnumValue values[] = {
 584     {GST_INDEX_UNKNOWN, "GST_INDEX_UNKNOWN", "unknown"},
 585     {GST_INDEX_CERTAIN, "GST_INDEX_CERTAIN", "certain"},
 586     {GST_INDEX_FUZZY, "GST_INDEX_FUZZY", "fuzzy"},
 587     {0, NULL, NULL}
 588   };
 589   *id = g_enum_register_static ("GstIndexCertainty", values);
 590 }
 591
 592 GType
 593 gst_index_certainty_get_type (void)
 594 {
 595   static GType id;
 596   static GOnce once = G_ONCE_INIT;
 597
 598   g_once (&once, (GThreadFunc) register_gst_index_certainty, &id);
 599   return id;
 600 }
 601 static void
 602 register_gst_index_entry_type (GType * id)
 603 {
 604   static const GEnumValue values[] = {
 605     {GST_INDEX_ENTRY_ID, "GST_INDEX_ENTRY_ID", "id"},
 606     {GST_INDEX_ENTRY_ASSOCIATION, "GST_INDEX_ENTRY_ASSOCIATION", "association"},
 607     {GST_INDEX_ENTRY_OBJECT, "GST_INDEX_ENTRY_OBJECT", "object"},
 608     {GST_INDEX_ENTRY_FORMAT, "GST_INDEX_ENTRY_FORMAT", "format"},
 609     {0, NULL, NULL}
 610   };
 611   *id = g_enum_register_static ("GstIndexEntryType", values);
 612 }
 613
 614 GType
 615 gst_index_entry_type_get_type (void)
 616 {
 617   static GType id;
 618   static GOnce once = G_ONCE_INIT;
 619
 620   g_once (&once, (GThreadFunc) register_gst_index_entry_type, &id);
 621   return id;
 622 }
 623 static void
 624 register_gst_index_lookup_method (GType * id)
 625 {
 626   static const GEnumValue values[] = {
 627     {GST_INDEX_LOOKUP_EXACT, "GST_INDEX_LOOKUP_EXACT", "exact"},
 628     {GST_INDEX_LOOKUP_BEFORE, "GST_INDEX_LOOKUP_BEFORE", "before"},
 629     {GST_INDEX_LOOKUP_AFTER, "GST_INDEX_LOOKUP_AFTER", "after"},
 630     {0, NULL, NULL}
 631   };
 632   *id = g_enum_register_static ("GstIndexLookupMethod", values);
 633 }
 634
 635 GType
 636 gst_index_lookup_method_get_type (void)
 637 {
 638   static GType id;
 639   static GOnce once = G_ONCE_INIT;
 640
 641   g_once (&once, (GThreadFunc) register_gst_index_lookup_method, &id);
 642   return id;
 643 }
 644 static void
 645 register_gst_assoc_flags (GType * id)
 646 {
 647   static const GFlagsValue values[] = {
 648     {GST_ASSOCIATION_FLAG_NONE, "GST_ASSOCIATION_FLAG_NONE", "none"},
 649     {GST_ASSOCIATION_FLAG_KEY_UNIT, "GST_ASSOCIATION_FLAG_KEY_UNIT",
 650           "key-unit"},
 651     {GST_ASSOCIATION_FLAG_DELTA_UNIT, "GST_ASSOCIATION_FLAG_DELTA_UNIT",
 652           "delta-unit"},
 653     {GST_ASSOCIATION_FLAG_LAST, "GST_ASSOCIATION_FLAG_LAST", "last"},
 654     {0, NULL, NULL}
 655   };
 656   *id = g_flags_register_static ("GstAssocFlags", values);
 657 }
 658
 659 GType
 660 gst_assoc_flags_get_type (void)
 661 {
 662   static GType id;
 663   static GOnce once = G_ONCE_INIT;
 664
 665   g_once (&once, (GThreadFunc) register_gst_assoc_flags, &id);
 666   return id;
 667 }
 668 static void
 669 register_gst_index_resolver_method (GType * id)
 670 {
 671   static const GEnumValue values[] = {
 672     {GST_INDEX_RESOLVER_CUSTOM, "GST_INDEX_RESOLVER_CUSTOM", "custom"},
 673     {GST_INDEX_RESOLVER_GTYPE, "GST_INDEX_RESOLVER_GTYPE", "gtype"},
 674     {GST_INDEX_RESOLVER_PATH, "GST_INDEX_RESOLVER_PATH", "path"},
 675     {0, NULL, NULL}
 676   };
 677   *id = g_enum_register_static ("GstIndexResolverMethod", values);
 678 }
 679
 680 GType
 681 gst_index_resolver_method_get_type (void)
 682 {
 683   static GType id;
 684   static GOnce once = G_ONCE_INIT;
 685
 686   g_once (&once, (GThreadFunc) register_gst_index_resolver_method, &id);
 687   return id;
 688 }
 689 static void
 690 register_gst_index_flags (GType * id)
 691 {
 692   static const GFlagsValue values[] = {
 693     {GST_INDEX_WRITABLE, "GST_INDEX_WRITABLE", "writable"},
 694     {GST_INDEX_READABLE, "GST_INDEX_READABLE", "readable"},
 695     {GST_INDEX_FLAG_LAST, "GST_INDEX_FLAG_LAST", "flag-last"},
 696     {0, NULL, NULL}
 697   };
 698   *id = g_flags_register_static ("GstIndexFlags", values);
 699 }
 700
 701 GType
 702 gst_index_flags_get_type (void)
 703 {
 704   static GType id;
 705   static GOnce once = G_ONCE_INIT;
 706
 707   g_once (&once, (GThreadFunc) register_gst_index_flags, &id);
 708   return id;
 709 }
 710
 711 /* enumerations from "gstinfo.h" */
 712 static void
 713 register_gst_debug_level (GType * id)
 714 {
 715   static const GEnumValue values[] = {
 716     {GST_LEVEL_NONE, "GST_LEVEL_NONE", "none"},
 717     {GST_LEVEL_ERROR, "GST_LEVEL_ERROR", "error"},
 718     {GST_LEVEL_WARNING, "GST_LEVEL_WARNING", "warning"},
 719     {GST_LEVEL_INFO, "GST_LEVEL_INFO", "info"},
 720     {GST_LEVEL_DEBUG, "GST_LEVEL_DEBUG", "debug"},
 721     {GST_LEVEL_LOG, "GST_LEVEL_LOG", "log"},
 722     {GST_LEVEL_COUNT, "GST_LEVEL_COUNT", "count"},
 723     {0, NULL, NULL}
 724   };
 725   *id = g_enum_register_static ("GstDebugLevel", values);
 726 }
 727
 728 GType
 729 gst_debug_level_get_type (void)
 730 {
 731   static GType id;
 732   static GOnce once = G_ONCE_INIT;
 733
 734   g_once (&once, (GThreadFunc) register_gst_debug_level, &id);
 735   return id;
 736 }
 737 static void
 738 register_gst_debug_color_flags (GType * id)
 739 {
 740   static const GEnumValue values[] = {
 741     {GST_DEBUG_FG_BLACK, "GST_DEBUG_FG_BLACK", "fg-black"},
 742     {GST_DEBUG_FG_RED, "GST_DEBUG_FG_RED", "fg-red"},
 743     {GST_DEBUG_FG_GREEN, "GST_DEBUG_FG_GREEN", "fg-green"},
 744     {GST_DEBUG_FG_YELLOW, "GST_DEBUG_FG_YELLOW", "fg-yellow"},
 745     {GST_DEBUG_FG_BLUE, "GST_DEBUG_FG_BLUE", "fg-blue"},
 746     {GST_DEBUG_FG_MAGENTA, "GST_DEBUG_FG_MAGENTA", "fg-magenta"},
 747     {GST_DEBUG_FG_CYAN, "GST_DEBUG_FG_CYAN", "fg-cyan"},
 748     {GST_DEBUG_FG_WHITE, "GST_DEBUG_FG_WHITE", "fg-white"},
 749     {GST_DEBUG_BG_BLACK, "GST_DEBUG_BG_BLACK", "bg-black"},
 750     {GST_DEBUG_BG_RED, "GST_DEBUG_BG_RED", "bg-red"},
 751     {GST_DEBUG_BG_GREEN, "GST_DEBUG_BG_GREEN", "bg-green"},
 752     {GST_DEBUG_BG_YELLOW, "GST_DEBUG_BG_YELLOW", "bg-yellow"},
 753     {GST_DEBUG_BG_BLUE, "GST_DEBUG_BG_BLUE", "bg-blue"},
 754     {GST_DEBUG_BG_MAGENTA, "GST_DEBUG_BG_MAGENTA", "bg-magenta"},
 755     {GST_DEBUG_BG_CYAN, "GST_DEBUG_BG_CYAN", "bg-cyan"},
 756     {GST_DEBUG_BG_WHITE, "GST_DEBUG_BG_WHITE", "bg-white"},
 757     {GST_DEBUG_BOLD, "GST_DEBUG_BOLD", "bold"},
 758     {GST_DEBUG_UNDERLINE, "GST_DEBUG_UNDERLINE", "underline"},
 759     {0, NULL, NULL}
 760   };
 761   *id = g_enum_register_static ("GstDebugColorFlags", values);
 762 }
 763
 764 GType
 765 gst_debug_color_flags_get_type (void)
 766 {
 767   static GType id;
 768   static GOnce once = G_ONCE_INIT;
 769
 770   g_once (&once, (GThreadFunc) register_gst_debug_color_flags, &id);
 771   return id;
 772 }
 773
 774 /* enumerations from "gstiterator.h" */
 775 static void
 776 register_gst_iterator_result (GType * id)
 777 {
 778   static const GEnumValue values[] = {
 779     {GST_ITERATOR_DONE, "GST_ITERATOR_DONE", "done"},
 780     {GST_ITERATOR_OK, "GST_ITERATOR_OK", "ok"},
 781     {GST_ITERATOR_RESYNC, "GST_ITERATOR_RESYNC", "resync"},
 782     {GST_ITERATOR_ERROR, "GST_ITERATOR_ERROR", "error"},
 783     {0, NULL, NULL}
 784   };
 785   *id = g_enum_register_static ("GstIteratorResult", values);
 786 }
 787
 788 GType
 789 gst_iterator_result_get_type (void)
 790 {
 791   static GType id;
 792   static GOnce once = G_ONCE_INIT;
 793
 794   g_once (&once, (GThreadFunc) register_gst_iterator_result, &id);
 795   return id;
 796 }
 797 static void
 798 register_gst_iterator_item (GType * id)
 799 {
 800   static const GEnumValue values[] = {
 801     {GST_ITERATOR_ITEM_SKIP, "GST_ITERATOR_ITEM_SKIP", "skip"},
 802     {GST_ITERATOR_ITEM_PASS, "GST_ITERATOR_ITEM_PASS", "pass"},
 803     {GST_ITERATOR_ITEM_END, "GST_ITERATOR_ITEM_END", "end"},
 804     {0, NULL, NULL}
 805   };
 806   *id = g_enum_register_static ("GstIteratorItem", values);
 807 }
 808
 809 GType
 810 gst_iterator_item_get_type (void)
 811 {
 812   static GType id;
 813   static GOnce once = G_ONCE_INIT;
 814
 815   g_once (&once, (GThreadFunc) register_gst_iterator_item, &id);
 816   return id;
 817 }
 818
 819 /* enumerations from "gstmessage.h" */
 820 static void
 821 register_gst_message_type (GType * id)
 822 {
 823   static const GFlagsValue values[] = {
 824     {GST_MESSAGE_UNKNOWN, "GST_MESSAGE_UNKNOWN", "unknown"},
 825     {GST_MESSAGE_EOS, "GST_MESSAGE_EOS", "eos"},
 826     {GST_MESSAGE_ERROR, "GST_MESSAGE_ERROR", "error"},
 827     {GST_MESSAGE_WARNING, "GST_MESSAGE_WARNING", "warning"},
 828     {GST_MESSAGE_INFO, "GST_MESSAGE_INFO", "info"},
 829     {GST_MESSAGE_TAG, "GST_MESSAGE_TAG", "tag"},
 830     {GST_MESSAGE_BUFFERING, "GST_MESSAGE_BUFFERING", "buffering"},
 831     {GST_MESSAGE_STATE_CHANGED, "GST_MESSAGE_STATE_CHANGED", "state-changed"},
 832     {GST_MESSAGE_STATE_DIRTY, "GST_MESSAGE_STATE_DIRTY", "state-dirty"},
 833     {GST_MESSAGE_STEP_DONE, "GST_MESSAGE_STEP_DONE", "step-done"},
 834     {GST_MESSAGE_CLOCK_PROVIDE, "GST_MESSAGE_CLOCK_PROVIDE", "clock-provide"},
 835     {GST_MESSAGE_CLOCK_LOST, "GST_MESSAGE_CLOCK_LOST", "clock-lost"},
 836     {GST_MESSAGE_NEW_CLOCK, "GST_MESSAGE_NEW_CLOCK", "new-clock"},
 837     {GST_MESSAGE_STRUCTURE_CHANGE, "GST_MESSAGE_STRUCTURE_CHANGE",
 838           "structure-change"},
 839     {GST_MESSAGE_STREAM_STATUS, "GST_MESSAGE_STREAM_STATUS", "stream-status"},
 840     {GST_MESSAGE_APPLICATION, "GST_MESSAGE_APPLICATION", "application"},
 841     {GST_MESSAGE_ELEMENT, "GST_MESSAGE_ELEMENT", "element"},
 842     {GST_MESSAGE_SEGMENT_START, "GST_MESSAGE_SEGMENT_START", "segment-start"},
 843     {GST_MESSAGE_SEGMENT_DONE, "GST_MESSAGE_SEGMENT_DONE", "segment-done"},
 844     {GST_MESSAGE_DURATION, "GST_MESSAGE_DURATION", "duration"},
 845     {GST_MESSAGE_ANY, "GST_MESSAGE_ANY", "any"},
 846     {0, NULL, NULL}
 847   };
 848   *id = g_flags_register_static ("GstMessageType", values);
 849 }
 850
 851 GType
 852 gst_message_type_get_type (void)
 853 {
 854   static GType id;
 855   static GOnce once = G_ONCE_INIT;
 856
 857   g_once (&once, (GThreadFunc) register_gst_message_type, &id);
 858   return id;
 859 }
 860
 861 /* enumerations from "gstminiobject.h" */
 862 static void
 863 register_gst_mini_object_flags (GType * id)
 864 {
 865   static const GFlagsValue values[] = {
 866     {GST_MINI_OBJECT_FLAG_READONLY, "GST_MINI_OBJECT_FLAG_READONLY",
 867           "readonly"},
 868     {GST_MINI_OBJECT_FLAG_LAST, "GST_MINI_OBJECT_FLAG_LAST", "last"},
 869     {0, NULL, NULL}
 870   };
 871   *id = g_flags_register_static ("GstMiniObjectFlags", values);
 872 }
 873
 874 GType
 875 gst_mini_object_flags_get_type (void)
 876 {
 877   static GType id;
 878   static GOnce once = G_ONCE_INIT;
 879
 880   g_once (&once, (GThreadFunc) register_gst_mini_object_flags, &id);
 881   return id;
 882 }
 883
 884 /* enumerations from "gstpad.h" */
 885 static void
 886 register_gst_pad_link_return (GType * id)
 887 {
 888   static const GEnumValue values[] = {
 889     {GST_PAD_LINK_OK, "GST_PAD_LINK_OK", "ok"},
 890     {GST_PAD_LINK_WRONG_HIERARCHY, "GST_PAD_LINK_WRONG_HIERARCHY",
 891           "wrong-hierarchy"},
 892     {GST_PAD_LINK_WAS_LINKED, "GST_PAD_LINK_WAS_LINKED", "was-linked"},
 893     {GST_PAD_LINK_WRONG_DIRECTION, "GST_PAD_LINK_WRONG_DIRECTION",
 894           "wrong-direction"},
 895     {GST_PAD_LINK_NOFORMAT, "GST_PAD_LINK_NOFORMAT", "noformat"},
 896     {GST_PAD_LINK_NOSCHED, "GST_PAD_LINK_NOSCHED", "nosched"},
 897     {GST_PAD_LINK_REFUSED, "GST_PAD_LINK_REFUSED", "refused"},
 898     {0, NULL, NULL}
 899   };
 900   *id = g_enum_register_static ("GstPadLinkReturn", values);
 901 }
 902
 903 GType
 904 gst_pad_link_return_get_type (void)
 905 {
 906   static GType id;
 907   static GOnce once = G_ONCE_INIT;
 908
 909   g_once (&once, (GThreadFunc) register_gst_pad_link_return, &id);
 910   return id;
 911 }
 912 static void
 913 register_gst_flow_return (GType * id)
 914 {
 915   static const GEnumValue values[] = {
 916     {GST_FLOW_RESEND, "GST_FLOW_RESEND", "resend"},
 917     {GST_FLOW_OK, "GST_FLOW_OK", "ok"},
 918     {GST_FLOW_NOT_LINKED, "GST_FLOW_NOT_LINKED", "not-linked"},
 919     {GST_FLOW_WRONG_STATE, "GST_FLOW_WRONG_STATE", "wrong-state"},
 920     {GST_FLOW_UNEXPECTED, "GST_FLOW_UNEXPECTED", "unexpected"},
 921     {GST_FLOW_NOT_NEGOTIATED, "GST_FLOW_NOT_NEGOTIATED", "not-negotiated"},
 922     {GST_FLOW_ERROR, "GST_FLOW_ERROR", "error"},
 923     {GST_FLOW_NOT_SUPPORTED, "GST_FLOW_NOT_SUPPORTED", "not-supported"},
 924     {0, NULL, NULL}
 925   };
 926   *id = g_enum_register_static ("GstFlowReturn", values);
 927 }
 928
 929 GType
 930 gst_flow_return_get_type (void)
 931 {
 932   static GType id;
 933   static GOnce once = G_ONCE_INIT;
 934
 935   g_once (&once, (GThreadFunc) register_gst_flow_return, &id);
 936   return id;
 937 }
 938 static void
 939 register_gst_activate_mode (GType * id)
 940 {
 941   static const GEnumValue values[] = {
 942     {GST_ACTIVATE_NONE, "GST_ACTIVATE_NONE", "none"},
 943     {GST_ACTIVATE_PUSH, "GST_ACTIVATE_PUSH", "push"},
 944     {GST_ACTIVATE_PULL, "GST_ACTIVATE_PULL", "pull"},
 945     {0, NULL, NULL}
 946   };
 947   *id = g_enum_register_static ("GstActivateMode", values);
 948 }
 949
 950 GType
 951 gst_activate_mode_get_type (void)
 952 {
 953   static GType id;
 954   static GOnce once = G_ONCE_INIT;
 955
 956   g_once (&once, (GThreadFunc) register_gst_activate_mode, &id);
 957   return id;
 958 }
 959 static void
 960 register_gst_pad_direction (GType * id)
 961 {
 962   static const GEnumValue values[] = {
 963     {GST_PAD_UNKNOWN, "GST_PAD_UNKNOWN", "unknown"},
 964     {GST_PAD_SRC, "GST_PAD_SRC", "src"},
 965     {GST_PAD_SINK, "GST_PAD_SINK", "sink"},
 966     {0, NULL, NULL}
 967   };
 968   *id = g_enum_register_static ("GstPadDirection", values);
 969 }
 970
 971 GType
 972 gst_pad_direction_get_type (void)
 973 {
 974   static GType id;
 975   static GOnce once = G_ONCE_INIT;
 976
 977   g_once (&once, (GThreadFunc) register_gst_pad_direction, &id);
 978   return id;
 979 }
 980 static void
 981 register_gst_pad_flags (GType * id)
 982 {
 983   static const GFlagsValue values[] = {
 984     {GST_PAD_BLOCKED, "GST_PAD_BLOCKED", "blocked"},
 985     {GST_PAD_FLUSHING, "GST_PAD_FLUSHING", "flushing"},
 986     {GST_PAD_IN_GETCAPS, "GST_PAD_IN_GETCAPS", "in-getcaps"},
 987     {GST_PAD_IN_SETCAPS, "GST_PAD_IN_SETCAPS", "in-setcaps"},
 988     {GST_PAD_FLAG_LAST, "GST_PAD_FLAG_LAST", "flag-last"},
 989     {0, NULL, NULL}
 990   };
 991   *id = g_flags_register_static ("GstPadFlags", values);
 992 }
 993
 994 GType
 995 gst_pad_flags_get_type (void)
 996 {
 997   static GType id;
 998   static GOnce once = G_ONCE_INIT;
 999
1000   g_once (&once, (GThreadFunc) register_gst_pad_flags, &id);
1001   return id;
1002 }
1003
1004 /* enumerations from "gstpadtemplate.h" */
1005 static void
1006 register_gst_pad_presence (GType * id)
1007 {
1008   static const GEnumValue values[] = {
1009     {GST_PAD_ALWAYS, "GST_PAD_ALWAYS", "always"},
1010     {GST_PAD_SOMETIMES, "GST_PAD_SOMETIMES", "sometimes"},
1011     {GST_PAD_REQUEST, "GST_PAD_REQUEST", "request"},
1012     {0, NULL, NULL}
1013   };
1014   *id = g_enum_register_static ("GstPadPresence", values);
1015 }
1016
1017 GType
1018 gst_pad_presence_get_type (void)
1019 {
1020   static GType id;
1021   static GOnce once = G_ONCE_INIT;
1022
1023   g_once (&once, (GThreadFunc) register_gst_pad_presence, &id);
1024   return id;
1025 }
1026 static void
1027 register_gst_pad_template_flags (GType * id)
1028 {
1029   static const GFlagsValue values[] = {
1030     {GST_PAD_TEMPLATE_FIXED, "GST_PAD_TEMPLATE_FIXED", "fixed"},
1031     {GST_PAD_TEMPLATE_FLAG_LAST, "GST_PAD_TEMPLATE_FLAG_LAST", "flag-last"},
1032     {0, NULL, NULL}
1033   };
1034   *id = g_flags_register_static ("GstPadTemplateFlags", values);
1035 }
1036
1037 GType
1038 gst_pad_template_flags_get_type (void)
1039 {
1040   static GType id;
1041   static GOnce once = G_ONCE_INIT;
1042
1043   g_once (&once, (GThreadFunc) register_gst_pad_template_flags, &id);
1044   return id;
1045 }
1046
1047 /* enumerations from "gstpipeline.h" */
1048 static void
1049 register_gst_pipeline_flags (GType * id)
1050 {
1051   static const GFlagsValue values[] = {
1052     {GST_PIPELINE_FLAG_FIXED_CLOCK, "GST_PIPELINE_FLAG_FIXED_CLOCK",
1053           "fixed-clock"},
1054     {GST_PIPELINE_FLAG_LAST, "GST_PIPELINE_FLAG_LAST", "last"},
1055     {0, NULL, NULL}
1056   };
1057   *id = g_flags_register_static ("GstPipelineFlags", values);
1058 }
1059
1060 GType
1061 gst_pipeline_flags_get_type (void)
1062 {
1063   static GType id;
1064   static GOnce once = G_ONCE_INIT;
1065
1066   g_once (&once, (GThreadFunc) register_gst_pipeline_flags, &id);
1067   return id;
1068 }
1069
1070 /* enumerations from "gstplugin.h" */
1071 static void
1072 register_gst_plugin_error (GType * id)
1073 {
1074   static const GEnumValue values[] = {
1075     {GST_PLUGIN_ERROR_MODULE, "GST_PLUGIN_ERROR_MODULE", "module"},
1076     {GST_PLUGIN_ERROR_DEPENDENCIES, "GST_PLUGIN_ERROR_DEPENDENCIES",
1077           "dependencies"},
1078     {GST_PLUGIN_ERROR_NAME_MISMATCH, "GST_PLUGIN_ERROR_NAME_MISMATCH",
1079           "name-mismatch"},
1080     {0, NULL, NULL}
1081   };
1082   *id = g_enum_register_static ("GstPluginError", values);
1083 }
1084
1085 GType
1086 gst_plugin_error_get_type (void)
1087 {
1088   static GType id;
1089   static GOnce once = G_ONCE_INIT;
1090
1091   g_once (&once, (GThreadFunc) register_gst_plugin_error, &id);
1092   return id;
1093 }
1094 static void
1095 register_gst_plugin_flags (GType * id)
1096 {
1097   static const GFlagsValue values[] = {
1098     {GST_PLUGIN_FLAG_CACHED, "GST_PLUGIN_FLAG_CACHED", "cached"},
1099     {0, NULL, NULL}
1100   };
1101   *id = g_flags_register_static ("GstPluginFlags", values);
1102 }
1103
1104 GType
1105 gst_plugin_flags_get_type (void)
1106 {
1107   static GType id;
1108   static GOnce once = G_ONCE_INIT;
1109
1110   g_once (&once, (GThreadFunc) register_gst_plugin_flags, &id);
1111   return id;
1112 }
1113
1114 /* enumerations from "gstpluginfeature.h" */
1115 static void
1116 register_gst_rank (GType * id)
1117 {
1118   static const GEnumValue values[] = {
1119     {GST_RANK_NONE, "GST_RANK_NONE", "none"},
1120     {GST_RANK_MARGINAL, "GST_RANK_MARGINAL", "marginal"},
1121     {GST_RANK_SECONDARY, "GST_RANK_SECONDARY", "secondary"},
1122     {GST_RANK_PRIMARY, "GST_RANK_PRIMARY", "primary"},
1123     {0, NULL, NULL}
1124   };
1125   *id = g_enum_register_static ("GstRank", values);
1126 }
1127
1128 GType
1129 gst_rank_get_type (void)
1130 {
1131   static GType id;
1132   static GOnce once = G_ONCE_INIT;
1133
1134   g_once (&once, (GThreadFunc) register_gst_rank, &id);
1135   return id;
1136 }
1137
1138 /* enumerations from "gstquery.h" */
1139 static void
1140 register_gst_query_type (GType * id)
1141 {
1142   static const GEnumValue values[] = {
1143     {GST_QUERY_NONE, "GST_QUERY_NONE", "none"},
1144     {GST_QUERY_POSITION, "GST_QUERY_POSITION", "position"},
1145     {GST_QUERY_DURATION, "GST_QUERY_DURATION", "duration"},
1146     {GST_QUERY_LATENCY, "GST_QUERY_LATENCY", "latency"},
1147     {GST_QUERY_JITTER, "GST_QUERY_JITTER", "jitter"},
1148     {GST_QUERY_RATE, "GST_QUERY_RATE", "rate"},
1149     {GST_QUERY_SEEKING, "GST_QUERY_SEEKING", "seeking"},
1150     {GST_QUERY_SEGMENT, "GST_QUERY_SEGMENT", "segment"},
1151     {GST_QUERY_CONVERT, "GST_QUERY_CONVERT", "convert"},
1152     {GST_QUERY_FORMATS, "GST_QUERY_FORMATS", "formats"},
1153     {0, NULL, NULL}
1154   };
1155   *id = g_enum_register_static ("GstQueryType", values);
1156 }
1157
1158 GType
1159 gst_query_type_get_type (void)
1160 {
1161   static GType id;
1162   static GOnce once = G_ONCE_INIT;
1163
1164   g_once (&once, (GThreadFunc) register_gst_query_type, &id);
1165   return id;
1166 }
1167
1168 /* enumerations from "gsttaglist.h" */
1169 static void
1170 register_gst_tag_merge_mode (GType * id)
1171 {
1172   static const GEnumValue values[] = {
1173     {GST_TAG_MERGE_UNDEFINED, "GST_TAG_MERGE_UNDEFINED", "undefined"},
1174     {GST_TAG_MERGE_REPLACE_ALL, "GST_TAG_MERGE_REPLACE_ALL", "replace-all"},
1175     {GST_TAG_MERGE_REPLACE, "GST_TAG_MERGE_REPLACE", "replace"},
1176     {GST_TAG_MERGE_APPEND, "GST_TAG_MERGE_APPEND", "append"},
1177     {GST_TAG_MERGE_PREPEND, "GST_TAG_MERGE_PREPEND", "prepend"},
1178     {GST_TAG_MERGE_KEEP, "GST_TAG_MERGE_KEEP", "keep"},
1179     {GST_TAG_MERGE_KEEP_ALL, "GST_TAG_MERGE_KEEP_ALL", "keep-all"},
1180     {GST_TAG_MERGE_COUNT, "GST_TAG_MERGE_COUNT", "count"},
1181     {0, NULL, NULL}
1182   };
1183   *id = g_enum_register_static ("GstTagMergeMode", values);
1184 }
1185
1186 GType
1187 gst_tag_merge_mode_get_type (void)
1188 {
1189   static GType id;
1190   static GOnce once = G_ONCE_INIT;
1191
1192   g_once (&once, (GThreadFunc) register_gst_tag_merge_mode, &id);
1193   return id;
1194 }
1195 static void
1196 register_gst_tag_flag (GType * id)
1197 {
1198   static const GEnumValue values[] = {
1199     {GST_TAG_FLAG_UNDEFINED, "GST_TAG_FLAG_UNDEFINED", "undefined"},
1200     {GST_TAG_FLAG_META, "GST_TAG_FLAG_META", "meta"},
1201     {GST_TAG_FLAG_ENCODED, "GST_TAG_FLAG_ENCODED", "encoded"},
1202     {GST_TAG_FLAG_DECODED, "GST_TAG_FLAG_DECODED", "decoded"},
1203     {GST_TAG_FLAG_COUNT, "GST_TAG_FLAG_COUNT", "count"},
1204     {0, NULL, NULL}
1205   };
1206   *id = g_enum_register_static ("GstTagFlag", values);
1207 }
1208
1209 GType
1210 gst_tag_flag_get_type (void)
1211 {
1212   static GType id;
1213   static GOnce once = G_ONCE_INIT;
1214
1215   g_once (&once, (GThreadFunc) register_gst_tag_flag, &id);
1216   return id;
1217 }
1218
1219 /* enumerations from "gsttask.h" */
1220 static void
1221 register_gst_task_state (GType * id)
1222 {
1223   static const GEnumValue values[] = {
1224     {GST_TASK_STARTED, "GST_TASK_STARTED", "started"},
1225     {GST_TASK_STOPPED, "GST_TASK_STOPPED", "stopped"},
1226     {GST_TASK_PAUSED, "GST_TASK_PAUSED", "paused"},
1227     {0, NULL, NULL}
1228   };
1229   *id = g_enum_register_static ("GstTaskState", values);
1230 }
1231
1232 GType
1233 gst_task_state_get_type (void)
1234 {
1235   static GType id;
1236   static GOnce once = G_ONCE_INIT;
1237
1238   g_once (&once, (GThreadFunc) register_gst_task_state, &id);
1239   return id;
1240 }
1241
1242 /* enumerations from "gsttrace.h" */
1243 static void
1244 register_gst_alloc_trace_flags (GType * id)
1245 {
1246   static const GFlagsValue values[] = {
1247     {GST_ALLOC_TRACE_LIVE, "GST_ALLOC_TRACE_LIVE", "live"},
1248     {GST_ALLOC_TRACE_MEM_LIVE, "GST_ALLOC_TRACE_MEM_LIVE", "mem-live"},
1249     {0, NULL, NULL}
1250   };
1251   *id = g_flags_register_static ("GstAllocTraceFlags", values);
1252 }
1253
1254 GType
1255 gst_alloc_trace_flags_get_type (void)
1256 {
1257   static GType id;
1258   static GOnce once = G_ONCE_INIT;
1259
1260   g_once (&once, (GThreadFunc) register_gst_alloc_trace_flags, &id);
1261   return id;
1262 }
1263
1264 /* enumerations from "gsttypefind.h" */
1265 static void
1266 register_gst_type_find_probability (GType * id)
1267 {
1268   static const GEnumValue values[] = {
1269     {GST_TYPE_FIND_MINIMUM, "GST_TYPE_FIND_MINIMUM", "minimum"},
1270     {GST_TYPE_FIND_POSSIBLE, "GST_TYPE_FIND_POSSIBLE", "possible"},
1271     {GST_TYPE_FIND_LIKELY, "GST_TYPE_FIND_LIKELY", "likely"},
1272     {GST_TYPE_FIND_NEARLY_CERTAIN, "GST_TYPE_FIND_NEARLY_CERTAIN",
1273           "nearly-certain"},
1274     {GST_TYPE_FIND_MAXIMUM, "GST_TYPE_FIND_MAXIMUM", "maximum"},
1275     {0, NULL, NULL}
1276   };
1277   *id = g_enum_register_static ("GstTypeFindProbability", values);
1278 }
1279
1280 GType
1281 gst_type_find_probability_get_type (void)
1282 {
1283   static GType id;
1284   static GOnce once = G_ONCE_INIT;
1285
1286   g_once (&once, (GThreadFunc) register_gst_type_find_probability, &id);
1287   return id;
1288 }
1289
1290 /* enumerations from "gsturi.h" */
1291 static void
1292 register_gst_uri_type (GType * id)
1293 {
1294   static const GEnumValue values[] = {
1295     {GST_URI_UNKNOWN, "GST_URI_UNKNOWN", "unknown"},
1296     {GST_URI_SINK, "GST_URI_SINK", "sink"},
1297     {GST_URI_SRC, "GST_URI_SRC", "src"},
1298     {0, NULL, NULL}
1299   };
1300   *id = g_enum_register_static ("GstURIType", values);
1301 }
1302
1303 GType
1304 gst_uri_type_get_type (void)
1305 {
1306   static GType id;
1307   static GOnce once = G_ONCE_INIT;
1308
1309   g_once (&once, (GThreadFunc) register_gst_uri_type, &id);
1310   return id;
1311 }
1312
1313 /* enumerations from "gstparse.h" */
1314 static void
1315 register_gst_parse_error (GType * id)
1316 {
1317   static const GEnumValue values[] = {
1318     {GST_PARSE_ERROR_SYNTAX, "GST_PARSE_ERROR_SYNTAX", "syntax"},
1319     {GST_PARSE_ERROR_NO_SUCH_ELEMENT, "GST_PARSE_ERROR_NO_SUCH_ELEMENT",
1320           "no-such-element"},
1321     {GST_PARSE_ERROR_NO_SUCH_PROPERTY, "GST_PARSE_ERROR_NO_SUCH_PROPERTY",
1322           "no-such-property"},
1323     {GST_PARSE_ERROR_LINK, "GST_PARSE_ERROR_LINK", "link"},
1324     {GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
1325           "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY", "could-not-set-property"},
1326     {GST_PARSE_ERROR_EMPTY_BIN, "GST_PARSE_ERROR_EMPTY_BIN", "empty-bin"},
1327     {GST_PARSE_ERROR_EMPTY, "GST_PARSE_ERROR_EMPTY", "empty"},
1328     {0, NULL, NULL}
1329   };
1330   *id = g_enum_register_static ("GstParseError", values);
1331 }
1332
1333 GType
1334 gst_parse_error_get_type (void)
1335 {
1336   static GType id;
1337   static GOnce once = G_ONCE_INIT;
1338
1339   g_once (&once, (GThreadFunc) register_gst_parse_error, &id);
1340   return id;
1341 }
1342
1343 /* Generated data ends here */