diff options
| -rw-r--r-- | gst-libs/gst/media-info/Makefile.am | 3 | ||||
| -rw-r--r-- | gst-libs/gst/media-info/media-info-priv.c | 641 | ||||
| -rw-r--r-- | gst-libs/gst/media-info/media-info-priv.h | 122 | ||||
| -rw-r--r-- | gst-libs/gst/media-info/media-info-test.c | 24 | ||||
| -rw-r--r-- | gst-libs/gst/media-info/media-info.c | 797 | ||||
| -rw-r--r-- | gst-libs/gst/media-info/media-info.h | 40 |
6 files changed, 1042 insertions, 585 deletions
diff --git a/gst-libs/gst/media-info/Makefile.am b/gst-libs/gst/media-info/Makefile.am index 5216ec40..4842bbe9 100644 --- a/gst-libs/gst/media-info/Makefile.am +++ b/gst-libs/gst/media-info/Makefile.am @@ -2,7 +2,7 @@ librarydir = $(libdir) library_LTLIBRARIES = libgstmedia-info-@GST_MAJORMINOR@.la -libgstmedia_info_@GST_MAJORMINOR@_la_SOURCES = media-info.c +libgstmedia_info_@GST_MAJORMINOR@_la_SOURCES = media-info.c media-info-priv.c libincludedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/media-info libinclude_HEADERS = media-info.h @@ -11,6 +11,7 @@ libgstmedia_info_@GST_MAJORMINOR@_la_CFLAGS = $(GST_CFLAGS) $(GST_PLUGIN_CFLAGS) libgstmedia_info_@GST_MAJORMINOR@_la_LIBADD = $(GST_LIBS) $(GST_PLUGIN_LIBS) noinst_PROGRAMS = media-info-test +noinst_HEADERS = media-info-priv.h media_info_test_SOURCES = media-info-test.c media_info_test_CFLAGS = $(GST_CFLAGS) diff --git a/gst-libs/gst/media-info/media-info-priv.c b/gst-libs/gst/media-info/media-info-priv.c new file mode 100644 index 00000000..7c776701 --- /dev/null +++ b/gst-libs/gst/media-info/media-info-priv.c @@ -0,0 +1,641 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu> + * + * 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. + */ + +/* media-info-priv.c - handling of internal stuff */ + +#include <gst/gst.h> +#include <string.h> +#include "media-info.h" +#include "media-info-priv.h" + + +/* helper structs bits */ +GstMediaInfoStream * +gmi_stream_new (void) +{ + GstMediaInfoStream *stream; + + stream = (GstMediaInfoStream *) g_malloc (sizeof (GstMediaInfoStream)); + + stream->length_tracks = 0; + stream->length_time = 0; + stream->bitrate = 0; + stream->seekable = FALSE; + stream->path = NULL; + stream->mime = NULL; + stream->tracks = NULL; + + return stream; +} + +void +gmi_stream_free (GstMediaInfoStream *stream) +{ + if (stream->mime) g_free (stream->mime); + /* FIXME: free tracks */ + g_free (stream); +} + +GstMediaInfoTrack * +gmi_track_new (void) +{ + GstMediaInfoTrack *track; + + track = g_malloc (sizeof (GstMediaInfoTrack)); + + track->metadata = NULL; + track->streaminfo = NULL; + track->format = NULL; + track->length_time = 0; + track->con_streams = NULL; + + return track; +} + +/** + * private functions + */ + +/* callbacks */ +static void +have_type_callback (GstElement *typefind, GstCaps *type, GstMediaInfoPriv *priv) +{ + priv->type = type; +} + +void +deep_notify_callback (GObject *object, GstObject *origin, + GParamSpec *pspec, GstMediaInfoPriv *priv) +{ + GValue value = { 0, }; + + if (strcmp (pspec->name, "metadata") == 0) + { + GMI_DEBUG("DEBUG: deep_notify: have metadata !\n"); + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (origin), pspec->name, &value); + priv->metadata = g_value_peek_pointer (&value); + } + else if (strcmp (pspec->name, "caps") == 0) + { + /* check if we're getting it from the source we want it from */ + if (GST_IS_PAD (origin) && GST_PAD (origin) == priv->decoder_pad) + { + GMI_DEBUG("DEBUG: deep_notify: have caps on decoder_pad !\n"); + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (origin), pspec->name, &value); + priv->format = g_value_peek_pointer (&value); + } + else GMI_DEBUG("DEBUG: igoring caps on object %s:%s\n", + gst_object_get_name (gst_object_get_parent (origin)), + gst_object_get_name (origin)); + } + else if (strcmp (pspec->name, "offset") == 0) + { + /* we REALLY ignore offsets, we hate them */ + } + else if (strcmp (pspec->name, "streaminfo") == 0) + { + GMI_DEBUG("DEBUG: deep_notify: have streaminfo !\n"); + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (origin), pspec->name, &value); + priv->streaminfo = g_value_peek_pointer (&value); + } + else GMI_DEBUG("DEBUG: ignoring notify of %s\n", pspec->name); +} + +/* helpers */ + +/* reset info to a state where it can be used to query for media info + * clear caps, metadata, and so on */ +void +gmi_reset (GstMediaInfo *info) +{ + GstMediaInfoPriv *priv = info->priv; + /* clear out some stuff */ + if (priv->format) + { + GMI_DEBUG ("unreffing priv->format, error before this ?\n"); + gst_caps_unref (priv->format); + priv->format = NULL; + } + if (priv->metadata) + { + GMI_DEBUG ("unreffing priv->metadata, error before this ?\n"); + gst_caps_unref (priv->metadata); + priv->metadata = NULL; + } + if (priv->stream) + { + GMI_DEBUG ("freeing priv->stream, error before this ?\n"); + g_free (priv->stream); + priv->stream = NULL; + } + if (priv->location) + { + GMI_DEBUG ("freeing priv->location, error before this ?\n"); + g_free (priv->location); + priv->location = NULL; + } + priv->flags = 0; + priv->state = GST_MEDIA_INFO_STATE_NULL; +} + +/* seek to a track and reset metadata and streaminfo structs */ +gboolean +gmi_seek_to_track (GstMediaInfo *info, long track) +{ + GstEvent *event; + GstFormat track_format = 0; + GstMediaInfoPriv *priv = info->priv; + gboolean res; + + /* FIXME: consider more nicks as "track" */ + track_format = gst_format_get_by_nick ("logical_stream"); + if (track_format == 0) return FALSE; + GMI_DEBUG("Track format: %d\n", track_format); + + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + g_warning ("Couldn't set to play"); + g_assert (GST_IS_PAD (info->priv->decoder_pad)); + event = gst_event_new_seek (track_format | + GST_SEEK_METHOD_SET | + GST_SEEK_FLAG_FLUSH, + track); + res = gst_pad_send_event (info->priv->decoder_pad, event); + if (!res) + { + g_warning ("seek to logical track on pad %s:%s failed of element %s", + GST_DEBUG_PAD_NAME(info->priv->decoder_pad), + gst_element_get_factory((gst_pad_get_parent(info->priv->decoder_pad)))->details->longname); + return FALSE; + } + /* clear structs because of the seek */ + if (priv->metadata) + { + gst_caps_unref (priv->metadata); + priv->metadata = NULL; + } + if (priv->streaminfo) + { + gst_caps_unref (priv->streaminfo); + priv->streaminfo = NULL; + } + return TRUE; +} + +/* create a good decoder for this mime type */ +/* FIXME: maybe make this more generic with a type, so it can be used + * for taggers and other things as well */ +GstElement * +gmi_get_decoder (GstMediaInfo *info, const char *mime) +{ + GstElement *decoder; + gchar *factory = NULL; + + /* check if we have an active codec element in the hash table for this */ + decoder = g_hash_table_lookup (info->priv->decoders, mime); + if (decoder == NULL) + { + GMI_DEBUG("DEBUG: no decoder in table, inserting one\n"); + /* FIXME: please figure out proper mp3 mimetypes */ + if ((strcmp (mime, "application/x-ogg") == 0) || + (strcmp (mime, "application/ogg") == 0)) + factory = g_strdup ("vorbisfile"); + else if ((strcmp (mime, "audio/mpeg") == 0) || + (strcmp (mime, "audio/x-mp3") == 0) || + (strcmp (mime, "audio/mp3") == 0)) + factory = g_strdup ("mad"); + else if (strcmp (mime, "application/x-flac") == 0) + factory = g_strdup ("flacdec"); + else if (strcmp (mime, "audio/x-wav") == 0) + factory = g_strdup ("wavparse"); + else if (strcmp (mime, "audio/x-mod") == 0 || + strcmp (mime, "audio/x-s3m") == 0 || + strcmp (mime, "audio/x-xm") == 0 || + strcmp (mime, "audio/x-it") == 0) + factory = g_strdup ("modplug"); + + if (factory == NULL) + return NULL; + + GMI_DEBUG("DEBUG: using factory %s\n", factory); + decoder = gst_element_factory_make (factory, "decoder"); + g_free (factory); + + if (decoder) + { + g_hash_table_insert (info->priv->decoders, g_strdup (mime), decoder); + /* ref it so we don't lose it when removing from bin */ + g_object_ref (GST_OBJECT (decoder)); + } + } + return decoder; +} + +/* set the decoder to be used for decoding + * install callback handlers + */ +void +gmi_set_decoder (GstMediaInfo *info, GstElement *decoder) +{ + GstMediaInfoPriv *priv = info->priv; + + /* set up pipeline and connect signal handlers */ + priv->decoder = decoder; + gst_bin_add (GST_BIN (priv->pipeline), decoder); + if (!gst_element_link (priv->source, decoder)) + g_warning ("Couldn't connect source and decoder\n"); + /* FIXME: we should be connecting to ALL possible src pads */ + if (!(priv->decoder_pad = gst_element_get_pad (decoder, "src"))) + g_warning ("Couldn't get decoder pad\n"); + if (!(priv->source_pad = gst_element_get_pad (priv->source, "src"))) + g_warning ("Couldn't get source pad\n"); +} + +/* clear the decoder (if it was set) + */ +void +gmi_clear_decoder (GstMediaInfo *info) +{ + if (info->priv->decoder) + { + /* clear up decoder */ + /* FIXME: shouldn't need to set state here */ + gst_element_set_state (info->priv->pipeline, GST_STATE_READY); + gst_element_unlink (info->priv->source, info->priv->decoder); + gst_bin_remove (GST_BIN (info->priv->pipeline), info->priv->decoder); + info->priv->decoder = NULL; + } +} + +/**** + * typefind functions + * find the type of a file and store it in the caps of the info + * FIXME: we might better return GstCaps instead of storing them + * internally */ + +/* prepare for typefind, move from NULL to TYPEFIND */ +gboolean +gmip_find_type_pre (GstMediaInfoPriv *priv) +{ + /* clear vars that need clearing */ + if (priv->type) + { + /* we don't need to unref, this is done inside gsttypefind.c + gst_caps_unref (priv->type); + */ + priv->type = NULL; + } + + GMI_DEBUG("DEBUG: gmip_find_type_pre: start\n"); + /* find out type */ + /* FIXME: we could move caps for typefind out of struct and + * just use it through this function only */ + + gst_bin_add (GST_BIN (priv->pipeline), priv->typefind); + g_object_set (G_OBJECT (priv->source), "location", priv->location, NULL); + if (!gst_element_link (priv->source, priv->typefind)) + g_warning ("Couldn't connect source and typefind\n"); + g_signal_connect (G_OBJECT (priv->typefind), "have-type", + G_CALLBACK (have_type_callback), priv); + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + { + g_warning ("Couldn't set to play"); + return FALSE; + } + priv->state = GST_MEDIA_INFO_STATE_TYPEFIND; + return TRUE; +} + +/* finish off typefind */ +gboolean +gmip_find_type_post (GstMediaInfoPriv *priv) +{ + /*clear up typefind */ + gst_element_set_state (priv->pipeline, GST_STATE_READY); + gst_element_unlink (priv->source, priv->typefind); + gst_bin_remove (GST_BIN (priv->pipeline), priv->typefind); + + if (priv->type == NULL) + { + g_warning ("iteration ended, type not found !\n"); + return FALSE; + } + priv->state = GST_MEDIA_INFO_STATE_STREAM; + return TRUE; +} + +/* complete version */ +gboolean +gmip_find_type (GstMediaInfoPriv *priv) +{ + if (!gmip_find_type_pre (priv)) + return FALSE; + GMI_DEBUG("DEBUG: gmip_find_type: iterating\n"); + while ((priv->type == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + GMI_DEBUG("+"); + GMI_DEBUG("\n"); + return gmip_find_type_post (priv); +} + +/* FIXME: why not have these functions work on priv types ? */ +gboolean +gmip_find_stream_pre (GstMediaInfoPriv *priv) +{ + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + { + g_warning ("Couldn't set to play"); + return FALSE; + } + priv->state = GST_MEDIA_INFO_STATE_STREAM; + return TRUE; +} + +gboolean +gmip_find_stream_post (GstMediaInfoPriv *priv) +{ + GstMediaInfoStream *stream = priv->stream; + const GstFormat *formats; + GstFormat track_format = 0; + GstFormat format; + gint64 value; + gboolean res; + glong bytes = 0; + + + GMI_DEBUG("gmip_find_stream_post: start\n"); + /* find a format that matches the "track" concept */ + /* FIXME: this is used in vorbis, but we might have to loop when + * more codecs have tracks */ + track_format = gst_format_get_by_nick ("logical_stream"); + + /* get supported formats on decoder pad */ + formats = gst_pad_get_formats (priv->decoder_pad); + while (*formats) + { + const GstFormatDefinition *definition; + + format = *formats; + + g_assert (GST_IS_PAD (priv->decoder_pad)); + definition = gst_format_get_details (*formats); + GMI_DEBUG("trying to figure out length for format %s\n", definition->nick); + + res = gst_pad_query (priv->decoder_pad, GST_QUERY_TOTAL, + &format, &value); + + if (res) + { + switch (format) + { + case GST_FORMAT_TIME: + stream->length_time = value; + GMI_DEBUG(" total %s: %lld\n", definition->nick, value); + break; + case GST_FORMAT_DEFAULT: + case GST_FORMAT_BYTES: + break; + default: + /* separation is necessary because track_format doesn't resolve to + * int */ + if (format == track_format) + { + stream->length_tracks = value; + GMI_DEBUG(" total %s: %lld\n", definition->nick, value); + } + else + GMI_DEBUG("unhandled format %s\n", definition->nick); + } + } + else + GMI_DEBUG("query didn't return result for %s\n", definition->nick); + + formats++; + } + if (stream->length_tracks == 0) stream->length_tracks = 1; + /* now get number of bytes from the sink pad to get the bitrate */ + format = GST_FORMAT_BYTES; + g_assert (GST_IS_PAD (priv->source_pad)); + res = gst_pad_query (priv->source_pad, GST_QUERY_TOTAL, + &format, &value); + if (!res) g_warning ("Failed to query on sink pad !"); + bytes = value; + GMI_DEBUG("bitrate calc: bytes gotten: %ld\n", bytes); + + if (bytes) + { + double seconds = (double) stream->length_time / GST_SECOND; + double bits = bytes * 8; + stream->bitrate = (long) (bits / seconds); + } + priv->state = GST_MEDIA_INFO_STATE_METADATA; /* metadata of first track */ + return TRUE; +} + +/* get properties of complete physical stream + * and return them in pre-alloced stream struct in priv->stream */ +gboolean +gmip_find_stream (GstMediaInfoPriv *priv) +{ + GMI_DEBUG("DEBUG:gmip_find_stream start\n"); + + gmip_find_stream_pre (priv); + /* iterate until caps are found */ + /* FIXME: this should be done through the plugin sending some signal + * that it is ready for queries */ + while (gst_bin_iterate (GST_BIN (priv->pipeline)) && + priv->format == NULL) + ; + if (gst_element_set_state (priv->pipeline, GST_STATE_PAUSED) + == GST_STATE_FAILURE) + g_warning ("Couldn't set to paused"); + + if (priv->format == NULL) + { + GMI_DEBUG("DEBUG: gmip_find_stream: couldn't get caps !"); + return FALSE; + } + return gmip_find_stream_post (priv); +} + +/* find metadata encoded in media and store in priv->metadata */ +gboolean +gmip_find_track_metadata_pre (GstMediaInfoPriv *priv) +{ + /* FIXME: this is a hack to set max allowed iterations for metadata + * querying - we should make gst smarter by itself instead */ + priv->metadata_iters = 0; + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + { + g_warning ("Couldn't set to play"); + return FALSE; + } + return TRUE; +} + +gboolean +gmip_find_track_metadata_post (GstMediaInfoPriv *priv) +{ + if (gst_element_set_state (priv->pipeline, GST_STATE_PAUSED) + == GST_STATE_FAILURE) + return FALSE; + priv->current_track->metadata = priv->metadata; + priv->metadata = NULL; + return TRUE; +} + +gboolean +gmip_find_track_metadata (GstMediaInfoPriv *priv) +{ + gmip_find_track_metadata_pre (priv); + GMI_DEBUG("DEBUG: gmip_find_metadata: iterating\n"); + while ((priv->metadata == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + GMI_DEBUG("+"); + GMI_DEBUG("\n"); + gmip_find_track_metadata_post (priv); + + return TRUE; +} + +/* find streaminfo found by decoder and store in priv->streaminfo */ +/* FIXME: this is an exact copy, so reuse this functioin instead */ +gboolean +gmip_find_track_streaminfo_pre (GstMediaInfoPriv *priv) +{ + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + { + g_warning ("Couldn't set to play"); + return FALSE; + } + return TRUE; +} + +gboolean +gmip_find_track_streaminfo_post (GstMediaInfoPriv *priv) +{ + GstFormat format, track_format; + + gst_element_set_state (priv->pipeline, GST_STATE_PAUSED); + + /* now add total length to this, and maybe even bitrate ? FIXME */ + track_format = gst_format_get_by_nick ("logical_stream"); + if (track_format == 0) + { + g_print ("FIXME: implement getting length of whole track\n"); + } + else + { + /* which one are we at ? */ + long track_num; + gint64 value_start, value_end; + gboolean res; + + res = gst_pad_query (priv->decoder_pad, GST_QUERY_POSITION, + &track_format, &value_start); + if (res) + { + format = GST_FORMAT_TIME; + track_num = value_start; + GMI_DEBUG("DEBUG: we are currently at %ld\n", track_num); + res = gst_pad_convert (priv->decoder_pad, + track_format, track_num, + &format, &value_start); + res &= gst_pad_convert (priv->decoder_pad, + track_format, track_num + 1, + &format, &value_end); + if (res) + { + GstPropsEntry *length; + /* substract to get the length */ + GMI_DEBUG("DEBUG: start %lld, end %lld\n", value_start, value_end); + value_end -= value_start; + /* FIXME: check units; this is in seconds */ + length = gst_props_entry_new ("length", + GST_PROPS_INT ((int) (value_end / 1E6))); + gst_props_add_entry (gst_caps_get_props (priv->streaminfo), length); + } + } + } + priv->current_track->streaminfo = priv->streaminfo; + priv->streaminfo = NULL; + + return TRUE; +} + +gboolean +gmip_find_track_streaminfo (GstMediaInfoPriv *priv) +{ + gmip_find_track_streaminfo_pre (priv); + GMI_DEBUG("DEBUG: gmip_find_streaminfo: iterating\n"); + while ((priv->streaminfo == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + GMI_DEBUG("+"); + GMI_DEBUG("\n"); + gmip_find_track_streaminfo_post (priv); + + return TRUE; +} + +/* find format found by decoder and store in priv->format */ +gboolean +gmip_find_track_format_pre (GstMediaInfoPriv *priv) +{ + if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) + == GST_STATE_FAILURE) + { + g_warning ("Couldn't set to play"); + return FALSE; + } + return TRUE; +} + +gboolean +gmip_find_track_format_post (GstMediaInfoPriv *priv) +{ + if (gst_element_set_state (priv->pipeline, GST_STATE_PAUSED) + == GST_STATE_FAILURE) + return FALSE; + priv->current_track->format = priv->format; + priv->format = NULL; + return TRUE; +} + +gboolean +gmip_find_track_format (GstMediaInfoPriv *priv) +{ + gmip_find_track_format_pre (priv); + GMI_DEBUG("DEBUG: gmip_find_format: iterating\n"); + while ((priv->format == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + GMI_DEBUG("+"); + GMI_DEBUG("\n"); + gmip_find_track_format_post (priv); + + return TRUE; +} + + diff --git a/gst-libs/gst/media-info/media-info-priv.h b/gst-libs/gst/media-info/media-info-priv.h new file mode 100644 index 00000000..3e7a598c --- /dev/null +++ b/gst-libs/gst/media-info/media-info-priv.h @@ -0,0 +1,122 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu> + * + * 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. + */ + +/* media-info-priv.h: private stuff */ + +#ifndef __GST_MEDIA_INFO_PRIV_H__ +#define __GST_MEDIA_INFO_PRIV_H__ + +#include <gst/gst.h> + +/* debug */ +#define DEBUG +#ifdef DEBUG +static gboolean _gmi_debug = TRUE; +#else +static gboolean _gmi_debug = FALSE; +#endif + +#define GMI_DEBUG(format, args...) \ + { if (_gmi_debug) { g_print ( format , ## args ); }} + + +/* state machine enum; FIXME: can we move this to priv.c ? */ +typedef enum +{ + GST_MEDIA_INFO_STATE_NULL, + GST_MEDIA_INFO_STATE_TYPEFIND, + GST_MEDIA_INFO_STATE_STREAM, + GST_MEDIA_INFO_STATE_METADATA, + GST_MEDIA_INFO_STATE_STREAMINFO, + GST_MEDIA_INFO_STATE_FORMAT, + GST_MEDIA_INFO_STATE_DONE +} GstMediaInfoState; + +/* private structure */ +struct GstMediaInfoPriv +{ + GstElement *pipeline; + + GstElement *typefind; + + GstCaps *type; + GstPad *decoder_pad; /* pad for querying decoded caps */ + GstPad *source_pad; /* pad for querying encoded caps */ + + GstCaps *format; + GstCaps *metadata; + gint metadata_iters; + GstCaps *streaminfo; + + GstElement *decoder; /* will be != NULL during collection */ + gchar *source_element; /* type of element used as source */ + GstElement *source; + + GHashTable *decoders; /* a table of decoder GstElements */ + + GstMediaInfoState state; /* current state of state machine */ + gchar *location; /* location set on the info object */ + guint16 flags; /* flags supplied for detection */ + GstMediaInfoTrack *current_track; /* track pointer under inspection */ + glong current_track_num; /* current track under inspection */ + + GstMediaInfoStream *stream; /* total stream properties */ + char *cache; /* location of cache */ +}; + +/* declarations */ +GstMediaInfoStream * + gmi_stream_new (void); +void gmi_stream_free (GstMediaInfoStream *stream); + +GstMediaInfoTrack * + gmi_track_new (void); + +void gmi_reset (GstMediaInfo *info); +gboolean gmi_seek_to_track (GstMediaInfo *info, + long track); + +GstElement * gmi_get_decoder (GstMediaInfo *info, + const char *mime); +void gmi_set_decoder (GstMediaInfo *info, + GstElement *decoder); +void gmi_clear_decoder (GstMediaInfo *info); + +void deep_notify_callback (GObject *object, + GstObject *origin, + GParamSpec *pspec, + GstMediaInfoPriv *priv); + +gboolean gmip_find_type_pre (GstMediaInfoPriv *priv); +gboolean gmip_find_type_post (GstMediaInfoPriv *priv); +gboolean gmip_find_type (GstMediaInfoPriv *priv); +gboolean gmip_find_stream_pre (GstMediaInfoPriv *priv); +gboolean gmip_find_stream_post (GstMediaInfoPriv *priv); +gboolean gmip_find_stream (GstMediaInfoPriv *priv); +gboolean gmip_find_track_metadata_pre (GstMediaInfoPriv *priv); +gboolean gmip_find_track_metadata_post (GstMediaInfoPriv *priv); +gboolean gmip_find_track_metadata (GstMediaInfoPriv *priv); +gboolean gmip_find_track_streaminfo_pre (GstMediaInfoPriv *priv); +gboolean gmip_find_track_streaminfo_post (GstMediaInfoPriv *priv); +gboolean gmip_find_track_streaminfo (GstMediaInfoPriv *priv); +gboolean gmip_find_track_format_pre (GstMediaInfoPriv *priv); +gboolean gmip_find_track_format_post (GstMediaInfoPriv *priv); +gboolean gmip_find_track_format (GstMediaInfoPriv *priv); + +#endif /* __GST_MEDIA_INFO_PRIV_H__ */ diff --git a/gst-libs/gst/media-info/media-info-test.c b/gst-libs/gst/media-info/media-info-test.c index 916d8d77..553e97c6 100644 --- a/gst-libs/gst/media-info/media-info-test.c +++ b/gst-libs/gst/media-info/media-info-test.c @@ -62,11 +62,16 @@ info_print (GstMediaInfoStream *stream) GstMediaInfoTrack *track; g_print ("- mime type: %s\n", stream->mime); - g_print ("- length: %.3f seconds\n", + g_print ("- length: %.3f seconds\n", (gdouble) stream->length_time / GST_SECOND); g_print ("- bitrate: %.3f kbps\n", stream->bitrate / 1000.0); g_print ("- number of tracks: %ld\n", stream->length_tracks); p = stream->tracks; + if (p == NULL) + { + g_print ("- no track information, probably an error\n"); + return; + } for (i = 0; i < stream->length_tracks; ++i) { g_print ("- track %d\n", i); @@ -85,23 +90,32 @@ int main (int argc, char *argv[]) { GstMediaInfo *info; - GstMediaInfoStream *stream; + GstMediaInfoStream *stream = NULL; gint i; - + g_assert (argc > 1); gst_init (&argc, &argv); info = g_object_new (GST_MEDIA_INFO_TYPE, NULL); + g_print ("stream: %p, &stream: %p\n", stream, &stream); for (i = 1; i < argc; ++i) { + + /* stream = gst_media_info_read (info, argv[i], GST_MEDIA_INFO_ALL); + */ + gst_media_info_read_with_idler (info, argv[i], GST_MEDIA_INFO_ALL); + while (gst_media_info_read_idler (info, &stream) && stream == NULL) + /* keep idling */ g_print ("+"); g_print ("\nFILE: %s\n", argv[i]); + g_print ("stream: %p, &stream: %p\n", stream, &stream); if (stream) info_print (stream); else g_print ("no media info found.\n"); + stream = NULL; } - - return 0; + + return 0; } diff --git a/gst-libs/gst/media-info/media-info.c b/gst-libs/gst/media-info/media-info.c index 4be9c241..b559463d 100644 --- a/gst-libs/gst/media-info/media-info.c +++ b/gst-libs/gst/media-info/media-info.c @@ -20,102 +20,19 @@ #include <gst/gst.h> #include <string.h> #include "media-info.h" +#include "media-info-priv.h" -static gboolean _gst_media_info_debug = TRUE; - -#ifdef G_HAVE_ISO_VARARGS -#define GMI_DEBUG(...) \ - G_STMT_START { \ - if (_gst_media_info_debug) { g_print ( __VA_ARGS__ ); } \ - } G_STMT_END -#elif defined(G_HAVE_GNUC_VARARGS) -#define GMI_DEBUG(format, args...) \ - G_STMT_START { \ - if (_gst_media_info_debug) { g_print ( format , ## args ); } \ - } G_STMT_END -#else -#error Variable argument macros not supported by compiler -#endif - - -struct GstMediaInfoPriv -{ - GstElement *pipeline; - - GstElement *typefind; - - GstCaps *type; - GstPad *decoder_pad; /* pad for querying decoded caps */ - GstPad *source_pad; /* pad for querying encoded caps */ - - GstCaps *format; - GstCaps *metadata; - GstCaps *streaminfo; - - GstElement *decoder; /* will be != NULL during collection */ - gchar *source_element; /* type of element used as source */ - GstElement *source; - - GHashTable *decoders; /* a table of decoder GstElements */ - - GstMediaInfoStream *stream; /* total stream properties */ - char *cache; /* location of cache */ -}; - -static void gst_media_info_class_init (GstMediaInfoClass *klass); -static void gst_media_info_instance_init (GstMediaInfo *info); +static void gst_media_info_class_init (GstMediaInfoClass *klass); +static void gst_media_info_instance_init (GstMediaInfo *info); static void gst_media_info_get_property (GObject *object, guint prop_id, - GValue *value, GParamSpec *pspec); - - -static void gst_media_info_reset (GstMediaInfo *info); - -static void deep_notify_callback (GObject *object, GstObject *origin, - GParamSpec *pspec, GstMediaInfo *info); - -/* helper structs bits */ -static GstMediaInfoStream * -gst_media_info_stream_new (void) -{ - GstMediaInfoStream *stream; - - stream = g_malloc (sizeof (GstMediaInfoStream)); - - stream->length_tracks = 0; - stream->length_time = 0; - stream->bitrate = 0; - stream->seekable = FALSE; - stream->path = NULL; - stream->mime = NULL; - stream->tracks = NULL; - - return stream; -} - -static void -gst_media_info_stream_free (GstMediaInfoStream *stream) -{ - if (stream->mime) g_free (stream->mime); - /* FIXME: free tracks */ - g_free (stream); -} - -static GstMediaInfoTrack * -gst_media_info_track_new (void) -{ - GstMediaInfoTrack *track; + GValue *value, + GParamSpec *pspec); - track = g_malloc (sizeof (GstMediaInfoTrack)); - track->metadata = NULL; - track->streaminfo = NULL; - track->format = NULL; - track->length_time = 0; - track->con_streams = NULL; +/* FIXME: this is a lousy hack that needs to go */ +#define MAX_METADATA_ITERS 5 - return track; -} /* GObject-y bits */ /* signal stuff */ @@ -146,7 +63,7 @@ gst_media_info_error_quark (void) } */ /* - * GObject type stuff + * GObject type stuff */ enum @@ -173,9 +90,9 @@ gst_media_info_get_type (void) (GInstanceInitFunc) gst_media_info_instance_init, NULL }; - gst_media_info_type = g_type_register_static (G_TYPE_OBJECT, + gst_media_info_type = g_type_register_static (G_TYPE_OBJECT, "GstMediaInfo", - &gst_media_info_info, 0); + &gst_media_info_info, 0); } return gst_media_info_type; } @@ -184,7 +101,7 @@ static void gst_media_info_class_init (GstMediaInfoClass *klass) { GObjectClass *g_object_class = G_OBJECT_CLASS (klass); - + parent_class = g_type_class_ref (G_TYPE_OBJECT); //parent_class = g_type_class_peek_parent (klass); @@ -241,6 +158,7 @@ gst_media_info_instance_init (GstMediaInfo *info) info->priv->source = NULL; info->priv->source_element = NULL; } + info->priv->location = NULL; info->priv->decoder = NULL; info->priv->type = NULL; info->priv->format = NULL; @@ -254,7 +172,7 @@ gst_media_info_instance_init (GstMediaInfo *info) /* attach notify handler */ g_signal_connect (G_OBJECT (info->priv->pipeline), "deep_notify", - G_CALLBACK (deep_notify_callback), info); + G_CALLBACK (deep_notify_callback), info->priv); } /* get/set */ @@ -286,538 +204,294 @@ gst_media_info_new (const gchar *source_element) } /** - * private functions + * public methods */ - -/* callbacks */ -static void -have_type_callback (GstElement *typefind, GstCaps *type, GstMediaInfo *info) -{ - info->priv->type = type; -} - -static void -deep_notify_callback (GObject *object, GstObject *origin, - GParamSpec *pspec, GstMediaInfo *info) +gboolean +gst_media_info_set_source (GstMediaInfo *info, const char *source) { - GValue value = { 0, }; + GstElement *src; + src = gst_element_factory_make (source, "new-source"); + if (!GST_IS_ELEMENT (src)) + return FALSE; - if (strcmp (pspec->name, "metadata") == 0) - { - GMI_DEBUG("DEBUG: deep_notify: have metadata !\n"); - g_value_init (&value, pspec->value_type); - g_object_get_property (G_OBJECT (origin), pspec->name, &value); - info->priv->metadata = g_value_peek_pointer (&value); - } - else if (strcmp (pspec->name, "caps") == 0) + if (info->priv->source) { - /* check if we're getting it from the source we want it from */ - if (GST_IS_PAD (origin) && GST_PAD (origin) == info->priv->decoder_pad) + /* this also unrefs the element */ + gst_bin_remove (GST_BIN (info->priv->pipeline), info->priv->source); + if (info->priv->source_element) { - GMI_DEBUG("DEBUG: deep_notify: have caps on decoder_pad !\n"); - g_value_init (&value, pspec->value_type); - g_object_get_property (G_OBJECT (origin), pspec->name, &value); - info->priv->format = g_value_peek_pointer (&value); + g_free (info->priv->source_element); + info->priv->source_element = NULL; } - else GMI_DEBUG("DEBUG: igoring caps on object %s:%s\n", - gst_object_get_name (gst_object_get_parent (origin)), - gst_object_get_name (origin)); - } - else if (strcmp (pspec->name, "offset") == 0) - { - /* we REALLY ignore offsets, we hate them */ - } - else if (strcmp (pspec->name, "streaminfo") == 0) - { - GMI_DEBUG("DEBUG: deep_notify: have streaminfo !\n"); - g_value_init (&value, pspec->value_type); - g_object_get_property (G_OBJECT (origin), pspec->name, &value); - info->priv->streaminfo = g_value_peek_pointer (&value); - } - else GMI_DEBUG("DEBUG: ignoring notify of %s\n", pspec->name); -} - -/* helpers */ - -/* reset info to a state where it can be used to query for media info - * clear caps, metadata, and so on */ -static void -gst_media_info_reset (GstMediaInfo *info) -{ - GstMediaInfoPriv *priv = info->priv; - /* clear out some stuff */ - if (priv->format) - { - gst_caps_unref (priv->format); - priv->format = NULL; } - if (priv->metadata) - { - gst_caps_unref (priv->metadata); - priv->metadata = NULL; - } - if (priv->stream) - { - g_free (priv->stream); - priv->stream = NULL; - } -} + g_object_set (G_OBJECT (src), "name", "source", NULL); + gst_bin_add (GST_BIN (info->priv->pipeline), src); + info->priv->source = src; + info->priv->source_element = g_strdup (source); -/* seek to a track and reset metadata and streaminfo structs */ -static gboolean -gst_media_info_seek_to_track (GstMediaInfo *info, long track) -{ - GstEvent *event; - GstFormat track_format = 0; - GstMediaInfoPriv *priv = info->priv; - gboolean res; - - /* FIXME: consider more nicks as "track" */ - track_format = gst_format_get_by_nick ("logical_stream"); - if (track_format == 0) return FALSE; - GMI_DEBUG("Track format: %d\n", track_format); - - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - g_assert (GST_IS_PAD (info->priv->decoder_pad)); - event = gst_event_new_seek (track_format | - GST_SEEK_METHOD_SET | - GST_SEEK_FLAG_FLUSH, - track); - res = gst_pad_send_event (info->priv->decoder_pad, event); - g_assert (res); - if (!res) - { - g_warning ("seek to logical track failed"); - return FALSE; - } - /* clear structs because of the seek */ - if (priv->metadata) - { - gst_caps_unref (priv->metadata); - priv->metadata = NULL; - } - if (priv->streaminfo) - { - gst_caps_unref (priv->streaminfo); - priv->streaminfo = NULL; - } return TRUE; } -/* create a good decoder for this mime type */ -/* FIXME: maybe make this more generic with a type, so it can be used - * for taggers and other things as well */ -GstElement * -gst_media_info_get_decoder (GstMediaInfo *info, const char *mime) -{ - GstElement *decoder; - gchar *factory = NULL; - - /* check if we have an active codec element in the hash table for this */ - decoder = g_hash_table_lookup (info->priv->decoders, mime); - if (decoder == NULL) - { - GMI_DEBUG("DEBUG: no decoder in table, inserting one\n"); - if (strcmp (mime, "application/x-ogg") == 0) - factory = g_strdup ("vorbisfile"); - else if (strcmp (mime, "audio/x-mp3") == 0) - factory = g_strdup ("mad"); - else if (strcmp (mime, "audio/x-wav") == 0) - factory = g_strdup ("wavparse"); - - if (factory == NULL) - return NULL; - - GMI_DEBUG("DEBUG: using factory %s\n", factory); - decoder = gst_element_factory_make (factory, "decoder"); - g_free (factory); - - if (decoder) - { - g_hash_table_insert (info->priv->decoders, g_strdup (mime), decoder); - /* ref it so we don't lose it when removing from bin */ - g_object_ref (GST_OBJECT (decoder)); - } - } - - return decoder; -} - -/* find the type of a file and store it in the caps of the info - * FIXME: we might better return GstCaps instead of storing them - * internally */ -static void -gst_media_info_find_type (GstMediaInfo *info, const char *location) +/* idler-based implementation + * set up read on a given location + * FIXME: maybe we should check if the info is cleared when calling this + * function ? What happens if it gets called again on same info before + * previous one is done ? + */ +void +gst_media_info_read_with_idler (GstMediaInfo *info, const char *location, + guint16 flags) { GstMediaInfoPriv *priv = info->priv; - /* clear vars that need clearing */ - if (priv->type) - { - gst_caps_unref (priv->type); - priv->type = NULL; - } - - GMI_DEBUG("DEBUG: gst_media_info_find_type: start\n"); - /* find out type */ - /* FIXME: we could move caps for typefind out of struct and - * just use it through this function only */ - - gst_bin_add (GST_BIN (priv->pipeline), priv->typefind); - g_object_set (G_OBJECT (priv->source), "location", location, NULL); - if (!gst_element_link (priv->source, priv->typefind)) - g_warning ("Couldn't link source and typefind\n"); - g_signal_connect (G_OBJECT (priv->typefind), "have-type", - G_CALLBACK (have_type_callback), info); - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - GMI_DEBUG("DEBUG: gst_media_info_find_type: iterating\n"); - while ((priv->type == NULL) && - gst_bin_iterate (GST_BIN (priv->pipeline))) - GMI_DEBUG("+"); - GMI_DEBUG("\n"); - - /*clear up typefind */ - gst_element_set_state (priv->pipeline, GST_STATE_READY); - gst_element_unlink (priv->source, priv->typefind); - gst_bin_remove (GST_BIN (priv->pipeline), priv->typefind); + gmi_reset (info); /* reset all structs */ + priv->location = g_strdup (location); + priv->flags = flags; } -/* get properties of complete physical stream - * and return them in pre-alloced stream struct */ -static gboolean -gst_media_info_get_stream (GstMediaInfo *info, GstMediaInfoStream *stream) + +/* an idler which does the work of actually collecting all data + * this must be called repeatedly, until streamp is set to a non-NULL value + * returns: TRUE if it was able to idle, FALSE if there was an error + */ +gboolean +gst_media_info_read_idler (GstMediaInfo *info, GstMediaInfoStream **streamp) { - GstMediaInfoPriv *priv = info->priv; - const GstFormat *formats; - GstFormat track_format = 0; - GstFormat format; - gint64 value; - gboolean res; - glong bytes = 0; - - GMI_DEBUG("DEBUG:gst_media_info_get_stream start\n"); - - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - /* iterate until caps are found */ - /* FIXME: this should be done through the plugin sending some signal - * that it is ready for queries */ - while (gst_bin_iterate (GST_BIN (priv->pipeline)) && - priv->format == NULL) - ; - if (gst_element_set_state (priv->pipeline, GST_STATE_PAUSED) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to paused"); - if (priv->format == NULL) - { - GMI_DEBUG("DEBUG: gst_media_info_get_stream: couldn't get caps !"); - return FALSE; - } + GstMediaInfoPriv *priv ; + /* if it's NULL then we're sure something went wrong higher up) */ + if (info == NULL) return FALSE; - /* find a format that matches the "track" concept */ - /* FIXME: this is used in vorbis, but we might have to loop when - * more codecs have tracks */ - track_format = gst_format_get_by_nick ("logical_stream"); + priv = info->priv; - /* get supported formats on decoder pad */ - formats = gst_pad_get_formats (priv->decoder_pad); - while (*formats) + g_assert (streamp != NULL); + switch (priv->state) { - const GstFormatDefinition *definition; + case GST_MEDIA_INFO_STATE_NULL: + /* need to find type */ + GMI_DEBUG("idler: NULL, need to find type\n"); + return gmip_find_type_pre (priv); - format = *formats; - - g_assert (GST_IS_PAD (priv->decoder_pad)); - res = gst_pad_query (priv->decoder_pad, GST_QUERY_TOTAL, - &format, &value); + case GST_MEDIA_INFO_STATE_TYPEFIND: + { + gchar *mime; + GstElement *decoder; - definition = gst_format_get_details (*formats); - GMI_DEBUG("trying to figure out length for format %s\n", definition->nick); + GMI_DEBUG("STATE_TYPEFIND\n"); + if ((priv->type == NULL) && gst_bin_iterate (GST_BIN (priv->pipeline))) + { + GMI_DEBUG("?"); + return TRUE; + } + if (priv->type == NULL) + { + g_warning ("Couldn't find type\n"); + return FALSE; + } + /* do the state transition */ + GMI_DEBUG("doing find_type_post\n"); + gmip_find_type_post (priv); + GMI_DEBUG("finding out mime type\n"); + mime = g_strdup (gst_caps_get_mime (priv->type)); + GMI_DEBUG("found out mime type: %s\n", mime); + decoder = gmi_get_decoder (info, mime); + if (decoder == NULL) + { + /* FIXME: pop up error */ + GMI_DEBUG("DEBUG: no decoder found for mime %s\n", mime); + return FALSE; + } + priv->stream = gmi_stream_new (); + GMI_DEBUG("DEBUG: new stream: %p\n", priv->stream); + priv->stream->mime = mime; + priv->stream->path = priv->location; + gmi_set_decoder (info, decoder); - if (res) + gmip_find_stream_pre (priv); + } + case GST_MEDIA_INFO_STATE_STREAM: { - switch (format) + GMI_DEBUG("STATE_STREAM\n"); + if ((priv->format == NULL) && gst_bin_iterate (GST_BIN (priv->pipeline))) + { + GMI_DEBUG("?"); + return TRUE; + } + if (priv->format == NULL) { - case GST_FORMAT_TIME: - stream->length_time = value; - g_print (" total %s: %" G_GINT64_FORMAT "\n", definition->nick, value); - break; - default: - /* separation is necessary because track_format doesn't resolve to - * int */ - if (format == track_format) - { - stream->length_tracks = value; - g_print (" total %s: %" G_GINT64_FORMAT "\n", definition->nick, value); - } - else - g_print ("warning: unhandled format %s\n", definition->nick); + g_warning ("Couldn't find format\n"); + return FALSE; } + /* do state transition; stream -> first track metadata */ + priv->current_track_num = 0; + gmip_find_stream_post (priv); + priv->current_track = gmi_track_new (); + gmip_find_track_metadata_pre (priv); + return TRUE; } - else - GMI_DEBUG("query didn't return result for %s\n", definition->nick); - - formats++; - } - if (stream->length_tracks == 0) stream->length_tracks = 1; - /* now get number of bytes from the sink pad to get the bitrate */ - format = GST_FORMAT_BYTES; - g_assert (GST_IS_PAD (priv->source_pad)); - res = gst_pad_query (priv->source_pad, GST_QUERY_TOTAL, - &format, &value); - if (!res) g_warning ("Failed to query on sink pad !"); - bytes = value; - - if (bytes) - { - double seconds = stream->length_time / GST_SECOND; - double bits = bytes * 8; - stream->bitrate = (long) (bits / seconds); - } - return TRUE; -} - -/* find metadata encoded in media */ -GstCaps * -gst_media_info_find_metadata (GstMediaInfo *info) -{ - GstMediaInfoPriv *priv = info->priv; - GstCaps *metadata; - - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - GMI_DEBUG("DEBUG: gst_media_info_find_metadata: iterating\n"); - while ((priv->metadata == NULL) && - gst_bin_iterate (GST_BIN (priv->pipeline))) - GMI_DEBUG("+"); - GMI_DEBUG("\n"); - gst_element_set_state (priv->pipeline, GST_STATE_PAUSED); - metadata = priv->metadata; - priv->metadata = NULL; - return metadata; -} - -/* find streaminfo found by decoder */ -GstCaps * -gst_media_info_find_streaminfo (GstMediaInfo *info) -{ - GstMediaInfoPriv *priv = info->priv; - GstCaps *streaminfo; - GstFormat format, track_format; - - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - GMI_DEBUG("DEBUG: gst_media_info_find_streaminfo: iterating\n"); - while ((priv->streaminfo == NULL) && - gst_bin_iterate (GST_BIN (priv->pipeline))) - GMI_DEBUG("+"); - GMI_DEBUG("\n"); - gst_element_set_state (priv->pipeline, GST_STATE_PAUSED); - streaminfo = priv->streaminfo; - priv->streaminfo = NULL; - - /* now add total length to this, and maybe even bitrate ? FIXME */ - track_format = gst_format_get_by_nick ("logical_stream"); - if (track_format == 0) - { - g_print ("FIXME: implement getting length of whole track\n"); - } - else - { - /* which one are we at ? */ - long track_num; - gint64 value_start, value_end; - gboolean res; - - res = gst_pad_query (priv->decoder_pad, GST_QUERY_POSITION, - &track_format, &value_start); - if (res) + /* these ones are repeated per track */ + case GST_MEDIA_INFO_STATE_METADATA: { - format = GST_FORMAT_TIME; - track_num = value_start; - GMI_DEBUG("DEBUG: we are currently at %ld\n", track_num); - res = gst_pad_convert (priv->decoder_pad, - track_format, track_num, - &format, &value_start); - res &= gst_pad_convert (priv->decoder_pad, - track_format, track_num + 1, - &format, &value_end); - if (res) + if ((priv->metadata == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline)) && + priv->metadata_iters < MAX_METADATA_ITERS) + { + GMI_DEBUG("?"); + priv->metadata_iters++; + return TRUE; + } + if (priv->metadata_iters == MAX_METADATA_ITERS) + g_print ("iterated a few times, didn't find metadata\n"); + if (priv->metadata == NULL) { - GstPropsEntry *length; - /* substract to get the length */ - GMI_DEBUG("DEBUG: start %" G_GINT64_FORMAT ", end %" - G_GINT64_FORMAT "\n", value_start, value_end); - value_end -= value_start; - g_print ("DEBUG: length: %d\n", (int) value_end); - length = gst_props_entry_new ("length", GST_PROPS_INT ((int) value_end)); - gst_props_add_entry (gst_caps_get_props (streaminfo), length); + /* this is not a permanent failure */ + GMI_DEBUG("Couldn't find metadata\n"); } + GMI_DEBUG("found metadata of track %ld\n", priv->current_track_num); + if (!gmip_find_track_metadata_post (priv)) return FALSE; + GMI_DEBUG("METADATA: going to STREAMINFO\n"); + priv->state = GST_MEDIA_INFO_STATE_STREAMINFO; + return gmip_find_track_streaminfo_pre (priv); } - } - - return streaminfo; -} - -/* find format found by decoder */ -GstCaps * -gst_media_info_find_format (GstMediaInfo *info) -{ - GstMediaInfoPriv *priv = info->priv; - GstCaps *format; - - if (gst_element_set_state (priv->pipeline, GST_STATE_PLAYING) - == GST_STATE_FAILURE) - g_warning ("Couldn't set to play"); - GMI_DEBUG("DEBUG: gst_media_info_find_format: iterating\n"); - while ((priv->format == NULL) && - gst_bin_iterate (GST_BIN (priv->pipeline))) - GMI_DEBUG("+"); - GMI_DEBUG("\n"); - gst_element_set_state (priv->pipeline, GST_STATE_PAUSED); - format = priv->format; - priv->format = NULL; - return format; -} - -/* clear the decoder - * (if it was set) - */ -static void -gst_media_info_clear_decoder (GstMediaInfo *info) -{ - if (info->priv->decoder) - { - /* clear up decoder */ - /* FIXME: shouldn't need to set state here */ - gst_element_set_state (info->priv->pipeline, GST_STATE_READY); - gst_element_unlink (info->priv->source, info->priv->decoder); - gst_bin_remove (GST_BIN (info->priv->pipeline), info->priv->decoder); - info->priv->decoder = NULL; - } -} - -/* set the decoder to be used for decoding - * install callback handlers - */ - -static void -gst_media_info_set_decoder (GstMediaInfo *info, GstElement *decoder) -{ - GstMediaInfoPriv *priv = info->priv; - - /* set up pipeline and connect signal handlers */ - priv->decoder = decoder; - gst_bin_add (GST_BIN (priv->pipeline), decoder); - if (!gst_element_link (priv->source, decoder)) - g_warning ("Couldn't link source and decoder\n"); - /* FIXME: we should be link to ALL possible src pads */ - if (!(priv->decoder_pad = gst_element_get_pad (decoder, "src"))) - g_warning ("Couldn't get decoder pad\n"); - if (!(priv->source_pad = gst_element_get_pad (priv->source, "src"))) - g_warning ("Couldn't get source pad\n"); -} - -/** - * public methods - */ -gboolean -gst_media_info_set_source (GstMediaInfo *info, const char *source) -{ - GstElement *src; - src = gst_element_factory_make (source, "new-source"); - if (!GST_IS_ELEMENT (src)) - return FALSE; - - if (info->priv->source) - { - /* this also unrefs the element */ - gst_bin_remove (GST_BIN (info->priv->pipeline), info->priv->source); - if (info->priv->source_element) + case GST_MEDIA_INFO_STATE_STREAMINFO: { - g_free (info->priv->source_element); - info->priv->source_element = NULL; + if ((priv->streaminfo == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + { + GMI_DEBUG("?"); + return TRUE; + } + if (priv->streaminfo == NULL) + { + /* this is not a permanent failure */ + GMI_DEBUG("Couldn't find streaminfo\n"); + } + else + GMI_DEBUG("found streaminfo of track %ld\n", priv->current_track_num); + if (!gmip_find_track_streaminfo_post (priv)) return FALSE; + priv->state = GST_MEDIA_INFO_STATE_FORMAT; + return gmip_find_track_format_pre (priv); } - } - g_object_set (G_OBJECT (src), "name", "source", NULL); - gst_bin_add (GST_BIN (info->priv->pipeline), src); - info->priv->source = src; - info->priv->source_element = g_strdup (source); - - return TRUE; + case GST_MEDIA_INFO_STATE_FORMAT: + { + if ((priv->format == NULL) && + gst_bin_iterate (GST_BIN (priv->pipeline))) + { + GMI_DEBUG("?"); + return TRUE; + } + if (priv->format == NULL) + { + g_warning ("Couldn't find format\n"); + return FALSE; + } + GMI_DEBUG("found format of track %ld\n", priv->current_track_num); + if (!gmip_find_track_format_post (priv)) return FALSE; + /* save the track info */ + priv->stream->tracks = g_list_append (priv->stream->tracks, + priv->current_track); + /* these alloc'd data types have been handed off */ + priv->current_track = NULL; + priv->location = NULL; + /* now see if we need to seek to a next track or not */ + priv->current_track_num++; + if (priv->current_track_num < priv->stream->length_tracks) + { + gmi_seek_to_track (info, priv->current_track_num); + priv->current_track = gmi_track_new (); + if (!gmip_find_track_metadata_pre (priv)) + { + g_free (priv->current_track); + return FALSE; + } + priv->state = GST_MEDIA_INFO_STATE_METADATA; + return TRUE; + } + priv->state = GST_MEDIA_INFO_STATE_DONE; + *streamp = priv->stream; + priv->stream = NULL; + GMI_DEBUG("TOTALLY DONE, setting pointer *streamp to %p\n", *streamp); + gmi_clear_decoder (info); + return TRUE; + } + case GST_MEDIA_INFO_STATE_DONE: + return TRUE; + default: + g_warning ("don't know what to do\n"); + return FALSE; + } } +/* main function + * read all possible info from the file pointed to by location + * use flags to limit the type of information searched for */ GstMediaInfoStream * gst_media_info_read (GstMediaInfo *info, const char *location, guint16 flags) { GstMediaInfoPriv *priv = info->priv; - GstElement *decoder = NULL; - const gchar *mime; GstMediaInfoStream *stream = NULL; + GstElement *decoder = NULL; + gchar *mime; int i; - + GMI_DEBUG("DEBUG: gst_media_info_read: start\n"); - gst_media_info_reset (info); /* reset all structs */ - /* find out type */ - /* FIXME: we could move caps for typefind out of struct and - * just use it through this function only */ - gst_media_info_find_type (info, location); + gmi_reset (info); /* reset all structs */ + priv->location = g_strdup (location); + priv->flags = flags; - if (priv->type == NULL) - { - /* iteration ended, still don't have type, ugh */ - g_warning ("iteration ended, type not found !\n"); - return NULL; - } - stream = gst_media_info_stream_new (); - mime = gst_caps_get_mime (priv->type); - if (flags & GST_MEDIA_INFO_MIME) - stream->mime = g_strdup (mime); - stream->path = g_strdup (location); + if (!gmip_find_type (priv)) return NULL; + + mime = g_strdup (gst_caps_get_mime (priv->type)); GMI_DEBUG("mime type: %s\n", mime); - decoder = gst_media_info_get_decoder (info, mime); + + /* c) figure out decoder */ + decoder = gmi_get_decoder (info, mime); + g_print ("DEBUG: using decoder %s\n", gst_element_get_name (decoder)); /* if it's NULL, then that's a sign we can't decode it */ if (decoder == NULL) { g_warning ("Can't find a decoder for type %s\n", mime); - gst_media_info_stream_free (stream); return NULL; } + + /* b) create media info stream object */ + priv->stream = gmi_stream_new (); + priv->stream->mime = mime; + priv->stream->path = priv->location; + /* install this decoder in the pipeline */ - gst_media_info_set_decoder (info, decoder); + gmi_set_decoder (info, decoder); /* collect total stream properties */ - gst_media_info_get_stream (info, stream); + /* d) get all stream properties */ + gmip_find_stream (priv); - /* if we have multiple tracks, loop over them; if not, just get + /* e) if we have multiple tracks, loop over them; if not, just get * metadata and return it */ - GMI_DEBUG("DEBUG: num tracks %ld\n", stream->length_tracks); - for (i = 0; i < stream->length_tracks; ++i) + GMI_DEBUG("DEBUG: num tracks %ld\n", priv->stream->length_tracks); + for (i = 0; i < priv->stream->length_tracks; ++i) { - GstMediaInfoTrack *track = gst_media_info_track_new (); + priv->current_track = gmi_track_new (); if (i > 0) { GMI_DEBUG("seeking to track %d\n", i); - gst_media_info_seek_to_track (info, i); + gmi_seek_to_track (info, i); } if (flags & GST_MEDIA_INFO_METADATA) - track->metadata = gst_media_info_find_metadata (info); + gmip_find_track_metadata (priv); if (flags & GST_MEDIA_INFO_STREAMINFO) - track->streaminfo = gst_media_info_find_streaminfo (info); + gmip_find_track_streaminfo (priv); if (flags & GST_MEDIA_INFO_FORMAT) - track->format = gst_media_info_find_format (info); - stream->tracks = g_list_append (stream->tracks, track); + gmip_find_track_format (priv); + priv->stream->tracks = g_list_append (priv->stream->tracks, + priv->current_track); + priv->current_track = NULL; } - gst_media_info_clear_decoder (info); + /* f) clear decoder */ + gmi_clear_decoder (info); /* please return it */ + stream = priv->stream; + priv->stream = NULL; return stream; } @@ -828,4 +502,3 @@ gboolean gst_media_info_write (GstMediaInfo *media_info, const char *location, GstCaps *media_info); */ - diff --git a/gst-libs/gst/media-info/media-info.h b/gst-libs/gst/media-info/media-info.h index 9cfe5401..942fbf63 100644 --- a/gst-libs/gst/media-info/media-info.h +++ b/gst-libs/gst/media-info/media-info.h @@ -37,7 +37,7 @@ typedef struct GObjectClass parent_class; /* signals */ - void (*media_info_signal) (GstMediaInfo *gst_media_info); + void (*media_info_signal) (GstMediaInfo *gst_media_info); } GstMediaInfoClass; @@ -57,7 +57,7 @@ typedef struct GList *tracks; } GstMediaInfoStream; -/* structure for "logical" stream or track, +/* structure for "logical" stream or track, * or one of a set of sequentially muxed streams */ typedef struct { @@ -76,7 +76,7 @@ typedef struct GstCaps *caps; /* properties of the muxed concurrent stream */ } GstMediaInfoConcurrent; -#define GST_MEDIA_INFO_ERROR gst_media_info_error_quark () +#define GST_MEDIA_INFO_ERROR gst_media_info_error_quark () #define GST_MEDIA_INFO_TYPE (gst_media_info_get_type ()) #define GST_MEDIA_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_MEDIA_INFO_TYPE, GstMediaInfo)) @@ -92,24 +92,30 @@ typedef struct #define GST_MEDIA_INFO_FORMAT 1 << 5 #define GST_MEDIA_INFO_ALL ((1 << 6) - 1) -GType gst_media_info_get_type (void); - -GstMediaInfo * gst_media_info_new (const char *source_element); -GstMediaInfoStream * - gst_media_info_read (GstMediaInfo *media_info, - const char *location, - guint16 GST_MEDIA_INFO_FLAGS); -gboolean gst_media_info_read_many (GstMediaInfo *media_info, - GList *locations, - guint16 GST_MEDIA_INFO_FLAGS, - GError **error); -GstCaps * gst_media_info_get_next (GstMediaInfo *media_info, - GError **error); +GType gst_media_info_get_type (void); + +GstMediaInfo * gst_media_info_new (const char *source_element); + +void gst_media_info_read_with_idler (GstMediaInfo *media_info, + const char *location, + guint16 GST_MEDIA_INFO_FLAGS); +gboolean gst_media_info_read_idler (GstMediaInfo *media_info, + GstMediaInfoStream **streamp); +GstMediaInfoStream * + gst_media_info_read (GstMediaInfo *media_info, + const char *location, + guint16 GST_MEDIA_INFO_FLAGS); +gboolean gst_media_info_read_many (GstMediaInfo *media_info, + GList *locations, + guint16 GST_MEDIA_INFO_FLAGS, + GError **error); +GstCaps * gst_media_info_get_next (GstMediaInfo *media_info, + GError **error); /* * FIXME: reset ? gboolean gst_media_info_write (GstMediaInfo *media_info, const char *location, GstCaps *media_info); */ - + #endif /* __GST_MEDIA_INFO_H__ */ |