/* GStreamer

 * Copyright (C) <2007> 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.

 */

/**

 * SECTION:element-uridecodebin

 *

 * Decodes data from a URI into raw media.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <string.h>

#include <gst/gst.h>

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

#include "gstplay-marshal.h"

#include "gstplay-enum.h"

#define GST_TYPE_URI_DECODE_BIN \

  (gst_uri_decode_bin_get_type())

#define GST_URI_DECODE_BIN(obj) \

  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_URI_DECODE_BIN,GstURIDecodeBin))

#define GST_URI_DECODE_BIN_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_URI_DECODE_BIN,GstURIDecodeBinClass))

#define GST_IS_URI_DECODE_BIN(obj) \

  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_URI_DECODE_BIN))

#define GST_IS_URI_DECODE_BIN_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_URI_DECODE_BIN))

typedef struct _GstURIDecodeBin GstURIDecodeBin;

typedef struct _GstURIDecodeBinClass GstURIDecodeBinClass;

struct _GstURIDecodeBin

{

  GstBin parent_instance;

  gchar *uri;

  guint connection_speed;

  GstCaps *caps;

  gchar *encoding;

  gboolean is_stream;

  GstElement *source;

  GSList *srcpads;

  gint numpads;

  /* for dynamic sources */

  guint src_np_sig_id;          /* new-pad signal id */

  guint src_nmp_sig_id;         /* no-more-pads signal id */

  gint pending;

};

struct _GstURIDecodeBinClass

{

  GstBinClass parent_class;

  /* 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 select from the proposed list of factories */

    GstAutoplugSelectResult (*autoplug_select) (GstElement * element,

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

  /* emited when all data is decoded */

  void (*drained) (GstElement * element);

};

static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src%d",

    GST_PAD_SRC,

    GST_PAD_SOMETIMES,

    GST_STATIC_CAPS_ANY);

GST_DEBUG_CATEGORY_STATIC (gst_uri_decode_bin_debug);

#define GST_CAT_DEFAULT gst_uri_decode_bin_debug

static const GstElementDetails gst_uri_decode_bin_details =

GST_ELEMENT_DETAILS ("URI Decoder",

    "Generic/Bin/Decoder",

    "Autoplug and decode an URI to raw media",

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

/* signals */

enum

{

  SIGNAL_UNKNOWN_TYPE,

  SIGNAL_AUTOPLUG_CONTINUE,

  SIGNAL_AUTOPLUG_FACTORIES,

  SIGNAL_AUTOPLUG_SELECT,

  SIGNAL_DRAINED,

  LAST_SIGNAL

};

/* properties */

#define DEFAULT_PROP_URI	    NULL

#define DEFAULT_CONNECTION_SPEED    0

#define DEFAULT_CAPS                NULL

#define DEFAULT_SUBTITLE_ENCODING   NULL

enum

{

  PROP_0,

  PROP_URI,

  PROP_CONNECTION_SPEED,

  PROP_CAPS,

  PROP_SUBTITLE_ENCODING,

  PROP_LAST

};

static guint gst_uri_decode_bin_signals[LAST_SIGNAL] = { 0 };

GST_BOILERPLATE (GstURIDecodeBin, gst_uri_decode_bin, GstBin, GST_TYPE_BIN);

static void gst_uri_decode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_uri_decode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static void gst_uri_decode_bin_finalize (GObject * obj);

static void handle_message (GstBin * bin, GstMessage * msg);

static gboolean gst_uri_decode_bin_query (GstElement * element,

    GstQuery * query);

static GstStateChangeReturn gst_uri_decode_bin_change_state (GstElement *

    element, GstStateChange transition);

static void

gst_uri_decode_bin_base_init (gpointer g_class)

{

  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (gstelement_class,

      gst_static_pad_template_get (&srctemplate));

  gst_element_class_set_details (gstelement_class, &gst_uri_decode_bin_details);

}

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

gst_uri_decode_bin_autoplug_continue (GstElement * element, GstPad * pad,

    GstCaps * caps)

{

  /* by default we always continue */

  return TRUE;

}

static void

gst_uri_decode_bin_class_init (GstURIDecodeBinClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  GstBinClass *gstbin_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gstelement_class = GST_ELEMENT_CLASS (klass);

  gstbin_class = GST_BIN_CLASS (klass);

  gobject_class->set_property = gst_uri_decode_bin_set_property;

  gobject_class->get_property = gst_uri_decode_bin_get_property;

  gobject_class->finalize = gst_uri_decode_bin_finalize;

  g_object_class_install_property (gobject_class, PROP_URI,

      g_param_spec_string ("uri", "URI", "URI to decode",

  g_object_class_install_property (gobject_class, PROP_CONNECTION_SPEED,

      g_param_spec_uint ("connection-speed", "Connection Speed",

          "Network connection speed in kbps (0 = unknown)",

  g_object_class_install_property (gobject_class, PROP_CAPS,

      g_param_spec_boxed ("caps", "Caps",

          "The caps on which to stop decoding. (NULL = default)",

  g_object_class_install_property (gobject_class, PROP_SUBTITLE_ENCODING,

      g_param_spec_string ("subtitle-encoding", "subtitle encoding",

          "Encoding to assume if input subtitles are not in UTF-8 encoding. "

          "If not set, the GST_SUBTITLE_ENCODING environment variable will "

          "be checked for an encoding to use. If that is not set either, "

  /**

   * GstURIDecodeBin::unknown-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 uridecodebin.

   */

  gst_uri_decode_bin_signals[SIGNAL_UNKNOWN_TYPE] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass, unknown_type),

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-continue:

   * @pad: The #GstPad.

   * @caps: The #GstCaps found.

   *

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

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

   *

   * Returns: #TRUE if you wish uridecodebin 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_uri_decode_bin_signals[SIGNAL_AUTOPLUG_CONTINUE] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass,

          autoplug_continue), _gst_boolean_accumulator, NULL,

      GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-factories:

   * @pad: The #GstPad.

   * @caps: The #GstCaps found.

   *

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

   *

   * 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_uri_decode_bin_signals[SIGNAL_AUTOPLUG_FACTORIES] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass,

          autoplug_factories), _gst_array_accumulator, NULL,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-select:

   * @pad: The #GstPad.

   * @caps: The #GstCaps.

   *

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

   *

   */

  gst_uri_decode_bin_signals[SIGNAL_AUTOPLUG_SELECT] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass,

          autoplug_select), _gst_select_accumulator, NULL,

      GST_TYPE_AUTOPLUG_SELECT_RESULT, 3, GST_TYPE_PAD, GST_TYPE_CAPS,

      GST_TYPE_ELEMENT_FACTORY);

  /**

   * GstURIDecodeBin::drained:

   *

   * This signal is emitted when the data for the current uri is played.

   */

  gst_uri_decode_bin_signals[SIGNAL_DRAINED] =

      g_signal_new ("drained", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstURIDecodeBinClass, drained), NULL, NULL,

      gst_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);

  gstelement_class->query = GST_DEBUG_FUNCPTR (gst_uri_decode_bin_query);

  gstelement_class->change_state =

      GST_DEBUG_FUNCPTR (gst_uri_decode_bin_change_state);

  gstbin_class->handle_message = GST_DEBUG_FUNCPTR (handle_message);

  klass->autoplug_continue =

      GST_DEBUG_FUNCPTR (gst_uri_decode_bin_autoplug_continue);

}

static void

gst_uri_decode_bin_init (GstURIDecodeBin * dec, GstURIDecodeBinClass * klass)

{

  dec->uri = g_strdup (DEFAULT_PROP_URI);

  dec->connection_speed = DEFAULT_CONNECTION_SPEED;

  dec->caps = DEFAULT_CAPS;

  dec->encoding = g_strdup (DEFAULT_SUBTITLE_ENCODING);

}

static void

gst_uri_decode_bin_finalize (GObject * obj)

{

  GstURIDecodeBin *dec = GST_URI_DECODE_BIN (obj);

  g_free (dec->uri);

  g_free (dec->encoding);

  G_OBJECT_CLASS (parent_class)->finalize (obj);

}

static void

gst_uri_decode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstURIDecodeBin *dec = GST_URI_DECODE_BIN (object);

  switch (prop_id) {

    case PROP_URI:

      GST_OBJECT_LOCK (dec);

      g_free (dec->uri);

      dec->uri = g_value_dup_string (value);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_CONNECTION_SPEED:

      GST_OBJECT_LOCK (dec);

      dec->connection_speed = g_value_get_uint (value) * 1000;

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_CAPS:

      GST_OBJECT_LOCK (dec);

      if (dec->caps)

        gst_caps_unref (dec->caps);

      dec->caps = g_value_dup_boxed (value);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_SUBTITLE_ENCODING:

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_uri_decode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstURIDecodeBin *dec = GST_URI_DECODE_BIN (object);

  switch (prop_id) {

    case PROP_URI:

      GST_OBJECT_LOCK (dec);

      g_value_set_string (value, dec->uri);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_CONNECTION_SPEED:

      GST_OBJECT_LOCK (dec);

      g_value_set_uint (value, dec->connection_speed / 1000);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_CAPS:

      GST_OBJECT_LOCK (dec);

      g_value_set_boxed (value, dec->caps);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_SUBTITLE_ENCODING:

      GST_OBJECT_LOCK (dec);

      g_value_set_string (value, dec->encoding);

      GST_OBJECT_UNLOCK (dec);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

#define DEFAULT_QUEUE_SIZE          (3 * GST_SECOND)

#define DEFAULT_QUEUE_MIN_THRESHOLD ((DEFAULT_QUEUE_SIZE * 30) / 100)

#define DEFAULT_QUEUE_THRESHOLD     ((DEFAULT_QUEUE_SIZE * 95) / 100)

static void

unknown_type_cb (GstElement * element, GstPad * pad, GstCaps * caps,

    GstURIDecodeBin * decoder)

{

  gchar *capsstr;

  capsstr = gst_caps_to_string (caps);

  GST_ELEMENT_WARNING (decoder, STREAM, WRONG_TYPE,

      (_("No decoder available for type \'%s\'."), capsstr), (NULL));

  g_free (capsstr);

}

/* add a streaminfo that indicates that the stream is handled by the

 * given element. This usually means that a stream without actual data is

 * produced but one that is sunken by an element. Examples of this are:

 * cdaudio, a hardware decoder/sink, dvd meta bins etc...

 */

static void

add_element_stream (GstElement * element, GstURIDecodeBin * decoder)

{

  g_warning ("add element stream");

}

/* when the decoder element signals that no more pads will be generated, we

 * can commit the current group.

 */

static void

no_more_pads_full (GstElement * element, gboolean subs,

    GstURIDecodeBin * decoder)

{

  gboolean final;

  /* setup phase */

  GST_DEBUG_OBJECT (element, "no more pads, %d pending", decoder->pending);

  final = (decoder->pending == 0);

  /* nothing pending, we can exit */

  if (final)

    goto done;

  /* the object has no pending no_more_pads */

  if (!g_object_get_data (G_OBJECT (element), "pending"))

    goto done;

  g_object_set_data (G_OBJECT (element), "pending", NULL);

  decoder->pending--;

  final = (decoder->pending == 0);

done:

  if (final)

    gst_element_no_more_pads (GST_ELEMENT_CAST (decoder));

  return;

}

static void

no_more_pads (GstElement * element, GstURIDecodeBin * decoder)

{

  no_more_pads_full (element, FALSE, decoder);

}

static void

source_no_more_pads (GstElement * element, GstURIDecodeBin * bin)

{

  GST_DEBUG_OBJECT (bin, "No more pads in source element %s.",

      GST_ELEMENT_NAME (element));

  g_signal_handler_disconnect (G_OBJECT (element), bin->src_np_sig_id);

  bin->src_np_sig_id = 0;

  g_signal_handler_disconnect (G_OBJECT (element), bin->src_nmp_sig_id);

  bin->src_nmp_sig_id = 0;

  no_more_pads_full (element, FALSE, bin);

}

/* Called by the signal handlers when a decodebin has 

 * found a new raw pad.  

 */

static void