/* GStreamer

 * Copyright (C) <2004> Wim Taymans <wim.taymans@gmail.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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst-i18n-plugin.h>

#include <string.h>

#include <gst/gst.h>

#include <gst/pbutils/pbutils.h>

#include <glib_global.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

#define GST_TYPE_DECODE_BIN             (gst_decode_bin_get_type())

#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))

typedef struct _GstDecodeBin GstDecodeBin;

typedef struct _GstDecodeBinClass GstDecodeBinClass;

struct _GstDecodeBin

{

  GstBin bin;                   /* we extend GstBin */

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

  GstElement *fakesink;

  GList *dynamics;              /* list of dynamic connections */

  GList *queues;                /* list of demuxer-decoder queues */

  GList *probes;                /* list of PadProbeData */

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

  gint numpads;

  gint numwaiting;

  gboolean have_type;

  guint have_type_id;           /* signal id for the typefind element */

  gboolean shutting_down;       /* stop pluggin if we're shutting down */

  GType queue_type;             /* store the GType of queues, to aid in recognising them */

  GMutex *cb_mutex;             /* Mutex for multi-threaded callbacks, such as removing the fakesink */

};

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);

};

/* signals */

enum

{

  SIGNAL_NEW_DECODED_PAD,

  SIGNAL_REMOVED_DECODED_PAD,

  SIGNAL_UNKNOWN_TYPE,

  SIGNAL_REDIRECT,

  LAST_SIGNAL

};

typedef struct

{

  GstPad *pad;

  gulong sigid;

  gboolean done;

} PadProbeData;

/* this structure is created for all dynamic pads that could get created

 * at runtime */

typedef struct

{

  GstDecodeBin *decode_bin;     /* pointer to ourself */

  GstElement *element;          /* the element sending the signal */

  gint np_sig_id;               /* signal id of new_pad */

  gint nmp_sig_id;              /* signal id of no_more_pads */

  GstPad *pad;                  /* the pad sending the signal */

  gint caps_sig_id;             /* signal id of caps */

}

GstDynamic;

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 GstStateChangeReturn gst_decode_bin_change_state (GstElement * element,

    GstStateChange transition);

static gboolean add_fakesink (GstDecodeBin * decode_bin);

static void remove_fakesink (GstDecodeBin * decode_bin);

static void dynamic_free (GstDynamic * dyn);

static void free_dynamics (GstDecodeBin * decode_bin);

static void type_found (GstElement * typefind, guint probability,

    GstCaps * caps, GstDecodeBin * decode_bin);

static GstElement *try_to_link_1 (GstDecodeBin * decode_bin,

    GstElement * origelement, GstPad * pad, GList * factories);

static void close_link (GstElement * element, GstDecodeBin * decode_bin);

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

    GstCaps * caps, GstDecodeBin * decode_bin, gboolean more);

static void unlinked (GstPad * pad, GstPad * peerpad,

    GstDecodeBin * decode_bin);

static void new_pad (GstElement * element, GstPad * pad, GstDynamic * dynamic);

static void no_more_pads (GstElement * element, GstDynamic * dynamic);

static void new_caps (GstPad * pad, GParamSpec * unused, GstDynamic * dynamic);

static void queue_filled_cb (GstElement * queue, GstDecodeBin * decode_bin);

static void queue_underrun_cb (GstElement * queue, GstDecodeBin * decode_bin);

static GstElementClass *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",

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

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, "GstDecodeBin",

        &gst_decode_bin_info, 0);

  }

  return gst_decode_bin_type;

}

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);

  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);

  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);

  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);

  gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_decode_bin_dispose);

  gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_decode_bin_finalize);

  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);

}

/* check if the bin is dynamic.

 *

 * If there are no outstanding dynamic connections, the bin is

 * considered to be non-dynamic.

 */

static gboolean

gst_decode_bin_is_dynamic (GstDecodeBin * decode_bin)

{

  return decode_bin->dynamics != NULL;

}

/* 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 &&

      strstr (klass, "Depayloader") == NULL) {

    return FALSE;

  }

  /* only select elements with autoplugging rank */

  rank = gst_plugin_feature_get_rank (feature);

  if (rank < GST_RANK_MARGINAL)

    return FALSE;

  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;

  decode_bin->cb_mutex = g_mutex_new ();

  /* 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, *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 */

    decode_bin->have_type_id =

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

        G_CALLBACK (type_found), decode_bin);

  }

  add_fakesink (decode_bin);

  decode_bin->dynamics = NULL;

  decode_bin->queues = NULL;

  decode_bin->probes = NULL;

}

static void

gst_decode_bin_dispose (GObject * object)

{

  GstDecodeBin *decode_bin;

  decode_bin = GST_DECODE_BIN (object);

  if (decode_bin->factories)

    gst_plugin_feature_list_free (decode_bin->factories);

  decode_bin->factories = NULL;

  G_OBJECT_CLASS (parent_class)->dispose (object);

  /* our parent dispose might trigger new signals when pads are unlinked

   * etc. clean up the mess here. */

  /* FIXME do proper cleanup when going to NULL */

  free_dynamics (decode_bin);

}

static void

gst_decode_bin_finalize (GObject * object)

{

  GstDecodeBin *decode_bin = GST_DECODE_BIN (object);

  g_mutex_free (decode_bin->cb_mutex);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

struct DynFind

{

  GstElement *elem;

  GstPad *pad;

};

static gint

find_dynamic (GstDynamic * dyn, struct DynFind *info)

{

  if (dyn->element == info->elem && dyn->pad == info->pad)

    return 0;

  return 1;

}

/* Add either an element (for dynamic pads/pad-added watching) or a

 * pad (for delayed caps/notify::caps watching) to the dynamic list,

 * taking care to ignore repeat entries so we don't end up handling a

 * pad twice, for example */

static void

dynamic_add (GstElement * element, GstPad * pad, GstDecodeBin * decode_bin)

{

  GstDynamic *dyn;

  struct DynFind find_info;

  GList *found;

  g_return_if_fail (element != NULL);

  /* do a search that this entry doesn't already exist */

  find_info.elem = element;

  find_info.pad = pad;

  found = g_list_find_custom (decode_bin->dynamics, &find_info,

      (GCompareFunc) find_dynamic);

  if (found != NULL)

    goto exit;

  /* take refs */

  dyn = g_new0 (GstDynamic, 1);

  dyn->element = gst_object_ref (element);

  dyn->decode_bin = gst_object_ref (decode_bin);

  if (pad) {

    dyn->pad = gst_object_ref (pad);

    GST_DEBUG_OBJECT (decode_bin, "dynamic create for pad %" GST_PTR_FORMAT,

        pad);

    dyn->caps_sig_id = g_signal_connect (G_OBJECT (pad), "notify::caps",

        G_CALLBACK (new_caps), dyn);

  } else {

    GST_DEBUG_OBJECT (decode_bin, "dynamic create for element %"

        GST_PTR_FORMAT, element);

    dyn->np_sig_id = g_signal_connect (G_OBJECT (element), "pad-added",

        G_CALLBACK (new_pad), dyn);

    dyn->nmp_sig_id = g_signal_connect (G_OBJECT (element), "no-more-pads",

        G_CALLBACK (no_more_pads), dyn);

  }

  /* and add this element to the dynamic elements */

  decode_bin->dynamics = g_list_prepend (decode_bin->dynamics, dyn);

  return;

exit:

  if (element) {

    GST_DEBUG_OBJECT (decode_bin, "Dynamic element already added: %"

        GST_PTR_FORMAT, element);

  } else {

    GST_DEBUG_OBJECT (decode_bin, "Dynamic pad already added: %"

        GST_PTR_FORMAT, pad);

  }

}

static void

dynamic_free (GstDynamic * dyn)

{

  GST_DEBUG_OBJECT (dyn->decode_bin, "dynamic free");

  /* disconnect signals */

  if (dyn->np_sig_id)

    g_signal_handler_disconnect (G_OBJECT (dyn->element), dyn->np_sig_id);

  if (dyn->nmp_sig_id)

    g_signal_handler_disconnect (G_OBJECT (dyn->element), dyn->nmp_sig_id);

  if (dyn->caps_sig_id)

    g_signal_handler_disconnect (G_OBJECT (dyn->pad), dyn->caps_sig_id);

  if (dyn->pad)

    gst_object_unref (dyn->pad);

  dyn->pad = NULL;

  if (dyn->element)

    gst_object_unref (dyn->element);

  dyn->element = NULL;

  gst_object_unref (dyn->decode_bin);

  dyn->decode_bin = NULL;

  g_free (dyn);

}

static void

free_dynamics (GstDecodeBin * decode_bin)

{

  GList *dyns;

  for (dyns = decode_bin->dynamics; dyns; dyns = g_list_next (dyns)) {

    GstDynamic *dynamic = (GstDynamic *) dyns->data;

    dynamic_free (dynamic);

  }

  g_list_free (decode_bin->dynamics);

  decode_bin->dynamics = NULL;

}

/* this function runs through the element factories and returns a list

 * of all elements that are able to sink the given caps

 */

static GList *

find_compatibles (GstDecodeBin * decode_bin, const GstCaps * caps)

{

  GList *factories;

  GList *to_try = NULL;

  /* loop over all the factories */

  for (factories = decode_bin->factories; factories;

      factories = g_list_next (factories)) {

    GstElementFactory *factory = GST_ELEMENT_FACTORY (factories->data);

    const GList *templates;

    GList *walk;

    /* get the templates from the element factory */

    templates = gst_element_factory_get_static_pad_templates (factory);

    for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {

      GstStaticPadTemplate *templ = walk->data;

      /* we only care about the sink templates */

      if (templ->direction == GST_PAD_SINK) {

        GstCaps *intersect;

        GstCaps *tmpl_caps;

        /* try to intersect the caps with the caps of the template */

        tmpl_caps = gst_static_caps_get (&templ->static_caps);