/* GStreamer

 * Copyright (C) 2003 Julien Moutte <julien@moutte.net>

 * Copyright (C) 2005 Ronald S. Bultje <rbultje@ronald.bitfreak.net>

 * Copyright (C) 2005 Jan Schmidt <thaytan@mad.scientist.com>

 * Copyright (C) 2007 Wim Taymans <wim.taymans@gmail.com>

 * Copyright (C) 2007 Andy Wingo <wingo@pobox.com>

 * Copyright (C) 2008 Nokia Corporation. (contact <stefan.kost@nokia.com>)

 *

 * 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:element-input-selector

 * @see_also: #GstOutputSelector

 *

 * Direct one out of N input streams to the output pad.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include "gstinputselector.h"

#include "gstplay-marshal.h"

GST_DEBUG_CATEGORY_STATIC (input_selector_debug);

#define GST_CAT_DEFAULT input_selector_debug

static const GstElementDetails gst_input_selector_details =

GST_ELEMENT_DETAILS ("Input selector",

    "Generic",

    "N-to-1 input stream selectoring",

    "Julien Moutte <julien@moutte.net>\n"

    "Ronald S. Bultje <rbultje@ronald.bitfreak.net>\n"

    "Jan Schmidt <thaytan@mad.scientist.com>\n"

    "Wim Taymans <wim.taymans@gmail.com>");

static GstStaticPadTemplate gst_input_selector_sink_factory =

GST_STATIC_PAD_TEMPLATE ("sink%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS_ANY);

static GstStaticPadTemplate gst_input_selector_src_factory =

GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

enum

{

  PROP_0,

  PROP_N_PADS,

  PROP_ACTIVE_PAD,

  PROP_SELECT_ALL,

  PROP_LAST

};

#define DEFAULT_PAD_ALWAYS_OK	TRUE

enum

{

  PROP_PAD_0,

  PROP_PAD_RUNNING_TIME,

  PROP_PAD_TAGS,

  PROP_PAD_ACTIVE,

  PROP_PAD_ALWAYS_OK,

  PROP_PAD_LAST

};

enum

{

  /* methods */

  SIGNAL_BLOCK,

  SIGNAL_SWITCH,

  LAST_SIGNAL

};

static guint gst_input_selector_signals[LAST_SIGNAL] = { 0 };

static gboolean gst_input_selector_is_active_sinkpad (GstInputSelector * sel,

    GstPad * pad);

static GstPad *gst_input_selector_activate_sinkpad (GstInputSelector * sel,

    GstPad * pad);

static GstPad *gst_input_selector_get_linked_pad (GstPad * pad,

    gboolean strict);

static gboolean gst_input_selector_check_eos (GstElement * selector);

#define GST_TYPE_SELECTOR_PAD \

  (gst_selector_pad_get_type())

#define GST_SELECTOR_PAD(obj) \

  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_SELECTOR_PAD, GstSelectorPad))

#define GST_SELECTOR_PAD_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_SELECTOR_PAD, GstSelectorPadClass))

#define GST_IS_SELECTOR_PAD(obj) \

  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_SELECTOR_PAD))

#define GST_IS_SELECTOR_PAD_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_SELECTOR_PAD))

#define GST_SELECTOR_PAD_CAST(obj) \

  ((GstSelectorPad *)(obj))

typedef struct _GstSelectorPad GstSelectorPad;

typedef struct _GstSelectorPadClass GstSelectorPadClass;

struct _GstSelectorPad

{

  GstPad parent;

  gboolean active;              /* when buffer have passed the pad */

  gboolean eos;                 /* when EOS has been received */

  gboolean discont;             /* after switching we create a discont */

  gboolean always_ok;

  GstSegment segment;           /* the current segment on the pad */

  GstTagList *tags;             /* last tags received on the pad */

  gboolean segment_pending;

};

struct _GstSelectorPadClass

{

  GstPadClass parent;

};

static void gst_selector_pad_class_init (GstSelectorPadClass * klass);

static void gst_selector_pad_init (GstSelectorPad * pad);

static void gst_selector_pad_finalize (GObject * object);

static void gst_selector_pad_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static void gst_selector_pad_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static GstPadClass *selector_pad_parent_class = NULL;

static gint64 gst_selector_pad_get_running_time (GstSelectorPad * pad);

static void gst_selector_pad_reset (GstSelectorPad * pad);

static gboolean gst_selector_pad_event (GstPad * pad, GstEvent * event);

static GstCaps *gst_selector_pad_getcaps (GstPad * pad);

static GList *gst_selector_pad_get_linked_pads (GstPad * pad);

static GstFlowReturn gst_selector_pad_chain (GstPad * pad, GstBuffer * buf);

static GstFlowReturn gst_selector_pad_bufferalloc (GstPad * pad,

    guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);

GType

gst_selector_pad_get_type (void)

{

  static GType selector_pad_type = 0;

  if (!selector_pad_type) {

    static const GTypeInfo selector_pad_info = {

      sizeof (GstSelectorPadClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_selector_pad_class_init,

      NULL,

      NULL,

      sizeof (GstSelectorPad),

      0,

      (GInstanceInitFunc) gst_selector_pad_init,

    };

    selector_pad_type =

        g_type_register_static (GST_TYPE_PAD, "GstPlaybin2SelectorPad",

        &selector_pad_info, 0);

  }

  return selector_pad_type;

}

static void

gst_selector_pad_class_init (GstSelectorPadClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  selector_pad_parent_class = g_type_class_peek_parent (klass);

  gobject_class->finalize = gst_selector_pad_finalize;

  gobject_class->get_property =

      GST_DEBUG_FUNCPTR (gst_selector_pad_get_property);

  gobject_class->set_property =

      GST_DEBUG_FUNCPTR (gst_selector_pad_set_property);

  g_object_class_install_property (gobject_class, PROP_PAD_RUNNING_TIME,

      g_param_spec_int64 ("running-time", "Running time",

          "Running time of stream on pad", 0, G_MAXINT64, 0, G_PARAM_READABLE));

  g_object_class_install_property (gobject_class, PROP_PAD_TAGS,

      g_param_spec_boxed ("tags", "Tags",

          "The currently active tags on the pad", GST_TYPE_TAG_LIST,

          G_PARAM_READABLE));

  g_object_class_install_property (gobject_class, PROP_PAD_ACTIVE,

      g_param_spec_boolean ("active", "Active",

          "If the pad is currently active", FALSE, G_PARAM_READABLE));

  g_object_class_install_property (gobject_class, PROP_PAD_ALWAYS_OK,

      g_param_spec_boolean ("always-ok", "Always OK",

          "Make an inactive pad return OK instead of NOT_LINKED",

          DEFAULT_PAD_ALWAYS_OK, G_PARAM_READWRITE));

}

static void

gst_selector_pad_init (GstSelectorPad * pad)

{

  pad->always_ok = DEFAULT_PAD_ALWAYS_OK;

  gst_selector_pad_reset (pad);

}

static void

gst_selector_pad_finalize (GObject * object)

{

  GstSelectorPad *pad;

  pad = GST_SELECTOR_PAD_CAST (object);

  if (pad->tags)

    gst_tag_list_free (pad->tags);

  G_OBJECT_CLASS (selector_pad_parent_class)->finalize (object);

}

static void

gst_selector_pad_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstSelectorPad *spad = GST_SELECTOR_PAD_CAST (object);

  switch (prop_id) {

    case PROP_PAD_ALWAYS_OK:

      GST_OBJECT_LOCK (object);

      spad->always_ok = g_value_get_boolean (value);

      GST_OBJECT_UNLOCK (object);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_selector_pad_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstSelectorPad *spad = GST_SELECTOR_PAD_CAST (object);

  switch (prop_id) {

    case PROP_PAD_RUNNING_TIME:

      g_value_set_int64 (value, gst_selector_pad_get_running_time (spad));

      break;

    case PROP_PAD_TAGS:

      GST_OBJECT_LOCK (object);

      g_value_set_boxed (value, spad->tags);

      GST_OBJECT_UNLOCK (object);

      break;

    case PROP_PAD_ACTIVE:

    {

      GstInputSelector *sel;

      sel = GST_INPUT_SELECTOR (gst_pad_get_parent (spad));

      g_value_set_boolean (value, gst_input_selector_is_active_sinkpad (sel,

              GST_PAD_CAST (spad)));

      gst_object_unref (sel);

      break;

    }

    case PROP_PAD_ALWAYS_OK:

      GST_OBJECT_LOCK (object);

      g_value_set_boolean (value, spad->always_ok);

      GST_OBJECT_UNLOCK (object);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static gint64

gst_selector_pad_get_running_time (GstSelectorPad * pad)

{

  gint64 ret = 0;

  GST_OBJECT_LOCK (pad);

  if (pad->active) {

    gint64 last_stop = pad->segment.last_stop;

    if (last_stop >= 0)

      ret = gst_segment_to_running_time (&pad->segment, GST_FORMAT_TIME,

          last_stop);

  }

  GST_OBJECT_UNLOCK (pad);

  GST_DEBUG_OBJECT (pad, "running time: %" GST_TIME_FORMAT,

      GST_TIME_ARGS (ret));

  return ret;

}

static void

gst_selector_pad_reset (GstSelectorPad * pad)

{

  GST_OBJECT_LOCK (pad);

  pad->active = FALSE;

  pad->eos = FALSE;

  pad->segment_pending = FALSE;

  pad->discont = FALSE;

  gst_segment_init (&pad->segment, GST_FORMAT_UNDEFINED);

  GST_OBJECT_UNLOCK (pad);

}

/* strictly get the linked pad from the sinkpad. If the pad is active we return

 * the srcpad else we return NULL */

static GList *

gst_selector_pad_get_linked_pads (GstPad * pad)

{

  GstPad *otherpad;

  otherpad = gst_input_selector_get_linked_pad (pad, TRUE);

  if (!otherpad)

    return NULL;

  /* need to drop the ref, internal linked pads is not MT safe */

  gst_object_unref (otherpad);

  return g_list_append (NULL, otherpad);

}

static gboolean

gst_selector_pad_event (GstPad * pad, GstEvent * event)

{

  gboolean res = TRUE;

  gboolean forward = TRUE;

  GstInputSelector *sel;

  GstSelectorPad *selpad;

  GstPad *prev_active_sinkpad;

  GstPad *active_sinkpad;

  sel = GST_INPUT_SELECTOR (gst_pad_get_parent (pad));

  selpad = GST_SELECTOR_PAD_CAST (pad);

  GST_INPUT_SELECTOR_LOCK (sel);

  prev_active_sinkpad = sel->active_sinkpad;

  active_sinkpad = gst_input_selector_activate_sinkpad (sel, pad);

  /* only forward if we are dealing with the active sinkpad or if select_all

   * is enabled */

  if (pad != active_sinkpad && !sel->select_all)

    forward = FALSE;

  GST_INPUT_SELECTOR_UNLOCK (sel);

  if (prev_active_sinkpad != active_sinkpad && pad == active_sinkpad)

    g_object_notify (G_OBJECT (sel), "active-pad");

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_FLUSH_START:

      /* FIXME, flush out the waiter */

      break;

    case GST_EVENT_FLUSH_STOP:

      GST_INPUT_SELECTOR_LOCK (sel);

      gst_selector_pad_reset (selpad);

      sel->pending_close = FALSE;

      GST_INPUT_SELECTOR_UNLOCK (sel);

      break;

    case GST_EVENT_NEWSEGMENT:

    {

      gboolean update;

      GstFormat format;

      gdouble rate, arate;

      gint64 start, stop, time;

      gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,

          &start, &stop, &time);

      GST_DEBUG_OBJECT (pad,

          "configured NEWSEGMENT update %d, rate %lf, applied rate %lf, "

          "format %d, "

          "%" G_GINT64_FORMAT " -- %" G_GINT64_FORMAT ", time %"

          G_GINT64_FORMAT, update, rate, arate, format, start, stop, time);

      GST_INPUT_SELECTOR_LOCK (sel);

      GST_OBJECT_LOCK (selpad);

      gst_segment_set_newsegment_full (&selpad->segment, update,

          rate, arate, format, start, stop, time);

      GST_OBJECT_UNLOCK (selpad);

      /* If we aren't forwarding the event (because the pad is not the

       * active_sinkpad, and select_all is not set, then set the flag on the

       * that says a segment needs sending if/when that pad is activated.

       * For all other cases, we send the event immediately, which makes

       * sparse streams and other segment updates work correctly downstream.

       */

      if (!forward)

        selpad->segment_pending = TRUE;

      GST_INPUT_SELECTOR_UNLOCK (sel);

      break;

    }

    case GST_EVENT_TAG:

    {

      GstTagList *tags, *oldtags, *newtags;

      gst_event_parse_tag (event, &tags);

      GST_OBJECT_LOCK (selpad);

      oldtags = selpad->tags;

      newtags = gst_tag_list_merge (oldtags, tags, GST_TAG_MERGE_REPLACE);

      selpad->tags = newtags;

      if (oldtags)

        gst_tag_list_free (oldtags);

      GST_DEBUG_OBJECT (pad, "received tags %" GST_PTR_FORMAT, newtags);

      GST_OBJECT_UNLOCK (selpad);

      g_object_notify (G_OBJECT (selpad), "tags");

      break;

    }

    case GST_EVENT_EOS:

      selpad->eos = TRUE;

      GST_DEBUG_OBJECT (pad, "received EOS");

      /* don't forward eos in select_all mode until all sink pads have eos */

      if (sel->select_all && !gst_input_selector_check_eos (GST_ELEMENT (sel))) {

        forward = FALSE;

      }

      break;

    default:

      break;

  }

  if (forward) {

    GST_DEBUG_OBJECT (pad, "forwarding event");

    res = gst_pad_push_event (sel->srcpad, event);

  } else

    gst_event_unref (event);

  gst_object_unref (sel);

  return res;

}

static GstCaps *

gst_selector_pad_getcaps (GstPad * pad)

{

  GstInputSelector *sel;

  GstCaps *caps;

  sel = GST_INPUT_SELECTOR (gst_pad_get_parent (pad));

  GST_DEBUG_OBJECT (sel, "Getting caps of srcpad peer");

  caps = gst_pad_peer_get_caps (sel->srcpad);

  if (caps == NULL)

    caps = gst_caps_new_any ();

  gst_object_unref (sel);

  return caps;

}

static GstFlowReturn

gst_selector_pad_bufferalloc (GstPad * pad, guint64 offset,

    guint size, GstCaps * caps, GstBuffer ** buf)

{

  GstInputSelector *sel;

  GstFlowReturn result;

  GstPad *active_sinkpad;

  GstPad *prev_active_sinkpad;

  GstSelectorPad *selpad;

  sel = GST_INPUT_SELECTOR (gst_pad_get_parent (pad));

  selpad = GST_SELECTOR_PAD_CAST (pad);

  GST_DEBUG_OBJECT (pad, "received alloc");

  GST_INPUT_SELECTOR_LOCK (sel);

  prev_active_sinkpad = sel->active_sinkpad;

  active_sinkpad = gst_input_selector_activate_sinkpad (sel, pad);

  if (pad != active_sinkpad)

    goto not_active;

  GST_INPUT_SELECTOR_UNLOCK (sel);

  if (prev_active_sinkpad != active_sinkpad && pad == active_sinkpad)

    g_object_notify (G_OBJECT (sel), "active-pad");

  result = gst_pad_alloc_buffer (sel->srcpad, offset, size, caps, buf);

done:

  gst_object_unref (sel);

  return result;

  /* ERRORS */

not_active:

  {

    GST_INPUT_SELECTOR_UNLOCK (sel);

    /* unselected pad, perform fallback alloc or return unlinked when

     * asked */

    GST_OBJECT_LOCK (selpad);

    if (selpad->always_ok) {

      GST_DEBUG_OBJECT (pad, "Not selected, performing fallback allocation");

      *buf = NULL;

      result = GST_FLOW_OK;

    } else {

      GST_DEBUG_OBJECT (pad, "Not selected, return NOT_LINKED");

      result = GST_FLOW_NOT_LINKED;

    }

    GST_OBJECT_UNLOCK (selpad);

    goto done;

  }

}

/* must be called with the SELECTOR_LOCK, will block while the pad is blocked 

 * or return TRUE when flushing */

static gboolean

gst_input_selector_wait (GstInputSelector * self, GstPad * pad)

{

  while (self->blocked && !self->flushing) {

    /* we can be unlocked here when we are shutting down (flushing) or when we