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 #include "gst_private.h"

    18 #include "glib-object.h"

    19 #include "gstmarshal.h"

    20 

    21 #include	<glib-object.h>

    22 

    23 

    24 #ifdef G_ENABLE_DEBUG

    25 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)

    26 #define g_marshal_value_peek_char(v)     g_value_get_char (v)

    27 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)

    28 #define g_marshal_value_peek_int(v)      g_value_get_int (v)

    29 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)

    30 #define g_marshal_value_peek_long(v)     g_value_get_long (v)

    31 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)

    32 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)

    33 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)

    34 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)

    35 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)

    36 #define g_marshal_value_peek_float(v)    g_value_get_float (v)

    37 #define g_marshal_value_peek_double(v)   g_value_get_double (v)

    38 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)

    39 #define g_marshal_value_peek_param(v)    g_value_get_param (v)

    40 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)

    41 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)

    42 #define g_marshal_value_peek_object(v)   g_value_get_object (v)

    43 #else /* !G_ENABLE_DEBUG */

    44 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.

    45  *          Do not access GValues directly in your code. Instead, use the

    46  *          g_value_get_*() functions

    47  */

    48 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int

    49 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int

    50 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint

    51 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int

    52 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint

    53 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long

    54 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong

    55 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64

    56 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64

    57 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long

    58 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong

    59 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float

    60 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double

    61 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer

    62 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer

    63 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer

    64 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer

    65 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer

    66 #endif /* !G_ENABLE_DEBUG */

    67 

    68 

    69 /* VOID:VOID (./gstmarshal.list:1) */

    70 

    71 /* VOID:BOOLEAN (./gstmarshal.list:2) */

    72 

    73 /* VOID:INT (./gstmarshal.list:3) */

    74 

    75 /* VOID:STRING (./gstmarshal.list:4) */

    76 

    77 /* VOID:BOXED (./gstmarshal.list:5) */

    78 

    79 /* VOID:BOXED,OBJECT (./gstmarshal.list:6) */

    80 #ifdef __SYMBIAN32__

    81 EXPORT_C

    82 #endif

    83 

    84 void

    85 gst_marshal_VOID__BOXED_OBJECT (GClosure     *closure,

    86                                 GValue       *return_value G_GNUC_UNUSED,

    87                                 guint         n_param_values,

    88                                 const GValue *param_values,

    89                                 gpointer      invocation_hint G_GNUC_UNUSED,

    90                                 gpointer      marshal_data)

    91 {

    92   typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer     data1,

    93                                                    gpointer     arg_1,

    94                                                    gpointer     arg_2,

    95                                                    gpointer     data2);

    96   register GMarshalFunc_VOID__BOXED_OBJECT callback;

    97   register GCClosure *cc = (GCClosure*) closure;

    98   register gpointer data1, data2;

    99 

   100   g_return_if_fail (n_param_values == 3);

   101 

   102   if (G_CCLOSURE_SWAP_DATA (closure))

   103     {

   104       data1 = closure->data;

   105       data2 = g_value_peek_pointer (param_values + 0);

   106     }

   107   else

   108     {

   109       data1 = g_value_peek_pointer (param_values + 0);

   110       data2 = closure->data;

   111     }

   112   callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);

   113 

   114   callback (data1,

   115             g_marshal_value_peek_boxed (param_values + 1),

   116             g_marshal_value_peek_object (param_values + 2),

   117             data2);

   118 }

   119 

   120 /* VOID:POINTER (./gstmarshal.list:7) */

   121 

   122 /* VOID:POINTER,OBJECT (./gstmarshal.list:8) */

   123 #ifdef __SYMBIAN32__

   124 EXPORT_C

   125 #endif

   126 

   127 void

   128 gst_marshal_VOID__POINTER_OBJECT (GClosure     *closure,

   129                                   GValue       *return_value G_GNUC_UNUSED,

   130                                   guint         n_param_values,

   131                                   const GValue *param_values,

   132                                   gpointer      invocation_hint G_GNUC_UNUSED,

   133                                   gpointer      marshal_data)

   134 {

   135   typedef void (*GMarshalFunc_VOID__POINTER_OBJECT) (gpointer     data1,

   136                                                      gpointer     arg_1,

   137                                                      gpointer     arg_2,

   138                                                      gpointer     data2);

   139   register GMarshalFunc_VOID__POINTER_OBJECT callback;

   140   register GCClosure *cc = (GCClosure*) closure;

   141   register gpointer data1, data2;

   142 

   143   g_return_if_fail (n_param_values == 3);

   144 

   145   if (G_CCLOSURE_SWAP_DATA (closure))

   146     {

   147       data1 = closure->data;

   148       data2 = g_value_peek_pointer (param_values + 0);

   149     }

   150   else

   151     {

   152       data1 = g_value_peek_pointer (param_values + 0);

   153       data2 = closure->data;

   154     }

   155   callback = (GMarshalFunc_VOID__POINTER_OBJECT) (marshal_data ? marshal_data : cc->callback);

   156 

   157   callback (data1,

   158             g_marshal_value_peek_pointer (param_values + 1),

   159             g_marshal_value_peek_object (param_values + 2),

   160             data2);

   161 }

   162 

   163 /* VOID:OBJECT (./gstmarshal.list:9) */

   164 

   165 /* VOID:OBJECT,OBJECT (./gstmarshal.list:10) */

   166 #ifdef __SYMBIAN32__

   167 EXPORT_C

   168 #endif

   169 

   170 void

   171 gst_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,

   172                                  GValue       *return_value G_GNUC_UNUSED,

   173                                  guint         n_param_values,

   174                                  const GValue *param_values,

   175                                  gpointer      invocation_hint G_GNUC_UNUSED,

   176                                  gpointer      marshal_data)

   177 {

   178   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,

   179                                                     gpointer     arg_1,

   180                                                     gpointer     arg_2,

   181                                                     gpointer     data2);

   182   register GMarshalFunc_VOID__OBJECT_OBJECT callback;

   183   register GCClosure *cc = (GCClosure*) closure;

   184   register gpointer data1, data2;

   185 

   186   g_return_if_fail (n_param_values == 3);

   187 

   188   if (G_CCLOSURE_SWAP_DATA (closure))

   189     {

   190       data1 = closure->data;

   191       data2 = g_value_peek_pointer (param_values + 0);

   192     }

   193   else

   194     {

   195       data1 = g_value_peek_pointer (param_values + 0);

   196       data2 = closure->data;

   197     }

   198   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);

   199 

   200   callback (data1,

   201             g_marshal_value_peek_object (param_values + 1),

   202             g_marshal_value_peek_object (param_values + 2),

   203             data2);

   204 }

   205 

   206 /* VOID:OBJECT,PARAM (./gstmarshal.list:11) */

   207 #ifdef __SYMBIAN32__

   208 EXPORT_C

   209 #endif

   210 

   211 void

   212 gst_marshal_VOID__OBJECT_PARAM (GClosure     *closure,

   213                                 GValue       *return_value G_GNUC_UNUSED,

   214                                 guint         n_param_values,

   215                                 const GValue *param_values,

   216                                 gpointer      invocation_hint G_GNUC_UNUSED,

   217                                 gpointer      marshal_data)

   218 {

   219   typedef void (*GMarshalFunc_VOID__OBJECT_PARAM) (gpointer     data1,

   220                                                    gpointer     arg_1,

   221                                                    gpointer     arg_2,

   222                                                    gpointer     data2);

   223   register GMarshalFunc_VOID__OBJECT_PARAM callback;

   224   register GCClosure *cc = (GCClosure*) closure;

   225   register gpointer data1, data2;

   226 

   227   g_return_if_fail (n_param_values == 3);

   228 

   229   if (G_CCLOSURE_SWAP_DATA (closure))

   230     {

   231       data1 = closure->data;

   232       data2 = g_value_peek_pointer (param_values + 0);

   233     }

   234   else

   235     {

   236       data1 = g_value_peek_pointer (param_values + 0);

   237       data2 = closure->data;

   238     }

   239   callback = (GMarshalFunc_VOID__OBJECT_PARAM) (marshal_data ? marshal_data : cc->callback);

   240 

   241   callback (data1,

   242             g_marshal_value_peek_object (param_values + 1),

   243             g_marshal_value_peek_param (param_values + 2),

   244             data2);

   245 }

   246 

   247 /* VOID:OBJECT,POINTER (./gstmarshal.list:12) */

   248 #ifdef __SYMBIAN32__

   249 EXPORT_C

   250 #endif

   251 

   252 void

   253 gst_marshal_VOID__OBJECT_POINTER (GClosure     *closure,

   254                                   GValue       *return_value G_GNUC_UNUSED,

   255                                   guint         n_param_values,

   256                                   const GValue *param_values,

   257                                   gpointer      invocation_hint G_GNUC_UNUSED,

   258                                   gpointer      marshal_data)

   259 {

   260   typedef void (*GMarshalFunc_VOID__OBJECT_POINTER) (gpointer     data1,

   261                                                      gpointer     arg_1,

   262                                                      gpointer     arg_2,

   263                                                      gpointer     data2);

   264   register GMarshalFunc_VOID__OBJECT_POINTER callback;

   265   register GCClosure *cc = (GCClosure*) closure;

   266   register gpointer data1, data2;

   267 

   268   g_return_if_fail (n_param_values == 3);

   269 

   270   if (G_CCLOSURE_SWAP_DATA (closure))

   271     {

   272       data1 = closure->data;

   273       data2 = g_value_peek_pointer (param_values + 0);

   274     }

   275   else

   276     {

   277       data1 = g_value_peek_pointer (param_values + 0);

   278       data2 = closure->data;

   279     }

   280   callback = (GMarshalFunc_VOID__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);

   281 

   282   callback (data1,

   283             g_marshal_value_peek_object (param_values + 1),

   284             g_marshal_value_peek_pointer (param_values + 2),

   285             data2);

   286 }

   287 

   288 /* VOID:OBJECT,BOXED (./gstmarshal.list:13) */

   289 #ifdef __SYMBIAN32__

   290 EXPORT_C

   291 #endif

   292 

   293 void

   294 gst_marshal_VOID__OBJECT_BOXED (GClosure     *closure,

   295                                 GValue       *return_value G_GNUC_UNUSED,

   296                                 guint         n_param_values,

   297                                 const GValue *param_values,

   298                                 gpointer      invocation_hint G_GNUC_UNUSED,

   299                                 gpointer      marshal_data)

   300 {

   301   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED) (gpointer     data1,

   302                                                    gpointer     arg_1,

   303                                                    gpointer     arg_2,

   304                                                    gpointer     data2);

   305   register GMarshalFunc_VOID__OBJECT_BOXED callback;

   306   register GCClosure *cc = (GCClosure*) closure;

   307   register gpointer data1, data2;

   308 

   309   g_return_if_fail (n_param_values == 3);

   310 

   311   if (G_CCLOSURE_SWAP_DATA (closure))

   312     {

   313       data1 = closure->data;

   314       data2 = g_value_peek_pointer (param_values + 0);

   315     }

   316   else

   317     {

   318       data1 = g_value_peek_pointer (param_values + 0);

   319       data2 = closure->data;

   320     }

   321   callback = (GMarshalFunc_VOID__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);

   322 

   323   callback (data1,

   324             g_marshal_value_peek_object (param_values + 1),

   325             g_marshal_value_peek_boxed (param_values + 2),

   326             data2);

   327 }

   328 

   329 /* VOID:OBJECT,BOXED,STRING (./gstmarshal.list:14) */

   330 #ifdef __SYMBIAN32__

   331 EXPORT_C

   332 #endif

   333 

   334 void

   335 gst_marshal_VOID__OBJECT_BOXED_STRING (GClosure     *closure,

   336                                        GValue       *return_value G_GNUC_UNUSED,

   337                                        guint         n_param_values,

   338                                        const GValue *param_values,

   339                                        gpointer      invocation_hint G_GNUC_UNUSED,

   340                                        gpointer      marshal_data)

   341 {

   342   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_STRING) (gpointer     data1,

   343                                                           gpointer     arg_1,

   344                                                           gpointer     arg_2,

   345                                                           gpointer     arg_3,

   346                                                           gpointer     data2);

   347   register GMarshalFunc_VOID__OBJECT_BOXED_STRING callback;

   348   register GCClosure *cc = (GCClosure*) closure;

   349   register gpointer data1, data2;

   350 

   351   g_return_if_fail (n_param_values == 4);

   352 

   353   if (G_CCLOSURE_SWAP_DATA (closure))

   354     {

   355       data1 = closure->data;

   356       data2 = g_value_peek_pointer (param_values + 0);

   357     }

   358   else

   359     {

   360       data1 = g_value_peek_pointer (param_values + 0);

   361       data2 = closure->data;

   362     }

   363   callback = (GMarshalFunc_VOID__OBJECT_BOXED_STRING) (marshal_data ? marshal_data : cc->callback);

   364 

   365   callback (data1,

   366             g_marshal_value_peek_object (param_values + 1),

   367             g_marshal_value_peek_boxed (param_values + 2),

   368             g_marshal_value_peek_string (param_values + 3),

   369             data2);

   370 }

   371 

   372 /* VOID:OBJECT,OBJECT,STRING (./gstmarshal.list:15) */

   373 #ifdef __SYMBIAN32__

   374 EXPORT_C

   375 #endif

   376 

   377 void

   378 gst_marshal_VOID__OBJECT_OBJECT_STRING (GClosure     *closure,

   379                                         GValue       *return_value G_GNUC_UNUSED,

   380                                         guint         n_param_values,

   381                                         const GValue *param_values,

   382                                         gpointer      invocation_hint G_GNUC_UNUSED,

   383                                         gpointer      marshal_data)

   384 {

   385   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (gpointer     data1,

   386                                                            gpointer     arg_1,

   387                                                            gpointer     arg_2,

   388                                                            gpointer     arg_3,

   389                                                            gpointer     data2);

   390   register GMarshalFunc_VOID__OBJECT_OBJECT_STRING callback;

   391   register GCClosure *cc = (GCClosure*) closure;

   392   register gpointer data1, data2;

   393 

   394   g_return_if_fail (n_param_values == 4);

   395 

   396   if (G_CCLOSURE_SWAP_DATA (closure))

   397     {

   398       data1 = closure->data;

   399       data2 = g_value_peek_pointer (param_values + 0);

   400     }

   401   else

   402     {

   403       data1 = g_value_peek_pointer (param_values + 0);

   404       data2 = closure->data;

   405     }

   406   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);

   407 

   408   callback (data1,

   409             g_marshal_value_peek_object (param_values + 1),

   410             g_marshal_value_peek_object (param_values + 2),

   411             g_marshal_value_peek_string (param_values + 3),

   412             data2);

   413 }

   414 

   415 /* VOID:OBJECT,STRING (./gstmarshal.list:16) */

   416 #ifdef __SYMBIAN32__

   417 EXPORT_C

   418 #endif

   419 

   420 void

   421 gst_marshal_VOID__OBJECT_STRING (GClosure     *closure,

   422                                  GValue       *return_value G_GNUC_UNUSED,

   423                                  guint         n_param_values,

   424                                  const GValue *param_values,

   425                                  gpointer      invocation_hint G_GNUC_UNUSED,

   426                                  gpointer      marshal_data)

   427 {

   428   typedef void (*GMarshalFunc_VOID__OBJECT_STRING) (gpointer     data1,

   429                                                     gpointer     arg_1,

   430                                                     gpointer     arg_2,

   431                                                     gpointer     data2);

   432   register GMarshalFunc_VOID__OBJECT_STRING callback;

   433   register GCClosure *cc = (GCClosure*) closure;

   434   register gpointer data1, data2;

   435 

   436   g_return_if_fail (n_param_values == 3);

   437 

   438   if (G_CCLOSURE_SWAP_DATA (closure))

   439     {

   440       data1 = closure->data;

   441       data2 = g_value_peek_pointer (param_values + 0);

   442     }

   443   else

   444     {

   445       data1 = g_value_peek_pointer (param_values + 0);

   446       data2 = closure->data;

   447     }

   448   callback = (GMarshalFunc_VOID__OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);

   449 

   450   callback (data1,

   451             g_marshal_value_peek_object (param_values + 1),

   452             g_marshal_value_peek_string (param_values + 2),

   453             data2);

   454 }

   455 

   456 /* VOID:INT,INT (./gstmarshal.list:17) */

   457 #ifdef __SYMBIAN32__

   458 EXPORT_C

   459 #endif

   460 

   461 void

   462 gst_marshal_VOID__INT_INT (GClosure     *closure,

   463                            GValue       *return_value G_GNUC_UNUSED,

   464                            guint         n_param_values,

   465                            const GValue *param_values,

   466                            gpointer      invocation_hint G_GNUC_UNUSED,

   467                            gpointer      marshal_data)

   468 {

   469   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,

   470                                               gint         arg_1,

   471                                               gint         arg_2,

   472                                               gpointer     data2);

   473   register GMarshalFunc_VOID__INT_INT callback;

   474   register GCClosure *cc = (GCClosure*) closure;

   475   register gpointer data1, data2;

   476 

   477   g_return_if_fail (n_param_values == 3);

   478 

   479   if (G_CCLOSURE_SWAP_DATA (closure))

   480     {

   481       data1 = closure->data;

   482       data2 = g_value_peek_pointer (param_values + 0);

   483     }

   484   else

   485     {

   486       data1 = g_value_peek_pointer (param_values + 0);

   487       data2 = closure->data;

   488     }

   489   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);

   490 

   491   callback (data1,

   492             g_marshal_value_peek_int (param_values + 1),

   493             g_marshal_value_peek_int (param_values + 2),

   494             data2);

   495 }

   496 

   497 /* VOID:INT64 (./gstmarshal.list:18) */

   498 #ifdef __SYMBIAN32__

   499 EXPORT_C

   500 #endif

   501 

   502 void

   503 gst_marshal_VOID__INT64 (GClosure     *closure,

   504                          GValue       *return_value G_GNUC_UNUSED,

   505                          guint         n_param_values,

   506                          const GValue *param_values,

   507                          gpointer      invocation_hint G_GNUC_UNUSED,

   508                          gpointer      marshal_data)

   509 {

   510   typedef void (*GMarshalFunc_VOID__INT64) (gpointer     data1,

   511                                             gint64       arg_1,

   512                                             gpointer     data2);

   513   register GMarshalFunc_VOID__INT64 callback;

   514   register GCClosure *cc = (GCClosure*) closure;

   515   register gpointer data1, data2;

   516 

   517   g_return_if_fail (n_param_values == 2);

   518 

   519   if (G_CCLOSURE_SWAP_DATA (closure))

   520     {

   521       data1 = closure->data;

   522       data2 = g_value_peek_pointer (param_values + 0);

   523     }

   524   else

   525     {

   526       data1 = g_value_peek_pointer (param_values + 0);

   527       data2 = closure->data;

   528     }

   529   callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);

   530 

   531   callback (data1,

   532             g_marshal_value_peek_int64 (param_values + 1),

   533             data2);

   534 }

   535 

   536 /* VOID:UINT,BOXED (./gstmarshal.list:19) */

   537 #ifdef __SYMBIAN32__

   538 EXPORT_C

   539 #endif

   540 

   541 void

   542 gst_marshal_VOID__UINT_BOXED (GClosure     *closure,

   543                               GValue       *return_value G_GNUC_UNUSED,

   544                               guint         n_param_values,

   545                               const GValue *param_values,

   546                               gpointer      invocation_hint G_GNUC_UNUSED,

   547                               gpointer      marshal_data)

   548 {

   549   typedef void (*GMarshalFunc_VOID__UINT_BOXED) (gpointer     data1,

   550                                                  guint        arg_1,

   551                                                  gpointer     arg_2,

   552                                                  gpointer     data2);

   553   register GMarshalFunc_VOID__UINT_BOXED callback;

   554   register GCClosure *cc = (GCClosure*) closure;

   555   register gpointer data1, data2;

   556 

   557   g_return_if_fail (n_param_values == 3);

   558 

   559   if (G_CCLOSURE_SWAP_DATA (closure))

   560     {

   561       data1 = closure->data;

   562       data2 = g_value_peek_pointer (param_values + 0);

   563     }

   564   else

   565     {

   566       data1 = g_value_peek_pointer (param_values + 0);

   567       data2 = closure->data;

   568     }

   569   callback = (GMarshalFunc_VOID__UINT_BOXED) (marshal_data ? marshal_data : cc->callback);

   570 

   571   callback (data1,

   572             g_marshal_value_peek_uint (param_values + 1),

   573             g_marshal_value_peek_boxed (param_values + 2),

   574             data2);

   575 }

   576 

   577 /* VOID:UINT,POINTER (./gstmarshal.list:20) */

   578 

   579 /* BOOLEAN:VOID (./gstmarshal.list:21) */

   580 #ifdef __SYMBIAN32__

   581 EXPORT_C

   582 #endif

   583 

   584 void

   585 gst_marshal_BOOLEAN__VOID (GClosure     *closure,

   586                            GValue       *return_value G_GNUC_UNUSED,

   587                            guint         n_param_values,

   588                            const GValue *param_values,

   589                            gpointer      invocation_hint G_GNUC_UNUSED,

   590                            gpointer      marshal_data)

   591 {

   592   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,

   593                                                   gpointer     data2);

   594   register GMarshalFunc_BOOLEAN__VOID callback;

   595   register GCClosure *cc = (GCClosure*) closure;

   596   register gpointer data1, data2;

   597   gboolean v_return;

   598 

   599   g_return_if_fail (return_value != NULL);

   600   g_return_if_fail (n_param_values == 1);

   601 

   602   if (G_CCLOSURE_SWAP_DATA (closure))

   603     {

   604       data1 = closure->data;

   605       data2 = g_value_peek_pointer (param_values + 0);

   606     }

   607   else

   608     {

   609       data1 = g_value_peek_pointer (param_values + 0);

   610       data2 = closure->data;

   611     }

   612   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);

   613 

   614   v_return = callback (data1,

   615                        data2);

   616 

   617   g_value_set_boolean (return_value, v_return);

   618 }

   619 

   620 /* BOOLEAN:POINTER (./gstmarshal.list:22) */

   621 #ifdef __SYMBIAN32__

   622 EXPORT_C

   623 #endif

   624 

   625 void

   626 gst_marshal_BOOLEAN__POINTER (GClosure     *closure,

   627                               GValue       *return_value G_GNUC_UNUSED,

   628                               guint         n_param_values,

   629                               const GValue *param_values,

   630                               gpointer      invocation_hint G_GNUC_UNUSED,

   631                               gpointer      marshal_data)

   632 {

   633   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,

   634                                                      gpointer     arg_1,

   635                                                      gpointer     data2);

   636   register GMarshalFunc_BOOLEAN__POINTER callback;

   637   register GCClosure *cc = (GCClosure*) closure;

   638   register gpointer data1, data2;

   639   gboolean v_return;

   640 

   641   g_return_if_fail (return_value != NULL);

   642   g_return_if_fail (n_param_values == 2);

   643 

   644   if (G_CCLOSURE_SWAP_DATA (closure))

   645     {

   646       data1 = closure->data;

   647       data2 = g_value_peek_pointer (param_values + 0);

   648     }

   649   else

   650     {

   651       data1 = g_value_peek_pointer (param_values + 0);

   652       data2 = closure->data;

   653     }

   654   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);

   655 

   656   v_return = callback (data1,

   657                        g_marshal_value_peek_pointer (param_values + 1),

   658                        data2);

   659 

   660   g_value_set_boolean (return_value, v_return);

   661 }

   662 

   663 /* POINTER:POINTER (./gstmarshal.list:23) */

   664 #ifdef __SYMBIAN32__

   665 EXPORT_C

   666 #endif

   667 

   668 void

   669 gst_marshal_POINTER__POINTER (GClosure     *closure,

   670                               GValue       *return_value G_GNUC_UNUSED,

   671                               guint         n_param_values,

   672                               const GValue *param_values,

   673                               gpointer      invocation_hint G_GNUC_UNUSED,

   674                               gpointer      marshal_data)

   675 {

   676   typedef gpointer (*GMarshalFunc_POINTER__POINTER) (gpointer     data1,

   677                                                      gpointer     arg_1,

   678                                                      gpointer     data2);

   679   register GMarshalFunc_POINTER__POINTER callback;

   680   register GCClosure *cc = (GCClosure*) closure;

   681   register gpointer data1, data2;

   682   gpointer v_return;

   683 

   684   g_return_if_fail (return_value != NULL);

   685   g_return_if_fail (n_param_values == 2);

   686 

   687   if (G_CCLOSURE_SWAP_DATA (closure))

   688     {

   689       data1 = closure->data;

   690       data2 = g_value_peek_pointer (param_values + 0);

   691     }

   692   else

   693     {

   694       data1 = g_value_peek_pointer (param_values + 0);

   695       data2 = closure->data;

   696     }

   697   callback = (GMarshalFunc_POINTER__POINTER) (marshal_data ? marshal_data : cc->callback);

   698 

   699   v_return = callback (data1,

   700                        g_marshal_value_peek_pointer (param_values + 1),

   701                        data2);

   702 

   703   g_value_set_pointer (return_value, v_return);

   704 }

   705 

   706 /* BOXED:BOXED (./gstmarshal.list:24) */

   707 #ifdef __SYMBIAN32__

   708 EXPORT_C

   709 #endif

   710 

   711 void

   712 gst_marshal_BOXED__BOXED (GClosure     *closure,

   713                           GValue       *return_value G_GNUC_UNUSED,

   714                           guint         n_param_values,

   715                           const GValue *param_values,

   716                           gpointer      invocation_hint G_GNUC_UNUSED,

   717                           gpointer      marshal_data)

   718 {

   719   typedef gpointer (*GMarshalFunc_BOXED__BOXED) (gpointer     data1,

   720                                                  gpointer     arg_1,

   721                                                  gpointer     data2);

   722   register GMarshalFunc_BOXED__BOXED callback;

   723   register GCClosure *cc = (GCClosure*) closure;

   724   register gpointer data1, data2;

   725   gpointer v_return;

   726 

   727   g_return_if_fail (return_value != NULL);

   728   g_return_if_fail (n_param_values == 2);

   729 

   730   if (G_CCLOSURE_SWAP_DATA (closure))

   731     {

   732       data1 = closure->data;

   733       data2 = g_value_peek_pointer (param_values + 0);

   734     }

   735   else

   736     {

   737       data1 = g_value_peek_pointer (param_values + 0);

   738       data2 = closure->data;

   739     }

   740   callback = (GMarshalFunc_BOXED__BOXED) (marshal_data ? marshal_data : cc->callback);

   741 

   742   v_return = callback (data1,

   743                        g_marshal_value_peek_boxed (param_values + 1),

   744                        data2);

   745 

   746   g_value_take_boxed (return_value, v_return);

   747 }

   748