Add some documentation.

Original commit message from CVS:
Add some documentation.

8 files changed, 1285 insertions, 818 deletions

diff --git a/ext/metadata/TODO b/ext/metadata/TODO
index 35c7eb8a..c6f837f5 100644
--- a/ext/metadata/TODO
+++ b/ext/metadata/TODO
@@ -22,6 +22,7 @@ OPEN ISSUES:
 4- Add GST_TYPE_FRACTION support for GStreamer TAGS
 5- currently, in JPEG files, if there is a Photoshop segment, everything inside it but IPTC will be lost. From the point of view of implementation it is easy, but I still don't now how to solve from the point of view of "designing". Anyway I think it is not so important.
 6- language is not considered in XMP (How to do it with GStreamer?)
+7- Add a helper function that convert from value to string. For example, aperture-size is 2.7 and the app wants to show "f/2.7", 'contrast' is a range and the app wants to show as "Normal", "Soft", "Hard". For the time being it is up to the APP to make this conversion.
 
 KNOWN BUGS
 
diff --git a/ext/metadata/gstbasemetadata.c b/ext/metadata/gstbasemetadata.c
index 75b515fd..011cd5ba 100644
--- a/ext/metadata/gstbasemetadata.c
+++ b/ext/metadata/gstbasemetadata.c
@@ -42,16 +42,57 @@
  */
 
 /**
- * SECTION:metadatabase-metadata
+ * SECTION: gstbasemetadata
+ * @short_description: Base class for metadata handling elements
+ *
+ * This is a generice base class for metadata handling elements. The following
+ * types of elements are supported:
+ * <itemizedlist>
+ *   <listitem><para>parsers (only parse data)</para></listitem>
+ *   <listitem><para>demuxers (parse data and remove metadata chunks)</para>
+ *   </listitem>
+ *   <listitem><para>muxers</para></listitem>
+ *   <listitem><para>any other kind of element that wants to handle chunks in
+ *     file formats based on chunks</para></listitem>
+ * </itemizedlist>
  *
  * <refsect2>
- * <title>Example launch line</title>
  * <para>
- * <programlisting>
- * gst-launch -v -m filesrc location=./test.jpeg ! metadatabase ! fakesink silent=TRUE
- * </programlisting>
+ * This a abstract element that parses a stream and find chunks and offset
+ * where new chunks could be injected into it.
+ * Basically, the only thing need by implementors (parsers, (de)muxers) is to
+ * set virtual methods that will be used to setup the caps and do some
+ * 'processing', which is called after the stream is completely parsed and
+ * before the first buffer is sent to the next element. Usualy the 'processing'
+ * function will send tags messages and event in case of parsers and demuxers,
+ * and add chunks to be injected (using the helper function
+ * #gst_base_metadata_update_inject_segment_with_new_data in case of muxers.
+ * </para>
+ * <para>
+ * This can work in 'pull' and 'push' scheduling modes. In case of push mode,
+ * the stream will be parsed during sink activation if #gst_pad_get_range is
+ * available on upstream element. If get_range function is not available
+ * upstream, then the data will be hold until the stream is completly parsed,
+ * and then after that the fisrt buffer will be pushed downstream. The same
+ * happens with pull mode, if the downstream element calls gst_pad_get_range
+ * it will only gets data after the stream has been completely parsed.
+ * </para>
+ * <para>
+ * Seek, and query duration will only be available after the stream has been
+ * parsed. Query position will always be 0 (zero) before the stream is
+ * completely parsed.
+ * </para>
+ * <para>
+ * Currently there is implementation for JPEG and PNG (demux mode only)
+ * stream types and EXIF, IPTC and XMP metadatas.
  * </para>
  * </refsect2>
+ * 
+ * Last reviewed on 2008-01-21 (0.10.15)
+ */
+
+/*
+ * includes
  */
 
 #ifdef HAVE_CONFIG_H
@@ -62,24 +103,16 @@
 
 #include "gstbasemetadata.h"
 
-#include "metadataexif.h"
-
-#include "metadataiptc.h"
-
 #include "metadataxmp.h"
 
 #include <string.h>
 
-GST_DEBUG_CATEGORY_STATIC (gst_base_metadata_debug);
-#define GST_CAT_DEFAULT gst_base_metadata_debug
-
-#define GOTO_DONE_IF_NULL(ptr) do { if ( NULL == (ptr) ) goto done; } while(FALSE)
-#define GOTO_DONE_IF_NULL_AND_FAIL(ptr, ret) do { if ( NULL == (ptr) ) { (ret) = FALSE; goto done; } } while(FALSE)
+/*
+ * enum and types
+ */
 
-/* Filter signals and args */
 enum
 {
-  /* FILL ME */
   LAST_SIGNAL
 };
 
@@ -91,25 +124,88 @@ enum
   ARG_XMP
 };
 
+/*
+ * defines and static global vars
+ */
+
+GST_DEBUG_CATEGORY_STATIC (gst_base_metadata_debug);
+#define GST_CAT_DEFAULT gst_base_metadata_debug
+
 static GstBaseMetadataClass *parent_class = NULL;
 
+/*
+ * static helper functions declaration
+ */
+
+static void gst_base_metadata_init_members (GstBaseMetadata * filter);
+
+static void gst_base_metadata_dispose_members (GstBaseMetadata * filter);
+
+const gchar *gst_base_metadata_get_type_name (int img_type);
+
+static gboolean gst_base_metadata_pull_range_parse (GstBaseMetadata * filter);
+
+static gboolean gst_base_metadata_configure_caps (GstBaseMetadata * filter);
+
+static gboolean gst_base_metadata_processing (GstBaseMetadata * filter);
+
+static void gst_base_metadata_reset_streaming (GstBaseMetadata * filter);
+
+static void gst_base_metadata_reset_parsing (GstBaseMetadata * filter);
+
+static int
+gst_base_metadata_parse (GstBaseMetadata * filter, const guint8 * buf,
+    guint32 size);
+
+static gboolean
+gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
+    gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf);
+
+static int
+gst_base_metadata_buf_get_intersection_seg (const gint64 offset, guint32 size,
+    const gint64 seg_offset, const guint32 seg_size,
+    gint64 * boffset, guint32 * bsize);
+
+static gboolean
+gst_base_metadata_translate_pos_to_orig (GstBaseMetadata * base,
+    gint64 pos, gint64 * orig_pos, GstBuffer ** buf);
+
+static gboolean gst_base_metadata_calculate_offsets (GstBaseMetadata * base);
+
+
+/*
+ * GObject callback functions declaration
+ */
+
+static void gst_base_metadata_base_init (gpointer gclass);
+
+static void gst_base_metadata_class_init (GstBaseMetadataClass * klass);
+
+static void
+gst_base_metadata_init (GstBaseMetadata * filter,
+    GstBaseMetadataClass * gclass);
+
 static void gst_base_metadata_dispose (GObject * object);
 
 static void gst_base_metadata_finalize (GObject * object);
 
 static void gst_base_metadata_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec);
+
 static void gst_base_metadata_get_property (GObject * object, guint prop_id,
     GValue * value, GParamSpec * pspec);
 
+/*
+ * GStreamer callback functions declaration
+ */
+
 static GstStateChangeReturn
 gst_base_metadata_change_state (GstElement * element,
     GstStateChange transition);
 
 static gboolean gst_base_metadata_src_event (GstPad * pad, GstEvent * event);
-static gboolean gst_base_metadata_sink_event (GstPad * pad, GstEvent * event);
 
-static GstFlowReturn gst_base_metadata_chain (GstPad * pad, GstBuffer * buf);
+static gboolean gst_base_metadata_sink_event (GstPad * pad, GstEvent * event);
 
 static gboolean gst_base_metadata_checkgetrange (GstPad * srcpad);
 
@@ -117,31 +213,20 @@ static GstFlowReturn
 gst_base_metadata_get_range (GstPad * pad, guint64 offset_orig, guint size,
     GstBuffer ** buf);
 
+static GstFlowReturn gst_base_metadata_chain (GstPad * pad, GstBuffer * buf);
+
 static gboolean gst_base_metadata_sink_activate (GstPad * pad);
 
 static gboolean
 gst_base_metadata_src_activate_pull (GstPad * pad, gboolean active);
 
-static gboolean gst_base_metadata_pull_range_base (GstBaseMetadata * filter);
-
-static void gst_base_metadata_init_members (GstBaseMetadata * filter);
-static void gst_base_metadata_dispose_members (GstBaseMetadata * filter);
-
-static gboolean gst_base_metadata_configure_caps (GstBaseMetadata * filter);
-
-static int
-gst_base_metadata_parse (GstBaseMetadata * filter, const guint8 * buf,
-    guint32 size);
-
 static const GstQueryType *gst_base_metadata_get_query_types (GstPad * pad);
 
 static gboolean gst_base_metadata_src_query (GstPad * pad, GstQuery * query);
 
-static void gst_base_metadata_base_init (gpointer gclass);
-static void gst_base_metadata_class_init (GstBaseMetadataClass * klass);
-static void
-gst_base_metadata_init (GstBaseMetadata * filter,
-    GstBaseMetadataClass * gclass);
+/*
+ * GST BOILERPLATE
+ */
 
 GType
 gst_base_metadata_get_type (void)
@@ -167,99 +252,411 @@ gst_base_metadata_get_type (void)
   return base_metadata_type;
 }
 
-/* static helper function */
-
 /*
- * 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 helper functions implementation
  */
 
-static int
-gst_base_metadata_get_strip_seg (const gint64 offset, guint32 size,
-    const gint64 seg_offset, const guint32 seg_size,
-    gint64 * boffset, guint32 * bsize, guint32 * seg_binter)
+static void
+gst_base_metadata_init_members (GstBaseMetadata * filter)
 {
-  int ret = -1;
 
-  *boffset = -1;
-  *bsize = 0;
-  *seg_binter = -1;
+  filter->metadata = NULL;
 
-  /* all segment after buffer */
-  if (seg_offset >= offset + size) {
-    ret = 1;
+  filter->img_type = IMG_NONE;
+
+  filter->duration_orig = 0;
+  filter->duration = 0;
+
+  filter->state = MT_STATE_NULL;
+
+  filter->options = META_OPT_EXIF | META_OPT_IPTC | META_OPT_XMP;
+
+  filter->need_processing = FALSE;
+
+  filter->adapter_parsing = NULL;
+  filter->adapter_holding = NULL;
+  filter->next_offset = 0;
+  filter->next_size = 0;
+  filter->need_more_data = FALSE;
+  filter->offset_orig = 0;
+  filter->offset = 0;
+
+  filter->append_buffer = NULL;
+  filter->prepend_buffer = NULL;
+
+}
+
+static void
+gst_base_metadata_dispose_members (GstBaseMetadata * filter)
+{
+
+  /* buffers used to build output buffer */
+
+  if (filter->prepend_buffer) {
+    gst_buffer_unref (filter->prepend_buffer);
+    filter->prepend_buffer = NULL;
+  }
+
+  if (filter->append_buffer) {
+    gst_buffer_unref (filter->append_buffer);
+    filter->append_buffer = NULL;
+  }
+
+  /* adapter used during parsing process */
+
+  if (filter->adapter_parsing) {
+    gst_object_unref (filter->adapter_parsing);
+    filter->adapter_parsing = NULL;
+  }
+
+  if (filter->adapter_holding) {
+    gst_object_unref (filter->adapter_holding);
+    filter->adapter_holding = NULL;
+  }
+
+  metadata_dispose (&filter->metadata);
+
+}
+
+const gchar *
+gst_base_metadata_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;
+}
+
+static gboolean
+gst_base_metadata_pull_range_parse (GstBaseMetadata * filter)
+{
+
+  int res;
+  gboolean ret = TRUE;
+  guint32 offset = 0;
+  gint64 duration = 0;
+  GstFormat format = GST_FORMAT_BYTES;
+
+  if (!(ret =
+          gst_pad_query_peer_duration (filter->sinkpad, &format, &duration))) {
+    /* this should never happen, but try chain anyway */
+    ret = TRUE;
     goto done;
   }
+  filter->duration_orig = duration;
 
-  if (seg_offset < offset) {
-    /* segment start somewhere before buffer */
+  if (format != GST_FORMAT_BYTES) {
+    /* this should never happen, but try chain anyway */
+    ret = TRUE;
+    goto done;
+  }
 
-    /* all segment before buffer */
-    if (seg_offset + seg_size <= offset) {
-      ret = -1;
-      goto done;
+  do {
+    GstFlowReturn flow;
+    GstBuffer *buf = NULL;
+
+    offset += filter->next_offset;
+
+    /* 'filter->next_size' only says the minimum required number of bytes.
+       We try provided more bytes (4096) just to avoid a lot of calls to
+       'metadata_parse'
+       returning META_PARSING_NEED_MORE_DATA */
+    if (filter->next_size < 4096) {
+      if (duration - offset < 4096) {
+        /* In case there is no 4096 bytes available upstream.
+           It should be done upstream but we do here for safety */
+        filter->next_size = duration - offset;
+      } else {
+        filter->next_size = 4096;
+      }
     }
 
-    *seg_binter = offset - seg_offset;
-    *boffset = 0;
+    flow =
+        gst_pad_pull_range (filter->sinkpad, offset, filter->next_size, &buf);
+    if (GST_FLOW_OK != flow) {
+      ret = FALSE;
+      goto done;
+    }
 
-    /* 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;
+    res =
+        gst_base_metadata_parse (filter, GST_BUFFER_DATA (buf),
+        GST_BUFFER_SIZE (buf));
+    if (res == META_PARSING_ERROR) {
+      ret = FALSE;
+      goto done;
     }
 
-    ret = 0;
+    gst_buffer_unref (buf);
 
-  } else {
-    /* segment start somewhere into buffer */
+  } while (res == META_PARSING_NEED_MORE_DATA);
 
-    *boffset = seg_offset - offset;
-    *seg_binter = 0;
+done:
 
-    if (seg_offset + seg_size <= offset + size) {
-      /* all segment into buffer */
-      *bsize = seg_size;
-    } else {
-      *bsize = size - *boffset;
-    }
+  return ret;
 
-    ret = 0;
+}
+
+static gboolean
+gst_base_metadata_configure_caps (GstBaseMetadata * filter)
+{
+  GstCaps *caps = NULL;
+  gboolean ret = FALSE;
+  gchar *mime = NULL;
+  GstPad *peer = NULL;
+
+  peer = gst_pad_get_peer (filter->sinkpad);
+
+  switch (filter->img_type) {
+    case IMG_JPEG:
+      mime = "image/jpeg";
+      break;
+    case IMG_PNG:
+      mime = "image/png";
+      break;
+    default:
+      goto done;
+      break;
+  }
+
+  caps = gst_caps_new_simple (mime, NULL);
 
+  if (!gst_pad_set_caps (peer, caps)) {
+    goto done;
   }
 
+  ret = gst_pad_set_caps (filter->sinkpad, caps);
+
 done:
 
+  if (caps) {
+    gst_caps_unref (caps);
+    caps = NULL;
+  }
+
+  if (peer) {
+    gst_object_unref (peer);
+    peer = NULL;
+  }
+
   return ret;
 
 }
 
 /*
- * extern functions declaration
+ * gst_base_metadata_processing:
+ * @filter: the base metadata instance
+ *
+ * Do some external 'process', if not done yet, just after parse the stream
+ * and before give the fisrt buffer downstream.
+ * Typically here the tag message and events will be sent, in case of demuxer
+ * and new chunks will be added in case of muxers.
+ * @see_also: #gst_base_metadata_calculate_offsets
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%TRUE no need futher processing, or the processing has
+ * been done</para></listitem>
+ * <listitem><para>%FALSE, if error. It is, need futher processing but
+ * #gst_base_metadata_calculate_offsets fails</para></listitem>
+ * </itemizedlist>
+ *
  */
 
+static gboolean
+gst_base_metadata_processing (GstBaseMetadata * filter)
+{
+  gboolean ret = TRUE;
+  GstBaseMetadataClass *bclass = GST_BASE_METADATA_GET_CLASS (filter);
+
+  if (filter->need_processing) {
+    bclass->processing (filter);
+    if (gst_base_metadata_calculate_offsets (filter)) {
+      filter->need_processing = FALSE;
+    } else {
+      ret = FALSE;
+    }
+  }
+
+  return ret;
+
+}
+
+/*
+ * gst_base_metadata_reset_streaming:
+ * @filter: the base metadata instance
+ *
+ * Clean the streaming process. The parser status is not changed.
+ * @see_also: #gst_base_metadata_reset_parsing
+ *
+ * Returns: nothing
+ *
+ */
+
+static void
+gst_base_metadata_reset_streaming (GstBaseMetadata * filter)
+{
+  filter->offset_orig = 0;
+  filter->offset = 0;
+  if (filter->adapter_holding)
+    gst_adapter_clear (filter->adapter_holding);
+}
+
+/*
+ * gst_base_metadata_reset_parsing:
+ * @filter: the base metadata instance
+ *
+ * Reset the parsing process to start from the beginning again.
+ * @see_also: #gst_base_metadata_reset_streaming
+ *
+ * Returns: nothing
+ *
+ */
+
+static void
+gst_base_metadata_reset_parsing (GstBaseMetadata * filter)
+{
+
+
+  if (filter->prepend_buffer) {
+    gst_buffer_unref (filter->prepend_buffer);
+    filter->prepend_buffer = NULL;
+  }
+
+  if (filter->append_buffer) {
+    gst_buffer_unref (filter->append_buffer);
+    filter->append_buffer = NULL;
+  }
+
+  if (filter->adapter_parsing)
+    gst_adapter_clear (filter->adapter_parsing);
+
+  if (filter->adapter_holding)
+    gst_adapter_clear (filter->adapter_holding);
+
+  filter->img_type = IMG_NONE;
+  filter->duration_orig = 0;
+  filter->duration = 0;
+  filter->state = MT_STATE_NULL;
+  filter->need_processing = FALSE;
+  filter->next_offset = 0;
+  filter->next_size = 0;
+  filter->need_more_data = FALSE;
+  filter->offset_orig = 0;
+  filter->offset = 0;
+
+  metadata_dispose (&filter->metadata);
+
+}
+
 /*
+ * gst_base_metadata_parse
+ * @filter: the base metadata instance
+ * @buf: buffer to be parsed
+ * @size: size of the buffer in bytes
+ *
+ * Parse the current buffer.
+ * This buffer must be provided by another function wich keeps track of the
+ * correct offset in the input stream.* 
+ * If this function returns META_PARSING_NEED_MORE_DATA, the calling function
+ * must look at @filter->next_offset and @filter->next_size to jump (forward)
+ * in input stream to provide the correct data in @buf for the next call.
+ * @see_also: #gst_base_metadata_pull_range_parse #gst_base_metadata_chain
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%META_PARSING_ERROR if there was an error</para></listitem>
+ * <listitem><para>%META_PARSING_DONE if the parse has completly finished
+ * </para></listitem>
+ * <listitem><para>%META_PARSING_NEED_MORE_DATA if need another buffer</para>
+ * </listitem>
+ * </itemizedlist>
+ */
+
+static int
+gst_base_metadata_parse (GstBaseMetadata * filter, const guint8 * buf,
+    guint32 size)
+{
+
+  int ret = META_PARSING_ERROR;
+
+  filter->next_offset = 0;
+  filter->next_size = 0;
+
+  ret = metadata_parse (filter->metadata, buf, size,
+      &filter->next_offset, &filter->next_size);
+
+  if (ret == META_PARSING_ERROR) {
+    if (META_DATA_IMG_TYPE (filter->metadata) == IMG_NONE) {
+      /* image type not recognized */
+      GST_ELEMENT_ERROR (filter, STREAM, TYPE_NOT_FOUND, (NULL),
+          ("Only jpeg and png are supported"));
+      goto done;
+    }
+  } else if (ret == META_PARSING_NEED_MORE_DATA) {
+    filter->need_more_data = TRUE;
+  } else {
+    filter->state = MT_STATE_PARSED;
+    filter->need_more_data = FALSE;
+    filter->need_processing = TRUE;
+  }
+
+  /* reconfigure caps if it is different from type detected by 'base_metadata'
+     function */
+  if (filter->img_type != META_DATA_IMG_TYPE (filter->metadata)) {
+    filter->img_type = META_DATA_IMG_TYPE (filter->metadata);
+    if (!gst_base_metadata_configure_caps (filter)) {
+      GST_ELEMENT_ERROR (filter, STREAM, FORMAT, (NULL),
+          ("Couldn't reconfigure caps for %s",
+              gst_base_metadata_get_type_name (filter->img_type)));
+      ret = META_PARSING_ERROR;
+      goto done;
+    }
+  }
+
+done:
+
+  return ret;
+
+}
+
 
 /*
- *  TRUE -> buffer striped or injeted
- *  FALSE -> buffer unmodified
+ * gst_base_metadata_strip_push_buffer:
+ * @base: the base metadata instance
+ * @offset_orig: the offset in original input stream of the buffer that will
+ * have data striped or injected
+ * @prepend: a buffer (can be NULL) that will be completely injected in the
+ * beginning og @buf
+ * @buf: a pointer to a buffer that will be modified (data striped/injected or
+ * prepended)
+ *
+ * Strip bytes from @buf that are part of some chunk that will be striped. Add
+ * a whole injected chunk if some inject chunk starts into the buffer. Prepend
+ * additonal data if @prepend is not NULL. After using the @prepend buffer it
+ * will be release and set to NULL.
+ * @see_also: #gst_base_metadata_get_range #gst_base_metadata_chain
+ * #gst_base_metadata_buf_get_intersection_seg
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%TRUE if the buffer has been striped or injected (@prepend
+ * doesn't change the return value).</para></listitem>
+ * <listitem><para>%FALSE if it hasn't changed.</para></listitem>
+ * </itemizedlist>
+ *
  */
 
-gboolean
+static gboolean
 gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
     gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf)
 {
@@ -268,13 +665,12 @@ gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
   const gsize strip_len = META_DATA_STRIP_CHUNKS (base->metadata).len;
   const gsize inject_len = META_DATA_INJECT_CHUNKS (base->metadata).len;
 
-  gboolean buffer_reallocated = FALSE;
+  gboolean buffer_is_ok_to_change = 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;
@@ -284,6 +680,12 @@ gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
 
   guint32 prepend_size = prepend && *prepend ? GST_BUFFER_SIZE (*prepend) : 0;
 
+  /*
+   * check all the 'inject chunks' having the 'original offset' starting into
+   * the buffer
+   * and calculates how many bytes will be injectd
+   */
+
   if (inject_len) {
 
     for (i = 0; i < inject_len; ++i) {
@@ -302,31 +704,38 @@ gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
   }
 
   /*
-   * strip segments
+   * strip step
    */
 
   if (strip_len == 0)
     goto inject;
 
+  /* just try to do fast allocation on stack */
   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);
 
+  /*
+   * calculate the number of bytes from the buffer bytes that intersect some
+   * 'strip chunk'.
+   * also get the position and size of segments into current buffer
+   * (boffset_strip[i] and bsize_strip[i])
+   * that will be striped
+   */
+
   for (i = 0; i < strip_len; ++i) {
     int res;
 
-    res = gst_base_metadata_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]);
+    res = gst_base_metadata_buf_get_intersection_seg (offset_orig, size_buf_in,
+        strip[i].offset_orig, strip[i].size,
+        &boffset_strip[i], &bsize_strip[i]);
 
     /* segment is after size (segments are sorted) */
     striped_bytes += bsize_strip[i];
@@ -340,8 +749,10 @@ gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
 
     guint8 *data;
 
-    if (!buffer_reallocated) {
-      buffer_reallocated = TRUE;
+    if (!buffer_is_ok_to_change) {
+      /* create a new buffer if there is no space on currect buffer or if is
+         read-only */
+      buffer_is_ok_to_change = TRUE;
       if (injected_bytes + prepend_size > striped_bytes) {
         GstBuffer *new_buf =
             gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
@@ -365,6 +776,7 @@ gst_base_metadata_strip_push_buffer (GstBaseMetadata * base,
 
     data = GST_BUFFER_DATA (*buf);
 
+    /* strip out the bytes from buffer */
     striped_bytes = 0;
     for (i = 0; i < strip_len; ++i) {
       /* intersect */
@@ -390,8 +802,10 @@ inject:
     guint8 *data;
     guint32 striped_so_far;
 
-    if (!buffer_reallocated) {
-      buffer_reallocated = TRUE;
+    if (!buffer_is_ok_to_change) {
+      /* create a new buffer fs there is no space on currect buffer or if is
+         read-only */
+      buffer_is_ok_to_change = TRUE;
       if (injected_bytes + prepend_size > striped_bytes) {
         GstBuffer *new_buf =
             gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
@@ -428,6 +842,9 @@ inject:
           break;
       }
 
+      /* inject the whole inject chunk if the 'original offset' is inside the
+         original buffer */
+
       if (inject[i].offset_orig >= offset_orig) {
         if (inject[i].offset_orig <
             offset_orig + size_buf_in + striped_bytes - injected_bytes) {
@@ -476,7 +893,6 @@ done:
   if (need_free_strip) {
     g_free (boffset_strip);
     g_free (bsize_strip);
-    g_free (seg_binter_strip);
   }
 
   return injected_bytes || striped_bytes;
@@ -484,12 +900,111 @@ done:
 }
 
 /*
- * pos - position in stream striped
- * orig_pos - position in original stream
- * return TRUE - position in original buffer
- *        FALSE - position in inserted chunk
+ * gst_base_metadata_buf_get_intersection_seg:
+ * @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
+ *
+ * Calculate which bytes into the buffer given by @offset and @size intersetcs
+ * the segment given by @seg_offset and @seg_size
+ * @see_also: #gst_base_metadata_strip_push_buffer
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%-1 if the segment is completly before the buffer</para>
+ * </listitem>
+ * <listitem><para>%0 if the segment intersects</para></listitem>
+ * <listitem><para>%1 if the segment is after the buffer</para></listitem>
+ * </itemizedlist>
  */
-gboolean
+
+static int
+gst_base_metadata_buf_get_intersection_seg (const gint64 offset, guint32 size,
+    const gint64 seg_offset, const guint32 seg_size,
+    gint64 * boffset, guint32 * bsize)
+{
+  int ret = -1;
+
+  *boffset = -1;
+  *bsize = 0;
+
+  /* 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;
+    }
+
+    *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 - (offset - seg_offset);
+    }
+
+    ret = 0;
+
+  } else {
+    /* segment start somewhere into buffer */
+
+    *boffset = seg_offset - offset;
+
+    if (seg_offset + seg_size <= offset + size) {
+      /* all segment into buffer */
+      *bsize = seg_size;
+    } else {
+      *bsize = size - *boffset;
+    }
+
+    ret = 0;
+
+  }
+
+done:
+
+  return ret;
+
+}
+
+/*
+ * gst_base_metadata_translate_pos_to_orig:
+ * @base: the base metadata instance
+ * @pos: position in output stream
+ * @orig_pos: position in original stream
+ * @buf: if not NULL, will have data that starts at some point into a injected
+ * chunk
+ *
+ * Given a position in output stream (@pos), returns the position in original 
+ * stream (@orig_pos) that contains the same data. If @pos is into a injected
+ * chunk, @orig_pos will contains the position just after the position in which
+ * the chunk has been insert and @buf (if non null) will be filled with
+ * injected bytes starting in @pos until the and of injected chunk.
+ * @see_also: #gst_base_metadata_src_event #gst_base_metadata_get_range
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%TRUE if @pos is in original buffer</para></listitem>
+ * <listitem><para>%FALSE if @pos is into a injected chunk</para></listitem>
+ * </itemizedlist>
+ *
+ */
+
+static gboolean
 gst_base_metadata_translate_pos_to_orig (GstBaseMetadata * base,
     gint64 pos, gint64 * orig_pos, GstBuffer ** buf)
 {
@@ -585,13 +1100,24 @@ done:
 }
 
 /*
- * return:
- *   -1 -> error
- *    0 -> succeded
- *    1 -> need more data
+ * gst_base_metadata_calculate_offsets:
+ * @base: the base metadata instance
+ *
+ * Recalculates the offset of injected chunks after take in account new sizes
+ * written by the 'muxers elements' and wrapped with bytes by the correct
+ * file type handler.
+ * @see_also: #gst_base_metadata_processing #metadata_lazy_update
+ * #gst_base_metadata_update_inject_segment_with_new_data
+ *
+ * Returns:
+ * <itemizedlist>
+ * <listitem><para>%TRUE if succeded</para></listitem>
+ * <listitem><para>%FALSE if fails. Which happens if the stream hasn't been
+ * completely parsed yet</para></listitem>
+ * </itemizedlist>
  */
 
-gboolean
+static gboolean
 gst_base_metadata_calculate_offsets (GstBaseMetadata * base)
 {
   int i, j;
@@ -601,9 +1127,15 @@ gst_base_metadata_calculate_offsets (GstBaseMetadata * base)
   MetadataChunk *inject = META_DATA_INJECT_CHUNKS (base->metadata).chunk;
   gsize strip_len;
   gsize inject_len;
+  gboolean ret = TRUE;
 
-  if (base->state != MT_STATE_PARSED)
-    return FALSE;
+  if (base->state != MT_STATE_PARSED) {
+    ret = FALSE;
+    goto done;
+  }
+
+  metadata_chunk_array_remove_zero_size (&META_DATA_INJECT_CHUNKS (base->
+          metadata));
 
   metadata_lazy_update (base->metadata);
 
@@ -626,7 +1158,11 @@ gst_base_metadata_calculate_offsets (GstBaseMetadata * base)
     bytes_inject += inject[i].size;
   }
 
-  /* calculate append (doesnt make much sense, but, anyway..) */
+  /* FIXME: For the time being we don't have append buffers 'cause in the case
+     of files we are handling it is not possible to append after the last byte
+     on original stream (which is part of a kind of end-of-file chunk) */
+#if 0
+  /* calculate append buffer */
   append_size = 0;
   for (i = inject_len - 1; i >= 0; --i) {
     if (inject[i].offset_orig == base->duration_orig)
@@ -649,6 +1185,7 @@ gst_base_metadata_calculate_offsets (GstBaseMetadata * base)
       }
     }
   }
+#endif
 
   if (base->duration_orig) {
     base->duration = base->duration_orig;
@@ -660,32 +1197,16 @@ gst_base_metadata_calculate_offsets (GstBaseMetadata * base)
     }
   }
 
-  return TRUE;
-
-}
+done:
 
-const gchar *
-gst_base_metadata_get_type_name (int img_type)
-{
-  gchar *type_name = NULL;
+  return ret;
 
-  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;
 }
 
 
-/* gstreamer functions */
-
+/*
+ * GObject callback functions implementation
+ */
 
 static void
 gst_base_metadata_base_init (gpointer gclass)
@@ -694,7 +1215,6 @@ gst_base_metadata_base_init (gpointer gclass)
       "basemetadata element");
 }
 
-/* initialize the plugin's class */
 static void
 gst_base_metadata_class_init (GstBaseMetadataClass * klass)
 {
@@ -728,11 +1248,6 @@ gst_base_metadata_class_init (GstBaseMetadataClass * klass)
 
 }
 
-/* initialize the new element
- * instantiate pads and add them to element
- * set functions
- * initialize structure
- */
 static void
 gst_base_metadata_init (GstBaseMetadata * filter, GstBaseMetadataClass * gclass)
 {
@@ -784,6 +1299,26 @@ gst_base_metadata_init (GstBaseMetadata * filter, GstBaseMetadataClass * gclass)
 }
 
 static void
+gst_base_metadata_dispose (GObject * object)
+{
+  GstBaseMetadata *filter = NULL;
+
+  filter = GST_BASE_METADATA (object);
+
+  gst_base_metadata_dispose_members (filter);
+
+  metadataparse_xmp_dispose ();
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gst_base_metadata_finalize (GObject * object)
+{
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
 gst_base_metadata_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec)
 {
@@ -836,59 +1371,49 @@ gst_base_metadata_get_property (GObject * object, guint prop_id,
   }
 }
 
-/* GstElement vmethod implementations */
-
-static gboolean
-gst_base_metadata_processing (GstBaseMetadata * filter)
-{
-  gboolean ret = TRUE;
-  GstBaseMetadataClass *bclass = GST_BASE_METADATA_GET_CLASS (filter);
-
-  if (filter->need_processing) {
-    bclass->processing (filter);
-    if (gst_base_metadata_calculate_offsets (filter)) {
-      filter->need_processing = FALSE;
-    } else {
-      ret = FALSE;
-    }
-  }
-
-  return ret;
 
-}
+/*
+ * GStreamer callback functions declaration
+ */
 
-static gboolean
-gst_base_metadata_sink_event (GstPad * pad, GstEvent * event)
+static GstStateChangeReturn
+gst_base_metadata_change_state (GstElement * element, GstStateChange transition)
 {
-  GstBaseMetadata *filter = NULL;
-  gboolean ret = FALSE;
-  GstBaseMetadataClass *bclass;
-
-  filter = GST_BASE_METADATA (gst_pad_get_parent (pad));
-  bclass = GST_BASE_METADATA_GET_CLASS (filter);
+  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
+  GstBaseMetadata *filter = GST_BASE_METADATA (element);
 
-  switch (GST_EVENT_TYPE (event)) {
-    case GST_EVENT_EOS:
-      if (filter->need_more_data) {
-        GST_ELEMENT_WARNING (filter, STREAM, DECODE, (NULL),
-            ("Need more data. Unexpected EOS"));
-      }
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      gst_base_metadata_reset_parsing (filter);
+      metadata_init (&filter->metadata, filter->options);
       break;
-    case GST_EVENT_TAG:
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      if (filter->metadata == NULL)
+        metadata_init (&filter->metadata, filter->options);
       break;
     default:
       break;
   }
 
-  ret = bclass->sink_event (pad, event);
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+  if (ret == GST_STATE_CHANGE_FAILURE)
+    goto done;
 
-  gst_object_unref (filter);
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_base_metadata_reset_streaming (filter);
+      if (filter->state != MT_STATE_PARSED)
+        gst_base_metadata_reset_parsing (filter);
+      break;
+    default:
+      break;
+  }
 
-  return ret;
+done:
 
+  return ret;
 }
 
-
 static gboolean
 gst_base_metadata_src_event (GstPad * pad, GstEvent * event)
 {
@@ -945,7 +1470,13 @@ gst_base_metadata_src_event (GstPad * pad, GstEvent * event)
         filter->prepend_buffer = NULL;
       }
 
-      /* FIXME: related to append */
+      /* FIXME: if some chunk is injected after the end of original file
+         (which is not the case for any file type currently handled), appending
+         a buffer should be taken in account
+       */
+
+      /* translate position and setup filter-prepend to be prepend to the
+         striped/injected buffer in next 'chain' calling */
       filter->offset = start;
       gst_base_metadata_translate_pos_to_orig (filter, start, &start,
           &filter->prepend_buffer);
@@ -973,7 +1504,7 @@ gst_base_metadata_src_event (GstPad * pad, GstEvent * event)
   }
 
   ret = gst_pad_event_default (pad, event);
-  event = NULL;                 /* event has another owner */
+  event = NULL;
 
 done:
 
@@ -987,303 +1518,116 @@ done:
 
 }
 
-static void
-gst_base_metadata_dispose (GObject * object)
-{
-  GstBaseMetadata *filter = NULL;
-
-  filter = GST_BASE_METADATA (object);
-
-  gst_base_metadata_dispose_members (filter);
-
-  metadataparse_xmp_dispose ();
-
-  G_OBJECT_CLASS (parent_class)->dispose (object);
-}
-
-static void
-gst_base_metadata_finalize (GObject * object)
-{
-  G_OBJECT_CLASS (parent_class)->finalize (object);
-}
-
-static void
-gst_base_metadata_dispose_members (GstBaseMetadata * filter)
-{
-
-  /* buffers used to build output buffer */
-
-  if (filter->prepend_buffer) {
-    gst_buffer_unref (filter->prepend_buffer);
-    filter->prepend_buffer = NULL;
-  }
-
-  if (filter->append_buffer) {
-    gst_buffer_unref (filter->append_buffer);
-    filter->append_buffer = NULL;
-  }
-
-  /* adapter used during parsing process */
-
-  if (filter->adapter_parsing) {
-    gst_object_unref (filter->adapter_parsing);
-    filter->adapter_parsing = NULL;
-  }
-
-  if (filter->adapter_holding) {
-    gst_object_unref (filter->adapter_holding);
-    filter->adapter_holding = NULL;
-  }
-
-  metadata_dispose (&filter->metadata);
-
-}
-
-static void
-gst_base_metadata_init_members (GstBaseMetadata * filter)
-{
-
-  filter->metadata = NULL;
-
-  filter->img_type = IMG_NONE;
-
-  filter->duration_orig = 0;
-  filter->duration = 0;
-
-  filter->state = MT_STATE_NULL;
-
-  filter->options = META_OPT_EXIF | META_OPT_IPTC | META_OPT_XMP;
-
-  filter->need_processing = FALSE;
-
-  filter->adapter_parsing = NULL;
-  filter->adapter_holding = NULL;
-  filter->next_offset = 0;
-  filter->next_size = 0;
-  filter->need_more_data = FALSE;
-  filter->offset_orig = 0;
-  filter->offset = 0;
-
-  filter->append_buffer = NULL;
-  filter->prepend_buffer = NULL;
-
-}
-
-static void
-gst_base_metadata_reset_streaming (GstBaseMetadata * filter)
-{
-  filter->offset_orig = 0;
-  filter->offset = 0;
-  if (filter->adapter_holding)
-    gst_adapter_clear (filter->adapter_holding);
-}
-
-static void
-gst_base_metadata_reset_parsing (GstBaseMetadata * filter)
-{
-
-
-  if (filter->prepend_buffer) {
-    gst_buffer_unref (filter->prepend_buffer);
-    filter->prepend_buffer = NULL;
-  }
-
-  if (filter->append_buffer) {
-    gst_buffer_unref (filter->append_buffer);
-    filter->append_buffer = NULL;
-  }
-
-  if (filter->adapter_parsing)
-    gst_adapter_clear (filter->adapter_parsing);
-
-  if (filter->adapter_holding)
-    gst_adapter_clear (filter->adapter_holding);
-
-  filter->img_type = IMG_NONE;
-  filter->duration_orig = 0;
-  filter->duration = 0;
-  filter->state = MT_STATE_NULL;
-  filter->need_processing = FALSE;
-  filter->next_offset = 0;
-  filter->next_size = 0;
-  filter->need_more_data = FALSE;
-  filter->offset_orig = 0;
-  filter->offset = 0;
-
-  metadata_dispose (&filter->metadata);
-
-}
-
 static gboolean
-gst_base_metadata_configure_caps (GstBaseMetadata * filter)
+gst_base_metadata_sink_event (GstPad * pad, GstEvent * event)
 {
-  GstCaps *caps = NULL;
+  GstBaseMetadata *filter = NULL;
   gboolean ret = FALSE;
-  gchar *mime = NULL;
-  GstPad *peer = NULL;
+  GstBaseMetadataClass *bclass;
 
-  peer = gst_pad_get_peer (filter->sinkpad);
+  filter = GST_BASE_METADATA (gst_pad_get_parent (pad));
+  bclass = GST_BASE_METADATA_GET_CLASS (filter);
 
-  switch (filter->img_type) {
-    case IMG_JPEG:
-      mime = "image/jpeg";
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_EOS:
+      if (filter->need_more_data) {
+        GST_ELEMENT_WARNING (filter, STREAM, DECODE, (NULL),
+            ("Need more data. Unexpected EOS"));
+      }
       break;
-    case IMG_PNG:
-      mime = "image/png";
+    case GST_EVENT_TAG:
       break;
     default:
-      goto done;
       break;
   }
 
-  caps = gst_caps_new_simple (mime, NULL);
-
-  if (!gst_pad_set_caps (peer, caps)) {
-    goto done;
-  }
-
-  ret = gst_pad_set_caps (filter->sinkpad, caps);
-
-done:
-
-  if (caps) {
-    gst_caps_unref (caps);
-    caps = NULL;
-  }
+  ret = bclass->sink_event (pad, event);
 
-  if (peer) {
-    gst_object_unref (peer);
-    peer = NULL;
-  }
+  gst_object_unref (filter);
 
   return ret;
 
 }
 
-static const GstQueryType *
-gst_base_metadata_get_query_types (GstPad * pad)
-{
-  static const GstQueryType gst_base_metadata_src_query_types[] = {
-    GST_QUERY_POSITION,
-    GST_QUERY_DURATION,
-    GST_QUERY_FORMATS,
-    0
-  };
-
-  return gst_base_metadata_src_query_types;
-}
-
 static gboolean
-gst_base_metadata_src_query (GstPad * pad, GstQuery * query)
+gst_base_metadata_checkgetrange (GstPad * srcpad)
 {
-  gboolean ret = FALSE;
-  GstFormat format;
-  GstBaseMetadata *filter = GST_BASE_METADATA (gst_pad_get_parent (pad));
+  GstBaseMetadata *filter = NULL;
 
-  switch (GST_QUERY_TYPE (query)) {
-    case GST_QUERY_POSITION:
-      gst_query_parse_position (query, &format, NULL);
+  filter = GST_BASE_METADATA (GST_PAD_PARENT (srcpad));
 
-      if (format == GST_FORMAT_BYTES) {
-        gst_query_set_position (query, GST_FORMAT_BYTES, filter->offset);
-        ret = TRUE;
-      }
-      break;
-    case GST_QUERY_DURATION:
+  return gst_pad_check_pull_range (filter->sinkpad);
+}
 
-      if (!gst_base_metadata_processing (filter)) {
-        ret = FALSE;
-        goto done;
-      }
+static GstFlowReturn
+gst_base_metadata_get_range (GstPad * pad,
+    guint64 offset, guint size, GstBuffer ** buf)
+{
+  GstBaseMetadata *filter = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+  gint64 offset_orig = 0;
+  guint size_orig;
+  GstBuffer *prepend = NULL;
+  gboolean need_append = FALSE;
 
-      gst_query_parse_duration (query, &format, NULL);
+  filter = GST_BASE_METADATA (GST_PAD_PARENT (pad));
 
-      if (format == GST_FORMAT_BYTES) {
-        if (filter->duration >= 0) {
-          gst_query_set_duration (query, GST_FORMAT_BYTES, filter->duration);
-          ret = TRUE;
-        }
-      }
-      break;
-    case GST_QUERY_FORMATS:
-      gst_query_set_formats (query, 1, GST_FORMAT_BYTES);
-      ret = TRUE;
-      break;
-    default:
-      break;
+  if (!gst_base_metadata_processing (filter)) {
+    ret = GST_FLOW_ERROR;
+    goto done;
   }
 
-done:
+  if (offset + size > filter->duration) {
+    size = filter->duration - offset;
+  }
 
-  gst_object_unref (filter);
+  size_orig = size;
 
-  return ret;
+  gst_base_metadata_translate_pos_to_orig (filter, offset,
+      &offset_orig, &prepend);
 
-}
+  if (size > 1) {
+    gint64 pos;
 
-/*
- * Do parsing step-by-step and reconfigure caps if need
- * return:
- *   META_PARSING_ERROR
- *   META_PARSING_DONE
- *   META_PARSING_NEED_MORE_DATA
- */
+    pos = offset + size - 1;
+    gst_base_metadata_translate_pos_to_orig (filter, pos, &pos, NULL);
+    size_orig = pos + 1 - offset_orig;
+  }
 
-static int
-gst_base_metadata_parse (GstBaseMetadata * filter, const guint8 * buf,
-    guint32 size)
-{
+  if (size_orig) {
 
-  int ret = META_PARSING_ERROR;
+    ret = gst_pad_pull_range (filter->sinkpad, offset_orig, size_orig, buf);
 
-  filter->next_offset = 0;
-  filter->next_size = 0;
+    if (ret == GST_FLOW_OK && *buf) {
+      gst_base_metadata_strip_push_buffer (filter, offset_orig, &prepend, buf);
 
-  ret = metadata_parse (filter->metadata, buf, size,
-      &filter->next_offset, &filter->next_size);
+      if (GST_BUFFER_SIZE (*buf) < size) {
+        /* need append */
+        need_append = TRUE;
+      }
 
-  if (ret == META_PARSING_ERROR) {
-    if (META_DATA_IMG_TYPE (filter->metadata) == IMG_NONE) {
-      /* image type not recognized */
-      GST_ELEMENT_ERROR (filter, STREAM, TYPE_NOT_FOUND, (NULL),
-          ("Only jpeg and png are supported"));
-      goto done;
     }
-  } else if (ret == META_PARSING_NEED_MORE_DATA) {
-    filter->need_more_data = TRUE;
   } else {
-    filter->state = MT_STATE_PARSED;
-    filter->need_more_data = FALSE;
-    filter->need_processing = TRUE;
-  }
-
-  /* reconfigure caps if it is different from type detected by 'base_metadata' function */
-  if (filter->img_type != META_DATA_IMG_TYPE (filter->metadata)) {
-    filter->img_type = META_DATA_IMG_TYPE (filter->metadata);
-    if (!gst_base_metadata_configure_caps (filter)) {
-      GST_ELEMENT_ERROR (filter, STREAM, FORMAT, (NULL),
-          ("Couldn't reconfigure caps for %s",
-              gst_base_metadata_get_type_name (filter->img_type)));
-      ret = META_PARSING_ERROR;
-      goto done;
-    }
+    *buf = prepend;
   }
 
 done:
 
+  if (need_append) {
+    /* FIXME: together with SEEK and
+     * gst_base_metadata_translate_pos_to_orig
+     * this way if chunk is added in the end we are in trouble
+     * ...still not implemented 'cause it will not be the
+     * case for the time being (All the file types handled
+     * have a kind of end-of-file chunk (or mark, so nothing
+     * will be injected after it)
+     */
+  }
+
   return ret;
 
 }
 
-/* chain function
- * this function does the actual processing
- */
-
-/* FIXME */
-/* Current base is just done before is pull mode could be activated */
-/* may be it is possible to base in chain mode by doing some trick with gst-adapter */
-/* the pipeline below would be a test for that case */
-/* gst-launch-0.10 filesrc location=Exif.jpg ! queue !  metadatabase ! filesink location=gen3.jpg */
 
 static GstFlowReturn
 gst_base_metadata_chain (GstPad * pad, GstBuffer * buf)
@@ -1422,74 +1766,6 @@ done:
 }
 
 static gboolean
-gst_base_metadata_pull_range_base (GstBaseMetadata * filter)
-{
-
-  int res;
-  gboolean ret = TRUE;
-  guint32 offset = 0;
-  gint64 duration = 0;
-  GstFormat format = GST_FORMAT_BYTES;
-
-  if (!(ret =
-          gst_pad_query_peer_duration (filter->sinkpad, &format, &duration))) {
-    /* this should never happen, but try chain anyway */
-    ret = TRUE;
-    goto done;
-  }
-  filter->duration_orig = duration;
-
-  if (format != GST_FORMAT_BYTES) {
-    /* this should never happen, but try chain anyway */
-    ret = TRUE;
-    goto done;
-  }
-
-  do {
-    GstFlowReturn flow;
-    GstBuffer *buf = NULL;
-
-    offset += filter->next_offset;
-
-    /* 'filter->next_size' only says the minimum required number of bytes.
-       We try provided more bytes (4096) just to avoid a lot of calls to 'metadata_parse'
-       returning META_PARSING_NEED_MORE_DATA */
-    if (filter->next_size < 4096) {
-      if (duration - offset < 4096) {
-        /* In case there is no 4096 bytes available upstream.
-           It should be done upstream but we do here for safety */
-        filter->next_size = duration - offset;
-      } else {
-        filter->next_size = 4096;
-      }
-    }
-
-    flow =
-        gst_pad_pull_range (filter->sinkpad, offset, filter->next_size, &buf);
-    if (GST_FLOW_OK != flow) {
-      ret = FALSE;
-      goto done;
-    }
-
-    res =
-        gst_base_metadata_parse (filter, GST_BUFFER_DATA (buf),
-        GST_BUFFER_SIZE (buf));
-    if (res == META_PARSING_ERROR) {
-      ret = FALSE;
-      goto done;
-    }
-
-    gst_buffer_unref (buf);
-
-  } while (res == META_PARSING_NEED_MORE_DATA);
-
-done:
-
-  return ret;
-
-}
-
-static gboolean
 gst_base_metadata_sink_activate (GstPad * pad)
 {
   GstBaseMetadata *filter = NULL;
@@ -1500,14 +1776,14 @@ gst_base_metadata_sink_activate (GstPad * pad)
 
   if (!gst_pad_check_pull_range (pad) ||
       !gst_pad_activate_pull (filter->sinkpad, TRUE)) {
-    /* FIXME: currently it is not possible to base in chain. Fail here ? */
-    /* nothing to be done by now, activate push mode */
+    /* FIXME: currently it is not possible to base in chain. Fail here ?
+       nothing to be done by now, activate push mode */
     return gst_pad_activate_push (pad, TRUE);
   }
 
   /* try to base */
   if (filter->state == MT_STATE_NULL) {
-    ret = gst_base_metadata_pull_range_base (filter);
+    ret = gst_base_metadata_pull_range_parse (filter);
   }
 
 done:
@@ -1526,83 +1802,6 @@ done:
 }
 
 static gboolean
-gst_base_metadata_checkgetrange (GstPad * srcpad)
-{
-  GstBaseMetadata *filter = NULL;
-
-  filter = GST_BASE_METADATA (GST_PAD_PARENT (srcpad));
-
-  return gst_pad_check_pull_range (filter->sinkpad);
-}
-
-static GstFlowReturn
-gst_base_metadata_get_range (GstPad * pad,
-    guint64 offset, guint size, GstBuffer ** buf)
-{
-  GstBaseMetadata *filter = NULL;
-  GstFlowReturn ret = GST_FLOW_OK;
-  gint64 offset_orig = 0;
-  guint size_orig;
-  GstBuffer *prepend = NULL;
-  gboolean need_append = FALSE;
-
-  filter = GST_BASE_METADATA (GST_PAD_PARENT (pad));
-
-  if (!gst_base_metadata_processing (filter)) {
-    ret = GST_FLOW_ERROR;
-    goto done;
-  }
-
-  if (offset + size > filter->duration) {
-    size = filter->duration - offset;
-  }
-
-  size_orig = size;
-
-  gst_base_metadata_translate_pos_to_orig (filter, offset,
-      &offset_orig, &prepend);
-
-  if (size > 1) {
-    gint64 pos;
-
-    pos = offset + size - 1;
-    gst_base_metadata_translate_pos_to_orig (filter, pos, &pos, NULL);
-    size_orig = pos + 1 - offset_orig;
-  }
-
-  if (size_orig) {
-
-    ret = gst_pad_pull_range (filter->sinkpad, offset_orig, size_orig, buf);
-
-    if (ret == GST_FLOW_OK && *buf) {
-      gst_base_metadata_strip_push_buffer (filter, offset_orig, &prepend, buf);
-
-      if (GST_BUFFER_SIZE (*buf) < size) {
-        /* need append */
-        need_append = TRUE;
-      }
-
-    }
-  } else {
-    *buf = prepend;
-  }
-
-done:
-
-  if (need_append) {
-    /* FIXME: together with SEEK and
-     * gst_base_metadata_translate_pos_to_orig
-     * this way if chunk is added in the end we are in trolble
-     * ...still not implemented 'cause it will not be the
-     * case for the time being
-     */
-  }
-
-  return ret;
-
-}
-
-static gboolean
 gst_base_metadata_src_activate_pull (GstPad * pad, gboolean active)
 {
   GstBaseMetadata *filter = NULL;
@@ -1613,7 +1812,7 @@ gst_base_metadata_src_activate_pull (GstPad * pad, gboolean active)
   ret = gst_pad_activate_pull (filter->sinkpad, active);
 
   if (ret && filter->state == MT_STATE_NULL) {
-    ret = gst_base_metadata_pull_range_base (filter);
+    ret = gst_base_metadata_pull_range_parse (filter);
   }
 
   gst_object_unref (filter);
@@ -1621,35 +1820,54 @@ gst_base_metadata_src_activate_pull (GstPad * pad, gboolean active)
   return ret;
 }
 
+static const GstQueryType *
+gst_base_metadata_get_query_types (GstPad * pad)
+{
+  static const GstQueryType gst_base_metadata_src_query_types[] = {
+    GST_QUERY_POSITION,
+    GST_QUERY_DURATION,
+    GST_QUERY_FORMATS,
+    0
+  };
+
+  return gst_base_metadata_src_query_types;
+}
 
-static GstStateChangeReturn
-gst_base_metadata_change_state (GstElement * element, GstStateChange transition)
+static gboolean
+gst_base_metadata_src_query (GstPad * pad, GstQuery * query)
 {
-  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
-  GstBaseMetadata *filter = GST_BASE_METADATA (element);
+  gboolean ret = FALSE;
+  GstFormat format;
+  GstBaseMetadata *filter = GST_BASE_METADATA (gst_pad_get_parent (pad));
 
-  switch (transition) {
-    case GST_STATE_CHANGE_NULL_TO_READY:
-      gst_base_metadata_reset_parsing (filter);
-      metadata_init (&filter->metadata, filter->options);
-      break;
-    case GST_STATE_CHANGE_READY_TO_PAUSED:
-      if (filter->metadata == NULL)
-        metadata_init (&filter->metadata, filter->options);
-      break;
-    default:
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_POSITION:
+      gst_query_parse_position (query, &format, NULL);
+
+      if (format == GST_FORMAT_BYTES) {
+        gst_query_set_position (query, GST_FORMAT_BYTES, filter->offset);
+        ret = TRUE;
+      }
       break;
-  }
+    case GST_QUERY_DURATION:
 
-  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
-  if (ret == GST_STATE_CHANGE_FAILURE)
-    goto done;
+      if (!gst_base_metadata_processing (filter)) {
+        ret = FALSE;
+        goto done;
+      }
 
-  switch (transition) {
-    case GST_STATE_CHANGE_PAUSED_TO_READY:
-      gst_base_metadata_reset_streaming (filter);
-      if (filter->state != MT_STATE_PARSED)
-        gst_base_metadata_reset_parsing (filter);
+      gst_query_parse_duration (query, &format, NULL);
+
+      if (format == GST_FORMAT_BYTES) {
+        if (filter->duration >= 0) {
+          gst_query_set_duration (query, GST_FORMAT_BYTES, filter->duration);
+          ret = TRUE;
+        }
+      }
+      break;
+    case GST_QUERY_FORMATS:
+      gst_query_set_formats (query, 1, GST_FORMAT_BYTES);
+      ret = TRUE;
       break;
     default:
       break;
@@ -1657,15 +1875,50 @@ gst_base_metadata_change_state (GstElement * element, GstStateChange transition)
 
 done:
 
+  gst_object_unref (filter);
+
   return ret;
+
 }
 
+/*
+ * extern functions declaration
+ */
+
+/**
+ * gst_base_metadata_set_option_flag:
+ * @base: the base metadata instance
+ * @options: mode of operation
+ *
+ * Set how the this base class will behaviour. As a demuxer or muxer. Hanlding
+ * EXIF, IPTC, XMP or not.
+ * @see_also: #gst_base_metadata_unset_option_flag
+ * #gst_base_metadata_get_option_flag 
+ *
+ * Returns: nothing
+ *
+ */
+
 void
 gst_base_metadata_set_option_flag (GstBaseMetadata * base, MetaOptions options)
 {
   base->options |= options;
 }
 
+/**
+ * gst_base_metadata_unset_option_flag:
+ * @base: the base metadata instance
+ * @options: mode of operation
+ *
+ * Set how the this base class will behaviour. As a demuxer or muxer. Hanlding
+ * EXIF, IPTC, XMP or not.
+ * @see_also: #gst_base_metadata_set_option_flag
+ * #gst_base_metadata_get_option_flag 
+ *
+ * Returns: nothing
+ *
+ */
+
 void
 gst_base_metadata_unset_option_flag (GstBaseMetadata * base,
     MetaOptions options)
@@ -1673,23 +1926,55 @@ gst_base_metadata_unset_option_flag (GstBaseMetadata * base,
   base->options &= ~options;
 }
 
+/**
+ * gst_base_metadata_get_option_flag:
+ * @base: the base metadata instance
+ *
+ * Check how the this base class will behaviour. As a demuxer or muxer.
+ * Hanlding EXIF, IPTC, XMP or not.
+ * @see_also: #gst_base_metadata_set_option_flag
+ * #gst_base_metadata_unset_option_flag
+ *
+ * Returns: The current mode of operation
+ *
+ */
+
 MetaOptions
 gst_base_metadata_get_option_flag (const GstBaseMetadata * base)
 {
   return base->options;
 }
 
-void
-gst_base_metadata_update_segment_with_new_buffer (GstBaseMetadata * base,
-    guint8 ** buf, guint32 * size, MetadataChunkType type)
+
+/**
+ * gst_base_metadata_update_inject_segment_with_new_data:
+ * @base: the base metadata instance
+ * @data: new data to be injected
+ * @size: the size in bytes of @data
+ * @type: kind of metadata chunk it is (currently EXIF, IPTC or XMP)
+ *
+ * If the file type specification of the parsed stream allows a chunk of @type,
+ * set the @data and @size of the segment to be injected. This the @data has
+ * been injected (metadata type supported by the stream @type) then, the
+ * the @data ownership will be taken and @data and @size willl be set to 0;
+ * Hanlding EXIF, IPTC, XMP or not.
+ * @see_also: #gst_base_metadata_calculate_offsets
+ *
+ * Returns: Nothing
+ *
+ */
+
+void gst_base_metadata_update_inject_segment_with_new_data
+    (GstBaseMetadata * base,
+    guint8 ** data, guint32 * size, MetadataChunkType type)
 {
   int i;
   MetadataChunk *inject = META_DATA_INJECT_CHUNKS (base->metadata).chunk;
   const gsize inject_len = META_DATA_INJECT_CHUNKS (base->metadata).len;
 
-  if (!(buf && size))
+  if (!(data && size))
     goto done;
-  if (*buf == 0)
+  if (*data == 0)
     goto done;
   if (*size == 0)
     goto done;
@@ -1699,9 +1984,9 @@ gst_base_metadata_update_segment_with_new_buffer (GstBaseMetadata * base,
       inject[i].size = *size;
       if (inject[i].data)
         g_free (inject[i].data);
-      inject[i].data = *buf;
+      inject[i].data = *data;
       *size = 0;
-      *buf = 0;
+      *data = 0;
       break;
     }
   }
@@ -1711,10 +1996,3 @@ done:
   return;
 
 }
-
-void
-gst_base_metadata_chunk_array_remove_zero_size (GstBaseMetadata * base)
-{
-  metadata_chunk_array_remove_zero_size (&META_DATA_INJECT_CHUNKS (base->
-          metadata));
-}
diff --git a/ext/metadata/gstbasemetadata.h b/ext/metadata/gstbasemetadata.h
index 1e49f8bc..9a3c08ce 100644
--- a/ext/metadata/gstbasemetadata.h
+++ b/ext/metadata/gstbasemetadata.h
@@ -49,14 +49,20 @@
 
 G_BEGIN_DECLS
 
-/* #defines don't like whitespacey bits */
-#define GST_TYPE_BASE_METADATA		(gst_base_metadata_get_type())
-#define GST_BASE_METADATA(obj)		(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_METADATA,GstBaseMetadata))
-#define GST_BASE_METADATA_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_METADATA,GstBaseMetadataClass))
-#define GST_BASE_METADATA_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_BASE_METADATA, GstBaseMetadataClass))
-#define GST_IS_BASE_METADATA(obj)		(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_METADATA))
-#define GST_IS_BASE_METADATA_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_METADATA))
-#define GST_BASE_METADATA_CAST(obj)		((GstBaseMetadata *)(obj))
+/* *INDENT-OFF* */
+#define GST_TYPE_BASE_METADATA            (gst_base_metadata_get_type())
+#define GST_BASE_METADATA(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj),\
+  GST_TYPE_BASE_METADATA,GstBaseMetadata))
+#define GST_BASE_METADATA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),\
+  GST_TYPE_BASE_METADATA,GstBaseMetadataClass))
+#define GST_BASE_METADATA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+  GST_TYPE_BASE_METADATA, GstBaseMetadataClass))
+#define GST_IS_BASE_METADATA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj),\
+  GST_TYPE_BASE_METADATA))
+#define GST_IS_BASE_METADATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),\
+  GST_TYPE_BASE_METADATA))
+#define GST_BASE_METADATA_CAST(obj)       ((GstBaseMetadata *)(obj))
+/* *INDENT-ON* */
 
 typedef struct _GstBaseMetadata GstBaseMetadata;
 typedef struct _GstBaseMetadataClass GstBaseMetadataClass;
@@ -98,7 +104,6 @@ typedef enum _tag_MetadataState
 
 /**
  * GstBaseMetadata:
- * @element: the parent element.
  *
  * The opaque #GstBaseMetadata data structure.
  */
@@ -165,11 +170,8 @@ extern MetaOptions
 gst_base_metadata_get_option_flag(const GstBaseMetadata *base);
 
 extern void
-gst_base_metadata_update_segment_with_new_buffer (GstBaseMetadata *base,
-    guint8 ** buf, guint32 * size, MetadataChunkType type);
-
-extern void
-gst_base_metadata_chunk_array_remove_zero_size (GstBaseMetadata *base);
+gst_base_metadata_update_inject_segment_with_new_data (GstBaseMetadata *base,
+    guint8 ** data, guint32 * size, MetadataChunkType type);
 
 G_END_DECLS
 #endif /* __GST_BASE_METADATA_H__ */
diff --git a/ext/metadata/gstmetadatademux.c b/ext/metadata/gstmetadatademux.c
index 6393319e..a183739f 100644
--- a/ext/metadata/gstmetadatademux.c
+++ b/ext/metadata/gstmetadatademux.c
@@ -42,18 +42,57 @@
  */
 
 /**
- * SECTION:metadatademux-metadata
+ * SECTION: element-metadatademux
+ * @short_description: element that parse or demux metadata from image files
+ * @see_also: #metadatamux
  *
  * <refsect2>
+ * <para>
+ * This element parses image files JPEG and PNG, to find metadata chunks (EXIF,
+ * IPTC, XMP) in it, and then send individual tags as a 'tag message' do the
+ * application and as 'tag event' to the next element in pipeline. It also
+ * strips out the metadata chunks from original stream (unless the 'parse-only'
+ * property is set to 'true'). In addition the whole metadata chunk (striped
+ * or not) it also sent as a message to the application bus, so the application
+ * can have more controls about the metadata.
+ * </para>
  * <title>Example launch line</title>
  * <para>
  * <programlisting>
- * gst-launch -v -m filesrc location=./test.jpeg ! metadatademux ! fakesink silent=TRUE
+ * gst-launch -v -m filesrc location=./test.jpeg ! metadatademux ! fakesink
+ * silent=TRUE
+ * </programlisting>
+ * <programlisting>
+ * GST_DEBUG:*metadata:5 gst-launch filesrc location=./test.jpeg ! 
+ * metadatademux ! fakesink
+ * </programlisting>
+ * </para>
+ * <title>Application sample code using 'libexif' to have more control</title>
+ * <para>
+ * <programlisting>
+ * val = gst_tag_list_get_value_index (taglist, GST_TAG_EXIF, 0);
+ * if (val) {
+ *  exif_chunk = gst_value_get_buffer (val);
+ *  if (exif_chunk) {
+ *    ed = exif_data_new_from_data (GST_BUFFER_DATA (exif_chunk),
+ *        GST_BUFFER_SIZE (exif_chunk));
+ *  }
+ * }
  * </programlisting>
+ * This same idea can be used to handle IPTC and XMP directly by using
+ * libdata and exempi (or any other libraries). Notice: the whole metadata
+ * chunk sent as a message to the application contains only metadata data, i.e.
+ * the wrapper specific to the file format (JPEG, PNG, ...) is already
+ * striped out.
  * </para>
  * </refsect2>
  */
 
+
+/*
+ * includes
+ */
+
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
@@ -70,16 +109,13 @@
 
 #include <string.h>
 
-GST_DEBUG_CATEGORY_STATIC (gst_metadata_demux_debug);
-#define GST_CAT_DEFAULT gst_metadata_demux_debug
 
-#define GOTO_DONE_IF_NULL(ptr) do { if ( NULL == (ptr) ) goto done; } while(FALSE)
-#define GOTO_DONE_IF_NULL_AND_FAIL(ptr, ret) do { if ( NULL == (ptr) ) { (ret) = FALSE; goto done; } } while(FALSE)
+/*
+ * enum and types
+ */
 
-/* Filter signals and args */
 enum
 {
-  /* FILL ME */
   LAST_SIGNAL
 };
 
@@ -89,6 +125,19 @@ enum
   ARG_PARSE_ONLY
 };
 
+/*
+ * defines and static global vars
+ */
+
+
+GST_DEBUG_CATEGORY_STATIC (gst_metadata_demux_debug);
+#define GST_CAT_DEFAULT gst_metadata_demux_debug
+
+#define GOTO_DONE_IF_NULL(ptr) \
+    do { if ( NULL == (ptr) ) goto done; } while(FALSE)
+#define GOTO_DONE_IF_NULL_AND_FAIL(ptr, ret) \
+    do { if ( NULL == (ptr) ) { (ret) = FALSE; goto done; } } while(FALSE)
+
 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
     GST_PAD_SINK,
     GST_PAD_ALWAYS,
@@ -105,35 +154,113 @@ static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
         "image/png, " "tags-extracted = (bool) true")
     );
 
-GST_BOILERPLATE (GstMetadataDemux, gst_metadata_demux, GstBaseMetadata,
-    GST_TYPE_BASE_METADATA);
-
 static GstMetadataDemuxClass *metadata_parent_class = NULL;
 
+/*
+ * static helper functions declaration
+ */
+
+static gboolean
+gst_metadata_demux_configure_srccaps (GstMetadataDemux * filter);
+
+/*
+ * GObject callback functions declaration
+ */
+
+static void gst_metadata_demux_base_init (gpointer gclass);
+
+static void gst_metadata_demux_class_init (GstMetadataDemuxClass * klass);
+
+static void
+gst_metadata_demux_init (GstMetadataDemux * filter,
+    GstMetadataDemuxClass * gclass);
+
 static void gst_metadata_demux_dispose (GObject * object);
 
 static void gst_metadata_demux_finalize (GObject * object);
 
 static void gst_metadata_demux_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec);
+
 static void gst_metadata_demux_get_property (GObject * object, guint prop_id,
     GValue * value, GParamSpec * pspec);
 
-static GstCaps *gst_metadata_demux_get_caps (GstPad * pad);
+/*
+ * GstBaseMetadata virtual functions declaration
+ */
+
+static void gst_metadata_demux_send_tags (GstBaseMetadata * base);
+
 static gboolean gst_metadata_demux_set_caps (GstPad * pad, GstCaps * caps);
+
+static GstCaps *gst_metadata_demux_get_caps (GstPad * pad);
+
 static gboolean gst_metadata_demux_sink_event (GstPad * pad, GstEvent * event);
 
-static void gst_metadata_demux_send_tags (GstBaseMetadata * base);
+
+/*
+ * GST BOILERPLATE
+ */
+
+GST_BOILERPLATE (GstMetadataDemux, gst_metadata_demux, GstBaseMetadata,
+    GST_TYPE_BASE_METADATA);
+
+/*
+ * static helper functions implementation
+ */
+
+static gboolean
+gst_metadata_demux_configure_srccaps (GstMetadataDemux * filter)
+{
+  GstCaps *caps = NULL;
+  gboolean ret = FALSE;
+  gchar *mime = NULL;
+
+  switch (GST_BASE_METADATA_IMG_TYPE (filter)) {
+    case IMG_JPEG:
+      mime = "image/jpeg";
+      break;
+    case IMG_PNG:
+      mime = "image/png";
+      break;
+    default:
+      ret = FALSE;
+      goto done;
+      break;
+  }
+
+  caps =
+      gst_caps_new_simple (mime, "tags-extracted", G_TYPE_BOOLEAN, TRUE, NULL);
+
+  ret = gst_pad_set_caps (GST_BASE_METADATA_SRC_PAD (filter), caps);
+
+done:
+
+  if (caps) {
+    gst_caps_unref (caps);
+    caps = NULL;
+  }
+
+  return ret;
+
+}
+
+/*
+ * GObject callback functions implementation
+ */
 
 static void
 gst_metadata_demux_base_init (gpointer gclass)
 {
+/* *INDENT-OFF* */
   static GstElementDetails element_details = {
-    "Metadata demuxr",
-    "Demuxr/Extracter/Metadata",
-    "Send metadata tags (EXIF, IPTC and XMP) and remove metadata chunks from stream",
+    "Metadata demuxer",
+    "Demuxer/Extracter/Metadata",
+    "Send metadata tags (EXIF, IPTC and XMP) and "
+      "remove metadata chunks from stream",
     "Edgard Lima <edgard.lima@indt.org.br>"
   };
+/* *INDENT-ON* */
   GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
 
   gst_element_class_add_pad_template (element_class,
@@ -143,7 +270,6 @@ gst_metadata_demux_base_init (gpointer gclass)
   gst_element_class_set_details (element_class, &element_details);
 }
 
-/* initialize the plugin's class */
 static void
 gst_metadata_demux_class_init (GstMetadataDemuxClass * klass)
 {
@@ -180,11 +306,6 @@ gst_metadata_demux_class_init (GstMetadataDemuxClass * klass)
 
 }
 
-/* initialize the new element
- * instantiate pads and add them to element
- * set functions
- * initialize structure
- */
 static void
 gst_metadata_demux_init (GstMetadataDemux * filter,
     GstMetadataDemuxClass * gclass)
@@ -250,6 +371,23 @@ gst_metadata_demux_finalize (GObject * object)
   G_OBJECT_CLASS (metadata_parent_class)->finalize (object);
 }
 
+
+/*
+ * GstBaseMetadata virtual functions implementation
+ */
+
+/*
+ * gst_metadata_demux_send_tags:
+ * @base: the base metadata instance
+ * 
+ * Send individual tags as message to the bus and as event to the next
+ * element, and send the whole metadata chunk (with file specific wrapper
+ * striped) to the next element as a event.
+ *
+ * Returns: nothing
+ *
+ */
+
 static void
 gst_metadata_demux_send_tags (GstBaseMetadata * base)
 {
@@ -260,6 +398,8 @@ gst_metadata_demux_send_tags (GstBaseMetadata * base)
   GstEvent *event;
   GstPad *srcpad = GST_BASE_METADATA_SRC_PAD (filter);
 
+  /* get whole chunk */
+
   if (gst_base_metadata_get_option_flag (base) & META_OPT_EXIF)
     metadataparse_exif_tag_list_add (taglist, GST_TAG_MERGE_KEEP,
         GST_BASE_METADATA_EXIF_ADAPTER (base), METADATA_TAG_MAP_WHOLECHUNK);
@@ -284,6 +424,8 @@ gst_metadata_demux_send_tags (GstBaseMetadata * base)
   if (!taglist)
     taglist = gst_tag_list_new ();
 
+  /*get individual tags */
+
   if (gst_base_metadata_get_option_flag (base) & META_OPT_EXIF)
     metadataparse_exif_tag_list_add (taglist, GST_TAG_MERGE_KEEP,
         GST_BASE_METADATA_EXIF_ADAPTER (base), METADATA_TAG_MAP_INDIVIDUALS);
@@ -307,44 +449,6 @@ gst_metadata_demux_send_tags (GstBaseMetadata * base)
 }
 
 static gboolean
-gst_metadata_demux_configure_srccaps (GstMetadataDemux * filter)
-{
-  GstCaps *caps = NULL;
-  gboolean ret = FALSE;
-  gchar *mime = NULL;
-
-  switch (GST_BASE_METADATA_IMG_TYPE (filter)) {
-    case IMG_JPEG:
-      mime = "image/jpeg";
-      break;
-    case IMG_PNG:
-      mime = "image/png";
-      break;
-    default:
-      ret = FALSE;
-      goto done;
-      break;
-  }
-
-  caps =
-      gst_caps_new_simple (mime, "tags-extracted", G_TYPE_BOOLEAN, TRUE, NULL);
-
-  ret = gst_pad_set_caps (GST_BASE_METADATA_SRC_PAD (filter), caps);
-
-done:
-
-  if (caps) {
-    gst_caps_unref (caps);
-    caps = NULL;
-  }
-
-  return ret;
-
-}
-
-
-/* this function handles the link with other elements */
-static gboolean
 gst_metadata_demux_set_caps (GstPad * pad, GstCaps * caps)
 {
   GstMetadataDemux *filter = NULL;
diff --git a/ext/metadata/gstmetadatademux.h b/ext/metadata/gstmetadatademux.h
index df1c42df..de47f259 100644
--- a/ext/metadata/gstmetadatademux.h
+++ b/ext/metadata/gstmetadatademux.h
@@ -49,23 +49,34 @@
 #include "gstbasemetadata.h"
 
 G_BEGIN_DECLS
-/* #defines don't like whitespacey bits */
+
+/* *INDENT-OFF* */
 #define GST_TYPE_METADATA_DEMUX \
   (gst_metadata_demux_get_type())
 #define GST_METADATA_DEMUX(obj) \
   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_DEMUX,GstMetadataDemux))
 #define GST_METADATA_DEMUX_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_DEMUX,GstMetadataDemuxClass))
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_DEMUX,\
+  GstMetadataDemuxClass))
 #define GST_IS_METADATA_DEMUX(obj) \
   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_DEMUX))
 #define GST_IS_METADATA_DEMUX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_DEMUX))
+/* *INDENT-ON* */
+
 typedef struct _GstMetadataDemux GstMetadataDemux;
 typedef struct _GstMetadataDemuxClass GstMetadataDemuxClass;
 
+
+/**
+ * GstMetadataDemux:
+ *
+ * The opaque #GstMetadataDemux data structure.
+ */
+
 struct _GstMetadataDemux
 {
-  GstBaseMetadata element;
+  GstBaseMetadata metadata;
 };
 
 struct _GstMetadataDemuxClass
diff --git a/ext/metadata/gstmetadatamux.c b/ext/metadata/gstmetadatamux.c
index 8175e7c6..85a8769d 100644
--- a/ext/metadata/gstmetadatamux.c
+++ b/ext/metadata/gstmetadatamux.c
@@ -42,18 +42,40 @@
  */
 
 /**
- * SECTION:metadatamux-metadata
+ * SECTION: element-metadatamux
  *
  * <refsect2>
+ * <para>
+ * This element writes tags into metadata (EXIF, IPTC and XMP) chunks, and
+ * writes the chunks into image files (JPEG, PNG). Tags the are received as
+ * GST_EVENT_TAG event or set by the application using #GstTagSetter interface.
+ * </para>
  * <title>Example launch line</title>
  * <para>
  * <programlisting>
- * gst-launch -v -m filesrc location=./test.jpeg ! metadatamux ! fakesink silent=TRUE
+ * gst-launch -v -m filesrc location=orig.jpeg ! metadatamux ! filesink
+ * location=dest.jpeg
  * </programlisting>
+ * <programlisting>
+ * gst-launch -v -m filesrc location=orig.png ! metadatademux ! pngdec ! 
+ * ffmpegcolorspace ! jpegenc ! metadatamux ! filesink location=dest.jpeg
+ * </programlisting>
+ * </para>
+ * <title>How it works</title>
+ * <para>
+ * If this element receives a GST_TAG_EXIF, GST_TAG_IPTC or GST_TAG_XMP which
+ * are whole chunk metadata tags, then this whole chunk will be modified by
+ * individual tags received and written to the file. Otherwise, a new chunk
+ * will be created from the scratch and then modified in same way.
  * </para>
  * </refsect2>
  */
 
+
+/*
+ * includes
+ */
+
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
@@ -70,26 +92,35 @@
 
 #include <string.h>
 
-GST_DEBUG_CATEGORY_STATIC (gst_metadata_mux_debug);
-#define GST_CAT_DEFAULT gst_metadata_mux_debug
-
-#define GOTO_DONE_IF_NULL(ptr) do { if ( NULL == (ptr) ) goto done; } while(FALSE)
-#define GOTO_DONE_IF_NULL_AND_FAIL(ptr, ret) do { if ( NULL == (ptr) ) { (ret) = FALSE; goto done; } } while(FALSE)
+/*
+ * enum and types
+ */
 
-/* Filter signals and args */
 enum
 {
-  /* FILL ME */
   LAST_SIGNAL
 };
 
 enum
 {
   ARG_0,
-  ARG_PARSE_ONLY
 };
 
 
+/*
+ * defines and static global vars
+ */
+
+
+GST_DEBUG_CATEGORY_STATIC (gst_metadata_mux_debug);
+#define GST_CAT_DEFAULT gst_metadata_mux_debug
+
+#define GOTO_DONE_IF_NULL(ptr) \
+    do { if ( NULL == (ptr) ) goto done; } while(FALSE)
+
+#define GOTO_DONE_IF_NULL_AND_FAIL(ptr, ret) \
+    do { if ( NULL == (ptr) ) { (ret) = FALSE; goto done; } } while(FALSE)
+
 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
     GST_PAD_SINK,
     GST_PAD_ALWAYS,
@@ -103,19 +134,24 @@ static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
     GST_STATIC_CAPS ("image/jpeg; " "image/png")
     );
 
-static void
-gst_metadata_mux_add_interfaces (GType type)
-{
-  static const GInterfaceInfo tag_setter_info = { NULL, NULL, NULL };
+static GstMetadataMuxClass *metadata_parent_class = NULL;
 
-  g_type_add_interface_static (type, GST_TYPE_TAG_SETTER, &tag_setter_info);
-}
+/*
+ * static helper functions declaration
+ */
 
+static gboolean gst_metadata_mux_configure_srccaps (GstMetadataMux * filter);
 
-GST_BOILERPLATE_FULL (GstMetadataMux, gst_metadata_mux, GstBaseMetadata,
-    GST_TYPE_BASE_METADATA, gst_metadata_mux_add_interfaces);
+/*
+ * GObject callback functions declaration
+ */
 
-static GstMetadataMuxClass *metadata_parent_class = NULL;
+static void gst_metadata_mux_base_init (gpointer gclass);
+
+static void gst_metadata_mux_class_init (GstMetadataMuxClass * klass);
+
+static void
+gst_metadata_mux_init (GstMetadataMux * filter, GstMetadataMuxClass * gclass);
 
 static void gst_metadata_mux_dispose (GObject * object);
 
@@ -123,24 +159,93 @@ static void gst_metadata_mux_finalize (GObject * object);
 
 static void gst_metadata_mux_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec);
+
 static void gst_metadata_mux_get_property (GObject * object, guint prop_id,
     GValue * value, GParamSpec * pspec);
 
-static GstCaps *gst_metadata_mux_get_caps (GstPad * pad);
+/*
+ * GstBaseMetadata virtual functions declaration
+ */
+
+static void gst_metadata_mux_create_chunks_from_tags (GstBaseMetadata * base);
+
 static gboolean gst_metadata_mux_set_caps (GstPad * pad, GstCaps * caps);
+
+static GstCaps *gst_metadata_mux_get_caps (GstPad * pad);
+
 static gboolean gst_metadata_mux_sink_event (GstPad * pad, GstEvent * event);
 
-static void gst_metadata_mux_create_chunks_from_tags (GstBaseMetadata * base);
+/*
+ * GST BOILERPLATE
+ */
+
+static void
+gst_metadata_mux_add_interfaces (GType type)
+{
+  static const GInterfaceInfo tag_setter_info = { NULL, NULL, NULL };
+
+  g_type_add_interface_static (type, GST_TYPE_TAG_SETTER, &tag_setter_info);
+}
+
+
+GST_BOILERPLATE_FULL (GstMetadataMux, gst_metadata_mux, GstBaseMetadata,
+    GST_TYPE_BASE_METADATA, gst_metadata_mux_add_interfaces);
+
+
+/*
+ * static helper functions implementation
+ */
+
+static gboolean
+gst_metadata_mux_configure_srccaps (GstMetadataMux * filter)
+{
+  GstCaps *caps = NULL;
+  gboolean ret = FALSE;
+  gchar *mime = NULL;
+
+  switch (GST_BASE_METADATA_IMG_TYPE (filter)) {
+    case IMG_JPEG:
+      mime = "image/jpeg";
+      break;
+    case IMG_PNG:
+      mime = "image/png";
+      break;
+    default:
+      ret = FALSE;
+      goto done;
+      break;
+  }
+
+  caps = gst_caps_new_simple (mime, NULL);
+
+  ret = gst_pad_set_caps (GST_BASE_METADATA_SRC_PAD (filter), caps);
+
+done:
+
+  if (caps) {
+    gst_caps_unref (caps);
+    caps = NULL;
+  }
+
+  return ret;
+
+}
+
+/*
+ * GObject callback functions declaration
+ */
 
 static void
 gst_metadata_mux_base_init (gpointer gclass)
 {
+/* *INDENT-OFF* */
   static GstElementDetails element_details = {
-    "Metadata muxr",
-    "Muxr/Extracter/Metadata",
-    "Send metadata tags (EXIF, IPTC and XMP) and remove metadata chunks from stream",
+    "Metadata muxer",
+    "Muxer/Extracter/Metadata",
+    "Write metadata (EXIF, IPTC and XMP) into a image stream",
     "Edgard Lima <edgard.lima@indt.org.br>"
   };
+/* *INDENT-ON* */
   GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
 
   gst_element_class_add_pad_template (element_class,
@@ -150,7 +255,6 @@ gst_metadata_mux_base_init (gpointer gclass)
   gst_element_class_set_details (element_class, &element_details);
 }
 
-/* initialize the plugin's class */
 static void
 gst_metadata_mux_class_init (GstMetadataMuxClass * klass)
 {
@@ -170,10 +274,6 @@ gst_metadata_mux_class_init (GstMetadataMuxClass * klass)
   gobject_class->set_property = gst_metadata_mux_set_property;
   gobject_class->get_property = gst_metadata_mux_get_property;
 
-  g_object_class_install_property (gobject_class, ARG_PARSE_ONLY,
-      g_param_spec_boolean ("parse-only", "parse-only",
-          "If TRUE, don't strip out any chunk", FALSE, G_PARAM_READWRITE));
-
   gstbasemetadata_class->processing =
       GST_DEBUG_FUNCPTR (gst_metadata_mux_create_chunks_from_tags);
   gstbasemetadata_class->set_caps =
@@ -187,11 +287,6 @@ gst_metadata_mux_class_init (GstMetadataMuxClass * klass)
 
 }
 
-/* initialize the new element
- * instantiate pads and add them to element
- * set functions
- * initialize structure
- */
 static void
 gst_metadata_mux_init (GstMetadataMux * filter, GstMetadataMuxClass * gclass)
 {
@@ -209,14 +304,6 @@ gst_metadata_mux_set_property (GObject * object, guint prop_id,
   GstMetadataMux *filter = GST_METADATA_MUX (object);
 
   switch (prop_id) {
-    case ARG_PARSE_ONLY:
-      if (g_value_get_boolean (value))
-        gst_base_metadata_set_option_flag (GST_BASE_METADATA (object),
-            META_OPT_PARSE_ONLY);
-      else
-        gst_base_metadata_unset_option_flag (GST_BASE_METADATA (object),
-            META_OPT_PARSE_ONLY);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -231,9 +318,6 @@ gst_metadata_mux_get_property (GObject * object, guint prop_id,
       gst_base_metadata_get_option_flag (GST_BASE_METADATA (object));
 
   switch (prop_id) {
-    case ARG_PARSE_ONLY:
-      g_value_set_boolean (value, option & META_OPT_PARSE_ONLY);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -256,6 +340,23 @@ gst_metadata_mux_finalize (GObject * object)
   G_OBJECT_CLASS (metadata_parent_class)->finalize (object);
 }
 
+
+/*
+ * GstBaseMetadata virtual functions implementation
+ */
+
+/*
+ * gst_metadata_mux_create_chunks_from_tags:
+ * @base: the base metadata instance
+ * 
+ * This function creates new metadata (EXIF, IPTC, XMP) chunks with the tags
+ * received and add it to the list of segments that will be injected to the
+ * resulting file by #GstBaseMetadata.
+ *
+ * Returns: nothing
+ *
+ */
+
 static void
 gst_metadata_mux_create_chunks_from_tags (GstBaseMetadata * base)
 {
@@ -272,19 +373,19 @@ gst_metadata_mux_create_chunks_from_tags (GstBaseMetadata * base)
 
     if (gst_base_metadata_get_option_flag (base) & META_OPT_EXIF) {
       metadatamux_exif_create_chunk_from_tag_list (&buf, &size, taglist);
-      gst_base_metadata_update_segment_with_new_buffer (base, &buf, &size,
+      gst_base_metadata_update_inject_segment_with_new_data (base, &buf, &size,
           MD_CHUNK_EXIF);
     }
 
     if (gst_base_metadata_get_option_flag (base) & META_OPT_IPTC) {
       metadatamux_iptc_create_chunk_from_tag_list (&buf, &size, taglist);
-      gst_base_metadata_update_segment_with_new_buffer (base, &buf, &size,
+      gst_base_metadata_update_inject_segment_with_new_data (base, &buf, &size,
           MD_CHUNK_IPTC);
     }
 
     if (gst_base_metadata_get_option_flag (base) & META_OPT_XMP) {
       metadatamux_xmp_create_chunk_from_tag_list (&buf, &size, taglist);
-      gst_base_metadata_update_segment_with_new_buffer (base, &buf, &size,
+      gst_base_metadata_update_inject_segment_with_new_data (base, &buf, &size,
           MD_CHUNK_XMP);
     }
 
@@ -294,48 +395,9 @@ gst_metadata_mux_create_chunks_from_tags (GstBaseMetadata * base)
     g_free (buf);
   }
 
-  gst_base_metadata_chunk_array_remove_zero_size (base);
-
 }
 
 static gboolean
-gst_metadata_mux_configure_srccaps (GstMetadataMux * filter)
-{
-  GstCaps *caps = NULL;
-  gboolean ret = FALSE;
-  gchar *mime = NULL;
-
-  switch (GST_BASE_METADATA_IMG_TYPE (filter)) {
-    case IMG_JPEG:
-      mime = "image/jpeg";
-      break;
-    case IMG_PNG:
-      mime = "image/png";
-      break;
-    default:
-      ret = FALSE;
-      goto done;
-      break;
-  }
-
-  caps = gst_caps_new_simple (mime, NULL);
-
-  ret = gst_pad_set_caps (GST_BASE_METADATA_SRC_PAD (filter), caps);
-
-done:
-
-  if (caps) {
-    gst_caps_unref (caps);
-    caps = NULL;
-  }
-
-  return ret;
-
-}
-
-
-/* this function handles the link with other elements */
-static gboolean
 gst_metadata_mux_set_caps (GstPad * pad, GstCaps * caps)
 {
   GstMetadataMux *filter = NULL;
diff --git a/ext/metadata/gstmetadatamux.h b/ext/metadata/gstmetadatamux.h
index cafd6e08..bcdeaf1b 100644
--- a/ext/metadata/gstmetadatamux.h
+++ b/ext/metadata/gstmetadatamux.h
@@ -49,7 +49,8 @@
 #include "gstbasemetadata.h"
 
 G_BEGIN_DECLS
-/* #defines don't like whitespacey bits */
+
+/* *INDENT-OFF* */
 #define GST_TYPE_METADATA_MUX \
   (gst_metadata_mux_get_type())
 #define GST_METADATA_MUX(obj) \
@@ -60,12 +61,20 @@ G_BEGIN_DECLS
   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_MUX))
 #define GST_IS_METADATA_MUX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_MUX))
+/* *INDENT-ON* */
+
 typedef struct _GstMetadataMux GstMetadataMux;
 typedef struct _GstMetadataMuxClass GstMetadataMuxClass;
 
+/**
+ * GstMetadataMux:
+ *
+ * The opaque #GstMetadataMux data structure.
+ */
+
 struct _GstMetadataMux
 {
-  GstBaseMetadata element;
+  GstBaseMetadata metadata;
 };
 
 struct _GstMetadataMuxClass
diff --git a/ext/metadata/metadatatags.c b/ext/metadata/metadatatags.c
index 6250c256..fbbdc328 100644
--- a/ext/metadata/metadatatags.c
+++ b/ext/metadata/metadatatags.c
@@ -83,34 +83,34 @@ metadata_tags_exif_register (void)
   gst_tag_register (GST_TAG_CAPTURE_FNUMBER, GST_TAG_FLAG_META,
       GST_TYPE_FRACTION, GST_TAG_CAPTURE_FNUMBER, "F number (focal ratio)",
       NULL);
-  /**
-    0 - not defined
-    1- Manual
-    2- Normal program
-    3- Aperture priority
-    4- Shutter priority
-    5- Creative program (biased toward death of field)
-    6- Action program (biased toward fast shutter speed)
-    7- Portrait mode (for closeup photos with the background out of focus)
-    8- Landscape mode (for landscape photos with the background in focus)
-    *** exif is until here ***
-    9- Night
-    10- Back-light
-    11- Spotlight
-    12- Snow
-    13- Beach
-  */
+  /*
+     0 - not defined
+     1- Manual
+     2- Normal program
+     3- Aperture priority
+     4- Shutter priority
+     5- Creative program (biased toward death of field)
+     6- Action program (biased toward fast shutter speed)
+     7- Portrait mode (for closeup photos with the background out of focus)
+     8- Landscape mode (for landscape photos with the background in focus)
+     *** exif is until here ***
+     9- Night
+     10- Back-light
+     11- Spotlight
+     12- Snow
+     13- Beach
+   */
   gst_tag_register (GST_TAG_CAPTURE_EXPOSURE_PROGRAM, GST_TAG_FLAG_META,
       G_TYPE_UINT, GST_TAG_CAPTURE_EXPOSURE_PROGRAM,
       "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.
-      if numerator is 0xFFFFFFFF means unknown      
-  */
+  /* The unit is the APEX value.
+     Ordinarily it is given in the range of -99.99 to 99.99.
+     if numerator is 0xFFFFFFFF means unknown      
+   */
   gst_tag_register (GST_TAG_CAPTURE_BRIGHTNESS, GST_TAG_FLAG_META,
       GST_TYPE_FRACTION, GST_TAG_CAPTURE_BRIGHTNESS,
       "Brightness (APEX from -99.99 to 99.99)", NULL);
-  /**
+  /*
      0- Auto
      1- Off
      *** exif is until here ***
@@ -122,39 +122,39 @@ metadata_tags_exif_register (void)
      7- Incandescent
      8- Flash
      9- Horizon (sun on the horizon)
-  */
+   */
   gst_tag_register (GST_TAG_CAPTURE_WHITE_BALANCE, GST_TAG_FLAG_META,
       G_TYPE_UINT, GST_TAG_CAPTURE_WHITE_BALANCE, "White balance mode", NULL);
-  /** if Zero ZOOM not used
+  /* if Zero ZOOM not used
    */
   gst_tag_register (GST_TAG_CAPTURE_DIGITAL_ZOOM, GST_TAG_FLAG_META,
       GST_TYPE_FRACTION, GST_TAG_CAPTURE_DIGITAL_ZOOM, "Digital zoom ratio",
       NULL);
-  /**
+  /*
      0- None
      1- Low gain up
      2- High gain up
      3- Low gain down
      4- High gain down
-  */
+   */
   gst_tag_register (GST_TAG_CAPTURE_GAIN, GST_TAG_FLAG_META, G_TYPE_UINT,
       GST_TAG_CAPTURE_GAIN, "", NULL);
-  /**
+  /*
      from -100 to 100
      [-100, -34] - soft
      [-33, 33] - normal
      [34, 100] - hard
      *** exif is just 0, 1, 2 (normal, soft and hard)
-  */
+   */
   gst_tag_register (GST_TAG_CAPTURE_CONTRAST, GST_TAG_FLAG_META, G_TYPE_INT,
       GST_TAG_CAPTURE_CONTRAST, "", NULL);
-  /**
+  /*
      from -100 to 100
      [-100, -34] - low
      [-33, 33] - normal
      [34, 100] - high
      *** exif is just 0, 1, 2 (normal, low and high)
-  */
+   */
   gst_tag_register (GST_TAG_CAPTURE_SATURATION, GST_TAG_FLAG_META, G_TYPE_INT,
       GST_TAG_CAPTURE_SATURATION, "", NULL);