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

      GST_TYPE_PAD, GST_TYPE_CAPS);

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

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