summaryrefslogtreecommitdiffstats
path: root/gst-libs/gst/riff/riff-read.c
diff options
context:
space:
mode:
Diffstat (limited to 'gst-libs/gst/riff/riff-read.c')
-rw-r--r--gst-libs/gst/riff/riff-read.c877
1 files changed, 877 insertions, 0 deletions
diff --git a/gst-libs/gst/riff/riff-read.c b/gst-libs/gst/riff/riff-read.c
new file mode 100644
index 00000000..c264cced
--- /dev/null
+++ b/gst-libs/gst/riff/riff-read.c
@@ -0,0 +1,877 @@
+/* GStreamer RIFF I/O
+ * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
+ *
+ * riff-read.c: RIFF input file parsing
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+#include "riff-ids.h"
+#include "riff-read.h"
+
+enum {
+ ARG_0,
+ ARG_METADATA
+ /* FILL ME */
+};
+
+static void gst_riff_read_class_init (GstRiffReadClass *klass);
+static void gst_riff_read_init (GstRiffRead *riff);
+static void gst_riff_read_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static GstElementStateReturn
+ gst_riff_read_change_state (GstElement *element);
+
+static GstElementClass *parent_class = NULL;
+
+GType
+gst_riff_read_get_type (void)
+{
+ static GType gst_riff_read_type = 0;
+
+ if (!gst_riff_read_type) {
+ static const GTypeInfo gst_riff_read_info = {
+ sizeof (GstRiffReadClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) gst_riff_read_class_init,
+ NULL,
+ NULL,
+ sizeof (GstRiffRead),
+ 0,
+ (GInstanceInitFunc) gst_riff_read_init,
+ };
+
+ gst_riff_read_type =
+ g_type_register_static (GST_TYPE_ELEMENT, "GstRiffRead",
+ &gst_riff_read_info, 0);
+ }
+
+ return gst_riff_read_type;
+}
+
+static void
+gst_riff_read_class_init (GstRiffReadClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
+
+ g_object_class_install_property (gobject_class, ARG_METADATA,
+ g_param_spec_boxed ("metadata", "Metadata", "Metadata",
+ GST_TYPE_CAPS, G_PARAM_READABLE));
+
+ parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+ gobject_class->get_property = gst_riff_read_get_property;
+
+ gstelement_class->change_state = gst_riff_read_change_state;
+}
+
+static void
+gst_riff_read_init (GstRiffRead *riff)
+{
+ riff->sinkpad = NULL;
+ riff->bs = NULL;
+ riff->level = NULL;
+ riff->metadata = NULL;
+}
+
+static void
+gst_riff_read_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GstRiffRead *riff = GST_RIFF_READ (object);
+
+ switch (prop_id) {
+ case ARG_METADATA:
+ g_value_set_boxed (value, riff->metadata);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static GstElementStateReturn
+gst_riff_read_change_state (GstElement *element)
+{
+ GstRiffRead *riff = GST_RIFF_READ (element);
+
+ switch (GST_STATE_TRANSITION (element)) {
+ case GST_STATE_READY_TO_PAUSED:
+ if (!riff->sinkpad)
+ return GST_STATE_FAILURE;
+ riff->bs = gst_bytestream_new (riff->sinkpad);
+ break;
+ case GST_STATE_PAUSED_TO_READY:
+ gst_caps_replace (&riff->metadata, NULL);
+ gst_bytestream_destroy (riff->bs);
+ while (riff->level) {
+ GstRiffLevel *level = riff->level->data;
+
+ riff->level = g_list_remove (riff->level, level);
+ g_free (level);
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (GST_ELEMENT_CLASS (parent_class)->change_state)
+ return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+
+ return GST_STATE_SUCCESS;
+}
+
+/*
+ * Return: the amount of levels in the hierarchy that the
+ * current element lies higher than the previous one.
+ * The opposite isn't done - that's auto-done using list
+ * element reading.
+ */
+
+static guint
+gst_riff_read_element_level_up (GstRiffRead *riff)
+{
+ guint num = 0;
+ guint64 pos = gst_bytestream_tell (riff->bs);
+
+ while (riff->level != NULL) {
+ GList *last = g_list_last (riff->level);
+ GstRiffLevel *level = last->data;
+
+ if (pos >= level->start + level->length) {
+ riff->level = g_list_remove (riff->level, level);
+ g_free (level);
+ num++;
+ } else
+ break;
+ }
+
+ return num;
+}
+
+/*
+ * Read the next tag plus length (may be NULL). Return
+ * TRUE on success or FALSE on failure.
+ */
+
+static gboolean
+gst_riff_peek_head (GstRiffRead *riff,
+ guint32 *tag,
+ guint32 *length,
+ guint *level_up)
+{
+ guint8 *data;
+
+ /* read */
+ if (gst_bytestream_peek_bytes (riff->bs, &data, 8) != 8) {
+ GstEvent *event = NULL;
+ guint32 remaining;
+
+ /* Here, we might encounter EOS */
+ gst_bytestream_get_status (riff->bs, &remaining, &event);
+ if (event && GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
+ gst_pad_event_default (riff->sinkpad, event);
+ } else {
+ gst_event_unref (event);
+ gst_element_error (GST_ELEMENT (riff), "Read error");
+ }
+ return FALSE;
+ }
+
+ /* parse tag + length (if wanted) */
+ *tag = GUINT32_FROM_LE (((guint32 *) data)[0]);
+ if (length)
+ *length = GUINT32_FROM_LE (((guint32 *) data)[1]);
+
+ /* level */
+ if (level_up)
+ *level_up = gst_riff_read_element_level_up (riff);
+
+ return TRUE;
+}
+
+/*
+ * Read: the actual data (plus alignment and flush).
+ * Return: the data, as a GstBuffer.
+ */
+
+static GstBuffer *
+gst_riff_read_element_data (GstRiffRead *riff,
+ guint length)
+{
+ GstBuffer *buf = NULL;
+
+ if (gst_bytestream_peek (riff->bs, &buf, length) != length) {
+ gst_element_error (GST_ELEMENT (riff), "Read error");
+ if (buf)
+ gst_buffer_unref (buf);
+ return NULL;
+ }
+
+ /* we need 16-bit alignment */
+ if (length & 1)
+ length++;
+
+ gst_bytestream_flush (riff->bs, length);
+
+ return buf;
+}
+
+/*
+ * Seek.
+ */
+
+GstEvent *
+gst_riff_read_seek (GstRiffRead *riff,
+ guint64 offset)
+{
+ guint64 length = gst_bytestream_length (riff->bs);
+ guint32 remaining;
+ GstEvent *event;
+ guchar *data;
+
+ /* hack for AVI files with broken idx1 size chunk markers */
+ if (offset > length)
+ offset = length;
+
+ /* first, flush remaining buffers */
+ gst_bytestream_get_status (riff->bs, &remaining, &event);
+ if (event) {
+ g_warning ("Unexpected event before seek");
+ gst_event_unref (event);
+ }
+ if (remaining)
+ gst_bytestream_flush_fast (riff->bs, remaining);
+
+ /* now seek */
+ if (!gst_bytestream_seek (riff->bs, offset, GST_SEEK_METHOD_SET)) {
+ gst_element_error (GST_ELEMENT (riff), "Seek failed");
+ return NULL;
+ }
+
+ /* and now, peek a new byte. This will fail because there's a
+ * pending event. Then, take the event and return it. */
+ if (gst_bytestream_peek_bytes (riff->bs, &data, 1))
+ g_warning ("Unexpected data after seek");
+
+ /* get the discont event and return */
+ gst_bytestream_get_status (riff->bs, &remaining, &event);
+ if (!event || GST_EVENT_TYPE (event) != GST_EVENT_DISCONTINUOUS) {
+ gst_element_error (GST_ELEMENT (riff),
+ "No discontinuity event after seek");
+ if (event)
+ gst_event_unref (event);
+ return NULL;
+ }
+
+ return event;
+}
+
+/*
+ * Gives the tag of the next RIFF element.
+ */
+
+guint32
+gst_riff_peek_tag (GstRiffRead *riff,
+ guint *level_up)
+{
+ guint32 tag;
+
+ if (!gst_riff_peek_head (riff, &tag, NULL, level_up))
+ return 0;
+
+ return tag;
+}
+
+/*
+ * Gives the tag of the next LIST/RIFF element.
+ */
+
+guint32
+gst_riff_peek_list (GstRiffRead *riff)
+{
+ guint32 lst;
+ guint8 *data;
+
+ if (!gst_riff_peek_head (riff, &lst, NULL, NULL))
+ return FALSE;
+ if (lst != GST_RIFF_TAG_LIST) {
+ g_warning ("Not a LIST object");
+ return 0;
+ }
+
+ if (gst_bytestream_peek_bytes (riff->bs, &data, 12) != 12) {
+ gst_element_error (GST_ELEMENT (riff), "Read error");
+ return 0;
+ }
+
+ return GUINT32_FROM_LE (((guint32 *) data)[2]);
+}
+
+/*
+ * Don't read data.
+ */
+
+gboolean
+gst_riff_read_skip (GstRiffRead *riff)
+{
+ guint32 tag, length;
+ GstEvent *event;
+ guint32 remaining;
+
+ if (!gst_riff_peek_head (riff, &tag, &length, NULL))
+ return FALSE;
+
+ /* 16-bit alignment */
+ if (length & 1)
+ length++;
+
+ /* header itself */
+ length += 8;
+
+ /* see if we have that much data available */
+ gst_bytestream_get_status (riff->bs, &remaining, &event);
+ if (event) {
+ g_warning ("Unexpected event in skip");
+ gst_event_unref (event);
+ }
+
+ /* yes */
+ if (remaining >= length) {
+ gst_bytestream_flush_fast (riff->bs, length);
+ return TRUE;
+ }
+
+ /* no */
+ if (!(event = gst_riff_read_seek (riff,
+ gst_bytestream_tell (riff->bs) + length)))
+ return FALSE;
+
+ gst_event_unref (event);
+
+ return TRUE;
+}
+
+/*
+ * Read any type of data.
+ */
+
+gboolean
+gst_riff_read_data (GstRiffRead *riff,
+ guint32 *tag,
+ GstBuffer **buf)
+{
+ guint32 length;
+
+ if (!gst_riff_peek_head (riff, tag, &length, NULL))
+ return FALSE;
+ gst_bytestream_flush_fast (riff->bs, 8);
+
+ return ((*buf = gst_riff_read_element_data (riff, length)) != NULL);
+}
+
+/*
+ * Read a string.
+ */
+
+gboolean
+gst_riff_read_ascii (GstRiffRead *riff,
+ guint32 *tag,
+ gchar **str)
+{
+ GstBuffer *buf;
+
+ if (!gst_riff_read_data (riff, tag, &buf))
+ return FALSE;
+
+ *str = g_malloc (GST_BUFFER_SIZE (buf) + 1);
+ memcpy (*str, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
+ (*str)[GST_BUFFER_SIZE (buf)] = '\0';
+
+ gst_buffer_unref (buf);
+
+ return TRUE;
+}
+
+/*
+ * Read media structs.
+ */
+
+gboolean
+gst_riff_read_strh (GstRiffRead *riff,
+ gst_riff_strh **header)
+{
+ guint32 tag;
+ GstBuffer *buf;
+ gst_riff_strh *strh;
+
+ if (!gst_riff_read_data (riff, &tag, &buf))
+ return FALSE;
+
+ if (tag != GST_RIFF_TAG_strh) {
+ g_warning ("Not a strh chunk");
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+ if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_strh)) {
+ g_warning ("Too small strh (%d available, %d needed)",
+ GST_BUFFER_SIZE (buf), sizeof (gst_riff_strh));
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+
+ strh = g_memdup (GST_BUFFER_DATA (buf),
+ GST_BUFFER_SIZE (buf));
+ gst_buffer_unref (buf);
+
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ strh->type = GUINT32_FROM_LE (strh->type);
+ strh->fcc_handler = GUINT32_FROM_LE (strh->fcc_handler);
+ strh->flags = GUINT32_FROM_LE (strh->flags);
+ strh->priority = GUINT32_FROM_LE (strh->priority);
+ strh->init_frames = GUINT32_FROM_LE (strh->init_frames);
+ strh->scale = GUINT32_FROM_LE (strh->scale);
+ strh->rate = GUINT32_FROM_LE (strh->rate);
+ strh->start = GUINT32_FROM_LE (strh->start);
+ strh->length = GUINT32_FROM_LE (strh->length);
+ strh->bufsize = GUINT32_FROM_LE (strh->bufsize);
+ strh->quality = GUINT32_FROM_LE (strh->quality);
+ strh->samplesize = GUINT32_FROM_LE (strh->samplesize);
+#endif
+
+ /* avoid divisions by zero */
+ if (!strh->scale)
+ strh->scale = 1;
+ if (!strh->rate)
+ strh->rate = 1;
+
+ /* debug */
+ GST_INFO ("strh tag found");
+ GST_INFO (" type " GST_FOURCC_FORMAT,
+ GST_FOURCC_ARGS (strh->type));
+ GST_INFO (" fcc_handler " GST_FOURCC_FORMAT,
+ GST_FOURCC_ARGS (strh->fcc_handler));
+ GST_INFO (" flags 0x%08x", strh->flags);
+ GST_INFO (" priority %d", strh->priority);
+ GST_INFO (" init_frames %d", strh->init_frames);
+ GST_INFO (" scale %d", strh->scale);
+ GST_INFO (" rate %d", strh->rate);
+ GST_INFO (" start %d", strh->start);
+ GST_INFO (" length %d", strh->length);
+ GST_INFO (" bufsize %d", strh->bufsize);
+ GST_INFO (" quality %d", strh->quality);
+ GST_INFO (" samplesize %d", strh->samplesize);
+
+ *header = strh;
+
+ return TRUE;
+}
+
+gboolean
+gst_riff_read_strf_vids (GstRiffRead *riff,
+ gst_riff_strf_vids **header)
+{
+ guint32 tag;
+ GstBuffer *buf;
+ gst_riff_strf_vids *strf;
+
+ if (!gst_riff_read_data (riff, &tag, &buf))
+ return FALSE;
+
+ if (tag != GST_RIFF_TAG_strf) {
+ g_warning ("Not a strf chunk");
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+ if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_strf_vids)) {
+ g_warning ("Too small strf_vids (%d available, %d needed)",
+ GST_BUFFER_SIZE (buf), sizeof (gst_riff_strf_vids));
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+
+ strf = g_memdup (GST_BUFFER_DATA (buf),
+ GST_BUFFER_SIZE (buf));
+
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ strf->size = GUINT32_FROM_LE (strf->size);
+ strf->width = GUINT32_FROM_LE (strf->width);
+ strf->height = GUINT32_FROM_LE (strf->height);
+ strf->planes = GUINT16_FROM_LE (strf->planes);
+ strf->bit_cnt = GUINT16_FROM_LE (strf->bit_cnt);
+ strf->compression = GUINT32_FROM_LE (strf->compression);
+ strf->image_size = GUINT32_FROM_LE (strf->image_size);
+ strf->xpels_meter = GUINT32_FROM_LE (strf->xpels_meter);
+ strf->ypels_meter = GUINT32_FROM_LE (strf->ypels_meter);
+ strf->num_colors = GUINT32_FROM_LE (strf->num_colors);
+ strf->imp_colors = GUINT32_FROM_LE (strf->imp_colors);
+#endif
+
+ /* size checking */
+ if (strf->size > GST_BUFFER_SIZE (buf)) {
+ g_warning ("strf_vids header gave %d bytes data, only %d available",
+ strf->size, GST_BUFFER_SIZE (buf));
+ strf->size = GST_BUFFER_SIZE (buf);
+ }
+
+ /* debug */
+ GST_INFO ("strf tag found in context vids:");
+ GST_INFO (" size %d", strf->size);
+ GST_INFO (" width %d", strf->width);
+ GST_INFO (" height %d", strf->height);
+ GST_INFO (" planes %d", strf->planes);
+ GST_INFO (" bit_cnt %d", strf->bit_cnt);
+ GST_INFO (" compression " GST_FOURCC_FORMAT,
+ GST_FOURCC_ARGS (strf->compression));
+ GST_INFO (" image_size %d", strf->image_size);
+ GST_INFO (" xpels_meter %d", strf->xpels_meter);
+ GST_INFO (" ypels_meter %d", strf->ypels_meter);
+ GST_INFO (" num_colors %d", strf->num_colors);
+ GST_INFO (" imp_colors %d", strf->imp_colors);
+
+ gst_buffer_unref (buf);
+
+ *header = strf;
+
+ return TRUE;
+}
+
+gboolean
+gst_riff_read_strf_auds (GstRiffRead *riff,
+ gst_riff_strf_auds **header)
+{
+ guint32 tag;
+ GstBuffer *buf;
+ gst_riff_strf_auds *strf;
+
+ if (!gst_riff_read_data (riff, &tag, &buf))
+ return FALSE;
+
+ if (tag != GST_RIFF_TAG_strf) {
+ g_warning ("Not a strf chunk");
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+ if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_strf_auds)) {
+ g_warning ("Too small strf_auds (%d available, %d needed)",
+ GST_BUFFER_SIZE (buf), sizeof (gst_riff_strf_auds));
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+
+ strf = g_memdup (GST_BUFFER_DATA (buf),
+ GST_BUFFER_SIZE (buf));
+
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ strf->format = GUINT16_FROM_LE (strf->format);
+ strf->channels = GUINT16_FROM_LE (strf->channels);
+ strf->rate = GUINT32_FROM_LE (strf->rate);
+ strf->av_bps = GUINT32_FROM_LE (strf->av_bps);
+ strf->blockalign = GUINT16_FROM_LE (strf->blockalign);
+ strf->size = GUINT16_FROM_LE (strf->size);
+#endif
+
+ /* debug */
+ GST_INFO ("strf tag found in context auds:");
+ GST_INFO (" format %d", strf->format);
+ GST_INFO (" channels %d", strf->channels);
+ GST_INFO (" rate %d", strf->rate);
+ GST_INFO (" av_bps %d", strf->av_bps);
+ GST_INFO (" blockalign %d", strf->blockalign);
+ GST_INFO (" size %d", strf->size); /* wordsize, not extrasize! */
+
+ gst_buffer_unref (buf);
+
+ *header = strf;
+
+ return TRUE;
+}
+
+gboolean
+gst_riff_read_strf_iavs (GstRiffRead *riff,
+ gst_riff_strf_iavs **header)
+{
+ guint32 tag;
+ GstBuffer *buf;
+ gst_riff_strf_iavs *strf;
+
+ if (!gst_riff_read_data (riff, &tag, &buf))
+ return FALSE;
+
+ if (tag != GST_RIFF_TAG_strf) {
+ g_warning ("Not a strf chunk");
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+ if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_strf_iavs)) {
+ g_warning ("Too small strf_iavs (%d available, %d needed)",
+ GST_BUFFER_SIZE (buf), sizeof (gst_riff_strf_iavs));
+ gst_buffer_unref (buf);
+ return FALSE;
+ }
+
+ strf = g_memdup (GST_BUFFER_DATA (buf),
+ GST_BUFFER_SIZE (buf));
+ gst_buffer_unref (buf);
+
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ strf->DVAAuxSrc = GUINT32_FROM_LE (strf->DVAAuxSrc);
+ strf->DVAAuxCtl = GUINT32_FROM_LE (strf->DVAAuxCtl);
+ strf->DVAAuxSrc1 = GUINT32_FROM_LE (strf->DVAAuxSrc1);
+ strf->DVAAuxCtl1 = GUINT32_FROM_LE (strf->DVAAuxCtl1);
+ strf->DVVAuxSrc = GUINT32_FROM_LE (strf->DVVAuxSrc);
+ strf->DVVAuxCtl = GUINT32_FROM_LE (strf->DVVAuxCtl);
+ strf->DVReserved1 = GUINT32_FROM_LE (strf->DVReserved1);
+ strf->DVReserved2 = GUINT32_FROM_LE (strf->DVReserved2);
+#endif
+
+ /* debug */
+ GST_INFO ("strf tag found in context iavs");
+ GST_INFO (" DVAAuxSrc %08x", strf->DVAAuxSrc);
+ GST_INFO (" DVAAuxCtl %08x", strf->DVAAuxCtl);
+ GST_INFO (" DVAAuxSrc1 %08x", strf->DVAAuxSrc1);
+ GST_INFO (" DVAAuxCtl1 %08x", strf->DVAAuxCtl1);
+ GST_INFO (" DVVAuxSrc %08x", strf->DVVAuxSrc);
+ GST_INFO (" DVVAuxCtl %08x", strf->DVVAuxCtl);
+ GST_INFO (" DVReserved1 %08x", strf->DVReserved1);
+ GST_INFO (" DVReserved2 %08x", strf->DVReserved2);
+
+ *header = strf;
+
+ return TRUE;
+}
+
+/*
+ * Read a list.
+ */
+
+gboolean
+gst_riff_read_list (GstRiffRead *riff,
+ guint32 *tag)
+{
+ guint32 length, lst;
+ GstRiffLevel *level;
+ guint8 *data;
+
+ if (!gst_riff_peek_head (riff, &lst, &length, NULL))
+ return FALSE;
+ if (lst != GST_RIFF_TAG_LIST) {
+ g_warning ("Not a LIST object");
+ return FALSE;
+ }
+ gst_bytestream_flush_fast (riff->bs, 8);
+ if (gst_bytestream_peek_bytes (riff->bs, &data, 4) != 4) {
+ gst_element_error (GST_ELEMENT (riff), "Read error");
+ return FALSE;
+ }
+ gst_bytestream_flush_fast (riff->bs, 4);
+ *tag = GUINT32_FROM_LE (* (guint32 *) data);
+
+ /* remember level */
+ level = g_new (GstRiffLevel, 1);
+ level->start = gst_bytestream_tell (riff->bs);
+ level->length = length - 4;
+ riff->level = g_list_append (riff->level, level);
+
+ return TRUE;
+}
+
+/*
+ * Utility function for reading metadata in a RIFF file.
+ */
+
+gboolean
+gst_riff_read_info (GstRiffRead *riff)
+{
+ guint32 tag;
+ guint64 end;
+ GstRiffLevel *level;
+ GList *last;
+ gchar *name, *type;
+ GstProps *props;
+
+ /* What we're doing here is ugly (oh no!); we look
+ * at our LIST tag size and assure that we do not
+ * cross boundaries. This is to maintain the level
+ * counter for the client app. */
+ last = g_list_last (riff->level);
+ level = last->data;
+ riff->level = g_list_remove (riff->level, level);
+ end = level->start + level->length;
+ g_free (level);
+
+ props = gst_props_empty_new ();
+
+ while (gst_bytestream_tell (riff->bs) < end) {
+ if (!gst_riff_peek_head (riff, &tag, NULL, NULL)) {
+ gst_props_unref (props);
+ return FALSE;
+ }
+
+ /* find out the type of metadata */
+ switch (tag) {
+ case GST_RIFF_INFO_IARL:
+ type = "Location";
+ break;
+ case GST_RIFF_INFO_IART:
+ type = "Artist";
+ break;
+ case GST_RIFF_INFO_ICMS:
+ type = "Commissioner";
+ break;
+ case GST_RIFF_INFO_ICMT:
+ type = "Comment";
+ break;
+ case GST_RIFF_INFO_ICOP:
+ type = "Copyright";
+ break;
+ case GST_RIFF_INFO_ICRD:
+ type = "Creation Date";
+ break;
+ case GST_RIFF_INFO_ICRP:
+ type = "Cropped";
+ break;
+ case GST_RIFF_INFO_IDIM:
+ type = "Dimensions";
+ break;
+ case GST_RIFF_INFO_IDPI:
+ type = "Dots per Inch";
+ break;
+ case GST_RIFF_INFO_IENG:
+ type = "Engineer";
+ break;
+ case GST_RIFF_INFO_IGNR:
+ type = "Genre";
+ break;
+ case GST_RIFF_INFO_IKEY:
+ type = "Keywords";
+ break;
+ case GST_RIFF_INFO_ILGT:
+ type = "Lightness";
+ break;
+ case GST_RIFF_INFO_IMED:
+ type = "Medium";
+ break;
+ case GST_RIFF_INFO_INAM:
+ type = "Title"; /* "Name" */
+ break;
+ case GST_RIFF_INFO_IPLT:
+ type = "Palette";
+ break;
+ case GST_RIFF_INFO_IPRD:
+ type = "Product";
+ break;
+ case GST_RIFF_INFO_ISBJ:
+ type = "Subject";
+ break;
+ case GST_RIFF_INFO_ISFT:
+ type = "Encoder"; /* "Software" */
+ break;
+ case GST_RIFF_INFO_ISHP:
+ type = "Sharpness";
+ break;
+ case GST_RIFF_INFO_ISRC:
+ type = "Source";
+ break;
+ case GST_RIFF_INFO_ISRF:
+ type = "Source Form";
+ break;
+ case GST_RIFF_INFO_ITCH:
+ type = "Technician";
+ break;
+ default:
+ type = NULL;
+ GST_WARNING ("Unknown INFO (metadata) tag entry " GST_FOURCC_FORMAT,
+ GST_FOURCC_ARGS (tag));
+ break;
+ }
+
+ if (type) {
+ GstPropsEntry *entry;
+
+ if (!gst_riff_read_ascii (riff, &tag, &name)) {
+ gst_props_unref (props);
+ return FALSE;
+ }
+
+ entry = gst_props_entry_new (type, GST_PROPS_STRING (name));
+ gst_props_add_entry (props, entry);
+ } else {
+ gst_riff_read_skip (riff);
+ }
+ }
+
+ /* let the world know about this wonderful thing */
+ gst_props_debug (props);
+ gst_caps_replace_sink (&riff->metadata,
+ gst_caps_new ("riff_metadata",
+ "application/x-gst-metadata",
+ props));
+ g_object_notify (G_OBJECT (riff), "metadata");
+
+ return TRUE;
+}
+
+/*
+ * Read RIFF header and document type.
+ */
+
+gboolean
+gst_riff_read_header (GstRiffRead *riff,
+ guint32 *doctype)
+{
+ GstRiffLevel *level;
+ guint32 tag, length;
+ guint8 *data;
+
+ /* We ignore size for openDML-2.0 support */
+ if (!gst_riff_peek_head (riff, &tag, &length, NULL))
+ return FALSE;
+ if (tag != GST_RIFF_TAG_RIFF) {
+ GST_WARNING ("Not a RIFF file");
+ return FALSE;
+ }
+ gst_bytestream_flush_fast (riff->bs, 8);
+
+ /* doctype */
+ if (gst_bytestream_peek_bytes (riff->bs, &data, 4) != 4) {
+ gst_element_error (GST_ELEMENT (riff), "Read error");
+ return FALSE;
+ }
+ gst_bytestream_flush_fast (riff->bs, 4);
+ *doctype = GUINT32_FROM_LE (* (guint32 *) data);
+
+ /* remember level */
+ level = g_new (GstRiffLevel, 1);
+ level->start = gst_bytestream_tell (riff->bs);
+ level->length = length - 4;
+ riff->level = g_list_append (riff->level, level);
+
+ return TRUE;
+}