1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 /* Generated data (by glib-mkenums) */

    19 

    20 #include "gst_private.h"

    21 #include <gst/gst.h>

    22 #define C_ENUM(v) ((gint) v)

    23 #define C_FLAGS(v) ((guint) v)

    24  

    25 

    26 /* enumerations from "gstobject.h" */

    27 static void

    28 register_gst_object_flags (GType* id)

    29 {

    30   static const GFlagsValue values[] = {

    31     { C_FLAGS(GST_OBJECT_DISPOSING), "GST_OBJECT_DISPOSING", "disposing" },

    32     { C_FLAGS(GST_OBJECT_FLOATING), "GST_OBJECT_FLOATING", "floating" },

    33     { C_FLAGS(GST_OBJECT_FLAG_LAST), "GST_OBJECT_FLAG_LAST", "flag-last" },

    34     { 0, NULL, NULL }

    35   };

    36   *id = g_flags_register_static ("GstObjectFlags", values);

    37 }

    38 #ifdef __SYMBIAN32__

    39 EXPORT_C

    40 #endif

    41 

    42 GType

    43 gst_object_flags_get_type (void)

    44 {

    45   static GType id;

    46   static GOnce once = G_ONCE_INIT;

    47 

    48   g_once (&once, (GThreadFunc)register_gst_object_flags, &id);

    49   return id;

    50 }

    51 

    52 /* enumerations from "gstbin.h" */

    53 static void

    54 register_gst_bin_flags (GType* id)

    55 {

    56   static const GFlagsValue values[] = {

    57     { C_FLAGS(GST_BIN_FLAG_LAST), "GST_BIN_FLAG_LAST", "last" },

    58     { 0, NULL, NULL }

    59   };

    60   *id = g_flags_register_static ("GstBinFlags", values);

    61 }

    62 #ifdef __SYMBIAN32__

    63 EXPORT_C

    64 #endif

    65 

    66 GType

    67 gst_bin_flags_get_type (void)

    68 {

    69   static GType id;

    70   static GOnce once = G_ONCE_INIT;

    71 

    72   g_once (&once, (GThreadFunc)register_gst_bin_flags, &id);

    73   return id;

    74 }

    75 

    76 /* enumerations from "gstbuffer.h" */

    77 static void

    78 register_gst_buffer_flag (GType* id)

    79 {

    80   static const GFlagsValue values[] = {

    81     { C_FLAGS(GST_BUFFER_FLAG_READONLY), "GST_BUFFER_FLAG_READONLY", "readonly" },

    82     { C_FLAGS(GST_BUFFER_FLAG_PREROLL), "GST_BUFFER_FLAG_PREROLL", "preroll" },

    83     { C_FLAGS(GST_BUFFER_FLAG_DISCONT), "GST_BUFFER_FLAG_DISCONT", "discont" },

    84     { C_FLAGS(GST_BUFFER_FLAG_IN_CAPS), "GST_BUFFER_FLAG_IN_CAPS", "in-caps" },

    85     { C_FLAGS(GST_BUFFER_FLAG_GAP), "GST_BUFFER_FLAG_GAP", "gap" },

    86     { C_FLAGS(GST_BUFFER_FLAG_DELTA_UNIT), "GST_BUFFER_FLAG_DELTA_UNIT", "delta-unit" },

    87     { C_FLAGS(GST_BUFFER_FLAG_LAST), "GST_BUFFER_FLAG_LAST", "last" },

    88     { 0, NULL, NULL }

    89   };

    90   *id = g_flags_register_static ("GstBufferFlag", values);

    91 }

    92 #ifdef __SYMBIAN32__

    93 EXPORT_C

    94 #endif

    95 

    96 GType

    97 gst_buffer_flag_get_type (void)

    98 {

    99   static GType id;

   100   static GOnce once = G_ONCE_INIT;

   101 

   102   g_once (&once, (GThreadFunc)register_gst_buffer_flag, &id);

   103   return id;

   104 }

   105 static void

   106 register_gst_buffer_copy_flags (GType* id)

   107 {

   108   static const GFlagsValue values[] = {

   109     { C_FLAGS(GST_BUFFER_COPY_FLAGS), "GST_BUFFER_COPY_FLAGS", "flags" },

   110     { C_FLAGS(GST_BUFFER_COPY_TIMESTAMPS), "GST_BUFFER_COPY_TIMESTAMPS", "timestamps" },

   111     { C_FLAGS(GST_BUFFER_COPY_CAPS), "GST_BUFFER_COPY_CAPS", "caps" },

   112     { 0, NULL, NULL }

   113   };

   114   *id = g_flags_register_static ("GstBufferCopyFlags", values);

   115 }

   116 #ifdef __SYMBIAN32__

   117 EXPORT_C

   118 #endif

   119 

   120 GType

   121 gst_buffer_copy_flags_get_type (void)

   122 {

   123   static GType id;

   124   static GOnce once = G_ONCE_INIT;

   125 

   126   g_once (&once, (GThreadFunc)register_gst_buffer_copy_flags, &id);

   127   return id;

   128 }

   129 

   130 /* enumerations from "gstbus.h" */

   131 static void

   132 register_gst_bus_flags (GType* id)

   133 {

   134   static const GFlagsValue values[] = {

   135     { C_FLAGS(GST_BUS_FLUSHING), "GST_BUS_FLUSHING", "flushing" },

   136     { C_FLAGS(GST_BUS_FLAG_LAST), "GST_BUS_FLAG_LAST", "flag-last" },

   137     { 0, NULL, NULL }

   138   };

   139   *id = g_flags_register_static ("GstBusFlags", values);

   140 }

   141 #ifdef __SYMBIAN32__

   142 EXPORT_C

   143 #endif

   144 

   145 GType

   146 gst_bus_flags_get_type (void)

   147 {

   148   static GType id;

   149   static GOnce once = G_ONCE_INIT;

   150 

   151   g_once (&once, (GThreadFunc)register_gst_bus_flags, &id);

   152   return id;

   153 }

   154 static void

   155 register_gst_bus_sync_reply (GType* id)

   156 {

   157   static const GEnumValue values[] = {

   158     { C_ENUM(GST_BUS_DROP), "GST_BUS_DROP", "drop" },

   159     { C_ENUM(GST_BUS_PASS), "GST_BUS_PASS", "pass" },

   160     { C_ENUM(GST_BUS_ASYNC), "GST_BUS_ASYNC", "async" },

   161     { 0, NULL, NULL }

   162   };

   163   *id = g_enum_register_static ("GstBusSyncReply", values);

   164 }

   165 #ifdef __SYMBIAN32__

   166 EXPORT_C

   167 #endif

   168 

   169 GType

   170 gst_bus_sync_reply_get_type (void)

   171 {

   172   static GType id;

   173   static GOnce once = G_ONCE_INIT;

   174 

   175   g_once (&once, (GThreadFunc)register_gst_bus_sync_reply, &id);

   176   return id;

   177 }

   178 

   179 /* enumerations from "gstcaps.h" */

   180 static void

   181 register_gst_caps_flags (GType* id)

   182 {

   183   static const GFlagsValue values[] = {

   184     { C_FLAGS(GST_CAPS_FLAGS_ANY), "GST_CAPS_FLAGS_ANY", "any" },

   185     { 0, NULL, NULL }

   186   };

   187   *id = g_flags_register_static ("GstCapsFlags", values);

   188 }

   189 #ifdef __SYMBIAN32__

   190 EXPORT_C

   191 #endif

   192 

   193 GType

   194 gst_caps_flags_get_type (void)

   195 {

   196   static GType id;

   197   static GOnce once = G_ONCE_INIT;

   198 

   199   g_once (&once, (GThreadFunc)register_gst_caps_flags, &id);

   200   return id;

   201 }

   202 

   203 /* enumerations from "gstclock.h" */

   204 static void

   205 register_gst_clock_return (GType* id)

   206 {

   207   static const GEnumValue values[] = {

   208     { C_ENUM(GST_CLOCK_OK), "GST_CLOCK_OK", "ok" },

   209     { C_ENUM(GST_CLOCK_EARLY), "GST_CLOCK_EARLY", "early" },

   210     { C_ENUM(GST_CLOCK_UNSCHEDULED), "GST_CLOCK_UNSCHEDULED", "unscheduled" },

   211     { C_ENUM(GST_CLOCK_BUSY), "GST_CLOCK_BUSY", "busy" },

   212     { C_ENUM(GST_CLOCK_BADTIME), "GST_CLOCK_BADTIME", "badtime" },

   213     { C_ENUM(GST_CLOCK_ERROR), "GST_CLOCK_ERROR", "error" },

   214     { C_ENUM(GST_CLOCK_UNSUPPORTED), "GST_CLOCK_UNSUPPORTED", "unsupported" },

   215     { 0, NULL, NULL }

   216   };

   217   *id = g_enum_register_static ("GstClockReturn", values);

   218 }

   219 #ifdef __SYMBIAN32__

   220 EXPORT_C

   221 #endif

   222 

   223 GType

   224 gst_clock_return_get_type (void)

   225 {

   226   static GType id;

   227   static GOnce once = G_ONCE_INIT;

   228 

   229   g_once (&once, (GThreadFunc)register_gst_clock_return, &id);

   230   return id;

   231 }

   232 static void

   233 register_gst_clock_entry_type (GType* id)

   234 {

   235   static const GEnumValue values[] = {

   236     { C_ENUM(GST_CLOCK_ENTRY_SINGLE), "GST_CLOCK_ENTRY_SINGLE", "single" },

   237     { C_ENUM(GST_CLOCK_ENTRY_PERIODIC), "GST_CLOCK_ENTRY_PERIODIC", "periodic" },

   238     { 0, NULL, NULL }

   239   };

   240   *id = g_enum_register_static ("GstClockEntryType", values);

   241 }

   242 #ifdef __SYMBIAN32__

   243 EXPORT_C

   244 #endif

   245 

   246 GType

   247 gst_clock_entry_type_get_type (void)

   248 {

   249   static GType id;

   250   static GOnce once = G_ONCE_INIT;

   251 

   252   g_once (&once, (GThreadFunc)register_gst_clock_entry_type, &id);

   253   return id;

   254 }

   255 static void

   256 register_gst_clock_flags (GType* id)

   257 {

   258   static const GFlagsValue values[] = {

   259     { C_FLAGS(GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC), "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC", "can-do-single-sync" },

   260     { C_FLAGS(GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC), "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC", "can-do-single-async" },

   261     { C_FLAGS(GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC), "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC", "can-do-periodic-sync" },

   262     { C_FLAGS(GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC), "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC", "can-do-periodic-async" },

   263     { C_FLAGS(GST_CLOCK_FLAG_CAN_SET_RESOLUTION), "GST_CLOCK_FLAG_CAN_SET_RESOLUTION", "can-set-resolution" },

   264     { C_FLAGS(GST_CLOCK_FLAG_CAN_SET_MASTER), "GST_CLOCK_FLAG_CAN_SET_MASTER", "can-set-master" },

   265     { C_FLAGS(GST_CLOCK_FLAG_LAST), "GST_CLOCK_FLAG_LAST", "last" },

   266     { 0, NULL, NULL }

   267   };

   268   *id = g_flags_register_static ("GstClockFlags", values);

   269 }

   270 #ifdef __SYMBIAN32__

   271 EXPORT_C

   272 #endif

   273 

   274 GType

   275 gst_clock_flags_get_type (void)

   276 {

   277   static GType id;

   278   static GOnce once = G_ONCE_INIT;

   279 

   280   g_once (&once, (GThreadFunc)register_gst_clock_flags, &id);

   281   return id;

   282 }

   283 

   284 /* enumerations from "gstdebugutils.h" */

   285 static void

   286 register_gst_debug_graph_details (GType* id)

   287 {

   288   static const GFlagsValue values[] = {

   289     { C_FLAGS(GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE), "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE", "media-type" },

   290     { C_FLAGS(GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS), "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS", "caps-details" },

   291     { C_FLAGS(GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS), "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS", "non-default-params" },

   292     { C_FLAGS(GST_DEBUG_GRAPH_SHOW_STATES), "GST_DEBUG_GRAPH_SHOW_STATES", "states" },

   293     { C_FLAGS(GST_DEBUG_GRAPH_SHOW_ALL), "GST_DEBUG_GRAPH_SHOW_ALL", "all" },

   294     { 0, NULL, NULL }

   295   };

   296   *id = g_flags_register_static ("GstDebugGraphDetails", values);

   297 }

   298 #ifdef __SYMBIAN32__

   299 EXPORT_C

   300 #endif

   301 

   302 GType

   303 gst_debug_graph_details_get_type (void)

   304 {

   305   static GType id;

   306   static GOnce once = G_ONCE_INIT;

   307 

   308   g_once (&once, (GThreadFunc)register_gst_debug_graph_details, &id);

   309   return id;

   310 }

   311 

   312 /* enumerations from "gstelement.h" */

   313 static void

   314 register_gst_state (GType* id)

   315 {

   316   static const GEnumValue values[] = {

   317     { C_ENUM(GST_STATE_VOID_PENDING), "GST_STATE_VOID_PENDING", "void-pending" },

   318     { C_ENUM(GST_STATE_NULL), "GST_STATE_NULL", "null" },

   319     { C_ENUM(GST_STATE_READY), "GST_STATE_READY", "ready" },

   320     { C_ENUM(GST_STATE_PAUSED), "GST_STATE_PAUSED", "paused" },

   321     { C_ENUM(GST_STATE_PLAYING), "GST_STATE_PLAYING", "playing" },

   322     { 0, NULL, NULL }

   323   };

   324   *id = g_enum_register_static ("GstState", values);

   325 }

   326 #ifdef __SYMBIAN32__

   327 EXPORT_C

   328 #endif

   329 

   330 GType

   331 gst_state_get_type (void)

   332 {

   333   static GType id;

   334   static GOnce once = G_ONCE_INIT;

   335 

   336   g_once (&once, (GThreadFunc)register_gst_state, &id);

   337   return id;

   338 }

   339 static void

   340 register_gst_state_change_return (GType* id)

   341 {

   342   static const GEnumValue values[] = {

   343     { C_ENUM(GST_STATE_CHANGE_FAILURE), "GST_STATE_CHANGE_FAILURE", "failure" },

   344     { C_ENUM(GST_STATE_CHANGE_SUCCESS), "GST_STATE_CHANGE_SUCCESS", "success" },

   345     { C_ENUM(GST_STATE_CHANGE_ASYNC), "GST_STATE_CHANGE_ASYNC", "async" },

   346     { C_ENUM(GST_STATE_CHANGE_NO_PREROLL), "GST_STATE_CHANGE_NO_PREROLL", "no-preroll" },

   347     { 0, NULL, NULL }

   348   };

   349   *id = g_enum_register_static ("GstStateChangeReturn", values);

   350 }

   351 #ifdef __SYMBIAN32__

   352 EXPORT_C

   353 #endif

   354 

   355 GType

   356 gst_state_change_return_get_type (void)

   357 {

   358   static GType id;

   359   static GOnce once = G_ONCE_INIT;

   360 

   361   g_once (&once, (GThreadFunc)register_gst_state_change_return, &id);

   362   return id;

   363 }

   364 static void

   365 register_gst_state_change (GType* id)

   366 {

   367   static const GEnumValue values[] = {

   368     { C_ENUM(GST_STATE_CHANGE_NULL_TO_READY), "GST_STATE_CHANGE_NULL_TO_READY", "null-to-ready" },

   369     { C_ENUM(GST_STATE_CHANGE_READY_TO_PAUSED), "GST_STATE_CHANGE_READY_TO_PAUSED", "ready-to-paused" },

   370     { C_ENUM(GST_STATE_CHANGE_PAUSED_TO_PLAYING), "GST_STATE_CHANGE_PAUSED_TO_PLAYING", "paused-to-playing" },

   371     { C_ENUM(GST_STATE_CHANGE_PLAYING_TO_PAUSED), "GST_STATE_CHANGE_PLAYING_TO_PAUSED", "playing-to-paused" },

   372     { C_ENUM(GST_STATE_CHANGE_PAUSED_TO_READY), "GST_STATE_CHANGE_PAUSED_TO_READY", "paused-to-ready" },

   373     { C_ENUM(GST_STATE_CHANGE_READY_TO_NULL), "GST_STATE_CHANGE_READY_TO_NULL", "ready-to-null" },

   374     { 0, NULL, NULL }

   375   };

   376   *id = g_enum_register_static ("GstStateChange", values);

   377 }

   378 #ifdef __SYMBIAN32__

   379 EXPORT_C

   380 #endif

   381 

   382 GType

   383 gst_state_change_get_type (void)

   384 {

   385   static GType id;

   386   static GOnce once = G_ONCE_INIT;

   387 

   388   g_once (&once, (GThreadFunc)register_gst_state_change, &id);

   389   return id;

   390 }

   391 static void

   392 register_gst_element_flags (GType* id)

   393 {

   394   static const GFlagsValue values[] = {

   395     { C_FLAGS(GST_ELEMENT_LOCKED_STATE), "GST_ELEMENT_LOCKED_STATE", "locked-state" },

   396     { C_FLAGS(GST_ELEMENT_IS_SINK), "GST_ELEMENT_IS_SINK", "is-sink" },

   397     { C_FLAGS(GST_ELEMENT_UNPARENTING), "GST_ELEMENT_UNPARENTING", "unparenting" },

   398     { C_FLAGS(GST_ELEMENT_FLAG_LAST), "GST_ELEMENT_FLAG_LAST", "flag-last" },

   399     { 0, NULL, NULL }

   400   };

   401   *id = g_flags_register_static ("GstElementFlags", values);

   402 }

   403 #ifdef __SYMBIAN32__

   404 EXPORT_C

   405 #endif

   406 

   407 GType

   408 gst_element_flags_get_type (void)

   409 {

   410   static GType id;

   411   static GOnce once = G_ONCE_INIT;

   412 

   413   g_once (&once, (GThreadFunc)register_gst_element_flags, &id);

   414   return id;

   415 }

   416 

   417 /* enumerations from "gsterror.h" */

   418 static void

   419 register_gst_core_error (GType* id)

   420 {

   421   static const GEnumValue values[] = {

   422     { C_ENUM(GST_CORE_ERROR_FAILED), "GST_CORE_ERROR_FAILED", "failed" },

   423     { C_ENUM(GST_CORE_ERROR_TOO_LAZY), "GST_CORE_ERROR_TOO_LAZY", "too-lazy" },

   424     { C_ENUM(GST_CORE_ERROR_NOT_IMPLEMENTED), "GST_CORE_ERROR_NOT_IMPLEMENTED", "not-implemented" },

   425     { C_ENUM(GST_CORE_ERROR_STATE_CHANGE), "GST_CORE_ERROR_STATE_CHANGE", "state-change" },

   426     { C_ENUM(GST_CORE_ERROR_PAD), "GST_CORE_ERROR_PAD", "pad" },

   427     { C_ENUM(GST_CORE_ERROR_THREAD), "GST_CORE_ERROR_THREAD", "thread" },

   428     { C_ENUM(GST_CORE_ERROR_NEGOTIATION), "GST_CORE_ERROR_NEGOTIATION", "negotiation" },

   429     { C_ENUM(GST_CORE_ERROR_EVENT), "GST_CORE_ERROR_EVENT", "event" },

   430     { C_ENUM(GST_CORE_ERROR_SEEK), "GST_CORE_ERROR_SEEK", "seek" },

   431     { C_ENUM(GST_CORE_ERROR_CAPS), "GST_CORE_ERROR_CAPS", "caps" },

   432     { C_ENUM(GST_CORE_ERROR_TAG), "GST_CORE_ERROR_TAG", "tag" },

   433     { C_ENUM(GST_CORE_ERROR_MISSING_PLUGIN), "GST_CORE_ERROR_MISSING_PLUGIN", "missing-plugin" },

   434     { C_ENUM(GST_CORE_ERROR_CLOCK), "GST_CORE_ERROR_CLOCK", "clock" },

   435     { C_ENUM(GST_CORE_ERROR_DISABLED), "GST_CORE_ERROR_DISABLED", "disabled" },

   436     { C_ENUM(GST_CORE_ERROR_NUM_ERRORS), "GST_CORE_ERROR_NUM_ERRORS", "num-errors" },

   437     { 0, NULL, NULL }

   438   };

   439   *id = g_enum_register_static ("GstCoreError", values);

   440 }

   441 #ifdef __SYMBIAN32__

   442 EXPORT_C

   443 #endif

   444 

   445 GType

   446 gst_core_error_get_type (void)

   447 {

   448   static GType id;

   449   static GOnce once = G_ONCE_INIT;

   450 

   451   g_once (&once, (GThreadFunc)register_gst_core_error, &id);

   452   return id;

   453 }

   454 static void

   455 register_gst_library_error (GType* id)

   456 {

   457   static const GEnumValue values[] = {

   458     { C_ENUM(GST_LIBRARY_ERROR_FAILED), "GST_LIBRARY_ERROR_FAILED", "failed" },

   459     { C_ENUM(GST_LIBRARY_ERROR_TOO_LAZY), "GST_LIBRARY_ERROR_TOO_LAZY", "too-lazy" },

   460     { C_ENUM(GST_LIBRARY_ERROR_INIT), "GST_LIBRARY_ERROR_INIT", "init" },

   461     { C_ENUM(GST_LIBRARY_ERROR_SHUTDOWN), "GST_LIBRARY_ERROR_SHUTDOWN", "shutdown" },

   462     { C_ENUM(GST_LIBRARY_ERROR_SETTINGS), "GST_LIBRARY_ERROR_SETTINGS", "settings" },

   463     { C_ENUM(GST_LIBRARY_ERROR_ENCODE), "GST_LIBRARY_ERROR_ENCODE", "encode" },

   464     { C_ENUM(GST_LIBRARY_ERROR_NUM_ERRORS), "GST_LIBRARY_ERROR_NUM_ERRORS", "num-errors" },

   465     { 0, NULL, NULL }

   466   };

   467   *id = g_enum_register_static ("GstLibraryError", values);

   468 }

   469 #ifdef __SYMBIAN32__

   470 EXPORT_C

   471 #endif

   472 

   473 GType

   474 gst_library_error_get_type (void)

   475 {

   476   static GType id;

   477   static GOnce once = G_ONCE_INIT;

   478 

   479   g_once (&once, (GThreadFunc)register_gst_library_error, &id);

   480   return id;

   481 }

   482 static void

   483 register_gst_resource_error (GType* id)

   484 {

   485   static const GEnumValue values[] = {

   486     { C_ENUM(GST_RESOURCE_ERROR_FAILED), "GST_RESOURCE_ERROR_FAILED", "failed" },

   487     { C_ENUM(GST_RESOURCE_ERROR_TOO_LAZY), "GST_RESOURCE_ERROR_TOO_LAZY", "too-lazy" },

   488     { C_ENUM(GST_RESOURCE_ERROR_NOT_FOUND), "GST_RESOURCE_ERROR_NOT_FOUND", "not-found" },

   489     { C_ENUM(GST_RESOURCE_ERROR_BUSY), "GST_RESOURCE_ERROR_BUSY", "busy" },

   490     { C_ENUM(GST_RESOURCE_ERROR_OPEN_READ), "GST_RESOURCE_ERROR_OPEN_READ", "open-read" },

   491     { C_ENUM(GST_RESOURCE_ERROR_OPEN_WRITE), "GST_RESOURCE_ERROR_OPEN_WRITE", "open-write" },

   492     { C_ENUM(GST_RESOURCE_ERROR_OPEN_READ_WRITE), "GST_RESOURCE_ERROR_OPEN_READ_WRITE", "open-read-write" },

   493     { C_ENUM(GST_RESOURCE_ERROR_CLOSE), "GST_RESOURCE_ERROR_CLOSE", "close" },

   494     { C_ENUM(GST_RESOURCE_ERROR_READ), "GST_RESOURCE_ERROR_READ", "read" },

   495     { C_ENUM(GST_RESOURCE_ERROR_WRITE), "GST_RESOURCE_ERROR_WRITE", "write" },

   496     { C_ENUM(GST_RESOURCE_ERROR_SEEK), "GST_RESOURCE_ERROR_SEEK", "seek" },

   497     { C_ENUM(GST_RESOURCE_ERROR_SYNC), "GST_RESOURCE_ERROR_SYNC", "sync" },

   498     { C_ENUM(GST_RESOURCE_ERROR_SETTINGS), "GST_RESOURCE_ERROR_SETTINGS", "settings" },

   499     { C_ENUM(GST_RESOURCE_ERROR_NO_SPACE_LEFT), "GST_RESOURCE_ERROR_NO_SPACE_LEFT", "no-space-left" },

   500     { C_ENUM(GST_RESOURCE_ERROR_NUM_ERRORS), "GST_RESOURCE_ERROR_NUM_ERRORS", "num-errors" },

   501     { 0, NULL, NULL }

   502   };

   503   *id = g_enum_register_static ("GstResourceError", values);

   504 }

   505 #ifdef __SYMBIAN32__

   506 EXPORT_C

   507 #endif

   508 

   509 GType

   510 gst_resource_error_get_type (void)

   511 {

   512   static GType id;

   513   static GOnce once = G_ONCE_INIT;

   514 

   515   g_once (&once, (GThreadFunc)register_gst_resource_error, &id);

   516   return id;

   517 }

   518 static void

   519 register_gst_stream_error (GType* id)

   520 {

   521   static const GEnumValue values[] = {

   522     { C_ENUM(GST_STREAM_ERROR_FAILED), "GST_STREAM_ERROR_FAILED", "failed" },

   523     { C_ENUM(GST_STREAM_ERROR_TOO_LAZY), "GST_STREAM_ERROR_TOO_LAZY", "too-lazy" },

   524     { C_ENUM(GST_STREAM_ERROR_NOT_IMPLEMENTED), "GST_STREAM_ERROR_NOT_IMPLEMENTED", "not-implemented" },

   525     { C_ENUM(GST_STREAM_ERROR_TYPE_NOT_FOUND), "GST_STREAM_ERROR_TYPE_NOT_FOUND", "type-not-found" },

   526     { C_ENUM(GST_STREAM_ERROR_WRONG_TYPE), "GST_STREAM_ERROR_WRONG_TYPE", "wrong-type" },

   527     { C_ENUM(GST_STREAM_ERROR_CODEC_NOT_FOUND), "GST_STREAM_ERROR_CODEC_NOT_FOUND", "codec-not-found" },

   528     { C_ENUM(GST_STREAM_ERROR_DECODE), "GST_STREAM_ERROR_DECODE", "decode" },

   529     { C_ENUM(GST_STREAM_ERROR_ENCODE), "GST_STREAM_ERROR_ENCODE", "encode" },

   530     { C_ENUM(GST_STREAM_ERROR_DEMUX), "GST_STREAM_ERROR_DEMUX", "demux" },

   531     { C_ENUM(GST_STREAM_ERROR_MUX), "GST_STREAM_ERROR_MUX", "mux" },

   532     { C_ENUM(GST_STREAM_ERROR_FORMAT), "GST_STREAM_ERROR_FORMAT", "format" },

   533     { C_ENUM(GST_STREAM_ERROR_NUM_ERRORS), "GST_STREAM_ERROR_NUM_ERRORS", "num-errors" },

   534     { 0, NULL, NULL }

   535   };

   536   *id = g_enum_register_static ("GstStreamError", values);

   537 }

   538 #ifdef __SYMBIAN32__

   539 EXPORT_C

   540 #endif

   541 

   542 GType

   543 gst_stream_error_get_type (void)

   544 {

   545   static GType id;

   546   static GOnce once = G_ONCE_INIT;

   547 

   548   g_once (&once, (GThreadFunc)register_gst_stream_error, &id);

   549   return id;

   550 }

   551 

   552 /* enumerations from "gstevent.h" */

   553 static void

   554 register_gst_event_type_flags (GType* id)

   555 {

   556   static const GFlagsValue values[] = {

   557     { C_FLAGS(GST_EVENT_TYPE_UPSTREAM), "GST_EVENT_TYPE_UPSTREAM", "upstream" },

   558     { C_FLAGS(GST_EVENT_TYPE_DOWNSTREAM), "GST_EVENT_TYPE_DOWNSTREAM", "downstream" },

   559     { C_FLAGS(GST_EVENT_TYPE_SERIALIZED), "GST_EVENT_TYPE_SERIALIZED", "serialized" },

   560     { 0, NULL, NULL }

   561   };

   562   *id = g_flags_register_static ("GstEventTypeFlags", values);

   563 }

   564 #ifdef __SYMBIAN32__

   565 EXPORT_C

   566 #endif

   567 

   568 GType

   569 gst_event_type_flags_get_type (void)

   570 {

   571   static GType id;

   572   static GOnce once = G_ONCE_INIT;

   573 

   574   g_once (&once, (GThreadFunc)register_gst_event_type_flags, &id);

   575   return id;

   576 }

   577 static void

   578 register_gst_event_type (GType* id)

   579 {

   580   static const GEnumValue values[] = {

   581     { C_ENUM(GST_EVENT_UNKNOWN), "GST_EVENT_UNKNOWN", "unknown" },

   582     { C_ENUM(GST_EVENT_FLUSH_START), "GST_EVENT_FLUSH_START", "flush-start" },

   583     { C_ENUM(GST_EVENT_FLUSH_STOP), "GST_EVENT_FLUSH_STOP", "flush-stop" },

   584     { C_ENUM(GST_EVENT_EOS), "GST_EVENT_EOS", "eos" },

   585     { C_ENUM(GST_EVENT_NEWSEGMENT), "GST_EVENT_NEWSEGMENT", "newsegment" },

   586     { C_ENUM(GST_EVENT_TAG), "GST_EVENT_TAG", "tag" },

   587     { C_ENUM(GST_EVENT_BUFFERSIZE), "GST_EVENT_BUFFERSIZE", "buffersize" },

   588     { C_ENUM(GST_EVENT_QOS), "GST_EVENT_QOS", "qos" },

   589     { C_ENUM(GST_EVENT_SEEK), "GST_EVENT_SEEK", "seek" },

   590     { C_ENUM(GST_EVENT_NAVIGATION), "GST_EVENT_NAVIGATION", "navigation" },

   591     { C_ENUM(GST_EVENT_LATENCY), "GST_EVENT_LATENCY", "latency" },

   592     { C_ENUM(GST_EVENT_CUSTOM_UPSTREAM), "GST_EVENT_CUSTOM_UPSTREAM", "custom-upstream" },

   593     { C_ENUM(GST_EVENT_CUSTOM_DOWNSTREAM), "GST_EVENT_CUSTOM_DOWNSTREAM", "custom-downstream" },

   594     { C_ENUM(GST_EVENT_CUSTOM_DOWNSTREAM_OOB), "GST_EVENT_CUSTOM_DOWNSTREAM_OOB", "custom-downstream-oob" },

   595     { C_ENUM(GST_EVENT_CUSTOM_BOTH), "GST_EVENT_CUSTOM_BOTH", "custom-both" },

   596     { C_ENUM(GST_EVENT_CUSTOM_BOTH_OOB), "GST_EVENT_CUSTOM_BOTH_OOB", "custom-both-oob" },

   597     { 0, NULL, NULL }

   598   };

   599   *id = g_enum_register_static ("GstEventType", values);

   600 }

   601 #ifdef __SYMBIAN32__

   602 EXPORT_C

   603 #endif

   604 

   605 GType

   606 gst_event_type_get_type (void)

   607 {

   608   static GType id;

   609   static GOnce once = G_ONCE_INIT;

   610 

   611   g_once (&once, (GThreadFunc)register_gst_event_type, &id);

   612   return id;

   613 }

   614 static void

   615 register_gst_seek_type (GType* id)

   616 {

   617   static const GEnumValue values[] = {

   618     { C_ENUM(GST_SEEK_TYPE_NONE), "GST_SEEK_TYPE_NONE", "none" },

   619     { C_ENUM(GST_SEEK_TYPE_CUR), "GST_SEEK_TYPE_CUR", "cur" },

   620     { C_ENUM(GST_SEEK_TYPE_SET), "GST_SEEK_TYPE_SET", "set" },

   621     { C_ENUM(GST_SEEK_TYPE_END), "GST_SEEK_TYPE_END", "end" },

   622     { 0, NULL, NULL }

   623   };

   624   *id = g_enum_register_static ("GstSeekType", values);

   625 }

   626 #ifdef __SYMBIAN32__

   627 EXPORT_C

   628 #endif

   629 

   630 GType

   631 gst_seek_type_get_type (void)

   632 {

   633   static GType id;

   634   static GOnce once = G_ONCE_INIT;

   635 

   636   g_once (&once, (GThreadFunc)register_gst_seek_type, &id);

   637   return id;

   638 }

   639 static void

   640 register_gst_seek_flags (GType* id)

   641 {

   642   static const GFlagsValue values[] = {

   643     { C_FLAGS(GST_SEEK_FLAG_NONE), "GST_SEEK_FLAG_NONE", "none" },

   644     { C_FLAGS(GST_SEEK_FLAG_FLUSH), "GST_SEEK_FLAG_FLUSH", "flush" },

   645     { C_FLAGS(GST_SEEK_FLAG_ACCURATE), "GST_SEEK_FLAG_ACCURATE", "accurate" },

   646     { C_FLAGS(GST_SEEK_FLAG_KEY_UNIT), "GST_SEEK_FLAG_KEY_UNIT", "key-unit" },

   647     { C_FLAGS(GST_SEEK_FLAG_SEGMENT), "GST_SEEK_FLAG_SEGMENT", "segment" },

   648     { 0, NULL, NULL }

   649   };

   650   *id = g_flags_register_static ("GstSeekFlags", values);

   651 }

   652 #ifdef __SYMBIAN32__

   653 EXPORT_C

   654 #endif

   655 

   656 GType

   657 gst_seek_flags_get_type (void)

   658 {

   659   static GType id;

   660   static GOnce once = G_ONCE_INIT;

   661 

   662   g_once (&once, (GThreadFunc)register_gst_seek_flags, &id);

   663   return id;

   664 }

   665 

   666 /* enumerations from "gstformat.h" */

   667 static void

   668 register_gst_format (GType* id)

   669 {

   670   static const GEnumValue values[] = {

   671     { C_ENUM(GST_FORMAT_UNDEFINED), "GST_FORMAT_UNDEFINED", "undefined" },

   672     { C_ENUM(GST_FORMAT_DEFAULT), "GST_FORMAT_DEFAULT", "default" },

   673     { C_ENUM(GST_FORMAT_BYTES), "GST_FORMAT_BYTES", "bytes" },

   674     { C_ENUM(GST_FORMAT_TIME), "GST_FORMAT_TIME", "time" },

   675     { C_ENUM(GST_FORMAT_BUFFERS), "GST_FORMAT_BUFFERS", "buffers" },

   676     { C_ENUM(GST_FORMAT_PERCENT), "GST_FORMAT_PERCENT", "percent" },

   677     { 0, NULL, NULL }

   678   };

   679   *id = g_enum_register_static ("GstFormat", values);

   680 }

   681 #ifdef __SYMBIAN32__

   682 EXPORT_C

   683 #endif

   684 

   685 GType

   686 gst_format_get_type (void)

   687 {

   688   static GType id;

   689   static GOnce once = G_ONCE_INIT;

   690 

   691   g_once (&once, (GThreadFunc)register_gst_format, &id);

   692   return id;

   693 }

   694 

   695 /* enumerations from "gstindex.h" */

   696 static void

   697 register_gst_index_certainty (GType* id)

   698 {

   699   static const GEnumValue values[] = {

   700     { C_ENUM(GST_INDEX_UNKNOWN), "GST_INDEX_UNKNOWN", "unknown" },

   701     { C_ENUM(GST_INDEX_CERTAIN), "GST_INDEX_CERTAIN", "certain" },

   702     { C_ENUM(GST_INDEX_FUZZY), "GST_INDEX_FUZZY", "fuzzy" },

   703     { 0, NULL, NULL }

   704   };

   705   *id = g_enum_register_static ("GstIndexCertainty", values);

   706 }

   707 #ifdef __SYMBIAN32__

   708 EXPORT_C

   709 #endif

   710 

   711 GType

   712 gst_index_certainty_get_type (void)

   713 {

   714   static GType id;

   715   static GOnce once = G_ONCE_INIT;

   716 

   717   g_once (&once, (GThreadFunc)register_gst_index_certainty, &id);

   718   return id;

   719 }

   720 static void

   721 register_gst_index_entry_type (GType* id)

   722 {

   723   static const GEnumValue values[] = {

   724     { C_ENUM(GST_INDEX_ENTRY_ID), "GST_INDEX_ENTRY_ID", "id" },

   725     { C_ENUM(GST_INDEX_ENTRY_ASSOCIATION), "GST_INDEX_ENTRY_ASSOCIATION", "association" },

   726     { C_ENUM(GST_INDEX_ENTRY_OBJECT), "GST_INDEX_ENTRY_OBJECT", "object" },

   727     { C_ENUM(GST_INDEX_ENTRY_FORMAT), "GST_INDEX_ENTRY_FORMAT", "format" },

   728     { 0, NULL, NULL }

   729   };

   730   *id = g_enum_register_static ("GstIndexEntryType", values);

   731 }

   732 #ifdef __SYMBIAN32__

   733 EXPORT_C

   734 #endif

   735 

   736 GType

   737 gst_index_entry_type_get_type (void)

   738 {

   739   static GType id;

   740   static GOnce once = G_ONCE_INIT;

   741 

   742   g_once (&once, (GThreadFunc)register_gst_index_entry_type, &id);

   743   return id;

   744 }

   745 static void

   746 register_gst_index_lookup_method (GType* id)

   747 {

   748   static const GEnumValue values[] = {

   749     { C_ENUM(GST_INDEX_LOOKUP_EXACT), "GST_INDEX_LOOKUP_EXACT", "exact" },

   750     { C_ENUM(GST_INDEX_LOOKUP_BEFORE), "GST_INDEX_LOOKUP_BEFORE", "before" },

   751     { C_ENUM(GST_INDEX_LOOKUP_AFTER), "GST_INDEX_LOOKUP_AFTER", "after" },

   752     { 0, NULL, NULL }

   753   };

   754   *id = g_enum_register_static ("GstIndexLookupMethod", values);

   755 }

   756 #ifdef __SYMBIAN32__

   757 EXPORT_C

   758 #endif

   759 

   760 GType

   761 gst_index_lookup_method_get_type (void)

   762 {

   763   static GType id;

   764   static GOnce once = G_ONCE_INIT;

   765 

   766   g_once (&once, (GThreadFunc)register_gst_index_lookup_method, &id);

   767   return id;

   768 }

   769 static void

   770 register_gst_assoc_flags (GType* id)

   771 {

   772   static const GFlagsValue values[] = {

   773     { C_FLAGS(GST_ASSOCIATION_FLAG_NONE), "GST_ASSOCIATION_FLAG_NONE", "none" },

   774     { C_FLAGS(GST_ASSOCIATION_FLAG_KEY_UNIT), "GST_ASSOCIATION_FLAG_KEY_UNIT", "key-unit" },

   775     { C_FLAGS(GST_ASSOCIATION_FLAG_DELTA_UNIT), "GST_ASSOCIATION_FLAG_DELTA_UNIT", "delta-unit" },

   776     { C_FLAGS(GST_ASSOCIATION_FLAG_LAST), "GST_ASSOCIATION_FLAG_LAST", "last" },

   777     { 0, NULL, NULL }

   778   };

   779   *id = g_flags_register_static ("GstAssocFlags", values);

   780 }

   781 #ifdef __SYMBIAN32__

   782 EXPORT_C

   783 #endif

   784 

   785 GType

   786 gst_assoc_flags_get_type (void)

   787 {

   788   static GType id;

   789   static GOnce once = G_ONCE_INIT;

   790 

   791   g_once (&once, (GThreadFunc)register_gst_assoc_flags, &id);

   792   return id;

   793 }

   794 static void

   795 register_gst_index_resolver_method (GType* id)

   796 {

   797   static const GEnumValue values[] = {

   798     { C_ENUM(GST_INDEX_RESOLVER_CUSTOM), "GST_INDEX_RESOLVER_CUSTOM", "custom" },

   799     { C_ENUM(GST_INDEX_RESOLVER_GTYPE), "GST_INDEX_RESOLVER_GTYPE", "gtype" },

   800     { C_ENUM(GST_INDEX_RESOLVER_PATH), "GST_INDEX_RESOLVER_PATH", "path" },

   801     { 0, NULL, NULL }

   802   };

   803   *id = g_enum_register_static ("GstIndexResolverMethod", values);

   804 }

   805 #ifdef __SYMBIAN32__

   806 EXPORT_C

   807 #endif

   808 

   809 GType

   810 gst_index_resolver_method_get_type (void)

   811 {

   812   static GType id;

   813   static GOnce once = G_ONCE_INIT;

   814 

   815   g_once (&once, (GThreadFunc)register_gst_index_resolver_method, &id);

   816   return id;

   817 }

   818 static void

   819 register_gst_index_flags (GType* id)

   820 {

   821   static const GFlagsValue values[] = {

   822     { C_FLAGS(GST_INDEX_WRITABLE), "GST_INDEX_WRITABLE", "writable" },

   823     { C_FLAGS(GST_INDEX_READABLE), "GST_INDEX_READABLE", "readable" },

   824     { C_FLAGS(GST_INDEX_FLAG_LAST), "GST_INDEX_FLAG_LAST", "flag-last" },

   825     { 0, NULL, NULL }

   826   };

   827   *id = g_flags_register_static ("GstIndexFlags", values);

   828 }

   829 #ifdef __SYMBIAN32__

   830 EXPORT_C

   831 #endif

   832 

   833 GType

   834 gst_index_flags_get_type (void)

   835 {

   836   static GType id;

   837   static GOnce once = G_ONCE_INIT;

   838 

   839   g_once (&once, (GThreadFunc)register_gst_index_flags, &id);

   840   return id;

   841 }

   842 

   843 /* enumerations from "gstinfo.h" */

   844 static void

   845 register_gst_debug_level (GType* id)

   846 {

   847   static const GEnumValue values[] = {

   848     { C_ENUM(GST_LEVEL_NONE), "GST_LEVEL_NONE", "none" },

   849     { C_ENUM(GST_LEVEL_ERROR), "GST_LEVEL_ERROR", "error" },

   850     { C_ENUM(GST_LEVEL_WARNING), "GST_LEVEL_WARNING", "warning" },

   851     { C_ENUM(GST_LEVEL_INFO), "GST_LEVEL_INFO", "info" },

   852     { C_ENUM(GST_LEVEL_DEBUG), "GST_LEVEL_DEBUG", "debug" },

   853     { C_ENUM(GST_LEVEL_LOG), "GST_LEVEL_LOG", "log" },

   854     { C_ENUM(GST_LEVEL_COUNT), "GST_LEVEL_COUNT", "count" },

   855     { 0, NULL, NULL }

   856   };

   857   *id = g_enum_register_static ("GstDebugLevel", values);

   858 }

   859 #ifdef __SYMBIAN32__

   860 EXPORT_C

   861 #endif

   862 

   863 GType

   864 gst_debug_level_get_type (void)

   865 {

   866   static GType id;

   867   static GOnce once = G_ONCE_INIT;

   868 

   869   g_once (&once, (GThreadFunc)register_gst_debug_level, &id);

   870   return id;

   871 }

   872 static void

   873 register_gst_debug_color_flags (GType* id)

   874 {

   875   static const GEnumValue values[] = {

   876     { C_ENUM(GST_DEBUG_FG_BLACK), "GST_DEBUG_FG_BLACK", "fg-black" },

   877     { C_ENUM(GST_DEBUG_FG_RED), "GST_DEBUG_FG_RED", "fg-red" },

   878     { C_ENUM(GST_DEBUG_FG_GREEN), "GST_DEBUG_FG_GREEN", "fg-green" },

   879     { C_ENUM(GST_DEBUG_FG_YELLOW), "GST_DEBUG_FG_YELLOW", "fg-yellow" },

   880     { C_ENUM(GST_DEBUG_FG_BLUE), "GST_DEBUG_FG_BLUE", "fg-blue" },

   881     { C_ENUM(GST_DEBUG_FG_MAGENTA), "GST_DEBUG_FG_MAGENTA", "fg-magenta" },

   882     { C_ENUM(GST_DEBUG_FG_CYAN), "GST_DEBUG_FG_CYAN", "fg-cyan" },

   883     { C_ENUM(GST_DEBUG_FG_WHITE), "GST_DEBUG_FG_WHITE", "fg-white" },

   884     { C_ENUM(GST_DEBUG_BG_BLACK), "GST_DEBUG_BG_BLACK", "bg-black" },

   885     { C_ENUM(GST_DEBUG_BG_RED), "GST_DEBUG_BG_RED", "bg-red" },

   886     { C_ENUM(GST_DEBUG_BG_GREEN), "GST_DEBUG_BG_GREEN", "bg-green" },

   887     { C_ENUM(GST_DEBUG_BG_YELLOW), "GST_DEBUG_BG_YELLOW", "bg-yellow" },

   888     { C_ENUM(GST_DEBUG_BG_BLUE), "GST_DEBUG_BG_BLUE", "bg-blue" },

   889     { C_ENUM(GST_DEBUG_BG_MAGENTA), "GST_DEBUG_BG_MAGENTA", "bg-magenta" },

   890     { C_ENUM(GST_DEBUG_BG_CYAN), "GST_DEBUG_BG_CYAN", "bg-cyan" },

   891     { C_ENUM(GST_DEBUG_BG_WHITE), "GST_DEBUG_BG_WHITE", "bg-white" },

   892     { C_ENUM(GST_DEBUG_BOLD), "GST_DEBUG_BOLD", "bold" },

   893     { C_ENUM(GST_DEBUG_UNDERLINE), "GST_DEBUG_UNDERLINE", "underline" },

   894     { 0, NULL, NULL }

   895   };

   896   *id = g_enum_register_static ("GstDebugColorFlags", values);

   897 }

   898 #ifdef __SYMBIAN32__

   899 EXPORT_C

   900 #endif

   901 

   902 GType

   903 gst_debug_color_flags_get_type (void)

   904 {

   905   static GType id;

   906   static GOnce once = G_ONCE_INIT;

   907 

   908   g_once (&once, (GThreadFunc)register_gst_debug_color_flags, &id);

   909   return id;

   910 }

   911 

   912 /* enumerations from "gstiterator.h" */

   913 static void

   914 register_gst_iterator_result (GType* id)

   915 {

   916   static const GEnumValue values[] = {

   917     { C_ENUM(GST_ITERATOR_DONE), "GST_ITERATOR_DONE", "done" },

   918     { C_ENUM(GST_ITERATOR_OK), "GST_ITERATOR_OK", "ok" },

   919     { C_ENUM(GST_ITERATOR_RESYNC), "GST_ITERATOR_RESYNC", "resync" },

   920     { C_ENUM(GST_ITERATOR_ERROR), "GST_ITERATOR_ERROR", "error" },

   921     { 0, NULL, NULL }

   922   };

   923   *id = g_enum_register_static ("GstIteratorResult", values);

   924 }

   925 #ifdef __SYMBIAN32__

   926 EXPORT_C

   927 #endif

   928 

   929 GType

   930 gst_iterator_result_get_type (void)

   931 {

   932   static GType id;

   933   static GOnce once = G_ONCE_INIT;

   934 

   935   g_once (&once, (GThreadFunc)register_gst_iterator_result, &id);

   936   return id;

   937 }

   938 static void

   939 register_gst_iterator_item (GType* id)

   940 {

   941   static const GEnumValue values[] = {

   942     { C_ENUM(GST_ITERATOR_ITEM_SKIP), "GST_ITERATOR_ITEM_SKIP", "skip" },

   943     { C_ENUM(GST_ITERATOR_ITEM_PASS), "GST_ITERATOR_ITEM_PASS", "pass" },

   944     { C_ENUM(GST_ITERATOR_ITEM_END), "GST_ITERATOR_ITEM_END", "end" },

   945     { 0, NULL, NULL }

   946   };

   947   *id = g_enum_register_static ("GstIteratorItem", values);

   948 }

   949 #ifdef __SYMBIAN32__

   950 EXPORT_C

   951 #endif

   952 

   953 GType

   954 gst_iterator_item_get_type (void)

   955 {

   956   static GType id;

   957   static GOnce once = G_ONCE_INIT;

   958 

   959   g_once (&once, (GThreadFunc)register_gst_iterator_item, &id);

   960   return id;

   961 }

   962 

   963 /* enumerations from "gstmessage.h" */

   964 static void

   965 register_gst_message_type (GType* id)

   966 {

   967   static const GFlagsValue values[] = {

   968     { C_FLAGS(GST_MESSAGE_UNKNOWN), "GST_MESSAGE_UNKNOWN", "unknown" },

   969     { C_FLAGS(GST_MESSAGE_EOS), "GST_MESSAGE_EOS", "eos" },

   970     { C_FLAGS(GST_MESSAGE_ERROR), "GST_MESSAGE_ERROR", "error" },

   971     { C_FLAGS(GST_MESSAGE_WARNING), "GST_MESSAGE_WARNING", "warning" },

   972     { C_FLAGS(GST_MESSAGE_INFO), "GST_MESSAGE_INFO", "info" },

   973     { C_FLAGS(GST_MESSAGE_TAG), "GST_MESSAGE_TAG", "tag" },

   974     { C_FLAGS(GST_MESSAGE_BUFFERING), "GST_MESSAGE_BUFFERING", "buffering" },

   975     { C_FLAGS(GST_MESSAGE_STATE_CHANGED), "GST_MESSAGE_STATE_CHANGED", "state-changed" },

   976     { C_FLAGS(GST_MESSAGE_STATE_DIRTY), "GST_MESSAGE_STATE_DIRTY", "state-dirty" },

   977     { C_FLAGS(GST_MESSAGE_STEP_DONE), "GST_MESSAGE_STEP_DONE", "step-done" },

   978     { C_FLAGS(GST_MESSAGE_CLOCK_PROVIDE), "GST_MESSAGE_CLOCK_PROVIDE", "clock-provide" },

   979     { C_FLAGS(GST_MESSAGE_CLOCK_LOST), "GST_MESSAGE_CLOCK_LOST", "clock-lost" },

   980     { C_FLAGS(GST_MESSAGE_NEW_CLOCK), "GST_MESSAGE_NEW_CLOCK", "new-clock" },

   981     { C_FLAGS(GST_MESSAGE_STRUCTURE_CHANGE), "GST_MESSAGE_STRUCTURE_CHANGE", "structure-change" },

   982     { C_FLAGS(GST_MESSAGE_STREAM_STATUS), "GST_MESSAGE_STREAM_STATUS", "stream-status" },

   983     { C_FLAGS(GST_MESSAGE_APPLICATION), "GST_MESSAGE_APPLICATION", "application" },

   984     { C_FLAGS(GST_MESSAGE_ELEMENT), "GST_MESSAGE_ELEMENT", "element" },

   985     { C_FLAGS(GST_MESSAGE_SEGMENT_START), "GST_MESSAGE_SEGMENT_START", "segment-start" },

   986     { C_FLAGS(GST_MESSAGE_SEGMENT_DONE), "GST_MESSAGE_SEGMENT_DONE", "segment-done" },

   987     { C_FLAGS(GST_MESSAGE_DURATION), "GST_MESSAGE_DURATION", "duration" },

   988     { C_FLAGS(GST_MESSAGE_LATENCY), "GST_MESSAGE_LATENCY", "latency" },

   989     { C_FLAGS(GST_MESSAGE_ASYNC_START), "GST_MESSAGE_ASYNC_START", "async-start" },

   990     { C_FLAGS(GST_MESSAGE_ASYNC_DONE), "GST_MESSAGE_ASYNC_DONE", "async-done" },

   991     { C_FLAGS(GST_MESSAGE_ANY), "GST_MESSAGE_ANY", "any" },

   992     { 0, NULL, NULL }

   993   };

   994   *id = g_flags_register_static ("GstMessageType", values);

   995 }

   996 #ifdef __SYMBIAN32__

   997 EXPORT_C

   998 #endif

   999 

  1000 GType

  1001 gst_message_type_get_type (void)

  1002 {

  1003   static GType id;

  1004   static GOnce once = G_ONCE_INIT;

  1005 

  1006   g_once (&once, (GThreadFunc)register_gst_message_type, &id);

  1007   return id;

  1008 }

  1009 

  1010 /* enumerations from "gstminiobject.h" */

  1011 static void

  1012 register_gst_mini_object_flags (GType* id)

  1013 {

  1014   static const GFlagsValue values[] = {

  1015     { C_FLAGS(GST_MINI_OBJECT_FLAG_READONLY), "GST_MINI_OBJECT_FLAG_READONLY", "readonly" },

  1016     { C_FLAGS(GST_MINI_OBJECT_FLAG_LAST), "GST_MINI_OBJECT_FLAG_LAST", "last" },

  1017     { 0, NULL, NULL }

  1018   };

  1019   *id = g_flags_register_static ("GstMiniObjectFlags", values);

  1020 }

  1021 #ifdef __SYMBIAN32__

  1022 EXPORT_C

  1023 #endif

  1024 

  1025 GType

  1026 gst_mini_object_flags_get_type (void)

  1027 {

  1028   static GType id;

  1029   static GOnce once = G_ONCE_INIT;

  1030 

  1031   g_once (&once, (GThreadFunc)register_gst_mini_object_flags, &id);

  1032   return id;

  1033 }

  1034 

  1035 /* enumerations from "gstpad.h" */

  1036 static void

  1037 register_gst_pad_link_return (GType* id)

  1038 {

  1039   static const GEnumValue values[] = {

  1040     { C_ENUM(GST_PAD_LINK_OK), "GST_PAD_LINK_OK", "ok" },

  1041     { C_ENUM(GST_PAD_LINK_WRONG_HIERARCHY), "GST_PAD_LINK_WRONG_HIERARCHY", "wrong-hierarchy" },

  1042     { C_ENUM(GST_PAD_LINK_WAS_LINKED), "GST_PAD_LINK_WAS_LINKED", "was-linked" },

  1043     { C_ENUM(GST_PAD_LINK_WRONG_DIRECTION), "GST_PAD_LINK_WRONG_DIRECTION", "wrong-direction" },

  1044     { C_ENUM(GST_PAD_LINK_NOFORMAT), "GST_PAD_LINK_NOFORMAT", "noformat" },

  1045     { C_ENUM(GST_PAD_LINK_NOSCHED), "GST_PAD_LINK_NOSCHED", "nosched" },

  1046     { C_ENUM(GST_PAD_LINK_REFUSED), "GST_PAD_LINK_REFUSED", "refused" },

  1047     { 0, NULL, NULL }

  1048   };

  1049   *id = g_enum_register_static ("GstPadLinkReturn", values);

  1050 }

  1051 #ifdef __SYMBIAN32__

  1052 EXPORT_C

  1053 #endif

  1054 

  1055 GType

  1056 gst_pad_link_return_get_type (void)

  1057 {

  1058   static GType id;

  1059   static GOnce once = G_ONCE_INIT;

  1060 

  1061   g_once (&once, (GThreadFunc)register_gst_pad_link_return, &id);

  1062   return id;

  1063 }

  1064 static void

  1065 register_gst_flow_return (GType* id)

  1066 {

  1067   static const GEnumValue values[] = {

  1068     { C_ENUM(GST_FLOW_CUSTOM_SUCCESS), "GST_FLOW_CUSTOM_SUCCESS", "custom-success" },

  1069     { C_ENUM(GST_FLOW_RESEND), "GST_FLOW_RESEND", "resend" },

  1070     { C_ENUM(GST_FLOW_OK), "GST_FLOW_OK", "ok" },

  1071     { C_ENUM(GST_FLOW_NOT_LINKED), "GST_FLOW_NOT_LINKED", "not-linked" },

  1072     { C_ENUM(GST_FLOW_WRONG_STATE), "GST_FLOW_WRONG_STATE", "wrong-state" },

  1073     { C_ENUM(GST_FLOW_UNEXPECTED), "GST_FLOW_UNEXPECTED", "unexpected" },

  1074     { C_ENUM(GST_FLOW_NOT_NEGOTIATED), "GST_FLOW_NOT_NEGOTIATED", "not-negotiated" },

  1075     { C_ENUM(GST_FLOW_ERROR), "GST_FLOW_ERROR", "error" },

  1076     { C_ENUM(GST_FLOW_NOT_SUPPORTED), "GST_FLOW_NOT_SUPPORTED", "not-supported" },

  1077     { C_ENUM(GST_FLOW_CUSTOM_ERROR), "GST_FLOW_CUSTOM_ERROR", "custom-error" },

  1078     { 0, NULL, NULL }

  1079   };

  1080   *id = g_enum_register_static ("GstFlowReturn", values);

  1081 }

  1082 #ifdef __SYMBIAN32__

  1083 EXPORT_C

  1084 #endif

  1085 

  1086 GType

  1087 gst_flow_return_get_type (void)

  1088 {

  1089   static GType id;

  1090   static GOnce once = G_ONCE_INIT;

  1091 

  1092   g_once (&once, (GThreadFunc)register_gst_flow_return, &id);

  1093   return id;

  1094 }

  1095 static void

  1096 register_gst_activate_mode (GType* id)

  1097 {

  1098   static const GEnumValue values[] = {

  1099     { C_ENUM(GST_ACTIVATE_NONE), "GST_ACTIVATE_NONE", "none" },

  1100     { C_ENUM(GST_ACTIVATE_PUSH), "GST_ACTIVATE_PUSH", "push" },

  1101     { C_ENUM(GST_ACTIVATE_PULL), "GST_ACTIVATE_PULL", "pull" },

  1102     { 0, NULL, NULL }

  1103   };

  1104   *id = g_enum_register_static ("GstActivateMode", values);

  1105 }

  1106 #ifdef __SYMBIAN32__

  1107 EXPORT_C

  1108 #endif

  1109 

  1110 GType

  1111 gst_activate_mode_get_type (void)

  1112 {

  1113   static GType id;

  1114   static GOnce once = G_ONCE_INIT;

  1115 

  1116   g_once (&once, (GThreadFunc)register_gst_activate_mode, &id);

  1117   return id;

  1118 }

  1119 static void

  1120 register_gst_pad_direction (GType* id)

  1121 {

  1122   static const GEnumValue values[] = {

  1123     { C_ENUM(GST_PAD_UNKNOWN), "GST_PAD_UNKNOWN", "unknown" },

  1124     { C_ENUM(GST_PAD_SRC), "GST_PAD_SRC", "src" },

  1125     { C_ENUM(GST_PAD_SINK), "GST_PAD_SINK", "sink" },

  1126     { 0, NULL, NULL }

  1127   };

  1128   *id = g_enum_register_static ("GstPadDirection", values);

  1129 }

  1130 #ifdef __SYMBIAN32__

  1131 EXPORT_C

  1132 #endif

  1133 

  1134 GType

  1135 gst_pad_direction_get_type (void)