/* GStreamer

 * Copyright (C) <2006> Edward Hervey <edward@fluendo.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-decodebin2

 * @short_description: Next-generation automatic decoding bin

 *

 * #GstBin that auto-magically constructs a decoding pipeline using available

 * decoders and demuxers via auto-plugging.

 *

 * At this stage, decodebin2 is considered UNSTABLE. The API provided in the

 * signals is expected to change in the near future. 

 *

 * To try out decodebin2, you can set the USE_DECODEBIN2 environment 

 * variable (USE_DECODEBIN2=1 for example). This will cause playbin to use

 * decodebin2 instead of the older decodebin for its internal auto-plugging.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/gst.h>

#include "gstplay-marshal.h"

/* generic templates */

static GstStaticPadTemplate decoder_bin_sink_template =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

static GstStaticPadTemplate decoder_bin_src_template =

GST_STATIC_PAD_TEMPLATE ("src%d",

    GST_PAD_SRC,

    GST_PAD_SOMETIMES,

    GST_STATIC_CAPS_ANY);

GST_DEBUG_CATEGORY_STATIC (gst_decode_bin_debug);

#define GST_CAT_DEFAULT gst_decode_bin_debug

typedef struct _GstDecodeGroup GstDecodeGroup;

typedef struct _GstDecodePad GstDecodePad;

typedef struct _GstDecodeBin GstDecodeBin;

typedef struct _GstDecodeBin GstDecodeBin2;

typedef struct _GstDecodeBinClass GstDecodeBinClass;

#define GST_TYPE_DECODE_BIN             (gst_decode_bin_get_type())

#define GST_DECODE_BIN_CAST(obj)        ((GstDecodeBin*)(obj))

#define GST_DECODE_BIN(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DECODE_BIN,GstDecodeBin))

#define GST_DECODE_BIN_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DECODE_BIN,GstDecodeBinClass))

#define GST_IS_DECODE_BIN(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DECODE_BIN))

#define GST_IS_DECODE_BIN_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DECODE_BIN))

/**

 *  GstDecodeBin2:

 *

 *  The opaque #DecodeBin2 data structure

 */

struct _GstDecodeBin

{

  GstBin bin;                   /* we extend GstBin */

  GstElement *typefind;         /* this holds the typefind object */

  GstElement *fakesink;

  GMutex *lock;                 /* Protects activegroup and groups */

  GstDecodeGroup *activegroup;  /* group currently active */

  GList *groups;                /* List of non-active GstDecodeGroups, sorted in

                                 * order of creation. */

  GList *oldgroups;             /* List of no-longer-used GstDecodeGroups. 

                                 * Should be freed in dispose */

  gint nbpads;                  /* unique identifier for source pads */

  GstCaps *caps;                /* caps on which to stop decoding */

  GList *factories;             /* factories we can use for selecting elements */

};

struct _GstDecodeBinClass

{

  GstBinClass parent_class;

  /* signal we fire when a new pad has been decoded into raw audio/video */

  void (*new_decoded_pad) (GstElement * element, GstPad * pad, gboolean last);

  /* signal we fire when a pad has been removed */

  void (*removed_decoded_pad) (GstElement * element, GstPad * pad);

  /* signal fired when we found a pad that we cannot decode */

  void (*unknown_type) (GstElement * element, GstPad * pad, GstCaps * caps);

  /* signal fired to know if we continue trying to decode the given caps */

    gboolean (*autoplug_continue) (GstElement * element, GstCaps * caps);

  /* signal fired to reorder the proposed list of factories */

    gboolean (*autoplug_sort) (GstElement * element, GstCaps * caps,

      GList ** list);

};

/* signals */

enum

{

  SIGNAL_NEW_DECODED_PAD,

  SIGNAL_REMOVED_DECODED_PAD,

  SIGNAL_UNKNOWN_TYPE,

  SIGNAL_AUTOPLUG_CONTINUE,

  SIGNAL_AUTOPLUG_SORT,

  LAST_SIGNAL

};

/* Properties */

enum

{

  PROP_0,

  PROP_CAPS,

};

static GstBinClass *parent_class;

static guint gst_decode_bin_signals[LAST_SIGNAL] = { 0 };

static const GstElementDetails gst_decode_bin_details =

GST_ELEMENT_DETAILS ("Decoder Bin",

    "Generic/Bin/Decoder",

    "Autoplug and decode to raw media",

    "Edward Hervey <edward@fluendo.com>");

static gboolean add_fakesink (GstDecodeBin * decode_bin);

static void remove_fakesink (GstDecodeBin * decode_bin);

static void type_found (GstElement * typefind, guint probability,

    GstCaps * caps, GstDecodeBin * decode_bin);

static gboolean gst_decode_bin_autoplug_continue (GstElement * element,

    GstCaps * caps);

static gboolean gst_decode_bin_autoplug_sort (GstElement * element,

    GstCaps * caps, GList ** list);

static void gst_decode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_decode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static void gst_decode_bin_set_caps (GstDecodeBin * dbin, GstCaps * caps);

static GstCaps *gst_decode_bin_get_caps (GstDecodeBin * dbin);

static GstPad *find_sink_pad (GstElement * element);

static GstStateChangeReturn gst_decode_bin_change_state (GstElement * element,

    GstStateChange transition);

#define DECODE_BIN_LOCK(dbin) G_STMT_START {				\

    GST_LOG_OBJECT (dbin,						\

		    "locking from thread %p",				\

		    g_thread_self ());					\

    g_mutex_lock (GST_DECODE_BIN_CAST(dbin)->lock);			\

    GST_LOG_OBJECT (dbin,						\

		    "locked from thread %p",				\

		    g_thread_self ());					\

} G_STMT_END

#define DECODE_BIN_UNLOCK(dbin) G_STMT_START {				\

    GST_LOG_OBJECT (dbin,						\

		    "unlocking from thread %p",				\

		    g_thread_self ());					\

    g_mutex_unlock (GST_DECODE_BIN_CAST(dbin)->lock);			\

} G_STMT_END

/* GstDecodeGroup

 *

 * Streams belonging to the same group/chain of a media file

 *

 */

struct _GstDecodeGroup

{

  GstDecodeBin *dbin;

  GMutex *lock;

  GstElement *multiqueue;

  gboolean exposed;             /* TRUE if this group is exposed */

  gboolean drained;             /* TRUE if EOS went throug all endpads */

  gboolean blocked;             /* TRUE if all endpads are blocked */

  gboolean complete;            /* TRUE if we are not expecting anymore streams 

                                 * on this group */

  gulong overrunsig;

  gulong underrunsig;

  guint nbdynamic;              /* number of dynamic pads in the group. */

  GList *endpads;               /* List of GstDecodePad of source pads to be exposed */

  GList *ghosts;                /* List of GstGhostPad for the endpads */

};

#define GROUP_MUTEX_LOCK(group) G_STMT_START {				\

    GST_LOG_OBJECT (group->dbin,					\

		    "locking group %p from thread %p",			\

		    group, g_thread_self ());				\

    g_mutex_lock (group->lock);						\

    GST_LOG_OBJECT (group->dbin,					\

		    "locked group %p from thread %p",			\

		    group, g_thread_self ());				\

} G_STMT_END

#define GROUP_MUTEX_UNLOCK(group) G_STMT_START {                        \

    GST_LOG_OBJECT (group->dbin,					\

		    "unlocking group %p from thread %p",		\

		    group, g_thread_self ());				\

    g_mutex_unlock (group->lock);					\

} G_STMT_END

static GstDecodeGroup *gst_decode_group_new (GstDecodeBin * decode_bin);

static GstPad *gst_decode_group_control_demuxer_pad (GstDecodeGroup * group,

    GstPad * pad);

static gboolean gst_decode_group_control_source_pad (GstDecodeGroup * group,

    GstPad * pad);

static gboolean gst_decode_group_expose (GstDecodeGroup * group);

static void gst_decode_group_check_if_blocked (GstDecodeGroup * group);

static void gst_decode_group_set_complete (GstDecodeGroup * group);

static void gst_decode_group_hide (GstDecodeGroup * group);

static void gst_decode_group_free (GstDecodeGroup * group);

/* GstDecodePad

 *

 * GstPad private used for source pads of groups

 */

struct _GstDecodePad

{

  GstPad *pad;

  GstDecodeGroup *group;

  gboolean blocked;

  gboolean drained;

};

static GstDecodePad *gst_decode_pad_new (GstDecodeGroup * group, GstPad * pad,

    gboolean block);

static void source_pad_blocked_cb (GstPad * pad, gboolean blocked,

    GstDecodePad * dpad);

/* TempPadStruct

 * Internal structure used for pads which have more than one structure.

 */

typedef struct _TempPadStruct

{

  GstDecodeBin *dbin;

  GstDecodeGroup *group;

} TempPadStruct;

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

 * Standard GObject boilerplate *

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

static void gst_decode_bin_class_init (GstDecodeBinClass * klass);

static void gst_decode_bin_init (GstDecodeBin * decode_bin);

static void gst_decode_bin_dispose (GObject * object);

static void gst_decode_bin_finalize (GObject * object);

static GType

gst_decode_bin_get_type (void)

{

  static GType gst_decode_bin_type = 0;

  if (!gst_decode_bin_type) {

    static const GTypeInfo gst_decode_bin_info = {

      sizeof (GstDecodeBinClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_decode_bin_class_init,

      NULL,

      NULL,

      sizeof (GstDecodeBin),

      0,

      (GInstanceInitFunc) gst_decode_bin_init,

      NULL

    };

    gst_decode_bin_type =

        g_type_register_static (GST_TYPE_BIN, "GstDecodeBin2",

        &gst_decode_bin_info, 0);

  }

  return gst_decode_bin_type;

}

static gboolean

_gst_boolean_accumulator (GSignalInvocationHint * ihint,

    GValue * return_accu, const GValue * handler_return, gpointer dummy)

{

  gboolean myboolean;

  myboolean = g_value_get_boolean (handler_return);

  if (!(ihint->run_type & G_SIGNAL_RUN_CLEANUP))

    g_value_set_boolean (return_accu, myboolean);

  /* stop emission if FALSE */

  return myboolean;

}

static void

gst_decode_bin_class_init (GstDecodeBinClass * klass)

{

  GObjectClass *gobject_klass;

  GstElementClass *gstelement_klass;

  GstBinClass *gstbin_klass;

  gobject_klass = (GObjectClass *) klass;

  gstelement_klass = (GstElementClass *) klass;

  gstbin_klass = (GstBinClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_decode_bin_dispose);

  gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_decode_bin_finalize);

  gobject_klass->set_property = GST_DEBUG_FUNCPTR (gst_decode_bin_set_property);

  gobject_klass->get_property = GST_DEBUG_FUNCPTR (gst_decode_bin_get_property);

  /**

   * GstDecodeBin2::new-decoded-pad:

   * @pad: the newly created pad

   * @islast: #TRUE if this is the last pad to be added. Deprecated.

   *

   * This signal gets emitted as soon as a new pad of the same type as one of

   * the valid 'raw' types is added.

   */

  gst_decode_bin_signals[SIGNAL_NEW_DECODED_PAD] =

      g_signal_new ("new-decoded-pad", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstDecodeBinClass, new_decoded_pad), NULL, NULL,

      gst_play_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, GST_TYPE_PAD,

      G_TYPE_BOOLEAN);

  /**

   * GstDecodeBin2::removed-decoded-pad:

   * @pad: the pad that was removed

   *

   * This signal is emitted when a 'final' caps pad has been removed.

   */

  gst_decode_bin_signals[SIGNAL_REMOVED_DECODED_PAD] =

      g_signal_new ("removed-decoded-pad", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstDecodeBinClass, removed_decoded_pad), NULL, NULL,

      gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);

  /**

   * GstDecodeBin2::unknown-type:

   * @pad: the new pad containing caps that cannot be resolved to a 'final' stream type.

   * @caps: the #GstCaps of the pad that cannot be resolved.

   *

   * This signal is emitted when a pad for which there is no further possible

   * decoding is added to the decodebin.

   */

  gst_decode_bin_signals[SIGNAL_UNKNOWN_TYPE] =

      g_signal_new ("unknown-type", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, unknown_type),

      NULL, NULL, gst_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstDecodeBin2::autoplug-continue:

   * @caps: The #GstCaps found.

   *

   * This signal is emitted whenever decodebin2 finds a new stream. It is

   * emitted before looking for any elements that can handle that stream.

   *

   * Returns: #TRUE if you wish decodebin2 to look for elements that can

   * handle the given @caps. If #FALSE, those caps will be considered as

   * final and the pad will be exposed as such (see 'new-decoded-pad'

   * signal).

   */

  gst_decode_bin_signals[SIGNAL_AUTOPLUG_CONTINUE] =

      g_signal_new ("autoplug-continue", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, autoplug_continue),

      _gst_boolean_accumulator, NULL, gst_play_marshal_BOOLEAN__OBJECT,

      G_TYPE_BOOLEAN, 1, GST_TYPE_CAPS);

  /**

   * GstDecodeBin2::autoplug-sort:

   * @caps: The #GstCaps.

   * @factories: A #GList of possible #GstElementFactory to use.

   *

   * This signal is emitted once decodebin2 has found all the possible

   * #GstElementFactory that can be used to handle the given @caps.

   *

   * UNSTABLE API. Will change soon.

   *

   * Returns: #TRUE if you wish decodebin2 to start trying to decode

   * the given @caps with the list of factories. #FALSE if you do not want

   * these #GstCaps, if so the pad will be exposed as unknown (see

   * 'unknown-type' signal).

   */

  gst_decode_bin_signals[SIGNAL_AUTOPLUG_SORT] =

      g_signal_new ("autoplug-sort", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass, autoplug_sort),

      _gst_boolean_accumulator, NULL, gst_play_marshal_BOOLEAN__OBJECT_POINTER,

      G_TYPE_BOOLEAN, 2, GST_TYPE_CAPS, G_TYPE_POINTER);

  g_object_class_install_property (gobject_klass, PROP_CAPS,

      g_param_spec_boxed ("caps", "Caps", "The caps on which to stop decoding.",

          GST_TYPE_CAPS, G_PARAM_READWRITE));

  klass->autoplug_continue =

      GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_continue);

  klass->autoplug_sort = GST_DEBUG_FUNCPTR (gst_decode_bin_autoplug_sort);

  gst_element_class_add_pad_template (gstelement_klass,

      gst_static_pad_template_get (&decoder_bin_sink_template));

  gst_element_class_add_pad_template (gstelement_klass,

      gst_static_pad_template_get (&decoder_bin_src_template));

  gst_element_class_set_details (gstelement_klass, &gst_decode_bin_details);

  gstelement_klass->change_state =

      GST_DEBUG_FUNCPTR (gst_decode_bin_change_state);

}

/* the filter function for selecting the elements we can use in

 * autoplugging */

static gboolean

gst_decode_bin_factory_filter (GstPluginFeature * feature,

    GstDecodeBin * decode_bin)

{

  guint rank;

  const gchar *klass;

  /* we only care about element factories */

  if (!GST_IS_ELEMENT_FACTORY (feature))

    return FALSE;

  klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));

  /* only demuxers, decoders and parsers can play */

  if (strstr (klass, "Demux") == NULL &&

      strstr (klass, "Decoder") == NULL && strstr (klass, "Parse") == NULL) {

    return FALSE;

  }

  /* only select elements with autoplugging rank */

#if 0

  rank = gst_plugin_feature_get_rank (feature);

  if (rank < GST_RANK_MARGINAL)

    return FALSE;

#endif

  return TRUE;

}

/* function used to sort element features */

static gint

compare_ranks (GstPluginFeature * f1, GstPluginFeature * f2)

{

  gint diff;

  const gchar *rname1, *rname2;

  diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);

  if (diff != 0)

    return diff;

  rname1 = gst_plugin_feature_get_name (f1);

  rname2 = gst_plugin_feature_get_name (f2);

  diff = strcmp (rname2, rname1);

  return diff;

}

static void

print_feature (GstPluginFeature * feature)

{

  const gchar *rname;

  rname = gst_plugin_feature_get_name (feature);

  GST_DEBUG ("%s", rname);

}

static void

gst_decode_bin_init (GstDecodeBin * decode_bin)

{

  GList *factories;

  /* first filter out the interesting element factories */

  factories = gst_default_registry_feature_filter (

      (GstPluginFeatureFilter) gst_decode_bin_factory_filter,

      FALSE, decode_bin);

  /* sort them according to their ranks */

  decode_bin->factories = g_list_sort (factories, (GCompareFunc) compare_ranks);

  /* do some debugging */

  g_list_foreach (decode_bin->factories, (GFunc) print_feature, NULL);

  /* we create the typefind element only once */

  decode_bin->typefind = gst_element_factory_make ("typefind", "typefind");

  if (!decode_bin->typefind) {

    g_warning ("can't find typefind element, decodebin will not work");

  } else {

    GstPad *pad;

    GstPad *gpad;

    /* add the typefind element */

    if (!gst_bin_add (GST_BIN (decode_bin), decode_bin->typefind)) {

      g_warning ("Could not add typefind element, decodebin will not work");

      gst_object_unref (decode_bin->typefind);

      decode_bin->typefind = NULL;

    }

    /* get the sinkpad */

    pad = gst_element_get_pad (decode_bin->typefind, "sink");

    /* ghost the sink pad to ourself */

    gpad = gst_ghost_pad_new ("sink", pad);

    gst_pad_set_active (gpad, TRUE);

    gst_element_add_pad (GST_ELEMENT (decode_bin), gpad);

    gst_object_unref (pad);

    /* connect a signal to find out when the typefind element found

     * a type */

    g_signal_connect (G_OBJECT (decode_bin->typefind), "have_type",

        G_CALLBACK (type_found), decode_bin);

  }

  decode_bin->lock = g_mutex_new ();

  decode_bin->activegroup = NULL;

  decode_bin->groups = NULL;

  decode_bin->caps =

      gst_caps_from_string ("video/x-raw-yuv;video/x-raw-rgb;video/x-raw-gray;"

      "audio/x-raw-int;audio/x-raw-float;" "text/plain;text/x-pango-markup");

  add_fakesink (decode_bin);

  /* FILLME */

}

static void

gst_decode_bin_dispose (GObject * object)

{

  GstDecodeBin *decode_bin;

  GList *tmp;

  decode_bin = GST_DECODE_BIN (object);

  if (decode_bin->factories)

    gst_plugin_feature_list_free (decode_bin->factories);

  decode_bin->factories = NULL;

  if (decode_bin->activegroup) {

    gst_decode_group_free (decode_bin->activegroup);

    decode_bin->activegroup = NULL;

  }

  /* remove groups */

  for (tmp = decode_bin->groups; tmp; tmp = g_list_next (tmp)) {

    GstDecodeGroup *group = (GstDecodeGroup *) tmp->data;

    gst_decode_group_free (group);

  }

  g_list_free (decode_bin->groups);

  decode_bin->groups = NULL;

  for (tmp = decode_bin->oldgroups; tmp; tmp = g_list_next (tmp)) {

    GstDecodeGroup *group = (GstDecodeGroup *) tmp->data;

    gst_decode_group_free (group);

  }

  g_list_free (decode_bin->oldgroups);

  decode_bin->oldgroups = NULL;

  if (decode_bin->caps)

    gst_caps_unref (decode_bin->caps);

  decode_bin->caps = NULL;

  remove_fakesink (decode_bin);

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_decode_bin_finalize (GObject * object)

{

  GstDecodeBin *decode_bin;

  decode_bin = GST_DECODE_BIN (object);

  if (decode_bin->lock) {

    g_mutex_free (decode_bin->lock);

    decode_bin->lock = NULL;

  }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_decode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstDecodeBin *dbin;

  dbin = GST_DECODE_BIN (object);

  switch (prop_id) {

    case PROP_CAPS:

      gst_decode_bin_set_caps (dbin, (GstCaps *) g_value_dup_boxed (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_decode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstDecodeBin *dbin;

  dbin = GST_DECODE_BIN (object);

  switch (prop_id) {

    case PROP_CAPS:{

      g_value_take_boxed (value, gst_decode_bin_get_caps (dbin));

      break;

    }

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

/* _set_caps

 * Changes the caps on which decodebin will stop decoding.

 * Will unref the previously set one. The refcount of the given caps will be

 * taken.

 * @caps can be NULL.

 *

 * MT-safe

 */

static void

gst_decode_bin_set_caps (GstDecodeBin * dbin, GstCaps * caps)

{

  GST_DEBUG_OBJECT (dbin, "Setting new caps: %" GST_PTR_FORMAT, caps);

  DECODE_BIN_LOCK (dbin);

  if (dbin->caps)

    gst_caps_unref (dbin->caps);

  dbin->caps = caps;

  DECODE_BIN_UNLOCK (dbin);

}

/* _get_caps

 * Returns the currently configured caps on which decodebin will stop decoding.

 * The returned caps (if not NULL), will have its refcount incremented.

 *

 * MT-safe

 */

static GstCaps *

gst_decode_bin_get_caps (GstDecodeBin * dbin)

{

  GstCaps *caps;

  GST_DEBUG_OBJECT (dbin, "Getting currently set caps");

  DECODE_BIN_LOCK (dbin);

  caps = dbin->caps;

  if (caps)

    gst_caps_ref (caps);

  DECODE_BIN_UNLOCK (dbin);

  return caps;

}

/*****

 * Default autoplug signal handlers

 *****/

static gboolean

gst_decode_bin_autoplug_continue (GstElement * element, GstCaps * caps)

{

  return TRUE;

}

static gboolean

gst_decode_bin_autoplug_sort (GstElement * element, GstCaps * caps,

    GList ** list)

{

  return TRUE;

}

/********

 * Discovery methods

 *****/

static gboolean are_raw_caps (GstDecodeBin * dbin, GstCaps * caps);

static gboolean is_demuxer_element (GstElement * srcelement);

static GList *find_compatibles (GstDecodeBin * decode_bin,

    const GstCaps * caps);

static gboolean connect_pad (GstDecodeBin * dbin, GstElement * src,

    GstPad * pad, GList * factories, GstDecodeGroup * group);

static gboolean connect_element (GstDecodeBin * dbin, GstElement * element,

    GstDecodeGroup * group);

static void expose_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

    GstDecodeGroup * group);

static void pad_added_group_cb (GstElement * element, GstPad * pad,

    GstDecodeGroup * group);

static void pad_removed_group_cb (GstElement * element, GstPad * pad,

    GstDecodeGroup * group);

static void no_more_pads_group_cb (GstElement * element,

    GstDecodeGroup * group);

static void pad_added_cb (GstElement * element, GstPad * pad,

    GstDecodeBin * dbin);

static void pad_removed_cb (GstElement * element, GstPad * pad,

    GstDecodeBin * dbin);

static void no_more_pads_cb (GstElement * element, GstDecodeBin * dbin);

static GstDecodeGroup *get_current_group (GstDecodeBin * dbin);

static void

analyze_new_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

    GstCaps * caps, GstDecodeGroup * group)

{

  gboolean apcontinue = TRUE;

  GList *factories = NULL;

  gboolean apsort = TRUE;

  GST_DEBUG_OBJECT (dbin, "Pad %s:%s caps:%" GST_PTR_FORMAT,

      GST_DEBUG_PAD_NAME (pad), caps);

  if ((caps == NULL) || gst_caps_is_empty (caps))

    goto unknown_type;

  if (gst_caps_is_any (caps))

    goto any_caps;

  /* 1. Emit 'autoplug-continue' */

  g_signal_emit (G_OBJECT (dbin),

      gst_decode_bin_signals[SIGNAL_AUTOPLUG_CONTINUE], 0, caps, &apcontinue);

  /* 1.a if autoplug-continue is FALSE or caps is a raw format, goto pad_is_final */

  if ((!apcontinue) || are_raw_caps (dbin, caps))

    goto expose_pad;

  /* 1.b else if there's no compatible factory or 'autoplug-sort' returned FALSE, goto pad_not_used */

  if ((factories = find_compatibles (dbin, caps))) {

    /* emit autoplug-sort */

    g_signal_emit (G_OBJECT (dbin),

        gst_decode_bin_signals[SIGNAL_AUTOPLUG_SORT],

        0, caps, &factories, &apsort);

    if (!apsort) {

      g_list_free (factories);

      /* User doesn't want that pad */

      goto pad_not_wanted;

    }

  } else {

    /* no compatible factories */

    goto unknown_type;

  }

  /* 1.c else goto pad_is_valid */

  GST_LOG_OBJECT (pad, "Let's continue discovery on this pad");

  connect_pad (dbin, src, pad, factories, group);

  g_list_free (factories);

  return;

expose_pad:

  {

    GST_LOG_OBJECT (dbin, "Pad is final. autoplug-continue:%d", apcontinue);

    expose_pad (dbin, src, pad, group);

    return;

  }

pad_not_wanted:

  {

    GST_LOG_OBJECT (pad, "User doesn't want this pad, stopping discovery");

    return;

  }

unknown_type:

  {

    GST_LOG_OBJECT (pad, "Unknown type, firing signal");

    g_signal_emit (G_OBJECT (dbin),

        gst_decode_bin_signals[SIGNAL_UNKNOWN_TYPE], 0, pad, caps);

    /* Check if there are no pending groups, if so, remove fakesink */

    if (dbin->groups == NULL)

      remove_fakesink (dbin);

    return;

  }

any_caps:

  {

    GST_WARNING_OBJECT (pad,

        "pad has ANY caps, not able to autoplug to anything");

    /* FIXME : connect to caps notification */

    return;

  }

}

/* connect_pad:

 *

 * Try to connect the given pad to an element created from one of the factories,

 * and recursively.

 *

 * Returns TRUE if an element was properly created and linked

 */

static gboolean

connect_pad (GstDecodeBin * dbin, GstElement * src, GstPad * pad,

    GList * factories, GstDecodeGroup * group)

{

  gboolean res = FALSE;

  GList *tmp;

  g_return_val_if_fail (factories != NULL, FALSE);

  GST_DEBUG_OBJECT (dbin, "pad %s:%s , group:%p",

      GST_DEBUG_PAD_NAME (pad), group);

  /* 1. is element demuxer or parser */

  if (is_demuxer_element (src)) {

    GstPad *mqpad;

    GST_LOG_OBJECT (src, "is a demuxer, connecting the pad through multiqueue");

    if (!group)

      if (!(group = get_current_group (dbin))) {

        group = gst_decode_group_new (dbin);

        DECODE_BIN_LOCK (dbin);

        dbin->groups = g_list_append (dbin->groups, group);

        DECODE_BIN_UNLOCK (dbin);

      }

    if (!(mqpad = gst_decode_group_control_demuxer_pad (group, pad)))

      goto beach;

    pad = mqpad;

  }

  /* 2. Try to create an element and link to it */

  for (tmp = factories; tmp; tmp = g_list_next (tmp)) {

    GstElementFactory *factory = (GstElementFactory *) tmp->data;

    GstElement *element;

    GstPad *sinkpad;

    /* 2.1. Try to create an element */

    if ((element = gst_element_factory_create (factory, NULL)) == NULL) {

      GST_WARNING_OBJECT (dbin, "Could not create an element from %s",

          gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));

      continue;

    }

    /* 2.3. Find its sink pad */

    if (!(sinkpad = find_sink_pad (element))) {

      GST_WARNING_OBJECT (dbin, "Element %s doesn't have a sink pad",

          GST_ELEMENT_NAME (element));

      gst_object_unref (element);

      continue;

    }

    /* 2.4 add it ... */

    if (!(gst_bin_add (GST_BIN (dbin), element))) {

      GST_WARNING_OBJECT (dbin, "Couldn't add %s to the bin",

          GST_ELEMENT_NAME (element));

      gst_object_unref (sinkpad);

      gst_object_unref (element);

      continue;

    }

    /* ... activate it ... */

    if ((gst_element_set_state (element,

                GST_STATE_READY)) == GST_STATE_CHANGE_FAILURE) {

      GST_WARNING_OBJECT (dbin, "Couldn't set %s to READY",

          GST_ELEMENT_NAME (element));

      gst_object_unref (sinkpad);

      gst_bin_remove (GST_BIN (dbin), element);

      continue;

    }

    /* 2.5 ...and try to link */

    if ((gst_pad_link (pad, sinkpad)) != GST_PAD_LINK_OK) {

      GST_WARNING_OBJECT (dbin, "Link failed on pad %s:%s",

          GST_DEBUG_PAD_NAME (sinkpad));

      gst_element_set_state (element, GST_STATE_NULL);

      gst_object_unref (sinkpad);

      gst_bin_remove (GST_BIN (dbin), element);

      continue;

    }

    GST_LOG_OBJECT (dbin, "linked on pad %s:%s", GST_DEBUG_PAD_NAME (pad));

    /* link this element further */

    connect_element (dbin, element, group);

    /* Bring the element to the state of the parent */

    if ((gst_element_set_state (element,

                GST_STATE_PAUSED)) == GST_STATE_CHANGE_FAILURE) {

      GST_WARNING_OBJECT (dbin, "Couldn't set %s to PAUSED",

          GST_ELEMENT_NAME (element));

      gst_element_set_state (element, GST_STATE_NULL);

      gst_object_unref (sinkpad);

      gst_bin_remove (GST_BIN (dbin), element);

      continue;

    }

    res = TRUE;

    break;

  }

beach:

  return res;

}

static gboolean

connect_element (GstDecodeBin * dbin, GstElement * element,

    GstDecodeGroup * group)

{

  GList *pads;

  gboolean res = TRUE;

  gboolean dynamic = FALSE;

  GList *to_connect = NULL;

  GST_DEBUG_OBJECT (dbin, "Attempting to connect element %s [group:%p] further",

      GST_ELEMENT_NAME (element), group);

  /* 1. Loop over pad templates, grabbing existing pads along the way */

  for (pads = GST_ELEMENT_GET_CLASS (element)->padtemplates; pads;

      pads = g_list_next (pads)) {

    GstPadTemplate *templ = GST_PAD_TEMPLATE (pads->data);

    const gchar *templ_name;

    /* we are only interested in source pads */

    if (GST_PAD_TEMPLATE_DIRECTION (templ) != GST_PAD_SRC)

      continue;

    templ_name = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);

    GST_DEBUG_OBJECT (dbin, "got a source pad template %s", templ_name);

    /* figure out what kind of pad this is */

    switch (GST_PAD_TEMPLATE_PRESENCE (templ)) {

      case GST_PAD_ALWAYS:

      {

        /* get the pad that we need to autoplug */

        GstPad *pad = gst_element_get_pad (element, templ_name);

        if (pad) {

          GST_DEBUG_OBJECT (dbin, "got the pad for always template %s",

              templ_name);

          /* here is the pad, we need to autoplug it */

          to_connect = g_list_prepend (to_connect, pad);

        } else {

          /* strange, pad is marked as always but it's not

           * there. Fix the element */

          GST_WARNING_OBJECT (dbin,

              "could not get the pad for always template %s", templ_name);

        }

        break;

      }

      case GST_PAD_SOMETIMES:

      {

        /* try to get the pad to see if it is already created or

         * not */

        GstPad *pad = gst_element_get_pad (element, templ_name);

        if (pad) {

          GST_DEBUG_OBJECT (dbin, "got the pad for sometimes template %s",

              templ_name);

          /* the pad is created, we need to autoplug it */

          to_connect = g_list_prepend (to_connect, pad);

        } else {

          GST_DEBUG_OBJECT (dbin,

              "did not get the sometimes pad of template %s", templ_name);

          /* we have an element that will create dynamic pads */