gst/gstpad.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *
   5  * gstpad.c: Pads for connecting elements together
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* #define GST_DEBUG_ENABLED */
  24 #include "gst_private.h"
  25
  26 #include "gstpad.h"
  27 #include "gstutils.h"
  28 #include "gstelement.h"
  29 #include "gsttype.h"
  30 #include "gstbin.h"
  31 #include "gstscheduler.h"
  32 #include "gstevent.h"
  33
  34 GType _gst_pad_type = 0;
  35
  36 /***** Start with the base GstPad class *****/
  37 static void             gst_pad_class_init              (GstPadClass *klass);
  38 static void             gst_pad_init                    (GstPad *pad);
  39
  40 static gboolean         gst_pad_try_reconnect_filtered_func (GstRealPad *srcpad, GstRealPad *sinkpad,
  41                                                          GstCaps *caps, gboolean clear);
  42
  43 #ifndef GST_DISABLE_LOADSAVE
  44 static xmlNodePtr       gst_pad_save_thyself            (GstObject *object, xmlNodePtr parent);
  45 #endif
  46
  47 static GstObject *pad_parent_class = NULL;
  48
  49 GType
  50 gst_pad_get_type(void)
  51 {
  52   if (!_gst_pad_type) {
  53     static const GTypeInfo pad_info = {
  54       sizeof(GstPadClass),
  55       NULL,
  56       NULL,
  57       (GClassInitFunc)gst_pad_class_init,
  58       NULL,
  59       NULL,
  60       sizeof(GstPad),
  61       32,
  62       (GInstanceInitFunc)gst_pad_init,
  63       NULL
  64     };
  65     _gst_pad_type = g_type_register_static(GST_TYPE_OBJECT, "GstPad", &pad_info, 0);
  66   }
  67   return _gst_pad_type;
  68 }
  69
  70 static void
  71 gst_pad_class_init (GstPadClass *klass)
  72 {
  73   pad_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
  74 }
  75
  76 static void
  77 gst_pad_init (GstPad *pad)
  78 {
  79   pad->element_private = NULL;
  80
  81   pad->padtemplate = NULL;
  82 }
  83
  84
  85
  86 /***** Then do the Real Pad *****/
  87 /* Pad signals and args */
  88 enum {
  89   REAL_SET_ACTIVE,
  90   REAL_CAPS_CHANGED,
  91   REAL_CAPS_NEGO_FAILED,
  92   REAL_CONNECTED,
  93   REAL_DISCONNECTED,
  94   REAL_EVENT_RECEIVED,
  95   /* FILL ME */
  96   REAL_LAST_SIGNAL
  97 };
  98
  99 enum {
 100   REAL_ARG_0,
 101   REAL_ARG_ACTIVE,
 102   /* FILL ME */
 103 };
 104
 105 static void     gst_real_pad_class_init         (GstRealPadClass *klass);
 106 static void     gst_real_pad_init               (GstRealPad *pad);
 107
 108 static void     gst_real_pad_set_property       (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
 109 static void     gst_real_pad_get_property       (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 110
 111 static void     gst_real_pad_dispose            (GObject *object);
 112
 113 static void     gst_pad_push_func               (GstPad *pad, GstBuffer *buf);
 114
 115 GType _gst_real_pad_type = 0;
 116
 117 static GstPad *real_pad_parent_class = NULL;
 118 static guint gst_real_pad_signals[REAL_LAST_SIGNAL] = { 0 };
 119
 120 GType
 121 gst_real_pad_get_type(void) {
 122   if (!_gst_real_pad_type) {
 123     static const GTypeInfo pad_info = {
 124       sizeof(GstRealPadClass),
 125       NULL,
 126       NULL,
 127       (GClassInitFunc)gst_real_pad_class_init,
 128       NULL,
 129       NULL,
 130       sizeof(GstRealPad),
 131       32,
 132       (GInstanceInitFunc)gst_real_pad_init,
 133       NULL
 134     };
 135     _gst_real_pad_type = g_type_register_static(GST_TYPE_PAD, "GstRealPad", &pad_info, 0);
 136   }
 137   return _gst_real_pad_type;
 138 }
 139
 140 static void
 141 gst_real_pad_class_init (GstRealPadClass *klass)
 142 {
 143   GObjectClass *gobject_class;
 144   GstObjectClass *gstobject_class;
 145
 146   gobject_class = (GObjectClass*) klass;
 147   gstobject_class = (GstObjectClass*) klass;
 148
 149   real_pad_parent_class = g_type_class_ref (GST_TYPE_PAD);
 150
 151   gobject_class->dispose  = GST_DEBUG_FUNCPTR (gst_real_pad_dispose);
 152   gobject_class->set_property  = GST_DEBUG_FUNCPTR (gst_real_pad_set_property);
 153   gobject_class->get_property  = GST_DEBUG_FUNCPTR (gst_real_pad_get_property);
 154
 155   gst_real_pad_signals[REAL_SET_ACTIVE] =
 156     g_signal_new ("set_active", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 157                     G_STRUCT_OFFSET (GstRealPadClass, set_active), NULL, NULL,
 158                     gst_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1,
 159                     G_TYPE_BOOLEAN);
 160   gst_real_pad_signals[REAL_CAPS_CHANGED] =
 161     g_signal_new ("caps_changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 162                     G_STRUCT_OFFSET (GstRealPadClass, caps_changed), NULL, NULL,
 163                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 164                     G_TYPE_POINTER);
 165   gst_real_pad_signals[REAL_CAPS_NEGO_FAILED] =
 166     g_signal_new ("caps_nego_failed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 167                     G_STRUCT_OFFSET (GstRealPadClass, caps_nego_failed), NULL, NULL,
 168                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 169                     G_TYPE_POINTER);
 170   gst_real_pad_signals[REAL_CONNECTED] =
 171     g_signal_new ("connected", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 172                     G_STRUCT_OFFSET (GstRealPadClass, connected), NULL, NULL,
 173                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 174                     G_TYPE_POINTER);
 175   gst_real_pad_signals[REAL_DISCONNECTED] =
 176     g_signal_new ("disconnected", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 177                     G_STRUCT_OFFSET (GstRealPadClass, disconnected), NULL, NULL,
 178                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 179                     G_TYPE_POINTER);
 180   gst_real_pad_signals[REAL_EVENT_RECEIVED] =
 181     g_signal_new ("event_received", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 182                     G_STRUCT_OFFSET (GstRealPadClass, event_received), NULL, NULL,
 183                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
 184                     G_TYPE_POINTER);
 185
 186 /*  gtk_object_add_arg_type ("GstRealPad::active", G_TYPE_BOOLEAN, */
 187 /*                           GTK_ARG_READWRITE, REAL_ARG_ACTIVE); */
 188   g_object_class_install_property (G_OBJECT_CLASS (klass), REAL_ARG_ACTIVE,
 189     g_param_spec_boolean ("active", "Active", "Whether the pad is active.",
 190                           TRUE,G_PARAM_READWRITE));
 191
 192 #ifndef GST_DISABLE_LOADSAVE
 193   gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_pad_save_thyself);
 194 #endif
 195   gstobject_class->path_string_separator = ".";
 196 }
 197
 198 static void
 199 gst_real_pad_init (GstRealPad *pad)
 200 {
 201   pad->direction = GST_PAD_UNKNOWN;
 202   pad->peer = NULL;
 203
 204   pad->sched = NULL;
 205   pad->sched_private = NULL;
 206
 207   pad->chainfunc = NULL;
 208   pad->getfunc = NULL;
 209   pad->getregionfunc = NULL;
 210
 211   pad->chainhandler = GST_DEBUG_FUNCPTR (gst_pad_push_func);
 212   pad->gethandler = NULL;
 213   pad->pullregionfunc = NULL;
 214
 215   pad->bufferpoolfunc = NULL;
 216   pad->ghostpads = NULL;
 217   pad->caps = NULL;
 218
 219   pad->connectfunc = NULL;
 220   pad->getcapsfunc = NULL;
 221 }
 222
 223 static void
 224 gst_real_pad_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 225 {
 226   g_return_if_fail (GST_IS_PAD (object));
 227
 228   switch (prop_id) {
 229     case REAL_ARG_ACTIVE:
 230       if (g_value_get_boolean (value)) {
 231         GST_DEBUG (GST_CAT_PADS, "activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
 232         GST_FLAG_UNSET (object, GST_PAD_DISABLED);
 233       } else {
 234         GST_DEBUG (GST_CAT_PADS, "de-activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
 235         GST_FLAG_SET (object, GST_PAD_DISABLED);
 236       }
 237       g_signal_emit (G_OBJECT (object), gst_real_pad_signals[REAL_SET_ACTIVE], 0,
 238                       !GST_FLAG_IS_SET (object, GST_PAD_DISABLED));
 239       break;
 240     default:
 241       break;
 242   }
 243 }
 244
 245 static void
 246 gst_real_pad_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 247 {
 248   /* it's not null if we got it, but it might not be ours */
 249   g_return_if_fail (GST_IS_PAD (object));
 250
 251   switch (prop_id) {
 252     case REAL_ARG_ACTIVE:
 253       g_value_set_boolean (value, !GST_FLAG_IS_SET (object, GST_PAD_DISABLED));
 254       break;
 255     default:
 256       break;
 257   }
 258 }
 259
 260
 261 /**
 262  * gst_pad_new:
 263  * @name: name of new pad
 264  * @direction: either GST_PAD_SRC or GST_PAD_SINK
 265  *
 266  * Create a new pad with given name.
 267  *
 268  * Returns: new pad
 269  */
 270 GstPad*
 271 gst_pad_new (gchar *name,
 272              GstPadDirection direction)
 273 {
 274   GstRealPad *pad;
 275
 276   g_return_val_if_fail (name != NULL, NULL);
 277   g_return_val_if_fail (direction != GST_PAD_UNKNOWN, NULL);
 278
 279   pad = g_object_new (gst_real_pad_get_type (), NULL);
 280   gst_object_set_name (GST_OBJECT (pad), name);
 281   GST_RPAD_DIRECTION (pad) = direction;
 282
 283   return GST_PAD (pad);
 284 }
 285
 286 /**
 287  * gst_pad_new_from_template:
 288  * @templ: the pad template to use
 289  * @name: the name of the element
 290  *
 291  * Create a new pad with given name from the given template.
 292  *
 293  * Returns: new pad
 294  */
 295 GstPad*
 296 gst_pad_new_from_template (GstPadTemplate *templ,
 297                            gchar *name)
 298 {
 299   GstPad *pad;
 300
 301   g_return_val_if_fail (name != NULL, NULL);
 302   g_return_val_if_fail (templ != NULL, NULL);
 303
 304   pad = gst_pad_new (name, templ->direction);
 305
 306   gst_object_ref (GST_OBJECT (templ));
 307   GST_PAD_PADTEMPLATE (pad) = templ;
 308
 309   return pad;
 310 }
 311
 312 /**
 313  * gst_pad_get_direction:
 314  * @pad: the Pad to get the direction from
 315  *
 316  * Get the direction of the pad.
 317  *
 318  * Returns: the direction of the pad
 319  */
 320 GstPadDirection
 321 gst_pad_get_direction (GstPad *pad)
 322 {
 323   g_return_val_if_fail (pad != NULL, GST_PAD_UNKNOWN);
 324   g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_UNKNOWN);
 325
 326   return GST_PAD_DIRECTION (pad);
 327 }
 328
 329 /**
 330  * gst_pad_set_name:
 331  * @pad: the pad to set the name of
 332  * @name: the name of the pad
 333  *
 334  * Set the name of a pad.
 335  */
 336 void
 337 gst_pad_set_name (GstPad *pad,
 338                   const gchar *name)
 339 {
 340   g_return_if_fail (pad != NULL);
 341   g_return_if_fail (GST_IS_PAD (pad));
 342
 343   gst_object_set_name (GST_OBJECT (pad), name);
 344 }
 345
 346 /**
 347  * gst_pad_get_name:
 348  * @pad: the pad to get the name of
 349  *
 350  * Get the name of a pad.
 351  *
 352  * Returns: the name of the pad, don't free.
 353  */
 354 const gchar*
 355 gst_pad_get_name (GstPad *pad)
 356 {
 357   g_return_val_if_fail (pad != NULL, NULL);
 358   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 359
 360   return GST_OBJECT_NAME (pad);
 361 }
 362
 363 /**
 364  * gst_pad_set_chain_function:
 365  * @pad: the pad to set the chain function for
 366  * @chain: the chain function
 367  *
 368  * Set the given chain function for the pad.
 369  */
 370 void
 371 gst_pad_set_chain_function (GstPad *pad,
 372                             GstPadChainFunction chain)
 373 {
 374   g_return_if_fail (pad != NULL);
 375   g_return_if_fail (GST_IS_REAL_PAD (pad));
 376
 377   GST_RPAD_CHAINFUNC(pad) = chain;
 378   GST_DEBUG (GST_CAT_PADS, "chainfunc for %s:%s set to %s\n",
 379              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (chain));
 380 }
 381
 382 /**
 383  * gst_pad_set_get_function:
 384  * @pad: the pad to set the get function for
 385  * @get: the get function
 386  *
 387  * Set the given get function for the pad.
 388  */
 389 void
 390 gst_pad_set_get_function (GstPad *pad,
 391                           GstPadGetFunction get)
 392 {
 393   g_return_if_fail (pad != NULL);
 394   g_return_if_fail (GST_IS_REAL_PAD (pad));
 395
 396   GST_RPAD_GETFUNC(pad) = get;
 397   GST_DEBUG (GST_CAT_PADS, "getfunc for %s:%s  set to %s\n",
 398              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (get));
 399 }
 400
 401 /**
 402  * gst_pad_set_event_function:
 403  * @pad: the pad to set the event handler for
 404  * @event: the event handler
 405  *
 406  * Set the given event handler for the pad.
 407  */
 408 void
 409 gst_pad_set_event_function (GstPad *pad,
 410                             GstPadEventFunction event)
 411 {
 412   g_return_if_fail (pad != NULL);
 413   g_return_if_fail (GST_IS_REAL_PAD (pad));
 414
 415   GST_RPAD_EVENTFUNC(pad) = event;
 416   GST_DEBUG (GST_CAT_PADS, "eventfunc for %s:%s  set to %s\n",
 417              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (event));
 418 }
 419
 420 /**
 421  * gst_pad_set_getregion_function:
 422  * @pad: the pad to set the getregion function for
 423  * @getregion: the getregion function
 424  *
 425  * Set the given getregion function for the pad.
 426  */
 427 void
 428 gst_pad_set_getregion_function (GstPad *pad,
 429                                 GstPadGetRegionFunction getregion)
 430 {
 431   g_return_if_fail (pad != NULL);
 432   g_return_if_fail (GST_IS_REAL_PAD (pad));
 433
 434   GST_RPAD_GETREGIONFUNC(pad) = getregion;
 435   GST_DEBUG (GST_CAT_PADS, "getregionfunc for %s:%s set to %s\n",
 436              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getregion));
 437 }
 438
 439 /**
 440  * gst_pad_set_connect_function:
 441  * @pad: the pad to set the connect function for
 442  * @connect: the connect function
 443  *
 444  * Set the given connect function for the pad. It will be called
 445  * when the pad is connected or reconnected with caps.
 446  */
 447 void
 448 gst_pad_set_connect_function (GstPad *pad,
 449                               GstPadConnectFunction connect)
 450 {
 451   g_return_if_fail (pad != NULL);
 452   g_return_if_fail (GST_IS_REAL_PAD (pad));
 453
 454   GST_RPAD_CONNECTFUNC (pad) = connect;
 455   GST_DEBUG (GST_CAT_PADS, "connectfunc for %s:%s set to %s\n",
 456              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (connect));
 457 }
 458
 459 /**
 460  * gst_pad_set_getcaps_function:
 461  * @pad: the pad to set the getcaps function for
 462  * @getcaps: the getcaps function
 463  *
 464  * Set the given getcaps function for the pad.
 465  */
 466 void
 467 gst_pad_set_getcaps_function (GstPad *pad,
 468                               GstPadGetCapsFunction getcaps)
 469 {
 470   g_return_if_fail (pad != NULL);
 471   g_return_if_fail (GST_IS_REAL_PAD (pad));
 472
 473   GST_RPAD_GETCAPSFUNC (pad) = getcaps;
 474   GST_DEBUG (GST_CAT_PADS, "getcapsfunc for %s:%s set to %s\n",
 475              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getcaps));
 476 }
 477 /**
 478  * gst_pad_set_bufferpool_function:
 479  * @pad: the pad to set the bufferpool function for
 480  * @bufpool: the bufferpool function
 481  *
 482  * Set the given bufferpool function for the pad.
 483  */
 484 void
 485 gst_pad_set_bufferpool_function (GstPad *pad,
 486                                  GstPadBufferPoolFunction bufpool)
 487 {
 488   g_return_if_fail (pad != NULL);
 489   g_return_if_fail (GST_IS_REAL_PAD (pad));
 490
 491   GST_RPAD_BUFFERPOOLFUNC (pad) = bufpool;
 492   GST_DEBUG (GST_CAT_PADS, "bufferpoolfunc for %s:%s set to %s\n",
 493              GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (bufpool));
 494 }
 495
 496 static void
 497 gst_pad_push_func(GstPad *pad, GstBuffer *buf)
 498 {
 499   if (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad)) != NULL) {
 500     GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function %s\n",
 501                GST_DEBUG_FUNCPTR_NAME (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))));
 502     (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))) (pad, buf);
 503   } else {
 504     GST_DEBUG (GST_CAT_DATAFLOW, "default pad_push handler in place, no chain function\n");
 505     g_warning ("(internal error) default pad_push in place for pad %s:%s but it has no chain function",
 506                     GST_DEBUG_PAD_NAME (pad));
 507   }
 508 }
 509
 510
 511 /**
 512  * gst_pad_disconnect:
 513  * @srcpad: the source pad to disconnect
 514  * @sinkpad: the sink pad to disconnect
 515  *
 516  * Disconnects the source pad from the sink pad.
 517  */
 518 void
 519 gst_pad_disconnect (GstPad *srcpad,
 520                     GstPad *sinkpad)
 521 {
 522   GstRealPad *realsrc, *realsink;
 523
 524   /* generic checks */
 525   g_return_if_fail (srcpad != NULL);
 526   g_return_if_fail (GST_IS_PAD (srcpad));
 527   g_return_if_fail (sinkpad != NULL);
 528   g_return_if_fail (GST_IS_PAD (sinkpad));
 529
 530   GST_INFO (GST_CAT_ELEMENT_PADS, "disconnecting %s:%s(%p) and %s:%s(%p)",
 531             GST_DEBUG_PAD_NAME (srcpad), srcpad, GST_DEBUG_PAD_NAME (sinkpad), sinkpad);
 532
 533   /* now we need to deal with the real/ghost stuff */
 534   realsrc = GST_PAD_REALIZE (srcpad);
 535   realsink = GST_PAD_REALIZE (sinkpad);
 536
 537   g_return_if_fail (GST_RPAD_PEER (realsrc) != NULL);
 538   g_return_if_fail (GST_RPAD_PEER (realsink) != NULL);
 539
 540   if ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SINK) &&
 541       (GST_RPAD_DIRECTION (realsink) == GST_PAD_SRC)) {
 542     GstRealPad *temppad;
 543
 544     temppad = realsrc;
 545     realsrc = realsink;
 546     realsink = temppad;
 547   }
 548   g_return_if_fail ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC) &&
 549                     (GST_RPAD_DIRECTION (realsink) == GST_PAD_SINK));
 550
 551   /* first clear peers */
 552   GST_RPAD_PEER (realsrc) = NULL;
 553   GST_RPAD_PEER (realsink) = NULL;
 554
 555   /* reset the filters, both filters are refcounted once */
 556   if (GST_RPAD_FILTER (realsrc)) {
 557     gst_caps_unref (GST_RPAD_FILTER (realsrc));
 558     GST_RPAD_FILTER (realsink) = NULL;
 559     GST_RPAD_FILTER (realsrc) = NULL;
 560   }
 561
 562   /* now tell the scheduler */
 563   if (GST_PAD_PARENT (realsrc)->sched)
 564     gst_scheduler_pad_disconnect (GST_PAD_PARENT (realsrc)->sched, (GstPad *)realsrc, (GstPad *)realsink);
 565   else if (GST_PAD_PARENT (realsink)->sched)
 566     gst_scheduler_pad_disconnect (GST_PAD_PARENT (realsink)->sched, (GstPad *)realsrc, (GstPad *)realsink);
 567
 568   /* fire off a signal to each of the pads telling them that they've been disconnected */
 569   g_signal_emit (G_OBJECT (realsrc), gst_real_pad_signals[REAL_DISCONNECTED], 0, realsink);
 570   g_signal_emit (G_OBJECT (realsink), gst_real_pad_signals[REAL_DISCONNECTED], 0, realsrc);
 571
 572   GST_INFO (GST_CAT_ELEMENT_PADS, "disconnected %s:%s and %s:%s",
 573             GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
 574 }
 575
 576 /**
 577  * gst_pad_connect_filtered:
 578  * @srcpad: the source pad to connect
 579  * @sinkpad: the sink pad to connect
 580  * @filtercaps: the filter caps.
 581  *
 582  * Connects the source pad to the sink pad. The filter indicates the media type
 583  * that should flow trought this connection.
 584  *
 585  * Returns: TRUE if the pad could be connected, FALSE otherwise
 586  */
 587 gboolean
 588 gst_pad_connect_filtered (GstPad *srcpad, GstPad *sinkpad, GstCaps *filtercaps)
 589 {
 590   GstRealPad *realsrc, *realsink;
 591   gint num_decoupled = 0;
 592
 593   /* generic checks */
 594   g_return_val_if_fail (srcpad != NULL, FALSE);
 595   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
 596   g_return_val_if_fail (sinkpad != NULL, FALSE);
 597   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
 598
 599   GST_INFO (GST_CAT_PADS, "connecting %s:%s and %s:%s",
 600             GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
 601
 602   /* now we need to deal with the real/ghost stuff */
 603   realsrc = GST_PAD_REALIZE (srcpad);
 604   realsink = GST_PAD_REALIZE (sinkpad);
 605
 606   if ((GST_PAD (realsrc) != srcpad) || (GST_PAD (realsink) != sinkpad)) {
 607     GST_INFO (GST_CAT_PADS, "*actually* connecting %s:%s and %s:%s",
 608               GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
 609   }
 610
 611   g_return_val_if_fail (GST_RPAD_PEER (realsrc) == NULL, FALSE);
 612   g_return_val_if_fail (GST_RPAD_PEER (realsink) == NULL, FALSE);
 613   g_return_val_if_fail (GST_PAD_PARENT (realsrc) != NULL, FALSE);
 614   g_return_val_if_fail (GST_PAD_PARENT (realsink) != NULL, FALSE);
 615
 616   if (realsrc->sched && realsink->sched) {
 617     if (GST_FLAG_IS_SET (GST_PAD_PARENT (realsrc), GST_ELEMENT_DECOUPLED))
 618       num_decoupled++;
 619     if (GST_FLAG_IS_SET (GST_PAD_PARENT (realsink), GST_ELEMENT_DECOUPLED))
 620       num_decoupled++;
 621
 622     if (realsrc->sched != realsink->sched && num_decoupled != 1) {
 623       g_warning ("connecting pads with different scheds requires exactly one decoupled element (queue)\n");
 624       return FALSE;
 625     }
 626   }
 627
 628   /* check for reversed directions and swap if necessary */
 629   if ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SINK) &&
 630       (GST_RPAD_DIRECTION (realsink) == GST_PAD_SRC)) {
 631     GstRealPad *temppad;
 632
 633     temppad = realsrc;
 634     realsrc = realsink;
 635     realsink = temppad;
 636   }
 637   g_return_val_if_fail ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC) &&
 638                         (GST_RPAD_DIRECTION (realsink) == GST_PAD_SINK), FALSE);
 639
 640   /* first set peers */
 641   GST_RPAD_PEER (realsrc) = realsink;
 642   GST_RPAD_PEER (realsink) = realsrc;
 643
 644   /* try to negotiate the pads, we don't need to clear the caps here */
 645   if (!gst_pad_try_reconnect_filtered_func (realsrc, realsink, filtercaps, FALSE)) {
 646     GST_DEBUG (GST_CAT_CAPS, "pads cannot connect\n");
 647
 648     GST_RPAD_PEER (realsrc) = NULL;
 649     GST_RPAD_PEER (realsink) = NULL;
 650
 651     return FALSE;
 652   }
 653
 654   /* fire off a signal to each of the pads telling them that they've been connected */
 655   g_signal_emit (G_OBJECT (realsrc), gst_real_pad_signals[REAL_CONNECTED], 0, realsink);
 656   g_signal_emit (G_OBJECT (realsink), gst_real_pad_signals[REAL_CONNECTED], 0, realsrc);
 657
 658   /* now tell the scheduler(s) */
 659   if (realsrc->sched)
 660     gst_scheduler_pad_connect (realsrc->sched, (GstPad *)realsrc, (GstPad *)realsink);
 661   else if (realsink->sched)
 662     gst_scheduler_pad_connect (realsink->sched, (GstPad *)realsrc, (GstPad *)realsink);
 663
 664   GST_INFO (GST_CAT_PADS, "connected %s:%s and %s:%s",
 665             GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
 666
 667   return TRUE;
 668 }
 669
 670 /**
 671  * gst_pad_connect:
 672  * @srcpad: the source pad to connect
 673  * @sinkpad: the sink pad to connect
 674  *
 675  * Connects the source pad to the sink pad.
 676  *
 677  * Returns: TRUE if the pad could be connected, FALSE otherwise
 678  */
 679 gboolean
 680 gst_pad_connect (GstPad *srcpad, GstPad *sinkpad)
 681 {
 682   return gst_pad_connect_filtered (srcpad, sinkpad, NULL);
 683 }
 684
 685 /**
 686  * gst_pad_set_parent:
 687  * @pad: the pad to set the parent
 688  * @parent: the object to set the parent to
 689  *
 690  * Sets the parent object of a pad.
 691  */
 692 void
 693 gst_pad_set_parent (GstPad *pad,
 694                     GstObject *parent)
 695 {
 696   g_return_if_fail (pad != NULL);
 697   g_return_if_fail (GST_IS_PAD (pad));
 698   g_return_if_fail (GST_PAD_PARENT (pad) == NULL);
 699   g_return_if_fail (parent != NULL);
 700   g_return_if_fail (GST_IS_OBJECT (parent));
 701   g_return_if_fail ((gpointer)pad != (gpointer)parent);
 702
 703   gst_object_set_parent (GST_OBJECT (pad), parent);
 704 }
 705
 706 /**
 707  * gst_pad_get_parent:
 708  * @pad: the pad to get the parent from
 709  *
 710  * Get the parent object of this pad.
 711  *
 712  * Returns: the parent object
 713  */
 714 GstElement*
 715 gst_pad_get_parent (GstPad *pad)
 716 {
 717   g_return_val_if_fail (pad != NULL, NULL);
 718   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 719
 720   return GST_PAD_PARENT (pad);
 721 }
 722
 723 /**
 724  * gst_pad_get_padtemplate:
 725  * @pad: the pad to get the padtemplate from
 726  *
 727  * Get the padtemplate object of this pad.
 728  *
 729  * Returns: the padtemplate object
 730  */
 731 GstPadTemplate*
 732 gst_pad_get_padtemplate (GstPad *pad)
 733 {
 734   g_return_val_if_fail (pad != NULL, NULL);
 735   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 736
 737   return GST_PAD_PADTEMPLATE (pad);
 738 }
 739
 740
 741 /**
 742  * gst_pad_set_sched:
 743  * @pad: the pad to set the scheduler for
 744  * @sched: The scheduler to set
 745  *
 746  * Set the scheduler for the pad
 747  */
 748 void
 749 gst_pad_set_sched (GstPad *pad, GstScheduler *sched)
 750 {
 751   g_return_if_fail (pad != NULL);
 752   g_return_if_fail (GST_IS_PAD (pad));
 753
 754   GST_RPAD_SCHED(pad) = sched;
 755 }
 756
 757 /**
 758  * gst_pad_get_sched:
 759  * @pad: the pad to get the scheduler from
 760  *
 761  * Get the scheduler of the pad
 762  *
 763  * Returns: the scheduler of the pad.
 764  */
 765 GstScheduler*
 766 gst_pad_get_sched (GstPad *pad)
 767 {
 768   g_return_val_if_fail (pad != NULL, NULL);
 769   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 770
 771   return GST_RPAD_SCHED(pad);
 772 }
 773
 774 /**
 775  * gst_pad_unset_sched:
 776  * @pad: the pad to unset the scheduler for
 777  *
 778  * Unset the scheduler for the pad
 779  */
 780 void
 781 gst_pad_unset_sched (GstPad *pad)
 782 {
 783   g_return_if_fail (pad != NULL);
 784   g_return_if_fail (GST_IS_PAD (pad));
 785
 786   GST_RPAD_SCHED(pad) = NULL;
 787 }
 788
 789 /**
 790  * gst_pad_get_real_parent:
 791  * @pad: the pad to get the parent from
 792  *
 793  * Get the real parent object of this pad. If the pad
 794  * is a ghostpad, the actual owner of the real pad is
 795  * returned, as opposed to the gst_pad_get_parent().
 796  *
 797  * Returns: the parent object
 798  */
 799 GstElement*
 800 gst_pad_get_real_parent (GstPad *pad)
 801 {
 802   g_return_val_if_fail (pad != NULL, NULL);
 803   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 804
 805   return GST_PAD_PARENT (GST_PAD (GST_PAD_REALIZE (pad)));
 806 }
 807
 808 /**
 809  * gst_pad_add_ghost_pad:
 810  * @pad: the pad to set the ghost parent
 811  * @ghostpad: the ghost pad to add
 812  *
 813  * Add a ghost pad to a pad.
 814  */
 815 void
 816 gst_pad_add_ghost_pad (GstPad *pad,
 817                        GstPad *ghostpad)
 818 {
 819   GstRealPad *realpad;
 820
 821   g_return_if_fail (pad != NULL);
 822   g_return_if_fail (GST_IS_PAD (pad));
 823   g_return_if_fail (ghostpad != NULL);
 824   g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
 825
 826   realpad = GST_PAD_REALIZE (pad);
 827
 828   realpad->ghostpads = g_list_prepend (realpad->ghostpads, ghostpad);
 829 }
 830
 831
 832 /**
 833  * gst_pad_remove_ghost_pad:
 834  * @pad: the pad to remove the ghost parent
 835  * @ghostpad: the ghost pad to remove from the pad
 836  *
 837  * Remove a ghost pad from a pad.
 838  */
 839 void
 840 gst_pad_remove_ghost_pad (GstPad *pad,
 841                           GstPad *ghostpad)
 842 {
 843   GstRealPad *realpad;
 844
 845   g_return_if_fail (pad != NULL);
 846   g_return_if_fail (GST_IS_PAD (pad));
 847   g_return_if_fail (ghostpad != NULL);
 848   g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
 849
 850   realpad = GST_PAD_REALIZE (pad);
 851
 852   realpad->ghostpads = g_list_remove (realpad->ghostpads, ghostpad);
 853 }
 854
 855 /**
 856  * gst_pad_get_ghost_pad_list:
 857  * @pad: the pad to get the ghost parents from
 858  *
 859  * Get the ghost parents of this pad.
 860  *
 861  * Returns: a GList of ghost pads
 862  */
 863 GList*
 864 gst_pad_get_ghost_pad_list (GstPad *pad)
 865 {
 866   g_return_val_if_fail (pad != NULL, NULL);
 867   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
 868
 869   return GST_PAD_REALIZE(pad)->ghostpads;
 870 }
 871
 872 /* an internal caps negotiation helper function does:
 873  *
 874  * 1. optinally calls the pad connect function with the provided caps
 875  * 2. deal with the result code of the connect function
 876  * 3. set fixed caps on the pad.
 877  */
 878 static GstPadConnectReturn
 879 gst_pad_try_set_caps_func (GstRealPad *pad, GstCaps *caps, gboolean notify)
 880 {
 881   GstCaps *oldcaps;
 882   GstElement *parent = GST_PAD_PARENT (pad);
 883
 884   /* if this pad has a parent and the parent is not READY, delay the
 885    * negotiation */
 886   if (parent && GST_STATE (parent) < GST_STATE_READY)
 887     return GST_PAD_CONNECT_DELAYED;
 888
 889   GST_INFO (GST_CAT_CAPS, "trying to set caps %p on pad %s:%s",
 890             caps, GST_DEBUG_PAD_NAME (pad));
 891
 892   /* we need to notify the connect function */
 893   if (notify && GST_RPAD_CONNECTFUNC (pad)) {
 894     GstPadConnectReturn res;
 895     gchar *debug_string;
 896
 897     GST_INFO (GST_CAT_CAPS, "calling connect function on pad %s:%s",
 898             GST_DEBUG_PAD_NAME (pad));
 899
 900     /* call the connect function */
 901     res = GST_RPAD_CONNECTFUNC (pad) (GST_PAD (pad), caps);
 902
 903     switch (res) {
 904       case GST_PAD_CONNECT_REFUSED:
 905         debug_string = "REFUSED";
 906         break;
 907       case GST_PAD_CONNECT_OK:
 908         debug_string = "OK";
 909         break;
 910       case GST_PAD_CONNECT_DONE:
 911         debug_string = "DONE";
 912         break;
 913       case GST_PAD_CONNECT_DELAYED:
 914         debug_string = "DELAYED";
 915         break;
 916       default:
 917         g_warning ("unknown return code from connect function of pad %s:%s",
 918             GST_DEBUG_PAD_NAME (pad));
 919         return GST_PAD_CONNECT_REFUSED;
 920     }
 921
 922     GST_INFO (GST_CAT_CAPS, "got reply %s (%d) from connect function on pad %s:%s",
 923             debug_string, res, GST_DEBUG_PAD_NAME (pad));
 924
 925     /* done means the connect function called another caps negotiate function
 926      * on this pad that succeeded, we dont need to continue */
 927     if (res == GST_PAD_CONNECT_DONE) {
 928       GST_INFO (GST_CAT_CAPS, "pad %s:%s is done", GST_DEBUG_PAD_NAME (pad));
 929       return GST_PAD_CONNECT_DONE;
 930     }
 931     if (res == GST_PAD_CONNECT_REFUSED) {
 932       GST_INFO (GST_CAT_CAPS, "pad %s:%s doesn't accept caps",
 933                     GST_DEBUG_PAD_NAME (pad));
 934       return GST_PAD_CONNECT_REFUSED;
 935     }
 936   }
 937   /* we can only set caps on the pad if they are ficed */
 938   if (GST_CAPS_IS_FIXED (caps)) {
 939
 940     GST_INFO (GST_CAT_CAPS, "setting caps on pad %s:%s",
 941               GST_DEBUG_PAD_NAME (pad));
 942     /* if we got this far all is ok, remove the old caps, set the new one */
 943     oldcaps = GST_PAD_CAPS (pad);
 944     if (caps) gst_caps_ref (caps);
 945     GST_PAD_CAPS (pad) = caps;
 946     if (oldcaps) gst_caps_unref (oldcaps);
 947   }
 948   else {
 949     GST_INFO (GST_CAT_CAPS, "caps are not fixed on pad %s:%s, not setting them yet",
 950               GST_DEBUG_PAD_NAME (pad));
 951   }
 952
 953   return GST_PAD_CONNECT_OK;
 954 }
 955
 956 /**
 957  * gst_pad_try_set_caps:
 958  * @pad: the pad to try to set the caps on
 959  * @caps: the caps to set
 960  *
 961  * Try to set the caps on the given pad.
 962  *
 963  * Returns: TRUE if the caps could be set
 964  */
 965 gboolean
 966 gst_pad_try_set_caps (GstPad *pad, GstCaps *caps)
 967 {
 968   GstCaps *oldcaps;
 969   GstRealPad *peer, *realpad;
 970
 971   realpad = GST_PAD_REALIZE (pad);
 972   peer = GST_RPAD_PEER (realpad);
 973
 974   GST_INFO (GST_CAT_CAPS, "trying to set caps %p on pad %s:%s",
 975             caps, GST_DEBUG_PAD_NAME (realpad));
 976
 977   /* setting non fixed caps on a pad is not allowed */
 978   if (!GST_CAPS_IS_FIXED (caps)) {
 979     g_warning ("trying to set non fixed caps on pad %s:%s",
 980             GST_DEBUG_PAD_NAME (realpad));
 981     gst_caps_debug (caps);
 982     return FALSE;
 983   }
 984   /* if we have a peer try to set the caps, notifying the peerpad
 985    * if it has a connect function */
 986   if (peer && !gst_pad_try_set_caps_func (peer, caps, TRUE))
 987     return FALSE;
 988   /* then try to set our own caps, we don't need to be notified */
 989   if (!gst_pad_try_set_caps_func (realpad, caps, FALSE))
 990     return FALSE;
 991
 992   return TRUE;
 993 }
 994
 995 /* this is a caps negotiation convenience routine, it performs:
 996  *
 997  * 1. optionally clear any pad caps
 998  * 2. calculate the intersection between the two pad tamplate/getcaps caps
 999  * 3. calculate the intersection with the (optional) filtercaps.
1000  * 4. store the intersection in the pad filter
1001  * 5. store the app filtercaps in the pad appfilter.
1002  * 6. start the caps negotiation.
1003  */
1004 static gboolean
1005 gst_pad_try_reconnect_filtered_func (GstRealPad *srcpad, GstRealPad *sinkpad, GstCaps *filtercaps, gboolean clear)
1006 {
1007   GstCaps *srccaps, *sinkcaps;
1008   GstCaps *intersection = NULL;
1009   GstRealPad *realsrc, *realsink;
1010
1011   realsrc = GST_PAD_REALIZE (srcpad);
1012   realsink = GST_PAD_REALIZE (sinkpad);
1013
1014   g_return_val_if_fail (GST_RPAD_PEER (realsrc) != NULL, FALSE);
1015   g_return_val_if_fail (GST_RPAD_PEER (realsink) == realsrc, FALSE);
1016
1017   /* optinally clear the caps */
1018   if (clear) {
1019     GST_INFO (GST_CAT_PADS, "reconnect filtered %s:%s and %s:%s, clearing caps",
1020         GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
1021
1022     GST_PAD_CAPS (GST_PAD (realsrc)) = NULL;
1023     GST_PAD_CAPS (GST_PAD (realsink)) = NULL;
1024   }
1025   else {
1026     GST_INFO (GST_CAT_PADS, "reconnect filtered %s:%s and %s:%s",
1027         GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
1028   }
1029
1030   srccaps = gst_pad_get_caps (GST_PAD (realsrc));
1031   GST_INFO (GST_CAT_PADS, "dumping caps of pad %s:%s", GST_DEBUG_PAD_NAME (realsrc));
1032   gst_caps_debug (srccaps);
1033   sinkcaps = gst_pad_get_caps (GST_PAD (realsink));
1034   GST_INFO (GST_CAT_PADS, "dumping caps of pad %s:%s", GST_DEBUG_PAD_NAME (realsink));
1035   gst_caps_debug (sinkcaps);
1036
1037   /* first take the intersection of the pad caps */
1038   intersection = gst_caps_intersect (srccaps, sinkcaps);
1039
1040   /* if we have no intersection but one of the caps was not NULL.. */
1041   if (!intersection && (srccaps || sinkcaps )) {
1042     /* the intersection is NULL but the pad caps were not both NULL,
1043      * this means they have no common format */
1044     GST_INFO (GST_CAT_PADS, "pads %s:%s and %s:%s have no common type",
1045          GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
1046     return FALSE;
1047   }
1048   else {
1049     GST_INFO (GST_CAT_PADS, "pads %s:%s and %s:%s intersected to %s caps",
1050          GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink),
1051          ((intersection && GST_CAPS_IS_FIXED (intersection)) ? "fixed" : "variable"));
1052
1053     /* then filter this against the app filter */
1054     if (filtercaps) {
1055       GstCaps *filtered_intersection = gst_caps_intersect (intersection, filtercaps);
1056
1057       /* get rid of the old intersection here */
1058       gst_caps_unref (intersection);
1059
1060       if (!filtered_intersection) {
1061         GST_INFO (GST_CAT_PADS, "filtered connection between pads %s:%s and %s:%s is empty",
1062              GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
1063         return FALSE;
1064       }
1065       intersection = filtered_intersection;
1066
1067       /* keep a reference to the app caps */
1068       GST_RPAD_APPFILTER (realsink) = filtercaps;
1069       GST_RPAD_APPFILTER (realsrc) = filtercaps;
1070     }
1071   }
1072   GST_DEBUG (GST_CAT_CAPS, "setting filter for connection to:\n");
1073   gst_caps_debug (intersection);
1074
1075   GST_RPAD_FILTER (realsrc) = intersection;
1076   GST_RPAD_FILTER (realsink) = intersection;
1077
1078   return gst_pad_perform_negotiate (GST_PAD (realsrc), GST_PAD (realsink));
1079 }
1080
1081 /**
1082  * gst_pad_perform_negotiate:
1083  * @srcpad: a srcpad
1084  * @sinkpad: a sinkpad
1085  *
1086  * Try to negotiate the pads.
1087  *
1088  * Returns: a boolean indicating the pad succesfully negotiated.
1089  */
1090 gboolean
1091 gst_pad_perform_negotiate (GstPad *srcpad, GstPad *sinkpad)
1092 {
1093   GstCaps *intersection;
1094   GstRealPad *realsrc, *realsink;
1095
1096   g_return_val_if_fail (srcpad != NULL, FALSE);
1097   g_return_val_if_fail (sinkpad != NULL, FALSE);
1098
1099   realsrc = GST_PAD_REALIZE (srcpad);
1100   realsink = GST_PAD_REALIZE (sinkpad);
1101
1102   g_return_val_if_fail (GST_RPAD_PEER (realsrc) != NULL, FALSE);
1103   g_return_val_if_fail (GST_RPAD_PEER (realsink) == realsrc, FALSE);
1104
1105   /* it doesn't matter which filter we take */
1106   intersection = GST_RPAD_FILTER (realsrc);
1107
1108   /* no negotiation is performed it the pads have filtercaps */
1109   if (intersection) {
1110     GstPadConnectReturn res;
1111
1112     res = gst_pad_try_set_caps_func (realsrc, intersection, TRUE);
1113     if (res == GST_PAD_CONNECT_REFUSED)
1114       return FALSE;
1115     if (res == GST_PAD_CONNECT_DONE)
1116       return TRUE;
1117
1118     res = gst_pad_try_set_caps_func (realsink, intersection, TRUE);
1119     if (res == GST_PAD_CONNECT_REFUSED)
1120       return FALSE;
1121     if (res == GST_PAD_CONNECT_DONE)
1122       return TRUE;
1123   }
1124   return TRUE;
1125 }
1126
1127 /**
1128  * gst_pad_try_reconnect_filtered:
1129  * @pad: the pad to reconnect
1130  * @caps: the capabilities to use in the reconnectiong
1131  *
1132  * Try to reconnect this pad and its peer with the specified caps
1133  *
1134  * Returns: a boolean indicating the peer pad could accept the caps.
1135  */
1136 gboolean
1137 gst_pad_try_reconnect_filtered (GstPad *srcpad, GstPad *sinkpad, GstCaps *filtercaps)
1138 {
1139   GstRealPad *realsrc, *realsink;
1140
1141   g_return_val_if_fail (srcpad != NULL, FALSE);
1142   g_return_val_if_fail (sinkpad != NULL, FALSE);
1143
1144   realsrc = GST_PAD_REALIZE (srcpad);
1145   realsink = GST_PAD_REALIZE (sinkpad);
1146
1147   g_return_val_if_fail (GST_RPAD_PEER (realsrc) != NULL, FALSE);
1148   g_return_val_if_fail (GST_RPAD_PEER (realsink) == realsrc, FALSE);
1149
1150   return gst_pad_try_reconnect_filtered_func (realsrc, realsink, filtercaps, TRUE);
1151 }
1152
1153 /**
1154  * gst_pad_reconnect_filtered:
1155  * @pad: the pad to reconnect
1156  * @caps: the capabilities to use in the reconnectiong
1157  *
1158  * Try to reconnect this pad and its peer with the specified caps.
1159  *
1160  * Returns: a boolean indicating the peer pad could accept the caps.
1161  *    if FALSE is returned, the pads are disconnected.
1162  */
1163 gboolean
1164 gst_pad_reconnect_filtered (GstPad *srcpad, GstPad *sinkpad, GstCaps *filtercaps)
1165 {
1166   GstRealPad *realsrc, *realsink;
1167
1168   g_return_val_if_fail (srcpad != NULL, FALSE);
1169   g_return_val_if_fail (sinkpad != NULL, FALSE);
1170
1171   realsrc = GST_PAD_REALIZE (srcpad);
1172   realsink = GST_PAD_REALIZE (sinkpad);
1173
1174   g_return_val_if_fail (GST_RPAD_PEER (realsrc) != NULL, FALSE);
1175   g_return_val_if_fail (GST_RPAD_PEER (realsink) == realsrc, FALSE);
1176
1177   if (!gst_pad_try_reconnect_filtered_func (realsrc, realsink, filtercaps, TRUE)) {
1178     gst_pad_disconnect (srcpad, GST_PAD (GST_PAD_PEER (srcpad)));
1179     return FALSE;
1180   }
1181   return TRUE;
1182 }
1183
1184 /**
1185  * gst_pad_proxy_connect:
1186  * @pad: the pad to proxy to
1187  * @caps: the capabilities to use in the proxying
1188  *
1189  * Proxy the connect function to the specified pad.
1190  *
1191  * Returns: a boolean indicating the peer pad could accept the caps.
1192  */
1193 GstPadConnectReturn
1194 gst_pad_proxy_connect (GstPad *pad, GstCaps *caps)
1195 {
1196   GstRealPad *peer, *realpad;
1197
1198   realpad = GST_PAD_REALIZE (pad);
1199
1200   peer = GST_RPAD_PEER (realpad);
1201
1202   GST_INFO (GST_CAT_CAPS, "proxy connect to pad %s:%s",
1203             GST_DEBUG_PAD_NAME (realpad));
1204
1205   if (peer && !gst_pad_try_set_caps_func (peer, caps, TRUE))
1206     return GST_PAD_CONNECT_REFUSED;
1207   if (!gst_pad_try_set_caps_func (realpad, caps, FALSE))
1208     return GST_PAD_CONNECT_REFUSED;
1209
1210   return GST_PAD_CONNECT_OK;
1211 }
1212
1213 /**
1214  * gst_pad_get_caps:
1215  * @pad: the pad to get the capabilities from
1216  *
1217  * Get the capabilities of this pad.
1218  *
1219  * Returns: the capabilities of this pad
1220  */
1221 GstCaps*
1222 gst_pad_get_caps (GstPad *pad)
1223 {
1224   GstRealPad *realpad;
1225
1226   g_return_val_if_fail (pad != NULL, NULL);
1227   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1228
1229   realpad = GST_PAD_REALIZE (pad);
1230
1231   GST_DEBUG (GST_CAT_CAPS, "get pad caps of %s:%s (%p)\n",
1232             GST_DEBUG_PAD_NAME (realpad), realpad);
1233
1234   if (GST_PAD_CAPS (realpad)) {
1235     GST_DEBUG (GST_CAT_CAPS, "using pad real caps\n");
1236     return GST_PAD_CAPS (realpad);
1237   }
1238   else if GST_RPAD_GETCAPSFUNC (realpad) {
1239     GST_DEBUG (GST_CAT_CAPS, "using pad get function\n");
1240     return GST_RPAD_GETCAPSFUNC (realpad) (GST_PAD_CAST (realpad), NULL);
1241   }
1242   else if (GST_PAD_PADTEMPLATE (realpad)) {
1243     GST_DEBUG (GST_CAT_CAPS, "using pad template\n");
1244     return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (realpad));
1245   }
1246   GST_DEBUG (GST_CAT_CAPS, "pad has no caps\n");
1247
1248   return NULL;
1249 }
1250
1251 /**
1252  * gst_pad_get_padtemplate_caps:
1253  * @pad: the pad to get the capabilities from
1254  *
1255  * Get the capabilities of this pad.
1256  *
1257  * Returns: a list of the capabilities of this pad
1258  */
1259 GstCaps*
1260 gst_pad_get_padtemplate_caps (GstPad *pad)
1261 {
1262   g_return_val_if_fail (pad != NULL, NULL);
1263   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1264
1265   if (GST_PAD_PADTEMPLATE (pad))
1266     return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (pad));
1267
1268   return NULL;
1269 }
1270
1271
1272 /**
1273  * gst_padtemplate_get_caps_by_name:
1274  * @templ: the padtemplate to get the capabilities from
1275  * @name: the name of the capability to get
1276  *
1277  * Get the capability with the given name from this padtemplate.
1278  *
1279  * Returns: a capability or NULL if not found
1280  */
1281 GstCaps*
1282 gst_padtemplate_get_caps_by_name (GstPadTemplate *templ, const gchar *name)
1283 {
1284   GstCaps *caps;
1285
1286   g_return_val_if_fail (templ != NULL, NULL);
1287
1288   caps = GST_PADTEMPLATE_CAPS (templ);
1289   if (!caps)
1290     return NULL;
1291
1292   return gst_caps_get_by_name (caps, name);
1293 }
1294
1295 /**
1296  * gst_pad_check_compatibility:
1297  * @srcpad: the srcpad to check
1298  * @sinkpad: the sinkpad to check against
1299  *
1300  * Check if two pads have compatible capabilities.
1301  *
1302  * Returns: TRUE if they are compatible or the capabilities
1303  * could not be checked
1304  */
1305 gboolean
1306 gst_pad_check_compatibility (GstPad *srcpad, GstPad *sinkpad)
1307 {
1308   g_return_val_if_fail (srcpad != NULL, FALSE);
1309   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1310   g_return_val_if_fail (sinkpad != NULL, FALSE);
1311   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1312
1313   if (GST_PAD_CAPS (srcpad) && GST_PAD_CAPS (sinkpad)) {
1314     if (!gst_caps_check_compatibility (GST_PAD_CAPS (srcpad), GST_PAD_CAPS (sinkpad))) {
1315       return FALSE;
1316     }
1317     else {
1318       return TRUE;
1319     }
1320   }
1321   else {
1322     GST_DEBUG (GST_CAT_PADS, "could not check capabilities of pads (%s:%s) and (%s:%s) %p %p\n",
1323                     GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
1324                     GST_PAD_CAPS (srcpad), GST_PAD_CAPS (sinkpad));
1325     return TRUE;
1326   }
1327 }
1328
1329 /**
1330  * gst_pad_get_peer:
1331  * @pad: the pad to get the peer from
1332  *
1333  * Get the peer pad of this pad.
1334  *
1335  * Returns: the peer pad
1336  */
1337 GstPad*
1338 gst_pad_get_peer (GstPad *pad)
1339 {
1340   g_return_val_if_fail (pad != NULL, NULL);
1341   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1342
1343   return GST_PAD (GST_PAD_PEER (pad));
1344 }
1345
1346 /**
1347  * gst_pad_get_allowed_caps:
1348  * @pad: the pad to get the allowed caps from
1349  *
1350  * Gst the caps of the allowed media types that can
1351  * go through this pad.
1352  *
1353  * Returns: the allowed caps
1354  */
1355 GstCaps*
1356 gst_pad_get_allowed_caps (GstPad *pad)
1357 {
1358   g_return_val_if_fail (pad != NULL, NULL);
1359   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1360
1361   GST_DEBUG (GST_CAT_PROPERTIES, "get allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
1362
1363   return gst_caps_copy (GST_RPAD_FILTER (pad));
1364 }
1365
1366 /**
1367  * gst_pad_get_allowed_caps:
1368  * @pad: the pad to get the allowed caps from
1369  *
1370  * Gst the caps of the allowed media types that can
1371  * go through this pad.
1372  *
1373  * Returns: the allowed caps
1374  */
1375 gboolean
1376 gst_pad_recalc_allowed_caps (GstPad *pad)
1377 {
1378   GstRealPad *peer;
1379
1380   g_return_if_fail (pad != NULL);
1381   g_return_if_fail (GST_IS_PAD (pad));
1382
1383   GST_DEBUG (GST_CAT_PROPERTIES, "set allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
1384
1385   peer = GST_RPAD_PEER (pad);
1386   if (peer)
1387     gst_pad_try_reconnect_filtered (pad, GST_PAD (peer), GST_RPAD_APPFILTER (pad));
1388 }
1389
1390 /**
1391  * gst_pad_get_bufferpool:
1392  * @pad: the pad to get the bufferpool from
1393  *
1394  * Get the bufferpool of the peer pad of the given
1395  * pad
1396  *
1397  * Returns: The GstBufferPool or NULL.
1398  */
1399 GstBufferPool*
1400 gst_pad_get_bufferpool (GstPad *pad)
1401 {
1402   GstRealPad *peer;
1403
1404   g_return_val_if_fail (pad != NULL, NULL);
1405   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1406
1407   peer = GST_RPAD_PEER (pad);
1408
1409   if (!peer)
1410     return NULL;
1411
1412   GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
1413
1414   if (peer->bufferpoolfunc) {
1415     GST_DEBUG (GST_CAT_PADS, "calling bufferpoolfunc &%s (@%p) of peer pad %s:%s\n",
1416       GST_DEBUG_FUNCPTR_NAME (peer->bufferpoolfunc), &peer->bufferpoolfunc, GST_DEBUG_PAD_NAME (((GstPad*) peer)));
1417     return (peer->bufferpoolfunc) (((GstPad*) peer));
1418   } else {
1419     GST_DEBUG (GST_CAT_PADS, "no bufferpoolfunc for peer pad %s:%s at %p\n",
1420                     GST_DEBUG_PAD_NAME (((GstPad*) peer)), &peer->bufferpoolfunc);
1421     return NULL;
1422   }
1423 }
1424
1425 static void
1426 gst_real_pad_dispose (GObject *object)
1427 {
1428   GstPad *pad = GST_PAD (object);
1429
1430   GST_DEBUG (GST_CAT_REFCOUNTING, "dispose %s:%s\n", GST_DEBUG_PAD_NAME(pad));
1431
1432   if (GST_PAD (pad)->padtemplate){
1433     GST_DEBUG (GST_CAT_REFCOUNTING, "unreffing padtemplate'%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_PAD (pad)->padtemplate)));
1434     gst_object_unref (GST_OBJECT (GST_PAD (pad)->padtemplate));
1435   }
1436
1437   if (GST_PAD_PEER (pad)){
1438     GST_DEBUG (GST_CAT_REFCOUNTING, "disconnecting pad '%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
1439     gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
1440   }
1441
1442   /* we destroy the ghostpads, because they are nothing without the real pad  */
1443   if (GST_REAL_PAD (pad)->ghostpads) {
1444     GList *orig, *ghostpads;
1445
1446     orig = ghostpads = g_list_copy (GST_REAL_PAD (pad)->ghostpads);
1447
1448     while (ghostpads) {
1449       GstPad *ghostpad = GST_PAD (ghostpads->data);
1450
1451       if (GST_IS_ELEMENT (GST_OBJECT_PARENT (ghostpad))){
1452         GST_DEBUG (GST_CAT_REFCOUNTING, "removing ghost pad from element '%s'\n",
1453                         GST_OBJECT_NAME (GST_OBJECT_PARENT (ghostpad)));
1454
1455         gst_element_remove_ghost_pad (GST_ELEMENT (GST_OBJECT_PARENT (ghostpad)), GST_PAD (ghostpad));
1456       }
1457       ghostpads = g_list_next (ghostpads);
1458     }
1459     g_list_free (orig);
1460     g_list_free (GST_REAL_PAD(pad)->ghostpads);
1461   }
1462
1463   if (GST_IS_ELEMENT (GST_OBJECT_PARENT (pad))){
1464     GST_DEBUG (GST_CAT_REFCOUNTING, "removing pad from element '%s'\n",
1465                     GST_OBJECT_NAME (GST_OBJECT (GST_ELEMENT (GST_OBJECT_PARENT (pad)))));
1466
1467     gst_element_remove_pad (GST_ELEMENT (GST_OBJECT_PARENT (pad)), pad);
1468   }
1469
1470   G_OBJECT_CLASS (real_pad_parent_class)->dispose (object);
1471 }
1472
1473
1474 #ifndef GST_DISABLE_LOADSAVE
1475 /**
1476  * gst_pad_load_and_connect:
1477  * @self: the XML node to read the description from
1478  * @parent: the element that has the pad
1479  *
1480  * Read the pad definition from the XML node and connect the given pad
1481  * in element to a pad of an element up in the hierarchy.
1482  */
1483 void
1484 gst_pad_load_and_connect (xmlNodePtr self,
1485                           GstObject *parent)
1486 {
1487   xmlNodePtr field = self->xmlChildrenNode;
1488   GstPad *pad = NULL, *targetpad;
1489   guchar *peer = NULL;
1490   gchar **split;
1491   GstElement *target;
1492   GstObject *grandparent;
1493
1494   while (field) {
1495     if (!strcmp (field->name, "name")) {
1496       pad = gst_element_get_pad (GST_ELEMENT (parent), xmlNodeGetContent (field));
1497     }
1498     else if (!strcmp(field->name, "peer")) {
1499       peer = xmlNodeGetContent (field);
1500     }
1501     field = field->next;
1502   }
1503   g_return_if_fail (pad != NULL);
1504
1505   if (peer == NULL) return;
1506
1507   split = g_strsplit (peer, ".", 2);
1508
1509   g_return_if_fail (split[0] != NULL);
1510   g_return_if_fail (split[1] != NULL);
1511
1512   grandparent = gst_object_get_parent (parent);
1513
1514   if (grandparent && GST_IS_BIN (grandparent)) {
1515     target = gst_bin_get_by_name_recurse_up (GST_BIN (grandparent), split[0]);
1516   }
1517   else
1518     goto cleanup;
1519
1520   if (target == NULL) goto cleanup;
1521
1522   targetpad = gst_element_get_pad (target, split[1]);
1523
1524   if (targetpad == NULL) goto cleanup;
1525
1526   gst_pad_connect (pad, targetpad);
1527
1528 cleanup:
1529   g_strfreev (split);
1530 }
1531
1532 /**
1533  * gst_pad_save_thyself:
1534  * @pad: the pad to save
1535  * @parent: the parent XML node to save the description in
1536  *
1537  * Saves the pad into an xml representation
1538  *
1539  * Returns: the xml representation of the pad
1540  */
1541 static xmlNodePtr
1542 gst_pad_save_thyself (GstObject *object,
1543                       xmlNodePtr parent)
1544 {
1545   GstRealPad *realpad;
1546   GstPad *peer;
1547
1548   g_return_val_if_fail (GST_IS_REAL_PAD (object), NULL);
1549
1550   realpad = GST_REAL_PAD(object);
1551
1552   xmlNewChild(parent,NULL,"name", GST_PAD_NAME (realpad));
1553   if (GST_RPAD_PEER(realpad) != NULL) {
1554     peer = GST_PAD(GST_RPAD_PEER(realpad));
1555     /* first check to see if the peer's parent's parent is the same */
1556     /* we just save it off */
1557     xmlNewChild(parent,NULL,"peer",g_strdup_printf("%s.%s",
1558                     GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer)));
1559   } else
1560     xmlNewChild(parent,NULL,"peer","");
1561
1562   return parent;
1563 }
1564
1565 /**
1566  * gst_pad_ghost_save_thyself:
1567  * @pad: the pad to save
1568  * @bin: the bin
1569  * @parent: the parent XML node to save the description in
1570  *
1571  * Saves the ghost pad into an xml representation.
1572  *
1573  * Returns: the xml representation of the pad
1574  */
1575 xmlNodePtr
1576 gst_pad_ghost_save_thyself (GstPad *pad,
1577                             GstElement *bin,
1578                             xmlNodePtr parent)
1579 {
1580   xmlNodePtr self;
1581
1582   g_return_val_if_fail (GST_IS_GHOST_PAD (pad), NULL);
1583
1584   self = xmlNewChild (parent, NULL, "ghostpad", NULL);
1585   xmlNewChild (self, NULL, "name", GST_PAD_NAME (pad));
1586   xmlNewChild (self, NULL, "parent", GST_OBJECT_NAME (GST_PAD_PARENT (pad)));
1587
1588   /* FIXME FIXME FIXME! */
1589
1590   return self;
1591 }
1592 #endif /* GST_DISABLE_LOADSAVE */
1593
1594 #ifndef gst_pad_push
1595 /**
1596  * gst_pad_push:
1597  * @pad: the pad to push
1598  * @buf: the buffer to push
1599  *
1600  * Push a buffer to the peer of the pad.
1601  */
1602 void
1603 gst_pad_push (GstPad *pad, GstBuffer *buf)
1604 {
1605   GstRealPad *peer = GST_RPAD_PEER (pad);
1606
1607   GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
1608
1609   g_return_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SRC);
1610
1611   if (!peer) {
1612     g_warning ("push on pad %s:%s but it is unconnected", GST_DEBUG_PAD_NAME (pad));
1613   }
1614   else {
1615     if (peer->chainhandler) {
1616       if (buf) {
1617         GST_DEBUG (GST_CAT_DATAFLOW, "calling chainhandler &%s of peer pad %s:%s\n",
1618             GST_DEBUG_FUNCPTR_NAME (peer->chainhandler), GST_DEBUG_PAD_NAME (GST_PAD (peer)));
1619         (peer->chainhandler) (GST_PAD_CAST (peer), buf);
1620         return;
1621       }
1622       else {
1623         g_warning ("trying to push a NULL buffer on pad %s:%s", GST_DEBUG_PAD_NAME (peer));
1624         return;
1625       }
1626     }
1627     else {
1628       g_warning ("(internal error) push on pad %s:%s but it has no chainhandler", GST_DEBUG_PAD_NAME (peer));
1629     }
1630   }
1631   /* clean up the mess here */
1632   if (buf != NULL) {
1633     if (GST_IS_BUFFER (buf))
1634       gst_buffer_unref (buf);
1635     else
1636       gst_event_free (GST_EVENT (buf));
1637   }
1638 }
1639 #endif
1640
1641 #ifndef gst_pad_pull
1642 /**
1643  * gst_pad_pull:
1644  * @pad: the pad to pull
1645  *
1646  * Pull a buffer from the peer pad.
1647  *
1648  * Returns: a new buffer from the peer pad.
1649  */
1650 GstBuffer*
1651 gst_pad_pull (GstPad *pad)
1652 {
1653   GstRealPad *peer = GST_RPAD_PEER(pad);
1654
1655   GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
1656
1657   g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
1658
1659   if (!peer) {
1660     gst_element_error (GST_PAD_PARENT (pad),
1661                     "pull on pad %s:%s but it was unconnected",
1662                     GST_ELEMENT_NAME (GST_PAD_PARENT (pad)), GST_PAD_NAME (pad),
1663                     NULL);
1664   }
1665   else {
1666     if (peer->gethandler) {
1667       GstBuffer *buf;
1668
1669       GST_DEBUG (GST_CAT_DATAFLOW, "calling gethandler %s of peer pad %s:%s\n",
1670         GST_DEBUG_FUNCPTR_NAME (peer->gethandler), GST_DEBUG_PAD_NAME (peer));
1671
1672       buf = (peer->gethandler) (GST_PAD_CAST (peer));
1673       if (buf)
1674         return buf;
1675       /* no null buffers allowed */
1676       gst_element_error (GST_PAD_PARENT (pad),
1677                     "NULL buffer during pull on %s:%s", GST_DEBUG_PAD_NAME (pad), NULL);
1678
1679     } else {
1680       gst_element_error (GST_PAD_PARENT (pad),
1681                     "(internal error) pull on pad %s:%s but the peer pad %s:%s has no gethandler",
1682                     GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (peer),
1683                     NULL);
1684     }
1685   }
1686   return NULL;
1687 }
1688 #endif
1689
1690 #ifndef gst_pad_pullregion
1691 /**
1692  * gst_pad_pullregion:
1693  * @pad: the pad to pull the region from
1694  * @type: the regiontype
1695  * @offset: the offset/start of the buffer to pull
1696  * @len: the length of the buffer to pull
1697  *
1698  * Pull a buffer region from the peer pad. The region to pull can be
1699  * specified with a offset/lenght pair or with a start/legnth time
1700  * indicator as specified by the type parameter.
1701  *
1702  * Returns: a new buffer from the peer pad with data in the specified
1703  * region.
1704  */
1705 GstBuffer*
1706 gst_pad_pullregion (GstPad *pad, GstRegionType type, guint64 offset, guint64 len)
1707 {
1708   GstRealPad *peer;
1709   GstBuffer *result = NULL;
1710
1711   g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
1712
1713   do {
1714     peer = GST_RPAD_PEER(pad);
1715     g_return_val_if_fail (peer != NULL, NULL);
1716
1717     if (result)
1718       gst_buffer_unref (result);
1719
1720     GST_DEBUG_ENTER("(%s:%s,%d,%lld,%lld)",GST_DEBUG_PAD_NAME(pad),type,offset,len);
1721
1722     if (peer->pullregionfunc) {
1723       GST_DEBUG (GST_CAT_DATAFLOW, "calling pullregionfunc &%s of peer pad %s:%s\n",
1724           GST_DEBUG_FUNCPTR_NAME (peer->pullregionfunc), GST_DEBUG_PAD_NAME(GST_PAD_CAST (peer)));
1725       result = (peer->pullregionfunc) (GST_PAD_CAST (peer), type, offset, len);
1726     } else {
1727       GST_DEBUG (GST_CAT_DATAFLOW,"no pullregionfunc\n");
1728       result = NULL;
1729       break;
1730     }
1731   }
1732   /* FIXME */
1733   while (result && !(GST_BUFFER_OFFSET (result) == offset &&
1734            GST_BUFFER_SIZE (result) == len));
1735
1736   return result;
1737 }
1738 #endif
1739
1740 /**
1741  * gst_pad_peek:
1742  * @pad: the pad to peek
1743  *
1744  * Peek for a buffer from the peer pad.
1745  *
1746  * Returns: a from the peer pad or NULL if the peer has no buffer.
1747  */
1748 GstBuffer*
1749 gst_pad_peek (GstPad *pad)
1750 {
1751   g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
1752
1753   return GST_RPAD_BUFPEN (GST_RPAD_PEER (pad));
1754 }
1755
1756 /**
1757  * gst_pad_select:
1758  * @padlist: A list of pads
1759  *
1760  * Wait for a buffer on the list of pads.
1761  *
1762  * Returns: The pad that has a buffer available, use
1763  * #gst_pad_pull to get the buffer.
1764  */
1765 GstPad*
1766 gst_pad_select (GList *padlist)
1767 {
1768   GstPad *pad;
1769
1770   pad = gst_scheduler_pad_select (GST_PAD_PARENT (padlist->data)->sched, padlist);
1771
1772   return pad;
1773 }
1774
1775 /**
1776  * gst_pad_selectv:
1777  * @pad: The first pad to perform the select on
1778  * @...: More pads
1779  *
1780  * Wait for a buffer on the given of pads.
1781  *
1782  * Returns: The pad that has a buffer available, use
1783  * #gst_pad_pull to get the buffer.
1784  */
1785 GstPad*
1786 gst_pad_selectv (GstPad *pad, ...)
1787 {
1788   GstPad *result;
1789   GList *padlist = NULL;
1790   va_list var_args;
1791
1792   if (pad == NULL)
1793     return NULL;
1794
1795   va_start (var_args, pad);
1796
1797   while (pad) {
1798     padlist = g_list_prepend (padlist, pad);
1799     pad = va_arg (var_args, GstPad *);
1800   }
1801   result = gst_pad_select (padlist);
1802   g_list_free (padlist);
1803
1804   va_end (var_args);
1805
1806   return result;
1807 }
1808
1809 /************************************************************************
1810  *
1811  * templates
1812  *
1813  */
1814 static void             gst_padtemplate_class_init      (GstPadTemplateClass *klass);
1815 static void             gst_padtemplate_init            (GstPadTemplate *templ);
1816
1817 enum {
1818   TEMPL_PAD_CREATED,
1819   /* FILL ME */
1820   TEMPL_LAST_SIGNAL
1821 };
1822
1823 static GstObject *padtemplate_parent_class = NULL;
1824 static guint gst_padtemplate_signals[TEMPL_LAST_SIGNAL] = { 0 };
1825
1826 GType
1827 gst_padtemplate_get_type (void)
1828 {
1829   static GType padtemplate_type = 0;
1830
1831   if (!padtemplate_type) {
1832     static const GTypeInfo padtemplate_info = {
1833       sizeof(GstPadTemplateClass),
1834       NULL,
1835       NULL,
1836       (GClassInitFunc)gst_padtemplate_class_init,
1837       NULL,
1838       NULL,
1839       sizeof(GstPadTemplate),
1840       32,
1841       (GInstanceInitFunc)gst_padtemplate_init,
1842       NULL
1843     };
1844     padtemplate_type = g_type_register_static(GST_TYPE_OBJECT, "GstPadTemplate", &padtemplate_info, 0);
1845   }
1846   return padtemplate_type;
1847 }
1848
1849 static void
1850 gst_padtemplate_class_init (GstPadTemplateClass *klass)
1851 {
1852   GObjectClass *gobject_class;
1853   GstObjectClass *gstobject_class;
1854
1855   gobject_class = (GObjectClass*)klass;
1856   gstobject_class = (GstObjectClass*)klass;
1857
1858   padtemplate_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
1859
1860   gst_padtemplate_signals[TEMPL_PAD_CREATED] =
1861     g_signal_new ("pad_created", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
1862                     G_STRUCT_OFFSET (GstPadTemplateClass, pad_created), NULL, NULL,
1863                     gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
1864                     G_TYPE_POINTER);
1865
1866
1867   gstobject_class->path_string_separator = "*";
1868 }
1869
1870 static void
1871 gst_padtemplate_init (GstPadTemplate *templ)
1872 {
1873 }
1874
1875 /**
1876  * gst_padtemplate_new:
1877  * @name_template: the name template
1878  * @direction: the direction for the template
1879  * @presence: the presence of the pad
1880  * @caps: a list of capabilities for the template
1881  * @...: more capabilities
1882  *
1883  * Creates a new padtemplate from the given arguments.
1884  *
1885  * Returns: the new padtemplate
1886  */
1887 GstPadTemplate*
1888 gst_padtemplate_new (gchar *name_template,
1889                      GstPadDirection direction, GstPadPresence presence,
1890                      GstCaps *caps, ...)
1891 {
1892   GstPadTemplate *new;
1893   va_list var_args;
1894   GstCaps *thecaps = NULL;
1895
1896   g_return_val_if_fail (name_template != NULL, NULL);
1897
1898   new = g_object_new(gst_padtemplate_get_type () ,NULL);
1899
1900   GST_PADTEMPLATE_NAME_TEMPLATE (new) = name_template;
1901   GST_PADTEMPLATE_DIRECTION (new) = direction;
1902   GST_PADTEMPLATE_PRESENCE (new) = presence;
1903
1904   va_start (var_args, caps);
1905
1906   while (caps) {
1907     new->fixed &= caps->fixed;
1908     thecaps = gst_caps_append (thecaps, caps);
1909     caps = va_arg (var_args, GstCaps*);
1910   }
1911   va_end (var_args);
1912
1913   GST_PADTEMPLATE_CAPS (new) = thecaps;
1914
1915   return new;
1916 }
1917
1918 /**
1919  * gst_padtemplate_get_caps:
1920  * @templ: the padtemplate to use
1921  *
1922  * Get the capabilities of the padtemplate
1923  *
1924  * Returns: a GstCaps*
1925  */
1926 GstCaps*
1927 gst_padtemplate_get_caps (GstPadTemplate *templ)
1928 {
1929   g_return_val_if_fail (templ != NULL, NULL);
1930
1931   return GST_PADTEMPLATE_CAPS (templ);
1932 }
1933
1934 #ifndef GST_DISABLE_LOADSAVE
1935 /**
1936  * gst_padtemplate_save_thyself:
1937  * @templ: the padtemplate to save
1938  * @parent: the parent XML tree
1939  *
1940  * Saves the padtemplate into XML.
1941  *
1942  * Returns: the new XML tree
1943  */
1944 xmlNodePtr
1945 gst_padtemplate_save_thyself (GstPadTemplate *templ, xmlNodePtr parent)
1946 {
1947   xmlNodePtr subtree;
1948   guchar *presence;
1949
1950   GST_DEBUG (GST_CAT_XML,"saving padtemplate %s\n", templ->name_template);
1951
1952   xmlNewChild(parent,NULL,"nametemplate", templ->name_template);
1953   xmlNewChild(parent,NULL,"direction", (templ->direction == GST_PAD_SINK? "sink":"src"));
1954
1955   switch (templ->presence) {
1956     case GST_PAD_ALWAYS:
1957       presence = "always";
1958       break;
1959     case GST_PAD_SOMETIMES:
1960       presence = "sometimes";
1961       break;
1962     case GST_PAD_REQUEST:
1963       presence = "request";
1964       break;
1965     default:
1966       presence = "unknown";
1967       break;
1968   }
1969   xmlNewChild(parent,NULL,"presence", presence);
1970
1971   if (GST_PADTEMPLATE_CAPS (templ)) {
1972     subtree = xmlNewChild (parent, NULL, "caps", NULL);
1973     gst_caps_save_thyself (GST_PADTEMPLATE_CAPS (templ), subtree);
1974   }
1975
1976   return parent;
1977 }
1978
1979 /**
1980  * gst_padtemplate_load_thyself:
1981  * @parent: the source XML tree
1982  *
1983  * Loads a padtemplate from the XML tree.
1984  *
1985  * Returns: the new padtemplate
1986  */
1987 GstPadTemplate*
1988 gst_padtemplate_load_thyself (xmlNodePtr parent)
1989 {
1990   xmlNodePtr field = parent->xmlChildrenNode;
1991   GstPadTemplate *factory;
1992   gchar *name_template = NULL;
1993   GstPadDirection direction = GST_PAD_UNKNOWN;
1994   GstPadPresence presence = GST_PAD_ALWAYS;
1995   GstCaps *caps = NULL;
1996
1997   while (field) {
1998     if (!strcmp(field->name, "nametemplate")) {
1999       name_template = xmlNodeGetContent(field);
2000     }
2001     if (!strcmp(field->name, "direction")) {
2002       gchar *value = xmlNodeGetContent(field);
2003
2004       if (!strcmp(value, "sink")) {
2005         direction = GST_PAD_SINK;
2006       }
2007       else if (!strcmp(value, "src")) {
2008         direction = GST_PAD_SRC;
2009       }
2010       g_free (value);
2011     }
2012     if (!strcmp(field->name, "presence")) {
2013       gchar *value = xmlNodeGetContent(field);
2014
2015       if (!strcmp(value, "always")) {
2016         presence = GST_PAD_ALWAYS;
2017       }
2018       else if (!strcmp(value, "sometimes")) {
2019         presence = GST_PAD_SOMETIMES;
2020       }
2021       else if (!strcmp(value, "request")) {
2022         presence = GST_PAD_REQUEST;
2023       }
2024       g_free (value);
2025     }
2026     else if (!strcmp(field->name, "caps")) {
2027       caps = gst_caps_load_thyself (field);
2028     }
2029     field = field->next;
2030   }
2031
2032   factory = gst_padtemplate_new (name_template, direction, presence, caps, NULL);
2033
2034   return factory;
2035 }
2036 #endif /* !GST_DISABLE_LOADSAVE */
2037
2038
2039 /**
2040  * gst_pad_set_element_private:
2041  * @pad: the pad to set the private data to
2042  * @priv: The private data to attach to the pad
2043  *
2044  * Set the given private data pointer to the pad. This
2045  * function can only be used by the element that own the
2046  * pad.
2047  */
2048 void
2049 gst_pad_set_element_private (GstPad *pad, gpointer priv)
2050 {
2051   pad->element_private = priv;
2052 }
2053
2054 /**
2055  * gst_pad_get_element_private:
2056  * @pad: the pad to get the private data of
2057  *
2058  * Get the private data of a pad. The private data can
2059  * only be set by the parent element of this pad.
2060  *
2061  * Returns: a pointer to the private data.
2062  */
2063 gpointer
2064 gst_pad_get_element_private (GstPad *pad)
2065 {
2066   return pad->element_private;
2067 }
2068
2069
2070 /***** ghost pads *****/
2071 GType _gst_ghost_pad_type = 0;
2072
2073 static void     gst_ghost_pad_class_init         (GstGhostPadClass *klass);
2074 static void     gst_ghost_pad_init               (GstGhostPad *pad);
2075
2076 static GstPad *ghost_pad_parent_class = NULL;
2077 /* static guint gst_ghost_pad_signals[LAST_SIGNAL] = { 0 }; */
2078
2079 GType
2080 gst_ghost_pad_get_type(void) {
2081   if (!_gst_ghost_pad_type) {
2082     static const GTypeInfo pad_info = {
2083       sizeof(GstGhostPadClass),
2084       NULL,
2085       NULL,
2086       (GClassInitFunc)gst_ghost_pad_class_init,
2087       NULL,
2088       NULL,
2089       sizeof(GstGhostPad),
2090       8,
2091       (GInstanceInitFunc)gst_ghost_pad_init,
2092       NULL
2093     };
2094     _gst_ghost_pad_type = g_type_register_static(GST_TYPE_PAD, "GstGhostPad", &pad_info, 0);
2095   }
2096   return _gst_ghost_pad_type;
2097 }
2098
2099 static void
2100 gst_ghost_pad_class_init (GstGhostPadClass *klass)
2101 {
2102   GObjectClass *gobject_class;
2103
2104   gobject_class = (GObjectClass*)klass;
2105
2106   ghost_pad_parent_class = g_type_class_ref(GST_TYPE_PAD);
2107 }
2108
2109 static void
2110 gst_ghost_pad_init (GstGhostPad *pad)
2111 {
2112   pad->realpad = NULL;
2113 }
2114
2115 /**
2116  * gst_ghost_pad_new:
2117  * @name: name of the new ghost pad
2118  * @pad: the pad to create a ghost pad of
2119  *
2120  * Create a new ghost pad associated with the given pad.
2121  *
2122  * Returns: new ghost pad
2123  */
2124 GstPad*
2125 gst_ghost_pad_new (gchar *name,
2126                    GstPad *pad)
2127 {
2128   GstGhostPad *ghostpad;
2129
2130   g_return_val_if_fail (name != NULL, NULL);
2131   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2132
2133   ghostpad = g_object_new (gst_ghost_pad_get_type () ,NULL);
2134   gst_pad_set_name (GST_PAD (ghostpad), name);
2135   GST_GPAD_REALPAD (ghostpad) = GST_PAD_REALIZE (pad);
2136   GST_PAD_PADTEMPLATE (ghostpad) = GST_PAD_PADTEMPLATE (pad);
2137
2138   /* add ourselves to the real pad's list of ghostpads */
2139   gst_pad_add_ghost_pad (pad, GST_PAD (ghostpad));
2140
2141   /* FIXME need to ref the real pad here... ? */
2142
2143   GST_DEBUG (GST_CAT_PADS, "created ghost pad \"%s\"\n", name);
2144
2145   return GST_PAD (ghostpad);
2146 }
2147
2148 static void
2149 gst_pad_event_default_dispatch (GstPad *pad, GstElement *element, GstEvent *event)
2150 {
2151   GList *pads = element->pads;
2152
2153   while (pads) {
2154     GstPad *eventpad = GST_PAD (pads->data);
2155     pads = g_list_next (pads);
2156
2157     /* for all pads in the opposite direction that are connected */
2158     if (GST_PAD_DIRECTION (eventpad) != GST_PAD_DIRECTION (pad) && GST_PAD_IS_CONNECTED (eventpad)) {
2159       if (GST_PAD_DIRECTION (eventpad) == GST_PAD_SRC) {
2160         gst_pad_push (eventpad, GST_BUFFER (gst_event_new (GST_EVENT_TYPE (event))));
2161       }
2162       else {
2163         GstPad *peerpad = GST_PAD_CAST (GST_RPAD_PEER (eventpad));
2164
2165         gst_pad_send_event (peerpad, gst_event_new (GST_EVENT_TYPE (event)));
2166       }
2167     }
2168   }
2169 }
2170
2171 /**
2172  * gst_pad_event_default:
2173  * @pad: the pad to operate on
2174  * @event: the event to handle
2175  *
2176  * Invoke the default event handler for the given pad.
2177  */
2178 void
2179 gst_pad_event_default (GstPad *pad, GstEvent *event)
2180 {
2181   GstElement *element = GST_PAD_PARENT (pad);
2182
2183   g_signal_emit (G_OBJECT (pad), gst_real_pad_signals[REAL_EVENT_RECEIVED], 0, event);
2184
2185   switch (GST_EVENT_TYPE (event)) {
2186     case GST_EVENT_EOS:
2187       gst_element_set_eos (element);
2188       gst_pad_event_default_dispatch (pad, element, event);
2189       gst_event_free (event);
2190       /* we have to try to schedule another element because this one is disabled */
2191       gst_element_yield (element);
2192       break;
2193     case GST_EVENT_FLUSH:
2194     default:
2195       gst_pad_event_default_dispatch (pad, element, event);
2196       gst_event_free (event);
2197       break;
2198   }
2199 }
2200
2201 /**
2202  * gst_pad_send_event:
2203  * @pad: the pad to send the event to
2204  * @event: the event to send to the pad.
2205  *
2206  * Send the event to the pad.
2207  *
2208  * Returns: TRUE if the event was handled.
2209  */
2210 gboolean
2211 gst_pad_send_event (GstPad *pad, GstEvent *event)
2212 {
2213   gboolean handled = FALSE;
2214
2215   g_return_val_if_fail (event, FALSE);
2216
2217   if (GST_EVENT_SRC (event) == NULL)
2218     GST_EVENT_SRC (event) = gst_object_ref (GST_OBJECT (pad));
2219
2220   GST_DEBUG (GST_CAT_EVENT, "have event %d on pad %s:%s\n",
2221                   GST_EVENT_TYPE (event), GST_DEBUG_PAD_NAME (pad));
2222
2223   if (GST_RPAD_EVENTFUNC (pad))
2224     handled = GST_RPAD_EVENTFUNC (pad) (pad, event);
2225   else {
2226     GST_DEBUG(GST_CAT_EVENT, "there's no event function for pad %s:%s\n", GST_DEBUG_PAD_NAME (pad));
2227   }
2228
2229   if (!handled) {
2230     GST_DEBUG(GST_CAT_EVENT, "proceeding with default event behavior here\n");
2231     gst_pad_event_default (pad, event);
2232     handled = TRUE;
2233   }
2234
2235   return handled;
2236 }
2237