Added new module for common functions. Using GST_TYPE_FRACTION for Exif (S)Rational types.

Original commit message from CVS:
Added new module for common functions. Using GST_TYPE_FRACTION for Exif (S)Rational types.

ChangeLog

@@ -1,3 +1,22 @@
+2007-12-14  Edgard Lima,,,,  <edgard.lima@indt.org.br>
+
+	* ext/metadata/Makefile.am:
+	* ext/metadata/TODO:
+	* ext/metadata/gstmetadata.c:
+	* ext/metadata/gstmetadatacommon.c:
+	* ext/metadata/gstmetadatacommon.h:
+	* ext/metadata/gstmetadatademux.c:
+	* ext/metadata/gstmetadatademux.h:
+	* ext/metadata/gstmetadatamux.c:
+	* ext/metadata/gstmetadatamux.h:
+	* ext/metadata/gstmetadataparse.c:
+	* ext/metadata/gstmetadataparse.h:
+	* ext/metadata/metadataexif.c:
+	* ext/metadata/metadatatags.c:
+	* ext/metadata/test/metadata_editor.c:
+	  Added new module for common functions. Using GST_TYPE_FRACTION for
+	  Exif (S)Rational types.
+
 2007-12-14  Zaheer Abbas Merali  <zaheerabbas at merali dot org>
 
 	* gst/mpegtsparse/mpegtspacketizer.c:

ext/metadata/Makefile.am

@@ -1,7 +1,8 @@
 plugin_LTLIBRARIES = libgstmetadata.la
 
 libgstmetadata_la_SOURCES =	gstmetadata.c       \
-				gstmetadataparse.c  \
+				gstmetadatacommon.c \
+				gstmetadatademux.c  \
 				metadata.c          \
 				metadataparsejpeg.c \
 				metadatamuxjpeg.c   \
@@ -15,11 +16,15 @@ libgstmetadata_la_SOURCES =	gstmetadata.c       \
 				gstmetadatamux.c    \
 				metadatatags.c
 
+libgstmetadata_ladir = $(includedir)/gstreamer-@GST_MAJORMINOR@/metadata
+libgstmetadata_la_HEADERS = metadatatags.h
+
 libgstmetadata_la_CFLAGS = $(METADATA_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS)
 libgstmetadata_la_LIBADD = $(METADATA_LIBS) -lgsttag-@GST_MAJORMINOR@ $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS)
 libgstmetadata_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
 
-noinst_HEADERS = 	gstmetadataparse.h   \
+noinst_HEADERS = 	gstmetadatademux.h   \
+			gstmetadatacommon.h  \
 			metadata.h           \
 			metadataparsejpeg.h  \
 			metadatamuxjpeg.h    \

ext/metadata/TODO

@@ -4,10 +4,9 @@ This file contains a list of things to be done as well some open issues (questio
 TODO:
 
 1- Add individual tags IPTC and XMP (and more for EXIF)
-2- Use GST_TYPE_FRACTION for Rational and SRational (metadataexif.c)
+2- Get properties like 'width' and 'height' from caps
-3- Get properties like 'width' and 'height' from caps
+3- Review the code (in order to move to gst-plugins-good)
-4- Review the code (in order to move to gst-plugins-good)
+4- Document how the plugin works (atchitecture and interaction beteween modules)
-5- Document how the plugin works (atchitecture and interaction beteween modules)
 
 OPEN ISSUES:
 
@@ -15,4 +14,7 @@ OPEN ISSUES:
 2- How to change metadata when the orignal image was modified.
   ex: file.jpeg has XMP, then we do filesrc ! metadataparse ! jpegdec ! pngenc ! metadatamux ! files
   is the metadata still valid? which fields are no valid anymore?
+3- Add GST_TYPE_FRACTION support for GStreamer TAGS
+4- Have parse, demux and mux? (or just demux and must) see issue (5)
+5- After decided issue (4) put more things to gstmetadatacommon (or else create a Class)
 

ext/metadata/gstmetadata.c

@@ -49,7 +49,7 @@
 
 #include "metadatatags.h"
 
-extern gboolean gst_metadata_parse_plugin_init (GstPlugin * plugin);
+extern gboolean gst_metadata_demux_plugin_init (GstPlugin * plugin);
 extern gboolean gst_metadata_mux_plugin_init (GstPlugin * plugin);
 
 GST_DEBUG_CATEGORY_EXTERN (gst_metadata_exif_debug);
@@ -71,7 +71,7 @@ plugin_init (GstPlugin * plugin)
 
   metadata_tags_register ();
 
-  ret = gst_metadata_parse_plugin_init (plugin);
+  ret = gst_metadata_demux_plugin_init (plugin);
 
   ret = ret && gst_metadata_mux_plugin_init (plugin);
 
@@ -82,5 +82,5 @@ plugin_init (GstPlugin * plugin)
 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
     GST_VERSION_MINOR,
     "metadata",
-    "Metadata (EXIF, IPTC and XMP) image (JPEG, TIFF) parser and muxer",
+    "Metadata (EXIF, IPTC and XMP) image (JPEG, TIFF) demuxer and muxer",
     plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)

ext/metadata/gstmetadatacommon.c

@@ -0,0 +1,631 @@
+/*
+ * GStreamer
+ * Copyright 2007 Edgard Lima <edgard.lima@indt.org.br>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Alternatively, the contents of this file may be used under the
+ * GNU Lesser General Public License Version 2.1 (the "LGPL"), in
+ * which case the following provisions apply instead of the ones
+ * mentioned above:
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:metadatamux-metadata
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * <para>
+ * <programlisting>
+ * gst-launch -v -m filesrc location=./test.jpeg ! metadatamux ! fakesink silent=TRUE
+ * </programlisting>
+ * </para>
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <string.h>
+
+/*
+ * static functions declaration
+ */
+
+#include "gstmetadatacommon.h"
+
+/*
+ * offset - offset of buffer in original stream
+ * size - size of buffer
+ * seg_offset - offset of segment in original stream
+ * seg_size - size of segment
+ * boffset - offset inside buffer where segment starts (-1 for no intersection)
+ * bsize - size of intersection
+ * seg_binter - if segment start inside buffer is zero. if segment start before
+ *               buffer and intersect, it is the offset inside segment.
+ *
+ * ret:
+ *  -1 - segment before buffer
+ *   0 - segment intersects
+ *   1 - segment after buffer
+ */
+
+static int
+gst_metadata_common_get_strip_seg (const gint64 offset, guint32 size,
+    const gint64 seg_offset, const guint32 seg_size,
+    gint64 * boffset, guint32 * bsize, guint32 * seg_binter)
+{
+  int ret = -1;
+
+  *boffset = -1;
+  *bsize = 0;
+  *seg_binter = -1;
+
+  /* all segment after buffer */
+  if (seg_offset >= offset + size) {
+    ret = 1;
+    goto done;
+  }
+
+  if (seg_offset < offset) {
+    /* segment start somewhere before buffer */
+
+    /* all segment before buffer */
+    if (seg_offset + seg_size <= offset) {
+      ret = -1;
+      goto done;
+    }
+
+    *seg_binter = offset - seg_offset;
+    *boffset = 0;
+
+    /* FIXME : optimize to >= size -> = size */
+    if (seg_offset + seg_size >= offset + size) {
+      /* segment cover all buffer */
+      *bsize = size;
+    } else {
+      /* segment goes from start of buffer to somewhere before end */
+      *bsize = seg_size - *seg_binter;
+    }
+
+    ret = 0;
+
+  } else {
+    /* segment start somewhere into buffer */
+
+    *boffset = seg_offset - offset;
+    *seg_binter = 0;
+
+    if (seg_offset + seg_size <= offset + size) {
+      /* all segment into buffer */
+      *bsize = seg_size;
+    } else {
+      *bsize = size - *boffset;
+    }
+
+    ret = 0;
+
+  }
+
+done:
+
+  return ret;
+
+}
+
+/*
+ * extern functions declaration
+ */
+
+void
+gst_metadata_common_init (GstMetadataCommon * common, gboolean parse,
+    guint8 options)
+{
+  metadata_init (&common->metadata, parse, options);
+}
+
+void
+gst_metadata_common_dispose (GstMetadataCommon * common)
+{
+  if (common->append_buffer) {
+    gst_buffer_unref (common->append_buffer);
+    common->append_buffer = NULL;
+  }
+  metadata_dispose (&common->metadata);
+}
+
+/*
+
+/*
+ *  TRUE -> buffer striped or injeted
+ *  FALSE -> buffer unmodified
+ */
+
+gboolean
+gst_metadata_common_strip_push_buffer (GstMetadataCommon * common,
+    gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf)
+{
+  MetadataChunk *strip = common->metadata.strip_chunks.chunk;
+  MetadataChunk *inject = common->metadata.inject_chunks.chunk;
+  const gsize strip_len = common->metadata.strip_chunks.len;
+  const gsize inject_len = common->metadata.inject_chunks.len;
+
+  gboolean buffer_reallocated = FALSE;
+
+  guint32 size_buf_in = GST_BUFFER_SIZE (*buf);
+
+  gint64 *boffset_strip = NULL;
+  guint32 *bsize_strip = NULL;
+  guint32 *seg_binter_strip = NULL;
+
+  int i, j;
+  gboolean need_free_strip = FALSE;
+
+  guint32 striped_bytes = 0;
+  guint32 injected_bytes = 0;
+
+  guint32 prepend_size = prepend && *prepend ? GST_BUFFER_SIZE (*prepend) : 0;
+
+  if (inject_len) {
+
+    for (i = 0; i < inject_len; ++i) {
+      int res;
+
+      if (inject[i].offset_orig >= offset_orig) {
+        if (inject[i].offset_orig < offset_orig + size_buf_in) {
+          injected_bytes += inject[i].size;
+        } else {
+          /* segment is after size (segments are sorted) */
+          break;
+        }
+      }
+    }
+
+  }
+
+  /*
+   * strip segments
+   */
+
+  if (strip_len == 0)
+    goto inject;
+
+  if (G_UNLIKELY (strip_len > 16)) {
+    boffset_strip = g_new (gint64, strip_len);
+    bsize_strip = g_new (guint32, strip_len);
+    seg_binter_strip = g_new (guint32, strip_len);
+    need_free_strip = TRUE;
+  } else {
+    boffset_strip = g_alloca (sizeof (boffset_strip[0]) * strip_len);
+    bsize_strip = g_alloca (sizeof (bsize_strip[0]) * strip_len);
+    seg_binter_strip = g_alloca (sizeof (seg_binter_strip[0]) * strip_len);
+  }
+
+  memset (bsize_strip, 0x00, sizeof (bsize_strip[0]) * strip_len);
+
+  for (i = 0; i < strip_len; ++i) {
+    int res;
+
+    res = gst_metadata_common_get_strip_seg (offset_orig, size_buf_in,
+        strip[i].offset_orig, strip[i].size, &boffset_strip[i], &bsize_strip[i],
+        &seg_binter_strip[i]);
+
+    /* segment is after size (segments are sorted) */
+    striped_bytes += bsize_strip[i];
+    if (res > 0) {
+      break;
+    }
+
+  }
+
+  if (striped_bytes) {
+
+    guint8 *data;
+
+    if (!buffer_reallocated) {
+      buffer_reallocated = TRUE;
+      if (injected_bytes + prepend_size > striped_bytes) {
+        GstBuffer *new_buf =
+            gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
+            prepend_size - striped_bytes);
+
+        memcpy (GST_BUFFER_DATA (new_buf), GST_BUFFER_DATA (*buf),
+            GST_BUFFER_SIZE (*buf));
+
+        gst_buffer_unref (*buf);
+        *buf = new_buf;
+
+      } else if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY)) {
+        GstBuffer *new_buf = gst_buffer_copy (*buf);
+
+        gst_buffer_unref (*buf);
+        *buf = new_buf;
+        GST_BUFFER_FLAG_UNSET (*buf, GST_BUFFER_FLAG_READONLY);
+        GST_BUFFER_SIZE (*buf) += injected_bytes + prepend_size - striped_bytes;
+      }
+    }
+
+    data = GST_BUFFER_DATA (*buf);
+
+    striped_bytes = 0;
+    for (i = 0; i < strip_len; ++i) {
+      /* intersect */
+      if (bsize_strip[i]) {
+        memmove (data + boffset_strip[i] - striped_bytes,
+            data + boffset_strip[i] + bsize_strip[i] - striped_bytes,
+            size_buf_in - boffset_strip[i] - bsize_strip[i]);
+        striped_bytes += bsize_strip[i];
+      }
+    }
+    size_buf_in -= striped_bytes;
+
+  }
+
+inject:
+
+  /*
+   * inject segments
+   */
+
+  if (inject_len) {
+
+    guint8 *data;
+    guint32 striped_so_far;
+
+    if (!buffer_reallocated) {
+      buffer_reallocated = TRUE;
+      if (injected_bytes + prepend_size > striped_bytes) {
+        GstBuffer *new_buf =
+            gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
+            prepend_size - striped_bytes);
+
+        memcpy (GST_BUFFER_DATA (new_buf), GST_BUFFER_DATA (*buf),
+            GST_BUFFER_SIZE (*buf));
+
+        gst_buffer_unref (*buf);
+        *buf = new_buf;
+
+      } else if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY)) {
+        GstBuffer *new_buf = gst_buffer_copy (*buf);
+
+        gst_buffer_unref (*buf);
+        *buf = new_buf;
+        GST_BUFFER_FLAG_UNSET (*buf, GST_BUFFER_FLAG_READONLY);
+        GST_BUFFER_SIZE (*buf) += injected_bytes + prepend_size - striped_bytes;
+      }
+    }
+
+    data = GST_BUFFER_DATA (*buf);
+
+    injected_bytes = 0;
+    striped_so_far = 0;
+    j = 0;
+    for (i = 0; i < inject_len; ++i) {
+      int res;
+
+      while (j < strip_len) {
+        if (strip[j].offset_orig < inject[i].offset_orig)
+          striped_so_far += bsize_strip[j++];
+        else
+          break;
+      }
+
+      if (inject[i].offset_orig >= offset_orig) {
+        if (inject[i].offset_orig <
+            offset_orig + size_buf_in + striped_bytes - injected_bytes) {
+          /* insert */
+          guint32 buf_off =
+              inject[i].offset_orig - offset_orig - striped_so_far +
+              injected_bytes;
+          memmove (data + buf_off + inject[i].size, data + buf_off,
+              size_buf_in - buf_off);
+          memcpy (data + buf_off, inject[i].data, inject[i].size);
+          injected_bytes += inject[i].size;
+          size_buf_in += inject[i].size;
+        } else {
+          /* segment is after size (segments are sorted) */
+          break;
+        }
+      }
+    }
+
+  }
+
+
+done:
+
+  if (prepend_size) {
+    if (injected_bytes == 0 && striped_bytes == 0) {
+      GstBuffer *new_buf =
+          gst_buffer_new_and_alloc (size_buf_in + prepend_size);
+
+      memcpy (GST_BUFFER_DATA (new_buf) + prepend_size, GST_BUFFER_DATA (*buf),
+          size_buf_in);
+
+      gst_buffer_unref (*buf);
+      *buf = new_buf;
+    } else {
+      memmove (GST_BUFFER_DATA (*buf) + prepend_size, GST_BUFFER_DATA (*buf),
+          size_buf_in);
+    }
+    memcpy (GST_BUFFER_DATA (*buf), GST_BUFFER_DATA (*prepend), prepend_size);
+    gst_buffer_unref (*prepend);
+    *prepend = NULL;
+  }
+
+  GST_BUFFER_SIZE (*buf) = size_buf_in + prepend_size;
+
+  if (need_free_strip) {
+    g_free (boffset_strip);
+    g_free (bsize_strip);
+    g_free (seg_binter_strip);
+  }
+
+  return injected_bytes || striped_bytes;
+
+}
+
+/*
+ * pos - position in stream striped
+ * orig_pos - position in original stream
+ * return TRUE - position in original buffer
+ *        FALSE - position in inserted chunk
+ */
+gboolean
+gst_metadata_common_translate_pos_to_orig (GstMetadataCommon * common,
+    gint64 pos, gint64 * orig_pos, GstBuffer ** buf)
+{
+  MetadataChunk *strip = common->metadata.strip_chunks.chunk;
+  MetadataChunk *inject = common->metadata.inject_chunks.chunk;
+  const gsize strip_len = common->metadata.strip_chunks.len;
+  const gsize inject_len = common->metadata.inject_chunks.len;
+  const gint64 duration_orig = common->duration_orig;
+  const gint64 duration = common->duration;
+
+  int i;
+  gboolean ret = TRUE;
+  guint64 new_buf_size = 0;
+  guint64 injected_before = 0;
+
+  if (G_UNLIKELY (pos == -1)) {
+    *orig_pos = -1;
+    return TRUE;
+  } else if (G_UNLIKELY (pos >= duration)) {
+    /* this should never happen */
+    *orig_pos = duration_orig;
+    return TRUE;
+  }
+
+  /* calculate for injected */
+
+  /* just calculate size */
+  *orig_pos = pos;              /* save pos */
+  for (i = 0; i < inject_len; ++i) {
+    /* check if pos in inside chunk */
+    if (inject[i].offset <= pos) {
+      if (pos < inject[i].offset + inject[i].size) {
+        /* orig pos points after insert chunk */
+        new_buf_size += inject[i].size;
+        /* put pos after current chunk */
+        pos = inject[i].offset + inject[i].size;
+        ret = FALSE;
+      } else {
+        /* in case pos is not inside a injected chunk */
+        injected_before += inject[i].size;
+      }
+    } else {
+      break;
+    }
+  }
+
+  /* alloc buffer and calcute original pos */
+  if (buf && ret == FALSE) {
+    guint8 *data;
+
+    if (*buf)
+      gst_buffer_unref (*buf);
+    *buf = gst_buffer_new_and_alloc (new_buf_size);
+    data = GST_BUFFER_DATA (*buf);
+    pos = *orig_pos;            /* recover saved pos */
+    for (i = 0; i < inject_len; ++i) {
+      if (inject[i].offset > pos) {
+        break;
+      }
+      if (inject[i].offset <= pos && pos < inject[i].offset + inject[i].size) {
+        memcpy (data, inject[i].data, inject[i].size);
+        data += inject[i].size;
+        pos = inject[i].offset + inject[i].size;
+        /* out position after insert chunk orig */
+        *orig_pos = inject[i].offset_orig + inject[i].size;
+      }
+    }
+  }
+
+  if (ret == FALSE) {
+    /* if it inside a injected is already done */
+    goto done;
+  }
+
+  /* calculate for striped */
+
+  *orig_pos = pos - injected_before;
+  for (i = 0; i < strip_len; ++i) {
+    if (strip[i].offset_orig > pos) {
+      break;
+    }
+    *orig_pos += strip[i].size;
+  }
+
+done:
+
+  if (G_UNLIKELY (*orig_pos >= duration_orig)) {
+    *orig_pos = duration_orig - 1;
+  }
+
+  return ret;
+
+}
+
+/*
+ * return:
+ *   -1 -> error
+ *    0 -> succeded
+ *    1 -> need more data
+ */
+
+gboolean
+gst_metadata_common_calculate_offsets (GstMetadataCommon * common)
+{
+  int i, j;
+  guint32 append_size;
+  guint32 bytes_striped, bytes_inject;
+  MetadataChunk *strip = common->metadata.strip_chunks.chunk;
+  MetadataChunk *inject = common->metadata.inject_chunks.chunk;
+  gsize strip_len;
+  gsize inject_len;
+
+  if (common->state != MT_STATE_PARSED)
+    return FALSE;
+
+  metadata_lazy_update (&common->metadata);
+
+  strip_len = common->metadata.strip_chunks.len;
+  inject_len = common->metadata.inject_chunks.len;
+
+  bytes_striped = 0;
+  bytes_inject = 0;
+
+  /* calculate the new position off injected chunks */
+  j = 0;
+  for (i = 0; i < inject_len; ++i) {
+    for (; j < strip_len; ++j) {
+      if (strip[j].offset_orig >= inject[i].offset_orig) {
+        break;
+      }
+      bytes_striped += strip[j].size;
+    }
+    inject[i].offset = inject[i].offset_orig - bytes_striped + bytes_inject;
+    bytes_inject += inject[i].size;
+  }
+
+  /* calculate append (doesnt make much sense, but, anyway..) */
+  append_size = 0;
+  for (i = inject_len - 1; i >= 0; --i) {
+    if (inject[i].offset_orig == common->duration_orig)
+      append_size += inject[i].size;
+    else
+      break;
+  }
+  if (append_size) {
+    guint8 *data;
+
+    common->append_buffer = gst_buffer_new_and_alloc (append_size);
+    GST_BUFFER_FLAG_SET (common->append_buffer, GST_BUFFER_FLAG_READONLY);
+    data = GST_BUFFER_DATA (common->append_buffer);
+    for (i = inject_len - 1; i >= 0; --i) {
+      if (inject[i].offset_orig == common->duration_orig) {
+        memcpy (data, inject[i].data, inject[i].size);
+        data += inject[i].size;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (common->duration_orig) {
+    common->duration = common->duration_orig;
+    for (i = 0; i < inject_len; ++i) {
+      common->duration += inject[i].size;
+    }
+    for (i = 0; i < strip_len; ++i) {
+      common->duration -= strip[i].size;
+    }
+  }
+
+  return TRUE;
+
+}
+
+void
+gst_metadata_common_update_segment_with_new_buffer (GstMetadataCommon * common,
+    guint8 ** buf, guint32 * size, MetadataChunkType type)
+{
+  int i;
+  MetadataChunk *inject = common->metadata.inject_chunks.chunk;
+  const gsize inject_len = common->metadata.inject_chunks.len;
+
+  if (!(buf && size))
+    goto done;
+  if (*buf == 0)
+    goto done;
+  if (*size == 0)
+    goto done;
+
+  for (i = 0; i < inject_len; ++i) {
+    if (inject[i].type == type) {
+      inject[i].size = *size;
+      if (inject[i].data)
+        g_free (inject[i].data);
+      inject[i].data = *buf;
+      *size = 0;
+      *buf = 0;
+      break;
+    }
+  }
+
+done:
+
+  return;
+
+}
+
+const gchar *
+gst_metadata_common_get_type_name (int img_type)
+{
+  gchar *type_name = NULL;
+
+  switch (img_type) {
+    case IMG_JPEG:
+      type_name = "jpeg";
+      break;
+    case IMG_PNG:
+      type_name = "png";
+      break;
+    default:
+      type_name = "invalid type";
+      break;
+  }
+  return type_name;
+}

ext/metadata/gstmetadatacommon.h

@@ -0,0 +1,96 @@
+/*
+ * GStreamer
+ * Copyright 2007 Edgard Lima <edgard.lima@indt.org.br>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Alternatively, the contents of this file may be used under the
+ * GNU Lesser General Public License Version 2.1 (the "LGPL"), in
+ * which case the following provisions apply instead of the ones
+ * mentioned above:
+ *
+ * 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.
+ */
+
+
+#ifndef __GST_METADATA_COMMON_H__
+#define __GST_METADATA_COMMON_H__
+
+#include "metadata.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GstMetadataCommon GstMetadataCommon;
+
+typedef enum _tag_MetadataState
+{
+  MT_STATE_NULL,                /* still need to check media type */
+  MT_STATE_PARSED
+} MetadataState;
+
+struct _GstMetadataCommon {
+
+  MetaData metadata;
+  gint64 duration_orig;     /* durarion of stream */
+  gint64 duration;          /* durarion of modified stream */
+
+  GstBuffer * append_buffer;
+  MetadataState state;
+
+};
+
+extern void
+gst_metadata_common_init(GstMetadataCommon *common, gboolean parse, guint8 options);
+
+extern void
+gst_metadata_common_dispose(GstMetadataCommon *common);
+
+extern gboolean
+gst_metadata_common_strip_push_buffer (GstMetadataCommon *common, gint64 offset_orig,
+    GstBuffer ** prepend, GstBuffer ** buf);
+
+extern gboolean
+gst_metadata_common_translate_pos_to_orig (GstMetadataCommon *common,
+    gint64 pos, gint64 * orig_pos, GstBuffer ** buf);
+
+extern gboolean
+gst_metadata_common_calculate_offsets (GstMetadataCommon *common);
+
+extern void
+gst_metadata_common_update_segment_with_new_buffer (GstMetadataCommon *common,
+    guint8 ** buf, guint32 * size, MetadataChunkType type);
+
+extern const gchar *
+gst_metadata_common_get_type_name (int img_type);
+
+G_END_DECLS
+#endif /* __GST_METADATA_COMMON_H__ */

ext/metadata/gstmetadatademux.h

@@ -41,45 +41,40 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#ifndef __GST_METADATA_PARSE_H__
+#ifndef __GST_METADATA_DEMUX_H__
-#define __GST_METADATA_PARSE_H__
+#define __GST_METADATA_DEMUX_H__
 
 #include <gst/gst.h>
 
-#include "metadata.h"
+#include "gstmetadatacommon.h"
 
 G_BEGIN_DECLS
 /* #defines don't like whitespacey bits */
-#define GST_TYPE_METADATA_PARSE \
+#define GST_TYPE_METADATA_DEMUX \
-  (gst_metadata_parse_get_type())
+  (gst_metadata_demux_get_type())
-#define GST_METADATA_PARSE(obj) \
+#define GST_METADATA_DEMUX(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_PARSE,GstMetadataParse))
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_DEMUX,GstMetadataDemux))
-#define GST_METADATA_PARSE_CLASS(klass) \
+#define GST_METADATA_DEMUX_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_PARSE,GstMetadataParseClass))
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_DEMUX,GstMetadataDemuxClass))
-#define GST_IS_METADATA_PARSE(obj) \
+#define GST_IS_METADATA_DEMUX(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_PARSE))
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_DEMUX))
-#define GST_IS_METADATA_PARSE_CLASS(klass) \
+#define GST_IS_METADATA_DEMUX_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_PARSE))
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_DEMUX))
-typedef struct _GstMetadataParse GstMetadataParse;
+typedef struct _GstMetadataDemux GstMetadataDemux;
-typedef struct _GstMetadataParseClass GstMetadataParseClass;
+typedef struct _GstMetadataDemuxClass GstMetadataDemuxClass;
 
-typedef enum _tag_MetadataState
+struct _GstMetadataDemux
-{
-  MT_STATE_NULL,                /* still need to check media type */
-  MT_STATE_PARSED
-} MetadataState;
-
-struct _GstMetadataParse
 {
   GstElement element;
 
   GstPad *sinkpad, *srcpad;
 
+  GstMetadataCommon common;
+
   guint8 options;
 
   gboolean need_send_tag;
 
-  MetaData parse_data;
   GstAdapter *adapter_parsing;
   GstAdapter *adapter_holding;
   guint32 next_offset;
@@ -87,14 +82,9 @@ struct _GstMetadataParse
   ImageType img_type;
 
   gint64 offset_orig;  /* offset in original stream */
-  gint64 duration_orig;     /* durarion of stream */
   gint64 offset;       /* offset in current stream */
-  gint64 duration;     /* durarion of modified stream */
-
-  MetadataState state;
 
   GstBuffer * prepend_buffer;
-  GstBuffer * append_buffer;
 
   gboolean need_more_data;
 
@@ -102,12 +92,12 @@ struct _GstMetadataParse
 
 };
 
-struct _GstMetadataParseClass
+struct _GstMetadataDemuxClass
 {
   GstElementClass parent_class;
 };
 
-extern GType gst_metadata_parse_get_type (void);
+extern GType gst_metadata_demux_get_type (void);
 
 G_END_DECLS
-#endif /* __GST_METADATA_PARSE_H__ */
+#endif /* __GST_METADATA_DEMUX_H__ */

ext/metadata/gstmetadatamux.h

@@ -46,7 +46,7 @@
 
 #include <gst/gst.h>
 
-#include "metadata.h"
+#include "gstmetadatacommon.h"
 
 G_BEGIN_DECLS
 /* #defines don't like whitespacey bits */
@@ -63,21 +63,16 @@ G_BEGIN_DECLS
 typedef struct _GstMetadataMux GstMetadataMux;
 typedef struct _GstMetadataMuxClass GstMetadataMuxClass;
 
-typedef enum _tag_MetadataState
-{
-  MT_STATE_NULL,                /* still need to check media type */
-  MT_STATE_MUXED
-} MetadataState;
-
 struct _GstMetadataMux
 {
   GstElement element;
 
   GstPad *sinkpad, *srcpad;
 
+  GstMetadataCommon common;
+
   guint8 options;
 
-  MetaData mux_data;
   GstAdapter *adapter_parsing;
   GstAdapter *adapter_holding;
   guint32 next_offset;
@@ -85,14 +80,9 @@ struct _GstMetadataMux
   ImageType img_type;
 
   gint64 offset_orig;  /* offset in original stream */
-  gint64 duration_orig;     /* durarion of stream */
   gint64 offset;       /* offset in current stream */
-  gint64 duration;     /* durarion of modified stream */
-
-  MetadataState state;
 
   GstBuffer * prepend_buffer;
-  GstBuffer * append_buffer;
 
   gboolean need_more_data;
 

ext/metadata/metadataexif.c

@@ -89,7 +89,6 @@ typedef struct _tag_MapIntStr
 {
   ExifTag exif;
   const gchar *str;
-  GType type;
 } MapIntStr;
 
 static void
@@ -99,21 +98,21 @@ static void exif_content_foreach_entry_func (ExifEntry * entry, void *);
 
 /* *INDENT-OFF* */
 static MapIntStr mappedTags[] = {
-  {EXIF_TAG_MAKE,               /*EXIF_FORMAT_ASCII,*/     GST_TAG_DEVICE_MAKE,              G_TYPE_STRING},
+  {EXIF_TAG_MAKE,               /*ASCII,*/     GST_TAG_DEVICE_MAKE,              /*STRING*/},
-  {EXIF_TAG_MODEL,              /*EXIF_FORMAT_ASCII,*/     GST_TAG_DEVICE_MODEL,             G_TYPE_STRING},
+  {EXIF_TAG_MODEL,              /*ASCII,*/     GST_TAG_DEVICE_MODEL,             /*STRING*/},
-  {EXIF_TAG_SOFTWARE,           /*EXIF_FORMAT_ASCII,*/     GST_TAG_CREATOR_TOOL,             G_TYPE_STRING},
+  {EXIF_TAG_SOFTWARE,           /*ASCII,*/     GST_TAG_CREATOR_TOOL,             /*STRING*/},
-  {EXIF_TAG_X_RESOLUTION,       /*EXIF_FORMAT_RATIONAL,*/  GST_TAG_IMAGE_XRESOLUTION,        G_TYPE_FLOAT},   /* inches */
+  {EXIF_TAG_X_RESOLUTION,       /*RATIONAL,*/  GST_TAG_IMAGE_XRESOLUTION,        /*FRACTION*/},   /* inches */
-  {EXIF_TAG_Y_RESOLUTION,       /*EXIF_FORMAT_RATIONAL,*/  GST_TAG_IMAGE_YRESOLUTION,        G_TYPE_FLOAT},   /* inches */
+  {EXIF_TAG_Y_RESOLUTION,       /*RATIONAL,*/  GST_TAG_IMAGE_YRESOLUTION,        /*FRACTION*/},   /* inches */
-  {EXIF_TAG_EXPOSURE_TIME,      /*EXIF_FORMAT_RATIONAL,*/  GST_TAG_CAPTURE_EXPOSURE_TIME,    G_TYPE_FLOAT},
+  {EXIF_TAG_EXPOSURE_TIME,      /*RATIONAL,*/  GST_TAG_CAPTURE_EXPOSURE_TIME,    /*FRACTION*/},
-  {EXIF_TAG_FNUMBER,            /*EXIF_FORMAT_RATIONAL,*/  GST_TAG_CAPTURE_FNUMBER,          G_TYPE_FLOAT},
+  {EXIF_TAG_FNUMBER,            /*RATIONAL,*/  GST_TAG_CAPTURE_FNUMBER,          /*FRACTION*/},
-  {EXIF_TAG_EXPOSURE_PROGRAM,   /*EXIF_FORMAT_SHORT,*/     GST_TAG_CAPTURE_EXPOSURE_PROGRAM, G_TYPE_UINT},
+  {EXIF_TAG_EXPOSURE_PROGRAM,   /*SHORT,*/     GST_TAG_CAPTURE_EXPOSURE_PROGRAM, /*UINT*/},
-  {EXIF_TAG_BRIGHTNESS_VALUE,   /*EXIF_FORMAT_SRATIONAL,*/ GST_TAG_CAPTURE_BRIGHTNESS,       G_TYPE_FLOAT},
+  {EXIF_TAG_BRIGHTNESS_VALUE,   /*SRATIONAL,*/ GST_TAG_CAPTURE_BRIGHTNESS,       /*FRACTION*/},
-  {EXIF_TAG_WHITE_BALANCE,      /*EXIF_FORMAT_SHORT,*/     GST_TAG_CAPTURE_WHITE_BALANCE,    G_TYPE_UINT},
+  {EXIF_TAG_WHITE_BALANCE,      /*SHORT,*/     GST_TAG_CAPTURE_WHITE_BALANCE,    /*UINT*/},
-  {EXIF_TAG_DIGITAL_ZOOM_RATIO, /*EXIF_FORMAT_RATIONAL,*/  GST_TAG_CAPTURE_DIGITAL_ZOOM,     G_TYPE_FLOAT},
+  {EXIF_TAG_DIGITAL_ZOOM_RATIO, /*RATIONAL,*/  GST_TAG_CAPTURE_DIGITAL_ZOOM,     /*FRACTION*/},
-  {EXIF_TAG_GAIN_CONTROL,       /*EXIF_FORMAT_SHORT,*/     GST_TAG_CAPTURE_GAIN,             G_TYPE_UINT},
+  {EXIF_TAG_GAIN_CONTROL,       /*SHORT,*/     GST_TAG_CAPTURE_GAIN,             /*UINT*/},
-  {EXIF_TAG_CONTRAST,           /*EXIF_FORMAT_SHORT,*/     GST_TAG_CAPTURE_CONTRAST,         G_TYPE_INT},
+  {EXIF_TAG_CONTRAST,           /*SHORT,*/     GST_TAG_CAPTURE_CONTRAST,         /*INT*/},
-  {EXIF_TAG_SATURATION,         /*EXIF_FORMAT_SHORT,*/     GST_TAG_CAPTURE_SATURATION,       G_TYPE_INT},
+  {EXIF_TAG_SATURATION,         /*SHORT,*/     GST_TAG_CAPTURE_SATURATION,       /*INT*/},
-  {0, NULL, G_TYPE_NONE}
+  {0, NULL}
 };
 /* *INDENT-ON* */
 
@@ -123,12 +122,13 @@ metadataparse_exif_get_tag_from_exif (ExifTag exif, GType * type)
   int i = 0;
 
   while (mappedTags[i].exif) {
-    if (exif == mappedTags[i].exif)
+    if (exif == mappedTags[i].exif) {
+      *type = gst_tag_get_type (mappedTags[i].str);
       break;
+    }
     ++i;
   }
 
-  *type = mappedTags[i].type;
   return mappedTags[i].str;
 
 }
@@ -139,12 +139,13 @@ metadataparse_exif_get_exif_from_tag (const gchar * tag, GType * type)
   int i = 0;
 
   while (mappedTags[i].exif) {
-    if (0 == strcmp (mappedTags[i].str, tag))
+    if (0 == strcmp (mappedTags[i].str, tag)) {
+      *type = gst_tag_get_type (tag);
       break;
+    }
     ++i;
   }
 
-  *type = mappedTags[i].type;
   return mappedTags[i].exif;
 
 }
@@ -257,61 +258,59 @@ exif_content_foreach_entry_func (ExifEntry * entry, void *user_data)
     goto done;
   }
 
-  if (tag) {
+  if (!tag)
-    /* FIXME: create a generic function for this */
+    goto done;
-    /* could also be used with entry->format */
+
+  if (type == GST_TYPE_FRACTION) {
+    gint numerator = 0;
+    gint denominator = 1;
+
+    switch (entry->format) {
+      case EXIF_FORMAT_SRATIONAL:
+      {
+        ExifSRational v_srat;
+
+        v_srat = exif_get_srational (entry->data, byte_order);
+        if (v_srat.denominator) {
+          numerator = (gint) v_srat.numerator;
+          denominator = (gint) v_srat.denominator;
+        }
+      }
+        break;
+      case EXIF_FORMAT_RATIONAL:
+      {
+        ExifRational v_rat;
+
+        v_rat = exif_get_rational (entry->data, byte_order);
+        if (v_rat.denominator) {
+          numerator = (gint) v_rat.numerator;
+          denominator = (gint) v_rat.denominator;
+        }
+        if (meudata->resolution_unit == 3) {
+          /* converts from cm to inches */
+          if (entry->tag == EXIF_TAG_X_RESOLUTION
+              || entry->tag == EXIF_TAG_Y_RESOLUTION) {
+            numerator *= 2;
+            denominator *= 5;
+          }
+        }
+      }
+        break;
+      default:
+        GST_ERROR ("Unexpected Tag Type");
+        goto done;
+        break;
+    }
+    gst_tag_list_add (meudata->taglist, meudata->mode, tag, numerator,
+        denominator, NULL);
+
+  } else {
+
     switch (type) {
       case G_TYPE_STRING:
         gst_tag_list_add (meudata->taglist, meudata->mode, tag,
             exif_entry_get_value (entry, buf, sizeof (buf)), NULL);
         break;
-      case G_TYPE_FLOAT:
-      {
-        gfloat f_value;
-
-        switch (entry->format) {
-          case EXIF_FORMAT_SRATIONAL:
-          {
-            ExifSRational v_srat;
-
-            v_srat = exif_get_srational (entry->data, byte_order);
-            if (v_srat.denominator == 0)
-              f_value = 0.0f;
-            else
-              f_value = (float) v_srat.numerator / (float) v_srat.denominator;
-            if (v_srat.numerator == 0xFFFFFFFF) {
-              if (entry->tag == EXIF_TAG_BRIGHTNESS_VALUE) {
-                f_value = 100.0f;
-              }
-            }
-          }
-            break;
-          case EXIF_FORMAT_RATIONAL:
-          {
-            ExifRational v_rat;
-
-            v_rat = exif_get_rational (entry->data, byte_order);
-            if (v_rat.denominator == 0)
-              f_value = 0.0f;
-            else
-              f_value = (float) v_rat.numerator / (float) v_rat.denominator;
-            if (meudata->resolution_unit == 3) {
-              /* converts from cm to inches */
-              if (entry->tag == EXIF_TAG_X_RESOLUTION
-                  || entry->tag == EXIF_TAG_Y_RESOLUTION) {
-                f_value *= 0.4f;
-              }
-            }
-          }
-            break;
-          default:
-            GST_ERROR ("Unexpected Tag Type");
-            goto done;
-            break;
-        }
-        gst_tag_list_add (meudata->taglist, meudata->mode, tag, f_value, NULL);
-      }
-        break;
       case G_TYPE_INT:
         /* fall through */
       case G_TYPE_UINT:
@@ -350,8 +349,10 @@ exif_content_foreach_entry_func (ExifEntry * entry, void *user_data)
       default:
         break;
     }
+
   }
 
+
 done:
 
   GST_LOG ("\n    Entry %p: %s (%s)\n"
@@ -465,90 +466,82 @@ metadataexif_for_each_tag_in_list (const GstTagList * list, const gchar * tag,
     exif_entry_initialize (entry, exif_tag);
   }
 
-  switch (type) {
+  if (type == GST_TYPE_FRACTION) {
-    case G_TYPE_STRING:
+    const GValue *gvalue = gst_tag_list_get_value_index (list, tag, 0);
-    {
+    gint numerator = gst_value_get_fraction_numerator (gvalue);
-      gchar *value = NULL;
+    gint denominator = gst_value_get_fraction_denominator (gvalue);
 
-      if (gst_tag_list_get_string (list, tag, &value)) {
+    switch (entry->format) {
-        entry->components = strlen (value) + 1;
+      case EXIF_FORMAT_SRATIONAL:
-        entry->size = exif_format_get_size (entry->format) * entry->components;
+      {
-        entry->data = value;
+        ExifSRational sr = { numerator, denominator };
+
+        exif_set_srational (entry->data, byte_order, sr);
       }
-    }
+        break;
-      break;
+      case EXIF_FORMAT_RATIONAL:
-    case G_TYPE_FLOAT:
+      {
-    {
+        ExifRational r = { numerator, denominator };
-      gfloat value;
 
-      gst_tag_list_get_float (list, tag, &value);
+        exif_set_rational (entry->data, byte_order, r);
+        if (entry->tag == EXIF_TAG_X_RESOLUTION ||
+            entry->tag == EXIF_TAG_Y_RESOLUTION) {
+          ExifEntry *unit_entry = NULL;
 
-      switch (entry->format) {
+          if ((unit_entry = exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT))) {
-        case EXIF_FORMAT_SRATIONAL:
+            ExifShort vsh = exif_get_short (unit_entry->data, byte_order);
-        {
-          ExifSRational sr;
 
-          sr = float_to_srational (value);
+            if (vsh != 2)       /* inches */
-          if (entry->tag == EXIF_TAG_BRIGHTNESS_VALUE) {
+              exif_set_short (unit_entry->data, byte_order, 2);
-            if (value == 100.0f) {
-              sr.numerator = 0xFFFFFFFF;
-              sr.denominator = 1;
-            }
-          }
-
-          exif_set_srational (entry->data, byte_order, sr);
-        }
-          break;
-        case EXIF_FORMAT_RATIONAL:
-        {
-          ExifRational r;
-
-          r = float_to_rational (value);
-          exif_set_rational (entry->data, byte_order, r);
-          if (entry->tag == EXIF_TAG_X_RESOLUTION ||
-              entry->tag == EXIF_TAG_Y_RESOLUTION) {
-            ExifEntry *unit_entry = NULL;
-
-            if ((unit_entry =
-                    exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT))) {
-              ExifShort vsh = exif_get_short (unit_entry->data, byte_order);
-
-              if (vsh != 2)     /* inches */
-                exif_set_short (unit_entry->data, byte_order, 2);
-            }
           }
         }
-          break;
-        default:
-          break;
       }
+        break;
+      default:
+        break;
     }
-      break;
+  } else {
-    case G_TYPE_UINT:
-    case G_TYPE_INT:
-    {
-      gint value;
-      ExifShort v_short;
 
-      if (G_TYPE_UINT == type) {
+    switch (type) {
-        gst_tag_list_get_uint (list, tag, &value);
+      case G_TYPE_STRING:
-      } else {
+      {
-        gst_tag_list_get_int (list, tag, &value);
+        gchar *value = NULL;
+
+        if (gst_tag_list_get_string (list, tag, &value)) {
+          entry->components = strlen (value) + 1;
+          entry->size =
+              exif_format_get_size (entry->format) * entry->components;
+          entry->data = value;
+        }
       }
-      if (entry->tag == EXIF_TAG_CONTRAST || entry->tag == EXIF_TAG_SATURATION) {
+        break;
-        if (value < -33)
+      case G_TYPE_UINT:
-          value = 1;            /* low */
+      case G_TYPE_INT:
-        else if (value < 34)
+      {
-          value = 0;            /* normal */
+        gint value;
-        else
+        ExifShort v_short;
-          value = 2;            /* high */
+
+        if (G_TYPE_UINT == type) {
+          gst_tag_list_get_uint (list, tag, &value);
+        } else {
+          gst_tag_list_get_int (list, tag, &value);
+        }
+        if (entry->tag == EXIF_TAG_CONTRAST
+            || entry->tag == EXIF_TAG_SATURATION) {
+          if (value < -33)
+            value = 1;          /* low */
+          else if (value < 34)
+            value = 0;          /* normal */
+          else
+            value = 2;          /* high */
+        }
+        v_short = value;
+        exif_set_short (entry->data, byte_order, v_short);
       }
-      v_short = value;
+        break;
-      exif_set_short (entry->data, byte_order, v_short);
+      default:
+        break;
     }
-      break;
-    default:
-      break;
   }
 
 done:

ext/metadata/metadatatags.c

@@ -49,39 +49,6 @@
 
 static void
 metadata_tags_exif_register (void)
-{
-  gst_tag_register (GST_TAG_EXIF, GST_TAG_FLAG_META,
-      GST_TYPE_BUFFER, GST_TAG_EXIF, "exif metadata chunk", NULL);
-}
-
-/*
- * IPTC tags
- */
-
-static void
-metadata_tags_iptc_register (void)
-{
-  gst_tag_register (GST_TAG_IPTC, GST_TAG_FLAG_META,
-      GST_TYPE_BUFFER, GST_TAG_IPTC, "iptc metadata chunk", NULL);
-}
-
-/*
- * XMP tags
- */
-
-static void
-metadata_tags_xmp_register (void)
-{
-  gst_tag_register (GST_TAG_XMP, GST_TAG_FLAG_META,
-      GST_TYPE_BUFFER, GST_TAG_XMP, "xmp metadata chunk", NULL);
-}
-
-/*
- *
- */
-
-void
-metadata_tags_register (void)
 {
   /* devices tags */
 
@@ -101,20 +68,21 @@ metadata_tags_register (void)
 
   /* image tags */
 
-  gst_tag_register (GST_TAG_IMAGE_XRESOLUTION, GST_TAG_FLAG_META, G_TYPE_FLOAT,
+  gst_tag_register (GST_TAG_IMAGE_XRESOLUTION, GST_TAG_FLAG_META,
-      GST_TAG_IMAGE_XRESOLUTION, "Horizontal resolution in pixels per inch",
+      GST_TYPE_FRACTION, GST_TAG_IMAGE_XRESOLUTION,
-      NULL);
+      "Horizontal resolution in pixels per inch", NULL);
-  gst_tag_register (GST_TAG_IMAGE_YRESOLUTION, GST_TAG_FLAG_META, G_TYPE_FLOAT,
+  gst_tag_register (GST_TAG_IMAGE_YRESOLUTION, GST_TAG_FLAG_META,
-      GST_TAG_IMAGE_YRESOLUTION, "Vertical resolution in pixels per inch",
+      GST_TYPE_FRACTION, GST_TAG_IMAGE_YRESOLUTION,
-      NULL);
+      "Vertical resolution in pixels per inch", NULL);
 
   /* capture tags */
 
   gst_tag_register (GST_TAG_CAPTURE_EXPOSURE_TIME, GST_TAG_FLAG_META,
-      G_TYPE_FLOAT, GST_TAG_CAPTURE_EXPOSURE_TIME, "Exposure time in seconds",
+      GST_TYPE_FRACTION, GST_TAG_CAPTURE_EXPOSURE_TIME,
+      "Exposure time in seconds", NULL);
+  gst_tag_register (GST_TAG_CAPTURE_FNUMBER, GST_TAG_FLAG_META,
+      GST_TYPE_FRACTION, GST_TAG_CAPTURE_FNUMBER, "F number (focal ratio)",
       NULL);
-  gst_tag_register (GST_TAG_CAPTURE_FNUMBER, GST_TAG_FLAG_META, G_TYPE_FLOAT,
-      GST_TAG_CAPTURE_FNUMBER, "F number (focal ratio)", NULL);
   /**
     0 - not defined
     1- Manual
@@ -137,11 +105,11 @@ metadata_tags_register (void)
       "Class of program used for exposure", NULL);
   /** The unit is the APEX value.
       Ordinarily it is given in the range of -99.99 to 99.99.
-      100.0 mean unknown      
+      if numerator is 0xFFFFFFFF means unknown      
   */
-  gst_tag_register (GST_TAG_CAPTURE_BRIGHTNESS, GST_TAG_FLAG_META, G_TYPE_FLOAT,
+  gst_tag_register (GST_TAG_CAPTURE_BRIGHTNESS, GST_TAG_FLAG_META,
-      GST_TAG_CAPTURE_BRIGHTNESS, "Brightness (APEX from -99.99 to 99.99)",
+      GST_TYPE_FRACTION, GST_TAG_CAPTURE_BRIGHTNESS,
-      NULL);
+      "Brightness (APEX from -99.99 to 99.99)", NULL);
   /**
      0- Auto
      1- Off
@@ -160,7 +128,8 @@ metadata_tags_register (void)
   /** if Zero ZOOM not used
    */
   gst_tag_register (GST_TAG_CAPTURE_DIGITAL_ZOOM, GST_TAG_FLAG_META,
-      G_TYPE_FLOAT, GST_TAG_CAPTURE_DIGITAL_ZOOM, "Digital zoom ratio", NULL);
+      GST_TYPE_FRACTION, GST_TAG_CAPTURE_DIGITAL_ZOOM, "Digital zoom ratio",
+      NULL);
   /**
      0- None
      1- Low gain up
@@ -189,6 +158,49 @@ metadata_tags_register (void)
   gst_tag_register (GST_TAG_CAPTURE_SATURATION, GST_TAG_FLAG_META, G_TYPE_INT,
       GST_TAG_CAPTURE_SATURATION, "", NULL);
 
+}
+
+/*
+ * IPTC tags
+ */
+
+static void
+metadata_tags_iptc_register (void)
+{
+
+}
+
+/*
+ * XMP tags
+ */
+
+static void
+metadata_tags_xmp_register (void)
+{
+
+}
+
+/*
+ *
+ */
+
+void
+metadata_tags_register (void)
+{
+
+  /* whole chunk tags */
+
+  gst_tag_register (GST_TAG_EXIF, GST_TAG_FLAG_META,
+      GST_TYPE_BUFFER, GST_TAG_EXIF, "exif metadata chunk", NULL);
+
+  gst_tag_register (GST_TAG_IPTC, GST_TAG_FLAG_META,
+      GST_TYPE_BUFFER, GST_TAG_IPTC, "iptc metadata chunk", NULL);
+
+  gst_tag_register (GST_TAG_XMP, GST_TAG_FLAG_META,
+      GST_TYPE_BUFFER, GST_TAG_XMP, "xmp metadata chunk", NULL);
+
+  /* tags related to some metadata */
+
   metadata_tags_exif_register ();
   metadata_tags_iptc_register ();
   metadata_tags_xmp_register ();

ext/metadata/test/metadata_editor.c

@@ -160,33 +160,43 @@ change_tag_list (GstTagList ** list, const gchar * tag, const gchar * value)
 
   type = gst_tag_get_type (tag);
 
-  switch (type) {
+  if (type == GST_TYPE_FRACTION) {
-    case G_TYPE_STRING:
+    /* FIXME: Ask GStreamer guys to add GST_FRACTION support to TAGS */
-      gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, value, NULL);
+    /* Even better: ask GLib guys to add this type */
-      ret = TRUE;
+    gint n, d;
-      break;
-    case G_TYPE_FLOAT:
-    {
-      gfloat fv = (gfloat) g_strtod (value, NULL);
 
-      gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, fv, NULL);
+    sscanf (value, "%d/%d", &n, &d);
-      ret = TRUE;
+    gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, n, d, NULL);
-    }
+    ret = TRUE;
-      break;
+  } else {
-    case G_TYPE_INT:
+    switch (type) {
-      /* fall through */
+      case G_TYPE_STRING:
-    case G_TYPE_UINT:
+        gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, value, NULL);
-    {
+        ret = TRUE;
-      gint iv = atoi (value);
+        break;
+      case G_TYPE_FLOAT:
+      {
+        gfloat fv = (gfloat) g_strtod (value, NULL);
 
-      gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, iv, NULL);
+        gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, fv, NULL);
-      ret = TRUE;
+        ret = TRUE;
+      }
+        break;
+      case G_TYPE_INT:
+        /* fall through */
+      case G_TYPE_UINT:
+      {
+        gint iv = atoi (value);
+
+        gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, iv, NULL);
+        ret = TRUE;
+      }
+        break;
+      default:
+        fprintf (stderr, "This app still doesn't handle type (%s)(%ld)\n",
+            g_type_name (type), type);
+        break;
     }
-      break;
-    default:
-      fprintf (stderr, "This app still doesn't handle type (%s)(%ld)\n",
-          g_type_name (type), type);
-      break;
   }
 
 done:
@@ -700,7 +710,7 @@ me_gst_setup_encode_pipeline (const gchar * src_file, const gchar * dest_file,
 
   /* create elements */
   gst_source = gst_element_factory_make ("filesrc", NULL);
-  gst_metadata_demux = gst_element_factory_make ("metadataparse", NULL);
+  gst_metadata_demux = gst_element_factory_make ("metadatademux", NULL);
   gst_metadata_mux = gst_element_factory_make ("metadatamux", NULL);
   gst_file_sink = gst_element_factory_make ("filesink", NULL);
 
@@ -767,7 +777,7 @@ me_gst_setup_view_pipeline (const gchar * filename, GdkWindow * window)
 
   /* create elements */
   gst_source = gst_element_factory_make ("filesrc", NULL);
-  gst_metadata_demux = gst_element_factory_make ("metadataparse", NULL);
+  gst_metadata_demux = gst_element_factory_make ("metadatademux", NULL);
   /* let's do a dummy stuff to avoid decodebin */
   if (is_png (filename))
     gst_image_dec = gst_element_factory_make ("pngdec", NULL);