FCL/sf/mw/gstreamer: comparison gst_plugins_base/gst/playback/gsturidecodebin.c

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 * Boston, MA 02111-1307, USA.
 */
 /**
 * SECTION:element-uridecodebin
+* @short_description: decoder for an uri
 *
 * Decodes data from a URI into raw media.
 */
 #ifdef HAVE_CONFIG_H
 #include <string.h>
 #include <gst/gst.h>
 #include <gst/gst-i18n-plugin.h>
-#include "gstfactorylists.h"
 #include "gstplay-marshal.h"
 #include "gstplay-enum.h"
+#ifdef __SYMBIAN32__
+#include <glib_global.h>
+#endif
 #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_GET_LOCK(dec) (((GstURIDecodeBin*)(dec))->lock)
-#define GST_URI_DECODE_BIN_LOCK(dec) (g_mutex_lock(GST_URI_DECODE_BIN_GET_LOCK(dec)))
-#define GST_URI_DECODE_BIN_UNLOCK(dec) (g_mutex_unlock(GST_URI_DECODE_BIN_GET_LOCK(dec)))
-/**
-* GstURIDecodeBin
-*
-* uridecodebin element struct
-*/
 struct _GstURIDecodeBin
 {
 GstBin parent_instance;
-GMutex *lock;                 /* lock for constructing */
-GValueArray *factories;       /* factories we can use for selecting elements */
 gchar *uri;
 guint connection_speed;
 GstCaps *caps;
 gchar *encoding;
 gboolean is_stream;
-gboolean need_queue;
-guint64 buffer_duration;      /* When streaming, buffer duration (ns) */
-guint buffer_size;            /* When streaming, buffer size (bytes) */
-gboolean download;
 GstElement *source;
-GstElement *typefind;
+GstElement *queue;
-guint have_type_id;           /* have-type signal id from typefind */
+GSList *decoders;
-GSList *decodebins;
 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;
-gboolean async_pending;       /* async-start has been emited */
 };
 struct _GstURIDecodeBinClass
 {
 GstBinClass parent_class;
 LAST_SIGNAL
 };
 /* properties */
 #define DEFAULT_PROP_URI	    NULL
-#define DEFAULT_PROP_SOURCE	    NULL
 #define DEFAULT_CONNECTION_SPEED    0
 #define DEFAULT_CAPS                NULL
 #define DEFAULT_SUBTITLE_ENCODING   NULL
-#define DEFAULT_BUFFER_DURATION     -1
-#define DEFAULT_BUFFER_SIZE         -1
-#define DEFAULT_DOWNLOAD            FALSE
 enum
 {
 PROP_0,
 PROP_URI,
-PROP_SOURCE,
 PROP_CONNECTION_SPEED,
 PROP_CAPS,
 PROP_SUBTITLE_ENCODING,
-PROP_BUFFER_SIZE,
-PROP_BUFFER_DURATION,
-PROP_DOWNLOAD,
 PROP_LAST
 };
 static guint gst_uri_decode_bin_signals[LAST_SIGNAL] = { 0 };
 {
 /* by default we always continue */
 return TRUE;
 }
-static GValueArray *
-gst_uri_decode_bin_autoplug_factories (GstElement * element, GstPad * pad,
-GstCaps * caps)
-{
-GValueArray *result;
-GST_DEBUG_OBJECT (element, "finding factories");
-/* return all compatible factories for caps */
-result =
-gst_factory_list_filter (GST_URI_DECODE_BIN_CAST (element)->factories,
-caps);
-GST_DEBUG_OBJECT (element, "autoplug-factories returns %p", result);
-return result;
-}
 static void
 gst_uri_decode_bin_class_init (GstURIDecodeBinClass * klass)
 {
 GObjectClass *gobject_class;
 GstElementClass *gstelement_class;
 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));
+DEFAULT_PROP_URI, G_PARAM_READWRITE));
-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_object_class_install_property (gobject_class, PROP_CONNECTION_SPEED,
 g_param_spec_uint ("connection-speed", "Connection Speed",
 "Network connection speed in kbps (0 = unknown)",
-0, G_MAXUINT / 1000, DEFAULT_CONNECTION_SPEED,
+0, G_MAXUINT, DEFAULT_CONNECTION_SPEED, G_PARAM_READWRITE));
-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));
+GST_TYPE_CAPS, G_PARAM_READWRITE));
 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,
+"ISO-8859-15 will be assumed.", NULL, G_PARAM_READWRITE));
-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 network streams",
--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 network streams",
--1, G_MAXINT64, DEFAULT_BUFFER_DURATION,
-G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
-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::unknown-type:
-* @bin: The uridecodebin
+* @pad: the new pad containing caps that cannot be resolved to a 'final' stream type.
-* @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, gst_marshal_VOID__OBJECT_BOXED, G_TYPE_NONE, 2,
+NULL, NULL, gst_marshal_VOID__OBJECT_OBJECT, 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.
 */
 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_play_marshal_BOOLEAN__OBJECT_BOXED, G_TYPE_BOOLEAN, 2, GST_TYPE_PAD,
+gst_play_marshal_BOOLEAN__OBJECT_OBJECT, G_TYPE_BOOLEAN, 2, GST_TYPE_PAD,
 GST_TYPE_CAPS);
 /**
 * GstURIDecodeBin::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. Uridecodebin will by default return an array with all
+* @pad is needed. Decodebin2 will by default return
-* 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_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_play_marshal_BOXED__OBJECT_BOXED, G_TYPE_VALUE_ARRAY, 2,
+gst_play_marshal_BOXED__OBJECT_OBJECT, G_TYPE_VALUE_ARRAY, 2,
 GST_TYPE_PAD, GST_TYPE_CAPS);
 /**
 * GstURIDecodeBin::autoplug-select:
 * @pad: The #GstPad.
 * @caps: The #GstCaps.
-* @factory: A #GstElementFactory to use
+* @factories: A #GValueArray of possible #GstElementFactory to use, sorted by
+* rank (higher ranks come first).
 *
 * This signal is emitted once uridecodebin has found all the possible
-* #GstElementFactory that can be used to handle the given @caps. For each of
+* #GstElementFactory that can be used to handle the given @caps.
-* those factories, this signal is emited.
 *
-* The signal handler should return a #GST_TYPE_AUTOPLUG_SELECT_RESULT enum
+* Returns: A #gint indicating what factory index from the @factories array
-* value indicating what decodebin2 should do next.
+* that you wish uridecodebin to use for trying to decode the given @caps.
-*
+* -1 to stop selection of a factory. The default handler always
-* A value of #GST_AUTOPLUG_SELECT_TRY will try to autoplug an element from
+* returns the first possible factory.
-* @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.
-*
-* 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,
-gst_play_marshal_ENUM__OBJECT_BOXED_OBJECT,
+gst_play_marshal_ENUM__OBJECT_OBJECT_OBJECT,
 GST_TYPE_AUTOPLUG_SELECT_RESULT, 3, GST_TYPE_PAD, GST_TYPE_CAPS,
 GST_TYPE_ELEMENT_FACTORY);
 /**
 * GstURIDecodeBin::drained:
 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);
 }
 static void
 gst_uri_decode_bin_init (GstURIDecodeBin * dec, GstURIDecodeBinClass * klass)
 {
-/* first filter out the interesting element factories */
-dec->factories = gst_factory_list_get_elements (GST_FACTORY_LIST_DECODER);
-dec->lock = g_mutex_new ();
 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;
 }
 static void
 gst_uri_decode_bin_finalize (GObject * obj)
 {
 GstURIDecodeBin *dec = GST_URI_DECODE_BIN (obj);
-g_mutex_free (dec->lock);
 g_free (dec->uri);
 g_free (dec->encoding);
-if (dec->factories)
-g_value_array_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)
 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));
+GST_OBJECT_LOCK (dec);
-break;
+g_free (dec->encoding);
-case PROP_BUFFER_SIZE:
+dec->encoding = g_value_dup_string (value);
-dec->buffer_size = g_value_get_int (value);
+GST_OBJECT_UNLOCK (dec);
-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;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 break;
 }
 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_uint (value, dec->connection_speed / 1000);
 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;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 break;
-}
-}
-static void
-do_async_start (GstURIDecodeBin * dbin)
-{
-GstMessage *message;
-dbin->async_pending = TRUE;
-message = gst_message_new_async_start (GST_OBJECT_CAST (dbin), FALSE);
-parent_class->handle_message (GST_BIN_CAST (dbin), message);
-}
-static void
-do_async_done (GstURIDecodeBin * dbin)
-{
-GstMessage *message;
-if (dbin->async_pending) {
-GST_DEBUG_OBJECT (dbin, "posting ASYNC_DONE");
-message = gst_message_new_async_done (GST_OBJECT_CAST (dbin));
-parent_class->handle_message (GST_BIN_CAST (dbin), message);
-dbin->async_pending = FALSE;
 }
 }
 #define DEFAULT_QUEUE_SIZE          (3 * GST_SECOND)
 #define DEFAULT_QUEUE_MIN_THRESHOLD ((DEFAULT_QUEUE_SIZE * 30) / 100)
 gboolean final;
 /* setup phase */
 GST_DEBUG_OBJECT (element, "no more pads, %d pending", decoder->pending);
-GST_URI_DECODE_BIN_LOCK (decoder);
+GST_OBJECT_LOCK (decoder);
 final = (decoder->pending == 0);
 /* nothing pending, we can exit */
 if (final)
 goto done;
 decoder->pending--;
 final = (decoder->pending == 0);
 done:
-GST_URI_DECODE_BIN_UNLOCK (decoder);
+GST_OBJECT_UNLOCK (decoder);
 if (final)
 gst_element_no_more_pads (GST_ELEMENT_CAST (decoder));
 return;
 gchar *padname;
 GST_DEBUG_OBJECT (element, "new decoded pad, name: <%s>. Last: %d",
 GST_PAD_NAME (pad), last);
-GST_URI_DECODE_BIN_LOCK (decoder);
+GST_OBJECT_LOCK (decoder);
 padname = g_strdup_printf ("src%d", decoder->numpads);
 decoder->numpads++;
-GST_URI_DECODE_BIN_UNLOCK (decoder);
+GST_OBJECT_UNLOCK (decoder);
 newpad = gst_ghost_pad_new (padname, pad);
 g_free (padname);
 /* store ref to the ghostpad so we can remove it */
 {
 GstPad *ghost;
 GST_DEBUG_OBJECT (element, "pad removed name: <%s:%s>",
 GST_DEBUG_PAD_NAME (pad));
-/* we only care about srcpads */
-if (!GST_PAD_IS_SRC (pad))
-return;
 if (!(ghost = g_object_get_data (G_OBJECT (pad), "uridecodebin.ghostpad")))
 goto no_ghost;
 /* unghost the pad */
 return TRUE;
 }
 return FALSE;
 }
-static gboolean
-array_has_uri_value (const gchar * values[], const gchar * value)
-{
-gint i;
-for (i = 0; values[i]; i++) {
-if (!g_ascii_strncasecmp (value, values[i], strlen (values[i])))
-return TRUE;
-}
-return FALSE;
-}
 /* list of URIs that we consider to be streams and that need buffering.
 * We have no mechanism yet to figure this out with a query. */
 static const gchar *stream_uris[] = { "http://", "mms://", "mmsh://",
-"mmsu://", "mmst://", "fd://", NULL
+"mmsu://", "mmst://", NULL
 };
-/* list of URIs that need a queue because they are pretty bursty */
-static const gchar *queue_uris[] = { "cdda://", NULL };
 /* blacklisted URIs, we know they will always fail. */
 static const gchar *blacklisted_uris[] = { NULL };
 /* mime types that we don't consider to be media types */
 "application/x-executable", "application/x-bzip", "application/x-gzip",
 "application/zip", "application/x-compress", NULL
 };
 #endif
-/* media types we consider raw media */
+/* mime types we consider raw media */
-static const gchar *raw_media[] = {
+static const gchar *raw_mimes[] = {
-"audio/x-raw", "video/x-raw", "text/plain", "text/x-pango-markup",
+"audio/x-raw", "video/x-raw", NULL
-"video/x-dvd-subpicture", "subpicture/x-", NULL
 };
-/* media types we can download */
+#define IS_STREAM_URI(uri)          (array_has_value (stream_uris, uri))
-static const gchar *download_media[] = {
+#define IS_BLACKLISTED_URI(uri)     (array_has_value (blacklisted_uris, uri))
-"video/quicktime", "video/x-flv", NULL
-};
-#define IS_STREAM_URI(uri)          (array_has_uri_value (stream_uris, uri))
-#define IS_QUEUE_URI(uri)           (array_has_uri_value (queue_uris, uri))
-#define IS_BLACKLISTED_URI(uri)     (array_has_uri_value (blacklisted_uris, uri))
 #define IS_NO_MEDIA_MIME(mime)      (array_has_value (no_media_mimes, mime))
-#define IS_RAW_MEDIA(media)         (array_has_value (raw_media, media))
+#define IS_RAW_MIME(mime)           (array_has_value (raw_mimes, mime))
-#define IS_DOWNLOAD_MEDIA(media)    (array_has_value (download_media, media))
 /*
 * Generate and configure a source element.
 */
 static GstElement *
 GstElement *source;
 if (!decoder->uri)
 goto no_uri;
-GST_LOG_OBJECT (decoder, "finding source for %s", decoder->uri);
 if (!gst_uri_is_valid (decoder->uri))
 goto invalid_uri;
 if (IS_BLACKLISTED_URI (decoder->uri))
 goto uri_blacklisted;
 source = gst_element_make_from_uri (GST_URI_SRC, decoder->uri, "source");
 if (!source)
 goto no_source;
-GST_LOG_OBJECT (decoder, "found source type %s", G_OBJECT_TYPE_NAME (source));
 decoder->is_stream = IS_STREAM_URI (decoder->uri);
-GST_LOG_OBJECT (decoder, "source is stream: %d", decoder->is_stream);
-decoder->need_queue = IS_QUEUE_URI (decoder->uri);
-GST_LOG_OBJECT (decoder, "source needs queue: %d", decoder->need_queue);
 /* make HTTP sources send extra headers so we get icecast
 * metadata in case the stream is an icecast stream */
 if (!strncmp (decoder->uri, "http://", 7) &&
 g_object_class_find_property (G_OBJECT_GET_CLASS (source),
 "iradio-mode")) {
-GST_LOG_OBJECT (decoder, "configuring iradio-mode");
 g_object_set (source, "iradio-mode", TRUE, NULL);
 }
 if (g_object_class_find_property (G_OBJECT_GET_CLASS (source),
 "connection-speed")) {
 "setting connection-speed=%d to source element",
 decoder->connection_speed / 1000);
 g_object_set (source, "connection-speed",
 decoder->connection_speed / 1000, NULL);
 }
-if (g_object_class_find_property (G_OBJECT_GET_CLASS (source),
-"subtitle-encoding")) {
-GST_DEBUG_OBJECT (decoder,
-"setting subtitle-encoding=%s to source element", decoder->encoding);
-g_object_set (G_OBJECT (source), "subtitle-encoding", decoder->encoding,
-NULL);
-}
 return source;
 /* ERRORS */
 no_uri:
 {
 caps = gst_pad_get_caps (pad);
 if (caps == NULL)
 return FALSE;
-GST_DEBUG_OBJECT (pad, "have caps %" GST_PTR_FORMAT, caps);
 capssize = gst_caps_get_size (caps);
 /* no caps, skip and move to the next pad */
 if (capssize == 0 || gst_caps_is_empty (caps) || gst_caps_is_any (caps))
 goto done;
 /* count the number of raw formats in the caps */
 for (i = 0; i < capssize; ++i) {
 GstStructure *s;
-const gchar *media_type;
+const gchar *mime_type;
 s = gst_caps_get_structure (caps, i);
-media_type = gst_structure_get_name (s);
+mime_type = gst_structure_get_name (s);
-GST_DEBUG_OBJECT (pad, "check media-type %s", media_type);
+if (IS_RAW_MIME (mime_type))
-if (IS_RAW_MEDIA (media_type))
 ++num_raw;
 }
 *all_raw = (num_raw == capssize);
 res = TRUE;
 * analyse_source:
 * @decoder: a #GstURIDecodeBin
 * @is_raw: are all pads raw data
 * @have_out: does the source have output
 * @is_dynamic: is this a dynamic source
-* @use_queue: put a queue before raw output pads
 *
 * Check the source of @decoder and collect information about it.
 *
 * @is_raw will be set to TRUE if the source only produces raw pads. When this
 * function returns, all of the raw pad of the source will be added
 *
 * Returns: FALSE if a fatal error occured while scanning.
 */
 static gboolean
 analyse_source (GstURIDecodeBin * decoder, gboolean * is_raw,
-gboolean * have_out, gboolean * is_dynamic, gboolean use_queue)
+gboolean * have_out, gboolean * is_dynamic)
 {
 GstIterator *pads_iter;
 gboolean done = FALSE;
 gboolean res = TRUE;
 case GST_ITERATOR_OK:
 /* we now officially have an ouput pad */
 *have_out = TRUE;
 /* if FALSE, this pad has no caps and we continue with the next pad. */
-if (!has_all_raw_caps (pad, is_raw)) {
+if (!has_all_raw_caps (pad, is_raw))
-gst_object_unref (pad);
 break;
-}
 /* caps on source pad are all raw, we can add the pad */
-if (*is_raw) {
+if (*is_raw)
-GstElement *outelem;
+new_decoded_pad_cb (decoder->source, pad, FALSE, decoder);
-if (use_queue) {
-GstPad *sinkpad;
-/* insert a queue element right before the raw pad */
-outelem = gst_element_factory_make ("queue2", "queue");
-gst_bin_add (GST_BIN_CAST (decoder), outelem);
-sinkpad = gst_element_get_static_pad (outelem, "sink");
-gst_pad_link (pad, sinkpad);
-gst_object_unref (sinkpad);
-gst_object_unref (pad);
-/* get the new raw srcpad */
-pad = gst_element_get_static_pad (outelem, "src");
-} else {
-outelem = decoder->source;
-}
-new_decoded_pad_cb (outelem, pad, FALSE, decoder);
-}
-gst_object_unref (pad);
 break;
 }
 }
 gst_iterator_free (pads_iter);
 static void
 remove_decoders (GstURIDecodeBin * bin)
 {
 GSList *walk;
-for (walk = bin->decodebins; walk; walk = g_slist_next (walk)) {
+for (walk = bin->decoders; walk; walk = g_slist_next (walk)) {
 GstElement *decoder = GST_ELEMENT_CAST (walk->data);
 GST_DEBUG_OBJECT (bin, "removing old decoder element");
 gst_element_set_state (decoder, GST_STATE_NULL);
 gst_bin_remove (GST_BIN_CAST (bin), decoder);
 }
-g_slist_free (bin->decodebins);
+g_slist_free (bin->decoders);
-bin->decodebins = NULL;
+bin->decoders = NULL;
 }
 static void
 remove_pads (GstURIDecodeBin * bin)
 {
 static GValueArray *
 proxy_autoplug_factories_signal (GstElement * element, GstPad * pad,
 GstCaps * caps, GstURIDecodeBin * dec)
 {
-GValueArray *result;
+GValueArray *result = NULL;
 g_signal_emit (G_OBJECT (dec),
 gst_uri_decode_bin_signals[SIGNAL_AUTOPLUG_FACTORIES], 0, pad, caps,
 &result);
 g_signal_emit (G_OBJECT (dec),
 gst_uri_decode_bin_signals[SIGNAL_DRAINED], 0, NULL);
 }
-/* make a decodebin and connect to all the signals */
 static GstElement *
-make_decoder (GstURIDecodeBin * decoder)
+make_decoder (GstURIDecodeBin * decoder, gboolean use_queue)
 {
-GstElement *decodebin;
+GstElement *result, *decodebin;
-GST_LOG_OBJECT (decoder, "making new decodebin2");
 /* now create the decoder element */
 decodebin = gst_element_factory_make ("decodebin2", NULL);
 if (!decodebin)
 goto no_decodebin;
-/* configure caps if we have any */
-if (decoder->caps)
-g_object_set (decodebin, "caps", decoder->caps, NULL);
 /* connect signals to proxy */
 g_signal_connect (G_OBJECT (decodebin), "unknown-type",
 G_CALLBACK (proxy_unknown_type_signal), decoder);
 g_signal_connect (G_OBJECT (decodebin), "autoplug-continue",
 g_signal_connect (G_OBJECT (decodebin), "autoplug-select",
 G_CALLBACK (proxy_autoplug_select_signal), decoder);
 g_signal_connect (G_OBJECT (decodebin), "drained",
 G_CALLBACK (proxy_drained_signal), decoder);
+if (use_queue) {
+GstElement *queue;
+GstPad *gpad, *pad;
+queue = gst_element_factory_make ("queue2", NULL);
+if (!queue)
+goto no_queue2;
+/* configure the queue as a buffering element */
+g_object_set (G_OBJECT (queue), "use-buffering", TRUE, NULL);
+result = gst_bin_new ("source-bin");
+gst_bin_add (GST_BIN_CAST (result), queue);
+gst_bin_add (GST_BIN_CAST (result), decodebin);
+gst_element_link (queue, decodebin);
+pad = gst_element_get_pad (queue, "sink");
+gpad = gst_ghost_pad_new (GST_PAD_NAME (pad), pad);
+gst_object_unref (pad);
+gst_pad_set_active (gpad, TRUE);
+gst_element_add_pad (GST_ELEMENT_CAST (result), gpad);
+} else {
+result = decodebin;
+}
 /* set up callbacks to create the links between decoded data
 * and video/audio/subtitle rendering/output. */
 g_signal_connect (G_OBJECT (decodebin),
 "new-decoded-pad", G_CALLBACK (new_decoded_pad_cb), decoder);
 g_signal_connect (G_OBJECT (decodebin),
 g_signal_connect (G_OBJECT (decodebin), "no-more-pads",
 G_CALLBACK (no_more_pads), decoder);
 g_signal_connect (G_OBJECT (decodebin),
 "unknown-type", G_CALLBACK (unknown_type_cb), decoder);
 g_object_set_data (G_OBJECT (decodebin), "pending", "1");
-g_object_set (G_OBJECT (decodebin), "subtitle-encoding", decoder->encoding,
-NULL);
 decoder->pending++;
-GST_LOG_OBJECT (decoder, "have %d pending dynamic objects", decoder->pending);
+gst_bin_add (GST_BIN_CAST (decoder), result);
-gst_bin_add (GST_BIN_CAST (decoder), decodebin);
+decoder->decoders = g_slist_prepend (decoder->decoders, result);
-decoder->decodebins = g_slist_prepend (decoder->decodebins, decodebin);
+return result;
-return decodebin;
 /* ERRORS */
 no_decodebin:
 {
 GST_ELEMENT_ERROR (decoder, CORE, MISSING_PLUGIN,
 (_("Could not create \"decodebin2\" element.")), (NULL));
 return NULL;
 }
-}
-static void
-type_found (GstElement * typefind, guint probability,
-GstCaps * caps, GstURIDecodeBin * decoder)
-{
-GstElement *dec_elem, *queue;
-GstStructure *s;
-const gchar *media_type;
-GST_DEBUG_OBJECT (decoder, "typefind found caps %" GST_PTR_FORMAT, caps);
-dec_elem = make_decoder (decoder);
-if (!dec_elem)
-goto no_decodebin;
-queue = gst_element_factory_make ("queue2", NULL);
-if (!queue)
-goto no_queue2;
-g_object_set (G_OBJECT (queue), "use-buffering", TRUE, NULL);
-s = gst_caps_get_structure (caps, 0);
-media_type = gst_structure_get_name (s);
-GST_DEBUG_OBJECT (decoder, "check media-type %s, %d", media_type,
-decoder->download);
-if (IS_DOWNLOAD_MEDIA (media_type) && decoder->download) {
-gchar *temp_template, *filename;
-const gchar *tmp_dir, *prgname;
-tmp_dir = g_get_tmp_dir ();
-prgname = g_get_prgname ();
-if (prgname == NULL)
-prgname = "GStreamer";
-filename = g_strdup_printf ("%s-XXXXXX", prgname);
-/* build our filename */
-temp_template = g_build_filename (tmp_dir, filename, NULL);
-GST_DEBUG_OBJECT (decoder, "enable download buffering in %s (%s, %s, %s)",
-temp_template, tmp_dir, prgname, filename);
-/* configure progressive download for selected media types */
-g_object_set (G_OBJECT (queue), "temp-template", temp_template, NULL);
-g_free (filename);
-g_free (temp_template);
-}
-/* Disable max-size-buffers */
-g_object_set (G_OBJECT (queue), "max-size-buffers", 0, NULL);
-/* If buffer size or duration are set, set them on the queue2 element */
-if (decoder->buffer_size != -1)
-g_object_set (G_OBJECT (queue), "max-size-bytes",
-decoder->buffer_size, NULL);
-if (decoder->buffer_duration != -1)
-g_object_set (G_OBJECT (queue), "max-size-time",
-decoder->buffer_duration, NULL);
-gst_bin_add (GST_BIN_CAST (decoder), queue);
-if (!gst_element_link_pads (typefind, "src", queue, "sink"))
-goto could_not_link;
-/* to force caps on the decodebin element and avoid reparsing stuff by
-* typefind. It also avoids a deadlock in the way typefind activates pads in
-* the state change */
-g_object_set (G_OBJECT (dec_elem), "sink-caps", caps, NULL);
-if (!gst_element_link_pads (queue, "src", dec_elem, "sink"))
-goto could_not_link;
-gst_element_set_state (dec_elem, GST_STATE_PLAYING);
-gst_element_set_state (queue, GST_STATE_PLAYING);
-do_async_done (decoder);
-return;
-/* ERRORS */
-no_decodebin:
-{
-/* error was posted */
-return;
-}
-could_not_link:
-{
-GST_ELEMENT_ERROR (decoder, CORE, NEGOTIATION,
-(NULL), ("Can't link typefind to decodebin2 element"));
-return;
-}
 no_queue2:
 {
 GST_ELEMENT_ERROR (decoder, CORE, MISSING_PLUGIN,
 (_("Could not create \"queue2\" element.")), (NULL));
-return;
+return NULL;
-}
-}
-/* setup a streaming source. This will first plug a typefind element to the
-* source. After we find the type, we decide to plug a queue2 and continue to
-* plug a decodebin2 starting from the found caps */
-static gboolean
-setup_streaming (GstURIDecodeBin * decoder)
-{
-GstElement *typefind;
-/* now create the decoder element */
-typefind = gst_element_factory_make ("typefind", NULL);
-if (!typefind)
-goto no_typefind;
-gst_bin_add (GST_BIN_CAST (decoder), typefind);
-if (!gst_element_link (decoder->source, typefind))
-goto could_not_link;
-decoder->typefind = typefind;
-/* connect a signal to find out when the typefind element found
-* a type */
-decoder->have_type_id =
-g_signal_connect (G_OBJECT (decoder->typefind), "have-type",
-G_CALLBACK (type_found), decoder);
-do_async_start (decoder);
-return TRUE;
-/* ERRORS */
-no_typefind:
-{
-GST_ELEMENT_ERROR (decoder, CORE, MISSING_PLUGIN,
-(_("Could not create \"typefind\" element.")), (NULL));
-return FALSE;
-}
-could_not_link:
-{
-GST_ELEMENT_ERROR (decoder, CORE, NEGOTIATION,
-(NULL), ("Can't link source to typefind element"));
-return FALSE;
 }
 }
 static void
 remove_source (GstURIDecodeBin * bin)
 source_new_pad (GstElement * element, GstPad * pad, GstURIDecodeBin * bin)
 {
 GstElement *decoder;
 gboolean is_raw;
-GST_URI_DECODE_BIN_LOCK (bin);
 GST_DEBUG_OBJECT (bin, "Found new pad %s.%s in source element %s",
 GST_DEBUG_PAD_NAME (pad), GST_ELEMENT_NAME (element));
 /* if this is a pad with all raw caps, we can expose it */
 if (has_all_raw_caps (pad, &is_raw) && is_raw) {
 /* it's all raw, create output pads. */
-GST_URI_DECODE_BIN_UNLOCK (bin);
 new_decoded_pad_cb (element, pad, FALSE, bin);
 return;
 }
 /* not raw, create decoder */
-decoder = make_decoder (bin);
+decoder = make_decoder (bin, FALSE);
 if (!decoder)
 goto no_decodebin;
 /* and link to decoder */
 if (!gst_element_link (bin->source, decoder))
 goto could_not_link;
 GST_DEBUG_OBJECT (bin, "linked decoder to new pad");
 gst_element_set_state (decoder, GST_STATE_PLAYING);
-GST_URI_DECODE_BIN_UNLOCK (bin);
 return;
 /* ERRORS */
 no_decodebin:
 {
 /* error was posted */
-GST_URI_DECODE_BIN_UNLOCK (bin);
 return;
 }
 could_not_link:
 {
 GST_ELEMENT_ERROR (bin, CORE, NEGOTIATION,
 (NULL), ("Can't link source to decoder element"));
-GST_URI_DECODE_BIN_UNLOCK (bin);
 return;
 }
 }
 /* construct and run the source and decoder elements until we found
 GST_DEBUG_OBJECT (decoder, "setup source");
 /* delete old src */
 remove_source (decoder);
-decoder->pending = 0;
 /* create and configure an element that can handle the uri */
 if (!(decoder->source = gen_source_element (decoder)))
 goto no_source;
 /* state will be merged later - if file is not found, error will be
 * handled by the application right after. */
 gst_bin_add (GST_BIN_CAST (decoder), decoder->source);
-/* notify of the new source used */
-g_object_notify (G_OBJECT (decoder), "source");
 /* remove the old decoders now, if any */
 remove_decoders (decoder);
 /* see if the source element emits raw audio/video all by itself,
 * if so, we can create streams for the pads and be done with it.
 * Also check that is has source pads, if not, we assume it will
 * do everything itself.  */
-if (!analyse_source (decoder, &is_raw, &have_out, &is_dynamic,
+if (!analyse_source (decoder, &is_raw, &have_out, &is_dynamic))
-decoder->need_queue))
 goto invalid_source;
 if (is_raw) {
 GST_DEBUG_OBJECT (decoder, "Source provides all raw data");
 /* source provides raw data, we added the pads and we can now signal a
 * no_more pads because we are done. */
-gst_element_no_more_pads (GST_ELEMENT_CAST (decoder));
+/* FIXME, actually do this... */
 return TRUE;
 }
 if (!have_out && !is_dynamic) {
 GST_DEBUG_OBJECT (decoder, "Source has no output pads");
 /* create a stream to indicate that this uri is handled by a self
 g_signal_connect (G_OBJECT (decoder->source), "no-more-pads",
 G_CALLBACK (source_no_more_pads), decoder);
 g_object_set_data (G_OBJECT (decoder->source), "pending", "1");
 decoder->pending++;
 } else {
-if (decoder->is_stream) {
+GstElement *dec_elem;
-GST_DEBUG_OBJECT (decoder, "Setting up streaming");
-/* do the stream things here */
+GST_DEBUG_OBJECT (decoder, "Pluggin decodebin to source");
-if (!setup_streaming (decoder))
-goto streaming_failed;
+/* no dynamic source, we can link now */
-} else {
+dec_elem = make_decoder (decoder, decoder->is_stream);
-GstElement *dec_elem;
+if (!dec_elem)
+goto no_decoder;
-/* no streaming source, we can link now */
-GST_DEBUG_OBJECT (decoder, "Plugging decodebin to source");
+if (!gst_element_link (decoder->source, dec_elem))
+goto could_not_link;
-dec_elem = make_decoder (decoder);
-if (!dec_elem)
-goto no_decoder;
-if (!gst_element_link (decoder->source, dec_elem))
-goto could_not_link;
-}
 }
 return TRUE;
 /* ERRORS */
 no_source:
 GST_ELEMENT_ERROR (decoder, CORE, FAILED,
 (_("Source element is invalid.")), (NULL));
 return FALSE;
 }
 no_decoder:
-{
-/* message was posted */
-return FALSE;
-}
-streaming_failed:
 {
 /* message was posted */
 return FALSE;
 }
 could_not_link:
 fold->max = duration;
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 decoder_query_duration_done (GstURIDecodeBin * dec, QueryFold * fold)
 {
 GstFormat format;
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 decoder_query_position_done (GstURIDecodeBin * dec, QueryFold * fold)
 {
 GstFormat format;
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 decoder_query_latency_done (GstURIDecodeBin * dec, QueryFold * fold)
 {
 /* store max in query result */
 gst_query_set_latency (fold->query, fold->live, fold->min, fold->max);
 }
 gst_object_unref (item);
 return TRUE;
 }
 static void
 decoder_query_seeking_done (GstURIDecodeBin * dec, QueryFold * fold)
 {
 GstFormat format;
 case GST_STATE_CHANGE_PAUSED_TO_READY:
 GST_DEBUG ("paused to ready");
 remove_decoders (decoder);
 remove_pads (decoder);
 remove_source (decoder);
-do_async_done (decoder);
-break;
-case GST_STATE_CHANGE_READY_TO_NULL:
-GST_DEBUG ("ready to null");
-remove_decoders (decoder);
-remove_pads (decoder);
-remove_source (decoder);
 break;
 default:
 break;
 }
 return ret;
 #ifdef ENABLE_NLS
 GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
 LOCALEDIR);
 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
-bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 #endif /* ENABLE_NLS */
 return gst_element_register (plugin, "uridecodebin", GST_RANK_NONE,
 GST_TYPE_URI_DECODE_BIN);
 }

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3