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_NO_SPACE_LEFT, "GST_RESOURCE_ERROR_NO_SPACE_LEFT",
 401         "no-space-left"},
 402     {GST_RESOURCE_ERROR_NUM_ERRORS, "GST_RESOURCE_ERROR_NUM_ERRORS",
 403         "num-errors"},
 404     {0, NULL, NULL}
 405   };
 406   *id = g_enum_register_static ("GstResourceError", values);
 407 }
 408
 409 GType
 410 gst_resource_error_get_type (void)
 411 {
 412   static GType id;
 413   static GOnce once = G_ONCE_INIT;
 414
 415   g_once (&once, (GThreadFunc) register_gst_resource_error, &id);
 416   return id;
 417 }
 418 static void
 419 register_gst_stream_error (GType * id)
 420 {
 421   static const GEnumValue values[] = {
 422     {GST_STREAM_ERROR_FAILED, "GST_STREAM_ERROR_FAILED", "failed"},
 423     {GST_STREAM_ERROR_TOO_LAZY, "GST_STREAM_ERROR_TOO_LAZY", "too-lazy"},
 424     {GST_STREAM_ERROR_NOT_IMPLEMENTED, "GST_STREAM_ERROR_NOT_IMPLEMENTED",
 425         "not-implemented"},
 426     {GST_STREAM_ERROR_TYPE_NOT_FOUND, "GST_STREAM_ERROR_TYPE_NOT_FOUND",
 427         "type-not-found"},
 428     {GST_STREAM_ERROR_WRONG_TYPE, "GST_STREAM_ERROR_WRONG_TYPE", "wrong-type"},
 429     {GST_STREAM_ERROR_CODEC_NOT_FOUND, "GST_STREAM_ERROR_CODEC_NOT_FOUND",
 430         "codec-not-found"},
 431     {GST_STREAM_ERROR_DECODE, "GST_STREAM_ERROR_DECODE", "decode"},
 432     {GST_STREAM_ERROR_ENCODE, "GST_STREAM_ERROR_ENCODE", "encode"},
 433     {GST_STREAM_ERROR_DEMUX, "GST_STREAM_ERROR_DEMUX", "demux"},
 434     {GST_STREAM_ERROR_MUX, "GST_STREAM_ERROR_MUX", "mux"},
 435     {GST_STREAM_ERROR_FORMAT, "GST_STREAM_ERROR_FORMAT", "format"},
 436     {GST_STREAM_ERROR_NUM_ERRORS, "GST_STREAM_ERROR_NUM_ERRORS", "num-errors"},
 437     {0, NULL, NULL}
 438   };
 439   *id = g_enum_register_static ("GstStreamError", values);
 440 }
 441
 442 GType
 443 gst_stream_error_get_type (void)
 444 {
 445   static GType id;
 446   static GOnce once = G_ONCE_INIT;
 447
 448   g_once (&once, (GThreadFunc) register_gst_stream_error, &id);
 449   return id;
 450 }
 451
 452 /* enumerations from "gstevent.h" */
 453 static void
 454 register_gst_event_type_flags (GType * id)
 455 {
 456   static const GFlagsValue values[] = {
 457     {GST_EVENT_TYPE_UPSTREAM, "GST_EVENT_TYPE_UPSTREAM", "upstream"},
 458     {GST_EVENT_TYPE_DOWNSTREAM, "GST_EVENT_TYPE_DOWNSTREAM", "downstream"},
 459     {GST_EVENT_TYPE_SERIALIZED, "GST_EVENT_TYPE_SERIALIZED", "serialized"},
 460     {0, NULL, NULL}
 461   };
 462   *id = g_flags_register_static ("GstEventTypeFlags", values);
 463 }
 464
 465 GType
 466 gst_event_type_flags_get_type (void)
 467 {
 468   static GType id;
 469   static GOnce once = G_ONCE_INIT;
 470
 471   g_once (&once, (GThreadFunc) register_gst_event_type_flags, &id);
 472   return id;
 473 }
 474 static void
 475 register_gst_event_type (GType * id)
 476 {
 477   static const GEnumValue values[] = {
 478     {GST_EVENT_UNKNOWN, "GST_EVENT_UNKNOWN", "unknown"},
 479     {GST_EVENT_FLUSH_START, "GST_EVENT_FLUSH_START", "flush-start"},
 480     {GST_EVENT_FLUSH_STOP, "GST_EVENT_FLUSH_STOP", "flush-stop"},
 481     {GST_EVENT_EOS, "GST_EVENT_EOS", "eos"},
 482     {GST_EVENT_NEWSEGMENT, "GST_EVENT_NEWSEGMENT", "newsegment"},
 483     {GST_EVENT_TAG, "GST_EVENT_TAG", "tag"},
 484     {GST_EVENT_BUFFERSIZE, "GST_EVENT_BUFFERSIZE", "buffersize"},
 485     {GST_EVENT_QOS, "GST_EVENT_QOS", "qos"},
 486     {GST_EVENT_SEEK, "GST_EVENT_SEEK", "seek"},
 487     {GST_EVENT_NAVIGATION, "GST_EVENT_NAVIGATION", "navigation"},
 488     {GST_EVENT_CUSTOM_UPSTREAM, "GST_EVENT_CUSTOM_UPSTREAM", "custom-upstream"},
 489     {GST_EVENT_CUSTOM_DOWNSTREAM, "GST_EVENT_CUSTOM_DOWNSTREAM",
 490         "custom-downstream"},
 491     {GST_EVENT_CUSTOM_DOWNSTREAM_OOB, "GST_EVENT_CUSTOM_DOWNSTREAM_OOB",
 492         "custom-downstream-oob"},
 493     {GST_EVENT_CUSTOM_BOTH, "GST_EVENT_CUSTOM_BOTH", "custom-both"},
 494     {GST_EVENT_CUSTOM_BOTH_OOB, "GST_EVENT_CUSTOM_BOTH_OOB", "custom-both-oob"},
 495     {0, NULL, NULL}
 496   };
 497   *id = g_enum_register_static ("GstEventType", values);
 498 }
 499
 500 GType
 501 gst_event_type_get_type (void)
 502 {
 503   static GType id;
 504   static GOnce once = G_ONCE_INIT;
 505
 506   g_once (&once, (GThreadFunc) register_gst_event_type, &id);
 507   return id;
 508 }
 509 static void
 510 register_gst_seek_type (GType * id)
 511 {
 512   static const GEnumValue values[] = {
 513     {GST_SEEK_TYPE_NONE, "GST_SEEK_TYPE_NONE", "none"},
 514     {GST_SEEK_TYPE_CUR, "GST_SEEK_TYPE_CUR", "cur"},
 515     {GST_SEEK_TYPE_SET, "GST_SEEK_TYPE_SET", "set"},
 516     {GST_SEEK_TYPE_END, "GST_SEEK_TYPE_END", "end"},
 517     {0, NULL, NULL}
 518   };
 519   *id = g_enum_register_static ("GstSeekType", values);
 520 }
 521
 522 GType
 523 gst_seek_type_get_type (void)
 524 {
 525   static GType id;
 526   static GOnce once = G_ONCE_INIT;
 527
 528   g_once (&once, (GThreadFunc) register_gst_seek_type, &id);
 529   return id;
 530 }
 531 static void
 532 register_gst_seek_flags (GType * id)
 533 {
 534   static const GFlagsValue values[] = {
 535     {GST_SEEK_FLAG_NONE, "GST_SEEK_FLAG_NONE", "none"},
 536     {GST_SEEK_FLAG_FLUSH, "GST_SEEK_FLAG_FLUSH", "flush"},
 537     {GST_SEEK_FLAG_ACCURATE, "GST_SEEK_FLAG_ACCURATE", "accurate"},
 538     {GST_SEEK_FLAG_KEY_UNIT, "GST_SEEK_FLAG_KEY_UNIT", "key-unit"},
 539     {GST_SEEK_FLAG_SEGMENT, "GST_SEEK_FLAG_SEGMENT", "segment"},
 540     {0, NULL, NULL}
 541   };
 542   *id = g_flags_register_static ("GstSeekFlags", values);
 543 }
 544
 545 GType
 546 gst_seek_flags_get_type (void)
 547 {
 548   static GType id;
 549   static GOnce once = G_ONCE_INIT;
 550
 551   g_once (&once, (GThreadFunc) register_gst_seek_flags, &id);
 552   return id;
 553 }
 554
 555 /* enumerations from "gstformat.h" */
 556 static void
 557 register_gst_format (GType * id)
 558 {
 559   static const GEnumValue values[] = {
 560     {GST_FORMAT_UNDEFINED, "GST_FORMAT_UNDEFINED", "undefined"},
 561     {GST_FORMAT_DEFAULT, "GST_FORMAT_DEFAULT", "default"},
 562     {GST_FORMAT_BYTES, "GST_FORMAT_BYTES", "bytes"},
 563     {GST_FORMAT_TIME, "GST_FORMAT_TIME", "time"},
 564     {GST_FORMAT_BUFFERS, "GST_FORMAT_BUFFERS", "buffers"},
 565     {GST_FORMAT_PERCENT, "GST_FORMAT_PERCENT", "percent"},
 566     {0, NULL, NULL}
 567   };
 568   *id = g_enum_register_static ("GstFormat", values);
 569 }
 570
 571 GType
 572 gst_format_get_type (void)
 573 {
 574   static GType id;
 575   static GOnce once = G_ONCE_INIT;
 576
 577   g_once (&once, (GThreadFunc) register_gst_format, &id);
 578   return id;
 579 }
 580
 581 /* enumerations from "gstindex.h" */
 582 static void
 583 register_gst_index_certainty (GType * id)
 584 {
 585   static const GEnumValue values[] = {
 586     {GST_INDEX_UNKNOWN, "GST_INDEX_UNKNOWN", "unknown"},
 587     {GST_INDEX_CERTAIN, "GST_INDEX_CERTAIN", "certain"},
 588     {GST_INDEX_FUZZY, "GST_INDEX_FUZZY", "fuzzy"},
 589     {0, NULL, NULL}
 590   };
 591   *id = g_enum_register_static ("GstIndexCertainty", values);
 592 }
 593
 594 GType
 595 gst_index_certainty_get_type (void)
 596 {
 597   static GType id;
 598   static GOnce once = G_ONCE_INIT;
 599
 600   g_once (&once, (GThreadFunc) register_gst_index_certainty, &id);
 601   return id;
 602 }
 603 static void
 604 register_gst_index_entry_type (GType * id)
 605 {
 606   static const GEnumValue values[] = {
 607     {GST_INDEX_ENTRY_ID, "GST_INDEX_ENTRY_ID", "id"},
 608     {GST_INDEX_ENTRY_ASSOCIATION, "GST_INDEX_ENTRY_ASSOCIATION", "association"},
 609     {GST_INDEX_ENTRY_OBJECT, "GST_INDEX_ENTRY_OBJECT", "object"},
 610     {GST_INDEX_ENTRY_FORMAT, "GST_INDEX_ENTRY_FORMAT", "format"},
 611     {0, NULL, NULL}
 612   };
 613   *id = g_enum_register_static ("GstIndexEntryType", values);
 614 }
 615
 616 GType
 617 gst_index_entry_type_get_type (void)
 618 {
 619   static GType id;
 620   static GOnce once = G_ONCE_INIT;
 621
 622   g_once (&once, (GThreadFunc) register_gst_index_entry_type, &id);
 623   return id;
 624 }
 625 static void
 626 register_gst_index_lookup_method (GType * id)
 627 {
 628   static const GEnumValue values[] = {
 629     {GST_INDEX_LOOKUP_EXACT, "GST_INDEX_LOOKUP_EXACT", "exact"},
 630     {GST_INDEX_LOOKUP_BEFORE, "GST_INDEX_LOOKUP_BEFORE", "before"},
 631     {GST_INDEX_LOOKUP_AFTER, "GST_INDEX_LOOKUP_AFTER", "after"},
 632     {0, NULL, NULL}
 633   };
 634   *id = g_enum_register_static ("GstIndexLookupMethod", values);
 635 }
 636
 637 GType
 638 gst_index_lookup_method_get_type (void)
 639 {
 640   static GType id;
 641   static GOnce once = G_ONCE_INIT;
 642
 643   g_once (&once, (GThreadFunc) register_gst_index_lookup_method, &id);
 644   return id;
 645 }
 646 static void
 647 register_gst_assoc_flags (GType * id)
 648 {
 649   static const GFlagsValue values[] = {
 650     {GST_ASSOCIATION_FLAG_NONE, "GST_ASSOCIATION_FLAG_NONE", "none"},
 651     {GST_ASSOCIATION_FLAG_KEY_UNIT, "GST_ASSOCIATION_FLAG_KEY_UNIT",
 652         "key-unit"},
 653     {GST_ASSOCIATION_FLAG_DELTA_UNIT, "GST_ASSOCIATION_FLAG_DELTA_UNIT",
 654         "delta-unit"},
 655     {GST_ASSOCIATION_FLAG_LAST, "GST_ASSOCIATION_FLAG_LAST", "last"},
 656     {0, NULL, NULL}
 657   };
 658   *id = g_flags_register_static ("GstAssocFlags", values);
 659 }
 660
 661 GType
 662 gst_assoc_flags_get_type (void)
 663 {
 664   static GType id;
 665   static GOnce once = G_ONCE_INIT;
 666
 667   g_once (&once, (GThreadFunc) register_gst_assoc_flags, &id);
 668   return id;
 669 }
 670 static void
 671 register_gst_index_resolver_method (GType * id)
 672 {
 673   static const GEnumValue values[] = {
 674     {GST_INDEX_RESOLVER_CUSTOM, "GST_INDEX_RESOLVER_CUSTOM", "custom"},
 675     {GST_INDEX_RESOLVER_GTYPE, "GST_INDEX_RESOLVER_GTYPE", "gtype"},
 676     {GST_INDEX_RESOLVER_PATH, "GST_INDEX_RESOLVER_PATH", "path"},
 677     {0, NULL, NULL}
 678   };
 679   *id = g_enum_register_static ("GstIndexResolverMethod", values);
 680 }
 681
 682 GType
 683 gst_index_resolver_method_get_type (void)
 684 {
 685   static GType id;
 686   static GOnce once = G_ONCE_INIT;
 687
 688   g_once (&once, (GThreadFunc) register_gst_index_resolver_method, &id);
 689   return id;
 690 }
 691 static void
 692 register_gst_index_flags (GType * id)
 693 {
 694   static const GFlagsValue values[] = {
 695     {GST_INDEX_WRITABLE, "GST_INDEX_WRITABLE", "writable"},
 696     {GST_INDEX_READABLE, "GST_INDEX_READABLE", "readable"},
 697     {GST_INDEX_FLAG_LAST, "GST_INDEX_FLAG_LAST", "flag-last"},
 698     {0, NULL, NULL}
 699   };
 700   *id = g_flags_register_static ("GstIndexFlags", values);
 701 }
 702
 703 GType
 704 gst_index_flags_get_type (void)
 705 {
 706   static GType id;
 707   static GOnce once = G_ONCE_INIT;
 708
 709   g_once (&once, (GThreadFunc) register_gst_index_flags, &id);
 710   return id;
 711 }
 712
 713 /* enumerations from "gstinfo.h" */
 714 static void
 715 register_gst_debug_level (GType * id)
 716 {
 717   static const GEnumValue values[] = {
 718     {GST_LEVEL_NONE, "GST_LEVEL_NONE", "none"},
 719     {GST_LEVEL_ERROR, "GST_LEVEL_ERROR", "error"},
 720     {GST_LEVEL_WARNING, "GST_LEVEL_WARNING", "warning"},
 721     {GST_LEVEL_INFO, "GST_LEVEL_INFO", "info"},
 722     {GST_LEVEL_DEBUG, "GST_LEVEL_DEBUG", "debug"},
 723     {GST_LEVEL_LOG, "GST_LEVEL_LOG", "log"},
 724     {GST_LEVEL_COUNT, "GST_LEVEL_COUNT", "count"},
 725     {0, NULL, NULL}
 726   };
 727   *id = g_enum_register_static ("GstDebugLevel", values);
 728 }
 729
 730 GType
 731 gst_debug_level_get_type (void)
 732 {
 733   static GType id;
 734   static GOnce once = G_ONCE_INIT;
 735
 736   g_once (&once, (GThreadFunc) register_gst_debug_level, &id);
 737   return id;
 738 }
 739 static void
 740 register_gst_debug_color_flags (GType * id)
 741 {
 742   static const GEnumValue values[] = {
 743     {GST_DEBUG_FG_BLACK, "GST_DEBUG_FG_BLACK", "fg-black"},
 744     {GST_DEBUG_FG_RED, "GST_DEBUG_FG_RED", "fg-red"},
 745     {GST_DEBUG_FG_GREEN, "GST_DEBUG_FG_GREEN", "fg-green"},
 746     {GST_DEBUG_FG_YELLOW, "GST_DEBUG_FG_YELLOW", "fg-yellow"},
 747     {GST_DEBUG_FG_BLUE, "GST_DEBUG_FG_BLUE", "fg-blue"},
 748     {GST_DEBUG_FG_MAGENTA, "GST_DEBUG_FG_MAGENTA", "fg-magenta"},
 749     {GST_DEBUG_FG_CYAN, "GST_DEBUG_FG_CYAN", "fg-cyan"},
 750     {GST_DEBUG_FG_WHITE, "GST_DEBUG_FG_WHITE", "fg-white"},
 751     {GST_DEBUG_BG_BLACK, "GST_DEBUG_BG_BLACK", "bg-black"},
 752     {GST_DEBUG_BG_RED, "GST_DEBUG_BG_RED", "bg-red"},
 753     {GST_DEBUG_BG_GREEN, "GST_DEBUG_BG_GREEN", "bg-green"},
 754     {GST_DEBUG_BG_YELLOW, "GST_DEBUG_BG_YELLOW", "bg-yellow"},
 755     {GST_DEBUG_BG_BLUE, "GST_DEBUG_BG_BLUE", "bg-blue"},
 756     {GST_DEBUG_BG_MAGENTA, "GST_DEBUG_BG_MAGENTA", "bg-magenta"},
 757     {GST_DEBUG_BG_CYAN, "GST_DEBUG_BG_CYAN", "bg-cyan"},
 758     {GST_DEBUG_BG_WHITE, "GST_DEBUG_BG_WHITE", "bg-white"},
 759     {GST_DEBUG_BOLD, "GST_DEBUG_BOLD", "bold"},
 760     {GST_DEBUG_UNDERLINE, "GST_DEBUG_UNDERLINE", "underline"},
 761     {0, NULL, NULL}
 762   };
 763   *id = g_enum_register_static ("GstDebugColorFlags", values);
 764 }
 765
 766 GType
 767 gst_debug_color_flags_get_type (void)
 768 {
 769   static GType id;
 770   static GOnce once = G_ONCE_INIT;
 771
 772   g_once (&once, (GThreadFunc) register_gst_debug_color_flags, &id);
 773   return id;
 774 }
 775
 776 /* enumerations from "gstiterator.h" */
 777 static void
 778 register_gst_iterator_result (GType * id)
 779 {
 780   static const GEnumValue values[] = {
 781     {GST_ITERATOR_DONE, "GST_ITERATOR_DONE", "done"},
 782     {GST_ITERATOR_OK, "GST_ITERATOR_OK", "ok"},
 783     {GST_ITERATOR_RESYNC, "GST_ITERATOR_RESYNC", "resync"},
 784     {GST_ITERATOR_ERROR, "GST_ITERATOR_ERROR", "error"},
 785     {0, NULL, NULL}
 786   };
 787   *id = g_enum_register_static ("GstIteratorResult", values);
 788 }
 789
 790 GType
 791 gst_iterator_result_get_type (void)
 792 {
 793   static GType id;
 794   static GOnce once = G_ONCE_INIT;
 795
 796   g_once (&once, (GThreadFunc) register_gst_iterator_result, &id);
 797   return id;
 798 }
 799 static void
 800 register_gst_iterator_item (GType * id)
 801 {
 802   static const GEnumValue values[] = {
 803     {GST_ITERATOR_ITEM_SKIP, "GST_ITERATOR_ITEM_SKIP", "skip"},
 804     {GST_ITERATOR_ITEM_PASS, "GST_ITERATOR_ITEM_PASS", "pass"},
 805     {GST_ITERATOR_ITEM_END, "GST_ITERATOR_ITEM_END", "end"},
 806     {0, NULL, NULL}
 807   };
 808   *id = g_enum_register_static ("GstIteratorItem", values);
 809 }
 810
 811 GType
 812 gst_iterator_item_get_type (void)
 813 {
 814   static GType id;
 815   static GOnce once = G_ONCE_INIT;
 816
 817   g_once (&once, (GThreadFunc) register_gst_iterator_item, &id);
 818   return id;
 819 }
 820
 821 /* enumerations from "gstmessage.h" */
 822 static void
 823 register_gst_message_type (GType * id)
 824 {
 825   static const GFlagsValue values[] = {
 826     {GST_MESSAGE_UNKNOWN, "GST_MESSAGE_UNKNOWN", "unknown"},
 827     {GST_MESSAGE_EOS, "GST_MESSAGE_EOS", "eos"},
 828     {GST_MESSAGE_ERROR, "GST_MESSAGE_ERROR", "error"},
 829     {GST_MESSAGE_WARNING, "GST_MESSAGE_WARNING", "warning"},
 830     {GST_MESSAGE_INFO, "GST_MESSAGE_INFO", "info"},
 831     {GST_MESSAGE_TAG, "GST_MESSAGE_TAG", "tag"},
 832     {GST_MESSAGE_BUFFERING, "GST_MESSAGE_BUFFERING", "buffering"},
 833     {GST_MESSAGE_STATE_CHANGED, "GST_MESSAGE_STATE_CHANGED", "state-changed"},
 834     {GST_MESSAGE_STATE_DIRTY, "GST_MESSAGE_STATE_DIRTY", "state-dirty"},
 835     {GST_MESSAGE_STEP_DONE, "GST_MESSAGE_STEP_DONE", "step-done"},
 836     {GST_MESSAGE_CLOCK_PROVIDE, "GST_MESSAGE_CLOCK_PROVIDE", "clock-provide"},
 837     {GST_MESSAGE_CLOCK_LOST, "GST_MESSAGE_CLOCK_LOST", "clock-lost"},
 838     {GST_MESSAGE_NEW_CLOCK, "GST_MESSAGE_NEW_CLOCK", "new-clock"},
 839     {GST_MESSAGE_STRUCTURE_CHANGE, "GST_MESSAGE_STRUCTURE_CHANGE",
 840         "structure-change"},
 841     {GST_MESSAGE_STREAM_STATUS, "GST_MESSAGE_STREAM_STATUS", "stream-status"},
 842     {GST_MESSAGE_APPLICATION, "GST_MESSAGE_APPLICATION", "application"},
 843     {GST_MESSAGE_ELEMENT, "GST_MESSAGE_ELEMENT", "element"},
 844     {GST_MESSAGE_SEGMENT_START, "GST_MESSAGE_SEGMENT_START", "segment-start"},
 845     {GST_MESSAGE_SEGMENT_DONE, "GST_MESSAGE_SEGMENT_DONE", "segment-done"},
 846     {GST_MESSAGE_DURATION, "GST_MESSAGE_DURATION", "duration"},
 847     {GST_MESSAGE_ANY, "GST_MESSAGE_ANY", "any"},
 848     {0, NULL, NULL}
 849   };
 850   *id = g_flags_register_static ("GstMessageType", values);
 851 }
 852
 853 GType
 854 gst_message_type_get_type (void)
 855 {
 856   static GType id;
 857   static GOnce once = G_ONCE_INIT;
 858
 859   g_once (&once, (GThreadFunc) register_gst_message_type, &id);
 860   return id;
 861 }
 862
 863 /* enumerations from "gstminiobject.h" */
 864 static void
 865 register_gst_mini_object_flags (GType * id)
 866 {
 867   static const GFlagsValue values[] = {
 868     {GST_MINI_OBJECT_FLAG_READONLY, "GST_MINI_OBJECT_FLAG_READONLY",
 869         "readonly"},
 870     {GST_MINI_OBJECT_FLAG_LAST, "GST_MINI_OBJECT_FLAG_LAST", "last"},
 871     {0, NULL, NULL}
 872   };
 873   *id = g_flags_register_static ("GstMiniObjectFlags", values);
 874 }
 875
 876 GType
 877 gst_mini_object_flags_get_type (void)
 878 {
 879   static GType id;
 880   static GOnce once = G_ONCE_INIT;
 881
 882   g_once (&once, (GThreadFunc) register_gst_mini_object_flags, &id);
 883   return id;
 884 }
 885
 886 /* enumerations from "gstpad.h" */
 887 static void
 888 register_gst_pad_link_return (GType * id)
 889 {
 890   static const GEnumValue values[] = {
 891     {GST_PAD_LINK_OK, "GST_PAD_LINK_OK", "ok"},
 892     {GST_PAD_LINK_WRONG_HIERARCHY, "GST_PAD_LINK_WRONG_HIERARCHY",
 893         "wrong-hierarchy"},
 894     {GST_PAD_LINK_WAS_LINKED, "GST_PAD_LINK_WAS_LINKED", "was-linked"},
 895     {GST_PAD_LINK_WRONG_DIRECTION, "GST_PAD_LINK_WRONG_DIRECTION",
 896         "wrong-direction"},
 897     {GST_PAD_LINK_NOFORMAT, "GST_PAD_LINK_NOFORMAT", "noformat"},
 898     {GST_PAD_LINK_NOSCHED, "GST_PAD_LINK_NOSCHED", "nosched"},
 899     {GST_PAD_LINK_REFUSED, "GST_PAD_LINK_REFUSED", "refused"},
 900     {0, NULL, NULL}
 901   };
 902   *id = g_enum_register_static ("GstPadLinkReturn", values);
 903 }
 904
 905 GType
 906 gst_pad_link_return_get_type (void)
 907 {
 908   static GType id;
 909   static GOnce once = G_ONCE_INIT;
 910
 911   g_once (&once, (GThreadFunc) register_gst_pad_link_return, &id);
 912   return id;
 913 }
 914 static void
 915 register_gst_flow_return (GType * id)
 916 {
 917   static const GEnumValue values[] = {
 918     {GST_FLOW_RESEND, "GST_FLOW_RESEND", "resend"},
 919     {GST_FLOW_OK, "GST_FLOW_OK", "ok"},
 920     {GST_FLOW_NOT_LINKED, "GST_FLOW_NOT_LINKED", "not-linked"},
 921     {GST_FLOW_WRONG_STATE, "GST_FLOW_WRONG_STATE", "wrong-state"},
 922     {GST_FLOW_UNEXPECTED, "GST_FLOW_UNEXPECTED", "unexpected"},
 923     {GST_FLOW_NOT_NEGOTIATED, "GST_FLOW_NOT_NEGOTIATED", "not-negotiated"},
 924     {GST_FLOW_ERROR, "GST_FLOW_ERROR", "error"},
 925     {GST_FLOW_NOT_SUPPORTED, "GST_FLOW_NOT_SUPPORTED", "not-supported"},
 926     {0, NULL, NULL}
 927   };
 928   *id = g_enum_register_static ("GstFlowReturn", values);
 929 }
 930
 931 GType
 932 gst_flow_return_get_type (void)
 933 {
 934   static GType id;
 935   static GOnce once = G_ONCE_INIT;
 936
 937   g_once (&once, (GThreadFunc) register_gst_flow_return, &id);
 938   return id;
 939 }
 940 static void
 941 register_gst_activate_mode (GType * id)
 942 {
 943   static const GEnumValue values[] = {
 944     {GST_ACTIVATE_NONE, "GST_ACTIVATE_NONE", "none"},
 945     {GST_ACTIVATE_PUSH, "GST_ACTIVATE_PUSH", "push"},
 946     {GST_ACTIVATE_PULL, "GST_ACTIVATE_PULL", "pull"},
 947     {0, NULL, NULL}
 948   };
 949   *id = g_enum_register_static ("GstActivateMode", values);
 950 }
 951
 952 GType
 953 gst_activate_mode_get_type (void)
 954 {
 955   static GType id;
 956   static GOnce once = G_ONCE_INIT;
 957
 958   g_once (&once, (GThreadFunc) register_gst_activate_mode, &id);
 959   return id;
 960 }
 961 static void
 962 register_gst_pad_direction (GType * id)
 963 {
 964   static const GEnumValue values[] = {
 965     {GST_PAD_UNKNOWN, "GST_PAD_UNKNOWN", "unknown"},
 966     {GST_PAD_SRC, "GST_PAD_SRC", "src"},
 967     {GST_PAD_SINK, "GST_PAD_SINK", "sink"},
 968     {0, NULL, NULL}
 969   };
 970   *id = g_enum_register_static ("GstPadDirection", values);
 971 }
 972
 973 GType
 974 gst_pad_direction_get_type (void)
 975 {
 976   static GType id;
 977   static GOnce once = G_ONCE_INIT;
 978
 979   g_once (&once, (GThreadFunc) register_gst_pad_direction, &id);
 980   return id;
 981 }
 982 static void
 983 register_gst_pad_flags (GType * id)
 984 {
 985   static const GFlagsValue values[] = {
 986     {GST_PAD_BLOCKED, "GST_PAD_BLOCKED", "blocked"},
 987     {GST_PAD_FLUSHING, "GST_PAD_FLUSHING", "flushing"},
 988     {GST_PAD_IN_GETCAPS, "GST_PAD_IN_GETCAPS", "in-getcaps"},
 989     {GST_PAD_IN_SETCAPS, "GST_PAD_IN_SETCAPS", "in-setcaps"},
 990     {GST_PAD_FLAG_LAST, "GST_PAD_FLAG_LAST", "flag-last"},
 991     {0, NULL, NULL}
 992   };
 993   *id = g_flags_register_static ("GstPadFlags", values);
 994 }
 995
 996 GType
 997 gst_pad_flags_get_type (void)
 998 {
 999   static GType id;
1000   static GOnce once = G_ONCE_INIT;
1001
1002   g_once (&once, (GThreadFunc) register_gst_pad_flags, &id);
1003   return id;
1004 }
1005
1006 /* enumerations from "gstpadtemplate.h" */
1007 static void
1008 register_gst_pad_presence (GType * id)
1009 {
1010   static const GEnumValue values[] = {
1011     {GST_PAD_ALWAYS, "GST_PAD_ALWAYS", "always"},
1012     {GST_PAD_SOMETIMES, "GST_PAD_SOMETIMES", "sometimes"},
1013     {GST_PAD_REQUEST, "GST_PAD_REQUEST", "request"},
1014     {0, NULL, NULL}
1015   };
1016   *id = g_enum_register_static ("GstPadPresence", values);
1017 }
1018
1019 GType
1020 gst_pad_presence_get_type (void)
1021 {
1022   static GType id;
1023   static GOnce once = G_ONCE_INIT;
1024
1025   g_once (&once, (GThreadFunc) register_gst_pad_presence, &id);
1026   return id;
1027 }
1028 static void
1029 register_gst_pad_template_flags (GType * id)
1030 {
1031   static const GFlagsValue values[] = {
1032     {GST_PAD_TEMPLATE_FIXED, "GST_PAD_TEMPLATE_FIXED", "fixed"},
1033     {GST_PAD_TEMPLATE_FLAG_LAST, "GST_PAD_TEMPLATE_FLAG_LAST", "flag-last"},
1034     {0, NULL, NULL}
1035   };
1036   *id = g_flags_register_static ("GstPadTemplateFlags", values);
1037 }
1038
1039 GType
1040 gst_pad_template_flags_get_type (void)
1041 {
1042   static GType id;
1043   static GOnce once = G_ONCE_INIT;
1044
1045   g_once (&once, (GThreadFunc) register_gst_pad_template_flags, &id);
1046   return id;
1047 }
1048
1049 /* enumerations from "gstpipeline.h" */
1050 static void
1051 register_gst_pipeline_flags (GType * id)
1052 {
1053   static const GFlagsValue values[] = {
1054     {GST_PIPELINE_FLAG_FIXED_CLOCK, "GST_PIPELINE_FLAG_FIXED_CLOCK",
1055         "fixed-clock"},
1056     {GST_PIPELINE_FLAG_LAST, "GST_PIPELINE_FLAG_LAST", "last"},
1057     {0, NULL, NULL}
1058   };
1059   *id = g_flags_register_static ("GstPipelineFlags", values);
1060 }
1061
1062 GType
1063 gst_pipeline_flags_get_type (void)
1064 {
1065   static GType id;
1066   static GOnce once = G_ONCE_INIT;
1067
1068   g_once (&once, (GThreadFunc) register_gst_pipeline_flags, &id);
1069   return id;
1070 }
1071
1072 /* enumerations from "gstplugin.h" */
1073 static void
1074 register_gst_plugin_error (GType * id)
1075 {
1076   static const GEnumValue values[] = {
1077     {GST_PLUGIN_ERROR_MODULE, "GST_PLUGIN_ERROR_MODULE", "module"},
1078     {GST_PLUGIN_ERROR_DEPENDENCIES, "GST_PLUGIN_ERROR_DEPENDENCIES",
1079         "dependencies"},
1080     {GST_PLUGIN_ERROR_NAME_MISMATCH, "GST_PLUGIN_ERROR_NAME_MISMATCH",
1081         "name-mismatch"},
1082     {0, NULL, NULL}
1083   };
1084   *id = g_enum_register_static ("GstPluginError", values);
1085 }
1086
1087 GType
1088 gst_plugin_error_get_type (void)
1089 {
1090   static GType id;
1091   static GOnce once = G_ONCE_INIT;
1092
1093   g_once (&once, (GThreadFunc) register_gst_plugin_error, &id);
1094   return id;
1095 }
1096 static void
1097 register_gst_plugin_flags (GType * id)
1098 {
1099   static const GFlagsValue values[] = {
1100     {GST_PLUGIN_FLAG_CACHED, "GST_PLUGIN_FLAG_CACHED", "cached"},
1101     {0, NULL, NULL}
1102   };
1103   *id = g_flags_register_static ("GstPluginFlags", values);
1104 }
1105
1106 GType
1107 gst_plugin_flags_get_type (void)
1108 {
1109   static GType id;
1110   static GOnce once = G_ONCE_INIT;
1111
1112   g_once (&once, (GThreadFunc) register_gst_plugin_flags, &id);
1113   return id;
1114 }
1115
1116 /* enumerations from "gstpluginfeature.h" */
1117 static void
1118 register_gst_rank (GType * id)
1119 {
1120   static const GEnumValue values[] = {
1121     {GST_RANK_NONE, "GST_RANK_NONE", "none"},
1122     {GST_RANK_MARGINAL, "GST_RANK_MARGINAL", "marginal"},
1123     {GST_RANK_SECONDARY, "GST_RANK_SECONDARY", "secondary"},
1124     {GST_RANK_PRIMARY, "GST_RANK_PRIMARY", "primary"},
1125     {0, NULL, NULL}
1126   };
1127   *id = g_enum_register_static ("GstRank", values);
1128 }
1129
1130 GType
1131 gst_rank_get_type (void)
1132 {
1133   static GType id;
1134   static GOnce once = G_ONCE_INIT;
1135
1136   g_once (&once, (GThreadFunc) register_gst_rank, &id);
1137   return id;
1138 }
1139
1140 /* enumerations from "gstquery.h" */
1141 static void
1142 register_gst_query_type (GType * id)
1143 {
1144   static const GEnumValue values[] = {
1145     {GST_QUERY_NONE, "GST_QUERY_NONE", "none"},
1146     {GST_QUERY_POSITION, "GST_QUERY_POSITION", "position"},
1147     {GST_QUERY_DURATION, "GST_QUERY_DURATION", "duration"},
1148     {GST_QUERY_LATENCY, "GST_QUERY_LATENCY", "latency"},
1149     {GST_QUERY_JITTER, "GST_QUERY_JITTER", "jitter"},
1150     {GST_QUERY_RATE, "GST_QUERY_RATE", "rate"},
1151     {GST_QUERY_SEEKING, "GST_QUERY_SEEKING", "seeking"},
1152     {GST_QUERY_SEGMENT, "GST_QUERY_SEGMENT", "segment"},
1153     {GST_QUERY_CONVERT, "GST_QUERY_CONVERT", "convert"},
1154     {GST_QUERY_FORMATS, "GST_QUERY_FORMATS", "formats"},
1155     {0, NULL, NULL}
1156   };
1157   *id = g_enum_register_static ("GstQueryType", values);
1158 }
1159
1160 GType
1161 gst_query_type_get_type (void)
1162 {
1163   static GType id;
1164   static GOnce once = G_ONCE_INIT;
1165
1166   g_once (&once, (GThreadFunc) register_gst_query_type, &id);
1167   return id;
1168 }
1169
1170 /* enumerations from "gsttaglist.h" */
1171 static void
1172 register_gst_tag_merge_mode (GType * id)
1173 {
1174   static const GEnumValue values[] = {
1175     {GST_TAG_MERGE_UNDEFINED, "GST_TAG_MERGE_UNDEFINED", "undefined"},
1176     {GST_TAG_MERGE_REPLACE_ALL, "GST_TAG_MERGE_REPLACE_ALL", "replace-all"},
1177     {GST_TAG_MERGE_REPLACE, "GST_TAG_MERGE_REPLACE", "replace"},
1178     {GST_TAG_MERGE_APPEND, "GST_TAG_MERGE_APPEND", "append"},
1179     {GST_TAG_MERGE_PREPEND, "GST_TAG_MERGE_PREPEND", "prepend"},
1180     {GST_TAG_MERGE_KEEP, "GST_TAG_MERGE_KEEP", "keep"},
1181     {GST_TAG_MERGE_KEEP_ALL, "GST_TAG_MERGE_KEEP_ALL", "keep-all"},
1182     {GST_TAG_MERGE_COUNT, "GST_TAG_MERGE_COUNT", "count"},
1183     {0, NULL, NULL}
1184   };
1185   *id = g_enum_register_static ("GstTagMergeMode", values);
1186 }
1187
1188 GType
1189 gst_tag_merge_mode_get_type (void)
1190 {
1191   static GType id;
1192   static GOnce once = G_ONCE_INIT;
1193
1194   g_once (&once, (GThreadFunc) register_gst_tag_merge_mode, &id);
1195   return id;
1196 }
1197 static void
1198 register_gst_tag_flag (GType * id)
1199 {
1200   static const GEnumValue values[] = {
1201     {GST_TAG_FLAG_UNDEFINED, "GST_TAG_FLAG_UNDEFINED", "undefined"},
1202     {GST_TAG_FLAG_META, "GST_TAG_FLAG_META", "meta"},
1203     {GST_TAG_FLAG_ENCODED, "GST_TAG_FLAG_ENCODED", "encoded"},
1204     {GST_TAG_FLAG_DECODED, "GST_TAG_FLAG_DECODED", "decoded"},
1205     {GST_TAG_FLAG_COUNT, "GST_TAG_FLAG_COUNT", "count"},
1206     {0, NULL, NULL}
1207   };
1208   *id = g_enum_register_static ("GstTagFlag", values);
1209 }
1210
1211 GType
1212 gst_tag_flag_get_type (void)
1213 {
1214   static GType id;
1215   static GOnce once = G_ONCE_INIT;
1216
1217   g_once (&once, (GThreadFunc) register_gst_tag_flag, &id);
1218   return id;
1219 }
1220
1221 /* enumerations from "gsttask.h" */
1222 static void
1223 register_gst_task_state (GType * id)
1224 {
1225   static const GEnumValue values[] = {
1226     {GST_TASK_STARTED, "GST_TASK_STARTED", "started"},
1227     {GST_TASK_STOPPED, "GST_TASK_STOPPED", "stopped"},
1228     {GST_TASK_PAUSED, "GST_TASK_PAUSED", "paused"},
1229     {0, NULL, NULL}
1230   };
1231   *id = g_enum_register_static ("GstTaskState", values);
1232 }
1233
1234 GType
1235 gst_task_state_get_type (void)
1236 {
1237   static GType id;
1238   static GOnce once = G_ONCE_INIT;
1239
1240   g_once (&once, (GThreadFunc) register_gst_task_state, &id);
1241   return id;
1242 }
1243
1244 /* enumerations from "gsttrace.h" */
1245 static void
1246 register_gst_alloc_trace_flags (GType * id)
1247 {
1248   static const GFlagsValue values[] = {
1249     {GST_ALLOC_TRACE_LIVE, "GST_ALLOC_TRACE_LIVE", "live"},
1250     {GST_ALLOC_TRACE_MEM_LIVE, "GST_ALLOC_TRACE_MEM_LIVE", "mem-live"},
1251     {0, NULL, NULL}
1252   };
1253   *id = g_flags_register_static ("GstAllocTraceFlags", values);
1254 }
1255
1256 GType
1257 gst_alloc_trace_flags_get_type (void)
1258 {
1259   static GType id;
1260   static GOnce once = G_ONCE_INIT;
1261
1262   g_once (&once, (GThreadFunc) register_gst_alloc_trace_flags, &id);
1263   return id;
1264 }
1265
1266 /* enumerations from "gsttypefind.h" */
1267 static void
1268 register_gst_type_find_probability (GType * id)
1269 {
1270   static const GEnumValue values[] = {
1271     {GST_TYPE_FIND_MINIMUM, "GST_TYPE_FIND_MINIMUM", "minimum"},
1272     {GST_TYPE_FIND_POSSIBLE, "GST_TYPE_FIND_POSSIBLE", "possible"},
1273     {GST_TYPE_FIND_LIKELY, "GST_TYPE_FIND_LIKELY", "likely"},
1274     {GST_TYPE_FIND_NEARLY_CERTAIN, "GST_TYPE_FIND_NEARLY_CERTAIN",
1275         "nearly-certain"},
1276     {GST_TYPE_FIND_MAXIMUM, "GST_TYPE_FIND_MAXIMUM", "maximum"},
1277     {0, NULL, NULL}
1278   };
1279   *id = g_enum_register_static ("GstTypeFindProbability", values);
1280 }
1281
1282 GType
1283 gst_type_find_probability_get_type (void)
1284 {
1285   static GType id;
1286   static GOnce once = G_ONCE_INIT;
1287
1288   g_once (&once, (GThreadFunc) register_gst_type_find_probability, &id);
1289   return id;
1290 }
1291
1292 /* enumerations from "gsturi.h" */
1293 static void
1294 register_gst_uri_type (GType * id)
1295 {
1296   static const GEnumValue values[] = {
1297     {GST_URI_UNKNOWN, "GST_URI_UNKNOWN", "unknown"},
1298     {GST_URI_SINK, "GST_URI_SINK", "sink"},
1299     {GST_URI_SRC, "GST_URI_SRC", "src"},
1300     {0, NULL, NULL}
1301   };
1302   *id = g_enum_register_static ("GstURIType", values);
1303 }
1304
1305 GType
1306 gst_uri_type_get_type (void)
1307 {
1308   static GType id;
1309   static GOnce once = G_ONCE_INIT;
1310
1311   g_once (&once, (GThreadFunc) register_gst_uri_type, &id);
1312   return id;
1313 }
1314
1315 /* enumerations from "gstparse.h" */
1316 static void
1317 register_gst_parse_error (GType * id)
1318 {
1319   static const GEnumValue values[] = {
1320     {GST_PARSE_ERROR_SYNTAX, "GST_PARSE_ERROR_SYNTAX", "syntax"},
1321     {GST_PARSE_ERROR_NO_SUCH_ELEMENT, "GST_PARSE_ERROR_NO_SUCH_ELEMENT",
1322         "no-such-element"},
1323     {GST_PARSE_ERROR_NO_SUCH_PROPERTY, "GST_PARSE_ERROR_NO_SUCH_PROPERTY",
1324         "no-such-property"},
1325     {GST_PARSE_ERROR_LINK, "GST_PARSE_ERROR_LINK", "link"},
1326     {GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
1327         "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY", "could-not-set-property"},
1328     {GST_PARSE_ERROR_EMPTY_BIN, "GST_PARSE_ERROR_EMPTY_BIN", "empty-bin"},
1329     {GST_PARSE_ERROR_EMPTY, "GST_PARSE_ERROR_EMPTY", "empty"},
1330     {0, NULL, NULL}
1331   };
1332   *id = g_enum_register_static ("GstParseError", values);
1333 }
1334
1335 GType
1336 gst_parse_error_get_type (void)
1337 {
1338   static GType id;
1339   static GOnce once = G_ONCE_INIT;
1340
1341   g_once (&once, (GThreadFunc) register_gst_parse_error, &id);
1342   return id;
1343 }
1344
1345 /* Generated data ends here */