/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:element-uridecodebin

 * @title: uridecodebin

 *

 * Decodes data from a URI into raw media. It selects a source element that can

 * handle the given #GstURIDecodeBin:uri scheme and connects it to a decodebin.

 */

/* FIXME 0.11: suppress warnings for deprecated API such as GValueArray

 * with newer GLib versions (>= 2.31.0) */

#define GLIB_DISABLE_DEPRECATION_WARNINGS

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <string.h>

#include <gst/gst.h>

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

#include <gst/pbutils/missing-plugins.h>

#include "gstplay-enum.h"

#include "gstrawcaps.h"

#include "gstplayback.h"

#include "gstplaybackutils.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))

#define GST_URI_DECODE_BIN_CAST(obj) ((GstURIDecodeBin *) (obj))

typedef struct _GstURIDecodeBin GstURIDecodeBin;

typedef struct _GstURIDecodeBinClass GstURIDecodeBinClass;

#define GST_URI_DECODE_BIN_LOCK(dec) (g_mutex_lock(&((GstURIDecodeBin*)(dec))->lock))

#define GST_URI_DECODE_BIN_UNLOCK(dec) (g_mutex_unlock(&((GstURIDecodeBin*)(dec))->lock))

typedef struct _GstURIDecodeBinStream

{

  gulong probe_id;

  guint bitrate;

} GstURIDecodeBinStream;

/**

 * GstURIDecodeBin

 *

 * uridecodebin element struct

 */

struct _GstURIDecodeBin

{

  GstBin parent_instance;

  GMutex lock;                  /* lock for constructing */

  GMutex factories_lock;

  guint32 factories_cookie;

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

  gchar *uri;

  guint64 connection_speed;

  GstCaps *caps;

  gchar *encoding;

  gboolean is_stream;

  gboolean is_adaptive;

  gboolean need_queue;

  guint64 buffer_duration;      /* When buffering, buffer duration (ns) */

  guint buffer_size;            /* When buffering, buffer size (bytes) */

  gboolean download;

  gboolean use_buffering;

  GstElement *source;

  GstElement *queue;

  GstElement *typefind;

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

  GSList *decodebins;

  GSList *pending_decodebins;

  GHashTable *streams;

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

  GList *missing_plugin_errors;

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

  gboolean expose_allstreams;   /* Whether to expose unknow type streams or not */

  guint64 ring_buffer_max_size; /* 0 means disabled */

};

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

  /* signal fired when a autoplugged element that is not linked downstream

   * or exposed wants to query something */

    gboolean (*autoplug_query) (GstElement * element, GstPad * pad,

      GstQuery * query);

  /* emitted when all data is decoded */

  void (*drained) (GstElement * element);

};

static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src_%u",

    GST_PAD_SRC,

    GST_PAD_SOMETIMES,

    GST_STATIC_CAPS_ANY);

static GstStaticCaps default_raw_caps = GST_STATIC_CAPS (DEFAULT_RAW_CAPS);

GST_DEBUG_CATEGORY_STATIC (gst_uri_decode_bin_debug);

#define GST_CAT_DEFAULT gst_uri_decode_bin_debug

/* signals */

enum

{

  SIGNAL_UNKNOWN_TYPE,

  SIGNAL_AUTOPLUG_CONTINUE,

  SIGNAL_AUTOPLUG_FACTORIES,

  SIGNAL_AUTOPLUG_SELECT,

  SIGNAL_AUTOPLUG_SORT,

  SIGNAL_AUTOPLUG_QUERY,

  SIGNAL_DRAINED,

  SIGNAL_SOURCE_SETUP,

  LAST_SIGNAL

};

/* properties */

#define DEFAULT_PROP_URI            NULL

#define DEFAULT_PROP_SOURCE         NULL

#define DEFAULT_CONNECTION_SPEED    0

#define DEFAULT_CAPS                (gst_static_caps_get (&default_raw_caps))

#define DEFAULT_SUBTITLE_ENCODING   NULL

#define DEFAULT_BUFFER_DURATION     -1

#define DEFAULT_BUFFER_SIZE         -1

#define DEFAULT_DOWNLOAD            FALSE

#define DEFAULT_USE_BUFFERING       FALSE

#define DEFAULT_EXPOSE_ALL_STREAMS  TRUE

#define DEFAULT_RING_BUFFER_MAX_SIZE 0

enum

{

  PROP_0,

  PROP_URI,

  PROP_SOURCE,

  PROP_CONNECTION_SPEED,

  PROP_CAPS,

  PROP_SUBTITLE_ENCODING,

  PROP_BUFFER_SIZE,

  PROP_BUFFER_DURATION,

  PROP_DOWNLOAD,

  PROP_USE_BUFFERING,

  PROP_EXPOSE_ALL_STREAMS,

  PROP_RING_BUFFER_MAX_SIZE

};

static guint gst_uri_decode_bin_signals[LAST_SIGNAL] = { 0 };

GType gst_uri_decode_bin_get_type (void);

#define gst_uri_decode_bin_parent_class parent_class

G_DEFINE_TYPE (GstURIDecodeBin, gst_uri_decode_bin, GST_TYPE_BIN);

static void remove_decoders (GstURIDecodeBin * bin, gboolean force);

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 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_boolean_or_accumulator (GSignalInvocationHint * ihint,

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

{

  gboolean myboolean;

  gboolean retboolean;

  myboolean = g_value_get_boolean (handler_return);

  retboolean = g_value_get_boolean (return_accu);

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

    g_value_set_boolean (return_accu, myboolean || retboolean);

  return TRUE;

}

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

  /* Call the next handler in the chain (if any) when the current callback

   * returns TRY. This makes it possible to register separate autoplug-select

   * handlers that implement different TRY/EXPOSE/SKIP strategies.

   */

  if (res == GST_AUTOPLUG_SELECT_TRY)

    return TRUE;

  return FALSE;

}

static gboolean

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

  if (array != NULL)

    return FALSE;

  return TRUE;

}

static gboolean

gst_uri_decode_bin_autoplug_continue (GstElement * element, GstPad * pad,

    GstCaps * caps)

{

  /* by default we always continue */

  return TRUE;

}

/* Must be called with factories lock! */

static void

gst_uri_decode_bin_update_factories_list (GstURIDecodeBin * dec)

{

  guint32 cookie;

  cookie = gst_registry_get_feature_list_cookie (gst_registry_get ());

  if (!dec->factories || dec->factories_cookie != cookie) {

    if (dec->factories)

      gst_plugin_feature_list_free (dec->factories);

    dec->factories =

        gst_element_factory_list_get_elements

        (GST_ELEMENT_FACTORY_TYPE_DECODABLE, GST_RANK_MARGINAL);

    dec->factories =

        g_list_sort (dec->factories, gst_playback_utils_compare_factories_func);

    dec->factories_cookie = cookie;

  }

}

static GValueArray *

gst_uri_decode_bin_autoplug_factories (GstElement * element, GstPad * pad,

    GstCaps * caps)

{

  GList *list, *tmp;

  GValueArray *result;

  GstURIDecodeBin *dec = GST_URI_DECODE_BIN_CAST (element);

  GST_DEBUG_OBJECT (element, "finding factories");

  /* return all compatible factories for caps */

  g_mutex_lock (&dec->factories_lock);

  gst_uri_decode_bin_update_factories_list (dec);

  list =

      gst_element_factory_list_filter (dec->factories, caps, GST_PAD_SINK,

      gst_caps_is_fixed (caps));

  g_mutex_unlock (&dec->factories_lock);

  result = g_value_array_new (g_list_length (list));

  for (tmp = list; tmp; tmp = tmp->next) {

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

    GValue val = { 0, };

    g_value_init (&val, G_TYPE_OBJECT);

    g_value_set_object (&val, factory);

    g_value_array_append (result, &val;;

    g_value_unset (&val;;

  }

  gst_plugin_feature_list_free (list);

  GST_DEBUG_OBJECT (element, "autoplug-factories returns %p", result);

  return result;

}

static GValueArray *

gst_uri_decode_bin_autoplug_sort (GstElement * element, GstPad * pad,

    GstCaps * caps, GValueArray * factories)

{

  return NULL;

}

static GstAutoplugSelectResult

gst_uri_decode_bin_autoplug_select (GstElement * element, GstPad * pad,

    GstCaps * caps, GstElementFactory * factory)

{

  GST_DEBUG_OBJECT (element, "default autoplug-select returns TRY");

  /* Try factory. */

  return GST_AUTOPLUG_SELECT_TRY;

}

static gboolean

gst_uri_decode_bin_autoplug_query (GstElement * element, GstPad * pad,

    GstQuery * query)

{

  /* No query handled here */

  return FALSE;

}

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

          DEFAULT_PROP_URI, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SOURCE,

      g_param_spec_object ("source", "Source", "Source object used",

          GST_TYPE_ELEMENT, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CONNECTION_SPEED,

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

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

          0, G_MAXUINT64 / 1000, DEFAULT_CONNECTION_SPEED,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CAPS,

      g_param_spec_boxed ("caps", "Caps",

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

          GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

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

          "ISO-8859-15 will be assumed.", NULL,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BUFFER_SIZE,

      g_param_spec_int ("buffer-size", "Buffer size (bytes)",

          "Buffer size when buffering streams (-1 default value)",

          -1, G_MAXINT, DEFAULT_BUFFER_SIZE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BUFFER_DURATION,

      g_param_spec_int64 ("buffer-duration", "Buffer duration (ns)",

          "Buffer duration when buffering streams (-1 default value)",

          -1, G_MAXINT64, DEFAULT_BUFFER_DURATION,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstURIDecodeBin::download:

   *

   * For certain media type, enable download buffering.

   */

  g_object_class_install_property (gobject_class, PROP_DOWNLOAD,

      g_param_spec_boolean ("download", "Download",

          "Attempt download buffering when buffering network streams",

          DEFAULT_DOWNLOAD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstURIDecodeBin::use-buffering:

   *

   * Emit BUFFERING messages based on low-/high-percent thresholds of the

   * demuxed or parsed data.

   * When download buffering is activated and used for the current media

   * type, this property does nothing. Otherwise perform buffering on the

   * demuxed or parsed media.

   */

  g_object_class_install_property (gobject_class, PROP_USE_BUFFERING,

      g_param_spec_boolean ("use-buffering", "Use Buffering",

          "Perform buffering on demuxed/parsed media",

          DEFAULT_USE_BUFFERING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstURIDecodeBin::expose-all-streams

   *

   * Expose streams of unknown type.

   *

   * If set to %FALSE, then only the streams that can be decoded to the final

   * caps (see 'caps' property) will have a pad exposed. Streams that do not

   * match those caps but could have been decoded will not have decoder plugged

   * in internally and will not have a pad exposed.

   */

  g_object_class_install_property (gobject_class, PROP_EXPOSE_ALL_STREAMS,

      g_param_spec_boolean ("expose-all-streams", "Expose All Streams",

          "Expose all streams, including those of unknown type or that don't match the 'caps' property",

          DEFAULT_EXPOSE_ALL_STREAMS,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstURIDecodeBin::ring-buffer-max-size

   *

   * The maximum size of the ring buffer in kilobytes. If set to 0, the ring

   * buffer is disabled. Default is 0.

   */

  g_object_class_install_property (gobject_class, PROP_RING_BUFFER_MAX_SIZE,

      g_param_spec_uint64 ("ring-buffer-max-size",

          "Max. ring buffer size (bytes)",

          "Max. amount of data in the ring buffer (bytes, 0 = ring buffer disabled)",

          0, G_MAXUINT, DEFAULT_RING_BUFFER_MAX_SIZE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstURIDecodeBin::unknown-type:

   * @bin: The uridecodebin.

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

      NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-continue:

   * @bin: The uridecodebin.

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

   *

   * >   Invocation of signal handlers stops after the first signal handler

   * >   returns %FALSE. Signal handlers are invoked in the order they were

   * >   connected in.

   *

   * 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 'pad-added' signal of

   * #GstElement).

   */

  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,

      g_cclosure_marshal_generic, G_TYPE_BOOLEAN, 2, GST_TYPE_PAD,

      GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-factories:

   * @bin: The uridecodebin.

   * @pad: The #GstPad.

   * @caps: The #GstCaps found.

   *

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

   * @pad is needed. Uridecodebin 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.

   *

   * >   Only the signal handler that is connected first will ever by invoked.

   * >   Don't connect signal handlers with the #G_CONNECT_AFTER flag to this

   * >   signal, they will never be invoked!

   *

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

      g_cclosure_marshal_generic, G_TYPE_VALUE_ARRAY, 2,

      GST_TYPE_PAD, GST_TYPE_CAPS);

  /**

   * GstURIDecodeBin::autoplug-sort:

   * @bin: The uridecodebin.

   * @pad: The #GstPad.

   * @caps: The #GstCaps.

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

   *

   * Once decodebin 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 or return %NULL if the

   * order should not change.

   *

   * >   Invocation of signal handlers stops after one signal handler has

   * >   returned something else than %NULL. Signal handlers are invoked in

   * >   the order they were connected in.

   * >   Don't connect signal handlers with the #G_CONNECT_AFTER flag to this

   * >   signal, they will never be invoked!

   *

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

   */

  gst_uri_decode_bin_signals[SIGNAL_AUTOPLUG_SORT] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass, autoplug_sort),

      _gst_array_hasvalue_accumulator, NULL,

      g_cclosure_marshal_generic, G_TYPE_VALUE_ARRAY, 3, GST_TYPE_PAD,

      GST_TYPE_CAPS, G_TYPE_VALUE_ARRAY | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GstURIDecodeBin::autoplug-select:

   * @bin: The uridecodebin.

   * @pad: The #GstPad.

   * @caps: The #GstCaps.

   * @factory: A #GstElementFactory to use.

   *

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

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

   * those factories, this signal is emitted.

   *

   * The signal handler should return a #GST_TYPE_AUTOPLUG_SELECT_RESULT enum

   * value indicating what decodebin should do next.

   *

   * A value of #GST_AUTOPLUG_SELECT_TRY will try to autoplug an element from

   * @factory.

   *

   * A value of #GST_AUTOPLUG_SELECT_EXPOSE will expose @pad without plugging

   * any element to it.

   *

   * A value of #GST_AUTOPLUG_SELECT_SKIP will skip @factory and move to the

   * next factory.

   *

   * >   The signal handler will not be invoked if any of the previously

   * >   registered signal handlers (if any) return a value other than

   * >   GST_AUTOPLUG_SELECT_TRY. Which also means that if you return

   * >   GST_AUTOPLUG_SELECT_TRY from one signal handler, handlers that get

   * >   registered next (again, if any) can override that decision.

   *

   * Returns: a #GST_TYPE_AUTOPLUG_SELECT_RESULT that indicates the required

   * operation. The default handler will always return

   * #GST_AUTOPLUG_SELECT_TRY.

   */

  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,

      g_cclosure_marshal_generic,

      GST_TYPE_AUTOPLUG_SELECT_RESULT, 3, GST_TYPE_PAD, GST_TYPE_CAPS,

      GST_TYPE_ELEMENT_FACTORY);

  /**

   * GstDecodeBin::autoplug-query:

   * @bin: The decodebin.

   * @child: The child element doing the query

   * @pad: The #GstPad.

   * @query: The #GstQuery.

   *

   * This signal is emitted whenever an autoplugged element that is

   * not linked downstream yet and not exposed does a query. It can

   * be used to tell the element about the downstream supported caps

   * for example.

   *

   * Returns: %TRUE if the query was handled, %FALSE otherwise.

   */

  gst_uri_decode_bin_signals[SIGNAL_AUTOPLUG_QUERY] =

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

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstURIDecodeBinClass, autoplug_query),

      _gst_boolean_or_accumulator, NULL, g_cclosure_marshal_generic,

      G_TYPE_BOOLEAN, 3, GST_TYPE_PAD, GST_TYPE_ELEMENT,

      GST_TYPE_QUERY | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

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

      g_cclosure_marshal_generic, G_TYPE_NONE, 0, G_TYPE_NONE);

  /**

   * GstURIDecodeBin::source-setup:

   * @bin: the uridecodebin.

   * @source: source element

   *

   * This signal is emitted after the source element has been created, so

   * it can be configured by setting additional properties (e.g. set a

   * proxy server for an http source, or set the device and read speed for

   * an audio cd source). This is functionally equivalent to connecting to

   * the notify::source signal, but more convenient.

   */

  gst_uri_decode_bin_signals[SIGNAL_SOURCE_SETUP] =

      g_signal_new ("source-setup", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL,

      g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);

  gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);

  gst_element_class_set_static_metadata (gstelement_class,

      "URI Decoder", "Generic/Bin/Decoder",

      "Autoplug and decode an URI to raw media",

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

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

  klass->autoplug_factories =

      GST_DEBUG_FUNCPTR (gst_uri_decode_bin_autoplug_factories);

  klass->autoplug_sort = GST_DEBUG_FUNCPTR (gst_uri_decode_bin_autoplug_sort);

  klass->autoplug_select =

      GST_DEBUG_FUNCPTR (gst_uri_decode_bin_autoplug_select);

  klass->autoplug_query = GST_DEBUG_FUNCPTR (gst_uri_decode_bin_autoplug_query);

}

static void

gst_uri_decode_bin_init (GstURIDecodeBin * dec)

{

  /* first filter out the interesting element factories */

  g_mutex_init (&dec->factories_lock);

  g_mutex_init (&dec->lock);

  dec->uri = g_strdup (DEFAULT_PROP_URI);

  dec->connection_speed = DEFAULT_CONNECTION_SPEED;

  dec->caps = DEFAULT_CAPS;

  dec->encoding = g_strdup (DEFAULT_SUBTITLE_ENCODING);

  dec->buffer_duration = DEFAULT_BUFFER_DURATION;

  dec->buffer_size = DEFAULT_BUFFER_SIZE;

  dec->download = DEFAULT_DOWNLOAD;

  dec->use_buffering = DEFAULT_USE_BUFFERING;

  dec->expose_allstreams = DEFAULT_EXPOSE_ALL_STREAMS;

  dec->ring_buffer_max_size = DEFAULT_RING_BUFFER_MAX_SIZE;

  GST_OBJECT_FLAG_SET (dec, GST_ELEMENT_FLAG_SOURCE);

  gst_bin_set_suppressed_flags (GST_BIN (dec),

      GST_ELEMENT_FLAG_SOURCE | GST_ELEMENT_FLAG_SINK);

}

static void

gst_uri_decode_bin_finalize (GObject * obj)

{

  GstURIDecodeBin *dec = GST_URI_DECODE_BIN (obj);

  remove_decoders (dec, TRUE);

  g_mutex_clear (&dec->lock);

  g_mutex_clear (&dec->factories_lock);

  g_free (dec->uri);

  g_free (dec->encoding);

  if (dec->factories)

    gst_plugin_feature_list_free (dec->factories);

  if (dec->caps)

    gst_caps_unref (dec->caps);

  G_OBJECT_CLASS (parent_class)->finalize (obj);

}

static void

gst_uri_decode_bin_set_encoding (GstURIDecodeBin * dec, const gchar * encoding)

{

  GSList *walk;

  GST_URI_DECODE_BIN_LOCK (dec);

  /* set property first */

  GST_OBJECT_LOCK (dec);

  g_free (dec->encoding);

  dec->encoding = g_strdup (encoding);

  GST_OBJECT_UNLOCK (dec);

  /* set the property on all decodebins now */

  for (walk = dec->decodebins; walk; walk = g_slist_next (walk)) {

    GObject *decodebin = G_OBJECT (walk->data);

    g_object_set (decodebin, "subtitle-encoding", encoding, NULL);

  }

  GST_URI_DECODE_BIN_UNLOCK (dec);

}

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_uint64 (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:

      gst_uri_decode_bin_set_encoding (dec, g_value_get_string (value));

      break;

    case PROP_BUFFER_SIZE:

      dec->buffer_size = g_value_get_int (value);

      break;

    case PROP_BUFFER_DURATION:

      dec->buffer_duration = g_value_get_int64 (value);

      break;

    case PROP_DOWNLOAD:

      dec->download = g_value_get_boolean (value);

      break;

    case PROP_USE_BUFFERING:

      dec->use_buffering = g_value_get_boolean (value);

      break;

    case PROP_EXPOSE_ALL_STREAMS:

      dec->expose_allstreams = g_value_get_boolean (value);

      break;

    case PROP_RING_BUFFER_MAX_SIZE:

      dec->ring_buffer_max_size = g_value_get_uint64 (value);

      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_SOURCE:

      GST_OBJECT_LOCK (dec);

      g_value_set_object (value, dec->source);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_CONNECTION_SPEED:

      GST_OBJECT_LOCK (dec);

      g_value_set_uint64 (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;

    case PROP_BUFFER_SIZE:

      GST_OBJECT_LOCK (dec);

      g_value_set_int (value, dec->buffer_size);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_BUFFER_DURATION:

      GST_OBJECT_LOCK (dec);

      g_value_set_int64 (value, dec->buffer_duration);

      GST_OBJECT_UNLOCK (dec);

      break;

    case PROP_DOWNLOAD:

      g_value_set_boolean (value, dec->download);

      break;

    case PROP_USE_BUFFERING:

      g_value_set_boolean (value, dec->use_buffering);

      break;

    case PROP_EXPOSE_ALL_STREAMS:

      g_value_set_boolean (value, dec->expose_allstreams);

      break;

    case PROP_RING_BUFFER_MAX_SIZE:

      g_value_set_uint64 (value, dec->ring_buffer_max_size);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}