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

 *

 * #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 #GstDecodeBin for its internal auto-plugging.

 */

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

#include "gstplay-enum.h"

#include "gstfactorylists.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 GstGhostPadClass GstDecodePadClass;

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

  /* properties */

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

  gchar *encoding;              /* encoding of subtitles */

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

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

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

  GList *subtitles;             /* List of elements with subtitle-encoding */

  gboolean have_type;           /* if we received the have_type signal */

  guint have_type_id;           /* signal id for have-type from typefind */

  gboolean async_pending;       /* async-start has been emited */

  GMutex *dyn_lock;             /* lock protecting pad blocking */

  gboolean shutdown;            /* if we are shutting down */

  GList *blocked_pads;          /* pads that have set to block */

};

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, GstPad * pad,

      GstCaps * caps);

  /* signal fired to get a list of factories to try to autoplug */

  GValueArray *(*autoplug_factories) (GstElement * element, GstPad * pad,

      GstCaps * caps);

  /* signal fired to sort the factories */

  GValueArray *(*autoplug_sort) (GstElement * element, GstPad * pad,

      GstCaps * caps, GValueArray * factories);

  /* signal fired to select from the proposed list of factories */

    GstAutoplugSelectResult (*autoplug_select) (GstElement * element,

      GstPad * pad, GstCaps * caps, GstElementFactory * factory);

  /* fired when the last group is drained */

  void (*drained) (GstElement * element);

};

/* signals */

enum

{

  SIGNAL_NEW_DECODED_PAD,

  SIGNAL_REMOVED_DECODED_PAD,

  SIGNAL_UNKNOWN_TYPE,

  SIGNAL_AUTOPLUG_CONTINUE,

  SIGNAL_AUTOPLUG_FACTORIES,

  SIGNAL_AUTOPLUG_SELECT,

  SIGNAL_AUTOPLUG_SORT,

  SIGNAL_DRAINED,

  LAST_SIGNAL

};

/* Properties */

enum

{

  PROP_0,

  PROP_CAPS,

  PROP_SUBTITLE_ENCODING,

  PROP_SINK_CAPS,

  PROP_LAST

};

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 void do_async_start (GstDecodeBin * dbin);

static void do_async_done (GstDecodeBin * dbin);

static void type_found (GstElement * typefind, guint probability,

    GstCaps * caps, GstDecodeBin * decode_bin);

static gboolean gst_decode_bin_autoplug_continue (GstElement * element,

    GstPad * pad, GstCaps * caps);

static GValueArray *gst_decode_bin_autoplug_factories (GstElement *

    element, GstPad * pad, GstCaps * caps);

static GValueArray *gst_decode_bin_autoplug_sort (GstElement * element,

    GstPad * pad, GstCaps * caps, GValueArray * factories);

static GstAutoplugSelectResult gst_decode_bin_autoplug_select (GstElement *

    element, GstPad * pad, GstCaps * caps, GstElementFactory * factory);

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 void caps_notify_group_cb (GstPad * pad, GParamSpec * unused,

    GstDecodeGroup * group);

static void caps_notify_cb (GstPad * pad, GParamSpec * unused,

    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

#define DECODE_BIN_DYN_LOCK(dbin) G_STMT_START {			\

    GST_LOG_OBJECT (dbin,						\

		    "dynlocking from thread %p",			\

		    g_thread_self ());					\

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

    GST_LOG_OBJECT (dbin,						\

		    "dynlocked from thread %p",				\

		    g_thread_self ());					\

} G_STMT_END

#define DECODE_BIN_DYN_UNLOCK(dbin) G_STMT_START {			\

    GST_LOG_OBJECT (dbin,						\

		    "dynunlocking from thread %p",			\

		    g_thread_self ());					\

    g_mutex_unlock (GST_DECODE_BIN_CAST(dbin)->dyn_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 through 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;            /* the overrun signal for multiqueue */

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

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

  GList *reqpads;               /* List of RequestPads for multiqueue. */

};

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

    gboolean use_queue);

static GstPad *gst_decode_group_control_demuxer_pad (GstDecodeGroup * group,

    GstPad * pad);

static gboolean gst_decode_group_control_source_pad (GstDecodeGroup * group,

    GstDecodePad * pad);

static gboolean gst_decode_group_expose (GstDecodeGroup * group);

static gboolean 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

{

  GstGhostPad parent;

  GstDecodeBin *dbin;

  GstDecodeGroup *group;

  gboolean blocked;             /* the pad is blocked */

  gboolean drained;             /* an EOS has been seen on the pad */

  gboolean added;               /* the pad is added to decodebin */

};

G_DEFINE_TYPE (GstDecodePad, gst_decode_pad, GST_TYPE_GHOST_PAD);

#define GST_TYPE_DECODE_PAD (gst_decode_pad_get_type ())

#define GST_DECODE_PAD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DECODE_PAD,GstDecodePad))

static GstDecodePad *gst_decode_pad_new (GstDecodeBin * dbin, GstPad * pad,

    GstDecodeGroup * group);

static void gst_decode_pad_activate (GstDecodePad * dpad,

    GstDecodeGroup * group);

static void gst_decode_pad_unblock (GstDecodePad * dpad);

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

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

}

/* we collect the first result */

static gboolean

_gst_array_accumulator (GSignalInvocationHint * ihint,

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

{

  gpointer array;

  array = g_value_get_boxed (handler_return);

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

    g_value_set_boxed (return_accu, array);

  return FALSE;

}

static gboolean

_gst_select_accumulator (GSignalInvocationHint * ihint,

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

{

  GstAutoplugSelectResult res;

  res = g_value_get_enum (handler_return);

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

    g_value_set_enum (return_accu, res);

  return FALSE;

}

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:

   * @bin: The decodebin

   * @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:

   * @bin: The decodebin

   * @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:

   * @bin: The decodebin

   * @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_BOXED, G_TYPE_NONE, 2,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstDecodeBin2::autoplug-continue:

   * @bin: The decodebin

   * @pad: The #GstPad.

   * @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_BOXED,

      G_TYPE_BOOLEAN, 2, GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstDecodeBin2::autoplug-factories:

   * @bin: The decodebin

   * @pad: The #GstPad.

   * @caps: The #GstCaps found.

   *

   * This function is emited when an array of possible factories for @caps on

   * @pad is needed. Decodebin2 will by default return an array with all

   * compatible factories, sorted by rank. 

   *

   * If this function returns NULL, @pad will be exposed as a final caps.

   *

   * If this function returns an empty array, the pad will be considered as 

   * having an unhandled type media type.

   *

   * Returns: a #GValueArray* with a list of factories to try. The factories are

   * by default tried in the returned order or based on the index returned by

   * "autoplug-select".

   */

  gst_decode_bin_signals[SIGNAL_AUTOPLUG_FACTORIES] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDecodeBinClass,

          autoplug_factories), _gst_array_accumulator, NULL,

      gst_play_marshal_BOXED__OBJECT_BOXED, G_TYPE_VALUE_ARRAY, 2,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstDecodeBin2::autoplug-sort:

   * @bin: The decodebin

   * @pad: The #GstPad.

   * @caps: The #GstCaps.

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

   *

   * Once decodebin2 has found the possible #GstElementFactory objects to try

   * for @caps on @pad, this signal is emited. The purpose of the signal is for

   * the application to perform additional sorting or filtering on the element

   * factory array.

   *

   * The callee should copy and modify @factories.

   *

   * Returns: A new sorted array of #GstElementFactory objects.

   */

  gst_decode_bin_signals[SIGNAL_AUTOPLUG_SORT] =

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