/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2005 Andy Wingo <wingo@pobox.com>

 *		      2006 Edward Hervey <bilboed@bilboed.com>

 *

 * gstghostpad.c: Proxy pads

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstghostpad

 * @short_description: Pseudo link pads

 * @see_also: #GstPad

 *

 * GhostPads are useful when organizing pipelines with #GstBin like elements.

 * The idea here is to create hierarchical element graphs. The bin element

 * contains a sub-graph. Now one would like to treat the bin-element like other

 * #GstElements. This is where GhostPads come into play. A GhostPad acts as a

 * proxy for another pad. Thus the bin can have sink and source ghost-pads that

 * are associated with sink and source pads of the child elements.

 *

 * If the target pad is known at creation time, gst_ghost_pad_new() is the

 * function to use to get a ghost-pad. Otherwise one can use gst_ghost_pad_new_no_target()

 * to create the ghost-pad and use gst_ghost_pad_set_target() to establish the

 * association later on.

 *

 * Note that GhostPads add overhead to the data processing of a pipeline.

 *

 * Last reviewed on 2005-11-18 (0.9.5)

 */

#include "gst_private.h"

#include "gstinfo.h"

#include "gstghostpad.h"

#include "gst.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

#define GST_CAT_DEFAULT GST_CAT_PADS

#define GST_PROXY_PAD_CAST(obj)         ((GstProxyPad *)obj)

#define GST_PROXY_LOCK(pad)     (g_mutex_lock (GST_PROXY_GET_LOCK (pad)))

#define GST_PROXY_UNLOCK(pad)   (g_mutex_unlock (GST_PROXY_GET_LOCK (pad)))

{

  /* with PROXY_LOCK */

  GMutex *proxy_lock;

  GstPad *target;

  GstPad *internal;

};

G_DEFINE_TYPE (GstProxyPad, gst_proxy_pad, GST_TYPE_PAD);

static GstPad *gst_proxy_pad_get_target (GstPad * pad);

static void gst_proxy_pad_dispose (GObject * object);

static void gst_proxy_pad_finalize (GObject * object);

#ifndef GST_DISABLE_LOADSAVE

static xmlNodePtr gst_proxy_pad_save_thyself (GstObject * object,

    xmlNodePtr parent);

#endif

static void

gst_proxy_pad_class_init (GstProxyPadClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_proxy_pad_dispose);

  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_proxy_pad_finalize);

#ifndef GST_DISABLE_LOADSAVE

  {

    GstObjectClass *gstobject_class = (GstObjectClass *) klass;

    gstobject_class->save_thyself =

        GST_DEBUG_FUNCPTR (gst_proxy_pad_save_thyself);

  }

#endif

}

static const GstQueryType *

gst_proxy_pad_do_query_type (GstPad * pad)

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  const GstQueryType *res = NULL;

  if (target) {

    res = gst_pad_get_query_types (target);

    gst_object_unref (target);

  }

  return res;

}

static gboolean

gst_proxy_pad_do_event (GstPad * pad, GstEvent * event)

{

  gboolean res = FALSE;

  GstPad *internal = GST_PROXY_PAD_INTERNAL (pad);

  res = gst_pad_push_event (internal, event);

  return res;

}

static gboolean

gst_proxy_pad_do_query (GstPad * pad, GstQuery * query)

{

  gboolean res = FALSE;

  GstPad *target = gst_proxy_pad_get_target (pad);

  if (target) {

    res = gst_pad_query (target, query);

    gst_object_unref (target);

  }

  return res;

}

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  if (target) {

    gst_object_unref (target);

  }

  return res;

}

static GstFlowReturn

gst_proxy_pad_do_bufferalloc (GstPad * pad, guint64 offset, guint size,

    GstCaps * caps, GstBuffer ** buf)

{

  GstFlowReturn result;

  GstPad *internal = GST_PROXY_PAD_INTERNAL (pad);

  result = gst_pad_alloc_buffer (internal, offset, size, caps, buf);

  return result;

}

static GstFlowReturn

gst_proxy_pad_do_chain (GstPad * pad, GstBuffer * buffer)

{

  GstFlowReturn res;

  GstPad *internal = GST_PROXY_PAD_INTERNAL (pad);

  res = gst_pad_push (internal, buffer);

  return res;

}

static GstFlowReturn

gst_proxy_pad_do_getrange (GstPad * pad, guint64 offset, guint size,

    GstBuffer ** buffer)

{

  GstFlowReturn res;

  GstPad *internal = GST_PROXY_PAD_INTERNAL (pad);

  res = gst_pad_pull_range (internal, offset, size, buffer);

  return res;

}

static gboolean

gst_proxy_pad_do_checkgetrange (GstPad * pad)

{

  gboolean result;

  GstPad *internal = GST_PROXY_PAD_INTERNAL (pad);

  result = gst_pad_check_pull_range (internal);

  return result;

}

static GstCaps *

gst_proxy_pad_do_getcaps (GstPad * pad)

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  GstCaps *res;

  GstPadTemplate *templ = GST_PAD_PAD_TEMPLATE (pad);

  if (target) {

    /* if we have a real target, proxy the call */

    res = gst_pad_get_caps (target);

    gst_object_unref (target);

    /* filter against the template */

    if (templ && res) {

      GstCaps *filt, *tmp;

      filt = GST_PAD_TEMPLATE_CAPS (templ);

      if (filt) {

        tmp = gst_caps_intersect (filt, res);

        gst_caps_unref (res);

        res = tmp;

        GST_DEBUG_OBJECT (pad,

            "filtered against template gives %" GST_PTR_FORMAT, res);

      }

    }

  } else {

    /* else, if we have a template, use its caps. */

    if (templ) {

      res = GST_PAD_TEMPLATE_CAPS (templ);

      GST_DEBUG_OBJECT (pad,

          "using pad template %p with caps %p %" GST_PTR_FORMAT, templ, res,

          res);

      res = gst_caps_ref (res);

      goto done;

    }

    /* last resort, any caps */

    GST_DEBUG_OBJECT (pad, "pad has no template, returning ANY");

    res = gst_caps_new_any ();

  }

done:

  return res;

}

static gboolean

gst_proxy_pad_do_acceptcaps (GstPad * pad, GstCaps * caps)

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  gboolean res;

  if (target) {

    res = gst_pad_accept_caps (target, caps);

    gst_object_unref (target);

  } else {

    /* We don't have a target, we return TRUE and we assume that any future

     * target will be able to deal with any configured caps. */

    res = TRUE;

  }

  return res;

}

static void

gst_proxy_pad_do_fixatecaps (GstPad * pad, GstCaps * caps)

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  if (target) {

    gst_pad_fixate_caps (target, caps);

    gst_object_unref (target);

  }

}

static gboolean

gst_proxy_pad_do_setcaps (GstPad * pad, GstCaps * caps)

{

  GstPad *target = gst_proxy_pad_get_target (pad);

  gboolean res;

  if (target) {

    res = gst_pad_set_caps (target, caps);

    gst_object_unref (target);

  } else {

    /* We don't have any target, but we shouldn't return FALSE since this

     * would stop the actual push of a buffer (which might trigger a pad block

     * or probe, or properly return GST_FLOW_NOT_LINKED.

     */

    res = TRUE;

  }

  return res;

}

static gboolean

gst_proxy_pad_set_target_unlocked (GstPad * pad, GstPad * target)

{

  GstPad *oldtarget;

  if (target) {

    GST_LOG_OBJECT (pad, "setting target %s:%s", GST_DEBUG_PAD_NAME (target));

    if (G_UNLIKELY (GST_PAD_DIRECTION (pad) != GST_PAD_DIRECTION (target)))

      goto wrong_direction;

  } else

    GST_LOG_OBJECT (pad, "clearing target");

  /* clear old target */

    gst_object_unref (oldtarget);

  /* set and ref new target if any */

  if (target)

    GST_PROXY_PAD_TARGET (pad) = gst_object_ref (target);

  else

    GST_PROXY_PAD_TARGET (pad) = NULL;

  return TRUE;

  /* ERRORS */

wrong_direction:

  {

    GST_ERROR_OBJECT (pad,

        "target pad doesn't have the same direction as ourself");

    return FALSE;

  }

}

static gboolean

gst_proxy_pad_set_target (GstPad * pad, GstPad * target)

{

  gboolean result;

  GST_PROXY_LOCK (pad);

  result = gst_proxy_pad_set_target_unlocked (pad, target);

  GST_PROXY_UNLOCK (pad);

  return result;

}

static GstPad *

gst_proxy_pad_get_target (GstPad * pad)

{

  GstPad *target;

  GST_PROXY_LOCK (pad);

  target = GST_PROXY_PAD_TARGET (pad);

  if (target)

    gst_object_ref (target);

  GST_PROXY_UNLOCK (pad);

  return target;

}

static void

gst_proxy_pad_dispose (GObject * object)

{

  GstPad *pad = GST_PAD (object);

  GstPad **target_p;

  GST_PROXY_LOCK (pad);

  /* remove and unref the target */

  target_p = &GST_PROXY_PAD_TARGET (pad);

  gst_object_replace ((GstObject **) target_p, NULL);

  /* The internal is only cleared by GstGhostPad::dispose, since it is the 

   * parent of non-ghost GstProxyPad and owns the refcount on the internal.

   */

  GST_PROXY_UNLOCK (pad);

  G_OBJECT_CLASS (gst_proxy_pad_parent_class)->dispose (object);

}

static void

gst_proxy_pad_finalize (GObject * object)

{

  GstProxyPad *pad = GST_PROXY_PAD (object);

  G_OBJECT_CLASS (gst_proxy_pad_parent_class)->finalize (object);

}

static void

gst_proxy_pad_init (GstProxyPad * ppad)

{

  GstPad *pad = (GstPad *) ppad;

  gst_pad_set_query_type_function (pad,

      GST_DEBUG_FUNCPTR (gst_proxy_pad_do_query_type));

  gst_pad_set_event_function (pad, GST_DEBUG_FUNCPTR (gst_proxy_pad_do_event));

  gst_pad_set_query_function (pad, GST_DEBUG_FUNCPTR (gst_proxy_pad_do_query));

  gst_pad_set_getcaps_function (pad,

      GST_DEBUG_FUNCPTR (gst_proxy_pad_do_getcaps));

  gst_pad_set_acceptcaps_function (pad,

      GST_DEBUG_FUNCPTR (gst_proxy_pad_do_acceptcaps));

  gst_pad_set_fixatecaps_function (pad,

      GST_DEBUG_FUNCPTR (gst_proxy_pad_do_fixatecaps));

  gst_pad_set_setcaps_function (pad,

      GST_DEBUG_FUNCPTR (gst_proxy_pad_do_setcaps));

}

#ifndef GST_DISABLE_LOADSAVE

/**

 * gst_proxy_pad_save_thyself:

 * @pad: a ghost #GstPad to save.

 * @parent: the parent #xmlNodePtr to save the description in.

 *

 * Saves the ghost pad into an xml representation.

 *

 * Returns: the #xmlNodePtr representation of the pad.

 */

static xmlNodePtr

gst_proxy_pad_save_thyself (GstObject * object, xmlNodePtr parent)

{

  xmlNodePtr self;

  GstProxyPad *proxypad;

  GstPad *pad;

  GstPad *peer;

  g_return_val_if_fail (GST_IS_PROXY_PAD (object), NULL);

  self = xmlNewChild (parent, NULL, (xmlChar *) "ghostpad", NULL);

  xmlNewChild (self, NULL, (xmlChar *) "name",

      (xmlChar *) GST_OBJECT_NAME (object));

  xmlNewChild (self, NULL, (xmlChar *) "parent",

      (xmlChar *) GST_OBJECT_NAME (GST_OBJECT_PARENT (object)));

  proxypad = GST_PROXY_PAD_CAST (object);

  pad = GST_PAD_CAST (proxypad);

  peer = GST_PAD_CAST (pad->peer);

  if (GST_IS_PAD (pad)) {

    if (GST_PAD_IS_SRC (pad))

      xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "source");

    else if (GST_PAD_IS_SINK (pad))

      xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "sink");

    else

      xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "unknown");

  } else {

    xmlNewChild (self, NULL, (xmlChar *) "direction", (xmlChar *) "unknown");

  }

  if (GST_IS_PAD (peer)) {

    gchar *content = g_strdup_printf ("%s.%s",

        GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer));

    xmlNewChild (self, NULL, (xmlChar *) "peer", (xmlChar *) content);

    g_free (content);

  } else {

    xmlNewChild (self, NULL, (xmlChar *) "peer", NULL);

  }

  return self;

}

#endif /* GST_DISABLE_LOADSAVE */

/***********************************************************************

 * Ghost pads, implemented as a pair of proxy pads (sort of)

 */

{

  /* with PROXY_LOCK */

  gulong notify_id;

};