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