FCL/sf/mw/gstreamer: comparison gstreamer_core/plugins/elements/gsttypefindelement.c

equal deleted inserted replaced

-:9b2c3c7a1a9c
+:567bb019e3e3
 * 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-typefind
+*
+* Determines the media-type of a stream. It applies typefind functions in the
+* order of their rank. One the type has been deteted it sets its src pad caps
+* to the found media type.
+*
+* Plugins can register custom typefinders by using #GstTypeFindFactory.
+*/
 /* FIXME: need a better solution for non-seekable streams */
 /* way of operation:
 * 1) get a list of all typefind functions sorted best to worst
 * 2) if all elements have been called with all requested data goto 8
 * 3) call all functions once with all available data
-* 4) if a function returns a value >= ARG_MAXIMUM goto 8
+* 4) if a function returns a value >= PROP_MAXIMUM goto 8
-* 5) all functions with a result > ARG_MINIMUM or functions that did not get
+* 5) all functions with a result > PROP_MINIMUM or functions that did not get
 *    all requested data (where peek returned NULL) stay in list
 * 6) seek to requested offset of best function that still has open data
 *    requests
 * 7) goto 2
 * 8) take best available result and use its caps
 */
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
-#ifdef __SYMBIAN32__
-#include <gst_global.h>
-#endif
 #include "gsttypefindelement.h"
 #include "gst/gst_private.h"
 #include "gst/gst-i18n-lib.h"
 #include "gst/base/gsttypefindhelper.h"
 HAVE_TYPE,
 LAST_SIGNAL
 };
 enum
 {
-ARG_0,
+PROP_0,
-ARG_CAPS,
+PROP_CAPS,
-ARG_MINIMUM,
+PROP_MINIMUM,
-ARG_MAXIMUM
+PROP_MAXIMUM,
+PROP_FORCE_CAPS,
+PROP_LAST
 };
 enum
 {
 MODE_NORMAL,                  /* act as identity */
 MODE_TYPEFIND,                /* do typefinding  */
 gst_type_find_element_have_type (GstTypeFindElement * typefind,
 guint probability, const GstCaps * caps)
 {
 g_assert (caps != NULL);
-GST_INFO_OBJECT (typefind, "found caps %" GST_PTR_FORMAT, caps);
+GST_INFO_OBJECT (typefind, "found caps %" GST_PTR_FORMAT ", probability=%u",
+caps, probability);
 if (typefind->caps)
 gst_caps_unref (typefind->caps);
 typefind->caps = gst_caps_copy (caps);
 gst_pad_set_caps (typefind->src, (GstCaps *) caps);
 }
 GST_DEBUG_FUNCPTR (gst_type_find_element_get_property);
 gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_type_find_element_dispose);
 typefind_class->have_type = gst_type_find_element_have_type;
-g_object_class_install_property (gobject_class, ARG_CAPS,
+g_object_class_install_property (gobject_class, PROP_CAPS,
 g_param_spec_boxed ("caps", _("caps"),
 _("detected capabilities in stream"), gst_caps_get_type (),
-G_PARAM_READABLE));
+G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
-g_object_class_install_property (gobject_class, ARG_MINIMUM,
+g_object_class_install_property (gobject_class, PROP_MINIMUM,
 g_param_spec_uint ("minimum", _("minimum"),
 "minimum probability required to accept caps", GST_TYPE_FIND_MINIMUM,
-GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM, G_PARAM_READWRITE));
+GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM,
-g_object_class_install_property (gobject_class, ARG_MAXIMUM,
+G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+g_object_class_install_property (gobject_class, PROP_MAXIMUM,
 g_param_spec_uint ("maximum", _("maximum"),
 "probability to stop typefinding (deprecated; non-functional)",
 GST_TYPE_FIND_MINIMUM, GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MAXIMUM,
-G_PARAM_READWRITE));
+G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+g_object_class_install_property (gobject_class, PROP_FORCE_CAPS,
+g_param_spec_boxed ("force-caps", _("force caps"),
+_("force caps without doing a typefind"), gst_caps_get_type (),
+G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 /**
 * GstTypeFindElement::have-type:
 * @typefind: the typefind instance
 * @probability: the probability of the type found
 * @caps: the caps of the type found
 G_TYPE_UINT, GST_TYPE_CAPS | G_SIGNAL_TYPE_STATIC_SCOPE);
 gstelement_class->change_state =
 GST_DEBUG_FUNCPTR (gst_type_find_element_change_state);
 }
 static void
 gst_type_find_element_init (GstTypeFindElement * typefind,
 GstTypeFindElementClass * g_class)
 {
 /* sinkpad */
 typefind->min_probability = 1;
 typefind->max_probability = GST_TYPE_FIND_MAXIMUM;
 typefind->store = NULL;
 }
 static void
 gst_type_find_element_dispose (GObject * object)
 {
 GstTypeFindElement *typefind = GST_TYPE_FIND_ELEMENT (object);
-G_OBJECT_CLASS (parent_class)->dispose (object);
 if (typefind->store) {
 gst_buffer_unref (typefind->store);
 typefind->store = NULL;
 }
-}
+if (typefind->force_caps) {
+gst_caps_unref (typefind->force_caps);
+typefind->force_caps = NULL;
+}
+G_OBJECT_CLASS (parent_class)->dispose (object);
+}
 static void
 gst_type_find_element_set_property (GObject * object, guint prop_id,
 const GValue * value, GParamSpec * pspec)
 {
 GstTypeFindElement *typefind;
 typefind = GST_TYPE_FIND_ELEMENT (object);
 switch (prop_id) {
-case ARG_MINIMUM:
+case PROP_MINIMUM:
 typefind->min_probability = g_value_get_uint (value);
 break;
-case ARG_MAXIMUM:
+case PROP_MAXIMUM:
 typefind->max_probability = g_value_get_uint (value);
+break;
+case PROP_FORCE_CAPS:
+GST_OBJECT_LOCK (typefind);
+if (typefind->force_caps)
+gst_caps_unref (typefind->force_caps);
+typefind->force_caps = g_value_dup_boxed (value);
+GST_OBJECT_UNLOCK (typefind);
 break;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 break;
 }
 }
 static void
 gst_type_find_element_get_property (GObject * object, guint prop_id,
 GValue * value, GParamSpec * pspec)
 {
 GstTypeFindElement *typefind;
 typefind = GST_TYPE_FIND_ELEMENT (object);
 switch (prop_id) {
-case ARG_CAPS:
+case PROP_CAPS:
 g_value_set_boxed (value, typefind->caps);
 break;
-case ARG_MINIMUM:
+case PROP_MINIMUM:
 g_value_set_uint (value, typefind->min_probability);
 break;
-case ARG_MAXIMUM:
+case PROP_MAXIMUM:
 g_value_set_uint (value, typefind->max_probability);
+break;
+case PROP_FORCE_CAPS:
+GST_OBJECT_LOCK (typefind);
+g_value_set_boxed (value, typefind->force_caps);
+GST_OBJECT_UNLOCK (typefind);
 break;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 break;
 }
 gst_query_parse_position (query, &format, &peer_pos);
 /* FIXME: this code assumes that there's no discont in the queue */
 switch (format) {
 case GST_FORMAT_BYTES:
-peer_pos -= typefind->store->size;
+peer_pos -= GST_BUFFER_SIZE (typefind->store);
 break;
 default:
 /* FIXME */
 break;
 }
 if (typefind->mode != MODE_NORMAL) {
 /* need to do more? */
 gst_mini_object_unref (GST_MINI_OBJECT (event));
 return FALSE;
 }
-return gst_pad_event_default (pad, event);
+return gst_pad_push_event (typefind->sink, event);
 }
 static void
 start_typefinding (GstTypeFindElement * typefind)
 {
 (_("Stream contains no data.")),
 ("Can't typefind empty stream"));
 }
 stop_typefinding (typefind);
-res = gst_pad_event_default (pad, event);
+res = gst_pad_push_event (typefind->src, event);
 break;
 }
+case GST_EVENT_FLUSH_STOP:
+g_list_foreach (typefind->cached_events,
+(GFunc) gst_mini_object_unref, NULL);
+g_list_free (typefind->cached_events);
+typefind->cached_events = NULL;
+gst_buffer_replace (&typefind->store, NULL);
+/* fall through */
+case GST_EVENT_FLUSH_START:
+res = gst_pad_push_event (typefind->src, event);
+break;
 default:
 GST_DEBUG_OBJECT (typefind, "Saving %s event to send later",
 GST_EVENT_TYPE_NAME (event));
 typefind->cached_events =
 g_list_append (typefind->cached_events, event);
 res = TRUE;
 break;
 }
 break;
 case MODE_NORMAL:
-res = gst_pad_event_default (pad, event);
+res = gst_pad_push_event (typefind->src, event);
 break;
 case MODE_ERROR:
 break;
 default:
 g_assert_not_reached ();
 typefind->store = NULL;
 }
 }
 return TRUE;
+}
+static GstCaps *
+gst_type_find_guess_by_extension (GstTypeFindElement * typefind, GstPad * pad,
+GstTypeFindProbability * probability)
+{
+GstQuery *query;
+gchar *uri;
+size_t len;
+gint find;
+GstCaps *caps;
+query = gst_query_new_uri ();
+/* try getting the caps with an uri query and from the extension */
+if (!gst_pad_peer_query (pad, query))
+goto peer_query_failed;
+gst_query_parse_uri (query, &uri);
+if (uri == NULL)
+goto no_uri;
+GST_DEBUG_OBJECT (typefind, "finding extension of %s", uri);
+/* find the extension on the uri, this is everything after a '.' */
+len = strlen (uri);
+find = len - 1;
+while (find >= 0) {
+if (uri[find] == '.')
+break;
+find--;
+}
+if (find < 0)
+goto no_extension;
+GST_DEBUG_OBJECT (typefind, "found extension %s", &uri[find + 1]);
+caps =
+gst_type_find_helper_for_extension (GST_OBJECT_CAST (typefind),
+&uri[find + 1]);
+if (caps)
+*probability = GST_TYPE_FIND_MAXIMUM;
+gst_query_unref (query);
+return caps;
+/* ERRORS */
+peer_query_failed:
+{
+GST_WARNING_OBJECT (typefind, "failed to query peer uri");
+gst_query_unref (query);
+return NULL;
+}
+no_uri:
+{
+GST_WARNING_OBJECT (typefind, "could not parse the peer uri");
+gst_query_unref (query);
+return NULL;
+}
+no_extension:
+{
+GST_WARNING_OBJECT (typefind, "could not find uri extension in %s", uri);
+gst_query_unref (query);
+return NULL;
+}
 }
 static GstFlowReturn
 gst_type_find_element_chain (GstPad * pad, GstBuffer * buffer)
 {
 GstCaps *found_caps = NULL;
 GstTypeFindElement *typefind;
 typefind = GST_TYPE_FIND_ELEMENT (GST_OBJECT_PARENT (pad));
+/* if we have force caps, use those */
+if (typefind->force_caps) {
+found_caps = gst_caps_ref (typefind->force_caps);
+probability = GST_TYPE_FIND_MAXIMUM;
+goto done;
+}
 /* 1. try to activate in pull mode. if not, switch to push and succeed.
 2. try to pull type find.
 3. deactivate pull mode.
 4. src pad might have been activated push by the state change. deactivate.
-5. if we didn't find any caps, fail.
+5. if we didn't find any caps, try getting the uri extension by doing an uri
-6. emit have-type; maybe the app connected the source pad to something.
+query.
-7. if the sink pad is activated, we are in pull mode. succeed.
+6. if we didn't find any caps, fail.
+7. emit have-type; maybe the app connected the source pad to something.
+8. if the sink pad is activated, we are in pull mode. succeed.
 otherwise activate both pads in push mode and succeed.
 */
 /* 1 */
 if (!gst_pad_check_pull_range (pad) || !gst_pad_activate_pull (pad, TRUE)) {
 gint64 size;
 GstFormat format = GST_FORMAT_BYTES;
 if (!gst_pad_query_duration (peer, &format, &size)) {
 GST_WARNING_OBJECT (typefind, "Could not query upstream length!");
+gst_object_unref (peer);
 return FALSE;
 }
-if (size > 0) {
+/* the size if 0, we cannot continue */
-found_caps = gst_type_find_helper_get_range (GST_OBJECT_CAST (peer),
+if (size == 0) {
-(GstTypeFindHelperGetRangeFunction) (GST_PAD_GETRANGEFUNC (peer)),
-(guint64) size, &probability);
-} else {
 /* keep message in sync with message in sink event handler */
 GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND,
 (_("Stream contains no data.")), ("Can't typefind empty stream"));
+gst_object_unref (peer);
+return FALSE;
 }
+found_caps = gst_type_find_helper_get_range (GST_OBJECT_CAST (peer),
+(GstTypeFindHelperGetRangeFunction) (GST_PAD_GETRANGEFUNC (peer)),
+(guint64) size, &probability);
 gst_object_unref (peer);
 }
 }
 /* 4 */
 gst_pad_activate_push (typefind->src, FALSE);
 /* 5 */
+if (!found_caps || probability < typefind->min_probability) {
+found_caps = gst_type_find_guess_by_extension (typefind, pad, &probability);
+}
+/* 6 */
 if (!found_caps || probability < typefind->min_probability) {
 GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
 gst_caps_replace (&found_caps, NULL);
 return FALSE;
 }
-/* 6 */
+done:
+/* 7 */
 g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE],
 0, probability, found_caps);
 gst_caps_unref (found_caps);
 typefind->mode = MODE_NORMAL;
-/* 7 */
+/* 8 */
 if (gst_pad_is_active (pad))
 return TRUE;
 else {
 gboolean ret;
 switch (transition) {
 case GST_STATE_CHANGE_PAUSED_TO_READY:
 case GST_STATE_CHANGE_READY_TO_NULL:
 gst_caps_replace (&typefind->caps, NULL);
 g_list_foreach (typefind->cached_events,
 (GFunc) gst_mini_object_unref, NULL);
 g_list_free (typefind->cached_events);
 typefind->cached_events = NULL;
 break;

branch	RCL_3
changeset 29	567bb019e3e3
parent 0	0e761a78d257
child 30	7e817e7e631c