win32/common/gstmarshal.c

   1 #include "gst_private.h"
   2 #include "glib-object.h"
   3 #include "gstmarshal.h"
   4
   5 #include        <glib-object.h>
   6
   7
   8 #ifdef G_ENABLE_DEBUG
   9 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
  10 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
  11 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  12 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  13 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  14 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  15 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  16 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  17 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  18 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  19 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  20 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  21 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  22 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  23 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  24 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  25 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  26 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  27 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
  28 #else /* !G_ENABLE_DEBUG */
  29 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  30  *          Do not access GValues directly in your code. Instead, use the
  31  *          g_value_get_*() functions
  32  */
  33 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  34 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  35 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  36 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  37 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  38 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  39 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  40 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  41 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  42 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
  43 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
  44 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  45 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  46 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  47 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  48 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  49 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  50 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  51 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
  52 #endif /* !G_ENABLE_DEBUG */
  53
  54
  55 /* VOID:VOID (./gstmarshal.list:1) */
  56
  57 /* VOID:BOOLEAN (./gstmarshal.list:2) */
  58
  59 /* VOID:INT (./gstmarshal.list:3) */
  60
  61 /* VOID:STRING (./gstmarshal.list:4) */
  62
  63 /* VOID:BOXED (./gstmarshal.list:5) */
  64
  65 /* VOID:BOXED,OBJECT (./gstmarshal.list:6) */
  66 void
  67 gst_marshal_VOID__BOXED_OBJECT (GClosure * closure,
  68     GValue * return_value G_GNUC_UNUSED,
  69     guint n_param_values,
  70     const GValue * param_values,
  71     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
  72 {
  73   typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer data1,
  74       gpointer arg_1, gpointer arg_2, gpointer data2);
  75   register GMarshalFunc_VOID__BOXED_OBJECT callback;
  76   register GCClosure *cc = (GCClosure *) closure;
  77   register gpointer data1, data2;
  78
  79   g_return_if_fail (n_param_values == 3);
  80
  81   if (G_CCLOSURE_SWAP_DATA (closure)) {
  82     data1 = closure->data;
  83     data2 = g_value_peek_pointer (param_values + 0);
  84   } else {
  85     data1 = g_value_peek_pointer (param_values + 0);
  86     data2 = closure->data;
  87   }
  88   callback =
  89       (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data :
  90       cc->callback);
  91
  92   callback (data1,
  93       g_marshal_value_peek_boxed (param_values + 1),
  94       g_marshal_value_peek_object (param_values + 2), data2);
  95 }
  96
  97 /* VOID:POINTER (./gstmarshal.list:7) */
  98
  99 /* VOID:POINTER,OBJECT (./gstmarshal.list:8) */
 100 void
 101 gst_marshal_VOID__POINTER_OBJECT (GClosure * closure,
 102     GValue * return_value G_GNUC_UNUSED,
 103     guint n_param_values,
 104     const GValue * param_values,
 105     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 106 {
 107   typedef void (*GMarshalFunc_VOID__POINTER_OBJECT) (gpointer data1,
 108       gpointer arg_1, gpointer arg_2, gpointer data2);
 109   register GMarshalFunc_VOID__POINTER_OBJECT callback;
 110   register GCClosure *cc = (GCClosure *) closure;
 111   register gpointer data1, data2;
 112
 113   g_return_if_fail (n_param_values == 3);
 114
 115   if (G_CCLOSURE_SWAP_DATA (closure)) {
 116     data1 = closure->data;
 117     data2 = g_value_peek_pointer (param_values + 0);
 118   } else {
 119     data1 = g_value_peek_pointer (param_values + 0);
 120     data2 = closure->data;
 121   }
 122   callback =
 123       (GMarshalFunc_VOID__POINTER_OBJECT) (marshal_data ? marshal_data :
 124       cc->callback);
 125
 126   callback (data1,
 127       g_marshal_value_peek_pointer (param_values + 1),
 128       g_marshal_value_peek_object (param_values + 2), data2);
 129 }
 130
 131 /* VOID:OBJECT (./gstmarshal.list:9) */
 132
 133 /* VOID:OBJECT,OBJECT (./gstmarshal.list:10) */
 134 void
 135 gst_marshal_VOID__OBJECT_OBJECT (GClosure * closure,
 136     GValue * return_value G_GNUC_UNUSED,
 137     guint n_param_values,
 138     const GValue * param_values,
 139     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 140 {
 141   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
 142       gpointer arg_1, gpointer arg_2, gpointer data2);
 143   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 144   register GCClosure *cc = (GCClosure *) closure;
 145   register gpointer data1, data2;
 146
 147   g_return_if_fail (n_param_values == 3);
 148
 149   if (G_CCLOSURE_SWAP_DATA (closure)) {
 150     data1 = closure->data;
 151     data2 = g_value_peek_pointer (param_values + 0);
 152   } else {
 153     data1 = g_value_peek_pointer (param_values + 0);
 154     data2 = closure->data;
 155   }
 156   callback =
 157       (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data :
 158       cc->callback);
 159
 160   callback (data1,
 161       g_marshal_value_peek_object (param_values + 1),
 162       g_marshal_value_peek_object (param_values + 2), data2);
 163 }
 164
 165 /* VOID:OBJECT,PARAM (./gstmarshal.list:11) */
 166 void
 167 gst_marshal_VOID__OBJECT_PARAM (GClosure * closure,
 168     GValue * return_value G_GNUC_UNUSED,
 169     guint n_param_values,
 170     const GValue * param_values,
 171     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 172 {
 173   typedef void (*GMarshalFunc_VOID__OBJECT_PARAM) (gpointer data1,
 174       gpointer arg_1, gpointer arg_2, gpointer data2);
 175   register GMarshalFunc_VOID__OBJECT_PARAM callback;
 176   register GCClosure *cc = (GCClosure *) closure;
 177   register gpointer data1, data2;
 178
 179   g_return_if_fail (n_param_values == 3);
 180
 181   if (G_CCLOSURE_SWAP_DATA (closure)) {
 182     data1 = closure->data;
 183     data2 = g_value_peek_pointer (param_values + 0);
 184   } else {
 185     data1 = g_value_peek_pointer (param_values + 0);
 186     data2 = closure->data;
 187   }
 188   callback =
 189       (GMarshalFunc_VOID__OBJECT_PARAM) (marshal_data ? marshal_data :
 190       cc->callback);
 191
 192   callback (data1,
 193       g_marshal_value_peek_object (param_values + 1),
 194       g_marshal_value_peek_param (param_values + 2), data2);
 195 }
 196
 197 /* VOID:OBJECT,POINTER (./gstmarshal.list:12) */
 198 void
 199 gst_marshal_VOID__OBJECT_POINTER (GClosure * closure,
 200     GValue * return_value G_GNUC_UNUSED,
 201     guint n_param_values,
 202     const GValue * param_values,
 203     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 204 {
 205   typedef void (*GMarshalFunc_VOID__OBJECT_POINTER) (gpointer data1,
 206       gpointer arg_1, gpointer arg_2, gpointer data2);
 207   register GMarshalFunc_VOID__OBJECT_POINTER callback;
 208   register GCClosure *cc = (GCClosure *) closure;
 209   register gpointer data1, data2;
 210
 211   g_return_if_fail (n_param_values == 3);
 212
 213   if (G_CCLOSURE_SWAP_DATA (closure)) {
 214     data1 = closure->data;
 215     data2 = g_value_peek_pointer (param_values + 0);
 216   } else {
 217     data1 = g_value_peek_pointer (param_values + 0);
 218     data2 = closure->data;
 219   }
 220   callback =
 221       (GMarshalFunc_VOID__OBJECT_POINTER) (marshal_data ? marshal_data :
 222       cc->callback);
 223
 224   callback (data1,
 225       g_marshal_value_peek_object (param_values + 1),
 226       g_marshal_value_peek_pointer (param_values + 2), data2);
 227 }
 228
 229 /* VOID:OBJECT,BOXED (./gstmarshal.list:13) */
 230 void
 231 gst_marshal_VOID__OBJECT_BOXED (GClosure * closure,
 232     GValue * return_value G_GNUC_UNUSED,
 233     guint n_param_values,
 234     const GValue * param_values,
 235     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 236 {
 237   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED) (gpointer data1,
 238       gpointer arg_1, gpointer arg_2, gpointer data2);
 239   register GMarshalFunc_VOID__OBJECT_BOXED callback;
 240   register GCClosure *cc = (GCClosure *) closure;
 241   register gpointer data1, data2;
 242
 243   g_return_if_fail (n_param_values == 3);
 244
 245   if (G_CCLOSURE_SWAP_DATA (closure)) {
 246     data1 = closure->data;
 247     data2 = g_value_peek_pointer (param_values + 0);
 248   } else {
 249     data1 = g_value_peek_pointer (param_values + 0);
 250     data2 = closure->data;
 251   }
 252   callback =
 253       (GMarshalFunc_VOID__OBJECT_BOXED) (marshal_data ? marshal_data :
 254       cc->callback);
 255
 256   callback (data1,
 257       g_marshal_value_peek_object (param_values + 1),
 258       g_marshal_value_peek_boxed (param_values + 2), data2);
 259 }
 260
 261 /* VOID:OBJECT,BOXED,STRING (./gstmarshal.list:14) */
 262 void
 263 gst_marshal_VOID__OBJECT_BOXED_STRING (GClosure * closure,
 264     GValue * return_value G_GNUC_UNUSED,
 265     guint n_param_values,
 266     const GValue * param_values,
 267     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 268 {
 269   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_STRING) (gpointer data1,
 270       gpointer arg_1, gpointer arg_2, gpointer arg_3, gpointer data2);
 271   register GMarshalFunc_VOID__OBJECT_BOXED_STRING callback;
 272   register GCClosure *cc = (GCClosure *) closure;
 273   register gpointer data1, data2;
 274
 275   g_return_if_fail (n_param_values == 4);
 276
 277   if (G_CCLOSURE_SWAP_DATA (closure)) {
 278     data1 = closure->data;
 279     data2 = g_value_peek_pointer (param_values + 0);
 280   } else {
 281     data1 = g_value_peek_pointer (param_values + 0);
 282     data2 = closure->data;
 283   }
 284   callback =
 285       (GMarshalFunc_VOID__OBJECT_BOXED_STRING) (marshal_data ? marshal_data :
 286       cc->callback);
 287
 288   callback (data1,
 289       g_marshal_value_peek_object (param_values + 1),
 290       g_marshal_value_peek_boxed (param_values + 2),
 291       g_marshal_value_peek_string (param_values + 3), data2);
 292 }
 293
 294 /* VOID:OBJECT,OBJECT,STRING (./gstmarshal.list:15) */
 295 void
 296 gst_marshal_VOID__OBJECT_OBJECT_STRING (GClosure * closure,
 297     GValue * return_value G_GNUC_UNUSED,
 298     guint n_param_values,
 299     const GValue * param_values,
 300     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 301 {
 302   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (gpointer data1,
 303       gpointer arg_1, gpointer arg_2, gpointer arg_3, gpointer data2);
 304   register GMarshalFunc_VOID__OBJECT_OBJECT_STRING callback;
 305   register GCClosure *cc = (GCClosure *) closure;
 306   register gpointer data1, data2;
 307
 308   g_return_if_fail (n_param_values == 4);
 309
 310   if (G_CCLOSURE_SWAP_DATA (closure)) {
 311     data1 = closure->data;
 312     data2 = g_value_peek_pointer (param_values + 0);
 313   } else {
 314     data1 = g_value_peek_pointer (param_values + 0);
 315     data2 = closure->data;
 316   }
 317   callback =
 318       (GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (marshal_data ? marshal_data :
 319       cc->callback);
 320
 321   callback (data1,
 322       g_marshal_value_peek_object (param_values + 1),
 323       g_marshal_value_peek_object (param_values + 2),
 324       g_marshal_value_peek_string (param_values + 3), data2);
 325 }
 326
 327 /* VOID:OBJECT,STRING (./gstmarshal.list:16) */
 328 void
 329 gst_marshal_VOID__OBJECT_STRING (GClosure * closure,
 330     GValue * return_value G_GNUC_UNUSED,
 331     guint n_param_values,
 332     const GValue * param_values,
 333     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 334 {
 335   typedef void (*GMarshalFunc_VOID__OBJECT_STRING) (gpointer data1,
 336       gpointer arg_1, gpointer arg_2, gpointer data2);
 337   register GMarshalFunc_VOID__OBJECT_STRING callback;
 338   register GCClosure *cc = (GCClosure *) closure;
 339   register gpointer data1, data2;
 340
 341   g_return_if_fail (n_param_values == 3);
 342
 343   if (G_CCLOSURE_SWAP_DATA (closure)) {
 344     data1 = closure->data;
 345     data2 = g_value_peek_pointer (param_values + 0);
 346   } else {
 347     data1 = g_value_peek_pointer (param_values + 0);
 348     data2 = closure->data;
 349   }
 350   callback =
 351       (GMarshalFunc_VOID__OBJECT_STRING) (marshal_data ? marshal_data :
 352       cc->callback);
 353
 354   callback (data1,
 355       g_marshal_value_peek_object (param_values + 1),
 356       g_marshal_value_peek_string (param_values + 2), data2);
 357 }
 358
 359 /* VOID:INT,INT (./gstmarshal.list:17) */
 360 void
 361 gst_marshal_VOID__INT_INT (GClosure * closure,
 362     GValue * return_value G_GNUC_UNUSED,
 363     guint n_param_values,
 364     const GValue * param_values,
 365     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 366 {
 367   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
 368       gint arg_1, gint arg_2, gpointer data2);
 369   register GMarshalFunc_VOID__INT_INT callback;
 370   register GCClosure *cc = (GCClosure *) closure;
 371   register gpointer data1, data2;
 372
 373   g_return_if_fail (n_param_values == 3);
 374
 375   if (G_CCLOSURE_SWAP_DATA (closure)) {
 376     data1 = closure->data;
 377     data2 = g_value_peek_pointer (param_values + 0);
 378   } else {
 379     data1 = g_value_peek_pointer (param_values + 0);
 380     data2 = closure->data;
 381   }
 382   callback =
 383       (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
 384
 385   callback (data1,
 386       g_marshal_value_peek_int (param_values + 1),
 387       g_marshal_value_peek_int (param_values + 2), data2);
 388 }
 389
 390 /* VOID:INT64 (./gstmarshal.list:18) */
 391 void
 392 gst_marshal_VOID__INT64 (GClosure * closure,
 393     GValue * return_value G_GNUC_UNUSED,
 394     guint n_param_values,
 395     const GValue * param_values,
 396     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 397 {
 398   typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1,
 399       gint64 arg_1, gpointer data2);
 400   register GMarshalFunc_VOID__INT64 callback;
 401   register GCClosure *cc = (GCClosure *) closure;
 402   register gpointer data1, data2;
 403
 404   g_return_if_fail (n_param_values == 2);
 405
 406   if (G_CCLOSURE_SWAP_DATA (closure)) {
 407     data1 = closure->data;
 408     data2 = g_value_peek_pointer (param_values + 0);
 409   } else {
 410     data1 = g_value_peek_pointer (param_values + 0);
 411     data2 = closure->data;
 412   }
 413   callback =
 414       (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);
 415
 416   callback (data1, g_marshal_value_peek_int64 (param_values + 1), data2);
 417 }
 418
 419 /* VOID:UINT,BOXED (./gstmarshal.list:19) */
 420 void
 421 gst_marshal_VOID__UINT_BOXED (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, gpointer marshal_data)
 426 {
 427   typedef void (*GMarshalFunc_VOID__UINT_BOXED) (gpointer data1,
 428       guint arg_1, gpointer arg_2, gpointer data2);
 429   register GMarshalFunc_VOID__UINT_BOXED callback;
 430   register GCClosure *cc = (GCClosure *) closure;
 431   register gpointer data1, data2;
 432
 433   g_return_if_fail (n_param_values == 3);
 434
 435   if (G_CCLOSURE_SWAP_DATA (closure)) {
 436     data1 = closure->data;
 437     data2 = g_value_peek_pointer (param_values + 0);
 438   } else {
 439     data1 = g_value_peek_pointer (param_values + 0);
 440     data2 = closure->data;
 441   }
 442   callback =
 443       (GMarshalFunc_VOID__UINT_BOXED) (marshal_data ? marshal_data :
 444       cc->callback);
 445
 446   callback (data1,
 447       g_marshal_value_peek_uint (param_values + 1),
 448       g_marshal_value_peek_boxed (param_values + 2), data2);
 449 }
 450
 451 /* VOID:UINT,POINTER (./gstmarshal.list:20) */
 452
 453 /* BOOLEAN:VOID (./gstmarshal.list:21) */
 454 void
 455 gst_marshal_BOOLEAN__VOID (GClosure * closure,
 456     GValue * return_value G_GNUC_UNUSED,
 457     guint n_param_values,
 458     const GValue * param_values,
 459     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 460 {
 461   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
 462       gpointer data2);
 463   register GMarshalFunc_BOOLEAN__VOID callback;
 464   register GCClosure *cc = (GCClosure *) closure;
 465   register gpointer data1, data2;
 466   gboolean v_return;
 467
 468   g_return_if_fail (return_value != NULL);
 469   g_return_if_fail (n_param_values == 1);
 470
 471   if (G_CCLOSURE_SWAP_DATA (closure)) {
 472     data1 = closure->data;
 473     data2 = g_value_peek_pointer (param_values + 0);
 474   } else {
 475     data1 = g_value_peek_pointer (param_values + 0);
 476     data2 = closure->data;
 477   }
 478   callback =
 479       (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 480
 481   v_return = callback (data1, data2);
 482
 483   g_value_set_boolean (return_value, v_return);
 484 }
 485
 486 /* BOOLEAN:POINTER (./gstmarshal.list:22) */
 487 void
 488 gst_marshal_BOOLEAN__POINTER (GClosure * closure,
 489     GValue * return_value G_GNUC_UNUSED,
 490     guint n_param_values,
 491     const GValue * param_values,
 492     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 493 {
 494   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1,
 495       gpointer arg_1, gpointer data2);
 496   register GMarshalFunc_BOOLEAN__POINTER callback;
 497   register GCClosure *cc = (GCClosure *) closure;
 498   register gpointer data1, data2;
 499   gboolean v_return;
 500
 501   g_return_if_fail (return_value != NULL);
 502   g_return_if_fail (n_param_values == 2);
 503
 504   if (G_CCLOSURE_SWAP_DATA (closure)) {
 505     data1 = closure->data;
 506     data2 = g_value_peek_pointer (param_values + 0);
 507   } else {
 508     data1 = g_value_peek_pointer (param_values + 0);
 509     data2 = closure->data;
 510   }
 511   callback =
 512       (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data :
 513       cc->callback);
 514
 515   v_return = callback (data1,
 516       g_marshal_value_peek_pointer (param_values + 1), data2);
 517
 518   g_value_set_boolean (return_value, v_return);
 519 }
 520
 521 /* BOOLEAN:BOXED (./gstmarshal.list:23) */
 522 void
 523 gst_marshal_BOOLEAN__BOXED (GClosure * closure,
 524     GValue * return_value G_GNUC_UNUSED,
 525     guint n_param_values,
 526     const GValue * param_values,
 527     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 528 {
 529   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer data1,
 530       gpointer arg_1, gpointer data2);
 531   register GMarshalFunc_BOOLEAN__BOXED callback;
 532   register GCClosure *cc = (GCClosure *) closure;
 533   register gpointer data1, data2;
 534   gboolean v_return;
 535
 536   g_return_if_fail (return_value != NULL);
 537   g_return_if_fail (n_param_values == 2);
 538
 539   if (G_CCLOSURE_SWAP_DATA (closure)) {
 540     data1 = closure->data;
 541     data2 = g_value_peek_pointer (param_values + 0);
 542   } else {
 543     data1 = g_value_peek_pointer (param_values + 0);
 544     data2 = closure->data;
 545   }
 546   callback =
 547       (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data :
 548       cc->callback);
 549
 550   v_return = callback (data1,
 551       g_marshal_value_peek_boxed (param_values + 1), data2);
 552
 553   g_value_set_boolean (return_value, v_return);
 554 }
 555
 556 /* POINTER:POINTER (./gstmarshal.list:24) */
 557 void
 558 gst_marshal_POINTER__POINTER (GClosure * closure,
 559     GValue * return_value G_GNUC_UNUSED,
 560     guint n_param_values,
 561     const GValue * param_values,
 562     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 563 {
 564   typedef gpointer (*GMarshalFunc_POINTER__POINTER) (gpointer data1,
 565       gpointer arg_1, gpointer data2);
 566   register GMarshalFunc_POINTER__POINTER callback;
 567   register GCClosure *cc = (GCClosure *) closure;
 568   register gpointer data1, data2;
 569   gpointer v_return;
 570
 571   g_return_if_fail (return_value != NULL);
 572   g_return_if_fail (n_param_values == 2);
 573
 574   if (G_CCLOSURE_SWAP_DATA (closure)) {
 575     data1 = closure->data;
 576     data2 = g_value_peek_pointer (param_values + 0);
 577   } else {
 578     data1 = g_value_peek_pointer (param_values + 0);
 579     data2 = closure->data;
 580   }
 581   callback =
 582       (GMarshalFunc_POINTER__POINTER) (marshal_data ? marshal_data :
 583       cc->callback);
 584
 585   v_return = callback (data1,
 586       g_marshal_value_peek_pointer (param_values + 1), data2);
 587
 588   g_value_set_pointer (return_value, v_return);
 589 }
 590
 591 /* BOXED:BOXED (./gstmarshal.list:25) */
 592 void
 593 gst_marshal_BOXED__BOXED (GClosure * closure,
 594     GValue * return_value G_GNUC_UNUSED,
 595     guint n_param_values,
 596     const GValue * param_values,
 597     gpointer invocation_hint G_GNUC_UNUSED, gpointer marshal_data)
 598 {
 599   typedef gpointer (*GMarshalFunc_BOXED__BOXED) (gpointer data1,
 600       gpointer arg_1, gpointer data2);
 601   register GMarshalFunc_BOXED__BOXED callback;
 602   register GCClosure *cc = (GCClosure *) closure;
 603   register gpointer data1, data2;
 604   gpointer v_return;
 605
 606   g_return_if_fail (return_value != NULL);
 607   g_return_if_fail (n_param_values == 2);
 608
 609   if (G_CCLOSURE_SWAP_DATA (closure)) {
 610     data1 = closure->data;
 611     data2 = g_value_peek_pointer (param_values + 0);
 612   } else {
 613     data1 = g_value_peek_pointer (param_values + 0);
 614     data2 = closure->data;
 615   }
 616   callback =
 617       (GMarshalFunc_BOXED__BOXED) (marshal_data ? marshal_data : cc->callback);
 618
 619   v_return = callback (data1,
 620       g_marshal_value_peek_boxed (param_values + 1), data2);
 621
 622   g_value_take_boxed (return_value, v_return);
 623 }