gst/playback/gstplay-marshal.c

   1 #include "gstplay-marshal.h"
   2
   3 #include        <glib-object.h>
   4
   5
   6 #ifdef G_ENABLE_DEBUG
   7 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
   8 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
   9 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  10 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  11 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  12 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  13 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  14 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  15 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  16 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  17 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  18 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  19 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  20 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  21 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  22 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  23 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  24 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  25 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
  26 #else /* !G_ENABLE_DEBUG */
  27 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  28  *          Do not access GValues directly in your code. Instead, use the
  29  *          g_value_get_*() functions
  30  */
  31 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  32 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  33 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  34 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  35 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  36 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  37 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  38 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  39 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  40 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
  41 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
  42 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  43 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  44 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  45 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  46 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  47 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  48 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  49 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
  50 #endif /* !G_ENABLE_DEBUG */
  51
  52
  53 /* BOOLEAN:OBJECT,BOXED (gstplay-marshal.list:1) */
  54 void
  55 gst_play_marshal_BOOLEAN__OBJECT_BOXED (GClosure     *closure,
  56                                         GValue       *return_value G_GNUC_UNUSED,
  57                                         guint         n_param_values,
  58                                         const GValue *param_values,
  59                                         gpointer      invocation_hint G_GNUC_UNUSED,
  60                                         gpointer      marshal_data)
  61 {
  62   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED) (gpointer     data1,
  63                                                           gpointer     arg_1,
  64                                                           gpointer     arg_2,
  65                                                           gpointer     data2);
  66   register GMarshalFunc_BOOLEAN__OBJECT_BOXED callback;
  67   register GCClosure *cc = (GCClosure*) closure;
  68   register gpointer data1, data2;
  69   gboolean v_return;
  70
  71   g_return_if_fail (return_value != NULL);
  72   g_return_if_fail (n_param_values == 3);
  73
  74   if (G_CCLOSURE_SWAP_DATA (closure))
  75     {
  76       data1 = closure->data;
  77       data2 = g_value_peek_pointer (param_values + 0);
  78     }
  79   else
  80     {
  81       data1 = g_value_peek_pointer (param_values + 0);
  82       data2 = closure->data;
  83     }
  84   callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
  85
  86   v_return = callback (data1,
  87                        g_marshal_value_peek_object (param_values + 1),
  88                        g_marshal_value_peek_boxed (param_values + 2),
  89                        data2);
  90
  91   g_value_set_boolean (return_value, v_return);
  92 }
  93
  94 /* BOOLEAN:OBJECT,OBJECT,OBJECT (gstplay-marshal.list:2) */
  95 void
  96 gst_play_marshal_BOOLEAN__OBJECT_OBJECT_OBJECT (GClosure     *closure,
  97                                                 GValue       *return_value G_GNUC_UNUSED,
  98                                                 guint         n_param_values,
  99                                                 const GValue *param_values,
 100                                                 gpointer      invocation_hint G_GNUC_UNUSED,
 101                                                 gpointer      marshal_data)
 102 {
 103   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (gpointer     data1,
 104                                                                   gpointer     arg_1,
 105                                                                   gpointer     arg_2,
 106                                                                   gpointer     arg_3,
 107                                                                   gpointer     data2);
 108   register GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT callback;
 109   register GCClosure *cc = (GCClosure*) closure;
 110   register gpointer data1, data2;
 111   gboolean v_return;
 112
 113   g_return_if_fail (return_value != NULL);
 114   g_return_if_fail (n_param_values == 4);
 115
 116   if (G_CCLOSURE_SWAP_DATA (closure))
 117     {
 118       data1 = closure->data;
 119       data2 = g_value_peek_pointer (param_values + 0);
 120     }
 121   else
 122     {
 123       data1 = g_value_peek_pointer (param_values + 0);
 124       data2 = closure->data;
 125     }
 126   callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 127
 128   v_return = callback (data1,
 129                        g_marshal_value_peek_object (param_values + 1),
 130                        g_marshal_value_peek_object (param_values + 2),
 131                        g_marshal_value_peek_object (param_values + 3),
 132                        data2);
 133
 134   g_value_set_boolean (return_value, v_return);
 135 }
 136
 137 /* BOXED:OBJECT,BOXED (gstplay-marshal.list:3) */
 138 void
 139 gst_play_marshal_BOXED__OBJECT_BOXED (GClosure     *closure,
 140                                       GValue       *return_value G_GNUC_UNUSED,
 141                                       guint         n_param_values,
 142                                       const GValue *param_values,
 143                                       gpointer      invocation_hint G_GNUC_UNUSED,
 144                                       gpointer      marshal_data)
 145 {
 146   typedef gpointer (*GMarshalFunc_BOXED__OBJECT_BOXED) (gpointer     data1,
 147                                                         gpointer     arg_1,
 148                                                         gpointer     arg_2,
 149                                                         gpointer     data2);
 150   register GMarshalFunc_BOXED__OBJECT_BOXED callback;
 151   register GCClosure *cc = (GCClosure*) closure;
 152   register gpointer data1, data2;
 153   gpointer v_return;
 154
 155   g_return_if_fail (return_value != NULL);
 156   g_return_if_fail (n_param_values == 3);
 157
 158   if (G_CCLOSURE_SWAP_DATA (closure))
 159     {
 160       data1 = closure->data;
 161       data2 = g_value_peek_pointer (param_values + 0);
 162     }
 163   else
 164     {
 165       data1 = g_value_peek_pointer (param_values + 0);
 166       data2 = closure->data;
 167     }
 168   callback = (GMarshalFunc_BOXED__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
 169
 170   v_return = callback (data1,
 171                        g_marshal_value_peek_object (param_values + 1),
 172                        g_marshal_value_peek_boxed (param_values + 2),
 173                        data2);
 174
 175   g_value_take_boxed (return_value, v_return);
 176 }
 177
 178 /* VOID:OBJECT,BOOLEAN (gstplay-marshal.list:4) */
 179 void
 180 gst_play_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 181                                        GValue       *return_value G_GNUC_UNUSED,
 182                                        guint         n_param_values,
 183                                        const GValue *param_values,
 184                                        gpointer      invocation_hint G_GNUC_UNUSED,
 185                                        gpointer      marshal_data)
 186 {
 187   typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer     data1,
 188                                                      gpointer     arg_1,
 189                                                      gboolean     arg_2,
 190                                                      gpointer     data2);
 191   register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
 192   register GCClosure *cc = (GCClosure*) closure;
 193   register gpointer data1, data2;
 194
 195   g_return_if_fail (n_param_values == 3);
 196
 197   if (G_CCLOSURE_SWAP_DATA (closure))
 198     {
 199       data1 = closure->data;
 200       data2 = g_value_peek_pointer (param_values + 0);
 201     }
 202   else
 203     {
 204       data1 = g_value_peek_pointer (param_values + 0);
 205       data2 = closure->data;
 206     }
 207   callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 208
 209   callback (data1,
 210             g_marshal_value_peek_object (param_values + 1),
 211             g_marshal_value_peek_boolean (param_values + 2),
 212             data2);
 213 }
 214
 215 /* ENUM:OBJECT,OBJECT,BOXED (gstplay-marshal.list:5) */
 216 void
 217 gst_play_marshal_ENUM__OBJECT_OBJECT_BOXED (GClosure     *closure,
 218                                             GValue       *return_value G_GNUC_UNUSED,
 219                                             guint         n_param_values,
 220                                             const GValue *param_values,
 221                                             gpointer      invocation_hint G_GNUC_UNUSED,
 222                                             gpointer      marshal_data)
 223 {
 224   typedef gint (*GMarshalFunc_ENUM__OBJECT_OBJECT_BOXED) (gpointer     data1,
 225                                                           gpointer     arg_1,
 226                                                           gpointer     arg_2,
 227                                                           gpointer     arg_3,
 228                                                           gpointer     data2);
 229   register GMarshalFunc_ENUM__OBJECT_OBJECT_BOXED callback;
 230   register GCClosure *cc = (GCClosure*) closure;
 231   register gpointer data1, data2;
 232   gint v_return;
 233
 234   g_return_if_fail (return_value != NULL);
 235   g_return_if_fail (n_param_values == 4);
 236
 237   if (G_CCLOSURE_SWAP_DATA (closure))
 238     {
 239       data1 = closure->data;
 240       data2 = g_value_peek_pointer (param_values + 0);
 241     }
 242   else
 243     {
 244       data1 = g_value_peek_pointer (param_values + 0);
 245       data2 = closure->data;
 246     }
 247   callback = (GMarshalFunc_ENUM__OBJECT_OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
 248
 249   v_return = callback (data1,
 250                        g_marshal_value_peek_object (param_values + 1),
 251                        g_marshal_value_peek_object (param_values + 2),
 252                        g_marshal_value_peek_boxed (param_values + 3),
 253                        data2);
 254
 255   g_value_set_enum (return_value, v_return);
 256 }
 257
 258 /* ENUM:OBJECT,BOXED,OBJECT (gstplay-marshal.list:6) */
 259 void
 260 gst_play_marshal_ENUM__OBJECT_BOXED_OBJECT (GClosure     *closure,
 261                                             GValue       *return_value G_GNUC_UNUSED,
 262                                             guint         n_param_values,
 263                                             const GValue *param_values,
 264                                             gpointer      invocation_hint G_GNUC_UNUSED,
 265                                             gpointer      marshal_data)
 266 {
 267   typedef gint (*GMarshalFunc_ENUM__OBJECT_BOXED_OBJECT) (gpointer     data1,
 268                                                           gpointer     arg_1,
 269                                                           gpointer     arg_2,
 270                                                           gpointer     arg_3,
 271                                                           gpointer     data2);
 272   register GMarshalFunc_ENUM__OBJECT_BOXED_OBJECT callback;
 273   register GCClosure *cc = (GCClosure*) closure;
 274   register gpointer data1, data2;
 275   gint v_return;
 276
 277   g_return_if_fail (return_value != NULL);
 278   g_return_if_fail (n_param_values == 4);
 279
 280   if (G_CCLOSURE_SWAP_DATA (closure))
 281     {
 282       data1 = closure->data;
 283       data2 = g_value_peek_pointer (param_values + 0);
 284     }
 285   else
 286     {
 287       data1 = g_value_peek_pointer (param_values + 0);
 288       data2 = closure->data;
 289     }
 290   callback = (GMarshalFunc_ENUM__OBJECT_BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
 291
 292   v_return = callback (data1,
 293                        g_marshal_value_peek_object (param_values + 1),
 294                        g_marshal_value_peek_boxed (param_values + 2),
 295                        g_marshal_value_peek_object (param_values + 3),
 296                        data2);
 297
 298   g_value_set_enum (return_value, v_return);
 299 }
 300
 301 /* BOXED:OBJECT,BOXED,BOXED (gstplay-marshal.list:7) */
 302 void
 303 gst_play_marshal_BOXED__OBJECT_BOXED_BOXED (GClosure     *closure,
 304                                             GValue       *return_value G_GNUC_UNUSED,
 305                                             guint         n_param_values,
 306                                             const GValue *param_values,
 307                                             gpointer      invocation_hint G_GNUC_UNUSED,
 308                                             gpointer      marshal_data)
 309 {
 310   typedef gpointer (*GMarshalFunc_BOXED__OBJECT_BOXED_BOXED) (gpointer     data1,
 311                                                               gpointer     arg_1,
 312                                                               gpointer     arg_2,
 313                                                               gpointer     arg_3,
 314                                                               gpointer     data2);
 315   register GMarshalFunc_BOXED__OBJECT_BOXED_BOXED callback;
 316   register GCClosure *cc = (GCClosure*) closure;
 317   register gpointer data1, data2;
 318   gpointer v_return;
 319
 320   g_return_if_fail (return_value != NULL);
 321   g_return_if_fail (n_param_values == 4);
 322
 323   if (G_CCLOSURE_SWAP_DATA (closure))
 324     {
 325       data1 = closure->data;
 326       data2 = g_value_peek_pointer (param_values + 0);
 327     }
 328   else
 329     {
 330       data1 = g_value_peek_pointer (param_values + 0);
 331       data2 = closure->data;
 332     }
 333   callback = (GMarshalFunc_BOXED__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
 334
 335   v_return = callback (data1,
 336                        g_marshal_value_peek_object (param_values + 1),
 337                        g_marshal_value_peek_boxed (param_values + 2),
 338                        g_marshal_value_peek_boxed (param_values + 3),
 339                        data2);
 340
 341   g_value_take_boxed (return_value, v_return);
 342 }
 343
 344 /* BOXED:INT (gstplay-marshal.list:8) */
 345 void
 346 gst_play_marshal_BOXED__INT (GClosure     *closure,
 347                              GValue       *return_value G_GNUC_UNUSED,
 348                              guint         n_param_values,
 349                              const GValue *param_values,
 350                              gpointer      invocation_hint G_GNUC_UNUSED,
 351                              gpointer      marshal_data)
 352 {
 353   typedef gpointer (*GMarshalFunc_BOXED__INT) (gpointer     data1,
 354                                                gint         arg_1,
 355                                                gpointer     data2);
 356   register GMarshalFunc_BOXED__INT callback;
 357   register GCClosure *cc = (GCClosure*) closure;
 358   register gpointer data1, data2;
 359   gpointer v_return;
 360
 361   g_return_if_fail (return_value != NULL);
 362   g_return_if_fail (n_param_values == 2);
 363
 364   if (G_CCLOSURE_SWAP_DATA (closure))
 365     {
 366       data1 = closure->data;
 367       data2 = g_value_peek_pointer (param_values + 0);
 368     }
 369   else
 370     {
 371       data1 = g_value_peek_pointer (param_values + 0);
 372       data2 = closure->data;
 373     }
 374   callback = (GMarshalFunc_BOXED__INT) (marshal_data ? marshal_data : cc->callback);
 375
 376   v_return = callback (data1,
 377                        g_marshal_value_peek_int (param_values + 1),
 378                        data2);
 379
 380   g_value_take_boxed (return_value, v_return);
 381 }
 382
 383 /* OBJECT:BOXED (gstplay-marshal.list:9) */
 384 void
 385 gst_play_marshal_OBJECT__BOXED (GClosure     *closure,
 386                                 GValue       *return_value G_GNUC_UNUSED,
 387                                 guint         n_param_values,
 388                                 const GValue *param_values,
 389                                 gpointer      invocation_hint G_GNUC_UNUSED,
 390                                 gpointer      marshal_data)
 391 {
 392   typedef GObject* (*GMarshalFunc_OBJECT__BOXED) (gpointer     data1,
 393                                                   gpointer     arg_1,
 394                                                   gpointer     data2);
 395   register GMarshalFunc_OBJECT__BOXED callback;
 396   register GCClosure *cc = (GCClosure*) closure;
 397   register gpointer data1, data2;
 398   GObject* v_return;
 399
 400   g_return_if_fail (return_value != NULL);
 401   g_return_if_fail (n_param_values == 2);
 402
 403   if (G_CCLOSURE_SWAP_DATA (closure))
 404     {
 405       data1 = closure->data;
 406       data2 = g_value_peek_pointer (param_values + 0);
 407     }
 408   else
 409     {
 410       data1 = g_value_peek_pointer (param_values + 0);
 411       data2 = closure->data;
 412     }
 413   callback = (GMarshalFunc_OBJECT__BOXED) (marshal_data ? marshal_data : cc->callback);
 414
 415   v_return = callback (data1,
 416                        g_marshal_value_peek_boxed (param_values + 1),
 417                        data2);
 418
 419   g_value_take_object (return_value, v_return);
 420 }
 421
 422 /* OBJECT:INT (gstplay-marshal.list:10) */
 423 void
 424 gst_play_marshal_OBJECT__INT (GClosure     *closure,
 425                               GValue       *return_value G_GNUC_UNUSED,
 426                               guint         n_param_values,
 427                               const GValue *param_values,
 428                               gpointer      invocation_hint G_GNUC_UNUSED,
 429                               gpointer      marshal_data)
 430 {
 431   typedef GObject* (*GMarshalFunc_OBJECT__INT) (gpointer     data1,
 432                                                 gint         arg_1,
 433                                                 gpointer     data2);
 434   register GMarshalFunc_OBJECT__INT callback;
 435   register GCClosure *cc = (GCClosure*) closure;
 436   register gpointer data1, data2;
 437   GObject* v_return;
 438
 439   g_return_if_fail (return_value != NULL);
 440   g_return_if_fail (n_param_values == 2);
 441
 442   if (G_CCLOSURE_SWAP_DATA (closure))
 443     {
 444       data1 = closure->data;
 445       data2 = g_value_peek_pointer (param_values + 0);
 446     }
 447   else
 448     {
 449       data1 = g_value_peek_pointer (param_values + 0);
 450       data2 = closure->data;
 451     }
 452   callback = (GMarshalFunc_OBJECT__INT) (marshal_data ? marshal_data : cc->callback);
 453
 454   v_return = callback (data1,
 455                        g_marshal_value_peek_int (param_values + 1),
 456                        data2);
 457
 458   g_value_take_object (return_value, v_return);
 459 }
 460