quicktime: rename plugin to isomp4

https://bugzilla.gnome.org/show_bug.cgi?id=648004

35 files changed, 25393 insertions, 0 deletions

diff --git a/gst/isomp4/LEGAL b/gst/isomp4/LEGAL
new file mode 100644
index 000000000..5af6e8f92
--- /dev/null
+++ b/gst/isomp4/LEGAL
@@ -0,0 +1,10 @@
+This is a demuxer supporting a subset of the Quicktime video container
+format developed by Apple. Apple and others have some patents on
+some features of the Quicktime container format in regards to technologies
+such as QuicktimeVR and RTP hinting. Due to that be aware that if ever
+such features are added to this demuxer it would need to be moved to the
+-ugly module or those features need to come as add-in functionality stored in 
+another module.
+
+As the plugin is as of today's date (19th of June 2007) it does not 
+violate any software patents we know of.
diff --git a/gst/isomp4/Makefile.am b/gst/isomp4/Makefile.am
new file mode 100644
index 000000000..010e09ca0
--- /dev/null
+++ b/gst/isomp4/Makefile.am
@@ -0,0 +1,55 @@
+
+plugin_LTLIBRARIES = libgstisomp4.la
+
+libgstisomp4_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS)
+libgstisomp4_la_LIBADD = \
+    $(GST_PLUGINS_BASE_LIBS) \
+    -lgstriff-@GST_MAJORMINOR@ \
+    -lgstaudio-@GST_MAJORMINOR@ \
+    -lgstrtp-@GST_MAJORMINOR@ \
+    -lgsttag-@GST_MAJORMINOR@ \
+    -lgstpbutils-@GST_MAJORMINOR@ \
+    $(GST_BASE_LIBS) $(GST_LIBS) $(ZLIB_LIBS)
+libgstisomp4_la_LDFLAGS = ${GST_PLUGIN_LDFLAGS}
+libgstisomp4_la_SOURCES = isomp4-plugin.c gstrtpxqtdepay.c \
+	qtdemux.c qtdemux_types.c qtdemux_dump.c qtdemux_lang.c \
+	gstqtmux.c gstqtmoovrecover.c atoms.c atomsrecovery.c descriptors.c \
+	properties.c gstqtmuxmap.c
+libgstisomp4_la_LIBTOOLFLAGS = --tag=disable-static
+
+noinst_HEADERS = \
+	qtatomparser.h   \
+	qtdemux.h        \
+	qtdemux_types.h  \
+	qtdemux_dump.h   \
+	qtdemux_fourcc.h \
+	qtdemux_lang.h   \
+	qtpalette.h      \
+	gstrtpxqtdepay.h \
+	gstqtmux.h       \
+	gstqtmoovrecover.h \
+	atoms.h          \
+	atomsrecovery.h  \
+	descriptors.h    \
+	properties.h     \
+	fourcc.h         \
+	ftypcc.h         \
+	gstqtmuxmap.h
+
+EXTRA_DIST = \
+	gstqtmux-doc.c \
+	gstqtmux-doc.h
+
+Android.mk: Makefile.am $(BUILT_SOURCES)
+	androgenizer \
+	-:PROJECT libgstisomp4 -:SHARED libgstisomp4 \
+	 -:TAGS eng debug \
+         -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \
+	 -:SOURCES $(libgstisomp4_la_SOURCES) \
+	 -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(CPPFLAGS) $(libgstisomp4_la_CFLAGS) \
+	 -:LDFLAGS $(libgstisomp4_la_LDFLAGS) \
+	           $(libgstisomp4_la_LIBADD) \
+	           -ldl \
+	 -:PASSTHROUGH LOCAL_ARM_MODE:=arm \
+		       LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-0.10' \
+	> $@
diff --git a/gst/isomp4/atoms.c b/gst/isomp4/atoms.c
new file mode 100644
index 000000000..5aebd6b69
--- /dev/null
+++ b/gst/isomp4/atoms.c
@@ -0,0 +1,4423 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#include "atoms.h"
+#include <string.h>
+#include <glib.h>
+
+#include <gst/gst.h>
+#include <gst/base/gstbytewriter.h>
+#include <gst/tag/tag.h>
+
+/**
+ * Creates a new AtomsContext for the given flavor.
+ */
+AtomsContext *
+atoms_context_new (AtomsTreeFlavor flavor)
+{
+  AtomsContext *context = g_new0 (AtomsContext, 1);
+  context->flavor = flavor;
+  return context;
+}
+
+/**
+ * Frees an AtomsContext and all memory associated with it
+ */
+void
+atoms_context_free (AtomsContext * context)
+{
+  g_free (context);
+}
+
+/* -- creation, initialization, clear and free functions -- */
+
+#define SECS_PER_DAY (24 * 60 * 60)
+#define LEAP_YEARS_FROM_1904_TO_1970 17
+
+static guint64
+get_current_qt_time (void)
+{
+  GTimeVal timeval;
+
+  g_get_current_time (&timeval);
+  /* FIXME this should use UTC coordinated time */
+  return timeval.tv_sec + (((1970 - 1904) * (guint64) 365) +
+      LEAP_YEARS_FROM_1904_TO_1970) * SECS_PER_DAY;
+}
+
+static void
+common_time_info_init (TimeInfo * ti)
+{
+  ti->creation_time = ti->modification_time = get_current_qt_time ();
+  ti->timescale = 0;
+  ti->duration = 0;
+}
+
+static void
+atom_header_set (Atom * header, guint32 fourcc, gint32 size, gint64 ext_size)
+{
+  header->type = fourcc;
+  header->size = size;
+  header->extended_size = ext_size;
+}
+
+static void
+atom_clear (Atom * atom)
+{
+}
+
+static void
+atom_full_init (AtomFull * full, guint32 fourcc, gint32 size, gint64 ext_size,
+    guint8 version, guint8 flags[3])
+{
+  atom_header_set (&(full->header), fourcc, size, ext_size);
+  full->version = version;
+  full->flags[0] = flags[0];
+  full->flags[1] = flags[1];
+  full->flags[2] = flags[2];
+}
+
+static void
+atom_full_clear (AtomFull * full)
+{
+  atom_clear (&full->header);
+}
+
+static void
+atom_full_free (AtomFull * full)
+{
+  atom_full_clear (full);
+  g_free (full);
+}
+
+static guint32
+atom_full_get_flags_as_uint (AtomFull * full)
+{
+  return full->flags[0] << 16 | full->flags[1] << 8 | full->flags[2];
+}
+
+static void
+atom_full_set_flags_as_uint (AtomFull * full, guint32 flags_as_uint)
+{
+  full->flags[2] = flags_as_uint & 0xFF;
+  full->flags[1] = (flags_as_uint & 0xFF00) >> 8;
+  full->flags[0] = (flags_as_uint & 0xFF0000) >> 16;
+}
+
+static AtomInfo *
+build_atom_info_wrapper (Atom * atom, gpointer copy_func, gpointer free_func)
+{
+  AtomInfo *info = NULL;
+
+  if (atom) {
+    info = g_new0 (AtomInfo, 1);
+
+    info->atom = atom;
+    info->copy_data_func = copy_func;
+    info->free_func = free_func;
+  }
+
+  return info;
+}
+
+static GList *
+atom_info_list_prepend_atom (GList * ai, Atom * atom,
+    AtomCopyDataFunc copy_func, AtomFreeFunc free_func)
+{
+  if (atom)
+    return g_list_prepend (ai,
+        build_atom_info_wrapper (atom, copy_func, free_func));
+  else
+    return ai;
+}
+
+static void
+atom_info_list_free (GList * ai)
+{
+  while (ai) {
+    AtomInfo *info = (AtomInfo *) ai->data;
+
+    info->free_func (info->atom);
+    g_free (info);
+    ai = g_list_delete_link (ai, ai);
+  }
+}
+
+static AtomData *
+atom_data_new (guint32 fourcc)
+{
+  AtomData *data = g_new0 (AtomData, 1);
+
+  atom_header_set (&data->header, fourcc, 0, 0);
+  return data;
+}
+
+static void
+atom_data_alloc_mem (AtomData * data, guint32 size)
+{
+  if (data->data) {
+    g_free (data->data);
+  }
+  data->data = g_new0 (guint8, size);
+  data->datalen = size;
+}
+
+static AtomData *
+atom_data_new_from_gst_buffer (guint32 fourcc, const GstBuffer * buf)
+{
+  AtomData *data = atom_data_new (fourcc);
+
+  atom_data_alloc_mem (data, GST_BUFFER_SIZE (buf));
+  g_memmove (data->data, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
+  return data;
+}
+
+static void
+atom_data_free (AtomData * data)
+{
+  atom_clear (&data->header);
+  g_free (data->data);
+  g_free (data);
+}
+
+static AtomUUID *
+atom_uuid_new (void)
+{
+  AtomUUID *uuid = g_new0 (AtomUUID, 1);
+
+  atom_header_set (&uuid->header, FOURCC_uuid, 0, 0);
+  return uuid;
+}
+
+static void
+atom_uuid_free (AtomUUID * data)
+{
+  atom_clear (&data->header);
+  g_free (data->data);
+  g_free (data);
+}
+
+static void
+atom_ftyp_init (AtomFTYP * ftyp, guint32 major, guint32 version, GList * brands)
+{
+  gint index;
+  GList *it = NULL;
+
+  atom_header_set (&ftyp->header, FOURCC_ftyp, 16, 0);
+  ftyp->major_brand = major;
+  ftyp->version = version;
+
+  /* always include major brand as compatible brand */
+  ftyp->compatible_brands_size = g_list_length (brands) + 1;
+  ftyp->compatible_brands = g_new (guint32, ftyp->compatible_brands_size);
+
+  ftyp->compatible_brands[0] = major;
+  index = 1;
+  for (it = brands; it != NULL; it = g_list_next (it)) {
+    ftyp->compatible_brands[index++] = GPOINTER_TO_UINT (it->data);
+  }
+}
+
+AtomFTYP *
+atom_ftyp_new (AtomsContext * context, guint32 major, guint32 version,
+    GList * brands)
+{
+  AtomFTYP *ftyp = g_new0 (AtomFTYP, 1);
+
+  atom_ftyp_init (ftyp, major, version, brands);
+  return ftyp;
+}
+
+void
+atom_ftyp_free (AtomFTYP * ftyp)
+{
+  atom_clear (&ftyp->header);
+  g_free (ftyp->compatible_brands);
+  ftyp->compatible_brands = NULL;
+  g_free (ftyp);
+}
+
+static void
+atom_esds_init (AtomESDS * esds)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&esds->header, FOURCC_esds, 0, 0, 0, flags);
+  desc_es_init (&esds->es);
+}
+
+static AtomESDS *
+atom_esds_new (void)
+{
+  AtomESDS *esds = g_new0 (AtomESDS, 1);
+
+  atom_esds_init (esds);
+  return esds;
+}
+
+static void
+atom_esds_free (AtomESDS * esds)
+{
+  atom_full_clear (&esds->header);
+  desc_es_descriptor_clear (&esds->es);
+  g_free (esds);
+}
+
+static AtomFRMA *
+atom_frma_new (void)
+{
+  AtomFRMA *frma = g_new0 (AtomFRMA, 1);
+
+  atom_header_set (&frma->header, FOURCC_frma, 0, 0);
+  return frma;
+}
+
+static void
+atom_frma_free (AtomFRMA * frma)
+{
+  atom_clear (&frma->header);
+  g_free (frma);
+}
+
+static AtomWAVE *
+atom_wave_new (void)
+{
+  AtomWAVE *wave = g_new0 (AtomWAVE, 1);
+
+  atom_header_set (&wave->header, FOURCC_wave, 0, 0);
+  return wave;
+}
+
+static void
+atom_wave_free (AtomWAVE * wave)
+{
+  atom_clear (&wave->header);
+  atom_info_list_free (wave->extension_atoms);
+  g_free (wave);
+}
+
+static void
+atom_elst_init (AtomELST * elst)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+  atom_full_init (&elst->header, FOURCC_elst, 0, 0, 0, flags);
+  elst->entries = 0;
+}
+
+static void
+atom_elst_clear (AtomELST * elst)
+{
+  GSList *walker;
+
+  atom_full_clear (&elst->header);
+  walker = elst->entries;
+  while (walker) {
+    g_free ((EditListEntry *) walker->data);
+    walker = g_slist_next (walker);
+  }
+  g_slist_free (elst->entries);
+}
+
+static void
+atom_edts_init (AtomEDTS * edts)
+{
+  atom_header_set (&edts->header, FOURCC_edts, 0, 0);
+  atom_elst_init (&edts->elst);
+}
+
+static void
+atom_edts_clear (AtomEDTS * edts)
+{
+  atom_clear (&edts->header);
+  atom_elst_clear (&edts->elst);
+}
+
+static AtomEDTS *
+atom_edts_new (void)
+{
+  AtomEDTS *edts = g_new0 (AtomEDTS, 1);
+  atom_edts_init (edts);
+  return edts;
+}
+
+static void
+atom_edts_free (AtomEDTS * edts)
+{
+  atom_edts_clear (edts);
+  g_free (edts);
+}
+
+static void
+atom_sample_entry_init (SampleTableEntry * se, guint32 type)
+{
+  atom_header_set (&se->header, type, 0, 0);
+
+  memset (se->reserved, 0, sizeof (guint8) * 6);
+  se->data_reference_index = 0;
+}
+
+static void
+atom_sample_entry_free (SampleTableEntry * se)
+{
+  atom_clear (&se->header);
+}
+
+static void
+sample_entry_mp4a_init (SampleTableEntryMP4A * mp4a)
+{
+  atom_sample_entry_init (&mp4a->se, FOURCC_mp4a);
+
+  mp4a->version = 0;
+  mp4a->revision_level = 0;
+  mp4a->vendor = 0;
+  mp4a->channels = 2;
+  mp4a->sample_size = 16;
+  mp4a->compression_id = 0;
+  mp4a->packet_size = 0;
+  mp4a->sample_rate = 0;
+  /* following only used if version is 1 */
+  mp4a->samples_per_packet = 0;
+  mp4a->bytes_per_packet = 0;
+  mp4a->bytes_per_frame = 0;
+  mp4a->bytes_per_sample = 0;
+
+  mp4a->extension_atoms = NULL;
+}
+
+static SampleTableEntryMP4A *
+sample_entry_mp4a_new (void)
+{
+  SampleTableEntryMP4A *mp4a = g_new0 (SampleTableEntryMP4A, 1);
+
+  sample_entry_mp4a_init (mp4a);
+  return mp4a;
+}
+
+static void
+sample_entry_mp4a_free (SampleTableEntryMP4A * mp4a)
+{
+  atom_sample_entry_free (&mp4a->se);
+  atom_info_list_free (mp4a->extension_atoms);
+  g_free (mp4a);
+}
+
+static void
+sample_entry_mp4v_init (SampleTableEntryMP4V * mp4v, AtomsContext * context)
+{
+  atom_sample_entry_init (&mp4v->se, FOURCC_mp4v);
+
+  mp4v->version = 0;
+  mp4v->revision_level = 0;
+  mp4v->vendor = 0;
+
+  mp4v->temporal_quality = 0;
+  mp4v->spatial_quality = 0;
+
+  /* qt and ISO base media do not contradict, and examples agree */
+  mp4v->horizontal_resolution = 0x00480000;
+  mp4v->vertical_resolution = 0x00480000;
+
+  mp4v->datasize = 0;
+  mp4v->frame_count = 1;
+
+  memset (mp4v->compressor, 0, sizeof (guint8) * 32);
+
+  mp4v->depth = 0;
+  mp4v->color_table_id = 0;
+
+  mp4v->extension_atoms = NULL;
+}
+
+static void
+sample_entry_mp4v_free (SampleTableEntryMP4V * mp4v)
+{
+  atom_sample_entry_free (&mp4v->se);
+  atom_info_list_free (mp4v->extension_atoms);
+  g_free (mp4v);
+}
+
+static SampleTableEntryMP4V *
+sample_entry_mp4v_new (AtomsContext * context)
+{
+  SampleTableEntryMP4V *mp4v = g_new0 (SampleTableEntryMP4V, 1);
+
+  sample_entry_mp4v_init (mp4v, context);
+  return mp4v;
+}
+
+static void
+atom_stsd_init (AtomSTSD * stsd)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&stsd->header, FOURCC_stsd, 0, 0, 0, flags);
+  stsd->entries = NULL;
+  stsd->n_entries = 0;
+}
+
+static void
+atom_stsd_remove_entries (AtomSTSD * stsd)
+{
+  GList *walker;
+
+  walker = stsd->entries;
+  while (walker) {
+    GList *aux = walker;
+    SampleTableEntry *se = (SampleTableEntry *) aux->data;
+
+    walker = g_list_next (walker);
+    stsd->entries = g_list_remove_link (stsd->entries, aux);
+
+    switch (se->kind) {
+      case AUDIO:
+        sample_entry_mp4a_free ((SampleTableEntryMP4A *) se);
+        break;
+      case VIDEO:
+        sample_entry_mp4v_free ((SampleTableEntryMP4V *) se);
+        break;
+      default:
+        /* best possible cleanup */
+        atom_sample_entry_free (se);
+    }
+    g_list_free (aux);
+  }
+  stsd->n_entries = 0;
+}
+
+static void
+atom_stsd_clear (AtomSTSD * stsd)
+{
+  atom_stsd_remove_entries (stsd);
+  atom_full_clear (&stsd->header);
+}
+
+static void
+atom_ctts_init (AtomCTTS * ctts)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&ctts->header, FOURCC_ctts, 0, 0, 0, flags);
+  atom_array_init (&ctts->entries, 128);
+  ctts->do_pts = FALSE;
+}
+
+static AtomCTTS *
+atom_ctts_new (void)
+{
+  AtomCTTS *ctts = g_new0 (AtomCTTS, 1);
+
+  atom_ctts_init (ctts);
+  return ctts;
+}
+
+static void
+atom_ctts_free (AtomCTTS * ctts)
+{
+  atom_full_clear (&ctts->header);
+  atom_array_clear (&ctts->entries);
+  g_free (ctts);
+}
+
+static void
+atom_stts_init (AtomSTTS * stts)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&stts->header, FOURCC_stts, 0, 0, 0, flags);
+  atom_array_init (&stts->entries, 512);
+}
+
+static void
+atom_stts_clear (AtomSTTS * stts)
+{
+  atom_full_clear (&stts->header);
+  atom_array_clear (&stts->entries);
+}
+
+static void
+atom_stsz_init (AtomSTSZ * stsz)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&stsz->header, FOURCC_stsz, 0, 0, 0, flags);
+  atom_array_init (&stsz->entries, 1024);
+  stsz->sample_size = 0;
+  stsz->table_size = 0;
+}
+
+static void
+atom_stsz_clear (AtomSTSZ * stsz)
+{
+  atom_full_clear (&stsz->header);
+  atom_array_clear (&stsz->entries);
+  stsz->table_size = 0;
+}
+
+static void
+atom_stsc_init (AtomSTSC * stsc)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&stsc->header, FOURCC_stsc, 0, 0, 0, flags);
+  atom_array_init (&stsc->entries, 128);
+}
+
+static void
+atom_stsc_clear (AtomSTSC * stsc)
+{
+  atom_full_clear (&stsc->header);
+  atom_array_clear (&stsc->entries);
+}
+
+static void
+atom_co64_init (AtomSTCO64 * co64)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&co64->header, FOURCC_stco, 0, 0, 0, flags);
+  atom_array_init (&co64->entries, 256);
+}
+
+static void
+atom_stco64_clear (AtomSTCO64 * stco64)
+{
+  atom_full_clear (&stco64->header);
+  atom_array_clear (&stco64->entries);
+}
+
+static void
+atom_stss_init (AtomSTSS * stss)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&stss->header, FOURCC_stss, 0, 0, 0, flags);
+  atom_array_init (&stss->entries, 128);
+}
+
+static void
+atom_stss_clear (AtomSTSS * stss)
+{
+  atom_full_clear (&stss->header);
+  atom_array_clear (&stss->entries);
+}
+
+void
+atom_stbl_init (AtomSTBL * stbl)
+{
+  atom_header_set (&stbl->header, FOURCC_stbl, 0, 0);
+
+  atom_stts_init (&stbl->stts);
+  atom_stss_init (&stbl->stss);
+  atom_stsd_init (&stbl->stsd);
+  atom_stsz_init (&stbl->stsz);
+  atom_stsc_init (&stbl->stsc);
+  stbl->ctts = NULL;
+
+  atom_co64_init (&stbl->stco64);
+}
+
+void
+atom_stbl_clear (AtomSTBL * stbl)
+{
+  atom_clear (&stbl->header);
+  atom_stsd_clear (&stbl->stsd);
+  atom_stts_clear (&stbl->stts);
+  atom_stss_clear (&stbl->stss);
+  atom_stsc_clear (&stbl->stsc);
+  atom_stsz_clear (&stbl->stsz);
+  if (stbl->ctts) {
+    atom_ctts_free (stbl->ctts);
+  }
+  atom_stco64_clear (&stbl->stco64);
+}
+
+static void
+atom_vmhd_init (AtomVMHD * vmhd, AtomsContext * context)
+{
+  guint8 flags[3] = { 0, 0, 1 };
+
+  atom_full_init (&vmhd->header, FOURCC_vmhd, 0, 0, 0, flags);
+  vmhd->graphics_mode = 0x0;
+  memset (vmhd->opcolor, 0, sizeof (guint16) * 3);
+
+  if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {
+    vmhd->graphics_mode = 0x40;
+    vmhd->opcolor[0] = 32768;
+    vmhd->opcolor[1] = 32768;
+    vmhd->opcolor[2] = 32768;
+  }
+}
+
+static AtomVMHD *
+atom_vmhd_new (AtomsContext * context)
+{
+  AtomVMHD *vmhd = g_new0 (AtomVMHD, 1);
+
+  atom_vmhd_init (vmhd, context);
+  return vmhd;
+}
+
+static void
+atom_vmhd_free (AtomVMHD * vmhd)
+{
+  atom_full_clear (&vmhd->header);
+  g_free (vmhd);
+}
+
+static void
+atom_smhd_init (AtomSMHD * smhd)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&smhd->header, FOURCC_smhd, 0, 0, 0, flags);
+  smhd->balance = 0;
+  smhd->reserved = 0;
+}
+
+static AtomSMHD *
+atom_smhd_new (void)
+{
+  AtomSMHD *smhd = g_new0 (AtomSMHD, 1);
+
+  atom_smhd_init (smhd);
+  return smhd;
+}
+
+static void
+atom_smhd_free (AtomSMHD * smhd)
+{
+  atom_full_clear (&smhd->header);
+  g_free (smhd);
+}
+
+static void
+atom_hmhd_free (AtomHMHD * hmhd)
+{
+  atom_full_clear (&hmhd->header);
+  g_free (hmhd);
+}
+
+static void
+atom_hdlr_init (AtomHDLR * hdlr)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&hdlr->header, FOURCC_hdlr, 0, 0, 0, flags);
+
+  hdlr->component_type = 0;
+  hdlr->handler_type = 0;
+  hdlr->manufacturer = 0;
+  hdlr->flags = 0;
+  hdlr->flags_mask = 0;
+  hdlr->name = g_strdup ("");
+}
+
+static AtomHDLR *
+atom_hdlr_new (void)
+{
+  AtomHDLR *hdlr = g_new0 (AtomHDLR, 1);
+
+  atom_hdlr_init (hdlr);
+  return hdlr;
+}
+
+static void
+atom_hdlr_clear (AtomHDLR * hdlr)
+{
+  atom_full_clear (&hdlr->header);
+  if (hdlr->name) {
+    g_free (hdlr->name);
+    hdlr->name = NULL;
+  }
+}
+
+static void
+atom_hdlr_free (AtomHDLR * hdlr)
+{
+  atom_hdlr_clear (hdlr);
+  g_free (hdlr);
+}
+
+static void
+atom_url_init (AtomURL * url)
+{
+  guint8 flags[3] = { 0, 0, 1 };
+
+  atom_full_init (&url->header, FOURCC_url_, 0, 0, 0, flags);
+  url->location = NULL;
+}
+
+static void
+atom_url_free (AtomURL * url)
+{
+  atom_full_clear (&url->header);
+  if (url->location) {
+    g_free (url->location);
+    url->location = NULL;
+  }
+  g_free (url);
+}
+
+static AtomURL *
+atom_url_new (void)
+{
+  AtomURL *url = g_new0 (AtomURL, 1);
+
+  atom_url_init (url);
+  return url;
+}
+
+static AtomFull *
+atom_alis_new (void)
+{
+  guint8 flags[3] = { 0, 0, 1 };
+  AtomFull *alis = g_new0 (AtomFull, 1);
+
+  atom_full_init (alis, FOURCC_alis, 0, 0, 0, flags);
+  return alis;
+}
+
+static void
+atom_dref_init (AtomDREF * dref, AtomsContext * context)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&dref->header, FOURCC_dref, 0, 0, 0, flags);
+
+  /* in either case, alis or url init arranges to set self-contained flag */
+  if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {
+    /* alis dref for qt */
+    AtomFull *alis = atom_alis_new ();
+    dref->entries = g_list_append (dref->entries, alis);
+  } else {
+    /* url for iso spec, as 'alis' not specified there */
+    AtomURL *url = atom_url_new ();
+    dref->entries = g_list_append (dref->entries, url);
+  }
+}
+
+static void
+atom_dref_clear (AtomDREF * dref)
+{
+  GList *walker;
+
+  atom_full_clear (&dref->header);
+  walker = dref->entries;
+  while (walker) {
+    GList *aux = walker;
+    Atom *atom = (Atom *) aux->data;
+
+    walker = g_list_next (walker);
+    dref->entries = g_list_remove_link (dref->entries, aux);
+    switch (atom->type) {
+      case FOURCC_alis:
+        atom_full_free ((AtomFull *) atom);
+        break;
+      case FOURCC_url_:
+        atom_url_free ((AtomURL *) atom);
+        break;
+      default:
+        /* we do nothing, better leak than crash */
+        break;
+    }
+    g_list_free (aux);
+  }
+}
+
+static void
+atom_dinf_init (AtomDINF * dinf, AtomsContext * context)
+{
+  atom_header_set (&dinf->header, FOURCC_dinf, 0, 0);
+  atom_dref_init (&dinf->dref, context);
+}
+
+static void
+atom_dinf_clear (AtomDINF * dinf)
+{
+  atom_clear (&dinf->header);
+  atom_dref_clear (&dinf->dref);
+}
+
+static void
+atom_minf_init (AtomMINF * minf, AtomsContext * context)
+{
+  atom_header_set (&minf->header, FOURCC_minf, 0, 0);
+
+  minf->vmhd = NULL;
+  minf->smhd = NULL;
+  minf->hmhd = NULL;
+
+  if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {
+    minf->hdlr = atom_hdlr_new ();
+    minf->hdlr->component_type = FOURCC_dhlr;
+    minf->hdlr->handler_type = FOURCC_alis;
+  } else {
+    minf->hdlr = NULL;
+  }
+  atom_dinf_init (&minf->dinf, context);
+  atom_stbl_init (&minf->stbl);
+}
+
+static void
+atom_minf_clear_handlers (AtomMINF * minf)
+{
+  if (minf->vmhd) {
+    atom_vmhd_free (minf->vmhd);
+    minf->vmhd = NULL;
+  }
+  if (minf->smhd) {
+    atom_smhd_free (minf->smhd);
+    minf->smhd = NULL;
+  }
+  if (minf->hmhd) {
+    atom_hmhd_free (minf->hmhd);
+    minf->hmhd = NULL;
+  }
+}
+
+static void
+atom_minf_clear (AtomMINF * minf)
+{
+  atom_clear (&minf->header);
+  atom_minf_clear_handlers (minf);
+  if (minf->hdlr) {
+    atom_hdlr_free (minf->hdlr);
+  }
+  atom_dinf_clear (&minf->dinf);
+  atom_stbl_clear (&minf->stbl);
+}
+
+static void
+atom_mdhd_init (AtomMDHD * mdhd)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&mdhd->header, FOURCC_mdhd, 0, 0, 0, flags);
+  common_time_info_init (&mdhd->time_info);
+  mdhd->language_code = 0;
+  mdhd->quality = 0;
+}
+
+static void
+atom_mdhd_clear (AtomMDHD * mdhd)
+{
+  atom_full_clear (&mdhd->header);
+}
+
+static void
+atom_mdia_init (AtomMDIA * mdia, AtomsContext * context)
+{
+  atom_header_set (&mdia->header, FOURCC_mdia, 0, 0);
+
+  atom_mdhd_init (&mdia->mdhd);
+  atom_hdlr_init (&mdia->hdlr);
+  atom_minf_init (&mdia->minf, context);
+}
+
+static void
+atom_mdia_clear (AtomMDIA * mdia)
+{
+  atom_clear (&mdia->header);
+  atom_mdhd_clear (&mdia->mdhd);
+  atom_hdlr_clear (&mdia->hdlr);
+  atom_minf_clear (&mdia->minf);
+}
+
+static void
+atom_tkhd_init (AtomTKHD * tkhd, AtomsContext * context)
+{
+  /*
+   * flags info
+   * 1 -> track enabled
+   * 2 -> track in movie
+   * 4 -> track in preview
+   */
+  guint8 flags[3] = { 0, 0, 7 };
+
+  atom_full_init (&tkhd->header, FOURCC_tkhd, 0, 0, 0, flags);
+
+  tkhd->creation_time = tkhd->modification_time = get_current_qt_time ();
+  tkhd->duration = 0;
+  tkhd->track_ID = 0;
+  tkhd->reserved = 0;
+
+  tkhd->reserved2[0] = tkhd->reserved2[1] = 0;
+  tkhd->layer = 0;
+  tkhd->alternate_group = 0;
+  tkhd->volume = 0;
+  tkhd->reserved3 = 0;
+  memset (tkhd->matrix, 0, sizeof (guint32) * 9);
+  tkhd->matrix[0] = 1 << 16;
+  tkhd->matrix[4] = 1 << 16;
+  tkhd->matrix[8] = 16384 << 16;
+  tkhd->width = 0;
+  tkhd->height = 0;
+}
+
+static void
+atom_tkhd_clear (AtomTKHD * tkhd)
+{
+  atom_full_clear (&tkhd->header);
+}
+
+static void
+atom_trak_init (AtomTRAK * trak, AtomsContext * context)
+{
+  atom_header_set (&trak->header, FOURCC_trak, 0, 0);
+
+  atom_tkhd_init (&trak->tkhd, context);
+  trak->edts = NULL;
+  atom_mdia_init (&trak->mdia, context);
+}
+
+AtomTRAK *
+atom_trak_new (AtomsContext * context)
+{
+  AtomTRAK *trak = g_new0 (AtomTRAK, 1);
+
+  atom_trak_init (trak, context);
+  return trak;
+}
+
+static void
+atom_trak_clear (AtomTRAK * trak)
+{
+  atom_clear (&trak->header);
+  atom_tkhd_clear (&trak->tkhd);
+  if (trak->edts)
+    atom_edts_free (trak->edts);
+  atom_mdia_clear (&trak->mdia);
+}
+
+static void
+atom_trak_free (AtomTRAK * trak)
+{
+  atom_trak_clear (trak);
+  g_free (trak);
+}
+
+static void
+atom_ilst_init (AtomILST * ilst)
+{
+  atom_header_set (&ilst->header, FOURCC_ilst, 0, 0);
+  ilst->entries = NULL;
+}
+
+static AtomILST *
+atom_ilst_new (void)
+{
+  AtomILST *ilst = g_new0 (AtomILST, 1);
+
+  atom_ilst_init (ilst);
+  return ilst;
+}
+
+static void
+atom_ilst_free (AtomILST * ilst)
+{
+  if (ilst->entries)
+    atom_info_list_free (ilst->entries);
+  atom_clear (&ilst->header);
+  g_free (ilst);
+}
+
+static void
+atom_meta_init (AtomMETA * meta)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&meta->header, FOURCC_meta, 0, 0, 0, flags);
+  atom_hdlr_init (&meta->hdlr);
+  /* FIXME (ISOM says this is always 0) */
+  meta->hdlr.component_type = FOURCC_mhlr;
+  meta->hdlr.handler_type = FOURCC_mdir;
+  meta->ilst = NULL;
+}
+
+static AtomMETA *
+atom_meta_new (void)
+{
+  AtomMETA *meta = g_new0 (AtomMETA, 1);
+
+  atom_meta_init (meta);
+  return meta;
+}
+
+static void
+atom_meta_free (AtomMETA * meta)
+{
+  atom_full_clear (&meta->header);
+  atom_hdlr_clear (&meta->hdlr);
+  if (meta->ilst)
+    atom_ilst_free (meta->ilst);
+  meta->ilst = NULL;
+  g_free (meta);
+}
+
+static void
+atom_udta_init (AtomUDTA * udta)
+{
+  atom_header_set (&udta->header, FOURCC_udta, 0, 0);
+  udta->meta = NULL;
+}
+
+static AtomUDTA *
+atom_udta_new (void)
+{
+  AtomUDTA *udta = g_new0 (AtomUDTA, 1);
+
+  atom_udta_init (udta);
+  return udta;
+}
+
+static void
+atom_udta_free (AtomUDTA * udta)
+{
+  atom_clear (&udta->header);
+  if (udta->meta)
+    atom_meta_free (udta->meta);
+  udta->meta = NULL;
+  if (udta->entries)
+    atom_info_list_free (udta->entries);
+  g_free (udta);
+}
+
+static void
+atom_tag_data_init (AtomTagData * data)
+{
+  guint8 flags[] = { 0, 0, 0 };
+
+  atom_full_init (&data->header, FOURCC_data, 0, 0, 0, flags);
+}
+
+static void
+atom_tag_data_clear (AtomTagData * data)
+{
+  atom_full_clear (&data->header);
+  g_free (data->data);
+  data->datalen = 0;
+}
+
+/*
+ * Fourcc is the tag fourcc
+ * flags will be truncated to 24bits
+ */
+static AtomTag *
+atom_tag_new (guint32 fourcc, guint32 flags_as_uint)
+{
+  AtomTag *tag = g_new0 (AtomTag, 1);
+
+  tag->header.type = fourcc;
+  atom_tag_data_init (&tag->data);
+  atom_full_set_flags_as_uint (&tag->data.header, flags_as_uint);
+  return tag;
+}
+
+static void
+atom_tag_free (AtomTag * tag)
+{
+  atom_clear (&tag->header);
+  atom_tag_data_clear (&tag->data);
+  g_free (tag);
+}
+
+static void
+atom_mvhd_init (AtomMVHD * mvhd)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&(mvhd->header), FOURCC_mvhd, sizeof (AtomMVHD), 0, 0, flags);
+
+  common_time_info_init (&mvhd->time_info);
+
+  mvhd->prefered_rate = 1 << 16;
+  mvhd->volume = 1 << 8;
+  mvhd->reserved3 = 0;
+  memset (mvhd->reserved4, 0, sizeof (guint32[2]));
+
+  memset (mvhd->matrix, 0, sizeof (guint32[9]));
+  mvhd->matrix[0] = 1 << 16;
+  mvhd->matrix[4] = 1 << 16;
+  mvhd->matrix[8] = 16384 << 16;
+
+  mvhd->preview_time = 0;
+  mvhd->preview_duration = 0;
+  mvhd->poster_time = 0;
+  mvhd->selection_time = 0;
+  mvhd->selection_duration = 0;
+  mvhd->current_time = 0;
+
+  mvhd->next_track_id = 1;
+}
+
+static void
+atom_mvhd_clear (AtomMVHD * mvhd)
+{
+  atom_full_clear (&mvhd->header);
+}
+
+static void
+atom_mehd_init (AtomMEHD * mehd)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&mehd->header, FOURCC_mehd, 0, 0, 1, flags);
+  mehd->fragment_duration = 0;
+}
+
+static void
+atom_mvex_init (AtomMVEX * mvex)
+{
+  atom_header_set (&mvex->header, FOURCC_mvex, 0, 0);
+  atom_mehd_init (&mvex->mehd);
+  mvex->trexs = NULL;
+}
+
+static void
+atom_moov_init (AtomMOOV * moov, AtomsContext * context)
+{
+  atom_header_set (&(moov->header), FOURCC_moov, 0, 0);
+  atom_mvhd_init (&(moov->mvhd));
+  atom_mvex_init (&(moov->mvex));
+  moov->udta = NULL;
+  moov->traks = NULL;
+  moov->context = *context;
+}
+
+AtomMOOV *
+atom_moov_new (AtomsContext * context)
+{
+  AtomMOOV *moov = g_new0 (AtomMOOV, 1);
+
+  atom_moov_init (moov, context);
+  return moov;
+}
+
+static void
+atom_trex_free (AtomTREX * trex)
+{
+  atom_full_clear (&trex->header);
+  g_free (trex);
+}
+
+static void
+atom_mvex_clear (AtomMVEX * mvex)
+{
+  GList *walker;
+
+  atom_clear (&mvex->header);
+  walker = mvex->trexs;
+  while (walker) {
+    atom_trex_free ((AtomTREX *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (mvex->trexs);
+  mvex->trexs = NULL;
+}
+
+void
+atom_moov_free (AtomMOOV * moov)
+{
+  GList *walker;
+
+  atom_clear (&moov->header);
+  atom_mvhd_clear (&moov->mvhd);
+
+  walker = moov->traks;
+  while (walker) {
+    atom_trak_free ((AtomTRAK *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (moov->traks);
+  moov->traks = NULL;
+
+  if (moov->udta) {
+    atom_udta_free (moov->udta);
+    moov->udta = NULL;
+  }
+
+  atom_mvex_clear (&moov->mvex);
+
+  g_free (moov);
+}
+
+/* -- end of init / free -- */
+
+/* -- copy data functions -- */
+
+static guint8
+atom_full_get_version (AtomFull * full)
+{
+  return full->version;
+}
+
+static guint64
+common_time_info_copy_data (TimeInfo * ti, gboolean trunc_to_32,
+    guint8 ** buffer, guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (trunc_to_32) {
+    prop_copy_uint32 ((guint32) ti->creation_time, buffer, size, offset);
+    prop_copy_uint32 ((guint32) ti->modification_time, buffer, size, offset);
+    prop_copy_uint32 (ti->timescale, buffer, size, offset);
+    prop_copy_uint32 ((guint32) ti->duration, buffer, size, offset);
+  } else {
+    prop_copy_uint64 (ti->creation_time, buffer, size, offset);
+    prop_copy_uint64 (ti->modification_time, buffer, size, offset);
+    prop_copy_uint32 (ti->timescale, buffer, size, offset);
+    prop_copy_uint64 (ti->duration, buffer, size, offset);
+  }
+  return *offset - original_offset;
+}
+
+static void
+atom_write_size (guint8 ** buffer, guint64 * size, guint64 * offset,
+    guint64 atom_pos)
+{
+  /* this only works for non-extended atom size, which is OK
+   * (though it could be made to do mem_move, etc and write extended size) */
+  prop_copy_uint32 (*offset - atom_pos, buffer, size, &atom_pos);
+}
+
+guint64
+atom_copy_data (Atom * atom, guint8 ** buffer, guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  /* copies type and size */
+  prop_copy_uint32 (atom->size, buffer, size, offset);
+  prop_copy_fourcc (atom->type, buffer, size, offset);
+
+  /* extended size needed */
+  if (atom->size == 1) {
+    /* really should not happen other than with mdat atom;
+     * would be a problem for size (re)write code, not to mention memory */
+    g_return_val_if_fail (atom->type == FOURCC_mdat, 0);
+    prop_copy_uint64 (atom->extended_size, buffer, size, offset);
+  }
+
+  return *offset - original_offset;
+}
+
+static guint64
+atom_full_copy_data (AtomFull * atom, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&atom->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint8 (atom->version, buffer, size, offset);
+  prop_copy_uint8_array (atom->flags, 3, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_info_list_copy_data (GList * ai, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  while (ai) {
+    AtomInfo *info = (AtomInfo *) ai->data;
+
+    if (!info->copy_data_func (info->atom, buffer, size, offset)) {
+      return 0;
+    }
+    ai = g_list_next (ai);
+  }
+
+  return *offset - original_offset;
+}
+
+static guint64
+atom_data_copy_data (AtomData * data, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&data->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (data->datalen)
+    prop_copy_uint8_array (data->data, data->datalen, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_uuid_copy_data (AtomUUID * uuid, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&uuid->header, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_uint8_array (uuid->uuid, 16, buffer, size, offset);
+  if (uuid->datalen)
+    prop_copy_uint8_array (uuid->data, uuid->datalen, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_ftyp_copy_data (AtomFTYP * ftyp, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&ftyp->header, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_fourcc (ftyp->major_brand, buffer, size, offset);
+  prop_copy_uint32 (ftyp->version, buffer, size, offset);
+
+  prop_copy_fourcc_array (ftyp->compatible_brands, ftyp->compatible_brands_size,
+      buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_mvhd_copy_data (AtomMVHD * atom, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint8 version;
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&(atom->header), buffer, size, offset)) {
+    return 0;
+  }
+
+  version = atom_full_get_version (&(atom->header));
+  if (version == 0) {
+    common_time_info_copy_data (&atom->time_info, TRUE, buffer, size, offset);
+  } else if (version == 1) {
+    common_time_info_copy_data (&atom->time_info, FALSE, buffer, size, offset);
+  } else {
+    *offset = original_offset;
+    return 0;
+  }
+
+  prop_copy_uint32 (atom->prefered_rate, buffer, size, offset);
+  prop_copy_uint16 (atom->volume, buffer, size, offset);
+  prop_copy_uint16 (atom->reserved3, buffer, size, offset);
+  prop_copy_uint32_array (atom->reserved4, 2, buffer, size, offset);
+  prop_copy_uint32_array (atom->matrix, 9, buffer, size, offset);
+  prop_copy_uint32 (atom->preview_time, buffer, size, offset);
+  prop_copy_uint32 (atom->preview_duration, buffer, size, offset);
+  prop_copy_uint32 (atom->poster_time, buffer, size, offset);
+  prop_copy_uint32 (atom->selection_time, buffer, size, offset);
+  prop_copy_uint32 (atom->selection_duration, buffer, size, offset);
+  prop_copy_uint32 (atom->current_time, buffer, size, offset);
+
+  prop_copy_uint32 (atom->next_track_id, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_tkhd_copy_data (AtomTKHD * tkhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&tkhd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (atom_full_get_version (&tkhd->header) == 0) {
+    prop_copy_uint32 ((guint32) tkhd->creation_time, buffer, size, offset);
+    prop_copy_uint32 ((guint32) tkhd->modification_time, buffer, size, offset);
+    prop_copy_uint32 (tkhd->track_ID, buffer, size, offset);
+    prop_copy_uint32 (tkhd->reserved, buffer, size, offset);
+    prop_copy_uint32 ((guint32) tkhd->duration, buffer, size, offset);
+  } else {
+    prop_copy_uint64 (tkhd->creation_time, buffer, size, offset);
+    prop_copy_uint64 (tkhd->modification_time, buffer, size, offset);
+    prop_copy_uint32 (tkhd->track_ID, buffer, size, offset);
+    prop_copy_uint32 (tkhd->reserved, buffer, size, offset);
+    prop_copy_uint64 (tkhd->duration, buffer, size, offset);
+  }
+
+  prop_copy_uint32_array (tkhd->reserved2, 2, buffer, size, offset);
+  prop_copy_uint16 (tkhd->layer, buffer, size, offset);
+  prop_copy_uint16 (tkhd->alternate_group, buffer, size, offset);
+  prop_copy_uint16 (tkhd->volume, buffer, size, offset);
+  prop_copy_uint16 (tkhd->reserved3, buffer, size, offset);
+  prop_copy_uint32_array (tkhd->matrix, 9, buffer, size, offset);
+
+  prop_copy_uint32 (tkhd->width, buffer, size, offset);
+  prop_copy_uint32 (tkhd->height, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_hdlr_copy_data (AtomHDLR * hdlr, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&hdlr->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_fourcc (hdlr->component_type, buffer, size, offset);
+  prop_copy_fourcc (hdlr->handler_type, buffer, size, offset);
+  prop_copy_fourcc (hdlr->manufacturer, buffer, size, offset);
+  prop_copy_uint32 (hdlr->flags, buffer, size, offset);
+  prop_copy_uint32 (hdlr->flags_mask, buffer, size, offset);
+
+  prop_copy_size_string ((guint8 *) hdlr->name, strlen (hdlr->name), buffer,
+      size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_vmhd_copy_data (AtomVMHD * vmhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&vmhd->header, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_uint16 (vmhd->graphics_mode, buffer, size, offset);
+  prop_copy_uint16_array (vmhd->opcolor, 3, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+static guint64
+atom_smhd_copy_data (AtomSMHD * smhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&smhd->header, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_uint16 (smhd->balance, buffer, size, offset);
+  prop_copy_uint16 (smhd->reserved, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+static guint64
+atom_hmhd_copy_data (AtomHMHD * hmhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&hmhd->header, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_uint16 (hmhd->max_pdu_size, buffer, size, offset);
+  prop_copy_uint16 (hmhd->avg_pdu_size, buffer, size, offset);
+  prop_copy_uint32 (hmhd->max_bitrate, buffer, size, offset);
+  prop_copy_uint32 (hmhd->avg_bitrate, buffer, size, offset);
+  prop_copy_uint32 (hmhd->sliding_avg_bitrate, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+static gboolean
+atom_url_same_file_flag (AtomURL * url)
+{
+  return (url->header.flags[2] & 0x1) == 1;
+}
+
+static guint64
+atom_url_copy_data (AtomURL * url, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&url->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_url_same_file_flag (url)) {
+    prop_copy_null_terminated_string (url->location, buffer, size, offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+guint64
+atom_stts_copy_data (AtomSTTS * stts, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+
+  if (!atom_full_copy_data (&stts->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (atom_array_get_len (&stts->entries), buffer, size, offset);
+  /* minimize realloc */
+  prop_copy_ensure_buffer (buffer, size, offset,
+      8 * atom_array_get_len (&stts->entries));
+  for (i = 0; i < atom_array_get_len (&stts->entries); i++) {
+    STTSEntry *entry = &atom_array_index (&stts->entries, i);
+
+    prop_copy_uint32 (entry->sample_count, buffer, size, offset);
+    prop_copy_int32 (entry->sample_delta, buffer, size, offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_sample_entry_copy_data (SampleTableEntry * se, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&se->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint8_array (se->reserved, 6, buffer, size, offset);
+  prop_copy_uint16 (se->data_reference_index, buffer, size, offset);
+
+  return *offset - original_offset;
+}
+
+static guint64
+atom_esds_copy_data (AtomESDS * esds, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&esds->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (!desc_es_descriptor_copy_data (&esds->es, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_frma_copy_data (AtomFRMA * frma, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&(frma->header), buffer, size, offset))
+    return 0;
+
+  prop_copy_fourcc (frma->media_type, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mp4s_copy_data (SampleTableEntryMP4S * mp4s, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_sample_entry_copy_data (&mp4s->se, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_esds_copy_data (&mp4s->es, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_hint_sample_entry_copy_data (AtomHintSampleEntry * hse, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_sample_entry_copy_data (&hse->se, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (hse->size, buffer, size, offset);
+  prop_copy_uint8_array (hse->data, hse->size, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+sample_entry_mp4a_copy_data (SampleTableEntryMP4A * mp4a, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_sample_entry_copy_data (&mp4a->se, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint16 (mp4a->version, buffer, size, offset);
+  prop_copy_uint16 (mp4a->revision_level, buffer, size, offset);
+  prop_copy_uint32 (mp4a->vendor, buffer, size, offset);
+  prop_copy_uint16 (mp4a->channels, buffer, size, offset);
+  prop_copy_uint16 (mp4a->sample_size, buffer, size, offset);
+  prop_copy_uint16 (mp4a->compression_id, buffer, size, offset);
+  prop_copy_uint16 (mp4a->packet_size, buffer, size, offset);
+  prop_copy_uint32 (mp4a->sample_rate, buffer, size, offset);
+
+  /* this should always be 0 for mp4 flavor */
+  if (mp4a->version == 1) {
+    prop_copy_uint32 (mp4a->samples_per_packet, buffer, size, offset);
+    prop_copy_uint32 (mp4a->bytes_per_packet, buffer, size, offset);
+    prop_copy_uint32 (mp4a->bytes_per_frame, buffer, size, offset);
+    prop_copy_uint32 (mp4a->bytes_per_sample, buffer, size, offset);
+  }
+
+  if (mp4a->extension_atoms) {
+    if (!atom_info_list_copy_data (mp4a->extension_atoms, buffer, size, offset))
+      return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+sample_entry_mp4v_copy_data (SampleTableEntryMP4V * mp4v, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_sample_entry_copy_data (&mp4v->se, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint16 (mp4v->version, buffer, size, offset);
+  prop_copy_uint16 (mp4v->revision_level, buffer, size, offset);
+  prop_copy_fourcc (mp4v->vendor, buffer, size, offset);
+  prop_copy_uint32 (mp4v->temporal_quality, buffer, size, offset);
+  prop_copy_uint32 (mp4v->spatial_quality, buffer, size, offset);
+
+  prop_copy_uint16 (mp4v->width, buffer, size, offset);
+  prop_copy_uint16 (mp4v->height, buffer, size, offset);
+
+  prop_copy_uint32 (mp4v->horizontal_resolution, buffer, size, offset);
+  prop_copy_uint32 (mp4v->vertical_resolution, buffer, size, offset);
+  prop_copy_uint32 (mp4v->datasize, buffer, size, offset);
+
+  prop_copy_uint16 (mp4v->frame_count, buffer, size, offset);
+
+  prop_copy_fixed_size_string ((guint8 *) mp4v->compressor, 32, buffer, size,
+      offset);
+
+  prop_copy_uint16 (mp4v->depth, buffer, size, offset);
+  prop_copy_uint16 (mp4v->color_table_id, buffer, size, offset);
+
+  /* extra atoms */
+  if (mp4v->extension_atoms &&
+      !atom_info_list_copy_data (mp4v->extension_atoms, buffer, size, offset))
+    return 0;
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_stsz_copy_data (AtomSTSZ * stsz, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+
+  if (!atom_full_copy_data (&stsz->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (stsz->sample_size, buffer, size, offset);
+  prop_copy_uint32 (stsz->table_size, buffer, size, offset);
+  if (stsz->sample_size == 0) {
+    /* minimize realloc */
+    prop_copy_ensure_buffer (buffer, size, offset, 4 * stsz->table_size);
+    /* entry count must match sample count */
+    g_assert (atom_array_get_len (&stsz->entries) == stsz->table_size);
+    for (i = 0; i < atom_array_get_len (&stsz->entries); i++) {
+      prop_copy_uint32 (atom_array_index (&stsz->entries, i), buffer, size,
+          offset);
+    }
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_stsc_copy_data (AtomSTSC * stsc, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+
+  if (!atom_full_copy_data (&stsc->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (atom_array_get_len (&stsc->entries), buffer, size, offset);
+  /* minimize realloc */
+  prop_copy_ensure_buffer (buffer, size, offset,
+      12 * atom_array_get_len (&stsc->entries));
+
+  for (i = 0; i < atom_array_get_len (&stsc->entries); i++) {
+    STSCEntry *entry = &atom_array_index (&stsc->entries, i);
+
+    prop_copy_uint32 (entry->first_chunk, buffer, size, offset);
+    prop_copy_uint32 (entry->samples_per_chunk, buffer, size, offset);
+    prop_copy_uint32 (entry->sample_description_index, buffer, size, offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_ctts_copy_data (AtomCTTS * ctts, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+
+  if (!atom_full_copy_data (&ctts->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (atom_array_get_len (&ctts->entries), buffer, size, offset);
+  /* minimize realloc */
+  prop_copy_ensure_buffer (buffer, size, offset,
+      8 * atom_array_get_len (&ctts->entries));
+  for (i = 0; i < atom_array_get_len (&ctts->entries); i++) {
+    CTTSEntry *entry = &atom_array_index (&ctts->entries, i);
+
+    prop_copy_uint32 (entry->samplecount, buffer, size, offset);
+    prop_copy_uint32 (entry->sampleoffset, buffer, size, offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_stco64_copy_data (AtomSTCO64 * stco64, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+  gboolean trunc_to_32 = stco64->header.header.type == FOURCC_stco;
+
+  if (!atom_full_copy_data (&stco64->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (atom_array_get_len (&stco64->entries), buffer, size,
+      offset);
+
+  /* minimize realloc */
+  prop_copy_ensure_buffer (buffer, size, offset,
+      8 * atom_array_get_len (&stco64->entries));
+  for (i = 0; i < atom_array_get_len (&stco64->entries); i++) {
+    guint64 *value = &atom_array_index (&stco64->entries, i);
+
+    if (trunc_to_32) {
+      prop_copy_uint32 ((guint32) * value, buffer, size, offset);
+    } else {
+      prop_copy_uint64 (*value, buffer, size, offset);
+    }
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_stss_copy_data (AtomSTSS * stss, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint i;
+
+  if (atom_array_get_len (&stss->entries) == 0) {
+    /* FIXME not needing this atom might be confused with error while copying */
+    return 0;
+  }
+
+  if (!atom_full_copy_data (&stss->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (atom_array_get_len (&stss->entries), buffer, size, offset);
+  /* minimize realloc */
+  prop_copy_ensure_buffer (buffer, size, offset,
+      4 * atom_array_get_len (&stss->entries));
+  for (i = 0; i < atom_array_get_len (&stss->entries); i++) {
+    prop_copy_uint32 (atom_array_index (&stss->entries, i), buffer, size,
+        offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_stsd_copy_data (AtomSTSD * stsd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_full_copy_data (&stsd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (stsd->n_entries, buffer, size, offset);
+
+  for (walker = g_list_last (stsd->entries); walker != NULL;
+      walker = g_list_previous (walker)) {
+    SampleTableEntry *se = (SampleTableEntry *) walker->data;
+
+    switch (((Atom *) walker->data)->type) {
+      case FOURCC_mp4a:
+        if (!sample_entry_mp4a_copy_data ((SampleTableEntryMP4A *) walker->data,
+                buffer, size, offset)) {
+          return 0;
+        }
+        break;
+      case FOURCC_mp4s:
+        if (!atom_mp4s_copy_data ((SampleTableEntryMP4S *) walker->data,
+                buffer, size, offset)) {
+          return 0;
+        }
+        break;
+      case FOURCC_mp4v:
+        if (!sample_entry_mp4v_copy_data ((SampleTableEntryMP4V *) walker->data,
+                buffer, size, offset)) {
+          return 0;
+        }
+        break;
+      default:
+        if (se->kind == VIDEO) {
+          if (!sample_entry_mp4v_copy_data ((SampleTableEntryMP4V *)
+                  walker->data, buffer, size, offset)) {
+            return 0;
+          }
+        } else if (se->kind == AUDIO) {
+          if (!sample_entry_mp4a_copy_data ((SampleTableEntryMP4A *)
+                  walker->data, buffer, size, offset)) {
+            return 0;
+          }
+        } else {
+          if (!atom_hint_sample_entry_copy_data (
+                  (AtomHintSampleEntry *) walker->data, buffer, size, offset)) {
+            return 0;
+          }
+        }
+        break;
+    }
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_stbl_copy_data (AtomSTBL * stbl, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&stbl->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_stsd_copy_data (&stbl->stsd, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_stts_copy_data (&stbl->stts, buffer, size, offset)) {
+    return 0;
+  }
+  /* this atom is optional, so let's check if we need it
+   * (to avoid false error) */
+  if (atom_array_get_len (&stbl->stss.entries)) {
+    if (!atom_stss_copy_data (&stbl->stss, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  if (!atom_stsc_copy_data (&stbl->stsc, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_stsz_copy_data (&stbl->stsz, buffer, size, offset)) {
+    return 0;
+  }
+  if (stbl->ctts && stbl->ctts->do_pts) {
+    if (!atom_ctts_copy_data (stbl->ctts, buffer, size, offset)) {
+      return 0;
+    }
+  }
+  if (!atom_stco64_copy_data (&stbl->stco64, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+
+static guint64
+atom_dref_copy_data (AtomDREF * dref, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_full_copy_data (&dref->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (g_list_length (dref->entries), buffer, size, offset);
+
+  walker = dref->entries;
+  while (walker != NULL) {
+    Atom *atom = (Atom *) walker->data;
+
+    if (atom->type == FOURCC_url_) {
+      atom_url_copy_data ((AtomURL *) atom, buffer, size, offset);
+    } else if (atom->type == FOURCC_alis) {
+      atom_full_copy_data ((AtomFull *) atom, buffer, size, offset);
+    } else {
+      g_error ("Unsupported atom used inside dref atom");
+    }
+    walker = g_list_next (walker);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_dinf_copy_data (AtomDINF * dinf, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&dinf->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_dref_copy_data (&dinf->dref, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return original_offset - *offset;
+}
+
+static guint64
+atom_minf_copy_data (AtomMINF * minf, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&minf->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (minf->vmhd) {
+    if (!atom_vmhd_copy_data (minf->vmhd, buffer, size, offset)) {
+      return 0;
+    }
+  } else if (minf->smhd) {
+    if (!atom_smhd_copy_data (minf->smhd, buffer, size, offset)) {
+      return 0;
+    }
+  } else if (minf->hmhd) {
+    if (!atom_hmhd_copy_data (minf->hmhd, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  if (minf->hdlr) {
+    if (!atom_hdlr_copy_data (minf->hdlr, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  if (!atom_dinf_copy_data (&minf->dinf, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_stbl_copy_data (&minf->stbl, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mdhd_copy_data (AtomMDHD * mdhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&mdhd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!common_time_info_copy_data (&mdhd->time_info,
+          atom_full_get_version (&mdhd->header) == 0, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint16 (mdhd->language_code, buffer, size, offset);
+  prop_copy_uint16 (mdhd->quality, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mdia_copy_data (AtomMDIA * mdia, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&mdia->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_mdhd_copy_data (&mdia->mdhd, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_hdlr_copy_data (&mdia->hdlr, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_minf_copy_data (&mdia->minf, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_elst_copy_data (AtomELST * elst, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GSList *walker;
+
+  if (!atom_full_copy_data (&elst->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (g_slist_length (elst->entries), buffer, size, offset);
+
+  for (walker = elst->entries; walker != NULL; walker = g_slist_next (walker)) {
+    EditListEntry *entry = (EditListEntry *) walker->data;
+    prop_copy_uint32 (entry->duration, buffer, size, offset);
+    prop_copy_uint32 (entry->media_time, buffer, size, offset);
+    prop_copy_uint32 (entry->media_rate, buffer, size, offset);
+  }
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_edts_copy_data (AtomEDTS * edts, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&(edts->header), buffer, size, offset))
+    return 0;
+
+  if (!atom_elst_copy_data (&(edts->elst), buffer, size, offset))
+    return 0;
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_trak_copy_data (AtomTRAK * trak, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&trak->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_tkhd_copy_data (&trak->tkhd, buffer, size, offset)) {
+    return 0;
+  }
+  if (trak->edts) {
+    if (!atom_edts_copy_data (trak->edts, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  if (!atom_mdia_copy_data (&trak->mdia, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_tag_data_copy_data (AtomTagData * data, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&data->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (data->reserved, buffer, size, offset);
+  prop_copy_uint8_array (data->data, data->datalen, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_tag_copy_data (AtomTag * tag, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&tag->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_tag_data_copy_data (&tag->data, buffer, size, offset)) {
+    return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_ilst_copy_data (AtomILST * ilst, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&ilst->header, buffer, size, offset)) {
+    return 0;
+  }
+  /* extra atoms */
+  if (ilst->entries &&
+      !atom_info_list_copy_data (ilst->entries, buffer, size, offset))
+    return 0;
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_meta_copy_data (AtomMETA * meta, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&meta->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_hdlr_copy_data (&meta->hdlr, buffer, size, offset)) {
+    return 0;
+  }
+  if (meta->ilst) {
+    if (!atom_ilst_copy_data (meta->ilst, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_udta_copy_data (AtomUDTA * udta, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&udta->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (udta->meta) {
+    if (!atom_meta_copy_data (udta->meta, buffer, size, offset)) {
+      return 0;
+    }
+  }
+  if (udta->entries) {
+    /* extra atoms */
+    if (!atom_info_list_copy_data (udta->entries, buffer, size, offset))
+      return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mehd_copy_data (AtomMEHD * mehd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&mehd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint64 (mehd->fragment_duration, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_trex_copy_data (AtomTREX * trex, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&trex->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (trex->track_ID, buffer, size, offset);
+  prop_copy_uint32 (trex->default_sample_description_index, buffer, size,
+      offset);
+  prop_copy_uint32 (trex->default_sample_duration, buffer, size, offset);
+  prop_copy_uint32 (trex->default_sample_size, buffer, size, offset);
+  prop_copy_uint32 (trex->default_sample_flags, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mvex_copy_data (AtomMVEX * mvex, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_copy_data (&mvex->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  if (!atom_mehd_copy_data (&mvex->mehd, buffer, size, offset)) {
+    return 0;
+  }
+
+  walker = g_list_first (mvex->trexs);
+  while (walker != NULL) {
+    if (!atom_trex_copy_data ((AtomTREX *) walker->data, buffer, size, offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+guint64
+atom_moov_copy_data (AtomMOOV * atom, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_copy_data (&(atom->header), buffer, size, offset))
+    return 0;
+
+  if (!atom_mvhd_copy_data (&(atom->mvhd), buffer, size, offset))
+    return 0;
+
+  walker = g_list_first (atom->traks);
+  while (walker != NULL) {
+    if (!atom_trak_copy_data ((AtomTRAK *) walker->data, buffer, size, offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  if (atom->udta) {
+    if (!atom_udta_copy_data (atom->udta, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  if (atom->fragmented) {
+    if (!atom_mvex_copy_data (&atom->mvex, buffer, size, offset)) {
+      return 0;
+    }
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_wave_copy_data (AtomWAVE * wave, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_copy_data (&(wave->header), buffer, size, offset))
+    return 0;
+
+  if (wave->extension_atoms) {
+    if (!atom_info_list_copy_data (wave->extension_atoms, buffer, size, offset))
+      return 0;
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+/* -- end of copy data functions -- */
+
+/* -- general functions, API and support functions */
+
+/* add samples to tables */
+
+static void
+atom_stsc_add_new_entry (AtomSTSC * stsc, guint32 first_chunk, guint32 nsamples)
+{
+  STSCEntry nentry;
+  gint len;
+
+  if ((len = atom_array_get_len (&stsc->entries)) &&
+      ((atom_array_index (&stsc->entries, len - 1)).samples_per_chunk ==
+          nsamples))
+    return;
+
+  nentry.first_chunk = first_chunk;
+  nentry.samples_per_chunk = nsamples;
+  nentry.sample_description_index = 1;
+  atom_array_append (&stsc->entries, nentry, 128);
+}
+
+static void
+atom_stts_add_entry (AtomSTTS * stts, guint32 sample_count, gint32 sample_delta)
+{
+  STTSEntry *entry = NULL;
+
+  if (G_LIKELY (atom_array_get_len (&stts->entries) != 0))
+    entry = &atom_array_index (&stts->entries,
+        atom_array_get_len (&stts->entries) - 1);
+
+  if (entry && entry->sample_delta == sample_delta) {
+    entry->sample_count += sample_count;
+  } else {
+    STTSEntry nentry;
+
+    nentry.sample_count = sample_count;
+    nentry.sample_delta = sample_delta;
+    atom_array_append (&stts->entries, nentry, 256);
+  }
+}
+
+static void
+atom_stsz_add_entry (AtomSTSZ * stsz, guint32 nsamples, guint32 size)
+{
+  guint32 i;
+
+  stsz->table_size += nsamples;
+  if (stsz->sample_size != 0) {
+    /* it is constant size, we don't need entries */
+    return;
+  }
+  for (i = 0; i < nsamples; i++) {
+    atom_array_append (&stsz->entries, size, 1024);
+  }
+}
+
+static guint32
+atom_stco64_get_entry_count (AtomSTCO64 * stco64)
+{
+  return atom_array_get_len (&stco64->entries);
+}
+
+static void
+atom_stco64_add_entry (AtomSTCO64 * stco64, guint64 entry)
+{
+  atom_array_append (&stco64->entries, entry, 256);
+  if (entry > G_MAXUINT32)
+    stco64->header.header.type = FOURCC_co64;
+}
+
+static void
+atom_stss_add_entry (AtomSTSS * stss, guint32 sample)
+{
+  atom_array_append (&stss->entries, sample, 512);
+}
+
+static void
+atom_stbl_add_stss_entry (AtomSTBL * stbl)
+{
+  guint32 sample_index = stbl->stsz.table_size;
+
+  atom_stss_add_entry (&stbl->stss, sample_index);
+}
+
+static void
+atom_ctts_add_entry (AtomCTTS * ctts, guint32 nsamples, guint32 offset)
+{
+  CTTSEntry *entry = NULL;
+
+  if (G_LIKELY (atom_array_get_len (&ctts->entries) != 0))
+    entry = &atom_array_index (&ctts->entries,
+        atom_array_get_len (&ctts->entries) - 1);
+
+  if (entry == NULL || entry->sampleoffset != offset) {
+    CTTSEntry nentry;
+
+    nentry.samplecount = nsamples;
+    nentry.sampleoffset = offset;
+    atom_array_append (&ctts->entries, nentry, 256);
+    if (offset != 0)
+      ctts->do_pts = TRUE;
+  } else {
+    entry->samplecount += nsamples;
+  }
+}
+
+static void
+atom_stbl_add_ctts_entry (AtomSTBL * stbl, guint32 nsamples, guint32 offset)
+{
+  if (stbl->ctts == NULL) {
+    stbl->ctts = atom_ctts_new ();
+  }
+  atom_ctts_add_entry (stbl->ctts, nsamples, offset);
+}
+
+void
+atom_stbl_add_samples (AtomSTBL * stbl, guint32 nsamples, guint32 delta,
+    guint32 size, guint64 chunk_offset, gboolean sync, gint64 pts_offset)
+{
+  atom_stts_add_entry (&stbl->stts, nsamples, delta);
+  atom_stsz_add_entry (&stbl->stsz, nsamples, size);
+  atom_stco64_add_entry (&stbl->stco64, chunk_offset);
+  atom_stsc_add_new_entry (&stbl->stsc,
+      atom_stco64_get_entry_count (&stbl->stco64), nsamples);
+  if (sync)
+    atom_stbl_add_stss_entry (stbl);
+  /* always store to arrange for consistent content */
+  atom_stbl_add_ctts_entry (stbl, nsamples, pts_offset);
+}
+
+void
+atom_trak_add_samples (AtomTRAK * trak, guint32 nsamples, guint32 delta,
+    guint32 size, guint64 chunk_offset, gboolean sync, gint64 pts_offset)
+{
+  AtomSTBL *stbl = &trak->mdia.minf.stbl;
+  atom_stbl_add_samples (stbl, nsamples, delta, size, chunk_offset, sync,
+      pts_offset);
+}
+
+/* trak and moov molding */
+
+guint32
+atom_trak_get_timescale (AtomTRAK * trak)
+{
+  return trak->mdia.mdhd.time_info.timescale;
+}
+
+guint32
+atom_trak_get_id (AtomTRAK * trak)
+{
+  return trak->tkhd.track_ID;
+}
+
+static void
+atom_trak_set_id (AtomTRAK * trak, guint32 id)
+{
+  trak->tkhd.track_ID = id;
+}
+
+static void
+atom_moov_add_trex (AtomMOOV * moov, AtomTREX * trex)
+{
+  moov->mvex.trexs = g_list_append (moov->mvex.trexs, trex);
+}
+
+static AtomTREX *
+atom_trex_new (AtomTRAK * trak)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+  AtomTREX *trex = g_new0 (AtomTREX, 1);
+
+  atom_full_init (&trex->header, FOURCC_trex, 0, 0, 0, flags);
+
+  trex->track_ID = trak->tkhd.track_ID;
+  trex->default_sample_description_index = 1;
+  trex->default_sample_duration = 0;
+  trex->default_sample_size = 0;
+  trex->default_sample_flags = 0;
+
+  return trex;
+}
+
+void
+atom_moov_add_trak (AtomMOOV * moov, AtomTRAK * trak)
+{
+  atom_trak_set_id (trak, moov->mvhd.next_track_id++);
+  moov->traks = g_list_append (moov->traks, trak);
+  /* additional trak means also new trex */
+  atom_moov_add_trex (moov, atom_trex_new (trak));
+}
+
+static guint64
+atom_trak_get_duration (AtomTRAK * trak)
+{
+  return trak->tkhd.duration;
+}
+
+static guint64
+atom_stts_get_total_duration (AtomSTTS * stts)
+{
+  guint i;
+  guint64 sum = 0;
+
+  for (i = 0; i < atom_array_get_len (&stts->entries); i++) {
+    STTSEntry *entry = &atom_array_index (&stts->entries, i);
+
+    sum += (guint64) (entry->sample_count) * entry->sample_delta;
+  }
+  return sum;
+}
+
+static void
+atom_trak_update_duration (AtomTRAK * trak, guint64 moov_timescale)
+{
+  trak->mdia.mdhd.time_info.duration =
+      atom_stts_get_total_duration (&trak->mdia.minf.stbl.stts);
+  if (trak->mdia.mdhd.time_info.timescale != 0) {
+    trak->tkhd.duration =
+        gst_util_uint64_scale (trak->mdia.mdhd.time_info.duration,
+        moov_timescale, trak->mdia.mdhd.time_info.timescale);
+  } else {
+    trak->tkhd.duration = 0;
+  }
+}
+
+static guint32
+atom_moov_get_timescale (AtomMOOV * moov)
+{
+  return moov->mvhd.time_info.timescale;
+}
+
+void
+atom_moov_update_timescale (AtomMOOV * moov, guint32 timescale)
+{
+  moov->mvhd.time_info.timescale = timescale;
+}
+
+void
+atom_moov_update_duration (AtomMOOV * moov)
+{
+  GList *traks = moov->traks;
+  guint64 dur, duration = 0;
+
+  while (traks) {
+    AtomTRAK *trak = (AtomTRAK *) traks->data;
+
+    atom_trak_update_duration (trak, atom_moov_get_timescale (moov));
+    dur = atom_trak_get_duration (trak);
+    if (dur > duration)
+      duration = dur;
+    traks = g_list_next (traks);
+  }
+  moov->mvhd.time_info.duration = duration;
+  moov->mvex.mehd.fragment_duration = duration;
+}
+
+void
+atom_moov_set_fragmented (AtomMOOV * moov, gboolean fragmented)
+{
+  moov->fragmented = fragmented;
+}
+
+void
+atom_stco64_chunks_add_offset (AtomSTCO64 * stco64, guint32 offset)
+{
+  guint i;
+
+  for (i = 0; i < atom_array_get_len (&stco64->entries); i++) {
+    guint64 *value = &atom_array_index (&stco64->entries, i);
+
+    *value += offset;
+  }
+}
+
+void
+atom_moov_chunks_add_offset (AtomMOOV * moov, guint32 offset)
+{
+  GList *traks = moov->traks;
+
+  while (traks) {
+    AtomTRAK *trak = (AtomTRAK *) traks->data;
+
+    atom_stco64_chunks_add_offset (&trak->mdia.minf.stbl.stco64, offset);
+    traks = g_list_next (traks);
+  }
+}
+
+/*
+ * Meta tags functions
+ */
+static void
+atom_moov_init_metatags (AtomMOOV * moov, AtomsContext * context)
+{
+  if (!moov->udta) {
+    moov->udta = atom_udta_new ();
+  }
+  if (context->flavor != ATOMS_TREE_FLAVOR_3GP) {
+    if (!moov->udta->meta) {
+      moov->udta->meta = atom_meta_new ();
+    }
+    if (!moov->udta->meta->ilst) {
+      moov->udta->meta->ilst = atom_ilst_new ();
+    }
+  }
+}
+
+static void
+atom_tag_data_alloc_data (AtomTagData * data, guint size)
+{
+  if (data->data != NULL) {
+    g_free (data->data);
+  }
+  data->data = g_new0 (guint8, size);
+  data->datalen = size;
+}
+
+static void
+atom_moov_append_tag (AtomMOOV * moov, AtomInfo * tag)
+{
+  GList **entries;
+
+  atom_moov_init_metatags (moov, &moov->context);
+  if (moov->udta->meta)
+    entries = &moov->udta->meta->ilst->entries;
+  else
+    entries = &moov->udta->entries;
+  *entries = g_list_append (*entries, tag);
+}
+
+void
+atom_moov_add_tag (AtomMOOV * moov, guint32 fourcc, guint32 flags,
+    const guint8 * data, guint size)
+{
+  AtomTag *tag;
+  AtomTagData *tdata;
+
+  tag = atom_tag_new (fourcc, flags);
+  tdata = &tag->data;
+  atom_tag_data_alloc_data (tdata, size);
+  g_memmove (tdata->data, data, size);
+
+  atom_moov_append_tag (moov,
+      build_atom_info_wrapper ((Atom *) tag, atom_tag_copy_data,
+          atom_tag_free));
+}
+
+void
+atom_moov_add_str_tag (AtomMOOV * moov, guint32 fourcc, const gchar * value)
+{
+  gint len = strlen (value);
+
+  if (len > 0)
+    atom_moov_add_tag (moov, fourcc, METADATA_TEXT_FLAG, (guint8 *) value, len);
+}
+
+void
+atom_moov_add_uint_tag (AtomMOOV * moov, guint32 fourcc, guint32 flags,
+    guint32 value)
+{
+  guint8 data[8] = { 0, };
+
+  if (flags) {
+    GST_WRITE_UINT16_BE (data, value);
+    atom_moov_add_tag (moov, fourcc, flags, data, 2);
+  } else {
+    GST_WRITE_UINT32_BE (data + 2, value);
+    atom_moov_add_tag (moov, fourcc, flags, data, 8);
+  }
+}
+
+void
+atom_moov_add_blob_tag (AtomMOOV * moov, guint8 * data, guint size)
+{
+  AtomData *data_atom;
+  GstBuffer *buf;
+  guint len;
+  guint32 fourcc;
+
+  if (size < 8)
+    return;
+
+  /* blob is unparsed atom;
+   * extract size and fourcc, and wrap remainder in data atom */
+  len = GST_READ_UINT32_BE (data);
+  fourcc = GST_READ_UINT32_LE (data + 4);
+  if (len > size)
+    return;
+
+  buf = gst_buffer_new ();
+  GST_BUFFER_SIZE (buf) = len - 8;
+  GST_BUFFER_DATA (buf) = data + 8;
+
+  data_atom = atom_data_new_from_gst_buffer (fourcc, buf);
+  gst_buffer_unref (buf);
+
+  atom_moov_append_tag (moov,
+      build_atom_info_wrapper ((Atom *) data_atom, atom_data_copy_data,
+          atom_data_free));
+}
+
+void
+atom_moov_add_3gp_tag (AtomMOOV * moov, guint32 fourcc, guint8 * data,
+    guint size)
+{
+  AtomData *data_atom;
+  GstBuffer *buf;
+  guint8 *bdata;
+
+  /* need full atom */
+  buf = gst_buffer_new_and_alloc (size + 4);
+  bdata = GST_BUFFER_DATA (buf);
+  /* full atom: version and flags */
+  GST_WRITE_UINT32_BE (bdata, 0);
+  memcpy (bdata + 4, data, size);
+
+  data_atom = atom_data_new_from_gst_buffer (fourcc, buf);
+  gst_buffer_unref (buf);
+
+  atom_moov_append_tag (moov,
+      build_atom_info_wrapper ((Atom *) data_atom, atom_data_copy_data,
+          atom_data_free));
+}
+
+guint16
+language_code (const char *lang)
+{
+  g_return_val_if_fail (lang != NULL, 0);
+  g_return_val_if_fail (strlen (lang) == 3, 0);
+
+  return (((lang[0] - 0x60) & 0x1F) << 10) + (((lang[1] - 0x60) & 0x1F) << 5) +
+      ((lang[2] - 0x60) & 0x1F);
+}
+
+void
+atom_moov_add_3gp_str_int_tag (AtomMOOV * moov, guint32 fourcc,
+    const gchar * value, gint16 ivalue)
+{
+  gint len = 0, size = 0;
+  guint8 *data;
+
+  if (value) {
+    len = strlen (value);
+    size = len + 3;
+  }
+
+  if (ivalue >= 0)
+    size += 2;
+
+  data = g_malloc (size + 3);
+  /* language tag and null-terminated UTF-8 string */
+  if (value) {
+    GST_WRITE_UINT16_BE (data, language_code (GST_QT_MUX_DEFAULT_TAG_LANGUAGE));
+    /* include 0 terminator */
+    memcpy (data + 2, value, len + 1);
+  }
+  /* 16-bit unsigned int if standalone, otherwise 8-bit */
+  if (ivalue >= 0) {
+    if (size == 2)
+      GST_WRITE_UINT16_BE (data + size - 2, ivalue);
+    else {
+      GST_WRITE_UINT8 (data + size - 2, ivalue & 0xFF);
+      size--;
+    }
+  }
+
+  atom_moov_add_3gp_tag (moov, fourcc, data, size);
+  g_free (data);
+}
+
+void
+atom_moov_add_3gp_str_tag (AtomMOOV * moov, guint32 fourcc, const gchar * value)
+{
+  atom_moov_add_3gp_str_int_tag (moov, fourcc, value, -1);
+}
+
+void
+atom_moov_add_3gp_uint_tag (AtomMOOV * moov, guint32 fourcc, guint16 value)
+{
+  atom_moov_add_3gp_str_int_tag (moov, fourcc, NULL, value);
+}
+
+void
+atom_moov_add_xmp_tags (AtomMOOV * moov, GstBuffer * xmpbuffer)
+{
+  AtomData *data_atom = NULL;
+
+  if (moov->context.flavor == ATOMS_TREE_FLAVOR_MOV) {
+    if (xmpbuffer) {
+      data_atom = atom_data_new_from_gst_buffer (FOURCC_XMP_, xmpbuffer);
+      atom_moov_init_metatags (moov, &moov->context);
+      moov->udta->entries = g_list_append (moov->udta->entries,
+          build_atom_info_wrapper ((Atom *) data_atom, atom_data_copy_data,
+              atom_data_free));
+    }
+  } else {
+    GST_DEBUG ("Not adding xmp to moov atom, it is only used in 'mov' format");
+  }
+
+}
+
+/*
+ * Functions for specifying media types
+ */
+
+static void
+atom_minf_set_audio (AtomMINF * minf)
+{
+  atom_minf_clear_handlers (minf);
+  minf->smhd = atom_smhd_new ();
+}
+
+static void
+atom_minf_set_video (AtomMINF * minf, AtomsContext * context)
+{
+  atom_minf_clear_handlers (minf);
+  minf->vmhd = atom_vmhd_new (context);
+}
+
+static void
+atom_hdlr_set_type (AtomHDLR * hdlr, AtomsContext * context, guint32 comp_type,
+    guint32 hdlr_type)
+{
+  if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {
+    hdlr->component_type = comp_type;
+  }
+  hdlr->handler_type = hdlr_type;
+}
+
+static void
+atom_hdlr_set_name (AtomHDLR * hdlr, const char *name)
+{
+  if (hdlr->name)
+    g_free (hdlr->name);
+  hdlr->name = g_strdup (name);
+}
+
+static void
+atom_mdia_set_hdlr_type_audio (AtomMDIA * mdia, AtomsContext * context)
+{
+  atom_hdlr_set_type (&mdia->hdlr, context, FOURCC_mhlr, FOURCC_soun);
+  /* Some players (low-end hardware) check for this name, which is what
+   * QuickTime itself sets */
+  atom_hdlr_set_name (&mdia->hdlr, "SoundHandler");
+}
+
+static void
+atom_mdia_set_hdlr_type_video (AtomMDIA * mdia, AtomsContext * context)
+{
+  atom_hdlr_set_type (&mdia->hdlr, context, FOURCC_mhlr, FOURCC_vide);
+  /* Some players (low-end hardware) check for this name, which is what
+   * QuickTime itself sets */
+  atom_hdlr_set_name (&mdia->hdlr, "VideoHandler");
+}
+
+static void
+atom_mdia_set_audio (AtomMDIA * mdia, AtomsContext * context)
+{
+  atom_mdia_set_hdlr_type_audio (mdia, context);
+  atom_minf_set_audio (&mdia->minf);
+}
+
+static void
+atom_mdia_set_video (AtomMDIA * mdia, AtomsContext * context)
+{
+  atom_mdia_set_hdlr_type_video (mdia, context);
+  atom_minf_set_video (&mdia->minf, context);
+}
+
+static void
+atom_tkhd_set_audio (AtomTKHD * tkhd)
+{
+  tkhd->volume = 0x0100;
+  tkhd->width = tkhd->height = 0;
+}
+
+static void
+atom_tkhd_set_video (AtomTKHD * tkhd, AtomsContext * context, guint32 width,
+    guint32 height)
+{
+  tkhd->volume = 0;
+
+  /* qt and ISO base media do not contradict, and examples agree */
+  tkhd->width = width;
+  tkhd->height = height;
+}
+
+static void
+atom_edts_add_entry (AtomEDTS * edts, EditListEntry * entry)
+{
+  edts->elst.entries = g_slist_append (edts->elst.entries, entry);
+}
+
+/* 
+ * Adds a new entry to this trak edits list
+ * duration is in the moov's timescale
+ * media_time is the offset in the media time to start from (media's timescale)
+ * rate is a 32 bits fixed-point
+ */
+void
+atom_trak_add_elst_entry (AtomTRAK * trak, guint32 duration, guint32 media_time,
+    guint32 rate)
+{
+  EditListEntry *entry = g_new (EditListEntry, 1);
+
+  entry->duration = duration;
+  entry->media_time = media_time;
+  entry->media_rate = rate;
+
+  if (trak->edts == NULL) {
+    trak->edts = atom_edts_new ();
+  }
+  atom_edts_add_entry (trak->edts, entry);
+}
+
+/* re-negotiation is prevented at top-level, so only 1 entry expected.
+ * Quite some more care here and elsewhere may be needed to
+ * support several entries */
+static SampleTableEntryMP4A *
+atom_trak_add_audio_entry (AtomTRAK * trak, AtomsContext * context,
+    guint32 type)
+{
+  AtomSTSD *stsd = &trak->mdia.minf.stbl.stsd;
+  SampleTableEntryMP4A *mp4a = sample_entry_mp4a_new ();
+
+  mp4a->se.header.type = type;
+  mp4a->se.kind = AUDIO;
+  mp4a->compression_id = -1;
+  mp4a->se.data_reference_index = 1;
+
+  stsd->entries = g_list_prepend (stsd->entries, mp4a);
+  stsd->n_entries++;
+  return mp4a;
+}
+
+static SampleTableEntryMP4V *
+atom_trak_add_video_entry (AtomTRAK * trak, AtomsContext * context,
+    guint32 type)
+{
+  SampleTableEntryMP4V *mp4v = sample_entry_mp4v_new (context);
+  AtomSTSD *stsd = &trak->mdia.minf.stbl.stsd;
+
+  mp4v->se.header.type = type;
+  mp4v->se.kind = VIDEO;
+  mp4v->se.data_reference_index = 1;
+  mp4v->horizontal_resolution = 72 << 16;
+  mp4v->vertical_resolution = 72 << 16;
+  if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {
+    mp4v->spatial_quality = 512;
+    mp4v->temporal_quality = 512;
+  }
+
+  stsd->entries = g_list_prepend (stsd->entries, mp4v);
+  stsd->n_entries++;
+  return mp4v;
+}
+
+static void
+atom_trak_set_constant_size_samples (AtomTRAK * trak, guint32 sample_size)
+{
+  trak->mdia.minf.stbl.stsz.sample_size = sample_size;
+}
+
+static void
+atom_trak_set_audio (AtomTRAK * trak, AtomsContext * context)
+{
+  atom_tkhd_set_audio (&trak->tkhd);
+  atom_mdia_set_audio (&trak->mdia, context);
+}
+
+static void
+atom_trak_set_video (AtomTRAK * trak, AtomsContext * context, guint32 width,
+    guint32 height)
+{
+  atom_tkhd_set_video (&trak->tkhd, context, width, height);
+  atom_mdia_set_video (&trak->mdia, context);
+}
+
+static void
+atom_trak_set_audio_commons (AtomTRAK * trak, AtomsContext * context,
+    guint32 rate)
+{
+  atom_trak_set_audio (trak, context);
+  trak->mdia.mdhd.time_info.timescale = rate;
+}
+
+static void
+atom_trak_set_video_commons (AtomTRAK * trak, AtomsContext * context,
+    guint32 rate, guint32 width, guint32 height)
+{
+  atom_trak_set_video (trak, context, width, height);
+  trak->mdia.mdhd.time_info.timescale = rate;
+  trak->tkhd.width = width << 16;
+  trak->tkhd.height = height << 16;
+}
+
+void
+atom_trak_set_audio_type (AtomTRAK * trak, AtomsContext * context,
+    AudioSampleEntry * entry, guint32 scale, AtomInfo * ext, gint sample_size)
+{
+  SampleTableEntryMP4A *ste;
+
+  atom_trak_set_audio_commons (trak, context, scale);
+  atom_stsd_remove_entries (&trak->mdia.minf.stbl.stsd);
+  ste = atom_trak_add_audio_entry (trak, context, entry->fourcc);
+
+  trak->is_video = FALSE;
+  trak->is_h264 = FALSE;
+
+  ste->version = entry->version;
+  ste->compression_id = entry->compression_id;
+  ste->sample_size = entry->sample_size;
+  ste->sample_rate = entry->sample_rate << 16;
+  ste->channels = entry->channels;
+
+  ste->samples_per_packet = entry->samples_per_packet;
+  ste->bytes_per_sample = entry->bytes_per_sample;
+  ste->bytes_per_packet = entry->bytes_per_packet;
+  ste->bytes_per_frame = entry->bytes_per_frame;
+
+  if (ext)
+    ste->extension_atoms = g_list_prepend (ste->extension_atoms, ext);
+
+  /* 0 size means variable size */
+  atom_trak_set_constant_size_samples (trak, sample_size);
+}
+
+static AtomInfo *
+build_pasp_extension (AtomTRAK * trak, gint par_width, gint par_height)
+{
+  AtomData *atom_data;
+  GstBuffer *buf;
+  guint8 *data;
+
+  buf = gst_buffer_new_and_alloc (8);
+  data = GST_BUFFER_DATA (buf);
+
+  /* ihdr = image header box */
+  GST_WRITE_UINT32_BE (data, par_width);
+  GST_WRITE_UINT32_BE (data + 4, par_height);
+
+  atom_data = atom_data_new_from_gst_buffer (FOURCC_pasp, buf);
+  gst_buffer_unref (buf);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+void
+atom_trak_set_video_type (AtomTRAK * trak, AtomsContext * context,
+    VisualSampleEntry * entry, guint32 scale, GList * ext_atoms_list)
+{
+  SampleTableEntryMP4V *ste;
+  gint dwidth, dheight;
+  gint par_n = 0, par_d = 0;
+
+  if ((entry->par_n != 1 || entry->par_d != 1) &&
+      (entry->par_n != entry->par_d)) {
+    par_n = entry->par_n;
+    par_d = entry->par_d;
+  }
+
+  dwidth = entry->width;
+  dheight = entry->height;
+  /* ISO file spec says track header w/h indicates track's visual presentation
+   * (so this together with pixels w/h implicitly defines PAR) */
+  if (par_n && (context->flavor != ATOMS_TREE_FLAVOR_MOV)) {
+    if (par_n > par_d) {
+      dwidth = entry->width * par_n / par_d;
+      dheight = entry->height;
+    } else {
+      dwidth = entry->width * par_n / par_d;
+      dheight = entry->height;
+    }
+  }
+
+  atom_trak_set_video_commons (trak, context, scale, dwidth, dheight);
+  atom_stsd_remove_entries (&trak->mdia.minf.stbl.stsd);
+  ste = atom_trak_add_video_entry (trak, context, entry->fourcc);
+
+  trak->is_video = TRUE;
+  trak->is_h264 = (entry->fourcc == FOURCC_avc1);
+
+  ste->version = entry->version;
+  ste->width = entry->width;
+  ste->height = entry->height;
+  ste->depth = entry->depth;
+  ste->color_table_id = entry->color_table_id;
+  ste->frame_count = entry->frame_count;
+
+  if (ext_atoms_list)
+    ste->extension_atoms = g_list_concat (ste->extension_atoms, ext_atoms_list);
+
+  /* QT spec has a pasp extension atom in stsd that can hold PAR */
+  if (par_n && (context->flavor == ATOMS_TREE_FLAVOR_MOV)) {
+    ste->extension_atoms = g_list_append (ste->extension_atoms,
+        build_pasp_extension (trak, par_n, par_d));
+  }
+}
+
+static void
+atom_mfhd_init (AtomMFHD * mfhd, guint32 sequence_number)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&(mfhd->header), FOURCC_mfhd, 0, 0, 0, flags);
+  mfhd->sequence_number = sequence_number;
+}
+
+static void
+atom_moof_init (AtomMOOF * moof, AtomsContext * context,
+    guint32 sequence_number)
+{
+  atom_header_set (&moof->header, FOURCC_moof, 0, 0);
+  atom_mfhd_init (&moof->mfhd, sequence_number);
+  moof->trafs = NULL;
+}
+
+AtomMOOF *
+atom_moof_new (AtomsContext * context, guint32 sequence_number)
+{
+  AtomMOOF *moof = g_new0 (AtomMOOF, 1);
+
+  atom_moof_init (moof, context, sequence_number);
+  return moof;
+}
+
+static void
+atom_trun_free (AtomTRUN * trun)
+{
+  atom_full_clear (&trun->header);
+  atom_array_clear (&trun->entries);
+  g_free (trun);
+}
+
+static void
+atom_sdtp_free (AtomSDTP * sdtp)
+{
+  atom_full_clear (&sdtp->header);
+  atom_array_clear (&sdtp->entries);
+  g_free (sdtp);
+}
+
+void
+atom_traf_free (AtomTRAF * traf)
+{
+  GList *walker;
+
+  walker = traf->truns;
+  while (walker) {
+    atom_trun_free ((AtomTRUN *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (traf->truns);
+  traf->truns = NULL;
+
+  walker = traf->sdtps;
+  while (walker) {
+    atom_sdtp_free ((AtomSDTP *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (traf->sdtps);
+  traf->sdtps = NULL;
+
+  g_free (traf);
+}
+
+void
+atom_moof_free (AtomMOOF * moof)
+{
+  GList *walker;
+
+  walker = moof->trafs;
+  while (walker) {
+    atom_traf_free ((AtomTRAF *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (moof->trafs);
+  moof->trafs = NULL;
+
+  g_free (moof);
+}
+
+static guint64
+atom_mfhd_copy_data (AtomMFHD * mfhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&mfhd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (mfhd->sequence_number, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_tfhd_copy_data (AtomTFHD * tfhd, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint32 flags;
+
+  if (!atom_full_copy_data (&tfhd->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (tfhd->track_ID, buffer, size, offset);
+
+  flags = atom_full_get_flags_as_uint (&tfhd->header);
+
+  if (flags & TF_BASE_DATA_OFFSET)
+    prop_copy_uint64 (tfhd->base_data_offset, buffer, size, offset);
+  if (flags & TF_SAMPLE_DESCRIPTION_INDEX)
+    prop_copy_uint32 (tfhd->sample_description_index, buffer, size, offset);
+  if (flags & TF_DEFAULT_SAMPLE_DURATION)
+    prop_copy_uint32 (tfhd->default_sample_duration, buffer, size, offset);
+  if (flags & TF_DEFAULT_SAMPLE_SIZE)
+    prop_copy_uint32 (tfhd->default_sample_size, buffer, size, offset);
+  if (flags & TF_DEFAULT_SAMPLE_FLAGS)
+    prop_copy_uint32 (tfhd->default_sample_flags, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_trun_copy_data (AtomTRUN * trun, guint8 ** buffer, guint64 * size,
+    guint64 * offset, guint32 * data_offset)
+{
+  guint64 original_offset = *offset;
+  guint32 flags, i;
+
+  flags = atom_full_get_flags_as_uint (&trun->header);
+
+  /* if first trun in moof, forcibly add data_offset and record
+   * where it must be written later on */
+  if (data_offset && !*data_offset) {
+    flags |= TR_DATA_OFFSET;
+  } else {
+    flags &= ~TR_DATA_OFFSET;
+  }
+
+  atom_full_set_flags_as_uint (&trun->header, flags);
+
+  if (!atom_full_copy_data (&trun->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (trun->sample_count, buffer, size, offset);
+
+  if (flags & TR_DATA_OFFSET) {
+    *data_offset = *offset;
+    prop_copy_int32 (trun->data_offset, buffer, size, offset);
+  }
+  if (flags & TR_FIRST_SAMPLE_FLAGS)
+    prop_copy_uint32 (trun->first_sample_flags, buffer, size, offset);
+
+  for (i = 0; i < atom_array_get_len (&trun->entries); i++) {
+    TRUNSampleEntry *entry = &atom_array_index (&trun->entries, i);
+
+    if (flags & TR_SAMPLE_DURATION)
+      prop_copy_uint32 (entry->sample_duration, buffer, size, offset);
+    if (flags & TR_SAMPLE_SIZE)
+      prop_copy_uint32 (entry->sample_size, buffer, size, offset);
+    if (flags & TR_SAMPLE_FLAGS)
+      prop_copy_uint32 (entry->sample_flags, buffer, size, offset);
+    if (flags & TR_COMPOSITION_TIME_OFFSETS)
+      prop_copy_uint32 (entry->sample_composition_time_offset,
+          buffer, size, offset);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_sdtp_copy_data (AtomSDTP * sdtp, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!atom_full_copy_data (&sdtp->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  /* all entries at once */
+  prop_copy_fixed_size_string (&atom_array_index (&sdtp->entries, 0),
+      atom_array_get_len (&sdtp->entries), buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_traf_copy_data (AtomTRAF * traf, guint8 ** buffer, guint64 * size,
+    guint64 * offset, guint32 * data_offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_copy_data (&traf->header, buffer, size, offset)) {
+    return 0;
+  }
+  if (!atom_tfhd_copy_data (&traf->tfhd, buffer, size, offset)) {
+    return 0;
+  }
+
+  walker = g_list_first (traf->truns);
+  while (walker != NULL) {
+    if (!atom_trun_copy_data ((AtomTRUN *) walker->data, buffer, size, offset,
+            data_offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  walker = g_list_first (traf->sdtps);
+  while (walker != NULL) {
+    if (!atom_sdtp_copy_data ((AtomSDTP *) walker->data, buffer, size, offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+/* creates moof atom; metadata is written expecting actual buffer data
+ * is in mdata directly after moof, and is consecutively written per trak */
+guint64
+atom_moof_copy_data (AtomMOOF * moof, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+  guint32 data_offset = 0;
+
+  if (!atom_copy_data (&moof->header, buffer, size, offset))
+    return 0;
+
+  if (!atom_mfhd_copy_data (&moof->mfhd, buffer, size, offset))
+    return 0;
+
+  walker = g_list_first (moof->trafs);
+  while (walker != NULL) {
+    if (!atom_traf_copy_data ((AtomTRAF *) walker->data, buffer, size, offset,
+            &data_offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+
+  if (*buffer && data_offset) {
+    /* first trun needs a data-offset relative to moof start
+     *   = moof size + mdat prefix */
+    GST_WRITE_UINT32_BE (*buffer + data_offset, *offset - original_offset + 8);
+  }
+
+  return *offset - original_offset;
+}
+
+static void
+atom_tfhd_init (AtomTFHD * tfhd, guint32 track_ID)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&tfhd->header, FOURCC_tfhd, 0, 0, 0, flags);
+  tfhd->track_ID = track_ID;
+  tfhd->base_data_offset = 0;
+  tfhd->sample_description_index = 1;
+  tfhd->default_sample_duration = 0;
+  tfhd->default_sample_size = 0;
+  tfhd->default_sample_flags = 0;
+}
+
+static void
+atom_trun_init (AtomTRUN * trun)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&trun->header, FOURCC_trun, 0, 0, 0, flags);
+  trun->sample_count = 0;
+  trun->data_offset = 0;
+  trun->first_sample_flags = 0;
+  atom_array_init (&trun->entries, 512);
+}
+
+static AtomTRUN *
+atom_trun_new (void)
+{
+  AtomTRUN *trun = g_new0 (AtomTRUN, 1);
+
+  atom_trun_init (trun);
+  return trun;
+}
+
+static void
+atom_sdtp_init (AtomSDTP * sdtp)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&sdtp->header, FOURCC_sdtp, 0, 0, 0, flags);
+  atom_array_init (&sdtp->entries, 512);
+}
+
+static AtomSDTP *
+atom_sdtp_new (AtomsContext * context)
+{
+  AtomSDTP *sdtp = g_new0 (AtomSDTP, 1);
+
+  atom_sdtp_init (sdtp);
+  return sdtp;
+}
+
+static void
+atom_traf_add_sdtp (AtomTRAF * traf, AtomSDTP * sdtp)
+{
+  traf->sdtps = g_list_append (traf->sdtps, sdtp);
+}
+
+static void
+atom_sdtp_add_samples (AtomSDTP * sdtp, guint8 val)
+{
+  /* it does not make much/any sense according to specs,
+   * but that's how MS isml samples seem to do it */
+  atom_array_append (&sdtp->entries, val, 256);
+}
+
+static void
+atom_trun_add_samples (AtomTRUN * trun, guint32 delta, guint32 size,
+    guint32 flags, gint64 pts_offset)
+{
+  TRUNSampleEntry nentry;
+
+  if (pts_offset != 0)
+    trun->header.flags[1] |= TR_COMPOSITION_TIME_OFFSETS;
+
+  nentry.sample_duration = delta;
+  nentry.sample_size = size;
+  nentry.sample_flags = flags;
+  nentry.sample_composition_time_offset = pts_offset;
+  atom_array_append (&trun->entries, nentry, 256);
+  trun->sample_count++;
+}
+
+static void
+atom_traf_init (AtomTRAF * traf, AtomsContext * context, guint32 track_ID)
+{
+  atom_header_set (&traf->header, FOURCC_traf, 0, 0);
+  atom_tfhd_init (&traf->tfhd, track_ID);
+  traf->truns = NULL;
+
+  if (context->flavor == ATOMS_TREE_FLAVOR_ISML)
+    atom_traf_add_sdtp (traf, atom_sdtp_new (context));
+}
+
+AtomTRAF *
+atom_traf_new (AtomsContext * context, guint32 track_ID)
+{
+  AtomTRAF *traf = g_new0 (AtomTRAF, 1);
+
+  atom_traf_init (traf, context, track_ID);
+  return traf;
+}
+
+static void
+atom_traf_add_trun (AtomTRAF * traf, AtomTRUN * trun)
+{
+  traf->truns = g_list_append (traf->truns, trun);
+}
+
+void
+atom_traf_add_samples (AtomTRAF * traf, guint32 delta, guint32 size,
+    gboolean sync, gint64 pts_offset, gboolean sdtp_sync)
+{
+  AtomTRUN *trun;
+  guint32 flags;
+
+  /* 0x10000 is sample-is-difference-sample flag
+   * low byte stuff is what ismv uses */
+  flags = (sync ? 0x0 : 0x10000) | (sdtp_sync ? 0x40 : 0xc0);
+
+  if (G_UNLIKELY (!traf->truns)) {
+    trun = atom_trun_new ();
+    atom_traf_add_trun (traf, trun);
+    /* optimistic; indicate all defaults present in tfhd */
+    traf->tfhd.header.flags[2] = TF_DEFAULT_SAMPLE_DURATION |
+        TF_DEFAULT_SAMPLE_SIZE | TF_DEFAULT_SAMPLE_FLAGS;
+    traf->tfhd.default_sample_duration = delta;
+    traf->tfhd.default_sample_size = size;
+    traf->tfhd.default_sample_flags = flags;
+    trun->first_sample_flags = flags;
+  }
+
+  trun = traf->truns->data;
+
+  /* check if still matching defaults,
+   * if not, abandon default and need entry for each sample */
+  if (traf->tfhd.default_sample_duration != delta) {
+    traf->tfhd.header.flags[2] &= ~TF_DEFAULT_SAMPLE_DURATION;
+    trun->header.flags[1] |= (TR_SAMPLE_DURATION >> 8);
+  }
+  if (traf->tfhd.default_sample_size != size) {
+    traf->tfhd.header.flags[2] &= ~TF_DEFAULT_SAMPLE_SIZE;
+    trun->header.flags[1] |= (TR_SAMPLE_SIZE >> 8);
+  }
+  if (traf->tfhd.default_sample_flags != flags) {
+    if (trun->sample_count == 1) {
+      /* at least will need first sample flag */
+      traf->tfhd.default_sample_flags = flags;
+      trun->header.flags[2] |= TR_FIRST_SAMPLE_FLAGS;
+    } else {
+      /* now we need sample flags for each sample */
+      traf->tfhd.header.flags[2] &= ~TF_DEFAULT_SAMPLE_FLAGS;
+      trun->header.flags[1] |= (TR_SAMPLE_FLAGS >> 8);
+      trun->header.flags[2] &= ~TR_FIRST_SAMPLE_FLAGS;
+    }
+  }
+
+  atom_trun_add_samples (traf->truns->data, delta, size, flags, pts_offset);
+
+  if (traf->sdtps)
+    atom_sdtp_add_samples (traf->sdtps->data, 0x10 | ((flags & 0xff) >> 4));
+}
+
+guint32
+atom_traf_get_sample_num (AtomTRAF * traf)
+{
+  AtomTRUN *trun;
+
+  if (G_UNLIKELY (!traf->truns))
+    return 0;
+
+  trun = traf->truns->data;
+  return atom_array_get_len (&trun->entries);
+}
+
+void
+atom_moof_add_traf (AtomMOOF * moof, AtomTRAF * traf)
+{
+  moof->trafs = g_list_append (moof->trafs, traf);
+}
+
+static void
+atom_tfra_free (AtomTFRA * tfra)
+{
+  atom_full_clear (&tfra->header);
+  atom_array_clear (&tfra->entries);
+  g_free (tfra);
+}
+
+AtomMFRA *
+atom_mfra_new (AtomsContext * context)
+{
+  AtomMFRA *mfra = g_new0 (AtomMFRA, 1);
+
+  atom_header_set (&mfra->header, FOURCC_mfra, 0, 0);
+  return mfra;
+}
+
+void
+atom_mfra_add_tfra (AtomMFRA * mfra, AtomTFRA * tfra)
+{
+  mfra->tfras = g_list_append (mfra->tfras, tfra);
+}
+
+void
+atom_mfra_free (AtomMFRA * mfra)
+{
+  GList *walker;
+
+  walker = mfra->tfras;
+  while (walker) {
+    atom_tfra_free ((AtomTFRA *) walker->data);
+    walker = g_list_next (walker);
+  }
+  g_list_free (mfra->tfras);
+  mfra->tfras = NULL;
+
+  atom_clear (&mfra->header);
+  g_free (mfra);
+}
+
+static void
+atom_tfra_init (AtomTFRA * tfra, guint32 track_ID)
+{
+  guint8 flags[3] = { 0, 0, 0 };
+
+  atom_full_init (&tfra->header, FOURCC_tfra, 0, 0, 0, flags);
+  tfra->track_ID = track_ID;
+  atom_array_init (&tfra->entries, 512);
+}
+
+AtomTFRA *
+atom_tfra_new (AtomsContext * context, guint32 track_ID)
+{
+  AtomTFRA *tfra = g_new0 (AtomTFRA, 1);
+
+  atom_tfra_init (tfra, track_ID);
+  return tfra;
+
+}
+
+static inline gint
+need_bytes (guint32 num)
+{
+  gint n = 0;
+
+  while (num >>= 8)
+    n++;
+
+  return n;
+}
+
+void
+atom_tfra_add_entry (AtomTFRA * tfra, guint64 dts, guint32 sample_num)
+{
+  TFRAEntry entry;
+
+  entry.time = dts;
+  /* fill in later */
+  entry.moof_offset = 0;
+  /* always write a single trun in a single traf */
+  entry.traf_number = 1;
+  entry.trun_number = 1;
+  entry.sample_number = sample_num;
+
+  /* auto-use 64 bits if needed */
+  if (dts > G_MAXUINT32)
+    tfra->header.version = 1;
+
+  /* 1 byte will always do for traf and trun number,
+   * check how much sample_num needs */
+  tfra->lengths = (tfra->lengths & 0xfc) ||
+      MAX (tfra->lengths, need_bytes (sample_num));
+
+  atom_array_append (&tfra->entries, entry, 256);
+}
+
+void
+atom_tfra_update_offset (AtomTFRA * tfra, guint64 offset)
+{
+  gint i;
+
+  /* auto-use 64 bits if needed */
+  if (offset > G_MAXUINT32)
+    tfra->header.version = 1;
+
+  for (i = atom_array_get_len (&tfra->entries) - 1; i >= 0; i--) {
+    TFRAEntry *entry = &atom_array_index (&tfra->entries, i);
+
+    if (entry->moof_offset)
+      break;
+    entry->moof_offset = offset;
+  }
+}
+
+static guint64
+atom_tfra_copy_data (AtomTFRA * tfra, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint32 i;
+  TFRAEntry *entry;
+  guint32 data;
+  guint bytes;
+  guint version;
+
+  if (!atom_full_copy_data (&tfra->header, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (tfra->track_ID, buffer, size, offset);
+  prop_copy_uint32 (tfra->lengths, buffer, size, offset);
+  prop_copy_uint32 (atom_array_get_len (&tfra->entries), buffer, size, offset);
+
+  version = tfra->header.version;
+  for (i = 0; i < atom_array_get_len (&tfra->entries); ++i) {
+    entry = &atom_array_index (&tfra->entries, i);
+    if (version) {
+      prop_copy_uint64 (entry->time, buffer, size, offset);
+      prop_copy_uint64 (entry->moof_offset, buffer, size, offset);
+    } else {
+      prop_copy_uint32 (entry->time, buffer, size, offset);
+      prop_copy_uint32 (entry->moof_offset, buffer, size, offset);
+    }
+
+    bytes = (tfra->lengths & (0x3 << 4)) + 1;
+    data = GUINT32_TO_BE (entry->traf_number);
+    prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+        buffer, size, offset);
+
+    bytes = (tfra->lengths & (0x3 << 2)) + 1;
+    data = GUINT32_TO_BE (entry->trun_number);
+    prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+        buffer, size, offset);
+
+    bytes = (tfra->lengths & (0x3)) + 1;
+    data = GUINT32_TO_BE (entry->sample_number);
+    prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+        buffer, size, offset);
+
+  }
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+static guint64
+atom_mfro_copy_data (guint32 s, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint8 flags[3] = { 0, 0, 0 };
+  AtomFull mfro;
+
+  atom_full_init (&mfro, FOURCC_mfro, 0, 0, 0, flags);
+
+  if (!atom_full_copy_data (&mfro, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint32 (s, buffer, size, offset);
+
+  atom_write_size (buffer, size, offset, original_offset);
+
+  return *offset - original_offset;
+}
+
+
+guint64
+atom_mfra_copy_data (AtomMFRA * mfra, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  GList *walker;
+
+  if (!atom_copy_data (&mfra->header, buffer, size, offset))
+    return 0;
+
+  walker = g_list_first (mfra->tfras);
+  while (walker != NULL) {
+    if (!atom_tfra_copy_data ((AtomTFRA *) walker->data, buffer, size, offset)) {
+      return 0;
+    }
+    walker = g_list_next (walker);
+  }
+
+  /* 16 is the size of the mfro atom */
+  if (!atom_mfro_copy_data (*offset - original_offset + 16, buffer,
+          size, offset))
+    return 0;
+
+  atom_write_size (buffer, size, offset, original_offset);
+  return *offset - original_offset;
+}
+
+/* some sample description construction helpers */
+
+AtomInfo *
+build_esds_extension (AtomTRAK * trak, guint8 object_type, guint8 stream_type,
+    const GstBuffer * codec_data, guint32 avg_bitrate, guint32 max_bitrate)
+{
+  guint32 track_id;
+  AtomESDS *esds;
+
+  track_id = trak->tkhd.track_ID;
+
+  esds = atom_esds_new ();
+  esds->es.id = track_id & 0xFFFF;
+  esds->es.dec_conf_desc.object_type = object_type;
+  esds->es.dec_conf_desc.stream_type = stream_type << 2 | 0x01;
+
+  if (avg_bitrate > 0)
+    esds->es.dec_conf_desc.avg_bitrate = avg_bitrate;
+  if (max_bitrate > 0)
+    esds->es.dec_conf_desc.max_bitrate = max_bitrate;
+
+  /* optional DecoderSpecificInfo */
+  if (codec_data) {
+    DecoderSpecificInfoDescriptor *desc;
+
+    esds->es.dec_conf_desc.dec_specific_info = desc =
+        desc_dec_specific_info_new ();
+    desc_dec_specific_info_alloc_data (desc, GST_BUFFER_SIZE (codec_data));
+
+    memcpy (desc->data, GST_BUFFER_DATA (codec_data),
+        GST_BUFFER_SIZE (codec_data));
+  }
+
+  return build_atom_info_wrapper ((Atom *) esds, atom_esds_copy_data,
+      atom_esds_free);
+}
+
+AtomInfo *
+build_btrt_extension (guint32 buffer_size_db, guint32 avg_bitrate,
+    guint32 max_bitrate)
+{
+  AtomData *atom_data;
+  GstBuffer *buf;
+
+  if (buffer_size_db == 0 && avg_bitrate == 0 && max_bitrate == 0)
+    return 0;
+
+  buf = gst_buffer_new_and_alloc (12);
+
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), buffer_size_db);
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf) + 4, max_bitrate);
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf) + 8, avg_bitrate);
+
+  atom_data =
+      atom_data_new_from_gst_buffer (GST_MAKE_FOURCC ('b', 't', 'r', 't'), buf);
+  gst_buffer_unref (buf);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+static AtomInfo *
+build_mov_wave_extension (AtomTRAK * trak, guint32 fourcc, AtomInfo * atom1,
+    AtomInfo * atom2, gboolean terminator)
+{
+  AtomWAVE *wave;
+  AtomFRMA *frma;
+  Atom *ext_atom;
+
+  /* Build WAVE atom for sample table entry */
+  wave = atom_wave_new ();
+
+  /* Prepend Terminator atom to the WAVE list first, so it ends up last */
+  if (terminator) {
+    ext_atom = (Atom *) atom_data_new (FOURCC_null);
+    wave->extension_atoms =
+        atom_info_list_prepend_atom (wave->extension_atoms, (Atom *) ext_atom,
+        (AtomCopyDataFunc) atom_data_copy_data, (AtomFreeFunc) atom_data_free);
+  }
+
+  /* Add supplied atoms to WAVE */
+  if (atom2)
+    wave->extension_atoms = g_list_prepend (wave->extension_atoms, atom2);
+  if (atom1)
+    wave->extension_atoms = g_list_prepend (wave->extension_atoms, atom1);
+
+  /* Add FRMA to the WAVE */
+  frma = atom_frma_new ();
+  frma->media_type = fourcc;
+
+  wave->extension_atoms =
+      atom_info_list_prepend_atom (wave->extension_atoms, (Atom *) frma,
+      (AtomCopyDataFunc) atom_frma_copy_data, (AtomFreeFunc) atom_frma_free);
+
+  return build_atom_info_wrapper ((Atom *) wave, atom_wave_copy_data,
+      atom_wave_free);
+}
+
+AtomInfo *
+build_mov_aac_extension (AtomTRAK * trak, const GstBuffer * codec_data,
+    guint32 avg_bitrate, guint32 max_bitrate)
+{
+  AtomInfo *esds, *mp4a;
+  GstBuffer *buf;
+
+  /* Add ESDS atom to WAVE */
+  esds = build_esds_extension (trak, ESDS_OBJECT_TYPE_MPEG4_P3,
+      ESDS_STREAM_TYPE_AUDIO, codec_data, avg_bitrate, max_bitrate);
+
+  /* Add MP4A atom to the WAVE:
+   * not really in spec, but makes offset based players happy */
+  buf = gst_buffer_new_and_alloc (4);
+  *((guint32 *) GST_BUFFER_DATA (buf)) = 0;
+  mp4a = build_codec_data_extension (FOURCC_mp4a, buf);
+  gst_buffer_unref (buf);
+
+  return build_mov_wave_extension (trak, FOURCC_mp4a, mp4a, esds, TRUE);
+}
+
+AtomInfo *
+build_mov_alac_extension (AtomTRAK * trak, const GstBuffer * codec_data)
+{
+  AtomInfo *alac;
+
+  alac = build_codec_data_extension (FOURCC_alac, codec_data);
+
+  return build_mov_wave_extension (trak, FOURCC_alac, NULL, alac, TRUE);
+}
+
+AtomInfo *
+build_fiel_extension (gint fields)
+{
+  AtomData *atom_data;
+  GstBuffer *buf;
+
+  if (fields == 1) {
+    return NULL;
+  }
+
+  buf = gst_buffer_new_and_alloc (1);
+  GST_BUFFER_DATA (buf)[0] = (guint8) fields;
+
+  atom_data =
+      atom_data_new_from_gst_buffer (GST_MAKE_FOURCC ('f', 'i', 'e', 'l'), buf);
+  gst_buffer_unref (buf);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+AtomInfo *
+build_jp2x_extension (const GstBuffer * prefix)
+{
+  AtomData *atom_data;
+
+  if (!prefix) {
+    return NULL;
+  }
+
+  atom_data =
+      atom_data_new_from_gst_buffer (GST_MAKE_FOURCC ('j', 'p', '2', 'x'),
+      prefix);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+AtomInfo *
+build_jp2h_extension (AtomTRAK * trak, gint width, gint height, guint32 fourcc,
+    gint ncomp, const GValue * cmap_array, const GValue * cdef_array)
+{
+  AtomData *atom_data;
+  GstBuffer *buf;
+  guint8 cenum;
+  gint i;
+  gint idhr_size = 22;
+  gint colr_size = 15;
+  gint cmap_size = 0, cdef_size = 0;
+  gint cmap_array_size = 0;
+  gint cdef_array_size = 0;
+  GstByteWriter writer;
+
+  g_return_val_if_fail (cmap_array == NULL ||
+      GST_VALUE_HOLDS_ARRAY (cmap_array), NULL);
+  g_return_val_if_fail (cdef_array == NULL ||
+      GST_VALUE_HOLDS_ARRAY (cdef_array), NULL);
+
+  if (fourcc == GST_MAKE_FOURCC ('s', 'R', 'G', 'B')) {
+    cenum = 0x10;
+    if (ncomp == 0)
+      ncomp = 3;
+  } else if (fourcc == GST_MAKE_FOURCC ('G', 'R', 'A', 'Y')) {
+    cenum = 0x11;
+    if (ncomp == 0)
+      ncomp = 1;
+  } else if (fourcc == GST_MAKE_FOURCC ('s', 'Y', 'U', 'V')) {
+    cenum = 0x12;
+    if (ncomp == 0)
+      ncomp = 3;
+  } else
+    return NULL;
+
+  if (cmap_array) {
+    cmap_array_size = gst_value_array_get_size (cmap_array);
+    cmap_size = 8 + cmap_array_size * 4;
+  }
+  if (cdef_array) {
+    cdef_array_size = gst_value_array_get_size (cdef_array);
+    cdef_size = 8 + 2 + cdef_array_size * 6;
+  }
+
+  buf = gst_buffer_new_and_alloc (idhr_size + colr_size + cmap_size +
+      cdef_size);
+  gst_byte_writer_init_with_buffer (&writer, buf, FALSE);
+
+  /* ihdr = image header box */
+  gst_byte_writer_put_uint32_be (&writer, 22);
+  gst_byte_writer_put_uint32_le (&writer, GST_MAKE_FOURCC ('i', 'h', 'd', 'r'));
+  gst_byte_writer_put_uint32_be (&writer, height);
+  gst_byte_writer_put_uint32_be (&writer, width);
+  gst_byte_writer_put_uint16_be (&writer, ncomp);
+  /* 8 bits per component, unsigned */
+  gst_byte_writer_put_uint8 (&writer, 0x7);
+  /* compression type; reserved */
+  gst_byte_writer_put_uint8 (&writer, 0x7);
+  /* colour space (un)known */
+  gst_byte_writer_put_uint8 (&writer, 0x0);
+  /* intellectual property right (box present) */
+  gst_byte_writer_put_uint8 (&writer, 0x0);
+
+  /* colour specification box */
+  gst_byte_writer_put_uint32_be (&writer, 15);
+  gst_byte_writer_put_uint32_le (&writer, GST_MAKE_FOURCC ('c', 'o', 'l', 'r'));
+
+  /* specification method: enumerated */
+  gst_byte_writer_put_uint8 (&writer, 0x1);
+  /* precedence; reserved */
+  gst_byte_writer_put_uint8 (&writer, 0x0);
+  /* approximation; reserved */
+  gst_byte_writer_put_uint8 (&writer, 0x0);
+  /* enumerated colourspace */
+  gst_byte_writer_put_uint32_be (&writer, cenum);
+
+  if (cmap_array) {
+    gst_byte_writer_put_uint32_be (&writer, cmap_size);
+    gst_byte_writer_put_uint32_le (&writer,
+        GST_MAKE_FOURCC ('c', 'm', 'a', 'p'));
+    for (i = 0; i < cmap_array_size; i++) {
+      const GValue *item;
+      gint value;
+      guint16 cmp;
+      guint8 mtyp;
+      guint8 pcol;
+      item = gst_value_array_get_value (cmap_array, i);
+      value = g_value_get_int (item);
+
+      /* value is '(mtyp << 24) | (pcol << 16) | cmp' */
+      cmp = value & 0xFFFF;
+      mtyp = value >> 24;
+      pcol = (value >> 16) & 0xFF;
+
+      if (mtyp == 1)
+        GST_WARNING ("MTYP of cmap atom signals Pallete Mapping, but we don't "
+            "handle Pallete mapping atoms yet");
+
+      gst_byte_writer_put_uint16_be (&writer, cmp);
+      gst_byte_writer_put_uint8 (&writer, mtyp);
+      gst_byte_writer_put_uint8 (&writer, pcol);
+    }
+  }
+
+  if (cdef_array) {
+    gst_byte_writer_put_uint32_be (&writer, cdef_size);
+    gst_byte_writer_put_uint32_le (&writer,
+        GST_MAKE_FOURCC ('c', 'd', 'e', 'f'));
+    gst_byte_writer_put_uint16_be (&writer, cdef_array_size);
+    for (i = 0; i < cdef_array_size; i++) {
+      const GValue *item;
+      gint value;
+      item = gst_value_array_get_value (cdef_array, i);
+      value = g_value_get_int (item);
+
+      gst_byte_writer_put_uint16_be (&writer, i);
+      if (value > 0) {
+        gst_byte_writer_put_uint16_be (&writer, 0);
+        gst_byte_writer_put_uint16_be (&writer, value);
+      } else if (value < 0) {
+        gst_byte_writer_put_uint16_be (&writer, -value);
+        gst_byte_writer_put_uint16_be (&writer, 0);     /* TODO what here? */
+      } else {
+        gst_byte_writer_put_uint16_be (&writer, 1);
+        gst_byte_writer_put_uint16_be (&writer, 0);
+      }
+    }
+  }
+
+  g_assert (gst_byte_writer_get_remaining (&writer) == 0);
+
+  atom_data = atom_data_new_from_gst_buffer (FOURCC_jp2h, buf);
+  gst_buffer_unref (buf);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+AtomInfo *
+build_codec_data_extension (guint32 fourcc, const GstBuffer * codec_data)
+{
+  AtomData *data;
+  AtomInfo *result = NULL;
+
+  if (codec_data) {
+    data = atom_data_new_from_gst_buffer (fourcc, codec_data);
+    result = build_atom_info_wrapper ((Atom *) data, atom_data_copy_data,
+        atom_data_free);
+  }
+
+  return result;
+}
+
+AtomInfo *
+build_amr_extension (void)
+{
+  guint8 ext[9];
+  GstBuffer *buf;
+  AtomInfo *res;
+
+  buf = gst_buffer_new ();
+  GST_BUFFER_DATA (buf) = ext;
+  GST_BUFFER_SIZE (buf) = sizeof (ext);
+
+  /* vendor */
+  GST_WRITE_UINT32_LE (ext, 0);
+  /* decoder version */
+  GST_WRITE_UINT8 (ext + 4, 0);
+  /* mode set (all modes) */
+  GST_WRITE_UINT16_BE (ext + 5, 0x81FF);
+  /* mode change period (no restriction) */
+  GST_WRITE_UINT8 (ext + 7, 0);
+  /* frames per sample */
+  GST_WRITE_UINT8 (ext + 8, 1);
+
+  res = build_codec_data_extension (GST_MAKE_FOURCC ('d', 'a', 'm', 'r'), buf);
+  gst_buffer_unref (buf);
+  return res;
+}
+
+AtomInfo *
+build_h263_extension (void)
+{
+  guint8 ext[7];
+  GstBuffer *buf;
+  AtomInfo *res;
+
+  buf = gst_buffer_new ();
+  GST_BUFFER_DATA (buf) = ext;
+  GST_BUFFER_SIZE (buf) = sizeof (ext);
+
+  /* vendor */
+  GST_WRITE_UINT32_LE (ext, 0);
+  /* decoder version */
+  GST_WRITE_UINT8 (ext + 4, 0);
+  /* level / profile */
+  /* FIXME ? maybe ? obtain somewhere; baseline for now */
+  GST_WRITE_UINT8 (ext + 5, 10);
+  GST_WRITE_UINT8 (ext + 6, 0);
+
+  res = build_codec_data_extension (GST_MAKE_FOURCC ('d', '2', '6', '3'), buf);
+  gst_buffer_unref (buf);
+  return res;
+}
+
+AtomInfo *
+build_gama_atom (gdouble gamma)
+{
+  AtomInfo *res;
+  guint32 gamma_fp;
+  GstBuffer *buf;
+
+  /* convert to uint32 from fixed point */
+  gamma_fp = (guint32) 65536 *gamma;
+
+  buf = gst_buffer_new_and_alloc (4);
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), gamma_fp);
+  res = build_codec_data_extension (FOURCC_gama, buf);
+  gst_buffer_unref (buf);
+  return res;
+}
+
+AtomInfo *
+build_SMI_atom (const GstBuffer * seqh)
+{
+  AtomInfo *res;
+  GstBuffer *buf;
+
+  /* the seqh plus its size and fourcc */
+  buf = gst_buffer_new_and_alloc (GST_BUFFER_SIZE (seqh) + 8);
+
+  GST_WRITE_UINT32_LE (GST_BUFFER_DATA (buf), FOURCC_SEQH);
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf) + 4, GST_BUFFER_SIZE (seqh));
+  memcpy (GST_BUFFER_DATA (buf) + 8, GST_BUFFER_DATA (seqh),
+      GST_BUFFER_SIZE (seqh));
+  res = build_codec_data_extension (FOURCC_SMI_, buf);
+  gst_buffer_unref (buf);
+  return res;
+}
+
+static AtomInfo *
+build_ima_adpcm_atom (gint channels, gint rate, gint blocksize)
+{
+  AtomData *atom_data;
+  GstBuffer *buf;
+  guint8 *data;
+  const gint ima_adpcm_atom_size = 20;
+  guint32 fourcc;
+  gint samplesperblock;
+  gint bytespersec;
+
+  /* The FOURCC for WAV codecs in QT is 'ms' followed by the 16 bit wave codec
+     identifier. Note that the identifier here is big-endian, but when used
+     within the WAVE header (below), it's little endian. */
+  fourcc = MS_WAVE_FOURCC (0x11);
+
+  buf = gst_buffer_new_and_alloc (ima_adpcm_atom_size);
+  data = GST_BUFFER_DATA (buf);
+
+  /* This atom's content is a WAVE header, including 2 bytes of extra data.
+     Note that all of this is little-endian, unlike most stuff in qt. */
+  /* 4 bytes header per channel (including 1 sample). Then 2 samples per byte
+     for the rest. Simplifies to this. */
+  samplesperblock = 2 * blocksize / channels - 7;
+  bytespersec = rate * blocksize / samplesperblock;
+  GST_WRITE_UINT16_LE (data, 0x11);
+  GST_WRITE_UINT16_LE (data + 2, channels);
+  GST_WRITE_UINT32_LE (data + 4, rate);
+  GST_WRITE_UINT32_LE (data + 8, bytespersec);
+  GST_WRITE_UINT16_LE (data + 12, blocksize);
+  GST_WRITE_UINT16_LE (data + 14, 4);
+  GST_WRITE_UINT16_LE (data + 16, 2);   /* Two extra bytes */
+  GST_WRITE_UINT16_LE (data + 18, samplesperblock);
+
+  atom_data = atom_data_new_from_gst_buffer (fourcc, buf);
+  gst_buffer_unref (buf);
+
+  return build_atom_info_wrapper ((Atom *) atom_data, atom_data_copy_data,
+      atom_data_free);
+}
+
+AtomInfo *
+build_ima_adpcm_extension (gint channels, gint rate, gint blocksize)
+{
+  AtomWAVE *wave;
+  AtomFRMA *frma;
+  Atom *ext_atom;
+
+  /* Add WAVE atom */
+  wave = atom_wave_new ();
+
+  /* Prepend Terminator atom to the WAVE list first, so it ends up last */
+  ext_atom = (Atom *) atom_data_new (FOURCC_null);
+  wave->extension_atoms =
+      atom_info_list_prepend_atom (wave->extension_atoms, (Atom *) ext_atom,
+      (AtomCopyDataFunc) atom_data_copy_data, (AtomFreeFunc) atom_data_free);
+
+  /* Add wave ima adpcm atom to WAVE */
+  wave->extension_atoms = g_list_prepend (wave->extension_atoms,
+      build_ima_adpcm_atom (channels, rate, blocksize));
+
+  /* Add FRMA to the WAVE */
+  frma = atom_frma_new ();
+  frma->media_type = MS_WAVE_FOURCC (0x11);
+
+  wave->extension_atoms =
+      atom_info_list_prepend_atom (wave->extension_atoms, (Atom *) frma,
+      (AtomCopyDataFunc) atom_frma_copy_data, (AtomFreeFunc) atom_frma_free);
+
+  return build_atom_info_wrapper ((Atom *) wave, atom_wave_copy_data,
+      atom_wave_free);
+}
+
+AtomInfo *
+build_uuid_xmp_atom (GstBuffer * xmp_data)
+{
+  AtomUUID *uuid;
+  static guint8 xmp_uuid[] = { 0xBE, 0x7A, 0xCF, 0xCB,
+    0x97, 0xA9, 0x42, 0xE8,
+    0x9C, 0x71, 0x99, 0x94,
+    0x91, 0xE3, 0xAF, 0xAC
+  };
+
+  if (xmp_data == NULL)
+    return NULL;
+
+  uuid = atom_uuid_new ();
+  memcpy (uuid->uuid, xmp_uuid, 16);
+
+  uuid->data = g_malloc (GST_BUFFER_SIZE (xmp_data));
+  uuid->datalen = GST_BUFFER_SIZE (xmp_data);
+  memcpy (uuid->data, GST_BUFFER_DATA (xmp_data), GST_BUFFER_SIZE (xmp_data));
+
+  return build_atom_info_wrapper ((Atom *) uuid, atom_uuid_copy_data,
+      atom_uuid_free);
+}
diff --git a/gst/isomp4/atoms.h b/gst/isomp4/atoms.h
new file mode 100644
index 000000000..5aeb5f8f6
--- /dev/null
+++ b/gst/isomp4/atoms.h
@@ -0,0 +1,956 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __ATOMS_H__
+#define __ATOMS_H__
+
+#include <glib.h>
+#include <string.h>
+
+#include "descriptors.h"
+#include "properties.h"
+#include "fourcc.h"
+#include "ftypcc.h"
+
+/* helper storage struct */
+#define ATOM_ARRAY(struct_type) \
+struct { \
+  guint size; \
+  guint len; \
+  struct_type *data; \
+}
+
+/* storage helpers */
+
+#define atom_array_init(array, reserve)                                       \
+G_STMT_START {                                                                \
+  (array)->len = 0;                                                           \
+  (array)->size = reserve;                                                    \
+  (array)->data = g_malloc (sizeof (*(array)->data) * reserve);               \
+} G_STMT_END
+
+#define atom_array_append(array, elmt, inc)                                   \
+G_STMT_START {                                                                \
+  g_assert ((array)->data);                                                   \
+  g_assert (inc > 0);                                                         \
+  if (G_UNLIKELY ((array)->len == (array)->size)) {                           \
+    (array)->size += inc;                                                     \
+    (array)->data =                                                           \
+        g_realloc ((array)->data, sizeof (*((array)->data)) * (array)->size); \
+  }                                                                           \
+  (array)->data[(array)->len] = elmt;                                         \
+  (array)->len++;                                                             \
+} G_STMT_END
+
+#define atom_array_get_len(array)                  ((array)->len)
+#define atom_array_index(array, index)             ((array)->data[index])
+
+#define atom_array_clear(array)                                               \
+G_STMT_START {                                                                \
+  (array)->size = (array)->len = 0;                                           \
+  g_free ((array)->data);                                                     \
+  (array)->data = NULL;                                                       \
+} G_STMT_END
+
+/* light-weight context that may influence header atom tree construction */
+typedef enum _AtomsTreeFlavor
+{
+  ATOMS_TREE_FLAVOR_MOV,
+  ATOMS_TREE_FLAVOR_ISOM,
+  ATOMS_TREE_FLAVOR_3GP,
+  ATOMS_TREE_FLAVOR_ISML
+} AtomsTreeFlavor;
+
+typedef struct _AtomsContext
+{
+  AtomsTreeFlavor flavor;
+} AtomsContext;
+
+AtomsContext* atoms_context_new  (AtomsTreeFlavor flavor);
+void          atoms_context_free (AtomsContext *context);
+
+#define METADATA_DATA_FLAG 0x0
+#define METADATA_TEXT_FLAG 0x1
+
+/* atom defs and functions */
+
+/**
+ * Used for storing time related values for some atoms.
+ */
+typedef struct _TimeInfo
+{
+  guint64 creation_time;
+  guint64 modification_time;
+  guint32 timescale;
+  guint64 duration;
+} TimeInfo;
+
+typedef struct _Atom
+{
+  guint32 size;
+  guint32 type;
+  guint64 extended_size;
+} Atom;
+
+typedef struct _AtomFull
+{
+  Atom header;
+
+  guint8 version;
+  guint8 flags[3];
+} AtomFull;
+
+/*
+ * Generic extension atom
+ */
+typedef struct _AtomData
+{
+  Atom header;
+
+  /* not written */
+  guint32 datalen;
+
+  guint8 *data;
+} AtomData;
+
+typedef struct _AtomUUID
+{
+  Atom header;
+
+  guint8 uuid[16];
+
+  /* not written */
+  guint32 datalen;
+
+  guint8 *data;
+} AtomUUID;
+
+typedef struct _AtomFTYP
+{
+  Atom header;
+  guint32 major_brand;
+  guint32 version;
+  guint32 *compatible_brands;
+
+  /* not written */
+  guint32 compatible_brands_size;
+} AtomFTYP;
+
+typedef struct _AtomMVHD
+{
+  AtomFull header;
+
+  /* version 0: 32 bits */
+  TimeInfo time_info;
+
+  guint32 prefered_rate;      /* ISO: 0x00010000 */
+  guint16 volume;             /* ISO: 0x0100 */
+  guint16 reserved3;          /* ISO: 0x0 */
+  guint32 reserved4[2];       /* ISO: 0, 0 */
+  /* ISO: identity matrix =
+   * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
+  guint32 matrix[9];
+
+  /* ISO: all 0 */
+  guint32 preview_time;
+  guint32 preview_duration;
+  guint32 poster_time;
+  guint32 selection_time;
+  guint32 selection_duration;
+  guint32 current_time;
+
+  guint32 next_track_id;
+} AtomMVHD;
+
+typedef struct _AtomTKHD
+{
+  AtomFull header;
+
+  /* version 0: 32 bits */
+  /* like the TimeInfo struct, but it has this track_ID inside */
+  guint64 creation_time;
+  guint64 modification_time;
+  guint32 track_ID;
+  guint32 reserved;
+  guint64 duration;
+
+  guint32 reserved2[2];
+  guint16 layer;
+  guint16 alternate_group;
+  guint16 volume;
+  guint16 reserved3;
+
+  /* ISO: identity matrix =
+   * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
+  guint32 matrix[9];
+  guint32 width;
+  guint32 height;
+} AtomTKHD;
+
+typedef struct _AtomMDHD
+{
+  AtomFull header;
+
+  /* version 0: 32 bits */
+  TimeInfo time_info;
+
+  /* ISO: packed ISO-639-2/T language code (first bit must be 0) */
+  guint16 language_code;
+  /* ISO: 0 */
+  guint16 quality;
+} AtomMDHD;
+
+typedef struct _AtomHDLR
+{
+  AtomFull header;
+
+  /* ISO: 0 */
+  guint32 component_type;
+  guint32 handler_type;
+  guint32 manufacturer;
+  guint32 flags;
+  guint32 flags_mask;
+  gchar *name;
+} AtomHDLR;
+
+typedef struct _AtomVMHD
+{
+  AtomFull header;          /* ISO: flags = 1 */
+
+  guint16 graphics_mode;
+  /* RGB */
+  guint16 opcolor[3];
+} AtomVMHD;
+
+typedef struct _AtomSMHD
+{
+  AtomFull header;
+
+  guint16 balance;
+  guint16 reserved;
+} AtomSMHD;
+
+typedef struct _AtomHMHD
+{
+  AtomFull header;
+
+  guint16 max_pdu_size;
+  guint16 avg_pdu_size;
+  guint32 max_bitrate;
+  guint32 avg_bitrate;
+  guint32 sliding_avg_bitrate;
+} AtomHMHD;
+
+typedef struct _AtomURL
+{
+  AtomFull header;
+
+  gchar *location;
+} AtomURL;
+
+typedef struct _AtomDREF
+{
+  AtomFull header;
+
+  GList *entries;
+} AtomDREF;
+
+typedef struct _AtomDINF
+{
+  Atom header;
+
+  AtomDREF dref;
+} AtomDINF;
+
+typedef struct _STTSEntry
+{
+  guint32 sample_count;
+  gint32 sample_delta;
+} STTSEntry;
+
+typedef struct _AtomSTTS
+{
+  AtomFull header;
+
+  ATOM_ARRAY (STTSEntry) entries;
+} AtomSTTS;
+
+typedef struct _AtomSTSS
+{
+  AtomFull header;
+
+  ATOM_ARRAY (guint32) entries;
+} AtomSTSS;
+
+typedef struct _AtomESDS
+{
+  AtomFull header;
+
+  ESDescriptor es;
+} AtomESDS;
+
+typedef struct _AtomFRMA
+{
+  Atom header;
+
+  guint32 media_type;
+} AtomFRMA;
+
+typedef enum _SampleEntryKind
+{
+  UNKNOWN,
+  AUDIO,
+  VIDEO
+} SampleEntryKind;
+
+typedef struct _SampleTableEntry
+{
+  Atom header;
+
+  guint8 reserved[6];
+  guint16 data_reference_index;
+
+  /* sort of entry */
+  SampleEntryKind kind;
+} SampleTableEntry;
+
+typedef struct _AtomHintSampleEntry
+{
+  SampleTableEntry se;
+  guint32 size;
+  guint8 *data;
+} AtomHintSampleEntry;
+
+typedef struct _SampleTableEntryMP4V
+{
+  SampleTableEntry se;
+
+  guint16 version;
+  guint16 revision_level;
+
+  guint32 vendor;                 /* fourcc code */
+  guint32 temporal_quality;
+  guint32 spatial_quality;
+
+  guint16 width;
+  guint16 height;
+
+  guint32 horizontal_resolution;
+  guint32 vertical_resolution;
+  guint32 datasize;
+
+  guint16 frame_count;            /* usually 1 */
+
+  guint8 compressor[32];         /* pascal string, i.e. first byte = length */
+
+  guint16 depth;
+  guint16 color_table_id;
+
+  /* (optional) list of AtomInfo */
+  GList *extension_atoms;
+} SampleTableEntryMP4V;
+
+typedef struct _SampleTableEntryMP4A
+{
+  SampleTableEntry se;
+
+  guint16 version;
+  guint16 revision_level;
+  guint32 vendor;
+
+  guint16 channels;
+  guint16 sample_size;
+  guint16 compression_id;
+  guint16 packet_size;
+
+  guint32 sample_rate;            /* fixed point 16.16 */
+
+  guint32 samples_per_packet;
+  guint32 bytes_per_packet;
+  guint32 bytes_per_frame;
+  guint32 bytes_per_sample;
+
+  /* (optional) list of AtomInfo */
+  GList *extension_atoms;
+} SampleTableEntryMP4A;
+
+typedef struct _SampleTableEntryMP4S
+{
+  SampleTableEntry se;
+
+  AtomESDS es;
+} SampleTableEntryMP4S;
+
+typedef struct _AtomSTSD
+{
+  AtomFull header;
+
+  guint n_entries;
+  /* list of subclasses of SampleTableEntry */
+  GList *entries;
+} AtomSTSD;
+
+typedef struct _AtomSTSZ
+{
+  AtomFull header;
+
+  guint32 sample_size;
+
+  /* need the size here because when sample_size is constant,
+   * the list is empty */
+  guint32 table_size;
+  ATOM_ARRAY (guint32) entries;
+} AtomSTSZ;
+
+typedef struct _STSCEntry
+{
+  guint32 first_chunk;
+  guint32 samples_per_chunk;
+  guint32 sample_description_index;
+} STSCEntry;
+
+typedef struct _AtomSTSC
+{
+  AtomFull header;
+
+  ATOM_ARRAY (STSCEntry) entries;
+} AtomSTSC;
+
+
+/*
+ * used for both STCO and CO64
+ * if used as STCO, entries should be truncated to use only 32bits
+ */
+typedef struct _AtomSTCO64
+{
+  AtomFull header;
+
+  ATOM_ARRAY (guint64) entries;
+} AtomSTCO64;
+
+typedef struct _CTTSEntry
+{
+  guint32 samplecount;
+  guint32 sampleoffset;
+} CTTSEntry;
+
+typedef struct _AtomCTTS
+{
+  AtomFull header;
+
+  /* also entry count here */
+  ATOM_ARRAY (CTTSEntry) entries;
+  gboolean do_pts;
+} AtomCTTS;
+
+typedef struct _AtomSTBL
+{
+  Atom header;
+
+  AtomSTSD stsd;
+  AtomSTTS stts;
+  AtomSTSS stss;
+  AtomSTSC stsc;
+  AtomSTSZ stsz;
+  /* NULL if not present */
+  AtomCTTS *ctts;
+
+  AtomSTCO64 stco64;
+} AtomSTBL;
+
+typedef struct _AtomMINF
+{
+  Atom header;
+
+  /* only (exactly) one of those must be present */
+  AtomVMHD *vmhd;
+  AtomSMHD *smhd;
+  AtomHMHD *hmhd;
+
+  AtomHDLR *hdlr;
+  AtomDINF dinf;
+  AtomSTBL stbl;
+} AtomMINF;
+
+typedef struct _EditListEntry
+{
+  /* duration in movie's timescale */
+  guint32 duration;
+  /* start time in media's timescale, -1 for empty */
+  guint32 media_time;
+  guint32 media_rate;  /* fixed point 32 bit */
+} EditListEntry;
+
+typedef struct _AtomELST
+{
+  AtomFull header;
+
+  /* number of entries is implicit */
+  GSList *entries;
+} AtomELST;
+
+typedef struct _AtomEDTS
+{
+  Atom header;
+  AtomELST elst;
+} AtomEDTS;
+
+typedef struct _AtomMDIA
+{
+  Atom header;
+
+  AtomMDHD mdhd;
+  AtomHDLR hdlr;
+  AtomMINF minf;
+} AtomMDIA;
+
+typedef struct _AtomILST
+{
+  Atom header;
+
+  /* list of AtomInfo */
+  GList* entries;
+} AtomILST;
+
+typedef struct _AtomTagData
+{
+  AtomFull header;
+  guint32 reserved;
+
+  guint32 datalen;
+  guint8* data;
+} AtomTagData;
+
+typedef struct _AtomTag
+{
+  Atom header;
+
+  AtomTagData data;
+} AtomTag;
+
+typedef struct _AtomMETA
+{
+  AtomFull header;
+  AtomHDLR hdlr;
+  AtomILST *ilst;
+} AtomMETA;
+
+typedef struct _AtomUDTA
+{
+  Atom header;
+
+  /* list of AtomInfo */
+  GList* entries;
+  /* or list is further down */
+  AtomMETA *meta;
+} AtomUDTA;
+
+enum TrFlags
+{
+  TR_DATA_OFFSET              = 0x01,     /* data-offset-present */
+  TR_FIRST_SAMPLE_FLAGS       = 0x04,     /* first-sample-flags-present */
+  TR_SAMPLE_DURATION          = 0x0100,   /* sample-duration-present */
+  TR_SAMPLE_SIZE              = 0x0200,   /* sample-size-present */
+  TR_SAMPLE_FLAGS             = 0x0400,   /* sample-flags-present */
+  TR_COMPOSITION_TIME_OFFSETS = 0x0800    /* sample-composition-time-offsets-presents */
+};
+
+enum TfFlags
+{
+  TF_BASE_DATA_OFFSET         = 0x01,     /* base-data-offset-present */
+  TF_SAMPLE_DESCRIPTION_INDEX = 0x02,     /* sample-description-index-present */
+  TF_DEFAULT_SAMPLE_DURATION  = 0x08,     /* default-sample-duration-present */
+  TF_DEFAULT_SAMPLE_SIZE      = 0x010,    /* default-sample-size-present */
+  TF_DEFAULT_SAMPLE_FLAGS     = 0x020,    /* default-sample-flags-present */
+  TF_DURATION_IS_EMPTY        = 0x010000  /* sample-composition-time-offsets-presents */
+};
+
+typedef struct _AtomTRAK
+{
+  Atom header;
+
+  AtomTKHD tkhd;
+  AtomEDTS *edts;
+  AtomMDIA mdia;
+
+  /* some helper info for structural conformity checks */
+  gboolean is_video;
+  gboolean is_h264;
+} AtomTRAK;
+
+typedef struct _AtomTREX
+{
+  AtomFull header;
+
+  guint32 track_ID;
+  guint32 default_sample_description_index;
+  guint32 default_sample_duration;
+  guint32 default_sample_size;
+  guint32 default_sample_flags;
+} AtomTREX;
+
+typedef struct _AtomMEHD
+{
+  AtomFull header;
+
+  guint64 fragment_duration;
+} AtomMEHD;
+
+
+typedef struct _AtomMVEX
+{
+  Atom header;
+
+  AtomMEHD mehd;
+
+  /* list of AtomTREX */
+  GList *trexs;
+} AtomMVEX;
+
+typedef struct _AtomMFHD
+{
+  AtomFull header;
+
+  guint32 sequence_number;
+} AtomMFHD;
+
+typedef struct _AtomTFHD
+{
+  AtomFull header;
+
+  guint32 track_ID;
+  guint64 base_data_offset;
+  guint32 sample_description_index;
+  guint32 default_sample_duration;
+  guint32 default_sample_size;
+  guint32 default_sample_flags;
+} AtomTFHD;
+
+typedef struct _TRUNSampleEntry
+{
+  guint32 sample_duration;
+  guint32 sample_size;
+  guint32 sample_flags;
+  guint32 sample_composition_time_offset;
+} TRUNSampleEntry;
+
+typedef struct _AtomTRUN
+{
+  AtomFull header;
+
+  guint32 sample_count;
+  gint32 data_offset;
+  guint32 first_sample_flags;
+
+  /* array of fields */
+  ATOM_ARRAY (TRUNSampleEntry) entries;
+} AtomTRUN;
+
+typedef struct _AtomSDTP
+{
+  AtomFull header;
+
+  /* not serialized */
+  guint32 sample_count;
+
+  /* array of fields */
+  ATOM_ARRAY (guint8) entries;
+} AtomSDTP;
+
+typedef struct _AtomTRAF
+{
+  Atom header;
+
+  AtomTFHD tfhd;
+
+  /* list of AtomTRUN */
+  GList *truns;
+  /* list of AtomSDTP */
+  GList *sdtps;
+} AtomTRAF;
+
+typedef struct _AtomMOOF
+{
+  Atom header;
+
+  AtomMFHD mfhd;
+
+  /* list of AtomTRAF */
+  GList *trafs;
+} AtomMOOF;
+
+
+typedef struct _AtomMOOV
+{
+  /* style */
+  AtomsContext context;
+
+  Atom header;
+
+  AtomMVHD mvhd;
+  AtomMVEX mvex;
+
+  /* list of AtomTRAK */
+  GList *traks;
+  AtomUDTA *udta;
+
+  gboolean fragmented;
+} AtomMOOV;
+
+typedef struct _AtomWAVE
+{
+  Atom header;
+
+  /* list of AtomInfo */
+  GList *extension_atoms;
+} AtomWAVE;
+
+typedef struct _TFRAEntry
+{
+  guint64 time;
+  guint64 moof_offset;
+  guint32 traf_number;
+  guint32 trun_number;
+  guint32 sample_number;
+} TFRAEntry;
+
+typedef struct _AtomTFRA
+{
+  AtomFull header;
+
+  guint32 track_ID;
+  guint32 lengths;
+  /* array of entries */
+  ATOM_ARRAY (TFRAEntry) entries;
+} AtomTFRA;
+
+typedef struct _AtomMFRA
+{
+  Atom header;
+
+  /* list of tfra */
+  GList *tfras;
+} AtomMFRA;
+
+/*
+ * Function to serialize an atom
+ */
+typedef guint64 (*AtomCopyDataFunc) (Atom *atom, guint8 **buffer, guint64 *size, guint64 *offset);
+
+/*
+ * Releases memory allocated by an atom
+ */
+typedef guint64 (*AtomFreeFunc) (Atom *atom);
+
+/*
+ * Some atoms might have many optional different kinds of child atoms, so this
+ * is useful for enabling generic handling of any atom.
+ * All we need are the two functions (copying it to an array
+ * for serialization and the memory releasing function).
+ */
+typedef struct _AtomInfo
+{
+  Atom *atom;
+  AtomCopyDataFunc copy_data_func;
+  AtomFreeFunc free_func;
+} AtomInfo;
+
+
+guint64    atom_copy_data              (Atom *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+
+AtomFTYP*  atom_ftyp_new               (AtomsContext *context, guint32 major,
+                                        guint32 version, GList *brands);
+guint64    atom_ftyp_copy_data         (AtomFTYP *ftyp, guint8 **buffer,
+                                        guint64 *size, guint64 *offset);
+void       atom_ftyp_free              (AtomFTYP *ftyp);
+
+AtomTRAK*  atom_trak_new               (AtomsContext *context);
+void       atom_trak_add_samples       (AtomTRAK * trak, guint32 nsamples, guint32 delta,
+                                        guint32 size, guint64 chunk_offset, gboolean sync,
+                                        gint64 pts_offset);
+void       atom_trak_add_elst_entry    (AtomTRAK * trak, guint32 duration,
+                                        guint32 media_time, guint32 rate);
+guint32    atom_trak_get_timescale     (AtomTRAK *trak);
+guint32    atom_trak_get_id            (AtomTRAK * trak);
+void       atom_stbl_add_samples       (AtomSTBL * stbl, guint32 nsamples,
+                                        guint32 delta, guint32 size,
+                                        guint64 chunk_offset, gboolean sync,
+                                        gint64 pts_offset);
+
+AtomMOOV*  atom_moov_new               (AtomsContext *context);
+void       atom_moov_free              (AtomMOOV *moov);
+guint64    atom_moov_copy_data         (AtomMOOV *atom, guint8 **buffer, guint64 *size, guint64* offset);
+void       atom_moov_update_timescale  (AtomMOOV *moov, guint32 timescale);
+void       atom_moov_update_duration   (AtomMOOV *moov);
+void       atom_moov_set_fragmented    (AtomMOOV *moov, gboolean fragmented);
+void       atom_moov_chunks_add_offset (AtomMOOV *moov, guint32 offset);
+void       atom_moov_add_trak          (AtomMOOV *moov, AtomTRAK *trak);
+
+guint64    atom_mvhd_copy_data         (AtomMVHD * atom, guint8 ** buffer,
+                                        guint64 * size, guint64 * offset);
+void       atom_stco64_chunks_add_offset (AtomSTCO64 * stco64, guint32 offset);
+guint64    atom_trak_copy_data         (AtomTRAK * atom, guint8 ** buffer,
+                                        guint64 * size, guint64 * offset);
+void       atom_stbl_clear             (AtomSTBL * stbl);
+void       atom_stbl_init              (AtomSTBL * stbl);
+guint64    atom_stss_copy_data         (AtomSTSS *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+guint64    atom_stts_copy_data         (AtomSTTS *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+guint64    atom_stsc_copy_data         (AtomSTSC *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+guint64    atom_stsz_copy_data         (AtomSTSZ *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+guint64    atom_ctts_copy_data         (AtomCTTS *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+guint64    atom_stco64_copy_data       (AtomSTCO64 *atom, guint8 **buffer,
+                                        guint64 *size, guint64* offset);
+AtomMOOF*  atom_moof_new               (AtomsContext *context, guint32 sequence_number);
+void       atom_moof_free              (AtomMOOF *moof);
+guint64    atom_moof_copy_data         (AtomMOOF *moof, guint8 **buffer, guint64 *size, guint64* offset);
+AtomTRAF * atom_traf_new               (AtomsContext * context, guint32 track_ID);
+void       atom_traf_free              (AtomTRAF * traf);
+void       atom_traf_add_samples       (AtomTRAF * traf, guint32 delta,
+                                        guint32 size, gboolean sync, gint64 pts_offset,
+                                        gboolean sdtp_sync);
+guint32    atom_traf_get_sample_num    (AtomTRAF * traf);
+void       atom_moof_add_traf          (AtomMOOF *moof, AtomTRAF *traf);
+
+AtomMFRA*  atom_mfra_new               (AtomsContext *context);
+void       atom_mfra_free              (AtomMFRA *mfra);
+AtomTFRA*  atom_tfra_new               (AtomsContext *context, guint32 track_ID);
+void       atom_tfra_add_entry         (AtomTFRA *tfra, guint64 dts, guint32 sample_num);
+void       atom_tfra_update_offset     (AtomTFRA * tfra, guint64 offset);
+void       atom_mfra_add_tfra          (AtomMFRA *mfra, AtomTFRA *tfra);
+guint64    atom_mfra_copy_data         (AtomMFRA *mfra, guint8 **buffer, guint64 *size, guint64* offset);
+
+
+/* media sample description related helpers */
+
+typedef struct
+{
+  guint16 version;
+  guint32 fourcc;
+  guint width;
+  guint height;
+  guint depth;
+  guint frame_count;
+  gint color_table_id;
+  guint par_n;
+  guint par_d;
+
+  GstBuffer *codec_data;
+} VisualSampleEntry;
+
+typedef struct
+{
+  guint32 fourcc;
+  guint version;
+  gint compression_id;
+  guint sample_rate;
+  guint channels;
+  guint sample_size;
+  guint bytes_per_packet;
+  guint samples_per_packet;
+  guint bytes_per_sample;
+  guint bytes_per_frame;
+
+  GstBuffer *codec_data;
+} AudioSampleEntry;
+
+void atom_trak_set_audio_type (AtomTRAK * trak, AtomsContext * context,
+                               AudioSampleEntry * entry, guint32 scale,
+                               AtomInfo * ext, gint sample_size);
+
+void atom_trak_set_video_type (AtomTRAK * trak, AtomsContext * context,
+                               VisualSampleEntry * entry, guint32 rate,
+                               GList * ext_atoms_list);
+
+AtomInfo *   build_codec_data_extension  (guint32 fourcc, const GstBuffer * codec_data);
+AtomInfo *   build_mov_aac_extension     (AtomTRAK * trak, const GstBuffer * codec_data,
+                                          guint32 avg_bitrate, guint32 max_bitrate);
+AtomInfo *   build_mov_alac_extension    (AtomTRAK * trak, const GstBuffer * codec_data);
+AtomInfo *   build_esds_extension        (AtomTRAK * trak, guint8 object_type,
+                                          guint8 stream_type, const GstBuffer * codec_data,
+                                          guint32 avg_bitrate, guint32 max_bitrate);
+AtomInfo *   build_btrt_extension        (guint32 buffer_size_db, guint32 avg_bitrate,
+                                          guint32 max_bitrate);
+AtomInfo *   build_jp2h_extension        (AtomTRAK * trak, gint width, gint height,
+                                          guint32 fourcc, gint ncomp,
+                                          const GValue * cmap_array,
+                                          const GValue * cdef_array);
+
+AtomInfo *   build_jp2x_extension        (const GstBuffer * prefix);
+AtomInfo *   build_fiel_extension        (gint fields);
+AtomInfo *   build_amr_extension         (void);
+AtomInfo *   build_h263_extension        (void);
+AtomInfo *   build_gama_atom             (gdouble gamma);
+AtomInfo *   build_SMI_atom              (const GstBuffer *seqh);
+AtomInfo *   build_ima_adpcm_extension   (gint channels, gint rate,
+                                          gint blocksize);
+AtomInfo *   build_uuid_xmp_atom         (GstBuffer * xmp);
+
+
+/*
+ * Meta tags functions
+ */
+void atom_moov_add_str_tag    (AtomMOOV *moov, guint32 fourcc, const gchar *value);
+void atom_moov_add_uint_tag   (AtomMOOV *moov, guint32 fourcc, guint32 flags,
+                               guint32 value);
+void atom_moov_add_tag        (AtomMOOV *moov, guint32 fourcc, guint32 flags,
+                               const guint8 * data, guint size);
+void atom_moov_add_blob_tag   (AtomMOOV *moov, guint8 *data, guint size);
+
+void atom_moov_add_3gp_str_tag       (AtomMOOV * moov, guint32 fourcc, const gchar * value);
+void atom_moov_add_3gp_uint_tag      (AtomMOOV * moov, guint32 fourcc, guint16 value);
+void atom_moov_add_3gp_str_int_tag   (AtomMOOV * moov, guint32 fourcc, const gchar * value,
+                                      gint16 ivalue);
+void atom_moov_add_3gp_tag           (AtomMOOV * moov, guint32 fourcc, guint8 * data,
+                                      guint size);
+
+void atom_moov_add_xmp_tags          (AtomMOOV * moov, GstBuffer * xmp);
+
+#define GST_QT_MUX_DEFAULT_TAG_LANGUAGE   "eng"
+guint16  language_code               (const char * lang);
+
+#endif /* __ATOMS_H__ */
diff --git a/gst/isomp4/atomsrecovery.c b/gst/isomp4/atomsrecovery.c
new file mode 100644
index 000000000..1f5a287d1
--- /dev/null
+++ b/gst/isomp4/atomsrecovery.c
@@ -0,0 +1,1095 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+/**
+ * This module contains functions for serializing partial information from
+ * a mux in progress (by qtmux elements). This enables reconstruction of the
+ * moov box if a crash happens and thus recovering the movie file.
+ *
+ * Usage:
+ * 1) pipeline: ...yourelements ! qtmux moov-recovery-file=path.mrf ! \
+ * filesink location=moovie.mov
+ *
+ * 2) CRASH!
+ *
+ * 3) gst-launch qtmoovrecover recovery-input=path.mrf broken-input=moovie.mov \
+        fixed-output=recovered.mov
+ *
+ * 4) (Hopefully) enjoy recovered.mov.
+ *
+ * --- Recovery file layout ---
+ * 1) Version (a guint16)
+ * 2) Prefix atom (if present)
+ * 3) ftyp atom
+ * 4) MVHD atom (without timescale/duration set)
+ * 5) moovie timescale
+ * 6) number of traks
+ * 7) list of trak atoms (stbl data is ignored, except for the stsd atom)
+ * 8) Buffers metadata (metadata that is relevant to the container)
+ *    Buffers metadata are stored in the order they are added to the mdat,
+ *    each entre has a fixed size and is stored in BE. booleans are stored
+ *    as a single byte where 0 means false, otherwise is true.
+ *   Metadata:
+ *   - guint32   track_id;
+ *   - guint32   nsamples;
+ *   - guint32   delta;
+ *   - guint32   size;
+ *   - guint64   chunk_offset;
+ *   - gboolean  sync;
+ *   - gboolean  do_pts;
+ *   - guint64   pts_offset; (always present, ignored if do_pts is false)
+ *
+ * The mdat file might contain ftyp and then mdat, in case this is the faststart
+ * temporary file there is no ftyp and no mdat header, only the buffers data.
+ *
+ * Notes about recovery file layout: We still don't store tags nor EDTS data.
+ *
+ * IMPORTANT: this is still at a experimental state.
+ */
+
+#include "atomsrecovery.h"
+
+#define ATOMS_RECOV_OUTPUT_WRITE_ERROR(err) \
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE, \
+        "Failed to write to output file: %s", g_strerror (errno))
+
+static gboolean
+atoms_recov_write_version (FILE * f)
+{
+  guint8 data[2];
+  GST_WRITE_UINT16_BE (data, ATOMS_RECOV_FILE_VERSION);
+  return fwrite (data, 2, 1, f) == 1;
+}
+
+static gboolean
+atoms_recov_write_ftyp_info (FILE * f, AtomFTYP * ftyp, GstBuffer * prefix)
+{
+  guint8 *data = NULL;
+  guint64 offset = 0;
+  guint64 size = 0;
+
+  if (prefix) {
+    if (fwrite (GST_BUFFER_DATA (prefix), 1, GST_BUFFER_SIZE (prefix), f) !=
+        GST_BUFFER_SIZE (prefix)) {
+      return FALSE;
+    }
+  }
+  if (!atom_ftyp_copy_data (ftyp, &data, &size, &offset)) {
+    return FALSE;
+  }
+  if (fwrite (data, 1, offset, f) != offset) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+/**
+ * Writes important info on the 'moov' atom (non-trak related)
+ * to be able to recover the moov structure after a crash.
+ *
+ * Currently, it writes the MVHD atom.
+ */
+static gboolean
+atoms_recov_write_moov_info (FILE * f, AtomMOOV * moov)
+{
+  guint8 *data;
+  guint64 size;
+  guint64 offset = 0;
+  guint64 atom_size = 0;
+  gint writen = 0;
+
+  /* likely enough */
+  size = 256;
+  data = g_malloc (size);
+  atom_size = atom_mvhd_copy_data (&moov->mvhd, &data, &size, &offset);
+  if (atom_size > 0)
+    writen = fwrite (data, 1, atom_size, f);
+  g_free (data);
+  return atom_size > 0 && writen == atom_size;
+}
+
+/**
+ * Writes the number of traks to the file.
+ * This simply writes a guint32 in BE.
+ */
+static gboolean
+atoms_recov_write_traks_number (FILE * f, guint32 traks)
+{
+  guint8 data[4];
+  GST_WRITE_UINT32_BE (data, traks);
+  return fwrite (data, 4, 1, f) == 1;
+}
+
+/**
+ * Writes the moov's timescale to the file
+ * This simply writes a guint32 in BE.
+ */
+static gboolean
+atoms_recov_write_moov_timescale (FILE * f, guint32 timescale)
+{
+  guint8 data[4];
+  GST_WRITE_UINT32_BE (data, timescale);
+  return fwrite (data, 4, 1, f) == 1;
+}
+
+/**
+ * Writes the trak atom to the file.
+ */
+gboolean
+atoms_recov_write_trak_info (FILE * f, AtomTRAK * trak)
+{
+  guint8 *data;
+  guint64 size;
+  guint64 offset = 0;
+  guint64 atom_size = 0;
+  gint writen = 0;
+
+  /* buffer is realloced to a larger size if needed */
+  size = 4 * 1024;
+  data = g_malloc (size);
+  atom_size = atom_trak_copy_data (trak, &data, &size, &offset);
+  if (atom_size > 0)
+    writen = fwrite (data, atom_size, 1, f);
+  g_free (data);
+  return atom_size > 0 && writen == atom_size;
+}
+
+gboolean
+atoms_recov_write_trak_samples (FILE * f, AtomTRAK * trak, guint32 nsamples,
+    guint32 delta, guint32 size, guint64 chunk_offset, gboolean sync,
+    gboolean do_pts, gint64 pts_offset)
+{
+  guint8 data[TRAK_BUFFER_ENTRY_INFO_SIZE];
+  /*
+   * We have to write a TrakBufferEntryInfo
+   */
+  GST_WRITE_UINT32_BE (data + 0, trak->tkhd.track_ID);
+  GST_WRITE_UINT32_BE (data + 4, nsamples);
+  GST_WRITE_UINT32_BE (data + 8, delta);
+  GST_WRITE_UINT32_BE (data + 12, size);
+  GST_WRITE_UINT64_BE (data + 16, chunk_offset);
+  if (sync)
+    GST_WRITE_UINT8 (data + 24, 1);
+  else
+    GST_WRITE_UINT8 (data + 24, 0);
+  if (do_pts) {
+    GST_WRITE_UINT8 (data + 25, 1);
+    GST_WRITE_UINT64_BE (data + 26, pts_offset);
+  } else {
+    GST_WRITE_UINT8 (data + 25, 0);
+    GST_WRITE_UINT64_BE (data + 26, 0);
+  }
+
+  return fwrite (data, 1, TRAK_BUFFER_ENTRY_INFO_SIZE, f) ==
+      TRAK_BUFFER_ENTRY_INFO_SIZE;
+}
+
+gboolean
+atoms_recov_write_headers (FILE * f, AtomFTYP * ftyp, GstBuffer * prefix,
+    AtomMOOV * moov, guint32 timescale, guint32 traks_number)
+{
+  if (!atoms_recov_write_version (f)) {
+    return FALSE;
+  }
+
+  if (!atoms_recov_write_ftyp_info (f, ftyp, prefix)) {
+    return FALSE;
+  }
+
+  if (!atoms_recov_write_moov_info (f, moov)) {
+    return FALSE;
+  }
+
+  if (!atoms_recov_write_moov_timescale (f, timescale)) {
+    return FALSE;
+  }
+
+  if (!atoms_recov_write_traks_number (f, traks_number)) {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+static gboolean
+read_atom_header (FILE * f, guint32 * fourcc, guint32 * size)
+{
+  guint8 aux[8];
+
+  if (fread (aux, 1, 8, f) != 8)
+    return FALSE;
+  *size = GST_READ_UINT32_BE (aux);
+  *fourcc = GST_READ_UINT32_LE (aux + 4);
+  return TRUE;
+}
+
+static gboolean
+moov_recov_file_parse_prefix (MoovRecovFile * moovrf)
+{
+  guint32 fourcc;
+  guint32 size;
+  guint32 total_size = 0;
+  if (fseek (moovrf->file, 2, SEEK_SET) != 0)
+    return FALSE;
+  if (!read_atom_header (moovrf->file, &fourcc, &size)) {
+    return FALSE;
+  }
+
+  if (fourcc != FOURCC_ftyp) {
+    /* we might have a prefix here */
+    if (fseek (moovrf->file, size - 8, SEEK_CUR) != 0)
+      return FALSE;
+
+    total_size += size;
+
+    /* now read the ftyp */
+    if (!read_atom_header (moovrf->file, &fourcc, &size))
+      return FALSE;
+  }
+
+  /* this has to be the ftyp */
+  if (fourcc != FOURCC_ftyp)
+    return FALSE;
+  total_size += size;
+  moovrf->prefix_size = total_size;
+  return fseek (moovrf->file, size - 8, SEEK_CUR) == 0;
+}
+
+static gboolean
+moov_recov_file_parse_mvhd (MoovRecovFile * moovrf)
+{
+  guint32 fourcc;
+  guint32 size;
+  if (!read_atom_header (moovrf->file, &fourcc, &size)) {
+    return FALSE;
+  }
+  /* check for sanity */
+  if (fourcc != FOURCC_mvhd)
+    return FALSE;
+
+  moovrf->mvhd_size = size;
+  moovrf->mvhd_pos = ftell (moovrf->file) - 8;
+
+  /* skip the remaining of the mvhd in the file */
+  return fseek (moovrf->file, size - 8, SEEK_CUR) == 0;
+}
+
+static gboolean
+mdat_recov_file_parse_mdat_start (MdatRecovFile * mdatrf)
+{
+  guint32 fourcc, size;
+
+  if (!read_atom_header (mdatrf->file, &fourcc, &size)) {
+    return FALSE;
+  }
+  if (size == 1) {
+    mdatrf->mdat_header_size = 16;
+    mdatrf->mdat_size = 16;
+  } else {
+    mdatrf->mdat_header_size = 8;
+    mdatrf->mdat_size = 8;
+  }
+  mdatrf->mdat_start = ftell (mdatrf->file) - 8;
+
+  return fourcc == FOURCC_mdat;
+}
+
+MdatRecovFile *
+mdat_recov_file_create (FILE * file, gboolean datafile, GError ** err)
+{
+  MdatRecovFile *mrf = g_new0 (MdatRecovFile, 1);
+  guint32 fourcc, size;
+
+  g_return_val_if_fail (file != NULL, NULL);
+
+  mrf->file = file;
+  mrf->rawfile = datafile;
+
+  /* get the file/data length */
+  if (fseek (file, 0, SEEK_END) != 0)
+    goto file_length_error;
+  /* still needs to deduce the mdat header and ftyp size */
+  mrf->data_size = ftell (file);
+  if (mrf->data_size == -1L)
+    goto file_length_error;
+
+  if (fseek (file, 0, SEEK_SET) != 0)
+    goto file_seek_error;
+
+  if (datafile) {
+    /* this file contains no atoms, only raw data to be placed on the mdat
+     * this happens when faststart mode is used */
+    mrf->mdat_start = 0;
+    mrf->mdat_header_size = 16;
+    mrf->mdat_size = 16;
+    return mrf;
+  }
+
+  if (!read_atom_header (file, &fourcc, &size)) {
+    goto parse_error;
+  }
+  if (fourcc != FOURCC_ftyp) {
+    /* this could be a prefix atom, let's skip it and try again */
+    if (fseek (file, size - 8, SEEK_CUR) != 0) {
+      goto file_seek_error;
+    }
+    if (!read_atom_header (file, &fourcc, &size)) {
+      goto parse_error;
+    }
+  }
+
+  if (fourcc != FOURCC_ftyp) {
+    goto parse_error;
+  }
+  if (fseek (file, size - 8, SEEK_CUR) != 0)
+    goto file_seek_error;
+
+  /* we don't parse this if we have a tmpdatafile */
+  if (!mdat_recov_file_parse_mdat_start (mrf)) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+        "Error while parsing mdat atom");
+    goto fail;
+  }
+
+  return mrf;
+
+parse_error:
+  g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+      "Failed to parse atom");
+  goto fail;
+
+file_seek_error:
+  g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+      "Failed to seek to start of the file");
+  goto fail;
+
+file_length_error:
+  g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+      "Failed to determine file size");
+  goto fail;
+
+fail:
+  mdat_recov_file_free (mrf);
+  return NULL;
+}
+
+void
+mdat_recov_file_free (MdatRecovFile * mrf)
+{
+  fclose (mrf->file);
+  g_free (mrf);
+}
+
+static gboolean
+moov_recov_parse_num_traks (MoovRecovFile * moovrf)
+{
+  guint8 traks[4];
+  if (fread (traks, 1, 4, moovrf->file) != 4)
+    return FALSE;
+  moovrf->num_traks = GST_READ_UINT32_BE (traks);
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_moov_timescale (MoovRecovFile * moovrf)
+{
+  guint8 ts[4];
+  if (fread (ts, 1, 4, moovrf->file) != 4)
+    return FALSE;
+  moovrf->timescale = GST_READ_UINT32_BE (ts);
+  return TRUE;
+}
+
+static gboolean
+skip_atom (MoovRecovFile * moovrf, guint32 expected_fourcc)
+{
+  guint32 size;
+  guint32 fourcc;
+
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != expected_fourcc)
+    return FALSE;
+
+  return (fseek (moovrf->file, size - 8, SEEK_CUR) == 0);
+}
+
+static gboolean
+moov_recov_parse_tkhd (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint32 size;
+  guint32 fourcc;
+  guint8 data[4];
+
+  /* make sure we are on a tkhd atom */
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != FOURCC_tkhd)
+    return FALSE;
+
+  trakrd->tkhd_file_offset = ftell (moovrf->file) - 8;
+
+  /* move 8 bytes forward to the trak_id pos */
+  if (fseek (moovrf->file, 12, SEEK_CUR) != 0)
+    return FALSE;
+  if (fread (data, 1, 4, moovrf->file) != 4)
+    return FALSE;
+
+  /* advance the rest of tkhd */
+  fseek (moovrf->file, 68, SEEK_CUR);
+
+  trakrd->trak_id = GST_READ_UINT32_BE (data);
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_stbl (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint32 size;
+  guint32 fourcc;
+  guint32 auxsize;
+
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != FOURCC_stbl)
+    return FALSE;
+
+  trakrd->stbl_file_offset = ftell (moovrf->file) - 8;
+  trakrd->stbl_size = size;
+
+  /* skip the stsd */
+  if (!read_atom_header (moovrf->file, &fourcc, &auxsize))
+    return FALSE;
+  if (fourcc != FOURCC_stsd)
+    return FALSE;
+  if (fseek (moovrf->file, auxsize - 8, SEEK_CUR) != 0)
+    return FALSE;
+
+  trakrd->stsd_size = auxsize;
+  trakrd->post_stsd_offset = ftell (moovrf->file);
+
+  /* as this is the last atom we parse, we don't skip forward */
+
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_minf (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint32 size;
+  guint32 fourcc;
+  guint32 auxsize;
+
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != FOURCC_minf)
+    return FALSE;
+
+  trakrd->minf_file_offset = ftell (moovrf->file) - 8;
+  trakrd->minf_size = size;
+
+  /* skip either of vmhd, smhd, hmhd that might follow */
+  if (!read_atom_header (moovrf->file, &fourcc, &auxsize))
+    return FALSE;
+  if (fourcc != FOURCC_vmhd && fourcc != FOURCC_smhd && fourcc != FOURCC_hmhd &&
+      fourcc != FOURCC_gmhd)
+    return FALSE;
+  if (fseek (moovrf->file, auxsize - 8, SEEK_CUR))
+    return FALSE;
+
+  /* skip a possible hdlr and the following dinf */
+  if (!read_atom_header (moovrf->file, &fourcc, &auxsize))
+    return FALSE;
+  if (fourcc == FOURCC_hdlr) {
+    if (fseek (moovrf->file, auxsize - 8, SEEK_CUR))
+      return FALSE;
+    if (!read_atom_header (moovrf->file, &fourcc, &auxsize))
+      return FALSE;
+  }
+  if (fourcc != FOURCC_dinf)
+    return FALSE;
+  if (fseek (moovrf->file, auxsize - 8, SEEK_CUR))
+    return FALSE;
+
+  /* now we are ready to read the stbl */
+  if (!moov_recov_parse_stbl (moovrf, trakrd))
+    return FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_mdhd (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint32 size;
+  guint32 fourcc;
+  guint8 data[4];
+
+  /* make sure we are on a tkhd atom */
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != FOURCC_mdhd)
+    return FALSE;
+
+  trakrd->mdhd_file_offset = ftell (moovrf->file) - 8;
+
+  /* get the timescale */
+  if (fseek (moovrf->file, 12, SEEK_CUR) != 0)
+    return FALSE;
+  if (fread (data, 1, 4, moovrf->file) != 4)
+    return FALSE;
+  trakrd->timescale = GST_READ_UINT32_BE (data);
+  if (fseek (moovrf->file, 8, SEEK_CUR) != 0)
+    return FALSE;
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_mdia (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint32 size;
+  guint32 fourcc;
+
+  /* make sure we are on a tkhd atom */
+  if (!read_atom_header (moovrf->file, &fourcc, &size))
+    return FALSE;
+  if (fourcc != FOURCC_mdia)
+    return FALSE;
+
+  trakrd->mdia_file_offset = ftell (moovrf->file) - 8;
+  trakrd->mdia_size = size;
+
+  if (!moov_recov_parse_mdhd (moovrf, trakrd))
+    return FALSE;
+
+  if (!skip_atom (moovrf, FOURCC_hdlr))
+    return FALSE;
+  if (!moov_recov_parse_minf (moovrf, trakrd))
+    return FALSE;
+  return TRUE;
+}
+
+static gboolean
+moov_recov_parse_trak (MoovRecovFile * moovrf, TrakRecovData * trakrd)
+{
+  guint64 offset;
+  guint32 size;
+  guint32 fourcc;
+
+  offset = ftell (moovrf->file);
+  if (offset == -1) {
+    return FALSE;
+  }
+
+  /* make sure we are on a trak atom */
+  if (!read_atom_header (moovrf->file, &fourcc, &size)) {
+    return FALSE;
+  }
+  if (fourcc != FOURCC_trak) {
+    return FALSE;
+  }
+  trakrd->trak_size = size;
+
+  /* now we should have a trak header 'tkhd' */
+  if (!moov_recov_parse_tkhd (moovrf, trakrd))
+    return FALSE;
+
+  /* FIXME add edts handling here and in qtmux, as this is only detected
+   * after buffers start flowing */
+
+  if (!moov_recov_parse_mdia (moovrf, trakrd))
+    return FALSE;
+
+  trakrd->file_offset = offset;
+  /* position after the trak */
+  return fseek (moovrf->file, (long int) offset + size, SEEK_SET) == 0;
+}
+
+MoovRecovFile *
+moov_recov_file_create (FILE * file, GError ** err)
+{
+  gint i;
+  MoovRecovFile *moovrf = g_new0 (MoovRecovFile, 1);
+
+  g_return_val_if_fail (file != NULL, NULL);
+
+  moovrf->file = file;
+
+  /* look for ftyp and prefix at the start */
+  if (!moov_recov_file_parse_prefix (moovrf)) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+        "Error while parsing prefix atoms");
+    goto fail;
+  }
+
+  /* parse the mvhd */
+  if (!moov_recov_file_parse_mvhd (moovrf)) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+        "Error while parsing mvhd atom");
+    goto fail;
+  }
+
+  if (!moov_recov_parse_moov_timescale (moovrf)) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+        "Error while parsing timescale");
+    goto fail;
+  }
+  if (!moov_recov_parse_num_traks (moovrf)) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+        "Error while parsing parsing number of traks");
+    goto fail;
+  }
+
+  /* init the traks */
+  moovrf->traks_rd = g_new0 (TrakRecovData, moovrf->num_traks);
+  for (i = 0; i < moovrf->num_traks; i++) {
+    atom_stbl_init (&(moovrf->traks_rd[i].stbl));
+  }
+  for (i = 0; i < moovrf->num_traks; i++) {
+    if (!moov_recov_parse_trak (moovrf, &(moovrf->traks_rd[i]))) {
+      g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+          "Error while parsing trak atom");
+      goto fail;
+    }
+  }
+
+  return moovrf;
+
+fail:
+  moov_recov_file_free (moovrf);
+  return NULL;
+}
+
+void
+moov_recov_file_free (MoovRecovFile * moovrf)
+{
+  gint i;
+  fclose (moovrf->file);
+  if (moovrf->traks_rd) {
+    for (i = 0; i < moovrf->num_traks; i++) {
+      atom_stbl_clear (&(moovrf->traks_rd[i].stbl));
+    }
+    g_free (moovrf->traks_rd);
+  }
+  g_free (moovrf);
+}
+
+static gboolean
+moov_recov_parse_buffer_entry (MoovRecovFile * moovrf, TrakBufferEntryInfo * b)
+{
+  guint8 data[TRAK_BUFFER_ENTRY_INFO_SIZE];
+  gint read;
+
+  read = fread (data, 1, TRAK_BUFFER_ENTRY_INFO_SIZE, moovrf->file);
+  if (read != TRAK_BUFFER_ENTRY_INFO_SIZE)
+    return FALSE;
+
+  b->track_id = GST_READ_UINT32_BE (data);
+  b->nsamples = GST_READ_UINT32_BE (data + 4);
+  b->delta = GST_READ_UINT32_BE (data + 8);
+  b->size = GST_READ_UINT32_BE (data + 12);
+  b->chunk_offset = GST_READ_UINT64_BE (data + 16);
+  b->sync = data[24] != 0;
+  b->do_pts = data[25] != 0;
+  b->pts_offset = GST_READ_UINT64_BE (data + 26);
+  return TRUE;
+}
+
+static gboolean
+mdat_recov_add_sample (MdatRecovFile * mdatrf, guint32 size)
+{
+  /* test if this data exists */
+  if (mdatrf->mdat_size - mdatrf->mdat_header_size + size > mdatrf->data_size)
+    return FALSE;
+
+  mdatrf->mdat_size += size;
+  return TRUE;
+}
+
+static TrakRecovData *
+moov_recov_get_trak (MoovRecovFile * moovrf, guint32 id)
+{
+  gint i;
+  for (i = 0; i < moovrf->num_traks; i++) {
+    if (moovrf->traks_rd[i].trak_id == id)
+      return &(moovrf->traks_rd[i]);
+  }
+  return NULL;
+}
+
+static void
+trak_recov_data_add_sample (TrakRecovData * trak, TrakBufferEntryInfo * b)
+{
+  trak->duration += b->nsamples * b->delta;
+  atom_stbl_add_samples (&trak->stbl, b->nsamples, b->delta, b->size,
+      b->chunk_offset, b->sync, b->pts_offset);
+}
+
+/**
+ * Parses the buffer entries in the MoovRecovFile and matches the inputs
+ * with the data in the MdatRecovFile. Whenever a buffer entry of that
+ * represents 'x' bytes of data, the same amount of data is 'validated' in
+ * the MdatRecovFile and will be inluded in the generated moovie file.
+ */
+gboolean
+moov_recov_parse_buffers (MoovRecovFile * moovrf, MdatRecovFile * mdatrf,
+    GError ** err)
+{
+  TrakBufferEntryInfo entry;
+  TrakRecovData *trak;
+
+  /* we assume both moovrf and mdatrf are at the starting points of their
+   * data reading */
+  while (moov_recov_parse_buffer_entry (moovrf, &entry)) {
+    /* be sure we still have this data in mdat */
+    trak = moov_recov_get_trak (moovrf, entry.track_id);
+    if (trak == NULL) {
+      g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_PARSING,
+          "Invalid trak id found in buffer entry");
+      return FALSE;
+    }
+    if (!mdat_recov_add_sample (mdatrf, entry.size))
+      break;
+    trak_recov_data_add_sample (trak, &entry);
+  }
+  return TRUE;
+}
+
+static guint32
+trak_recov_data_get_trak_atom_size (TrakRecovData * trak)
+{
+  AtomSTBL *stbl = &trak->stbl;
+  guint64 offset;
+
+  /* write out our stbl child atoms */
+  offset = 0;
+
+  if (!atom_stts_copy_data (&stbl->stts, NULL, NULL, &offset)) {
+    goto fail;
+  }
+  if (atom_array_get_len (&stbl->stss.entries) > 0) {
+    if (!atom_stss_copy_data (&stbl->stss, NULL, NULL, &offset)) {
+      goto fail;
+    }
+  }
+  if (!atom_stsc_copy_data (&stbl->stsc, NULL, NULL, &offset)) {
+    goto fail;
+  }
+  if (!atom_stsz_copy_data (&stbl->stsz, NULL, NULL, &offset)) {
+    goto fail;
+  }
+  if (stbl->ctts) {
+    if (!atom_ctts_copy_data (stbl->ctts, NULL, NULL, &offset)) {
+      goto fail;
+    }
+  }
+  if (!atom_stco64_copy_data (&stbl->stco64, NULL, NULL, &offset)) {
+    goto fail;
+  }
+
+  return trak->trak_size + ((trak->stsd_size + offset + 8) - trak->stbl_size);
+
+fail:
+  return 0;
+}
+
+static guint8 *
+moov_recov_get_stbl_children_data (MoovRecovFile * moovrf, TrakRecovData * trak,
+    guint64 * p_size)
+{
+  AtomSTBL *stbl = &trak->stbl;
+  guint8 *buffer;
+  guint64 size;
+  guint64 offset;
+
+  /* write out our stbl child atoms
+   *
+   * Use 1MB as a starting size, *_copy_data functions
+   * will grow the buffer if needed.
+   */
+  size = 1024 * 1024;
+  buffer = g_malloc0 (size);
+  offset = 0;
+
+  if (!atom_stts_copy_data (&stbl->stts, &buffer, &size, &offset)) {
+    goto fail;
+  }
+  if (atom_array_get_len (&stbl->stss.entries) > 0) {
+    if (!atom_stss_copy_data (&stbl->stss, &buffer, &size, &offset)) {
+      goto fail;
+    }
+  }
+  if (!atom_stsc_copy_data (&stbl->stsc, &buffer, &size, &offset)) {
+    goto fail;
+  }
+  if (!atom_stsz_copy_data (&stbl->stsz, &buffer, &size, &offset)) {
+    goto fail;
+  }
+  if (stbl->ctts) {
+    if (!atom_ctts_copy_data (stbl->ctts, &buffer, &size, &offset)) {
+      goto fail;
+    }
+  }
+  if (!atom_stco64_copy_data (&stbl->stco64, &buffer, &size, &offset)) {
+    goto fail;
+  }
+  *p_size = offset;
+  return buffer;
+
+fail:
+  g_free (buffer);
+  return NULL;
+}
+
+gboolean
+moov_recov_write_file (MoovRecovFile * moovrf, MdatRecovFile * mdatrf,
+    FILE * outf, GError ** err)
+{
+  guint8 auxdata[16];
+  guint8 *data = NULL;
+  guint8 *prefix_data = NULL;
+  guint8 *mvhd_data = NULL;
+  guint8 *trak_data = NULL;
+  guint32 moov_size = 0;
+  gint i;
+  guint64 stbl_children_size = 0;
+  guint8 *stbl_children = NULL;
+  guint32 longest_duration = 0;
+  guint16 version;
+
+  /* check the version */
+  if (fseek (moovrf->file, 0, SEEK_SET) != 0) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+        "Failed to seek to the start of the moov recovery file");
+    goto fail;
+  }
+  if (fread (auxdata, 1, 2, moovrf->file) != 2) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+        "Failed to read version from file");
+  }
+
+  version = GST_READ_UINT16_BE (auxdata);
+  if (version != ATOMS_RECOV_FILE_VERSION) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_VERSION,
+        "Input file version (%u) is not supported in this version (%u)",
+        version, ATOMS_RECOV_FILE_VERSION);
+    return FALSE;
+  }
+
+  /* write the ftyp */
+  prefix_data = g_malloc (moovrf->prefix_size);
+  if (fread (prefix_data, 1, moovrf->prefix_size,
+          moovrf->file) != moovrf->prefix_size) {
+    g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+        "Failed to read the ftyp atom from file");
+    goto fail;
+  }
+  if (fwrite (prefix_data, 1, moovrf->prefix_size, outf) != moovrf->prefix_size) {
+    ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+    goto fail;
+  }
+  g_free (prefix_data);
+  prefix_data = NULL;
+
+  /* need to calculate the moov size beforehand to add the offset to
+   * chunk offset entries */
+  moov_size += moovrf->mvhd_size + 8;   /* mvhd + moov size + fourcc */
+  for (i = 0; i < moovrf->num_traks; i++) {
+    TrakRecovData *trak = &(moovrf->traks_rd[i]);
+    guint32 duration;           /* in moov's timescale */
+    guint32 trak_size;
+
+    /* convert trak duration to moov's duration */
+    duration = gst_util_uint64_scale_round (trak->duration, moovrf->timescale,
+        trak->timescale);
+
+    if (duration > longest_duration)
+      longest_duration = duration;
+    trak_size = trak_recov_data_get_trak_atom_size (trak);
+    if (trak_size == 0) {
+      g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_GENERIC,
+          "Failed to estimate trak atom size");
+      goto fail;
+    }
+    moov_size += trak_size;
+  }
+
+  /* add chunks offsets */
+  for (i = 0; i < moovrf->num_traks; i++) {
+    TrakRecovData *trak = &(moovrf->traks_rd[i]);
+    /* 16 for the mdat header */
+    gint64 offset = moov_size + ftell (outf) + 16;
+    atom_stco64_chunks_add_offset (&trak->stbl.stco64, offset);
+  }
+
+  /* write the moov */
+  GST_WRITE_UINT32_BE (auxdata, moov_size);
+  GST_WRITE_UINT32_LE (auxdata + 4, FOURCC_moov);
+  if (fwrite (auxdata, 1, 8, outf) != 8) {
+    ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+    goto fail;
+  }
+
+  /* write the mvhd */
+  mvhd_data = g_malloc (moovrf->mvhd_size);
+  if (fseek (moovrf->file, moovrf->mvhd_pos, SEEK_SET) != 0)
+    goto fail;
+  if (fread (mvhd_data, 1, moovrf->mvhd_size,
+          moovrf->file) != moovrf->mvhd_size)
+    goto fail;
+  GST_WRITE_UINT32_BE (mvhd_data + 20, moovrf->timescale);
+  GST_WRITE_UINT32_BE (mvhd_data + 24, longest_duration);
+  if (fwrite (mvhd_data, 1, moovrf->mvhd_size, outf) != moovrf->mvhd_size) {
+    ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+    goto fail;
+  }
+  g_free (mvhd_data);
+  mvhd_data = NULL;
+
+  /* write the traks, this is the tough part because we need to update:
+   * - stbl atom
+   * - sizes of atoms from stbl to trak
+   * - trak duration
+   */
+  for (i = 0; i < moovrf->num_traks; i++) {
+    TrakRecovData *trak = &(moovrf->traks_rd[i]);
+    guint trak_data_size;
+    guint32 stbl_new_size;
+    guint32 minf_new_size;
+    guint32 mdia_new_size;
+    guint32 trak_new_size;
+    guint32 size_diff;
+    guint32 duration;           /* in moov's timescale */
+
+    /* convert trak duration to moov's duration */
+    duration = gst_util_uint64_scale_round (trak->duration, moovrf->timescale,
+        trak->timescale);
+
+    stbl_children = moov_recov_get_stbl_children_data (moovrf, trak,
+        &stbl_children_size);
+    if (stbl_children == NULL)
+      goto fail;
+
+    /* calc the new size of the atoms from stbl to trak in the atoms tree */
+    stbl_new_size = trak->stsd_size + stbl_children_size + 8;
+    size_diff = stbl_new_size - trak->stbl_size;
+    minf_new_size = trak->minf_size + size_diff;
+    mdia_new_size = trak->mdia_size + size_diff;
+    trak_new_size = trak->trak_size + size_diff;
+
+    if (fseek (moovrf->file, trak->file_offset, SEEK_SET) != 0)
+      goto fail;
+    trak_data_size = trak->post_stsd_offset - trak->file_offset;
+    trak_data = g_malloc (trak_data_size);
+    if (fread (trak_data, 1, trak_data_size, moovrf->file) != trak_data_size) {
+      goto fail;
+    }
+    /* update the size values in those read atoms before writing */
+    GST_WRITE_UINT32_BE (trak_data, trak_new_size);
+    GST_WRITE_UINT32_BE (trak_data + (trak->mdia_file_offset -
+            trak->file_offset), mdia_new_size);
+    GST_WRITE_UINT32_BE (trak_data + (trak->minf_file_offset -
+            trak->file_offset), minf_new_size);
+    GST_WRITE_UINT32_BE (trak_data + (trak->stbl_file_offset -
+            trak->file_offset), stbl_new_size);
+
+    /* update duration values in tkhd and mdhd */
+    GST_WRITE_UINT32_BE (trak_data + (trak->tkhd_file_offset -
+            trak->file_offset) + 28, duration);
+    GST_WRITE_UINT32_BE (trak_data + (trak->mdhd_file_offset -
+            trak->file_offset) + 24, trak->duration);
+
+    if (fwrite (trak_data, 1, trak_data_size, outf) != trak_data_size) {
+      ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+      goto fail;
+    }
+    if (fwrite (stbl_children, 1, stbl_children_size, outf) !=
+        stbl_children_size) {
+      ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+      goto fail;
+    }
+    g_free (trak_data);
+    trak_data = NULL;
+    g_free (stbl_children);
+    stbl_children = NULL;
+  }
+
+  /* write the mdat */
+  /* write the header first */
+  GST_WRITE_UINT32_BE (auxdata, 1);
+  GST_WRITE_UINT32_LE (auxdata + 4, FOURCC_mdat);
+  GST_WRITE_UINT64_BE (auxdata + 8, mdatrf->mdat_size);
+  if (fwrite (auxdata, 1, 16, outf) != 16) {
+    ATOMS_RECOV_OUTPUT_WRITE_ERROR (err);
+    goto fail;
+  }
+
+  /* now read the mdat data and output to the file */
+  if (fseek (mdatrf->file, mdatrf->mdat_start +
+          (mdatrf->rawfile ? 0 : mdatrf->mdat_header_size), SEEK_SET) != 0)
+    goto fail;
+
+  data = g_malloc (4096);
+  while (!feof (mdatrf->file)) {
+    gint read, write;
+
+    read = fread (data, 1, 4096, mdatrf->file);
+    write = fwrite (data, 1, read, outf);
+
+    if (write != read) {
+      g_set_error (err, ATOMS_RECOV_QUARK, ATOMS_RECOV_ERR_FILE,
+          "Failed to copy data to output file: %s", g_strerror (errno));
+      goto fail;
+    }
+  }
+  g_free (data);
+
+  return TRUE;
+
+fail:
+  g_free (stbl_children);
+  g_free (mvhd_data);
+  g_free (prefix_data);
+  g_free (trak_data);
+  g_free (data);
+  return FALSE;
+}
diff --git a/gst/isomp4/atomsrecovery.h b/gst/isomp4/atomsrecovery.h
new file mode 100644
index 000000000..4dffc48d3
--- /dev/null
+++ b/gst/isomp4/atomsrecovery.h
@@ -0,0 +1,159 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __ATOMS_RECOVERY_H__
+#define __ATOMS_RECOVERY_H__
+
+#include <glib.h>
+#include <string.h>
+#include <stdio.h>
+#include <gst/gst.h>
+
+#include "atoms.h"
+
+/* Version to be incremented each time we decide
+ * to change the file layout */
+#define ATOMS_RECOV_FILE_VERSION          1
+
+#define ATOMS_RECOV_QUARK (g_quark_from_string ("qtmux-atoms-recovery"))
+
+/* gerror error codes */
+#define ATOMS_RECOV_ERR_GENERIC           1
+#define ATOMS_RECOV_ERR_FILE              2
+#define ATOMS_RECOV_ERR_PARSING           3
+#define ATOMS_RECOV_ERR_VERSION           4
+
+/* this struct represents each buffer in a moov file, containing the info
+ * that is placed in the stsd children atoms
+ * Fields should be writen in BE order, and booleans should be writen as
+ * 1byte with 0 for false, anything otherwise */
+#define TRAK_BUFFER_ENTRY_INFO_SIZE 34
+typedef struct
+{
+  guint32   track_id;
+  guint32   nsamples;
+  guint32   delta;
+  guint32   size;
+  guint64   chunk_offset;
+  guint64   pts_offset;
+  gboolean  sync;
+  gboolean  do_pts;
+} TrakBufferEntryInfo;
+
+typedef struct
+{
+  guint32 trak_id;
+  guint32 duration;  /* duration in trak timescale */
+  guint32 timescale; /* trak's timescale */
+
+  guint64 file_offset;
+
+  /* need for later updating duration */
+  guint64 tkhd_file_offset;
+  guint64 mdhd_file_offset;
+
+  /* need these offsets to update size */
+  guint32 trak_size;
+  guint64 mdia_file_offset;
+  guint32 mdia_size;
+  guint64 minf_file_offset;
+  guint32 minf_size;
+  guint64 stbl_file_offset;
+  guint32 stbl_size;
+
+  guint64 post_stsd_offset;
+  guint32 stsd_size;
+
+  /* for storing the samples info */
+  AtomSTBL stbl;
+} TrakRecovData;
+
+typedef struct
+{
+  FILE * file;
+  gboolean rawfile;
+
+  /* results from parsing the input file */
+  guint64   data_size;
+  guint32   mdat_header_size;
+  guint     mdat_start;
+
+  guint64   mdat_size;
+} MdatRecovFile;
+
+typedef struct
+{
+  FILE * file;
+  guint32 timescale;
+
+  guint32 mvhd_pos;
+  guint32 mvhd_size;
+  guint32 prefix_size; /* prefix + ftyp total size */
+
+  gint num_traks;
+  TrakRecovData *traks_rd;
+} MoovRecovFile;
+
+gboolean atoms_recov_write_trak_info      (FILE * f, AtomTRAK * trak);
+gboolean atoms_recov_write_headers        (FILE * f, AtomFTYP * ftyp,
+                                           GstBuffer * prefix, AtomMOOV * moov,
+                                           guint32 timescale,
+                                           guint32 traks_number);
+gboolean atoms_recov_write_trak_samples   (FILE * f, AtomTRAK * trak,
+                                           guint32 nsamples, guint32 delta,
+                                           guint32 size, guint64 chunk_offset,
+                                           gboolean sync, gboolean do_pts,
+                                           gint64 pts_offset);
+
+MdatRecovFile * mdat_recov_file_create   (FILE * file, gboolean datafile,
+                                          GError ** err);
+void            mdat_recov_file_free     (MdatRecovFile * mrf);
+MoovRecovFile * moov_recov_file_create   (FILE * file, GError ** err);
+void            moov_recov_file_free     (MoovRecovFile * moovrf);
+gboolean        moov_recov_parse_buffers (MoovRecovFile * moovrf,
+                                          MdatRecovFile * mdatrf,
+                                          GError ** err);
+gboolean        moov_recov_write_file    (MoovRecovFile * moovrf,
+                                          MdatRecovFile * mdatrf, FILE * outf,
+                                          GError ** err);
+
+#endif /* __ATOMS_RECOVERY_H__ */
diff --git a/gst/isomp4/descriptors.c b/gst/isomp4/descriptors.c
new file mode 100644
index 000000000..e7d5a5d42
--- /dev/null
+++ b/gst/isomp4/descriptors.c
@@ -0,0 +1,457 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#include "descriptors.h"
+
+/*
+ * Some mp4 structures (descriptors) use a coding scheme for
+ * representing its size.
+ * It is grouped in bytes. The 1st bit set to 1 means we need another byte,
+ * 0 otherwise. The remaining 7 bits are the useful values.
+ *
+ * The next set of functions handle those values
+ */
+
+/*
+ * Gets an unsigned integer and packs it into a 'expandable size' format
+ * (as used by mp4 descriptors)
+ * @size: the integer to be parsed
+ * @ptr: the array to place the result
+ * @array_size: the size of ptr array
+ */
+static void
+expandable_size_parse (guint64 size, guint8 * ptr, guint32 array_size)
+{
+  int index = 0;
+
+  memset (ptr, 0, sizeof (array_size));
+  while (size > 0 && index < array_size) {
+    ptr[index++] = (size > 0x7F ? 0x80 : 0x0) | (size & 0x7F);
+    size = size >> 7;
+  }
+}
+
+/*
+ * Gets how many positions in an array holding an 'expandable size'
+ * are really used
+ *
+ * @ptr: the array with the 'expandable size'
+ * @array_size: the size of ptr array
+ *
+ * Returns: the number of really used positions
+ */
+static guint64
+expandable_size_get_length (guint8 * ptr, guint32 array_size)
+{
+  gboolean next = TRUE;
+  guint32 index = 0;
+
+  while (next && index < array_size) {
+    next = ((ptr[index] & 0x80) == 1);
+    index++;
+  }
+  return index;
+}
+
+/*
+ * Initializers below
+ */
+
+static void
+desc_base_descriptor_init (BaseDescriptor * bd, guint8 tag, guint32 size)
+{
+  bd->tag = tag;
+  expandable_size_parse (size, bd->size, 4);
+}
+
+static void
+desc_dec_specific_info_init (DecoderSpecificInfoDescriptor * dsid)
+{
+  desc_base_descriptor_init (&dsid->base, DECODER_SPECIFIC_INFO_TAG, 0);
+  dsid->length = 0;
+  dsid->data = NULL;
+}
+
+DecoderSpecificInfoDescriptor *
+desc_dec_specific_info_new (void)
+{
+  DecoderSpecificInfoDescriptor *desc =
+      g_new0 (DecoderSpecificInfoDescriptor, 1);
+  desc_dec_specific_info_init (desc);
+  return desc;
+}
+
+static void
+desc_dec_conf_desc_init (DecoderConfigDescriptor * dcd)
+{
+  desc_base_descriptor_init (&dcd->base, DECODER_CONFIG_DESC_TAG, 0);
+  dcd->dec_specific_info = NULL;
+}
+
+static void
+desc_sl_conf_desc_init (SLConfigDescriptor * sl)
+{
+  desc_base_descriptor_init (&sl->base, SL_CONFIG_DESC_TAG, 0);
+  sl->predefined = 0x2;
+}
+
+void
+desc_es_init (ESDescriptor * es)
+{
+  desc_base_descriptor_init (&es->base, ES_DESCRIPTOR_TAG, 0);
+
+  es->id = 0;
+  es->flags = 0;
+  es->depends_on_es_id = 0;
+  es->ocr_es_id = 0;
+  es->url_length = 0;
+  es->url_string = NULL;
+
+  desc_dec_conf_desc_init (&es->dec_conf_desc);
+  desc_sl_conf_desc_init (&es->sl_conf_desc);
+}
+
+ESDescriptor *
+desc_es_descriptor_new (void)
+{
+  ESDescriptor *es = g_new0 (ESDescriptor, 1);
+
+  desc_es_init (es);
+  return es;
+}
+
+/*
+ * Deinitializers/Destructors below
+ */
+
+static void
+desc_base_descriptor_clear (BaseDescriptor * base)
+{
+}
+
+void
+desc_dec_specific_info_free (DecoderSpecificInfoDescriptor * dsid)
+{
+  desc_base_descriptor_clear (&dsid->base);
+  if (dsid->data) {
+    g_free (dsid->data);
+    dsid->data = NULL;
+  }
+  g_free (dsid);
+}
+
+static void
+desc_dec_conf_desc_clear (DecoderConfigDescriptor * dec)
+{
+  desc_base_descriptor_clear (&dec->base);
+  if (dec->dec_specific_info) {
+    desc_dec_specific_info_free (dec->dec_specific_info);
+  }
+}
+
+static void
+desc_sl_config_descriptor_clear (SLConfigDescriptor * sl)
+{
+  desc_base_descriptor_clear (&sl->base);
+}
+
+void
+desc_es_descriptor_clear (ESDescriptor * es)
+{
+  desc_base_descriptor_clear (&es->base);
+  if (es->url_string) {
+    g_free (es->url_string);
+    es->url_string = NULL;
+  }
+  desc_dec_conf_desc_clear (&es->dec_conf_desc);
+  desc_sl_config_descriptor_clear (&es->sl_conf_desc);
+}
+
+/*
+ * Size handling functions below
+ */
+
+void
+desc_dec_specific_info_alloc_data (DecoderSpecificInfoDescriptor * dsid,
+    guint32 size)
+{
+  if (dsid->data) {
+    g_free (dsid->data);
+  }
+  dsid->data = g_new0 (guint8, size);
+  dsid->length = size;
+}
+
+static void
+desc_base_descriptor_set_size (BaseDescriptor * bd, guint32 size)
+{
+  expandable_size_parse (size, bd->size, 4);
+}
+
+static guint64
+desc_base_descriptor_get_size (BaseDescriptor * bd)
+{
+  guint64 size = 0;
+
+  size += sizeof (guint8);
+  size += expandable_size_get_length (bd->size, 4) * sizeof (guint8);
+  return size;
+}
+
+static guint64
+desc_sl_config_descriptor_get_size (SLConfigDescriptor * sl_desc)
+{
+  guint64 size = 0;
+  guint64 extra_size = 0;
+
+  size += desc_base_descriptor_get_size (&sl_desc->base);
+  /* predefined */
+  extra_size += sizeof (guint8);
+
+  desc_base_descriptor_set_size (&sl_desc->base, extra_size);
+
+  return size + extra_size;
+}
+
+static guint64
+desc_dec_specific_info_get_size (DecoderSpecificInfoDescriptor * dsid)
+{
+  guint64 size = 0;
+  guint64 extra_size = 0;
+
+  size += desc_base_descriptor_get_size (&dsid->base);
+  extra_size += sizeof (guint8) * dsid->length;
+  desc_base_descriptor_set_size (&dsid->base, extra_size);
+  return size + extra_size;
+}
+
+static guint64
+desc_dec_config_descriptor_get_size (DecoderConfigDescriptor * dec_desc)
+{
+  guint64 size = 0;
+  guint64 extra_size = 0;
+
+  size += desc_base_descriptor_get_size (&dec_desc->base);
+  /* object type */
+  extra_size += sizeof (guint8);
+  /* stream type */
+  extra_size += sizeof (guint8);
+  /* buffer size */
+  extra_size += sizeof (guint8) * 3;
+  /* max bitrate */
+  extra_size += sizeof (guint32);
+  /* avg bitrate */
+  extra_size += sizeof (guint32);
+  if (dec_desc->dec_specific_info) {
+    extra_size += desc_dec_specific_info_get_size (dec_desc->dec_specific_info);
+  }
+
+  desc_base_descriptor_set_size (&dec_desc->base, extra_size);
+  return size + extra_size;
+}
+
+static guint64
+desc_es_descriptor_get_size (ESDescriptor * es)
+{
+  guint64 size = 0;
+  guint64 extra_size = 0;
+
+  size += desc_base_descriptor_get_size (&es->base);
+  /* id */
+  extra_size += sizeof (guint16);
+  /* flags */
+  extra_size += sizeof (guint8);
+  /* depends_on_es_id */
+  if (es->flags & 0x80) {
+    extra_size += sizeof (guint16);
+  }
+  if (es->flags & 0x40) {
+    /* url_length */
+    extra_size += sizeof (guint8);
+    /* url */
+    extra_size += sizeof (gchar) * es->url_length;
+  }
+  if (es->flags & 0x20) {
+    /* ocr_es_id */
+    extra_size += sizeof (guint16);
+  }
+
+  extra_size += desc_dec_config_descriptor_get_size (&es->dec_conf_desc);
+  extra_size += desc_sl_config_descriptor_get_size (&es->sl_conf_desc);
+
+  desc_base_descriptor_set_size (&es->base, extra_size);
+
+  return size + extra_size;
+}
+
+static gboolean
+desc_es_descriptor_check_stream_dependency (ESDescriptor * es)
+{
+  return es->flags & 0x80;
+}
+
+static gboolean
+desc_es_descriptor_check_url_flag (ESDescriptor * es)
+{
+  return es->flags & 0x40;
+}
+
+static gboolean
+desc_es_descriptor_check_ocr (ESDescriptor * es)
+{
+  return es->flags & 0x20;
+}
+
+/* Copy/Serializations Functions below */
+
+static guint64
+desc_base_descriptor_copy_data (BaseDescriptor * desc, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  prop_copy_uint8 (desc->tag, buffer, size, offset);
+  prop_copy_uint8_array (desc->size, expandable_size_get_length (desc->size, 4),
+      buffer, size, offset);
+  return original_offset - *offset;
+}
+
+static guint64
+desc_sl_config_descriptor_copy_data (SLConfigDescriptor * desc,
+    guint8 ** buffer, guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
+    return 0;
+  }
+  /* predefined attribute */
+  prop_copy_uint8 (desc->predefined, buffer, size, offset);
+
+  return *offset - original_offset;
+}
+
+static guint64
+desc_dec_specific_info_copy_data (DecoderSpecificInfoDescriptor * desc,
+    guint8 ** buffer, guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
+    return 0;
+  }
+  prop_copy_uint8_array (desc->data, desc->length, buffer, size, offset);
+
+  return *offset - original_offset;
+}
+
+static guint64
+desc_dec_config_descriptor_copy_data (DecoderConfigDescriptor * desc,
+    guint8 ** buffer, guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
+    return 0;
+  }
+
+  prop_copy_uint8 (desc->object_type, buffer, size, offset);
+
+  prop_copy_uint8 (desc->stream_type, buffer, size, offset);
+  prop_copy_uint8_array (desc->buffer_size_DB, 3, buffer, size, offset);
+
+  prop_copy_uint32 (desc->max_bitrate, buffer, size, offset);
+  prop_copy_uint32 (desc->avg_bitrate, buffer, size, offset);
+
+  if (desc->dec_specific_info) {
+    if (!desc_dec_specific_info_copy_data (desc->dec_specific_info, buffer,
+            size, offset)) {
+      return 0;
+    }
+  }
+
+  return *offset - original_offset;
+}
+
+guint64
+desc_es_descriptor_copy_data (ESDescriptor * desc, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  /* must call this twice to have size fields of all contained descriptors set
+   * correctly, and to have the size of the size fields taken into account */
+  desc_es_descriptor_get_size (desc);
+  desc_es_descriptor_get_size (desc);
+
+  if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
+    return 0;
+  }
+  /* id and flags */
+  prop_copy_uint16 (desc->id, buffer, size, offset);
+  prop_copy_uint8 (desc->flags, buffer, size, offset);
+
+  if (desc_es_descriptor_check_stream_dependency (desc)) {
+    prop_copy_uint16 (desc->depends_on_es_id, buffer, size, offset);
+  }
+
+  if (desc_es_descriptor_check_url_flag (desc)) {
+    prop_copy_size_string (desc->url_string, desc->url_length, buffer, size,
+        offset);
+  }
+
+  if (desc_es_descriptor_check_ocr (desc)) {
+    prop_copy_uint16 (desc->ocr_es_id, buffer, size, offset);
+  }
+
+  if (!desc_dec_config_descriptor_copy_data (&desc->dec_conf_desc, buffer, size,
+          offset)) {
+    return 0;
+  }
+
+  if (!desc_sl_config_descriptor_copy_data (&desc->sl_conf_desc, buffer, size,
+          offset)) {
+    return 0;
+  }
+
+  return *offset - original_offset;
+}
diff --git a/gst/isomp4/descriptors.h b/gst/isomp4/descriptors.h
new file mode 100644
index 000000000..cc633a305
--- /dev/null
+++ b/gst/isomp4/descriptors.h
@@ -0,0 +1,151 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __DESCRIPTORS_H__
+#define __DESCRIPTORS_H__
+
+#include <glib.h>
+#include <string.h>
+#include "properties.h"
+
+/*
+ * Tags for descriptor (each kind is represented by a number, instead of fourcc as in atoms)
+ */
+#define OBJECT_DESC_TAG            0x01
+#define INIT_OBJECT_DESC_TAG       0x02
+#define ES_DESCRIPTOR_TAG          0x03
+#define DECODER_CONFIG_DESC_TAG    0x04
+#define DECODER_SPECIFIC_INFO_TAG  0x05
+#define SL_CONFIG_DESC_TAG         0x06
+#define ES_ID_INC_TAG              0x0E
+#define MP4_INIT_OBJECT_DESC_TAG   0x10
+
+#define ESDS_OBJECT_TYPE_MPEG1_P3       0x6B
+#define ESDS_OBJECT_TYPE_MPEG2_P7_MAIN  0x66
+#define ESDS_OBJECT_TYPE_MPEG4_P7_LC    0x67
+#define ESDS_OBJECT_TYPE_MPEG4_P7_SSR   0x68
+#define ESDS_OBJECT_TYPE_MPEG4_P2       0x20
+#define ESDS_OBJECT_TYPE_MPEG4_P3       0x40
+
+#define ESDS_STREAM_TYPE_VISUAL         0x04
+#define ESDS_STREAM_TYPE_AUDIO          0x05
+
+
+typedef struct _BaseDescriptor
+{
+  guint8 tag;
+  /* the first bit of each byte indicates if the next byte should be used */
+  guint8 size[4];
+} BaseDescriptor;
+
+typedef struct _SLConfigDescriptor
+{
+  BaseDescriptor base;
+
+  guint8 predefined;              /* everything is supposed predefined */
+} SLConfigDescriptor;
+
+typedef struct _DecoderSpecificInfoDescriptor
+{
+  BaseDescriptor base;
+  guint32 length;
+  guint8 *data;
+} DecoderSpecificInfoDescriptor;
+
+typedef struct _DecoderConfigDescriptor {
+  BaseDescriptor base;
+
+  guint8 object_type;
+
+  /* following are condensed into streamType:
+   * bit(6) streamType;
+   * bit(1) upStream;
+   * const bit(1) reserved=1;
+  */
+  guint8 stream_type;
+
+  guint8 buffer_size_DB[3];
+  guint32 max_bitrate;
+  guint32 avg_bitrate;
+
+  DecoderSpecificInfoDescriptor *dec_specific_info;
+} DecoderConfigDescriptor;
+
+typedef struct _ESDescriptor
+{
+  BaseDescriptor base;
+
+  guint16 id;
+
+  /* flags contains the following:
+   * bit(1) streamDependenceFlag;
+   * bit(1) URL_Flag;
+   * bit(1) OCRstreamFlag;
+   * bit(5) streamPriority;
+   */
+  guint8 flags;
+
+  guint16 depends_on_es_id;
+  guint8 url_length;              /* only if URL_flag is set */
+  guint8 *url_string;             /* size is url_length */
+
+  guint16 ocr_es_id;              /* only if OCRstreamFlag is set */
+
+  DecoderConfigDescriptor dec_conf_desc;
+  SLConfigDescriptor sl_conf_desc;
+
+  /* optional remainder of ESDescriptor is not used */
+} ESDescriptor;
+
+/* --- FUNCTIONS --- */
+void    desc_es_init                               (ESDescriptor *es);
+ESDescriptor *desc_es_descriptor_new               (void);
+guint64 desc_es_descriptor_copy_data               (ESDescriptor *es, guint8 **buffer,
+                                                    guint64 *size, guint64 *offset);
+void    desc_es_descriptor_clear                   (ESDescriptor *es);
+
+DecoderSpecificInfoDescriptor *desc_dec_specific_info_new(void);
+void    desc_dec_specific_info_free                (DecoderSpecificInfoDescriptor *dsid);
+void    desc_dec_specific_info_alloc_data          (DecoderSpecificInfoDescriptor *dsid,
+                                                    guint32 size);
+
+#endif /* __DESCRIPTORS_H__ */
diff --git a/gst/isomp4/fourcc.h b/gst/isomp4/fourcc.h
new file mode 100644
index 000000000..188e20275
--- /dev/null
+++ b/gst/isomp4/fourcc.h
@@ -0,0 +1,243 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+ /*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+
+#ifndef __FOURCC_H__
+#define __FOURCC_H__
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+#define FOURCC_null     0x0
+
+#define FOURCC_moov     GST_MAKE_FOURCC('m','o','o','v')
+#define FOURCC_mvhd     GST_MAKE_FOURCC('m','v','h','d')
+#define FOURCC_clip     GST_MAKE_FOURCC('c','l','i','p')
+#define FOURCC_trak     GST_MAKE_FOURCC('t','r','a','k')
+#define FOURCC_udta     GST_MAKE_FOURCC('u','d','t','a')
+#define FOURCC_ctab     GST_MAKE_FOURCC('c','t','a','b')
+#define FOURCC_tkhd     GST_MAKE_FOURCC('t','k','h','d')
+#define FOURCC_crgn     GST_MAKE_FOURCC('c','r','g','n')
+#define FOURCC_matt     GST_MAKE_FOURCC('m','a','t','t')
+#define FOURCC_kmat     GST_MAKE_FOURCC('k','m','a','t')
+#define FOURCC_edts     GST_MAKE_FOURCC('e','d','t','s')
+#define FOURCC_elst     GST_MAKE_FOURCC('e','l','s','t')
+#define FOURCC_load     GST_MAKE_FOURCC('l','o','a','d')
+#define FOURCC_tref     GST_MAKE_FOURCC('t','r','e','f')
+#define FOURCC_imap     GST_MAKE_FOURCC('i','m','a','p')
+#define FOURCC___in     GST_MAKE_FOURCC(' ',' ','i','n')
+#define FOURCC___ty     GST_MAKE_FOURCC(' ',' ','t','y')
+#define FOURCC_mdia     GST_MAKE_FOURCC('m','d','i','a')
+#define FOURCC_mdhd     GST_MAKE_FOURCC('m','d','h','d')
+#define FOURCC_hdlr     GST_MAKE_FOURCC('h','d','l','r')
+#define FOURCC_dhlr     GST_MAKE_FOURCC('d','h','l','r')
+#define FOURCC_mhlr     GST_MAKE_FOURCC('m','h','l','r')
+#define FOURCC_minf     GST_MAKE_FOURCC('m','i','n','f')
+#define FOURCC_mdir     GST_MAKE_FOURCC('m','d','i','r')
+#define FOURCC_vmhd     GST_MAKE_FOURCC('v','m','h','d')
+#define FOURCC_smhd     GST_MAKE_FOURCC('s','m','h','d')
+#define FOURCC_gmhd     GST_MAKE_FOURCC('g','m','h','d')
+#define FOURCC_hmhd     GST_MAKE_FOURCC('h','m','h','d')
+#define FOURCC_gmin     GST_MAKE_FOURCC('g','m','i','n')
+#define FOURCC_dinf     GST_MAKE_FOURCC('d','i','n','f')
+#define FOURCC_dref     GST_MAKE_FOURCC('d','r','e','f')
+#define FOURCC_stbl     GST_MAKE_FOURCC('s','t','b','l')
+#define FOURCC_stsd     GST_MAKE_FOURCC('s','t','s','d')
+#define FOURCC_stts     GST_MAKE_FOURCC('s','t','t','s')
+#define FOURCC_stss     GST_MAKE_FOURCC('s','t','s','s')
+#define FOURCC_stsc     GST_MAKE_FOURCC('s','t','s','c')
+#define FOURCC_stsz     GST_MAKE_FOURCC('s','t','s','z')
+#define FOURCC_stco     GST_MAKE_FOURCC('s','t','c','o')
+#define FOURCC_vide     GST_MAKE_FOURCC('v','i','d','e')
+#define FOURCC_soun     GST_MAKE_FOURCC('s','o','u','n')
+#define FOURCC_strm     GST_MAKE_FOURCC('s','t','r','m')
+#define FOURCC_rtsp     GST_MAKE_FOURCC('r','t','s','p')
+#define FOURCC_co64     GST_MAKE_FOURCC('c','o','6','4')
+#define FOURCC_cmov     GST_MAKE_FOURCC('c','m','o','v')
+#define FOURCC_dcom     GST_MAKE_FOURCC('d','c','o','m')
+#define FOURCC_cmvd     GST_MAKE_FOURCC('c','m','v','d')
+#define FOURCC_hint     GST_MAKE_FOURCC('h','i','n','t')
+#define FOURCC_mp4a     GST_MAKE_FOURCC('m','p','4','a')
+#define FOURCC__mp3     GST_MAKE_FOURCC('.','m','p','3')
+#define FOURCC_mp4s	GST_MAKE_FOURCC('m','p','4','s')
+#define FOURCC_mp4v     GST_MAKE_FOURCC('m','p','4','v')
+#define FOURCC_2vuy     GST_MAKE_FOURCC('2','v','u','y')
+#define FOURCC_wave     GST_MAKE_FOURCC('w','a','v','e')
+#define FOURCC_appl     GST_MAKE_FOURCC('a','p','p','l')
+#define FOURCC_esds     GST_MAKE_FOURCC('e','s','d','s')
+#define FOURCC_pasp     GST_MAKE_FOURCC('p','a','s','p')
+#define FOURCC_hnti     GST_MAKE_FOURCC('h','n','t','i')
+#define FOURCC_rtp_     GST_MAKE_FOURCC('r','t','p',' ')
+#define FOURCC_sdp_     GST_MAKE_FOURCC('s','d','p',' ')
+#define FOURCC_meta     GST_MAKE_FOURCC('m','e','t','a')
+#define FOURCC_ilst     GST_MAKE_FOURCC('i','l','s','t')
+#define FOURCC__nam     GST_MAKE_FOURCC(0xa9,'n','a','m')
+#define FOURCC__ART     GST_MAKE_FOURCC(0xa9,'A','R','T')
+#define FOURCC_aART     GST_MAKE_FOURCC('a','A','R','T')
+#define FOURCC__wrt     GST_MAKE_FOURCC(0xa9,'w','r','t')
+#define FOURCC__grp     GST_MAKE_FOURCC(0xa9,'g','r','p')
+#define FOURCC__alb     GST_MAKE_FOURCC(0xa9,'a','l','b')
+#define FOURCC__day     GST_MAKE_FOURCC(0xa9,'d','a','y')
+#define FOURCC__des     GST_MAKE_FOURCC(0xa9,'d','e','s')
+#define FOURCC__lyr     GST_MAKE_FOURCC(0xa9,'l','y','r')
+#define FOURCC_gnre     GST_MAKE_FOURCC('g','n','r','e')
+#define FOURCC_disc     GST_MAKE_FOURCC('d','i','s','c')
+#define FOURCC_disk     GST_MAKE_FOURCC('d','i','s','k')
+#define FOURCC_trkn     GST_MAKE_FOURCC('t','r','k','n')
+#define FOURCC_cprt     GST_MAKE_FOURCC('c','p','r','t')
+#define FOURCC_covr     GST_MAKE_FOURCC('c','o','v','r')
+#define FOURCC_cpil     GST_MAKE_FOURCC('c','p','i','l')
+#define FOURCC_tmpo     GST_MAKE_FOURCC('t','m','p','o')
+#define FOURCC__too     GST_MAKE_FOURCC(0xa9,'t','o','o')
+#define FOURCC_keyw     GST_MAKE_FOURCC('k','e','y','w')
+#define FOURCC_____     GST_MAKE_FOURCC('-','-','-','-')
+#define FOURCC_free     GST_MAKE_FOURCC('f','r','e','e')
+#define FOURCC_data     GST_MAKE_FOURCC('d','a','t','a')
+#define FOURCC_SVQ3     GST_MAKE_FOURCC('S','V','Q','3')
+#define FOURCC_rmra     GST_MAKE_FOURCC('r','m','r','a')
+#define FOURCC_rmda     GST_MAKE_FOURCC('r','m','d','a')
+#define FOURCC_rdrf     GST_MAKE_FOURCC('r','d','r','f')
+#define FOURCC__gen     GST_MAKE_FOURCC(0xa9, 'g', 'e', 'n')
+#define FOURCC_rmdr     GST_MAKE_FOURCC('r','m','d','r')
+#define FOURCC_rmvc     GST_MAKE_FOURCC('r','m','v','c')
+#define FOURCC_qtim     GST_MAKE_FOURCC('q','t','i','m')
+#define FOURCC_drms     GST_MAKE_FOURCC('d','r','m','s')
+#define FOURCC_avc1     GST_MAKE_FOURCC('a','v','c','1')
+#define FOURCC_h263     GST_MAKE_FOURCC('h','2','6','3')
+#define FOURCC_s263     GST_MAKE_FOURCC('s','2','6','3')
+#define FOURCC_avcC     GST_MAKE_FOURCC('a','v','c','C')
+#define FOURCC_VP31     GST_MAKE_FOURCC('V','P','3','1')
+#define FOURCC_VP80     GST_MAKE_FOURCC('V','P','8','0')
+#define FOURCC_rle_     GST_MAKE_FOURCC('r','l','e',' ')
+#define FOURCC_MAC6     GST_MAKE_FOURCC('M','A','C','6')
+#define FOURCC_MAC3     GST_MAKE_FOURCC('M','A','C','3')
+#define FOURCC_ima4     GST_MAKE_FOURCC('i','m','a','4')
+#define FOURCC_ulaw     GST_MAKE_FOURCC('u','l','a','w')
+#define FOURCC_alaw     GST_MAKE_FOURCC('a','l','a','w')
+#define FOURCC_twos     GST_MAKE_FOURCC('t','w','o','s')
+#define FOURCC_sowt     GST_MAKE_FOURCC('s','o','w','t')
+#define FOURCC_raw_     GST_MAKE_FOURCC('r','a','w',' ')
+#define FOURCC_QDM2     GST_MAKE_FOURCC('Q','D','M','2')
+#define FOURCC_alac     GST_MAKE_FOURCC('a','l','a','c')
+#define FOURCC_samr     GST_MAKE_FOURCC('s','a','m','r')
+#define FOURCC_sawb     GST_MAKE_FOURCC('s','a','w','b')
+#define FOURCC_mdat     GST_MAKE_FOURCC('m','d','a','t')
+#define FOURCC_wide     GST_MAKE_FOURCC('w','i','d','e')
+#define FOURCC_PICT     GST_MAKE_FOURCC('P','I','C','T')
+#define FOURCC_pnot     GST_MAKE_FOURCC('p','n','o','t')
+#define FOURCC_zlib     GST_MAKE_FOURCC('z','l','i','b')
+#define FOURCC_alis     GST_MAKE_FOURCC('a','l','i','s')
+#define FOURCC_url_     GST_MAKE_FOURCC('u','r','l',' ')
+#define FOURCC_frma     GST_MAKE_FOURCC('f','r','m','a')
+#define FOURCC_ctts     GST_MAKE_FOURCC('c','t','t','s')
+#define FOURCC_drac     GST_MAKE_FOURCC('d','r','a','c')
+#define FOURCC_jpeg     GST_MAKE_FOURCC('j','p','e','g')
+#define FOURCC_mjp2     GST_MAKE_FOURCC('m','j','p','2')
+#define FOURCC_jp2h     GST_MAKE_FOURCC('j','p','2','h')
+#define FOURCC_jp2c     GST_MAKE_FOURCC('j','p','2','c')
+#define FOURCC_gama     GST_MAKE_FOURCC('g','a','m','a')
+#define FOURCC_tvsh     GST_MAKE_FOURCC('t','v','s','h')
+#define FOURCC_tven     GST_MAKE_FOURCC('t','v','e','n')
+#define FOURCC_tvsn     GST_MAKE_FOURCC('t','v','s','n')
+#define FOURCC_tves     GST_MAKE_FOURCC('t','v','e','s')
+#define FOURCC_sonm     GST_MAKE_FOURCC('s','o','n','m')
+#define FOURCC_soal     GST_MAKE_FOURCC('s','o','a','l')
+#define FOURCC_soar     GST_MAKE_FOURCC('s','o','a','r')
+#define FOURCC_soaa     GST_MAKE_FOURCC('s','o','a','a')
+#define FOURCC_soco     GST_MAKE_FOURCC('s','o','c','o')
+#define FOURCC_sosn     GST_MAKE_FOURCC('s','o','s','n')
+#define FOURCC_XMP_     GST_MAKE_FOURCC('X','M','P','_')
+#define FOURCC_uuid     GST_MAKE_FOURCC('u','u','i','d')
+
+
+/* SVQ3 fourcc */
+#define FOURCC_SEQH     GST_MAKE_FOURCC('S','E','Q','H')
+#define FOURCC_SMI_     GST_MAKE_FOURCC('S','M','I',' ')
+
+/* fragmented mp4 */
+#define FOURCC_mvex     GST_MAKE_FOURCC('m','v','e','x')
+#define FOURCC_mehd     GST_MAKE_FOURCC('m','e','h','d')
+#define FOURCC_trex     GST_MAKE_FOURCC('t','r','e','x')
+#define FOURCC_mfra     GST_MAKE_FOURCC('m','f','r','a')
+#define FOURCC_moof     GST_MAKE_FOURCC('m','o','o','f')
+#define FOURCC_tfra     GST_MAKE_FOURCC('t','f','r','a')
+#define FOURCC_tfhd     GST_MAKE_FOURCC('t','f','h','d')
+#define FOURCC_trun     GST_MAKE_FOURCC('t','r','u','n')
+#define FOURCC_sdtp     GST_MAKE_FOURCC('s','d','t','p')
+#define FOURCC_mfro     GST_MAKE_FOURCC('m','f','r','o')
+#define FOURCC_mfhd     GST_MAKE_FOURCC('m','f','h','d')
+#define FOURCC_mvhd     GST_MAKE_FOURCC('m','v','h','d')
+#define FOURCC_traf     GST_MAKE_FOURCC('t','r','a','f')
+
+/* Xiph fourcc */
+#define FOURCC_XiTh     GST_MAKE_FOURCC('X','i','T','h')
+#define FOURCC_XdxT     GST_MAKE_FOURCC('X','d','x','T')
+#define FOURCC_tCtH     GST_MAKE_FOURCC('t','C','t','H')
+#define FOURCC_tCt_     GST_MAKE_FOURCC('t','C','t','#')
+#define FOURCC_tCtC     GST_MAKE_FOURCC('t','C','t','C')
+
+/* ilst metatags */
+#define FOURCC_titl     GST_MAKE_FOURCC('t','i','t','l')
+#define FOURCC__cmt     GST_MAKE_FOURCC(0xa9, 'c','m','t')
+
+/* 3gp tags */
+#define FOURCC_dscp     GST_MAKE_FOURCC('d','s','c','p')
+#define FOURCC_perf     GST_MAKE_FOURCC('p','e','r','f')
+#define FOURCC_auth     GST_MAKE_FOURCC('a','u','t','h')
+#define FOURCC_yrrc     GST_MAKE_FOURCC('y','r','r','c')
+#define FOURCC_albm     GST_MAKE_FOURCC('a','l','b','m')
+#define FOURCC_loci     GST_MAKE_FOURCC('l','o','c','i')
+#define FOURCC_kywd     GST_MAKE_FOURCC('k','y','w','d')
+#define FOURCC_clsf     GST_MAKE_FOURCC('c','l','s','f')
+
+/* For Microsoft Wave formats embedded in quicktime, the FOURCC is
+   'm', 's', then the 16 bit wave codec id */
+#define MS_WAVE_FOURCC(codecid)  GST_MAKE_FOURCC( \
+        'm', 's', ((codecid)>>8)&0xff, ((codecid)&0xff))
+
+#define FOURCC_owma     GST_MAKE_FOURCC('o','w','m','a')
+#define FOURCC_ovc1     GST_MAKE_FOURCC('o','v','c','1')
+
+G_END_DECLS
+
+#endif /* __FOURCC_H__ */
diff --git a/gst/isomp4/ftypcc.h b/gst/isomp4/ftypcc.h
new file mode 100644
index 000000000..3d31b6dd0
--- /dev/null
+++ b/gst/isomp4/ftypcc.h
@@ -0,0 +1,68 @@
+/* GStreamer
+ * Copyright (C) <2008> Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __FTYP_CC_H__
+#define __FTYP_CC_H__
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+#define FOURCC_ftyp	GST_MAKE_FOURCC('f','t','y','p')
+#define FOURCC_isom     GST_MAKE_FOURCC('i','s','o','m')
+#define FOURCC_iso2     GST_MAKE_FOURCC('i','s','o','2')
+#define FOURCC_mp41     GST_MAKE_FOURCC('m','p','4','1')
+#define FOURCC_mp42     GST_MAKE_FOURCC('m','p','4','2')
+#define FOURCC_mjp2     GST_MAKE_FOURCC('m','j','p','2')
+#define FOURCC_3gp4     GST_MAKE_FOURCC('3','g','p','4')
+#define FOURCC_3gp6     GST_MAKE_FOURCC('3','g','p','6')
+#define FOURCC_3gg6     GST_MAKE_FOURCC('3','g','g','6')
+#define FOURCC_3gr6     GST_MAKE_FOURCC('3','g','r','6')
+#define FOURCC_3gg7     GST_MAKE_FOURCC('3','g','g','7')
+#define FOURCC_avc1     GST_MAKE_FOURCC('a','v','c','1')
+#define FOURCC_qt__     GST_MAKE_FOURCC('q','t',' ',' ')
+#define FOURCC_isml     GST_MAKE_FOURCC('i','s','m','l')
+#define FOURCC_piff     GST_MAKE_FOURCC('p','i','f','f')
+
+G_END_DECLS
+
+#endif /* __FTYP_CC_H__ */
diff --git a/gst/isomp4/gstqtmoovrecover.c b/gst/isomp4/gstqtmoovrecover.c
new file mode 100644
index 000000000..80799724c
--- /dev/null
+++ b/gst/isomp4/gstqtmoovrecover.c
@@ -0,0 +1,391 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+
+/**
+ * SECTION:element-qtmoovrecover
+ * @short_description: Utility element for recovering unfinished quicktime files
+ *
+ * <refsect2>
+ * <para>
+ * This element recovers quicktime files created with qtmux using the moov
+ * recovery feature.
+ * </para>
+ * <title>Example pipelines</title>
+ * <para>
+ * <programlisting>
+ * TODO
+ * </programlisting>
+ * </para>
+ * </refsect2>
+ *
+ * Documentation last reviewed on 2011-04-21
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gstdio.h>
+#include <gst/gst.h>
+
+#include "gstqtmoovrecover.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_qt_moov_recover_debug);
+#define GST_CAT_DEFAULT gst_qt_moov_recover_debug
+
+/* QTMoovRecover signals and args */
+enum
+{
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum
+{
+  PROP_0,
+  PROP_RECOVERY_INPUT,
+  PROP_BROKEN_INPUT,
+  PROP_FIXED_OUTPUT,
+  PROP_FAST_START_MODE
+};
+
+GST_BOILERPLATE (GstQTMoovRecover, gst_qt_moov_recover, GstPipeline,
+    GST_TYPE_PIPELINE);
+
+/* property functions */
+static void gst_qt_moov_recover_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_qt_moov_recover_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
+
+static GstStateChangeReturn gst_qt_moov_recover_change_state (GstElement *
+    element, GstStateChange transition);
+
+static void gst_qt_moov_recover_finalize (GObject * object);
+
+static void
+gst_qt_moov_recover_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+#if 0
+  GstQTMoovRecoverClass *klass = (GstQTMoovRecoverClass *) g_class;
+#endif
+  gst_element_class_set_details_simple (element_class, "QT Moov Recover",
+      "Util", "Recovers unfinished qtmux files",
+      "Thiago Santos <thiago.sousa.santos@collabora.co.uk>");
+}
+
+static void
+gst_qt_moov_recover_class_init (GstQTMoovRecoverClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->finalize = gst_qt_moov_recover_finalize;
+  gobject_class->get_property = gst_qt_moov_recover_get_property;
+  gobject_class->set_property = gst_qt_moov_recover_set_property;
+
+  gstelement_class->change_state = gst_qt_moov_recover_change_state;
+
+  g_object_class_install_property (gobject_class, PROP_FIXED_OUTPUT,
+      g_param_spec_string ("fixed-output",
+          "Path to write the fixed file",
+          "Path to write the fixed file to (used as output)",
+          NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_BROKEN_INPUT,
+      g_param_spec_string ("broken-input",
+          "Path to broken input file",
+          "Path to broken input file. (If qtmux was on faststart mode, this "
+          "file is the faststart file)", NULL,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_RECOVERY_INPUT,
+      g_param_spec_string ("recovery-input",
+          "Path to recovery file",
+          "Path to recovery file (used as input)", NULL,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FAST_START_MODE,
+      g_param_spec_boolean ("faststart-mode",
+          "If the broken input is from faststart mode",
+          "If the broken input is from faststart mode",
+          FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  GST_DEBUG_CATEGORY_INIT (gst_qt_moov_recover_debug, "qtmoovrecover", 0,
+      "QT Moovie Recover");
+}
+
+static void
+gst_qt_moov_recover_init (GstQTMoovRecover * qtmr,
+    GstQTMoovRecoverClass * qtmr_klass)
+{
+}
+
+static void
+gst_qt_moov_recover_finalize (GObject * object)
+{
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_qt_moov_recover_run (void *data)
+{
+  FILE *moovrec = NULL;
+  FILE *mdatinput = NULL;
+  FILE *output = NULL;
+  MdatRecovFile *mdat_recov = NULL;
+  MoovRecovFile *moov_recov = NULL;
+  GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (data);
+  GError *err = NULL;
+
+  GST_LOG_OBJECT (qtmr, "Starting task");
+
+  GST_DEBUG_OBJECT (qtmr, "Validating properties");
+  GST_OBJECT_LOCK (qtmr);
+  /* validate properties */
+  if (qtmr->broken_input == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
+        ("Please set broken-input property"), (NULL));
+    goto end;
+  }
+  if (qtmr->recovery_input == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
+        ("Please set recovery-input property"), (NULL));
+    goto end;
+  }
+  if (qtmr->fixed_output == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
+        ("Please set fixed-output property"), (NULL));
+    goto end;
+  }
+
+  GST_DEBUG_OBJECT (qtmr, "Opening input/output files");
+  /* open files */
+  moovrec = g_fopen (qtmr->recovery_input, "rb");
+  if (moovrec == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ,
+        ("Failed to open recovery-input file"), (NULL));
+    goto end;
+  }
+
+  mdatinput = g_fopen (qtmr->broken_input, "rb");
+  if (mdatinput == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ,
+        ("Failed to open broken-input file"), (NULL));
+    goto end;
+  }
+  output = g_fopen (qtmr->fixed_output, "wb+");
+  if (output == NULL) {
+    GST_OBJECT_UNLOCK (qtmr);
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ_WRITE,
+        ("Failed to open fixed-output file"), (NULL));
+    goto end;
+  }
+  GST_OBJECT_UNLOCK (qtmr);
+
+  GST_DEBUG_OBJECT (qtmr, "Parsing input files");
+  /* now create our structures */
+  mdat_recov = mdat_recov_file_create (mdatinput, qtmr->faststart_mode, &err);
+  mdatinput = NULL;
+  if (mdat_recov == NULL) {
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED,
+        ("Broken file could not be parsed correctly"), (NULL));
+    goto end;
+  }
+  moov_recov = moov_recov_file_create (moovrec, &err);
+  moovrec = NULL;
+  if (moov_recov == NULL) {
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED,
+        ("Recovery file could not be parsed correctly"), (NULL));
+    goto end;
+  }
+
+  /* now parse the buffers data from moovrec */
+  if (!moov_recov_parse_buffers (moov_recov, mdat_recov, &err)) {
+    goto end;
+  }
+
+  GST_DEBUG_OBJECT (qtmr, "Writing fixed file to output");
+  if (!moov_recov_write_file (moov_recov, mdat_recov, output, &err)) {
+    goto end;
+  }
+
+  /* here means success */
+  GST_DEBUG_OBJECT (qtmr, "Finished successfully, posting EOS");
+  gst_element_post_message (GST_ELEMENT_CAST (qtmr),
+      gst_message_new_eos (GST_OBJECT_CAST (qtmr)));
+
+end:
+  GST_LOG_OBJECT (qtmr, "Finalizing task");
+  if (err) {
+    GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED, ("%s", err->message), (NULL));
+    g_error_free (err);
+  }
+
+  if (moov_recov)
+    moov_recov_file_free (moov_recov);
+  if (moovrec)
+    fclose (moovrec);
+
+  if (mdat_recov)
+    mdat_recov_file_free (mdat_recov);
+  if (mdatinput)
+    fclose (mdatinput);
+
+  if (output)
+    fclose (output);
+  GST_LOG_OBJECT (qtmr, "Leaving task");
+  gst_task_stop (qtmr->task);
+}
+
+static void
+gst_qt_moov_recover_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
+{
+  GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (object);
+
+  GST_OBJECT_LOCK (qtmr);
+  switch (prop_id) {
+    case PROP_FAST_START_MODE:
+      g_value_set_boolean (value, qtmr->faststart_mode);
+      break;
+    case PROP_BROKEN_INPUT:
+      g_value_set_string (value, qtmr->broken_input);
+      break;
+    case PROP_RECOVERY_INPUT:
+      g_value_set_string (value, qtmr->recovery_input);
+      break;
+    case PROP_FIXED_OUTPUT:
+      g_value_set_string (value, qtmr->fixed_output);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+  GST_OBJECT_UNLOCK (qtmr);
+}
+
+static void
+gst_qt_moov_recover_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+  GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (object);
+
+  GST_OBJECT_LOCK (qtmr);
+  switch (prop_id) {
+    case PROP_FAST_START_MODE:
+      qtmr->faststart_mode = g_value_get_boolean (value);
+      break;
+    case PROP_BROKEN_INPUT:
+      g_free (qtmr->broken_input);
+      qtmr->broken_input = g_value_dup_string (value);
+      break;
+    case PROP_RECOVERY_INPUT:
+      g_free (qtmr->recovery_input);
+      qtmr->recovery_input = g_value_dup_string (value);
+      break;
+    case PROP_FIXED_OUTPUT:
+      g_free (qtmr->fixed_output);
+      qtmr->fixed_output = g_value_dup_string (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+  GST_OBJECT_UNLOCK (qtmr);
+}
+
+static GstStateChangeReturn
+gst_qt_moov_recover_change_state (GstElement * element,
+    GstStateChange transition)
+{
+  GstStateChangeReturn ret;
+  GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      qtmr->task = gst_task_create (gst_qt_moov_recover_run, qtmr);
+      g_static_rec_mutex_init (&qtmr->task_mutex);
+      gst_task_set_lock (qtmr->task, &qtmr->task_mutex);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+      gst_task_start (qtmr->task);
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+      gst_task_stop (qtmr->task);
+      gst_task_join (qtmr->task);
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      g_assert (gst_task_get_state (qtmr->task) == GST_TASK_STOPPED);
+      gst_object_unref (qtmr->task);
+      qtmr->task = NULL;
+      g_static_rec_mutex_free (&qtmr->task_mutex);
+      break;
+    default:
+      break;
+  }
+  return ret;
+}
+
+
+gboolean
+gst_qt_moov_recover_register (GstPlugin * plugin)
+{
+  return gst_element_register (plugin, "qtmoovrecover", GST_RANK_NONE,
+      GST_TYPE_QT_MOOV_RECOVER);
+}
diff --git a/gst/isomp4/gstqtmoovrecover.h b/gst/isomp4/gstqtmoovrecover.h
new file mode 100644
index 000000000..15eac847b
--- /dev/null
+++ b/gst/isomp4/gstqtmoovrecover.h
@@ -0,0 +1,88 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __GST_QT_MOOV_RECOVER_H__
+#define __GST_QT_MOOV_RECOVER_H__
+
+#include <gst/gst.h>
+
+#include "atoms.h"
+#include "atomsrecovery.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_QT_MOOV_RECOVER (gst_qt_moov_recover_get_type())
+#define GST_QT_MOOV_RECOVER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QT_MOOV_RECOVER, GstQTMoovRecover))
+#define GST_QT_MOOV_RECOVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QT_MOOV_RECOVER, GstQTMoovRecover))
+#define GST_IS_QT_MOOV_RECOVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QT_MOOV_RECOVER))
+#define GST_IS_QT_MOOV_RECOVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QT_MOOV_RECOVER))
+#define GST_QT_MOOV_RECOVER_CAST(obj) ((GstQTMoovRecover*)(obj))
+
+
+typedef struct _GstQTMoovRecover GstQTMoovRecover;
+typedef struct _GstQTMoovRecoverClass GstQTMoovRecoverClass;
+
+struct _GstQTMoovRecover
+{
+  GstPipeline pipeline;
+
+  GstTask *task;
+  GStaticRecMutex task_mutex;
+
+  /* properties */
+  gboolean  faststart_mode;
+  gchar    *recovery_input;
+  gchar    *fixed_output;
+  gchar    *broken_input;
+};
+
+struct _GstQTMoovRecoverClass
+{
+  GstPipelineClass parent_class;
+};
+
+GType gst_qt_moov_recover_get_type (void);
+gboolean gst_qt_moov_recover_register (GstPlugin * plugin);
+
+G_END_DECLS
+
+#endif /* __GST_QT_MOOV_RECOVER_H__ */
diff --git a/gst/isomp4/gstqtmux-doc.c b/gst/isomp4/gstqtmux-doc.c
new file mode 100644
index 000000000..986fffc17
--- /dev/null
+++ b/gst/isomp4/gstqtmux-doc.c
@@ -0,0 +1,300 @@
+/* Quicktime muxer documentation
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ * Copyright (C) 2010 Nokia Corporation. All rights reserved.
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+/* ============================= mp4mux ==================================== */
+
+/**
+ * SECTION:element-mp4mux
+ * @short_description: Muxer for ISO MPEG-4 (.mp4) files
+ *
+ * This element merges streams (audio and video) into ISO MPEG-4 (.mp4) files.
+ *
+ * The following background intends to explain why various similar muxers
+ * are present in this plugin.
+ *
+ * The <ulink url="http://www.apple.com/quicktime/resources/qtfileformat.pdf">
+ * QuickTime file format specification</ulink> served as basis for the MP4 file
+ * format specification (mp4mux), and as such the QuickTime file structure is
+ * nearly identical to the so-called ISO Base Media file format defined in
+ * ISO 14496-12 (except for some media specific parts).
+ * In turn, the latter ISO Base Media format was further specialized as a
+ * Motion JPEG-2000 file format in ISO 15444-3 (mj2mux)
+ * and in various 3GPP(2) specs (gppmux).
+ * The fragmented file features defined (only) in ISO Base Media are used by
+ * ISMV files making up (a.o.) Smooth Streaming (ismlmux).
+ *
+ * A few properties (<link linkend="GstMP4Mux--movie-timescale">movie-timescale</link>,
+ * <link linkend="GstMP4Mux--trak-timescale">trak-timescale</link>) allow adjusting
+ * some technical parameters, which might be useful in (rare) cases to resolve
+ * compatibility issues in some situations.
+ *
+ * Some other properties influence the result more fundamentally.
+ * A typical mov/mp4 file's metadata (aka moov) is located at the end of the file,
+ * somewhat contrary to this usually being called "the header".
+ * However, a <link linkend="GstMP4Mux--faststart">faststart</link> file will
+ * (with some effort) arrange this to be located near start of the file,
+ * which then allows it e.g. to be played while downloading.
+ * Alternatively, rather than having one chunk of metadata at start (or end),
+ * there can be some metadata at start and most of the other data can be spread
+ * out into fragments of <link linkend="GstMP4Mux--fragment-duration">fragment-duration</link>.
+ * If such fragmented layout is intended for streaming purposes, then
+ * <link linkend="GstMP4Mux--streamable">streamable</link> allows foregoing to add
+ * index metadata (at the end of file).
+ *
+ * <link linkend="GstMP4Mux--dts-method">dts-method</link> allows selecting a
+ * method for managing input timestamps (stay tuned for 0.11 to have this
+ * automagically settled).  The default delta/duration method should handle nice
+ * (aka perfect streams) just fine, but may experience problems otherwise
+ * (e.g. input stream with re-ordered B-frames and/or with frame dropping).
+ * The re-ordering approach re-assigns incoming timestamps in ascending order
+ * to incoming buffers and offers an alternative in such cases.  In cases where
+ * that might fail, the remaining method can be tried, which is exact and
+ * according to specs, but might experience playback on not so spec-wise players.
+ * Note that this latter approach also requires one to enable
+ * <link linkend="GstMP4Mux--presentation-timestamp">presentation-timestamp</link>.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch gst-launch v4l2src num-buffers=50 ! queue ! x264enc ! mp4mux ! filesink location=video.mp4
+ * ]|
+ * Records a video stream captured from a v4l2 device, encodes it into H.264
+ * and muxes it into an mp4 file.
+ * </refsect2>
+ *
+ * Documentation last reviewed on 2011-04-21
+ */
+
+/* ============================= 3gppmux ==================================== */
+
+/**
+ * SECTION:element-3gppmux
+ * @short_description: Muxer for 3GPP (.3gp) files
+ *
+ * This element merges streams (audio and video) into 3GPP (.3gp) files.
+ *
+ * The following background intends to explain why various similar muxers
+ * are present in this plugin.
+ *
+ * The <ulink url="http://www.apple.com/quicktime/resources/qtfileformat.pdf">
+ * QuickTime file format specification</ulink> served as basis for the MP4 file
+ * format specification (mp4mux), and as such the QuickTime file structure is
+ * nearly identical to the so-called ISO Base Media file format defined in
+ * ISO 14496-12 (except for some media specific parts).
+ * In turn, the latter ISO Base Media format was further specialized as a
+ * Motion JPEG-2000 file format in ISO 15444-3 (mj2mux)
+ * and in various 3GPP(2) specs (gppmux).
+ * The fragmented file features defined (only) in ISO Base Media are used by
+ * ISMV files making up (a.o.) Smooth Streaming (ismlmux).
+ *
+ * A few properties (<link linkend="Gst3GPPMux--movie-timescale">movie-timescale</link>,
+ * <link linkend="Gst3GPPMux--trak-timescale">trak-timescale</link>) allow adjusting
+ * some technical parameters, which might be useful in (rare) cases to resolve
+ * compatibility issues in some situations.
+ *
+ * Some other properties influence the result more fundamentally.
+ * A typical mov/mp4 file's metadata (aka moov) is located at the end of the file,
+ * somewhat contrary to this usually being called "the header".
+ * However, a <link linkend="Gst3GPPMux--faststart">faststart</link> file will
+ * (with some effort) arrange this to be located near start of the file,
+ * which then allows it e.g. to be played while downloading.
+ * Alternatively, rather than having one chunk of metadata at start (or end),
+ * there can be some metadata at start and most of the other data can be spread
+ * out into fragments of <link linkend="Gst3GPPMux--fragment-duration">fragment-duration</link>.
+ * If such fragmented layout is intended for streaming purposes, then
+ * <link linkend="Gst3GPPMux--streamable">streamable</link> allows foregoing to add
+ * index metadata (at the end of file).
+ *
+ * <link linkend="Gst3GPPMux--dts-method">dts-method</link> allows selecting a
+ * method for managing input timestamps (stay tuned for 0.11 to have this
+ * automagically settled).  The default delta/duration method should handle nice
+ * (aka perfect streams) just fine, but may experience problems otherwise
+ * (e.g. input stream with re-ordered B-frames and/or with frame dropping).
+ * The re-ordering approach re-assigns incoming timestamps in ascending order
+ * to incoming buffers and offers an alternative in such cases.  In cases where
+ * that might fail, the remaining method can be tried, which is exact and
+ * according to specs, but might experience playback on not so spec-wise players.
+ * Note that this latter approach also requires one to enable
+ * <link linkend="Gst3GPPMux--presentation-timestamp">presentation-timestamp</link>.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch v4l2src num-buffers=50 ! queue ! ffenc_h263 ! gppmux ! filesink location=video.3gp
+ * ]|
+ * Records a video stream captured from a v4l2 device, encodes it into H.263
+ * and muxes it into an 3gp file.
+ * </refsect2>
+ *
+ * Documentation last reviewed on 2011-04-21
+ */
+
+/* ============================= mj2pmux ==================================== */
+
+/**
+ * SECTION:element-mj2mux
+ * @short_description: Muxer for Motion JPEG-2000 (.mj2) files
+ *
+ * This element merges streams (audio and video) into MJ2 (.mj2) files.
+ *
+ * The following background intends to explain why various similar muxers
+ * are present in this plugin.
+ *
+ * The <ulink url="http://www.apple.com/quicktime/resources/qtfileformat.pdf">
+ * QuickTime file format specification</ulink> served as basis for the MP4 file
+ * format specification (mp4mux), and as such the QuickTime file structure is
+ * nearly identical to the so-called ISO Base Media file format defined in
+ * ISO 14496-12 (except for some media specific parts).
+ * In turn, the latter ISO Base Media format was further specialized as a
+ * Motion JPEG-2000 file format in ISO 15444-3 (mj2mux)
+ * and in various 3GPP(2) specs (gppmux).
+ * The fragmented file features defined (only) in ISO Base Media are used by
+ * ISMV files making up (a.o.) Smooth Streaming (ismlmux).
+ *
+ * A few properties (<link linkend="GstMJ2Mux--movie-timescale">movie-timescale</link>,
+ * <link linkend="GstMJ2Mux--trak-timescale">trak-timescale</link>) allow adjusting
+ * some technical parameters, which might be useful in (rare) cases to resolve
+ * compatibility issues in some situations.
+ *
+ * Some other properties influence the result more fundamentally.
+ * A typical mov/mp4 file's metadata (aka moov) is located at the end of the file,
+ * somewhat contrary to this usually being called "the header".
+ * However, a <link linkend="GstMJ2Mux--faststart">faststart</link> file will
+ * (with some effort) arrange this to be located near start of the file,
+ * which then allows it e.g. to be played while downloading.
+ * Alternatively, rather than having one chunk of metadata at start (or end),
+ * there can be some metadata at start and most of the other data can be spread
+ * out into fragments of <link linkend="GstMJ2Mux--fragment-duration">fragment-duration</link>.
+ * If such fragmented layout is intended for streaming purposes, then
+ * <link linkend="GstMJ2Mux--streamable">streamable</link> allows foregoing to add
+ * index metadata (at the end of file).
+ *
+ * <link linkend="GstMJ2Mux--dts-method">dts-method</link> allows selecting a
+ * method for managing input timestamps (stay tuned for 0.11 to have this
+ * automagically settled).  The default delta/duration method should handle nice
+ * (aka perfect streams) just fine, but may experience problems otherwise
+ * (e.g. input stream with re-ordered B-frames and/or with frame dropping).
+ * The re-ordering approach re-assigns incoming timestamps in ascending order
+ * to incoming buffers and offers an alternative in such cases.  In cases where
+ * that might fail, the remaining method can be tried, which is exact and
+ * according to specs, but might experience playback on not so spec-wise players.
+ * Note that this latter approach also requires one to enable
+ * <link linkend="GstMJ2Mux--presentation-timestamp">presentation-timestamp</link>.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch v4l2src num-buffers=50 ! queue ! jp2kenc ! mj2mux ! filesink location=video.mj2
+ * ]|
+ * Records a video stream captured from a v4l2 device, encodes it into JPEG-2000
+ * and muxes it into an mj2 file.
+ * </refsect2>
+ *
+ * Documentation last reviewed on 2011-04-21
+ */
+
+/* ============================= ismlmux ==================================== */
+
+/**
+ * SECTION:element-ismlmux
+ * @short_description: Muxer for ISML smooth streaming (.isml) files
+ *
+ * This element merges streams (audio and video) into MJ2 (.mj2) files.
+ *
+ * The following background intends to explain why various similar muxers
+ * are present in this plugin.
+ *
+ * The <ulink url="http://www.apple.com/quicktime/resources/qtfileformat.pdf">
+ * QuickTime file format specification</ulink> served as basis for the MP4 file
+ * format specification (mp4mux), and as such the QuickTime file structure is
+ * nearly identical to the so-called ISO Base Media file format defined in
+ * ISO 14496-12 (except for some media specific parts).
+ * In turn, the latter ISO Base Media format was further specialized as a
+ * Motion JPEG-2000 file format in ISO 15444-3 (mj2mux)
+ * and in various 3GPP(2) specs (gppmux).
+ * The fragmented file features defined (only) in ISO Base Media are used by
+ * ISMV files making up (a.o.) Smooth Streaming (ismlmux).
+ *
+ * A few properties (<link linkend="GstISMLMux--movie-timescale">movie-timescale</link>,
+ * <link linkend="GstISMLMux--trak-timescale">trak-timescale</link>) allow adjusting
+ * some technical parameters, which might be useful in (rare) cases to resolve
+ * compatibility issues in some situations.
+ *
+ * Some other properties influence the result more fundamentally.
+ * A typical mov/mp4 file's metadata (aka moov) is located at the end of the file,
+ * somewhat contrary to this usually being called "the header".
+ * However, a <link linkend="GstISMLMux--faststart">faststart</link> file will
+ * (with some effort) arrange this to be located near start of the file,
+ * which then allows it e.g. to be played while downloading.
+ * Alternatively, rather than having one chunk of metadata at start (or end),
+ * there can be some metadata at start and most of the other data can be spread
+ * out into fragments of <link linkend="GstISMLMux--fragment-duration">fragment-duration</link>.
+ * If such fragmented layout is intended for streaming purposes, then
+ * <link linkend="GstISMLMux--streamable">streamable</link> allows foregoing to add
+ * index metadata (at the end of file).
+ *
+ * <link linkend="GstISMLMux--dts-method">dts-method</link> allows selecting a
+ * method for managing input timestamps (stay tuned for 0.11 to have this
+ * automagically settled).  The default delta/duration method should handle nice
+ * (aka perfect streams) just fine, but may experience problems otherwise
+ * (e.g. input stream with re-ordered B-frames and/or with frame dropping).
+ * The re-ordering approach re-assigns incoming timestamps in ascending order
+ * to incoming buffers and offers an alternative in such cases.  In cases where
+ * that might fail, the remaining method can be tried, which is exact and
+ * according to specs, but might experience playback on not so spec-wise players.
+ * Note that this latter approach also requires one to enable
+ * <link linkend="GstISMLMux--presentation-timestamp">presentation-timestamp</link>.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch v4l2src num-buffers=50 ! queue ! jp2kenc ! mj2mux ! filesink location=video.mj2
+ * ]|
+ * Records a video stream captured from a v4l2 device, encodes it into JPEG-2000
+ * and muxes it into an mj2 file.
+ * </refsect2>
+ *
+ * Documentation last reviewed on 2011-04-21
+ */
diff --git a/gst/isomp4/gstqtmux-doc.h b/gst/isomp4/gstqtmux-doc.h
new file mode 100644
index 000000000..48b5d8c41
--- /dev/null
+++ b/gst/isomp4/gstqtmux-doc.h
@@ -0,0 +1,52 @@
+/* Quicktime muxer documentation
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ * Copyright (C) 2010 Nokia Corporation. All rights reserved.
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#error "This header is for gtk-doc only and not supposed to be included"
+
+typedef struct _GstMP4Mux GstMP4Mux;
+typedef struct _Gst3GPPMux GstMP4Mux;
+typedef struct _GstISMLMux GstMP4Mux;
+typedef struct _GstMJ2Mux GstMJ2Mux;
+
diff --git a/gst/isomp4/gstqtmux.c b/gst/isomp4/gstqtmux.c
new file mode 100644
index 000000000..0b52e500f
--- /dev/null
+++ b/gst/isomp4/gstqtmux.c
@@ -0,0 +1,3526 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ * Copyright (C) 2010 Nokia Corporation. All rights reserved.
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+
+/**
+ * SECTION:element-qtmux
+ * @short_description: Muxer for quicktime(.mov) files
+ *
+ * This element merges streams (audio and video) into QuickTime(.mov) files.
+ *
+ * The following background intends to explain why various similar muxers
+ * are present in this plugin.
+ *
+ * The <ulink url="http://www.apple.com/quicktime/resources/qtfileformat.pdf">
+ * QuickTime file format specification</ulink> served as basis for the MP4 file
+ * format specification (mp4mux), and as such the QuickTime file structure is
+ * nearly identical to the so-called ISO Base Media file format defined in
+ * ISO 14496-12 (except for some media specific parts).
+ * In turn, the latter ISO Base Media format was further specialized as a
+ * Motion JPEG-2000 file format in ISO 15444-3 (mj2mux)
+ * and in various 3GPP(2) specs (gppmux).
+ * The fragmented file features defined (only) in ISO Base Media are used by
+ * ISMV files making up (a.o.) Smooth Streaming (ismlmux).
+ *
+ * A few properties (<link linkend="GstQTMux--movie-timescale">movie-timescale</link>,
+ * <link linkend="GstQTMux--trak-timescale">trak-timescale</link>) allow adjusting
+ * some technical parameters, which might be useful in (rare) cases to resolve
+ * compatibility issues in some situations.
+ *
+ * Some other properties influence the result more fundamentally.
+ * A typical mov/mp4 file's metadata (aka moov) is located at the end of the file,
+ * somewhat contrary to this usually being called "the header".
+ * However, a <link linkend="GstQTMux--faststart">faststart</link> file will
+ * (with some effort) arrange this to be located near start of the file,
+ * which then allows it e.g. to be played while downloading.
+ * Alternatively, rather than having one chunk of metadata at start (or end),
+ * there can be some metadata at start and most of the other data can be spread
+ * out into fragments of <link linkend="GstQTMux--fragment-duration">fragment-duration</link>.
+ * If such fragmented layout is intended for streaming purposes, then
+ * <link linkend="GstQTMux--streamable">streamable</link> allows foregoing to add
+ * index metadata (at the end of file).
+ *
+ * <link linkend="GstQTMux--dts-method">dts-method</link> allows selecting a
+ * method for managing input timestamps (stay tuned for 0.11 to have this
+ * automagically settled).  The default delta/duration method should handle nice
+ * (aka perfect streams) just fine, but may experience problems otherwise
+ * (e.g. input stream with re-ordered B-frames and/or with frame dropping).
+ * The re-ordering approach re-assigns incoming timestamps in ascending order
+ * to incoming buffers and offers an alternative in such cases.  In cases where
+ * that might fail, the remaining method can be tried, which is exact and
+ * according to specs, but might experience playback on not so spec-wise players.
+ * Note that this latter approach also requires one to enable
+ * <link linkend="GstQTMux--presentation-timestamp">presentation-timestamp</link>.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch v4l2src num-buffers=500 ! video/x-raw-yuv,width=320,height=240 ! ffmpegcolorspace ! qtmux ! filesink location=video.mov
+ * ]|
+ * Records a video stream captured from a v4l2 device and muxes it into a qt file.
+ * </refsect2>
+ *
+ * Last reviewed on 2010-12-03
+ */
+
+/*
+ * Based on avimux
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gstdio.h>
+
+#include <gst/gst.h>
+#include <gst/base/gstcollectpads.h>
+#include <gst/tag/xmpwriter.h>
+
+#include <sys/types.h>
+#ifdef G_OS_WIN32
+#include <io.h>                 /* lseek, open, close, read */
+#undef lseek
+#define lseek _lseeki64
+#undef off_t
+#define off_t guint64
+#endif
+
+#ifdef _MSC_VER
+#define ftruncate g_win32_ftruncate
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+
+#include "gstqtmux.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_qt_mux_debug);
+#define GST_CAT_DEFAULT gst_qt_mux_debug
+
+enum
+{
+  DTS_METHOD_DD,
+  DTS_METHOD_REORDER,
+  DTS_METHOD_ASC
+};
+
+static GType
+gst_qt_mux_dts_method_get_type (void)
+{
+  static GType gst_qt_mux_dts_method = 0;
+
+  if (!gst_qt_mux_dts_method) {
+    static const GEnumValue dts_methods[] = {
+      {DTS_METHOD_DD, "delta/duration", "dd"},
+      {DTS_METHOD_REORDER, "reorder", "reorder"},
+      {DTS_METHOD_ASC, "ascending", "asc"},
+      {0, NULL, NULL},
+    };
+
+    gst_qt_mux_dts_method =
+        g_enum_register_static ("GstQTMuxDtsMethods", dts_methods);
+  }
+
+  return gst_qt_mux_dts_method;
+}
+
+#define GST_TYPE_QT_MUX_DTS_METHOD \
+  (gst_qt_mux_dts_method_get_type ())
+
+/* QTMux signals and args */
+enum
+{
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum
+{
+  PROP_0,
+  PROP_MOVIE_TIMESCALE,
+  PROP_TRAK_TIMESCALE,
+  PROP_FAST_START,
+  PROP_FAST_START_TEMP_FILE,
+  PROP_MOOV_RECOV_FILE,
+  PROP_FRAGMENT_DURATION,
+  PROP_STREAMABLE,
+  PROP_DTS_METHOD,
+  PROP_DO_CTTS,
+};
+
+/* some spare for header size as well */
+#define MDAT_LARGE_FILE_LIMIT           ((guint64) 1024 * 1024 * 1024 * 2)
+#define MAX_TOLERATED_LATENESS          (GST_SECOND / 10)
+
+#define DEFAULT_MOVIE_TIMESCALE         1000
+#define DEFAULT_TRAK_TIMESCALE          0
+#define DEFAULT_DO_CTTS                 TRUE
+#define DEFAULT_FAST_START              FALSE
+#define DEFAULT_FAST_START_TEMP_FILE    NULL
+#define DEFAULT_MOOV_RECOV_FILE         NULL
+#define DEFAULT_FRAGMENT_DURATION       0
+#define DEFAULT_STREAMABLE              FALSE
+#define DEFAULT_DTS_METHOD              DTS_METHOD_REORDER
+
+
+static void gst_qt_mux_finalize (GObject * object);
+
+static GstStateChangeReturn gst_qt_mux_change_state (GstElement * element,
+    GstStateChange transition);
+
+/* property functions */
+static void gst_qt_mux_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_qt_mux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
+
+/* pad functions */
+static GstPad *gst_qt_mux_request_new_pad (GstElement * element,
+    GstPadTemplate * templ, const gchar * name);
+static void gst_qt_mux_release_pad (GstElement * element, GstPad * pad);
+
+/* event */
+static gboolean gst_qt_mux_sink_event (GstPad * pad, GstEvent * event);
+
+static GstFlowReturn gst_qt_mux_collected (GstCollectPads * pads,
+    gpointer user_data);
+static GstFlowReturn gst_qt_mux_add_buffer (GstQTMux * qtmux, GstQTPad * pad,
+    GstBuffer * buf);
+
+static GstElementClass *parent_class = NULL;
+
+static void
+gst_qt_mux_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+  GstQTMuxClass *klass = (GstQTMuxClass *) g_class;
+  GstQTMuxClassParams *params;
+  GstPadTemplate *videosinktempl, *audiosinktempl, *srctempl;
+  gchar *longname, *description;
+
+  params =
+      (GstQTMuxClassParams *) g_type_get_qdata (G_OBJECT_CLASS_TYPE (g_class),
+      GST_QT_MUX_PARAMS_QDATA);
+  g_assert (params != NULL);
+
+  /* construct the element details struct */
+  longname = g_strdup_printf ("%s Muxer", params->prop->long_name);
+  description = g_strdup_printf ("Multiplex audio and video into a %s file%s",
+      params->prop->long_name,
+      (params->prop->rank == GST_RANK_NONE) ? " (deprecated)" : "");
+  gst_element_class_set_details_simple (element_class, longname,
+      "Codec/Muxer", description,
+      "Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>");
+  g_free (longname);
+  g_free (description);
+
+  /* pad templates */
+  srctempl = gst_pad_template_new ("src", GST_PAD_SRC,
+      GST_PAD_ALWAYS, params->src_caps);
+  gst_element_class_add_pad_template (element_class, srctempl);
+
+  if (params->audio_sink_caps) {
+    audiosinktempl = gst_pad_template_new ("audio_%d",
+        GST_PAD_SINK, GST_PAD_REQUEST, params->audio_sink_caps);
+    gst_element_class_add_pad_template (element_class, audiosinktempl);
+  }
+
+  if (params->video_sink_caps) {
+    videosinktempl = gst_pad_template_new ("video_%d",
+        GST_PAD_SINK, GST_PAD_REQUEST, params->video_sink_caps);
+    gst_element_class_add_pad_template (element_class, videosinktempl);
+  }
+
+  klass->format = params->prop->format;
+}
+
+static void
+gst_qt_mux_class_init (GstQTMuxClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->finalize = gst_qt_mux_finalize;
+  gobject_class->get_property = gst_qt_mux_get_property;
+  gobject_class->set_property = gst_qt_mux_set_property;
+
+  g_object_class_install_property (gobject_class, PROP_MOVIE_TIMESCALE,
+      g_param_spec_uint ("movie-timescale", "Movie timescale",
+          "Timescale to use in the movie (units per second)",
+          1, G_MAXUINT32, DEFAULT_MOVIE_TIMESCALE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_TRAK_TIMESCALE,
+      g_param_spec_uint ("trak-timescale", "Track timescale",
+          "Timescale to use for the tracks (units per second, 0 is automatic)",
+          0, G_MAXUINT32, DEFAULT_TRAK_TIMESCALE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_DO_CTTS,
+      g_param_spec_boolean ("presentation-time",
+          "Include presentation-time info",
+          "Calculate and include presentation/composition time "
+          "(in addition to decoding time)", DEFAULT_DO_CTTS,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_DTS_METHOD,
+      g_param_spec_enum ("dts-method", "dts-method",
+          "Method to determine DTS time",
+          GST_TYPE_QT_MUX_DTS_METHOD, DEFAULT_DTS_METHOD,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FAST_START,
+      g_param_spec_boolean ("faststart", "Format file to faststart",
+          "If the file should be formatted for faststart (headers first)",
+          DEFAULT_FAST_START, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FAST_START_TEMP_FILE,
+      g_param_spec_string ("faststart-file", "File to use for storing buffers",
+          "File that will be used temporarily to store data from the stream "
+          "when creating a faststart file. If null a filepath will be "
+          "created automatically", DEFAULT_FAST_START_TEMP_FILE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_MOOV_RECOV_FILE,
+      g_param_spec_string ("moov-recovery-file",
+          "File to store data for posterior moov atom recovery",
+          "File to be used to store "
+          "data for moov atom making movie file recovery possible in case "
+          "of a crash during muxing. Null for disabled. (Experimental)",
+          DEFAULT_MOOV_RECOV_FILE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FRAGMENT_DURATION,
+      g_param_spec_uint ("fragment-duration", "Fragment duration",
+          "Fragment durations in ms (produce a fragmented file if > 0)",
+          0, G_MAXUINT32, klass->format == GST_QT_MUX_FORMAT_ISML ?
+          2000 : DEFAULT_FRAGMENT_DURATION,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_STREAMABLE,
+      g_param_spec_boolean ("streamable", "Streamable",
+          "If set to true, the output should be as if it is to be streamed "
+          "and hence no indexes written or duration written.",
+          DEFAULT_STREAMABLE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+
+  gstelement_class->request_new_pad =
+      GST_DEBUG_FUNCPTR (gst_qt_mux_request_new_pad);
+  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_qt_mux_change_state);
+  gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_qt_mux_release_pad);
+}
+
+static void
+gst_qt_mux_pad_reset (GstQTPad * qtpad)
+{
+  gint i;
+
+  qtpad->fourcc = 0;
+  qtpad->is_out_of_order = FALSE;
+  qtpad->have_dts = FALSE;
+  qtpad->sample_size = 0;
+  qtpad->sync = FALSE;
+  qtpad->last_dts = 0;
+  qtpad->first_ts = GST_CLOCK_TIME_NONE;
+  qtpad->prepare_buf_func = NULL;
+  qtpad->avg_bitrate = 0;
+  qtpad->max_bitrate = 0;
+  qtpad->ts_n_entries = 0;
+
+  qtpad->buf_head = 0;
+  qtpad->buf_tail = 0;
+  for (i = 0; i < G_N_ELEMENTS (qtpad->buf_entries); i++) {
+    if (qtpad->buf_entries[i]) {
+      gst_buffer_unref (qtpad->buf_entries[i]);
+      qtpad->buf_entries[i] = NULL;
+    }
+  }
+
+  if (qtpad->last_buf)
+    gst_buffer_replace (&qtpad->last_buf, NULL);
+
+  /* reference owned elsewhere */
+  qtpad->trak = NULL;
+
+  if (qtpad->traf) {
+    atom_traf_free (qtpad->traf);
+    qtpad->traf = NULL;
+  }
+  atom_array_clear (&qtpad->fragment_buffers);
+
+  /* reference owned elsewhere */
+  qtpad->tfra = NULL;
+}
+
+/*
+ * Takes GstQTMux back to its initial state
+ */
+static void
+gst_qt_mux_reset (GstQTMux * qtmux, gboolean alloc)
+{
+  GSList *walk;
+
+  qtmux->state = GST_QT_MUX_STATE_NONE;
+  qtmux->header_size = 0;
+  qtmux->mdat_size = 0;
+  qtmux->mdat_pos = 0;
+  qtmux->longest_chunk = GST_CLOCK_TIME_NONE;
+  qtmux->video_pads = 0;
+  qtmux->audio_pads = 0;
+  qtmux->fragment_sequence = 0;
+
+  if (qtmux->ftyp) {
+    atom_ftyp_free (qtmux->ftyp);
+    qtmux->ftyp = NULL;
+  }
+  if (qtmux->moov) {
+    atom_moov_free (qtmux->moov);
+    qtmux->moov = NULL;
+  }
+  if (qtmux->mfra) {
+    atom_mfra_free (qtmux->mfra);
+    qtmux->mfra = NULL;
+  }
+  if (qtmux->fast_start_file) {
+    fclose (qtmux->fast_start_file);
+    g_remove (qtmux->fast_start_file_path);
+    qtmux->fast_start_file = NULL;
+  }
+  if (qtmux->moov_recov_file) {
+    fclose (qtmux->moov_recov_file);
+    qtmux->moov_recov_file = NULL;
+  }
+  for (walk = qtmux->extra_atoms; walk; walk = g_slist_next (walk)) {
+    AtomInfo *ainfo = (AtomInfo *) walk->data;
+    ainfo->free_func (ainfo->atom);
+    g_free (ainfo);
+  }
+  g_slist_free (qtmux->extra_atoms);
+  qtmux->extra_atoms = NULL;
+
+  GST_OBJECT_LOCK (qtmux);
+  gst_tag_setter_reset_tags (GST_TAG_SETTER (qtmux));
+  GST_OBJECT_UNLOCK (qtmux);
+
+  /* reset pad data */
+  for (walk = qtmux->sinkpads; walk; walk = g_slist_next (walk)) {
+    GstQTPad *qtpad = (GstQTPad *) walk->data;
+    gst_qt_mux_pad_reset (qtpad);
+
+    /* hm, moov_free above yanked the traks away from us,
+     * so do not free, but do clear */
+    qtpad->trak = NULL;
+  }
+
+  if (alloc) {
+    qtmux->moov = atom_moov_new (qtmux->context);
+    /* ensure all is as nice and fresh as request_new_pad would provide it */
+    for (walk = qtmux->sinkpads; walk; walk = g_slist_next (walk)) {
+      GstQTPad *qtpad = (GstQTPad *) walk->data;
+
+      qtpad->trak = atom_trak_new (qtmux->context);
+      atom_moov_add_trak (qtmux->moov, qtpad->trak);
+    }
+  }
+}
+
+static void
+gst_qt_mux_init (GstQTMux * qtmux, GstQTMuxClass * qtmux_klass)
+{
+  GstElementClass *klass = GST_ELEMENT_CLASS (qtmux_klass);
+  GstPadTemplate *templ;
+
+  templ = gst_element_class_get_pad_template (klass, "src");
+  qtmux->srcpad = gst_pad_new_from_template (templ, "src");
+  gst_pad_use_fixed_caps (qtmux->srcpad);
+  gst_element_add_pad (GST_ELEMENT (qtmux), qtmux->srcpad);
+
+  qtmux->sinkpads = NULL;
+  qtmux->collect = gst_collect_pads_new ();
+  gst_collect_pads_set_function (qtmux->collect,
+      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_qt_mux_collected), qtmux);
+
+  /* properties set to default upon construction */
+
+  /* always need this */
+  qtmux->context =
+      atoms_context_new (gst_qt_mux_map_format_to_flavor (qtmux_klass->format));
+
+  /* internals to initial state */
+  gst_qt_mux_reset (qtmux, TRUE);
+}
+
+
+static void
+gst_qt_mux_finalize (GObject * object)
+{
+  GstQTMux *qtmux = GST_QT_MUX_CAST (object);
+
+  gst_qt_mux_reset (qtmux, FALSE);
+
+  g_free (qtmux->fast_start_file_path);
+  g_free (qtmux->moov_recov_file_path);
+
+  atoms_context_free (qtmux->context);
+  gst_object_unref (qtmux->collect);
+
+  g_slist_free (qtmux->sinkpads);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static GstBuffer *
+gst_qt_mux_prepare_jpc_buffer (GstQTPad * qtpad, GstBuffer * buf,
+    GstQTMux * qtmux)
+{
+  GstBuffer *newbuf;
+
+  GST_LOG_OBJECT (qtmux, "Preparing jpc buffer");
+
+  if (buf == NULL)
+    return NULL;
+
+  newbuf = gst_buffer_new_and_alloc (GST_BUFFER_SIZE (buf) + 8);
+  gst_buffer_copy_metadata (newbuf, buf, GST_BUFFER_COPY_ALL);
+
+  GST_WRITE_UINT32_BE (GST_BUFFER_DATA (newbuf), GST_BUFFER_SIZE (newbuf));
+  GST_WRITE_UINT32_LE (GST_BUFFER_DATA (newbuf) + 4, FOURCC_jp2c);
+
+  memcpy (GST_BUFFER_DATA (newbuf) + 8, GST_BUFFER_DATA (buf),
+      GST_BUFFER_SIZE (buf));
+  gst_buffer_unref (buf);
+
+  return newbuf;
+}
+
+static void
+gst_qt_mux_add_mp4_tag (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  switch (gst_tag_get_type (tag)) {
+      /* strings */
+    case G_TYPE_STRING:
+    {
+      gchar *str = NULL;
+
+      if (!gst_tag_list_get_string (list, tag, &str) || !str)
+        break;
+      GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",
+          GST_FOURCC_ARGS (fourcc), str);
+      atom_moov_add_str_tag (qtmux->moov, fourcc, str);
+      g_free (str);
+      break;
+    }
+      /* double */
+    case G_TYPE_DOUBLE:
+    {
+      gdouble value;
+
+      if (!gst_tag_list_get_double (list, tag, &value))
+        break;
+      GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %u",
+          GST_FOURCC_ARGS (fourcc), (gint) value);
+      atom_moov_add_uint_tag (qtmux->moov, fourcc, 21, (gint) value);
+      break;
+    }
+    case G_TYPE_UINT:
+    {
+      guint value = 0;
+      if (tag2) {
+        /* paired unsigned integers */
+        guint count = 0;
+
+        if (!(gst_tag_list_get_uint (list, tag, &value) ||
+                gst_tag_list_get_uint (list, tag2, &count)))
+          break;
+        GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %u/%u",
+            GST_FOURCC_ARGS (fourcc), value, count);
+        atom_moov_add_uint_tag (qtmux->moov, fourcc, 0,
+            value << 16 | (count & 0xFFFF));
+      } else {
+        /* unpaired unsigned integers */
+        if (!gst_tag_list_get_uint (list, tag, &value))
+          break;
+        GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %u",
+            GST_FOURCC_ARGS (fourcc), value);
+        atom_moov_add_uint_tag (qtmux->moov, fourcc, 1, value);
+      }
+      break;
+    }
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+}
+
+static void
+gst_qt_mux_add_mp4_date (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  GDate *date = NULL;
+  GDateYear year;
+  GDateMonth month;
+  GDateDay day;
+  gchar *str;
+
+  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);
+
+  if (!gst_tag_list_get_date (list, tag, &date) || !date)
+    return;
+
+  year = g_date_get_year (date);
+  month = g_date_get_month (date);
+  day = g_date_get_day (date);
+
+  if (year == G_DATE_BAD_YEAR && month == G_DATE_BAD_MONTH &&
+      day == G_DATE_BAD_DAY) {
+    GST_WARNING_OBJECT (qtmux, "invalid date in tag");
+    return;
+  }
+
+  str = g_strdup_printf ("%u-%u-%u", year, month, day);
+  GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",
+      GST_FOURCC_ARGS (fourcc), str);
+  atom_moov_add_str_tag (qtmux->moov, fourcc, str);
+  g_free (str);
+}
+
+static void
+gst_qt_mux_add_mp4_cover (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  GValue value = { 0, };
+  GstBuffer *buf;
+  GstCaps *caps;
+  GstStructure *structure;
+  gint flags = 0;
+
+  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_BUFFER);
+
+  if (!gst_tag_list_copy_value (&value, list, tag))
+    return;
+
+  buf = gst_value_get_buffer (&value);
+  if (!buf)
+    goto done;
+
+  caps = gst_buffer_get_caps (buf);
+  if (!caps) {
+    GST_WARNING_OBJECT (qtmux, "preview image without caps");
+    goto done;
+  }
+
+  GST_DEBUG_OBJECT (qtmux, "preview image caps %" GST_PTR_FORMAT, caps);
+
+  structure = gst_caps_get_structure (caps, 0);
+  if (gst_structure_has_name (structure, "image/jpeg"))
+    flags = 13;
+  else if (gst_structure_has_name (structure, "image/png"))
+    flags = 14;
+  gst_caps_unref (caps);
+
+  if (!flags) {
+    GST_WARNING_OBJECT (qtmux, "preview image format not supported");
+    goto done;
+  }
+
+  GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT
+      " -> image size %d", GST_FOURCC_ARGS (fourcc), GST_BUFFER_SIZE (buf));
+  atom_moov_add_tag (qtmux->moov, fourcc, flags, GST_BUFFER_DATA (buf),
+      GST_BUFFER_SIZE (buf));
+done:
+  g_value_unset (&value);
+}
+
+static void
+gst_qt_mux_add_3gp_str (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  gchar *str = NULL;
+  guint number;
+
+  g_return_if_fail (gst_tag_get_type (tag) == G_TYPE_STRING);
+  g_return_if_fail (!tag2 || gst_tag_get_type (tag2) == G_TYPE_UINT);
+
+  if (!gst_tag_list_get_string (list, tag, &str) || !str)
+    return;
+
+  if (tag2)
+    if (!gst_tag_list_get_uint (list, tag2, &number))
+      tag2 = NULL;
+
+  if (!tag2) {
+    GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",
+        GST_FOURCC_ARGS (fourcc), str);
+    atom_moov_add_3gp_str_tag (qtmux->moov, fourcc, str);
+  } else {
+    GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s/%d",
+        GST_FOURCC_ARGS (fourcc), str, number);
+    atom_moov_add_3gp_str_int_tag (qtmux->moov, fourcc, str, number);
+  }
+
+  g_free (str);
+}
+
+static void
+gst_qt_mux_add_3gp_date (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  GDate *date = NULL;
+  GDateYear year;
+
+  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);
+
+  if (!gst_tag_list_get_date (list, tag, &date) || !date)
+    return;
+
+  year = g_date_get_year (date);
+
+  if (year == G_DATE_BAD_YEAR) {
+    GST_WARNING_OBJECT (qtmux, "invalid date in tag");
+    return;
+  }
+
+  GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %d",
+      GST_FOURCC_ARGS (fourcc), year);
+  atom_moov_add_3gp_uint_tag (qtmux->moov, fourcc, year);
+}
+
+static void
+gst_qt_mux_add_3gp_location (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  gdouble latitude = -360, longitude = -360, altitude = 0;
+  gchar *location = NULL;
+  guint8 *data, *ddata;
+  gint size = 0, len = 0;
+  gboolean ret = FALSE;
+
+  g_return_if_fail (strcmp (tag, GST_TAG_GEO_LOCATION_NAME) == 0);
+
+  ret = gst_tag_list_get_string (list, tag, &location);
+  ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_LONGITUDE,
+      &longitude);
+  ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_LATITUDE,
+      &latitude);
+  ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_ELEVATION,
+      &altitude);
+
+  if (!ret)
+    return;
+
+  if (location)
+    len = strlen (location);
+  size += len + 1 + 2;
+
+  /* role + (long, lat, alt) + body + notes */
+  size += 1 + 3 * 4 + 1 + 1;
+
+  data = ddata = g_malloc (size);
+
+  /* language tag */
+  GST_WRITE_UINT16_BE (data, language_code (GST_QT_MUX_DEFAULT_TAG_LANGUAGE));
+  /* location */
+  if (location)
+    memcpy (data + 2, location, len);
+  GST_WRITE_UINT8 (data + 2 + len, 0);
+  data += len + 1 + 2;
+  /* role */
+  GST_WRITE_UINT8 (data, 0);
+  /* long, lat, alt */
+  GST_WRITE_UINT32_BE (data + 1, (guint32) (longitude * 65536.0));
+  GST_WRITE_UINT32_BE (data + 5, (guint32) (latitude * 65536.0));
+  GST_WRITE_UINT32_BE (data + 9, (guint32) (altitude * 65536.0));
+  /* neither astronomical body nor notes */
+  GST_WRITE_UINT16_BE (data + 13, 0);
+
+  GST_DEBUG_OBJECT (qtmux, "Adding tag 'loci'");
+  atom_moov_add_3gp_tag (qtmux->moov, fourcc, ddata, size);
+  g_free (ddata);
+}
+
+static void
+gst_qt_mux_add_3gp_keywords (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  gchar *keywords = NULL;
+  guint8 *data, *ddata;
+  gint size = 0, i;
+  gchar **kwds;
+
+  g_return_if_fail (strcmp (tag, GST_TAG_KEYWORDS) == 0);
+
+  if (!gst_tag_list_get_string (list, tag, &keywords) || !keywords)
+    return;
+
+  kwds = g_strsplit (keywords, ",", 0);
+  g_free (keywords);
+
+  size = 0;
+  for (i = 0; kwds[i]; i++) {
+    /* size byte + null-terminator */
+    size += strlen (kwds[i]) + 1 + 1;
+  }
+
+  /* language tag + count + keywords */
+  size += 2 + 1;
+
+  data = ddata = g_malloc (size);
+
+  /* language tag */
+  GST_WRITE_UINT16_BE (data, language_code (GST_QT_MUX_DEFAULT_TAG_LANGUAGE));
+  /* count */
+  GST_WRITE_UINT8 (data + 2, i);
+  data += 3;
+  /* keywords */
+  for (i = 0; kwds[i]; ++i) {
+    gint len = strlen (kwds[i]);
+
+    GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",
+        GST_FOURCC_ARGS (fourcc), kwds[i]);
+    /* size */
+    GST_WRITE_UINT8 (data, len + 1);
+    memcpy (data + 1, kwds[i], len + 1);
+    data += len + 2;
+  }
+
+  g_strfreev (kwds);
+
+  atom_moov_add_3gp_tag (qtmux->moov, fourcc, ddata, size);
+  g_free (ddata);
+}
+
+static gboolean
+gst_qt_mux_parse_classification_string (GstQTMux * qtmux, const gchar * input,
+    guint32 * p_fourcc, guint16 * p_table, gchar ** p_content)
+{
+  guint32 fourcc;
+  gint table;
+  gint size;
+  const gchar *data;
+
+  data = input;
+  size = strlen (input);
+
+  if (size < 4 + 3 + 1 + 1 + 1) {
+    /* at least the minimum xxxx://y/z */
+    GST_WARNING_OBJECT (qtmux, "Classification tag input (%s) too short, "
+        "ignoring", input);
+    return FALSE;
+  }
+
+  /* read the fourcc */
+  memcpy (&fourcc, data, 4);
+  size -= 4;
+  data += 4;
+
+  if (strncmp (data, "://", 3) != 0) {
+    goto mismatch;
+  }
+  data += 3;
+  size -= 3;
+
+  /* read the table number */
+  if (sscanf (data, "%d", &table) != 1) {
+    goto mismatch;
+  }
+  if (table < 0) {
+    GST_WARNING_OBJECT (qtmux, "Invalid table number in classification tag (%d)"
+        ", table numbers should be positive, ignoring tag", table);
+    return FALSE;
+  }
+
+  /* find the next / */
+  while (size > 0 && data[0] != '/') {
+    data += 1;
+    size -= 1;
+  }
+  if (size == 0) {
+    goto mismatch;
+  }
+  g_assert (data[0] == '/');
+
+  /* skip the '/' */
+  data += 1;
+  size -= 1;
+  if (size == 0) {
+    goto mismatch;
+  }
+
+  /* read up the rest of the string */
+  *p_content = g_strdup (data);
+  *p_table = (guint16) table;
+  *p_fourcc = fourcc;
+  return TRUE;
+
+mismatch:
+  {
+    GST_WARNING_OBJECT (qtmux, "Ignoring classification tag as "
+        "input (%s) didn't match the expected entitycode://table/content",
+        input);
+    return FALSE;
+  }
+}
+
+static void
+gst_qt_mux_add_3gp_classification (GstQTMux * qtmux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc)
+{
+  gchar *clsf_data = NULL;
+  gint size = 0;
+  guint32 entity = 0;
+  guint16 table = 0;
+  gchar *content = NULL;
+  guint8 *data;
+
+  g_return_if_fail (strcmp (tag, GST_TAG_3GP_CLASSIFICATION) == 0);
+
+  if (!gst_tag_list_get_string (list, tag, &clsf_data) || !clsf_data)
+    return;
+
+  GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",
+      GST_FOURCC_ARGS (fourcc), clsf_data);
+
+  /* parse the string, format is:
+   * entityfourcc://table/content
+   */
+  gst_qt_mux_parse_classification_string (qtmux, clsf_data, &entity, &table,
+      &content);
+  g_free (clsf_data);
+  /* +1 for the \0 */
+  size = strlen (content) + 1;
+
+  /* now we have everything, build the atom
+   * atom description is at 3GPP TS 26.244 V8.2.0 (2009-09) */
+  data = g_malloc (4 + 2 + 2 + size);
+  GST_WRITE_UINT32_LE (data, entity);
+  GST_WRITE_UINT16_BE (data + 4, (guint16) table);
+  GST_WRITE_UINT16_BE (data + 6, 0);
+  memcpy (data + 8, content, size);
+  g_free (content);
+
+  atom_moov_add_3gp_tag (qtmux->moov, fourcc, data, 4 + 2 + 2 + size);
+  g_free (data);
+}
+
+typedef void (*GstQTMuxAddTagFunc) (GstQTMux * mux, const GstTagList * list,
+    const char *tag, const char *tag2, guint32 fourcc);
+
+/*
+ * Struct to record mappings from gstreamer tags to fourcc codes
+ */
+typedef struct _GstTagToFourcc
+{
+  guint32 fourcc;
+  const gchar *gsttag;
+  const gchar *gsttag2;
+  const GstQTMuxAddTagFunc func;
+} GstTagToFourcc;
+
+/* tag list tags to fourcc matching */
+static const GstTagToFourcc tag_matches_mp4[] = {
+  {FOURCC__alb, GST_TAG_ALBUM, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_soal, GST_TAG_ALBUM_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__ART, GST_TAG_ARTIST, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_soar, GST_TAG_ARTIST_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_aART, GST_TAG_ALBUM_ARTIST, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_soaa, GST_TAG_ALBUM_ARTIST_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__cmt, GST_TAG_COMMENT, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__wrt, GST_TAG_COMPOSER, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_soco, GST_TAG_COMPOSER_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_tvsh, GST_TAG_SHOW_NAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_sosn, GST_TAG_SHOW_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_tvsn, GST_TAG_SHOW_SEASON_NUMBER, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_tves, GST_TAG_SHOW_EPISODE_NUMBER, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__gen, GST_TAG_GENRE, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__nam, GST_TAG_TITLE, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_sonm, GST_TAG_TITLE_SORTNAME, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_perf, GST_TAG_PERFORMER, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__grp, GST_TAG_GROUPING, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__des, GST_TAG_DESCRIPTION, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__lyr, GST_TAG_LYRICS, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__too, GST_TAG_ENCODER, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_cprt, GST_TAG_COPYRIGHT, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_keyw, GST_TAG_KEYWORDS, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC__day, GST_TAG_DATE, NULL, gst_qt_mux_add_mp4_date},
+  {FOURCC_tmpo, GST_TAG_BEATS_PER_MINUTE, NULL, gst_qt_mux_add_mp4_tag},
+  {FOURCC_trkn, GST_TAG_TRACK_NUMBER, GST_TAG_TRACK_COUNT,
+      gst_qt_mux_add_mp4_tag},
+  {FOURCC_disk, GST_TAG_ALBUM_VOLUME_NUMBER, GST_TAG_ALBUM_VOLUME_COUNT,
+      gst_qt_mux_add_mp4_tag},
+  {FOURCC_covr, GST_TAG_PREVIEW_IMAGE, NULL, gst_qt_mux_add_mp4_cover},
+  {0, NULL,}
+};
+
+static const GstTagToFourcc tag_matches_3gp[] = {
+  {FOURCC_titl, GST_TAG_TITLE, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_dscp, GST_TAG_DESCRIPTION, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_cprt, GST_TAG_COPYRIGHT, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_perf, GST_TAG_ARTIST, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_auth, GST_TAG_COMPOSER, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_gnre, GST_TAG_GENRE, NULL, gst_qt_mux_add_3gp_str},
+  {FOURCC_kywd, GST_TAG_KEYWORDS, NULL, gst_qt_mux_add_3gp_keywords},
+  {FOURCC_yrrc, GST_TAG_DATE, NULL, gst_qt_mux_add_3gp_date},
+  {FOURCC_albm, GST_TAG_ALBUM, GST_TAG_TRACK_NUMBER, gst_qt_mux_add_3gp_str},
+  {FOURCC_loci, GST_TAG_GEO_LOCATION_NAME, NULL, gst_qt_mux_add_3gp_location},
+  {FOURCC_clsf, GST_TAG_3GP_CLASSIFICATION, NULL,
+      gst_qt_mux_add_3gp_classification},
+  {0, NULL,}
+};
+
+/* qtdemux produces these for atoms it cannot parse */
+#define GST_QT_DEMUX_PRIVATE_TAG "private-qt-tag"
+
+static void
+gst_qt_mux_add_xmp_tags (GstQTMux * qtmux, const GstTagList * list)
+{
+  GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));
+  GstBuffer *xmp = NULL;
+
+  /* adobe specs only have 'quicktime' and 'mp4',
+   * but I guess we can extrapolate to gpp.
+   * Keep mj2 out for now as we don't add any tags for it yet.
+   * If you have further info about xmp on these formats, please share */
+  if (qtmux_klass->format == GST_QT_MUX_FORMAT_MJ2)
+    return;
+
+  GST_DEBUG_OBJECT (qtmux, "Adding xmp tags");
+
+  if (qtmux_klass->format == GST_QT_MUX_FORMAT_QT) {
+    xmp = gst_tag_xmp_writer_tag_list_to_xmp_buffer (GST_TAG_XMP_WRITER (qtmux),
+        list, TRUE);
+    if (xmp)
+      atom_moov_add_xmp_tags (qtmux->moov, xmp);
+  } else {
+    AtomInfo *ainfo;
+    /* for isom/mp4, it is a top level uuid atom */
+    xmp = gst_tag_xmp_writer_tag_list_to_xmp_buffer (GST_TAG_XMP_WRITER (qtmux),
+        list, TRUE);
+    if (xmp) {
+      ainfo = build_uuid_xmp_atom (xmp);
+      if (ainfo) {
+        qtmux->extra_atoms = g_slist_prepend (qtmux->extra_atoms, ainfo);
+      }
+    }
+  }
+  if (xmp)
+    gst_buffer_unref (xmp);
+}
+
+static void
+gst_qt_mux_add_metadata_tags (GstQTMux * qtmux, const GstTagList * list)
+{
+  GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));
+  guint32 fourcc;
+  gint i;
+  const gchar *tag, *tag2;
+  const GstTagToFourcc *tag_matches;
+
+  switch (qtmux_klass->format) {
+    case GST_QT_MUX_FORMAT_3GP:
+      tag_matches = tag_matches_3gp;
+      break;
+    case GST_QT_MUX_FORMAT_MJ2:
+      tag_matches = NULL;
+      break;
+    default:
+      /* sort of iTunes style for mp4 and QT (?) */
+      tag_matches = tag_matches_mp4;
+      break;
+  }
+
+  if (!tag_matches)
+    return;
+
+  for (i = 0; tag_matches[i].fourcc; i++) {
+    fourcc = tag_matches[i].fourcc;
+    tag = tag_matches[i].gsttag;
+    tag2 = tag_matches[i].gsttag2;
+
+    g_assert (tag_matches[i].func);
+    tag_matches[i].func (qtmux, list, tag, tag2, fourcc);
+  }
+
+  /* add unparsed blobs if present */
+  if (gst_tag_exists (GST_QT_DEMUX_PRIVATE_TAG)) {
+    guint num_tags;
+
+    num_tags = gst_tag_list_get_tag_size (list, GST_QT_DEMUX_PRIVATE_TAG);
+    for (i = 0; i < num_tags; ++i) {
+      const GValue *val;
+      GstBuffer *buf;
+      GstCaps *caps = NULL;
+
+      val = gst_tag_list_get_value_index (list, GST_QT_DEMUX_PRIVATE_TAG, i);
+      buf = (GstBuffer *) gst_value_get_mini_object (val);
+
+      if (buf && (caps = gst_buffer_get_caps (buf))) {
+        GstStructure *s;
+        const gchar *style = NULL;
+
+        GST_DEBUG_OBJECT (qtmux, "Found private tag %d/%d; size %d, caps %"
+            GST_PTR_FORMAT, i, num_tags, GST_BUFFER_SIZE (buf), caps);
+        s = gst_caps_get_structure (caps, 0);
+        if (s && (style = gst_structure_get_string (s, "style"))) {
+          /* try to prevent some style tag ending up into another variant
+           * (todo: make into a list if more cases) */
+          if ((strcmp (style, "itunes") == 0 &&
+                  qtmux_klass->format == GST_QT_MUX_FORMAT_MP4) ||
+              (strcmp (style, "iso") == 0 &&
+                  qtmux_klass->format == GST_QT_MUX_FORMAT_3GP)) {
+            GST_DEBUG_OBJECT (qtmux, "Adding private tag");
+            atom_moov_add_blob_tag (qtmux->moov, GST_BUFFER_DATA (buf),
+                GST_BUFFER_SIZE (buf));
+          }
+        }
+        gst_caps_unref (caps);
+      }
+    }
+  }
+
+  return;
+}
+
+/*
+ * Gets the tagsetter iface taglist and puts the known tags
+ * into the output stream
+ */
+static void
+gst_qt_mux_setup_metadata (GstQTMux * qtmux)
+{
+  const GstTagList *tags;
+
+  GST_OBJECT_LOCK (qtmux);
+  tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (qtmux));
+  GST_OBJECT_UNLOCK (qtmux);
+
+  GST_LOG_OBJECT (qtmux, "tags: %" GST_PTR_FORMAT, tags);
+
+  if (tags && !gst_tag_list_is_empty (tags)) {
+    GstTagList *copy = gst_tag_list_copy (tags);
+
+    GST_DEBUG_OBJECT (qtmux, "Removing bogus tags");
+    gst_tag_list_remove_tag (copy, GST_TAG_VIDEO_CODEC);
+    gst_tag_list_remove_tag (copy, GST_TAG_AUDIO_CODEC);
+    gst_tag_list_remove_tag (copy, GST_TAG_CONTAINER_FORMAT);
+
+    GST_DEBUG_OBJECT (qtmux, "Formatting tags");
+    gst_qt_mux_add_metadata_tags (qtmux, copy);
+    gst_qt_mux_add_xmp_tags (qtmux, copy);
+    gst_tag_list_free (copy);
+  } else {
+    GST_DEBUG_OBJECT (qtmux, "No tags received");
+  }
+}
+
+static inline GstBuffer *
+_gst_buffer_new_take_data (guint8 * data, guint size)
+{
+  GstBuffer *buf;
+
+  buf = gst_buffer_new ();
+  GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
+  GST_BUFFER_SIZE (buf) = size;
+
+  return buf;
+}
+
+static GstFlowReturn
+gst_qt_mux_send_buffer (GstQTMux * qtmux, GstBuffer * buf, guint64 * offset,
+    gboolean mind_fast)
+{
+  GstFlowReturn res;
+  guint8 *data;
+  guint size;
+
+  g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
+
+  data = GST_BUFFER_DATA (buf);
+  size = GST_BUFFER_SIZE (buf);
+
+  GST_LOG_OBJECT (qtmux, "sending buffer size %d", size);
+
+  if (mind_fast && qtmux->fast_start_file) {
+    gint ret;
+
+    GST_LOG_OBJECT (qtmux, "to temporary file");
+    ret = fwrite (data, sizeof (guint8), size, qtmux->fast_start_file);
+    gst_buffer_unref (buf);
+    if (ret != size)
+      goto write_error;
+    else
+      res = GST_FLOW_OK;
+  } else {
+    GST_LOG_OBJECT (qtmux, "downstream");
+
+    buf = gst_buffer_make_metadata_writable (buf);
+    gst_buffer_set_caps (buf, GST_PAD_CAPS (qtmux->srcpad));
+    res = gst_pad_push (qtmux->srcpad, buf);
+  }
+
+  if (G_LIKELY (offset))
+    *offset += size;
+
+  return res;
+
+  /* ERRORS */
+write_error:
+  {
+    GST_ELEMENT_ERROR (qtmux, RESOURCE, WRITE,
+        ("Failed to write to temporary file"), GST_ERROR_SYSTEM);
+    return GST_FLOW_ERROR;
+  }
+}
+
+static gboolean
+gst_qt_mux_seek_to_beginning (FILE * f)
+{
+#ifdef HAVE_FSEEKO
+  if (fseeko (f, (off_t) 0, SEEK_SET) != 0)
+    return FALSE;
+#elif defined (G_OS_UNIX) || defined (G_OS_WIN32)
+  if (lseek (fileno (f), (off_t) 0, SEEK_SET) == (off_t) - 1)
+    return FALSE;
+#else
+  if (fseek (f, (long) 0, SEEK_SET) != 0)
+    return FALSE;
+#endif
+  return TRUE;
+}
+
+static GstFlowReturn
+gst_qt_mux_send_buffered_data (GstQTMux * qtmux, guint64 * offset)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *buf = NULL;
+
+  if (fflush (qtmux->fast_start_file))
+    goto flush_failed;
+
+  if (!gst_qt_mux_seek_to_beginning (qtmux->fast_start_file))
+    goto seek_failed;
+
+  /* hm, this could all take a really really long time,
+   * but there may not be another way to get moov atom first
+   * (somehow optimize copy?) */
+  GST_DEBUG_OBJECT (qtmux, "Sending buffered data");
+  while (ret == GST_FLOW_OK) {
+    gint r;
+    const int bufsize = 4096;
+
+    buf = gst_buffer_new_and_alloc (bufsize);
+    r = fread (GST_BUFFER_DATA (buf), sizeof (guint8), bufsize,
+        qtmux->fast_start_file);
+    if (r == 0)
+      break;
+    GST_BUFFER_SIZE (buf) = r;
+    GST_LOG_OBJECT (qtmux, "Pushing buffered buffer of size %d", r);
+    ret = gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);
+    buf = NULL;
+  }
+  if (buf)
+    gst_buffer_unref (buf);
+
+  if (ftruncate (fileno (qtmux->fast_start_file), 0))
+    goto seek_failed;
+  if (!gst_qt_mux_seek_to_beginning (qtmux->fast_start_file))
+    goto seek_failed;
+
+  return ret;
+
+  /* ERRORS */
+flush_failed:
+  {
+    GST_ELEMENT_ERROR (qtmux, RESOURCE, WRITE,
+        ("Failed to flush temporary file"), GST_ERROR_SYSTEM);
+    ret = GST_FLOW_ERROR;
+    goto fail;
+  }
+seek_failed:
+  {
+    GST_ELEMENT_ERROR (qtmux, RESOURCE, SEEK,
+        ("Failed to seek temporary file"), GST_ERROR_SYSTEM);
+    ret = GST_FLOW_ERROR;
+    goto fail;
+  }
+fail:
+  {
+    /* clear descriptor so we don't remove temp file later on,
+     * might be possible to recover */
+    fclose (qtmux->fast_start_file);
+    qtmux->fast_start_file = NULL;
+    return ret;
+  }
+}
+
+/*
+ * Sends the initial mdat atom fields (size fields and fourcc type),
+ * the subsequent buffers are considered part of it's data.
+ * As we can't predict the amount of data that we are going to place in mdat
+ * we need to record the position of the size field in the stream so we can
+ * seek back to it later and update when the streams have finished.
+ */
+static GstFlowReturn
+gst_qt_mux_send_mdat_header (GstQTMux * qtmux, guint64 * off, guint64 size,
+    gboolean extended)
+{
+  Atom *node_header;
+  GstBuffer *buf;
+  guint8 *data = NULL;
+  guint64 offset = 0;
+
+  GST_DEBUG_OBJECT (qtmux, "Sending mdat's atom header, "
+      "size %" G_GUINT64_FORMAT, size);
+
+  node_header = g_malloc0 (sizeof (Atom));
+  node_header->type = FOURCC_mdat;
+  if (extended) {
+    /* use extended size */
+    node_header->size = 1;
+    node_header->extended_size = 0;
+    if (size)
+      node_header->extended_size = size + 16;
+  } else {
+    node_header->size = size + 8;
+  }
+
+  size = offset = 0;
+  if (atom_copy_data (node_header, &data, &size, &offset) == 0)
+    goto serialize_error;
+
+  buf = _gst_buffer_new_take_data (data, offset);
+  g_free (node_header);
+
+  GST_LOG_OBJECT (qtmux, "Pushing mdat start");
+  return gst_qt_mux_send_buffer (qtmux, buf, off, FALSE);
+
+  /* ERRORS */
+serialize_error:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Failed to serialize mdat"));
+    return GST_FLOW_ERROR;
+  }
+}
+
+/*
+ * We get the position of the mdat size field, seek back to it
+ * and overwrite with the real value
+ */
+static GstFlowReturn
+gst_qt_mux_update_mdat_size (GstQTMux * qtmux, guint64 mdat_pos,
+    guint64 mdat_size, guint64 * offset)
+{
+  GstEvent *event;
+  GstBuffer *buf;
+  gboolean large_file;
+
+  large_file = (mdat_size > MDAT_LARGE_FILE_LIMIT);
+
+  if (large_file)
+    mdat_pos += 8;
+
+  /* seek and rewrite the header */
+  event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
+      mdat_pos, GST_CLOCK_TIME_NONE, 0);
+  gst_pad_push_event (qtmux->srcpad, event);
+
+  if (large_file) {
+    buf = gst_buffer_new_and_alloc (sizeof (guint64));
+    GST_WRITE_UINT64_BE (GST_BUFFER_DATA (buf), mdat_size + 16);
+  } else {
+    guint8 *data;
+
+    buf = gst_buffer_new_and_alloc (16);
+    data = GST_BUFFER_DATA (buf);
+    GST_WRITE_UINT32_BE (data, 8);
+    GST_WRITE_UINT32_LE (data + 4, FOURCC_free);
+    GST_WRITE_UINT32_BE (data + 8, mdat_size + 8);
+    GST_WRITE_UINT32_LE (data + 12, FOURCC_mdat);
+  }
+
+  return gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);
+}
+
+static GstFlowReturn
+gst_qt_mux_send_ftyp (GstQTMux * qtmux, guint64 * off)
+{
+  GstBuffer *buf;
+  guint64 size = 0, offset = 0;
+  guint8 *data = NULL;
+
+  GST_DEBUG_OBJECT (qtmux, "Sending ftyp atom");
+
+  if (!atom_ftyp_copy_data (qtmux->ftyp, &data, &size, &offset))
+    goto serialize_error;
+
+  buf = _gst_buffer_new_take_data (data, offset);
+
+  GST_LOG_OBJECT (qtmux, "Pushing ftyp");
+  return gst_qt_mux_send_buffer (qtmux, buf, off, FALSE);
+
+  /* ERRORS */
+serialize_error:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Failed to serialize ftyp"));
+    return GST_FLOW_ERROR;
+  }
+}
+
+static void
+gst_qt_mux_prepare_ftyp (GstQTMux * qtmux, AtomFTYP ** p_ftyp,
+    GstBuffer ** p_prefix)
+{
+  GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));
+  guint32 major, version;
+  GList *comp;
+  GstBuffer *prefix = NULL;
+  AtomFTYP *ftyp = NULL;
+
+  GST_DEBUG_OBJECT (qtmux, "Preparing ftyp and possible prefix atom");
+
+  /* init and send context and ftyp based on current property state */
+  gst_qt_mux_map_format_to_header (qtmux_klass->format, &prefix, &major,
+      &version, &comp, qtmux->moov, qtmux->longest_chunk,
+      qtmux->fast_start_file != NULL);
+  ftyp = atom_ftyp_new (qtmux->context, major, version, comp);
+  if (comp)
+    g_list_free (comp);
+  if (prefix) {
+    if (p_prefix)
+      *p_prefix = prefix;
+    else
+      gst_buffer_unref (prefix);
+  }
+  *p_ftyp = ftyp;
+}
+
+static GstFlowReturn
+gst_qt_mux_prepare_and_send_ftyp (GstQTMux * qtmux)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *prefix = NULL;
+
+  GST_DEBUG_OBJECT (qtmux, "Preparing to send ftyp atom");
+
+  /* init and send context and ftyp based on current property state */
+  if (qtmux->ftyp) {
+    atom_ftyp_free (qtmux->ftyp);
+    qtmux->ftyp = NULL;
+  }
+  gst_qt_mux_prepare_ftyp (qtmux, &qtmux->ftyp, &prefix);
+  if (prefix) {
+    ret = gst_qt_mux_send_buffer (qtmux, prefix, &qtmux->header_size, FALSE);
+    if (ret != GST_FLOW_OK)
+      return ret;
+  }
+  return gst_qt_mux_send_ftyp (qtmux, &qtmux->header_size);
+}
+
+static void
+gst_qt_mux_set_header_on_caps (GstQTMux * mux, GstBuffer * buf)
+{
+  GstStructure *structure;
+  GValue array = { 0 };
+  GValue value = { 0 };
+  GstCaps *caps = GST_PAD_CAPS (mux->srcpad);
+
+  caps = gst_caps_copy (GST_PAD_CAPS (mux->srcpad));
+  structure = gst_caps_get_structure (caps, 0);
+
+  g_value_init (&array, GST_TYPE_ARRAY);
+
+  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
+  g_value_init (&value, GST_TYPE_BUFFER);
+  gst_value_take_buffer (&value, gst_buffer_ref (buf));
+  gst_value_array_append_value (&array, &value);
+  g_value_unset (&value);
+
+  gst_structure_set_value (structure, "streamheader", &array);
+  g_value_unset (&array);
+  gst_pad_set_caps (mux->srcpad, caps);
+  gst_caps_unref (caps);
+}
+
+static void
+gst_qt_mux_configure_moov (GstQTMux * qtmux, guint32 * _timescale)
+{
+  gboolean fragmented;
+  guint32 timescale;
+
+  GST_OBJECT_LOCK (qtmux);
+  timescale = qtmux->timescale;
+  fragmented = qtmux->fragment_sequence > 0;
+  GST_OBJECT_UNLOCK (qtmux);
+
+  /* inform lower layers of our property wishes, and determine duration.
+   * Let moov take care of this using its list of traks;
+   * so that released pads are also included */
+  GST_DEBUG_OBJECT (qtmux, "Updating timescale to %" G_GUINT32_FORMAT,
+      timescale);
+  atom_moov_update_timescale (qtmux->moov, timescale);
+  atom_moov_set_fragmented (qtmux->moov, fragmented);
+
+  atom_moov_update_duration (qtmux->moov);
+
+  if (_timescale)
+    *_timescale = timescale;
+}
+
+static GstFlowReturn
+gst_qt_mux_send_moov (GstQTMux * qtmux, guint64 * _offset, gboolean mind_fast)
+{
+  guint64 offset = 0, size = 0;
+  guint8 *data;
+  GstBuffer *buf;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  /* serialize moov */
+  offset = size = 0;
+  data = NULL;
+  GST_LOG_OBJECT (qtmux, "Copying movie header into buffer");
+  if (!atom_moov_copy_data (qtmux->moov, &data, &size, &offset))
+    goto serialize_error;
+
+  buf = _gst_buffer_new_take_data (data, offset);
+  GST_DEBUG_OBJECT (qtmux, "Pushing moov atoms");
+  gst_qt_mux_set_header_on_caps (qtmux, buf);
+  ret = gst_qt_mux_send_buffer (qtmux, buf, _offset, mind_fast);
+
+  return ret;
+
+serialize_error:
+  {
+    g_free (data);
+    return GST_FLOW_ERROR;
+  }
+}
+
+/* either calculates size of extra atoms or pushes them */
+static GstFlowReturn
+gst_qt_mux_send_extra_atoms (GstQTMux * qtmux, gboolean send, guint64 * offset,
+    gboolean mind_fast)
+{
+  GSList *walk;
+  guint64 loffset = 0, size = 0;
+  guint8 *data;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  for (walk = qtmux->extra_atoms; walk; walk = g_slist_next (walk)) {
+    AtomInfo *ainfo = (AtomInfo *) walk->data;
+
+    loffset = size = 0;
+    data = NULL;
+    if (!ainfo->copy_data_func (ainfo->atom,
+            send ? &data : NULL, &size, &loffset))
+      goto serialize_error;
+
+    if (send) {
+      GstBuffer *buf;
+
+      GST_DEBUG_OBJECT (qtmux,
+          "Pushing extra top-level atom %" GST_FOURCC_FORMAT,
+          GST_FOURCC_ARGS (ainfo->atom->type));
+      buf = _gst_buffer_new_take_data (data, loffset);
+      ret = gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);
+      if (ret != GST_FLOW_OK)
+        break;
+    } else {
+      if (offset)
+        *offset += loffset;
+    }
+  }
+
+  return ret;
+
+serialize_error:
+  {
+    g_free (data);
+    return GST_FLOW_ERROR;
+  }
+}
+
+static GstFlowReturn
+gst_qt_mux_start_file (GstQTMux * qtmux)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstCaps *caps;
+
+  GST_DEBUG_OBJECT (qtmux, "starting file");
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (qtmux->srcpad));
+  /* qtmux has structure with and without variant, remove all but the first */
+  while (gst_caps_get_size (caps) > 1)
+    gst_caps_remove_structure (caps, 1);
+  gst_pad_set_caps (qtmux->srcpad, caps);
+  gst_caps_unref (caps);
+
+  /* let downstream know we think in BYTES and expect to do seeking later on */
+  gst_pad_push_event (qtmux->srcpad,
+      gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0));
+
+  /* initialize our moov recovery file */
+  GST_OBJECT_LOCK (qtmux);
+  if (qtmux->moov_recov_file_path) {
+    GST_DEBUG_OBJECT (qtmux, "Openning moov recovery file: %s",
+        qtmux->moov_recov_file_path);
+    qtmux->moov_recov_file = g_fopen (qtmux->moov_recov_file_path, "wb+");
+    if (qtmux->moov_recov_file == NULL) {
+      GST_WARNING_OBJECT (qtmux, "Failed to open moov recovery file in %s",
+          qtmux->moov_recov_file_path);
+    } else {
+      GSList *walk;
+      gboolean fail = FALSE;
+      AtomFTYP *ftyp = NULL;
+      GstBuffer *prefix = NULL;
+
+      gst_qt_mux_prepare_ftyp (qtmux, &ftyp, &prefix);
+
+      if (!atoms_recov_write_headers (qtmux->moov_recov_file, ftyp, prefix,
+              qtmux->moov, qtmux->timescale,
+              g_slist_length (qtmux->sinkpads))) {
+        GST_WARNING_OBJECT (qtmux, "Failed to write moov recovery file "
+            "headers");
+        fail = TRUE;
+      }
+
+      atom_ftyp_free (ftyp);
+      if (prefix)
+        gst_buffer_unref (prefix);
+
+      for (walk = qtmux->sinkpads; walk && !fail; walk = g_slist_next (walk)) {
+        GstCollectData *cdata = (GstCollectData *) walk->data;
+        GstQTPad *qpad = (GstQTPad *) cdata;
+        /* write info for each stream */
+        fail = atoms_recov_write_trak_info (qtmux->moov_recov_file, qpad->trak);
+        if (fail) {
+          GST_WARNING_OBJECT (qtmux, "Failed to write trak info to recovery "
+              "file");
+        }
+      }
+      if (fail) {
+        /* cleanup */
+        fclose (qtmux->moov_recov_file);
+        qtmux->moov_recov_file = NULL;
+        GST_WARNING_OBJECT (qtmux, "An error was detected while writing to "
+            "recover file, moov recovery won't work");
+      }
+    }
+  }
+  GST_OBJECT_UNLOCK (qtmux);
+
+  /* 
+   * send mdat header if already needed, and mark position for later update.
+   * We don't send ftyp now if we are on fast start mode, because we can
+   * better fine tune using the information we gather to create the whole moov
+   * atom.
+   */
+  if (qtmux->fast_start) {
+    GST_OBJECT_LOCK (qtmux);
+    qtmux->fast_start_file = g_fopen (qtmux->fast_start_file_path, "wb+");
+    if (!qtmux->fast_start_file)
+      goto open_failed;
+    GST_OBJECT_UNLOCK (qtmux);
+
+    /* send a dummy buffer for preroll */
+    ret = gst_qt_mux_send_buffer (qtmux, gst_buffer_new (), NULL, FALSE);
+    if (ret != GST_FLOW_OK)
+      goto exit;
+
+  } else {
+    ret = gst_qt_mux_prepare_and_send_ftyp (qtmux);
+    if (ret != GST_FLOW_OK) {
+      goto exit;
+    }
+
+    /* well, it's moov pos if fragmented ... */
+    qtmux->mdat_pos = qtmux->header_size;
+
+    if (qtmux->fragment_duration) {
+      GST_DEBUG_OBJECT (qtmux, "fragment duration %d ms, writing headers",
+          qtmux->fragment_duration);
+      /* also used as snapshot marker to indicate fragmented file */
+      qtmux->fragment_sequence = 1;
+      /* prepare moov and/or tags */
+      gst_qt_mux_configure_moov (qtmux, NULL);
+      gst_qt_mux_setup_metadata (qtmux);
+      ret = gst_qt_mux_send_moov (qtmux, &qtmux->header_size, FALSE);
+      if (ret != GST_FLOW_OK)
+        return ret;
+      /* extra atoms */
+      ret =
+          gst_qt_mux_send_extra_atoms (qtmux, TRUE, &qtmux->header_size, FALSE);
+      if (ret != GST_FLOW_OK)
+        return ret;
+      /* prepare index */
+      if (!qtmux->streamable)
+        qtmux->mfra = atom_mfra_new (qtmux->context);
+    } else {
+      /* extended to ensure some spare space */
+      ret = gst_qt_mux_send_mdat_header (qtmux, &qtmux->header_size, 0, TRUE);
+    }
+  }
+
+exit:
+  return ret;
+
+  /* ERRORS */
+open_failed:
+  {
+    GST_ELEMENT_ERROR (qtmux, RESOURCE, OPEN_READ_WRITE,
+        (("Could not open temporary file \"%s\""), qtmux->fast_start_file_path),
+        GST_ERROR_SYSTEM);
+    GST_OBJECT_UNLOCK (qtmux);
+    return GST_FLOW_ERROR;
+  }
+}
+
+static GstFlowReturn
+gst_qt_mux_stop_file (GstQTMux * qtmux)
+{
+  gboolean ret = GST_FLOW_OK;
+  guint64 offset = 0, size = 0;
+  GSList *walk;
+  gboolean large_file;
+  guint32 timescale;
+  GstClockTime first_ts = GST_CLOCK_TIME_NONE;
+
+  GST_DEBUG_OBJECT (qtmux, "Updating remaining values and sending last data");
+
+  /* pushing last buffers for each pad */
+  for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {
+    GstCollectData *cdata = (GstCollectData *) walk->data;
+    GstQTPad *qtpad = (GstQTPad *) cdata;
+
+    /* send last buffer */
+    GST_DEBUG_OBJECT (qtmux, "Sending the last buffer for pad %s",
+        GST_PAD_NAME (qtpad->collect.pad));
+    ret = gst_qt_mux_add_buffer (qtmux, qtpad, NULL);
+    if (ret != GST_FLOW_OK)
+      GST_WARNING_OBJECT (qtmux, "Failed to send last buffer for %s, "
+          "flow return: %s", GST_PAD_NAME (qtpad->collect.pad),
+          gst_flow_get_name (ret));
+
+    if (!GST_CLOCK_TIME_IS_VALID (qtpad->first_ts)) {
+      GST_DEBUG_OBJECT (qtmux, "Pad %s has no buffers",
+          GST_PAD_NAME (qtpad->collect.pad));
+      continue;
+    }
+
+    /* determine max stream duration */
+    if (!GST_CLOCK_TIME_IS_VALID (first_ts) ||
+        (GST_CLOCK_TIME_IS_VALID (qtpad->first_ts) &&
+            qtpad->last_dts > first_ts)) {
+      first_ts = qtpad->last_dts;
+    }
+  }
+
+  if (qtmux->fragment_sequence) {
+    GstEvent *event;
+
+    if (qtmux->mfra) {
+      guint8 *data = NULL;
+      GstBuffer *buf;
+
+      size = offset = 0;
+      GST_DEBUG_OBJECT (qtmux, "adding mfra");
+      if (!atom_mfra_copy_data (qtmux->mfra, &data, &size, &offset))
+        goto serialize_error;
+      buf = _gst_buffer_new_take_data (data, offset);
+      ret = gst_qt_mux_send_buffer (qtmux, buf, NULL, FALSE);
+      if (ret != GST_FLOW_OK)
+        return ret;
+    } else {
+      /* must have been streamable; no need to write duration */
+      GST_DEBUG_OBJECT (qtmux, "streamable file; nothing to stop");
+      return GST_FLOW_OK;
+    }
+
+
+    timescale = qtmux->timescale;
+    /* only mvex duration is updated,
+     * mvhd should be consistent with empty moov
+     * (but TODO maybe some clients do not handle that well ?) */
+    qtmux->moov->mvex.mehd.fragment_duration =
+        gst_util_uint64_scale (first_ts, timescale, GST_SECOND);
+    GST_DEBUG_OBJECT (qtmux, "rewriting moov with mvex duration %"
+        GST_TIME_FORMAT, GST_TIME_ARGS (first_ts));
+    /* seek and rewrite the header */
+    event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
+        qtmux->mdat_pos, GST_CLOCK_TIME_NONE, 0);
+    gst_pad_push_event (qtmux->srcpad, event);
+    /* no need to seek back */
+    return gst_qt_mux_send_moov (qtmux, NULL, FALSE);
+  }
+
+  gst_qt_mux_configure_moov (qtmux, &timescale);
+
+  /* check for late streams */
+  first_ts = GST_CLOCK_TIME_NONE;
+  for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {
+    GstCollectData *cdata = (GstCollectData *) walk->data;
+    GstQTPad *qtpad = (GstQTPad *) cdata;
+
+    if (!GST_CLOCK_TIME_IS_VALID (first_ts) ||
+        (GST_CLOCK_TIME_IS_VALID (qtpad->first_ts) &&
+            qtpad->first_ts < first_ts)) {
+      first_ts = qtpad->first_ts;
+    }
+  }
+  GST_DEBUG_OBJECT (qtmux, "Media first ts selected: %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (first_ts));
+  /* add EDTSs for late streams */
+  for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {
+    GstCollectData *cdata = (GstCollectData *) walk->data;
+    GstQTPad *qtpad = (GstQTPad *) cdata;
+    guint32 lateness;
+    guint32 duration;
+
+    if (GST_CLOCK_TIME_IS_VALID (qtpad->first_ts) &&
+        qtpad->first_ts > first_ts + MAX_TOLERATED_LATENESS) {
+      GST_DEBUG_OBJECT (qtmux, "Pad %s is a late stream by %" GST_TIME_FORMAT,
+          GST_PAD_NAME (qtpad->collect.pad),
+          GST_TIME_ARGS (qtpad->first_ts - first_ts));
+      lateness = gst_util_uint64_scale_round (qtpad->first_ts - first_ts,
+          timescale, GST_SECOND);
+      duration = qtpad->trak->tkhd.duration;
+      atom_trak_add_elst_entry (qtpad->trak, lateness, (guint32) - 1,
+          (guint32) (1 * 65536.0));
+      atom_trak_add_elst_entry (qtpad->trak, duration, 0,
+          (guint32) (1 * 65536.0));
+
+      /* need to add the empty time to the trak duration */
+      qtpad->trak->tkhd.duration += lateness;
+    }
+  }
+
+  /* tags into file metadata */
+  gst_qt_mux_setup_metadata (qtmux);
+
+  large_file = (qtmux->mdat_size > MDAT_LARGE_FILE_LIMIT);
+  /* if faststart, update the offset of the atoms in the movie with the offset
+   * that the movie headers before mdat will cause.
+   * Also, send the ftyp */
+  if (qtmux->fast_start_file) {
+    GstFlowReturn flow_ret;
+    offset = size = 0;
+
+    flow_ret = gst_qt_mux_prepare_and_send_ftyp (qtmux);
+    if (flow_ret != GST_FLOW_OK) {
+      goto ftyp_error;
+    }
+    /* copy into NULL to obtain size */
+    if (!atom_moov_copy_data (qtmux->moov, NULL, &size, &offset))
+      goto serialize_error;
+    GST_DEBUG_OBJECT (qtmux, "calculated moov atom size %" G_GUINT64_FORMAT,
+        offset);
+    offset += qtmux->header_size + (large_file ? 16 : 8);
+
+    /* sum up with the extra atoms size */
+    ret = gst_qt_mux_send_extra_atoms (qtmux, FALSE, &offset, FALSE);
+    if (ret != GST_FLOW_OK)
+      return ret;
+  } else {
+    offset = qtmux->header_size;
+  }
+  atom_moov_chunks_add_offset (qtmux->moov, offset);
+
+  /* moov */
+  /* note: as of this point, we no longer care about tracking written data size,
+   * since there is no more use for it anyway */
+  ret = gst_qt_mux_send_moov (qtmux, NULL, FALSE);
+  if (ret != GST_FLOW_OK)
+    return ret;
+
+  /* extra atoms */
+  ret = gst_qt_mux_send_extra_atoms (qtmux, TRUE, NULL, FALSE);
+  if (ret != GST_FLOW_OK)
+    return ret;
+
+  /* if needed, send mdat atom and move buffered data into it */
+  if (qtmux->fast_start_file) {
+    /* mdat_size = accumulated (buffered data) */
+    ret = gst_qt_mux_send_mdat_header (qtmux, NULL, qtmux->mdat_size,
+        large_file);
+    if (ret != GST_FLOW_OK)
+      return ret;
+    ret = gst_qt_mux_send_buffered_data (qtmux, NULL);
+    if (ret != GST_FLOW_OK)
+      return ret;
+  } else {
+    /* mdat needs update iff not using faststart */
+    GST_DEBUG_OBJECT (qtmux, "updating mdat size");
+    ret = gst_qt_mux_update_mdat_size (qtmux, qtmux->mdat_pos,
+        qtmux->mdat_size, NULL);
+    /* note; no seeking back to the end of file is done,
+     * since we no longer write anything anyway */
+  }
+
+  return ret;
+
+  /* ERRORS */
+serialize_error:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Failed to serialize moov"));
+    return GST_FLOW_ERROR;
+  }
+ftyp_error:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL), ("Failed to send ftyp"));
+    return GST_FLOW_ERROR;
+  }
+}
+
+static GstFlowReturn
+gst_qt_mux_pad_fragment_add_buffer (GstQTMux * qtmux, GstQTPad * pad,
+    GstBuffer * buf, gboolean force, guint32 nsamples, gint64 dts,
+    guint32 delta, guint32 size, gboolean sync, gint64 pts_offset)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  /* setup if needed */
+  if (G_UNLIKELY (!pad->traf || force))
+    goto init;
+
+flush:
+  /* flush pad fragment if threshold reached,
+   * or at new keyframe if we should be minding those in the first place */
+  if (G_UNLIKELY (force || (sync && pad->sync) ||
+          pad->fragment_duration < (gint64) delta)) {
+    AtomMOOF *moof;
+    guint64 size = 0, offset = 0;
+    guint8 *data = NULL;
+    GstBuffer *buffer;
+    guint i, total_size;
+
+    /* now we know where moof ends up, update offset in tfra */
+    if (pad->tfra)
+      atom_tfra_update_offset (pad->tfra, qtmux->header_size);
+
+    moof = atom_moof_new (qtmux->context, qtmux->fragment_sequence);
+    /* takes ownership */
+    atom_moof_add_traf (moof, pad->traf);
+    pad->traf = NULL;
+    atom_moof_copy_data (moof, &data, &size, &offset);
+    buffer = _gst_buffer_new_take_data (data, offset);
+    GST_LOG_OBJECT (qtmux, "writing moof size %d", GST_BUFFER_SIZE (buffer));
+    ret = gst_qt_mux_send_buffer (qtmux, buffer, &qtmux->header_size, FALSE);
+
+    /* and actual data */
+    total_size = 0;
+    for (i = 0; i < atom_array_get_len (&pad->fragment_buffers); i++) {
+      total_size +=
+          GST_BUFFER_SIZE (atom_array_index (&pad->fragment_buffers, i));
+    }
+
+    GST_LOG_OBJECT (qtmux, "writing %d buffers, total_size %d",
+        atom_array_get_len (&pad->fragment_buffers), total_size);
+    if (ret == GST_FLOW_OK)
+      ret = gst_qt_mux_send_mdat_header (qtmux, &qtmux->header_size, total_size,
+          FALSE);
+    for (i = 0; i < atom_array_get_len (&pad->fragment_buffers); i++) {
+      if (G_LIKELY (ret == GST_FLOW_OK))
+        ret = gst_qt_mux_send_buffer (qtmux,
+            atom_array_index (&pad->fragment_buffers, i), &qtmux->header_size,
+            FALSE);
+      else
+        gst_buffer_unref (atom_array_index (&pad->fragment_buffers, i));
+    }
+
+    atom_array_clear (&pad->fragment_buffers);
+    atom_moof_free (moof);
+    qtmux->fragment_sequence++;
+    force = FALSE;
+  }
+
+init:
+  if (G_UNLIKELY (!pad->traf)) {
+    GST_LOG_OBJECT (qtmux, "setting up new fragment");
+    pad->traf = atom_traf_new (qtmux->context, atom_trak_get_id (pad->trak));
+    atom_array_init (&pad->fragment_buffers, 512);
+    pad->fragment_duration = gst_util_uint64_scale (qtmux->fragment_duration,
+        atom_trak_get_timescale (pad->trak), 1000);
+
+    if (G_UNLIKELY (qtmux->mfra && !pad->tfra)) {
+      pad->tfra = atom_tfra_new (qtmux->context, atom_trak_get_id (pad->trak));
+      atom_mfra_add_tfra (qtmux->mfra, pad->tfra);
+    }
+  }
+
+  /* add buffer and metadata */
+  atom_traf_add_samples (pad->traf, delta, size, sync, pts_offset,
+      pad->sync && sync);
+  atom_array_append (&pad->fragment_buffers, buf, 256);
+  pad->fragment_duration -= delta;
+
+  if (pad->tfra) {
+    guint32 sn = atom_traf_get_sample_num (pad->traf);
+
+    if ((sync && pad->sync) || (sn == 1 && !pad->sync))
+      atom_tfra_add_entry (pad->tfra, dts, sn);
+  }
+
+  if (G_UNLIKELY (force))
+    goto flush;
+
+  return ret;
+}
+
+/* sigh, tiny list helpers to re-order stuff */
+static void
+gst_qt_mux_push_ts (GstQTMux * qtmux, GstQTPad * pad, GstClockTime ts)
+{
+  gint i;
+
+  for (i = 0; (i < QTMUX_NO_OF_TS) && (i < pad->ts_n_entries); i++) {
+    if (ts > pad->ts_entries[i])
+      break;
+  }
+  memmove (&pad->ts_entries[i + 1], &pad->ts_entries[i],
+      sizeof (GstClockTime) * (pad->ts_n_entries - i));
+  pad->ts_entries[i] = ts;
+  pad->ts_n_entries++;
+}
+
+/* takes ownership of @buf */
+static GstBuffer *
+gst_qt_mux_get_asc_buffer_ts (GstQTMux * qtmux, GstQTPad * pad, GstBuffer * buf)
+{
+  const gint wrap = G_N_ELEMENTS (pad->buf_entries);
+  GstClockTime ts;
+
+  /* store buffer and ts, latter ordered */
+  if (buf) {
+    pad->buf_entries[pad->buf_tail++] = buf;
+    pad->buf_tail %= wrap;
+    gst_qt_mux_push_ts (qtmux, pad, GST_BUFFER_TIMESTAMP (buf));
+  }
+
+  if (pad->ts_n_entries && (!buf || pad->ts_n_entries >= QTMUX_NO_OF_TS)) {
+    ts = pad->ts_entries[--pad->ts_n_entries];
+    buf = pad->buf_entries[pad->buf_head];
+    pad->buf_entries[pad->buf_head++] = NULL;
+    pad->buf_head %= wrap;
+    buf = gst_buffer_make_metadata_writable (buf);
+    /* track original ts (= pts ?) for later */
+    GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_TIMESTAMP (buf);
+    GST_BUFFER_TIMESTAMP (buf) = ts;
+    GST_DEBUG_OBJECT (qtmux, "next buffer uses reordered ts %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (ts));
+  } else {
+    buf = NULL;
+  }
+
+  return buf;
+}
+
+/*
+ * Here we push the buffer and update the tables in the track atoms
+ */
+static GstFlowReturn
+gst_qt_mux_add_buffer (GstQTMux * qtmux, GstQTPad * pad, GstBuffer * buf)
+{
+  GstBuffer *last_buf = NULL;
+  GstClockTime duration;
+  guint nsamples, sample_size;
+  guint64 chunk_offset;
+  gint64 last_dts, scaled_duration;
+  gint64 pts_offset = 0;
+  gboolean sync = FALSE, do_pts = FALSE;
+  gboolean drain = (buf == NULL);
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  if (!pad->fourcc)
+    goto not_negotiated;
+
+  /* if this pad has a prepare function, call it */
+  if (pad->prepare_buf_func != NULL) {
+    buf = pad->prepare_buf_func (pad, buf, qtmux);
+  }
+
+again:
+  last_buf = pad->last_buf;
+  if (G_UNLIKELY (qtmux->dts_method == DTS_METHOD_REORDER)) {
+    buf = gst_qt_mux_get_asc_buffer_ts (qtmux, pad, buf);
+    if (!buf && !last_buf) {
+      GST_DEBUG_OBJECT (qtmux, "no reordered buffer");
+      return GST_FLOW_OK;
+    }
+  }
+
+  if (last_buf == NULL) {
+#ifndef GST_DISABLE_GST_DEBUG
+    if (buf == NULL) {
+      GST_DEBUG_OBJECT (qtmux, "Pad %s has no previous buffer stored and "
+          "received NULL buffer, doing nothing",
+          GST_PAD_NAME (pad->collect.pad));
+    } else {
+      GST_LOG_OBJECT (qtmux,
+          "Pad %s has no previous buffer stored, storing now",
+          GST_PAD_NAME (pad->collect.pad));
+    }
+#endif
+    pad->last_buf = buf;
+    goto exit;
+  } else
+    gst_buffer_ref (last_buf);
+
+  /* nasty heuristic mess to guestimate dealing with DTS/PTS,
+   * while also trying to stay close to input ts to preserve sync,
+   * so in DTS_METHOD_DD:
+   * - prefer using input ts where possible
+   * - if those detected out-of-order (*), mark as out-of-order
+   * - if in out-of-order, then
+   *   - if duration available, use that as delta
+   *     Also mind to preserve sync between streams, and adding
+   *     durations might drift, so try to resync when we expect
+   *     input ts == (sum of durations), which is at some keyframe input frame.
+   *   - if no duration available, we are actually in serious trouble and need
+   *     to hack around that, so we fail.
+   * To remedy failure, alternatively, in DTS_METHOD_REORDER:
+   * - collect some buffers and re-order timestamp,
+   *   then process the oldest buffer with smallest timestamps.
+   *   This should typically compensate for some codec's handywork with ts.
+   * ... but in case this makes ts end up where not expected, in DTS_METHOD_ASC:
+   * - keep each ts with its buffer and still keep a list of most recent X ts,
+   *   use the (ascending) minimum of those as DTS (and the difference as ts delta),
+   *   and use this DTS as a basis to obtain a (positive) CTS offset.
+   *   This should yield exact PTS == buffer ts, but it seems not all players
+   *   out there are aware of ctts pts ...
+   *
+   * 0.11 Phew, can we (pretty) please please sort out DTS/PTS on buffers ...
+   */
+  if (G_LIKELY (buf) && !pad->is_out_of_order) {
+    if (G_LIKELY (GST_BUFFER_TIMESTAMP_IS_VALID (last_buf) &&
+            GST_BUFFER_TIMESTAMP_IS_VALID (buf))) {
+      if ((GST_BUFFER_TIMESTAMP (buf) < GST_BUFFER_TIMESTAMP (last_buf))) {
+        GST_DEBUG_OBJECT (qtmux, "detected out-of-order input");
+        pad->is_out_of_order = TRUE;
+      }
+    } else {
+      /* this is pretty bad */
+      GST_WARNING_OBJECT (qtmux, "missing input timestamp");
+      /* fall back to durations */
+      pad->is_out_of_order = TRUE;
+    }
+  }
+
+  /* would have to be some unusual input, but not impossible */
+  if (G_UNLIKELY (qtmux->dts_method == DTS_METHOD_REORDER &&
+          pad->is_out_of_order)) {
+    goto no_order;
+  }
+
+  /* fall back to duration if last buffer or
+   * out-of-order (determined previously), otherwise use input ts */
+  if (buf == NULL ||
+      (pad->is_out_of_order && qtmux->dts_method == DTS_METHOD_DD)) {
+    if (!GST_BUFFER_DURATION_IS_VALID (last_buf)) {
+      /* be forgiving for some possibly last upstream flushed buffer */
+      if (buf)
+        goto no_time;
+      GST_WARNING_OBJECT (qtmux, "no duration for last buffer");
+      /* iso spec recommends some small value, try 0 */
+      duration = 0;
+    } else {
+      duration = GST_BUFFER_DURATION (last_buf);
+      /* avoid drift in sum timestamps,
+       * so use input timestamp for suitable keyframe */
+      if (buf && !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT) &&
+          GST_BUFFER_TIMESTAMP (buf) >= pad->last_dts) {
+        GST_DEBUG_OBJECT (qtmux, "resyncing out-of-order input to ts; "
+            "replacing %" GST_TIME_FORMAT " by %" GST_TIME_FORMAT,
+            GST_TIME_ARGS (pad->last_dts + duration),
+            GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
+        duration = GST_BUFFER_TIMESTAMP (buf) - pad->last_dts;
+      }
+    }
+  } else if (qtmux->dts_method != DTS_METHOD_ASC) {
+    duration = GST_BUFFER_TIMESTAMP (buf) - GST_BUFFER_TIMESTAMP (last_buf);
+  } else {
+    GstClockTime ts;
+
+    g_assert (qtmux->dts_method == DTS_METHOD_ASC);
+    if (!qtmux->guess_pts)
+      goto need_pts;
+
+    /* add timestamp to queue; keeps in descending order */
+    gst_qt_mux_push_ts (qtmux, pad, GST_BUFFER_TIMESTAMP (last_buf));
+    /* chuck out smallest/last one if we have enough */
+    if (G_LIKELY (pad->ts_n_entries > QTMUX_NO_OF_TS))
+      pad->ts_n_entries--;
+    /* peek the now smallest timestamp */
+    ts = pad->ts_entries[pad->ts_n_entries - 1];
+    /* these tails are expected to be (strictly) ascending with
+     * large enough history */
+    GST_DEBUG_OBJECT (qtmux, "ASC method; base timestamp %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (ts));
+    if (ts >= pad->last_dts) {
+      duration = ts - pad->last_dts;
+    } else {
+      /* fallback to previous value, negative ct offset might handle */
+      GST_WARNING_OBJECT (qtmux, "unexpected decrease in timestamp");
+      duration = 0;
+    }
+    /* arrange for small non-zero duration/delta << expected frame time */
+    ts = gst_util_uint64_scale (10, GST_SECOND,
+        atom_trak_get_timescale (pad->trak));
+    duration = MAX (duration, ts);
+  }
+
+  gst_buffer_replace (&pad->last_buf, buf);
+
+  last_dts = gst_util_uint64_scale_round (pad->last_dts,
+      atom_trak_get_timescale (pad->trak), GST_SECOND);
+
+  /* fragments only deal with 1 buffer == 1 chunk (== 1 sample) */
+  if (pad->sample_size && !qtmux->fragment_sequence) {
+    /* Constant size packets: usually raw audio (with many samples per
+       buffer (= chunk)), but can also be fixed-packet-size codecs like ADPCM
+     */
+    sample_size = pad->sample_size;
+    if (GST_BUFFER_SIZE (last_buf) % sample_size != 0)
+      goto fragmented_sample;
+    /* note: qt raw audio storage warps it implicitly into a timewise
+     * perfect stream, discarding buffer times */
+    if (GST_BUFFER_DURATION (last_buf) != GST_CLOCK_TIME_NONE) {
+      nsamples = gst_util_uint64_scale_round (GST_BUFFER_DURATION (last_buf),
+          atom_trak_get_timescale (pad->trak), GST_SECOND);
+    } else {
+      nsamples = GST_BUFFER_SIZE (last_buf) / sample_size;
+    }
+    duration = GST_BUFFER_DURATION (last_buf) / nsamples;
+
+    /* timescale = samplerate */
+    scaled_duration = 1;
+    pad->last_dts += duration * nsamples;
+  } else {
+    nsamples = 1;
+    sample_size = GST_BUFFER_SIZE (last_buf);
+    if (pad->have_dts) {
+      gint64 scaled_dts;
+      pad->last_dts = GST_BUFFER_OFFSET_END (last_buf);
+      if ((gint64) (pad->last_dts) < 0) {
+        scaled_dts = -gst_util_uint64_scale_round (-pad->last_dts,
+            atom_trak_get_timescale (pad->trak), GST_SECOND);
+      } else {
+        scaled_dts = gst_util_uint64_scale_round (pad->last_dts,
+            atom_trak_get_timescale (pad->trak), GST_SECOND);
+      }
+      scaled_duration = scaled_dts - last_dts;
+      last_dts = scaled_dts;
+    } else {
+      /* first convert intended timestamp (in GstClockTime resolution) to
+       * trak timescale, then derive delta;
+       * this ensures sums of (scale)delta add up to converted timestamp,
+       * which only deviates at most 1/scale from timestamp itself */
+      scaled_duration = gst_util_uint64_scale_round (pad->last_dts + duration,
+          atom_trak_get_timescale (pad->trak), GST_SECOND) - last_dts;
+      pad->last_dts += duration;
+    }
+  }
+  chunk_offset = qtmux->mdat_size;
+
+  GST_LOG_OBJECT (qtmux,
+      "Pad (%s) dts updated to %" GST_TIME_FORMAT,
+      GST_PAD_NAME (pad->collect.pad), GST_TIME_ARGS (pad->last_dts));
+  GST_LOG_OBJECT (qtmux,
+      "Adding %d samples to track, duration: %" G_GUINT64_FORMAT
+      " size: %" G_GUINT32_FORMAT " chunk offset: %" G_GUINT64_FORMAT,
+      nsamples, scaled_duration, sample_size, chunk_offset);
+
+  /* might be a sync sample */
+  if (pad->sync &&
+      !GST_BUFFER_FLAG_IS_SET (last_buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
+    GST_LOG_OBJECT (qtmux, "Adding new sync sample entry for track of pad %s",
+        GST_PAD_NAME (pad->collect.pad));
+    sync = TRUE;
+  }
+
+  /* optionally calculate ctts entry values
+   * (if composition-time expected different from decoding-time) */
+  /* really not recommended:
+   * - decoder typically takes care of dts/pts issues
+   * - in case of out-of-order, dts may only be determined as above
+   *   (e.g. sum of duration), which may be totally different from
+   *   buffer timestamps in case of multiple segment, non-perfect streams
+   *  (and just perhaps maybe with some luck segment_to_running_time
+   *   or segment_to_media_time might get near to it) */
+  if ((pad->have_dts || qtmux->guess_pts)) {
+    guint64 pts;
+
+    pts = qtmux->dts_method == DTS_METHOD_REORDER ?
+        GST_BUFFER_OFFSET_END (last_buf) : GST_BUFFER_TIMESTAMP (last_buf);
+    pts = gst_util_uint64_scale_round (pts,
+        atom_trak_get_timescale (pad->trak), GST_SECOND);
+    pts_offset = (gint64) (pts - last_dts);
+    do_pts = TRUE;
+    GST_LOG_OBJECT (qtmux, "Adding ctts entry for pad %s: %" G_GINT64_FORMAT,
+        GST_PAD_NAME (pad->collect.pad), pts_offset);
+  }
+
+  /*
+   * Each buffer starts a new chunk, so we can assume the buffer
+   * duration is the chunk duration
+   */
+  if (GST_CLOCK_TIME_IS_VALID (duration) && (duration > qtmux->longest_chunk ||
+          !GST_CLOCK_TIME_IS_VALID (qtmux->longest_chunk))) {
+    GST_DEBUG_OBJECT (qtmux, "New longest chunk found: %" GST_TIME_FORMAT
+        ", pad %s", GST_TIME_ARGS (duration), GST_PAD_NAME (pad->collect.pad));
+    qtmux->longest_chunk = duration;
+  }
+
+  /* if this is the first buffer, store the timestamp */
+  if (G_UNLIKELY (pad->first_ts == GST_CLOCK_TIME_NONE) && last_buf) {
+    if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (last_buf))) {
+      pad->first_ts = GST_BUFFER_TIMESTAMP (last_buf);
+    } else {
+      GST_DEBUG_OBJECT (qtmux, "First buffer for pad %s has no timestamp, "
+          "using 0 as first timestamp", GST_PAD_NAME (pad->collect.pad));
+      pad->first_ts = 0;
+    }
+    GST_DEBUG_OBJECT (qtmux, "Stored first timestamp for pad %s %"
+        GST_TIME_FORMAT, GST_PAD_NAME (pad->collect.pad),
+        GST_TIME_ARGS (pad->first_ts));
+  }
+
+  /* now we go and register this buffer/sample all over */
+  /* note that a new chunk is started each time (not fancy but works) */
+  if (qtmux->moov_recov_file) {
+    if (!atoms_recov_write_trak_samples (qtmux->moov_recov_file, pad->trak,
+            nsamples, (gint32) scaled_duration, sample_size, chunk_offset, sync,
+            do_pts, pts_offset)) {
+      GST_WARNING_OBJECT (qtmux, "Failed to write sample information to "
+          "recovery file, disabling recovery");
+      fclose (qtmux->moov_recov_file);
+      qtmux->moov_recov_file = NULL;
+    }
+  }
+
+  if (buf)
+    gst_buffer_unref (buf);
+
+  if (qtmux->fragment_sequence) {
+    /* ensure that always sync samples are marked as such */
+    ret = gst_qt_mux_pad_fragment_add_buffer (qtmux, pad, last_buf,
+        buf == NULL, nsamples, last_dts, (gint32) scaled_duration, sample_size,
+        !pad->sync || sync, pts_offset);
+  } else {
+    atom_trak_add_samples (pad->trak, nsamples, (gint32) scaled_duration,
+        sample_size, chunk_offset, sync, pts_offset);
+    ret = gst_qt_mux_send_buffer (qtmux, last_buf, &qtmux->mdat_size, TRUE);
+  }
+
+exit:
+  if (G_UNLIKELY (drain && qtmux->dts_method == DTS_METHOD_REORDER &&
+          ret == GST_FLOW_OK)) {
+    buf = NULL;
+    goto again;
+  }
+
+  return ret;
+
+  /* ERRORS */
+bail:
+  {
+    if (buf)
+      gst_buffer_unref (buf);
+    gst_buffer_unref (last_buf);
+    return GST_FLOW_ERROR;
+  }
+no_time:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Received buffer without timestamp/duration. "
+            "Using e.g. dts-method=reorder might help."));
+    goto bail;
+  }
+no_order:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("DTS method failed to re-order timestamps."));
+    goto bail;
+  }
+need_pts:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Selected DTS method also needs PTS enabled."));
+    goto bail;
+  }
+fragmented_sample:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),
+        ("Audio buffer contains fragmented sample."));
+    goto bail;
+  }
+not_negotiated:
+  {
+    GST_ELEMENT_ERROR (qtmux, CORE, NEGOTIATION, (NULL),
+        ("format wasn't negotiated before buffer flow on pad %s",
+            GST_PAD_NAME (pad->collect.pad)));
+    if (buf)
+      gst_buffer_unref (buf);
+    return GST_FLOW_NOT_NEGOTIATED;
+  }
+}
+
+static GstFlowReturn
+gst_qt_mux_collected (GstCollectPads * pads, gpointer user_data)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstQTMux *qtmux = GST_QT_MUX_CAST (user_data);
+  GSList *walk;
+  GstQTPad *best_pad = NULL;
+  GstClockTime time, best_time = GST_CLOCK_TIME_NONE;
+  GstBuffer *buf;
+
+  if (G_UNLIKELY (qtmux->state == GST_QT_MUX_STATE_STARTED)) {
+    if ((ret = gst_qt_mux_start_file (qtmux)) != GST_FLOW_OK)
+      return ret;
+    else
+      qtmux->state = GST_QT_MUX_STATE_DATA;
+  }
+
+  if (G_UNLIKELY (qtmux->state == GST_QT_MUX_STATE_EOS))
+    return GST_FLOW_UNEXPECTED;
+
+  /* select the best buffer */
+  walk = qtmux->collect->data;
+  while (walk) {
+    GstQTPad *pad;
+    GstCollectData *data;
+
+    data = (GstCollectData *) walk->data;
+    pad = (GstQTPad *) data;
+
+    walk = g_slist_next (walk);
+
+    buf = gst_collect_pads_peek (pads, data);
+    if (buf == NULL) {
+      GST_LOG_OBJECT (qtmux, "Pad %s has no buffers",
+          GST_PAD_NAME (pad->collect.pad));
+      continue;
+    }
+    time = GST_BUFFER_TIMESTAMP (buf);
+    gst_buffer_unref (buf);
+
+    /* invalid should pass */
+    if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (time))) {
+      time =
+          gst_segment_to_running_time (&data->segment, GST_FORMAT_TIME, time);
+      if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (time))) {
+        GST_DEBUG_OBJECT (qtmux, "clipping buffer on pad %s outside segment",
+            GST_PAD_NAME (data->pad));
+        buf = gst_collect_pads_pop (pads, data);
+        gst_buffer_unref (buf);
+        return GST_FLOW_OK;
+      }
+    }
+
+    if (best_pad == NULL || !GST_CLOCK_TIME_IS_VALID (time) ||
+        (GST_CLOCK_TIME_IS_VALID (best_time) && time < best_time)) {
+      best_pad = pad;
+      best_time = time;
+    }
+  }
+
+  if (best_pad != NULL) {
+    GST_LOG_OBJECT (qtmux, "selected pad %s with time %" GST_TIME_FORMAT,
+        GST_PAD_NAME (best_pad->collect.pad), GST_TIME_ARGS (best_time));
+    buf = gst_collect_pads_pop (pads, &best_pad->collect);
+    buf = gst_buffer_make_metadata_writable (buf);
+    GST_BUFFER_TIMESTAMP (buf) = best_time;
+    ret = gst_qt_mux_add_buffer (qtmux, best_pad, buf);
+  } else {
+    ret = gst_qt_mux_stop_file (qtmux);
+    if (ret == GST_FLOW_OK) {
+      GST_DEBUG_OBJECT (qtmux, "Pushing eos");
+      gst_pad_push_event (qtmux->srcpad, gst_event_new_eos ());
+      ret = GST_FLOW_UNEXPECTED;
+    } else {
+      GST_WARNING_OBJECT (qtmux, "Failed to stop file: %s",
+          gst_flow_get_name (ret));
+    }
+    qtmux->state = GST_QT_MUX_STATE_EOS;
+  }
+
+  return ret;
+}
+
+static gboolean
+check_field (GQuark field_id, const GValue * value, gpointer user_data)
+{
+  GstStructure *structure = (GstStructure *) user_data;
+  const GValue *other = gst_structure_id_get_value (structure, field_id);
+  if (other == NULL)
+    return FALSE;
+  return gst_value_compare (value, other) == GST_VALUE_EQUAL;
+}
+
+static gboolean
+gst_qtmux_caps_is_subset_full (GstQTMux * qtmux, GstCaps * subset,
+    GstCaps * superset)
+{
+  GstStructure *sub_s = gst_caps_get_structure (subset, 0);
+  GstStructure *sup_s = gst_caps_get_structure (superset, 0);
+
+  return gst_structure_foreach (sub_s, check_field, sup_s);
+}
+
+static gboolean
+gst_qt_mux_audio_sink_set_caps (GstPad * pad, GstCaps * caps)
+{
+  GstQTMux *qtmux = GST_QT_MUX_CAST (gst_pad_get_parent (pad));
+  GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));
+  GstQTPad *qtpad = NULL;
+  GstStructure *structure;
+  const gchar *mimetype;
+  gint rate, channels;
+  const GValue *value = NULL;
+  const GstBuffer *codec_data = NULL;
+  GstQTMuxFormat format;
+  AudioSampleEntry entry = { 0, };
+  AtomInfo *ext_atom = NULL;
+  gint constant_size = 0;
+  const gchar *stream_format;
+  GstCaps *current_caps = NULL;
+
+  /* find stream data */
+  qtpad = (GstQTPad *) gst_pad_get_element_private (pad);
+  g_assert (qtpad);
+
+  qtpad->prepare_buf_func = NULL;
+
+  /* does not go well to renegotiate stream mid-way, unless
+   * the old caps are a subset of the new one (this means upstream
+   * added more info to the caps, as both should be 'fixed' caps) */
+  if (qtpad->fourcc) {
+    g_object_get (pad, "caps", &current_caps, NULL);
+    g_assert (caps != NULL);
+
+    if (!gst_qtmux_caps_is_subset_full (qtmux, current_caps, caps)) {
+      goto refuse_renegotiation;
+    }
+    GST_DEBUG_OBJECT (qtmux,
+        "pad %s accepted renegotiation to %" GST_PTR_FORMAT " from %"
+        GST_PTR_FORMAT, GST_PAD_NAME (pad), caps, GST_PAD_CAPS (pad));
+  }
+
+  GST_DEBUG_OBJECT (qtmux, "%s:%s, caps=%" GST_PTR_FORMAT,
+      GST_DEBUG_PAD_NAME (pad), caps);
+
+  format = qtmux_klass->format;
+  structure = gst_caps_get_structure (caps, 0);
+  mimetype = gst_structure_get_name (structure);
+
+  /* common info */
+  if (!gst_structure_get_int (structure, "channels", &channels) ||
+      !gst_structure_get_int (structure, "rate", &rate)) {
+    goto refuse_caps;
+  }
+
+  /* optional */
+  value = gst_structure_get_value (structure, "codec_data");
+  if (value != NULL)
+    codec_data = gst_value_get_buffer (value);
+
+  qtpad->is_out_of_order = FALSE;
+  qtpad->have_dts = FALSE;
+
+  /* set common properties */
+  entry.sample_rate = rate;
+  entry.channels = channels;
+  /* default */
+  entry.sample_size = 16;
+  /* this is the typical compressed case */
+  if (format == GST_QT_MUX_FORMAT_QT) {
+    entry.version = 1;
+    entry.compression_id = -2;
+  }
+
+  /* now map onto a fourcc, and some extra properties */
+  if (strcmp (mimetype, "audio/mpeg") == 0) {
+    gint mpegversion = 0;
+    gint layer = -1;
+
+    gst_structure_get_int (structure, "mpegversion", &mpegversion);
+    switch (mpegversion) {
+      case 1:
+        gst_structure_get_int (structure, "layer", &layer);
+        switch (layer) {
+          case 3:
+            /* mp3 */
+            /* note: QuickTime player does not like mp3 either way in iso/mp4 */
+            if (format == GST_QT_MUX_FORMAT_QT)
+              entry.fourcc = FOURCC__mp3;
+            else {
+              entry.fourcc = FOURCC_mp4a;
+              ext_atom =
+                  build_esds_extension (qtpad->trak, ESDS_OBJECT_TYPE_MPEG1_P3,
+                  ESDS_STREAM_TYPE_AUDIO, codec_data, qtpad->avg_bitrate,
+                  qtpad->max_bitrate);
+            }
+            entry.samples_per_packet = 1152;
+            entry.bytes_per_sample = 2;
+            break;
+        }
+        break;
+      case 4:
+
+        /* check stream-format */
+        stream_format = gst_structure_get_string (structure, "stream-format");
+        if (stream_format) {
+          if (strcmp (stream_format, "raw") != 0) {
+            GST_WARNING_OBJECT (qtmux, "Unsupported AAC stream-format %s, "
+                "please use 'raw'", stream_format);
+            goto refuse_caps;
+          }
+        } else {
+          GST_WARNING_OBJECT (qtmux, "No stream-format present in caps, "
+              "assuming 'raw'");
+        }
+
+        if (!codec_data || GST_BUFFER_SIZE (codec_data) < 2)
+          GST_WARNING_OBJECT (qtmux, "no (valid) codec_data for AAC audio");
+        else {
+          guint8 profile = GST_READ_UINT8 (GST_BUFFER_DATA (codec_data));
+
+          /* warn if not Low Complexity profile */
+          profile >>= 3;
+          if (profile != 2)
+            GST_WARNING_OBJECT (qtmux,
+                "non-LC AAC may not run well on (Apple) QuickTime/iTunes");
+        }
+
+        /* AAC */
+        entry.fourcc = FOURCC_mp4a;
+
+        if (format == GST_QT_MUX_FORMAT_QT)
+          ext_atom = build_mov_aac_extension (qtpad->trak, codec_data,
+              qtpad->avg_bitrate, qtpad->max_bitrate);
+        else
+          ext_atom =
+              build_esds_extension (qtpad->trak, ESDS_OBJECT_TYPE_MPEG4_P3,
+              ESDS_STREAM_TYPE_AUDIO, codec_data, qtpad->avg_bitrate,
+              qtpad->max_bitrate);
+        break;
+      default:
+        break;
+    }
+  } else if (strcmp (mimetype, "audio/AMR") == 0) {
+    entry.fourcc = FOURCC_samr;
+    entry.sample_size = 16;
+    entry.samples_per_packet = 160;
+    entry.bytes_per_sample = 2;
+    ext_atom = build_amr_extension ();
+  } else if (strcmp (mimetype, "audio/AMR-WB") == 0) {
+    entry.fourcc = FOURCC_sawb;
+    entry.sample_size = 16;
+    entry.samples_per_packet = 320;
+    entry.bytes_per_sample = 2;
+    ext_atom = build_amr_extension ();
+  } else if (strcmp (mimetype, "audio/x-raw-int") == 0) {
+    gint width;
+    gint depth;
+    gint endianness;
+    gboolean sign;
+
+    if (!gst_structure_get_int (structure, "width", &width) ||
+        !gst_structure_get_int (structure, "depth", &depth) ||
+        !gst_structure_get_boolean (structure, "signed", &sign)) {
+      GST_DEBUG_OBJECT (qtmux, "broken caps, width/depth/signed field missing");
+      goto refuse_caps;
+    }
+
+    if (depth <= 8) {
+      endianness = G_BYTE_ORDER;
+    } else if (!gst_structure_get_int (structure, "endianness", &endianness)) {
+      GST_DEBUG_OBJECT (qtmux, "broken caps, endianness field missing");
+      goto refuse_caps;
+    }
+
+    /* spec has no place for a distinction in these */
+    if (width != depth) {
+      GST_DEBUG_OBJECT (qtmux, "width must be same as depth!");
+      goto refuse_caps;
+    }
+
+    if (sign) {
+      if (endianness == G_LITTLE_ENDIAN)
+        entry.fourcc = FOURCC_sowt;
+      else if (endianness == G_BIG_ENDIAN)
+        entry.fourcc = FOURCC_twos;
+      /* maximum backward compatibility; only new version for > 16 bit */
+      if (depth <= 16)
+        entry.version = 0;
+      /* not compressed in any case */
+      entry.compression_id = 0;
+      /* QT spec says: max at 16 bit even if sample size were actually larger,
+       * however, most players (e.g. QuickTime!) seem to disagree, so ... */
+      entry.sample_size = depth;
+      entry.bytes_per_sample = depth / 8;
+      entry.samples_per_packet = 1;
+      entry.bytes_per_packet = depth / 8;
+      entry.bytes_per_frame = entry.bytes_per_packet * channels;
+    } else {
+      if (width == 8 && depth == 8) {
+        /* fall back to old 8-bit version */
+        entry.fourcc = FOURCC_raw_;
+        entry.version = 0;
+        entry.compression_id = 0;
+        entry.sample_size = 8;
+      } else {
+        GST_DEBUG_OBJECT (qtmux, "non 8-bit PCM must be signed");
+        goto refuse_caps;
+      }
+    }
+    constant_size = (depth / 8) * channels;
+  } else if (strcmp (mimetype, "audio/x-alaw") == 0) {
+    entry.fourcc = FOURCC_alaw;
+    entry.samples_per_packet = 1023;
+    entry.bytes_per_sample = 2;
+  } else if (strcmp (mimetype, "audio/x-mulaw") == 0) {
+    entry.fourcc = FOURCC_ulaw;
+    entry.samples_per_packet = 1023;
+    entry.bytes_per_sample = 2;
+  } else if (strcmp (mimetype, "audio/x-adpcm") == 0) {
+    gint blocksize;
+    if (!gst_structure_get_int (structure, "block_align", &blocksize)) {
+      GST_DEBUG_OBJECT (qtmux, "broken caps, block_align missing");
+      goto refuse_caps;
+    }
+    /* Currently only supports WAV-style IMA ADPCM, for which the codec id is
+       0x11 */
+    entry.fourcc = MS_WAVE_FOURCC (0x11);
+    /* 4 byte header per channel (including one sample). 2 samples per byte
+       remaining. Simplifying gives the following (samples per block per
+       channel) */
+    entry.samples_per_packet = 2 * blocksize / channels - 7;
+    entry.bytes_per_sample = 2;
+
+    entry.bytes_per_frame = blocksize;
+    entry.bytes_per_packet = blocksize / channels;
+    /* ADPCM has constant size packets */
+    constant_size = 1;
+    /* TODO: I don't really understand why this helps, but it does! Constant
+     * size and compression_id of -2 seem to be incompatible, and other files
+     * in the wild use this too. */
+    entry.compression_id = -1;
+
+    ext_atom = build_ima_adpcm_extension (channels, rate, blocksize);
+  } else if (strcmp (mimetype, "audio/x-alac") == 0) {
+    GstBuffer *codec_config;
+    gint len;
+
+    entry.fourcc = FOURCC_alac;
+    /* let's check if codec data already comes with 'alac' atom prefix */
+    if (!codec_data || (len = GST_BUFFER_SIZE (codec_data)) < 28) {
+      GST_DEBUG_OBJECT (qtmux, "broken caps, codec data missing");
+      goto refuse_caps;
+    }
+    if (GST_READ_UINT32_LE (GST_BUFFER_DATA (codec_data) + 4) == FOURCC_alac) {
+      len -= 8;
+      codec_config = gst_buffer_create_sub ((GstBuffer *) codec_data, 8, len);
+    } else {
+      codec_config = gst_buffer_ref ((GstBuffer *) codec_data);
+    }
+    if (len != 28) {
+      /* does not look good, but perhaps some trailing unneeded stuff */
+      GST_WARNING_OBJECT (qtmux, "unexpected codec-data size, possibly broken");
+    }
+    if (format == GST_QT_MUX_FORMAT_QT)
+      ext_atom = build_mov_alac_extension (qtpad->trak, codec_config);
+    else
+      ext_atom = build_codec_data_extension (FOURCC_alac, codec_config);
+    /* set some more info */
+    entry.bytes_per_sample = 2;
+    entry.samples_per_packet =
+        GST_READ_UINT32_BE (GST_BUFFER_DATA (codec_config) + 4);
+    gst_buffer_unref (codec_config);
+  }
+
+  if (!entry.fourcc)
+    goto refuse_caps;
+
+  /* ok, set the pad info accordingly */
+  qtpad->fourcc = entry.fourcc;
+  qtpad->sample_size = constant_size;
+  atom_trak_set_audio_type (qtpad->trak, qtmux->context, &entry,
+      qtmux->trak_timescale ? qtmux->trak_timescale : entry.sample_rate,
+      ext_atom, constant_size);
+
+  gst_object_unref (qtmux);
+  return TRUE;
+
+  /* ERRORS */
+refuse_caps:
+  {
+    GST_WARNING_OBJECT (qtmux, "pad %s refused caps %" GST_PTR_FORMAT,
+        GST_PAD_NAME (pad), caps);
+    gst_object_unref (qtmux);
+    return FALSE;
+  }
+refuse_renegotiation:
+  {
+    GST_WARNING_OBJECT (qtmux,
+        "pad %s refused renegotiation to %" GST_PTR_FORMAT,
+        GST_PAD_NAME (pad), caps);
+    gst_object_unref (qtmux);
+    return FALSE;
+  }
+}
+
+/* scale rate up or down by factor of 10 to fit into [1000,10000] interval */
+static guint32
+adjust_rate (guint64 rate)
+{
+  if (rate == 0)
+    return 10000;
+
+  while (rate >= 10000)
+    rate /= 10;
+
+  while (rate < 1000)
+    rate *= 10;
+
+  return (guint32) rate;
+}
+
+static gboolean
+gst_qt_mux_video_sink_set_caps (GstPad * pad, GstCaps * caps)
+{
+  GstQTMux *qtmux = GST_QT_MUX_CAST (gst_pad_get_parent (pad));
+  GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));
+  GstQTPad *qtpad = NULL;
+  GstStructure *structure;
+  const gchar *mimetype;
+  gint width, height, depth = -1;
+  gint framerate_num, framerate_den;
+  guint32 rate;
+  const GValue *value = NULL;
+  const GstBuffer *codec_data = NULL;
+  VisualSampleEntry entry = { 0, };
+  GstQTMuxFormat format;
+  AtomInfo *ext_atom = NULL;
+  GList *ext_atom_list = NULL;
+  gboolean sync = FALSE;
+  int par_num, par_den;
+  GstCaps *current_caps = NULL;
+
+  /* find stream data */
+  qtpad = (GstQTPad *) gst_pad_get_element_private (pad);
+  g_assert (qtpad);
+
+  qtpad->prepare_buf_func = NULL;
+
+  /* does not go well to renegotiate stream mid-way, unless
+   * the old caps are a subset of the new one (this means upstream
+   * added more info to the caps, as both should be 'fixed' caps) */
+  if (qtpad->fourcc) {
+    g_object_get (pad, "caps", &current_caps, NULL);
+    g_assert (caps != NULL);
+
+    if (!gst_qtmux_caps_is_subset_full (qtmux, current_caps, caps)) {
+      goto refuse_renegotiation;
+    }
+    GST_DEBUG_OBJECT (qtmux,
+        "pad %s accepted renegotiation to %" GST_PTR_FORMAT " from %"
+        GST_PTR_FORMAT, GST_PAD_NAME (pad), caps, GST_PAD_CAPS (pad));
+  }
+
+  GST_DEBUG_OBJECT (qtmux, "%s:%s, caps=%" GST_PTR_FORMAT,
+      GST_DEBUG_PAD_NAME (pad), caps);
+
+  format = qtmux_klass->format;
+  structure = gst_caps_get_structure (caps, 0);
+  mimetype = gst_structure_get_name (structure);
+
+  /* required parts */
+  if (!gst_structure_get_int (structure, "width", &width) ||
+      !gst_structure_get_int (structure, "height", &height))
+    goto refuse_caps;
+
+  /* optional */
+  depth = -1;
+  /* works as a default timebase */
+  framerate_num = 10000;
+  framerate_den = 1;
+  gst_structure_get_fraction (structure, "framerate", &framerate_num,
+      &framerate_den);
+  gst_structure_get_int (structure, "depth", &depth);
+  value = gst_structure_get_value (structure, "codec_data");
+  if (value != NULL)
+    codec_data = gst_value_get_buffer (value);
+
+  par_num = 1;
+  par_den = 1;
+  gst_structure_get_fraction (structure, "pixel-aspect-ratio", &par_num,
+      &par_den);
+
+  qtpad->is_out_of_order = FALSE;
+
+  /* bring frame numerator into a range that ensures both reasonable resolution
+   * as well as a fair duration */
+  rate = qtmux->trak_timescale ?
+      qtmux->trak_timescale : adjust_rate (framerate_num);
+  GST_DEBUG_OBJECT (qtmux, "Rate of video track selected: %" G_GUINT32_FORMAT,
+      rate);
+
+  /* set common properties */
+  entry.width = width;
+  entry.height = height;
+  entry.par_n = par_num;
+  entry.par_d = par_den;
+  /* should be OK according to qt and iso spec, override if really needed */
+  entry.color_table_id = -1;
+  entry.frame_count = 1;
+  entry.depth = 24;
+
+  /* sync entries by default */
+  sync = TRUE;
+
+  /* now map onto a fourcc, and some extra properties */
+  if (strcmp (mimetype, "video/x-raw-rgb") == 0) {
+    gint bpp;
+
+    entry.fourcc = FOURCC_raw_;
+    gst_structure_get_int (structure, "bpp", &bpp);
+    entry.depth = bpp;
+    sync = FALSE;
+  } else if (strcmp (mimetype, "video/x-raw-yuv") == 0) {
+    guint32 format = 0;
+
+    sync = FALSE;
+    gst_structure_get_fourcc (structure, "format", &format);
+    switch (format) {
+      case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
+        if (depth == -1)
+          depth = 24;
+        entry.fourcc = FOURCC_2vuy;
+        entry.depth = depth;
+        break;
+    }
+  } else if (strcmp (mimetype, "video/x-h263") == 0) {
+    ext_atom = NULL;
+    if (format == GST_QT_MUX_FORMAT_QT)
+      entry.fourcc = FOURCC_h263;
+    else
+      entry.fourcc = FOURCC_s263;
+    ext_atom = build_h263_extension ();
+    if (ext_atom != NULL)
+      ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+  } else if (strcmp (mimetype, "video/x-divx") == 0 ||
+      strcmp (mimetype, "video/mpeg") == 0) {
+    gint version = 0;
+
+    if (strcmp (mimetype, "video/x-divx") == 0) {
+      gst_structure_get_int (structure, "divxversion", &version);
+      version = version == 5 ? 1 : 0;
+    } else {
+      gst_structure_get_int (structure, "mpegversion", &version);
+      version = version == 4 ? 1 : 0;
+    }
+    if (version) {
+      entry.fourcc = FOURCC_mp4v;
+      ext_atom =
+          build_esds_extension (qtpad->trak, ESDS_OBJECT_TYPE_MPEG4_P2,
+          ESDS_STREAM_TYPE_VISUAL, codec_data, qtpad->avg_bitrate,
+          qtpad->max_bitrate);
+      if (ext_atom != NULL)
+        ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+      if (!codec_data)
+        GST_WARNING_OBJECT (qtmux, "no codec_data for MPEG4 video; "
+            "output might not play in Apple QuickTime (try global-headers?)");
+    }
+  } else if (strcmp (mimetype, "video/x-h264") == 0) {
+    /* check if we accept these caps */
+    if (gst_structure_has_field (structure, "stream-format")) {
+      const gchar *format;
+      const gchar *alignment;
+
+      format = gst_structure_get_string (structure, "stream-format");
+      alignment = gst_structure_get_string (structure, "alignment");
+
+      if (strcmp (format, "avc") != 0 || alignment == NULL ||
+          strcmp (alignment, "au") != 0) {
+        GST_WARNING_OBJECT (qtmux, "Rejecting h264 caps, qtmux only accepts "
+            "avc format with AU aligned samples");
+        goto refuse_caps;
+      }
+    } else {
+      GST_WARNING_OBJECT (qtmux, "no stream-format field in h264 caps");
+      goto refuse_caps;
+    }
+
+    if (!codec_data) {
+      GST_WARNING_OBJECT (qtmux, "no codec_data in h264 caps");
+      goto refuse_caps;
+    }
+
+    entry.fourcc = FOURCC_avc1;
+    if (qtpad->avg_bitrate == 0) {
+      gint avg_bitrate = 0;
+      gst_structure_get_int (structure, "bitrate", &avg_bitrate);
+      qtpad->avg_bitrate = avg_bitrate;
+    }
+    ext_atom = build_btrt_extension (0, qtpad->avg_bitrate, qtpad->max_bitrate);
+    if (ext_atom != NULL)
+      ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+    ext_atom = build_codec_data_extension (FOURCC_avcC, codec_data);
+    if (ext_atom != NULL)
+      ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+  } else if (strcmp (mimetype, "video/x-svq") == 0) {
+    gint version = 0;
+    const GstBuffer *seqh = NULL;
+    const GValue *seqh_value;
+    gdouble gamma = 0;
+
+    gst_structure_get_int (structure, "svqversion", &version);
+    if (version == 3) {
+      entry.fourcc = FOURCC_SVQ3;
+      entry.version = 3;
+      entry.depth = 32;
+
+      seqh_value = gst_structure_get_value (structure, "seqh");
+      if (seqh_value) {
+        seqh = gst_value_get_buffer (seqh_value);
+        ext_atom = build_SMI_atom (seqh);
+        if (ext_atom)
+          ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+      }
+
+      /* we need to add the gamma anyway because quicktime might crash
+       * when it doesn't find it */
+      if (!gst_structure_get_double (structure, "applied-gamma", &gamma)) {
+        /* it seems that using 0 here makes it ignored */
+        gamma = 0.0;
+      }
+      ext_atom = build_gama_atom (gamma);
+      if (ext_atom)
+        ext_atom_list = g_list_prepend (ext_atom_list, ext_atom);
+    } else {
+      GST_WARNING_OBJECT (qtmux, "SVQ version %d not supported. Please file "
+          "a bug at http://bugzilla.gnome.org", version);
+    }
+  } else if (strcmp (mimetype, "video/x-dv") == 0) {
+    gint version = 0;
+    gboolean pal = TRUE;
+
+    sync = FALSE;
+    if (framerate_num != 25 || framerate_den != 1)
+      pal = FALSE;
+    gst_structure_get_int (structure, "dvversion", &version);
+    /* fall back to typical one */
+    if (!version)
+      version = 25;
+    switch (version) {
+      case 25:
+        if (pal)
+          entry.fourcc = GST_MAKE_FOURCC ('d', 'v', 'c', 'p');
+        else
+          entry.fourcc = GST_MAKE_FOURCC ('d', 'v', 'c', ' ');
+        break;
+      case 50:
+        if (pal)
+          entry.fourcc = GST_MAKE_FOURCC ('d', 'v', '5', 'p');
+        else
+          entry.fourcc = GST_MAKE_FOURCC ('d', 'v', '5', 'n');
+        break;
+      default:
+        GST_WARNING_OBJECT (qtmux, "unrecognized dv version");
+        break;
+    }
+  } else if (strcmp (mimetype, "image/jpeg") == 0) {
+    entry.fourcc = FOURCC_jpeg;
+    sync = FALSE;
+  } else if (strcmp (mimetype, "image/x-j2c") == 0 ||
+      strcmp (mimetype, "image/x-jpc") == 0) {
+    guint32 fourcc;
+    const GValue *cmap_array;
+    const GValue *cdef_array;
+    gint ncomp = 0;
+    gint fields = 1;
+
+    if (strcmp (mimetype, "image/x-jpc") == 0) {
+      qtpad->prepare_buf_func = gst_qt_mux_prepare_jpc_buffer;
+    }
+
+    gst_structure_get_int (structure, "num-components", &ncomp);
+    gst_structure_get_int (structure, "fields", &fields);
+    cmap_array = gst_structure_get_value (structure, "component-map");
+    cdef_array = gst_structure_get_value (structure, "channel-definitions");
+
+    ext_atom = NULL;
+    entry.fourcc = FOURCC_mjp2;
+    sync = FALSE;
+    if (gst_structure_get_fourcc (structure, "fourcc", &fourcc) &&
+        (ext_atom =
+            build_jp2h_extension (qtpad->trak, width, height, fourcc, ncomp,
+                cmap_array, cdef_array)) != NULL) {
+      ext_atom_list = g_list_append (ext_atom_list, ext_atom);
+
+      ext_atom = build_fiel_extension (fields);
+      if (ext_atom)
+        ext_atom_list = g_list_append (ext_atom_list, ext_atom);
+
+      ext_atom = build_jp2x_extension (codec_data);
+      if (ext_atom)
+        ext_atom_list = g_list_append (ext_atom_list, ext_atom);
+    } else {
+      GST_DEBUG_OBJECT (qtmux, "missing or invalid fourcc in jp2 caps");
+      goto refuse_caps;
+    }
+  } else if (strcmp (mimetype, "video/x-vp8") == 0) {
+    entry.fourcc = FOURCC_VP80;
+    sync = FALSE;
+  } else if (strcmp (mimetype, "video/x-qt-part") == 0) {
+    guint32 fourcc;
+
+    gst_structure_get_fourcc (structure, "format", &fourcc);
+    entry.fourcc = fourcc;
+    qtpad->have_dts = TRUE;
+  } else if (strcmp (mimetype, "video/x-mp4-part") == 0) {
+    guint32 fourcc;
+
+    gst_structure_get_fourcc (structure, "format", &fourcc);
+    entry.fourcc = fourcc;
+    qtpad->have_dts = TRUE;
+  }
+
+  if (!entry.fourcc)
+    goto refuse_caps;
+
+  /* ok, set the pad info accordingly */
+  qtpad->fourcc = entry.fourcc;
+  qtpad->sync = sync;
+  atom_trak_set_video_type (qtpad->trak, qtmux->context, &entry, rate,
+      ext_atom_list);
+
+  gst_object_unref (qtmux);
+  return TRUE;
+
+  /* ERRORS */
+refuse_caps:
+  {
+    GST_WARNING_OBJECT (qtmux, "pad %s refused caps %" GST_PTR_FORMAT,
+        GST_PAD_NAME (pad), caps);
+    gst_object_unref (qtmux);
+    return FALSE;
+  }
+refuse_renegotiation:
+  {
+    GST_WARNING_OBJECT (qtmux,
+        "pad %s refused renegotiation to %" GST_PTR_FORMAT " from %"
+        GST_PTR_FORMAT, GST_PAD_NAME (pad), caps, GST_PAD_CAPS (pad));
+    gst_object_unref (qtmux);
+    return FALSE;
+  }
+}
+
+static gboolean
+gst_qt_mux_sink_event (GstPad * pad, GstEvent * event)
+{
+  gboolean ret;
+  GstQTMux *qtmux;
+  guint32 avg_bitrate = 0, max_bitrate = 0;
+
+  qtmux = GST_QT_MUX_CAST (gst_pad_get_parent (pad));
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_TAG:{
+      GstTagList *list;
+      GstTagSetter *setter = GST_TAG_SETTER (qtmux);
+      GstTagMergeMode mode;
+
+      GST_OBJECT_LOCK (qtmux);
+      mode = gst_tag_setter_get_tag_merge_mode (setter);
+
+      GST_DEBUG_OBJECT (qtmux, "received tag event");
+      gst_event_parse_tag (event, &list);
+
+      gst_tag_setter_merge_tags (setter, list, mode);
+      GST_OBJECT_UNLOCK (qtmux);
+
+      if (gst_tag_list_get_uint (list, GST_TAG_BITRATE, &avg_bitrate) |
+          gst_tag_list_get_uint (list, GST_TAG_MAXIMUM_BITRATE, &max_bitrate)) {
+        GstQTPad *qtpad = gst_pad_get_element_private (pad);
+        g_assert (qtpad);
+
+        if (avg_bitrate > 0 && avg_bitrate < G_MAXUINT32)
+          qtpad->avg_bitrate = avg_bitrate;
+        if (max_bitrate > 0 && max_bitrate < G_MAXUINT32)
+          qtpad->max_bitrate = max_bitrate;
+      }
+
+      break;
+    }
+    default:
+      break;
+  }
+
+  ret = qtmux->collect_event (pad, event);
+  gst_object_unref (qtmux);
+
+  return ret;
+}
+
+static void
+gst_qt_mux_release_pad (GstElement * element, GstPad * pad)
+{
+  GstQTMux *mux = GST_QT_MUX_CAST (element);
+  GSList *walk;
+
+  GST_DEBUG_OBJECT (element, "Releasing %s:%s", GST_DEBUG_PAD_NAME (pad));
+
+  for (walk = mux->sinkpads; walk; walk = g_slist_next (walk)) {
+    GstQTPad *qtpad = (GstQTPad *) walk->data;
+    GST_DEBUG ("Checking %s:%s", GST_DEBUG_PAD_NAME (qtpad->collect.pad));
+    if (qtpad->collect.pad == pad) {
+      /* this is it, remove */
+      mux->sinkpads = g_slist_delete_link (mux->sinkpads, walk);
+      gst_element_remove_pad (element, pad);
+      break;
+    }
+  }
+
+  gst_collect_pads_remove_pad (mux->collect, pad);
+}
+
+static GstPad *
+gst_qt_mux_request_new_pad (GstElement * element,
+    GstPadTemplate * templ, const gchar * req_name)
+{
+  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
+  GstQTMux *qtmux = GST_QT_MUX_CAST (element);
+  GstQTPad *collect_pad;
+  GstPad *newpad;
+  gboolean audio;
+  gchar *name;
+
+  if (templ->direction != GST_PAD_SINK)
+    goto wrong_direction;
+
+  if (qtmux->state > GST_QT_MUX_STATE_STARTED)
+    goto too_late;
+
+  if (templ == gst_element_class_get_pad_template (klass, "audio_%d")) {
+    audio = TRUE;
+    name = g_strdup_printf ("audio_%02d", qtmux->audio_pads++);
+  } else if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {
+    audio = FALSE;
+    name = g_strdup_printf ("video_%02d", qtmux->video_pads++);
+  } else
+    goto wrong_template;
+
+  GST_DEBUG_OBJECT (qtmux, "Requested pad: %s", name);
+
+  /* create pad and add to collections */
+  newpad = gst_pad_new_from_template (templ, name);
+  g_free (name);
+  collect_pad = (GstQTPad *)
+      gst_collect_pads_add_pad_full (qtmux->collect, newpad, sizeof (GstQTPad),
+      (GstCollectDataDestroyNotify) (gst_qt_mux_pad_reset));
+  /* set up pad */
+  gst_qt_mux_pad_reset (collect_pad);
+  collect_pad->trak = atom_trak_new (qtmux->context);
+  atom_moov_add_trak (qtmux->moov, collect_pad->trak);
+
+  qtmux->sinkpads = g_slist_append (qtmux->sinkpads, collect_pad);
+
+  /* set up pad functions */
+  if (audio)
+    gst_pad_set_setcaps_function (newpad,
+        GST_DEBUG_FUNCPTR (gst_qt_mux_audio_sink_set_caps));
+  else
+    gst_pad_set_setcaps_function (newpad,
+        GST_DEBUG_FUNCPTR (gst_qt_mux_video_sink_set_caps));
+
+  /* FIXME: hacked way to override/extend the event function of
+   * GstCollectPads; because it sets its own event function giving the
+   * element no access to events.
+   */
+  qtmux->collect_event = (GstPadEventFunction) GST_PAD_EVENTFUNC (newpad);
+  gst_pad_set_event_function (newpad,
+      GST_DEBUG_FUNCPTR (gst_qt_mux_sink_event));
+
+  gst_pad_set_active (newpad, TRUE);
+  gst_element_add_pad (element, newpad);
+
+  return newpad;
+
+  /* ERRORS */
+wrong_direction:
+  {
+    GST_WARNING_OBJECT (qtmux, "Request pad that is not a SINK pad.");
+    return NULL;
+  }
+too_late:
+  {
+    GST_WARNING_OBJECT (qtmux, "Not providing request pad after stream start.");
+    return NULL;
+  }
+wrong_template:
+  {
+    GST_WARNING_OBJECT (qtmux, "This is not our template!");
+    return NULL;
+  }
+}
+
+static void
+gst_qt_mux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
+{
+  GstQTMux *qtmux = GST_QT_MUX_CAST (object);
+
+  GST_OBJECT_LOCK (qtmux);
+  switch (prop_id) {
+    case PROP_MOVIE_TIMESCALE:
+      g_value_set_uint (value, qtmux->timescale);
+      break;
+    case PROP_TRAK_TIMESCALE:
+      g_value_set_uint (value, qtmux->trak_timescale);
+      break;
+    case PROP_DO_CTTS:
+      g_value_set_boolean (value, qtmux->guess_pts);
+      break;
+    case PROP_DTS_METHOD:
+      g_value_set_enum (value, qtmux->dts_method);
+      break;
+    case PROP_FAST_START:
+      g_value_set_boolean (value, qtmux->fast_start);
+      break;
+    case PROP_FAST_START_TEMP_FILE:
+      g_value_set_string (value, qtmux->fast_start_file_path);
+      break;
+    case PROP_MOOV_RECOV_FILE:
+      g_value_set_string (value, qtmux->moov_recov_file_path);
+      break;
+    case PROP_FRAGMENT_DURATION:
+      g_value_set_uint (value, qtmux->fragment_duration);
+      break;
+    case PROP_STREAMABLE:
+      g_value_set_boolean (value, qtmux->streamable);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+  GST_OBJECT_UNLOCK (qtmux);
+}
+
+static void
+gst_qt_mux_generate_fast_start_file_path (GstQTMux * qtmux)
+{
+  gchar *tmp;
+
+  g_free (qtmux->fast_start_file_path);
+  qtmux->fast_start_file_path = NULL;
+
+  tmp = g_strdup_printf ("%s%d", "qtmux", g_random_int ());
+  qtmux->fast_start_file_path = g_build_filename (g_get_tmp_dir (), tmp, NULL);
+  g_free (tmp);
+}
+
+static void
+gst_qt_mux_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+  GstQTMux *qtmux = GST_QT_MUX_CAST (object);
+
+  GST_OBJECT_LOCK (qtmux);
+  switch (prop_id) {
+    case PROP_MOVIE_TIMESCALE:
+      qtmux->timescale = g_value_get_uint (value);
+      break;
+    case PROP_TRAK_TIMESCALE:
+      qtmux->trak_timescale = g_value_get_uint (value);
+      break;
+    case PROP_DO_CTTS:
+      qtmux->guess_pts = g_value_get_boolean (value);
+      break;
+    case PROP_DTS_METHOD:
+      qtmux->dts_method = g_value_get_enum (value);
+      break;
+    case PROP_FAST_START:
+      qtmux->fast_start = g_value_get_boolean (value);
+      break;
+    case PROP_FAST_START_TEMP_FILE:
+      g_free (qtmux->fast_start_file_path);
+      qtmux->fast_start_file_path = g_value_dup_string (value);
+      /* NULL means to generate a random one */
+      if (!qtmux->fast_start_file_path) {
+        gst_qt_mux_generate_fast_start_file_path (qtmux);
+      }
+      break;
+    case PROP_MOOV_RECOV_FILE:
+      g_free (qtmux->moov_recov_file_path);
+      qtmux->moov_recov_file_path = g_value_dup_string (value);
+      break;
+    case PROP_FRAGMENT_DURATION:
+      qtmux->fragment_duration = g_value_get_uint (value);
+      break;
+    case PROP_STREAMABLE:
+      qtmux->streamable = g_value_get_boolean (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+  GST_OBJECT_UNLOCK (qtmux);
+}
+
+static GstStateChangeReturn
+gst_qt_mux_change_state (GstElement * element, GstStateChange transition)
+{
+  GstStateChangeReturn ret;
+  GstQTMux *qtmux = GST_QT_MUX_CAST (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      break;
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      gst_collect_pads_start (qtmux->collect);
+      qtmux->state = GST_QT_MUX_STATE_STARTED;
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_collect_pads_stop (qtmux->collect);
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_qt_mux_reset (qtmux, TRUE);
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+gboolean
+gst_qt_mux_register (GstPlugin * plugin)
+{
+  GTypeInfo typeinfo = {
+    sizeof (GstQTMuxClass),
+    (GBaseInitFunc) gst_qt_mux_base_init,
+    NULL,
+    (GClassInitFunc) gst_qt_mux_class_init,
+    NULL,
+    NULL,
+    sizeof (GstQTMux),
+    0,
+    (GInstanceInitFunc) gst_qt_mux_init,
+  };
+  static const GInterfaceInfo tag_setter_info = {
+    NULL, NULL, NULL
+  };
+  static const GInterfaceInfo tag_xmp_writer_info = {
+    NULL, NULL, NULL
+  };
+  GType type;
+  GstQTMuxFormat format;
+  GstQTMuxClassParams *params;
+  guint i = 0;
+
+  GST_DEBUG_CATEGORY_INIT (gst_qt_mux_debug, "qtmux", 0, "QT Muxer");
+
+  GST_LOG ("Registering muxers");
+
+  while (TRUE) {
+    GstQTMuxFormatProp *prop;
+
+    prop = &gst_qt_mux_format_list[i];
+    format = prop->format;
+    if (format == GST_QT_MUX_FORMAT_NONE)
+      break;
+
+    /* create a cache for these properties */
+    params = g_new0 (GstQTMuxClassParams, 1);
+    params->prop = prop;
+    params->src_caps = gst_static_caps_get (&prop->src_caps);
+    params->video_sink_caps = gst_static_caps_get (&prop->video_sink_caps);
+    params->audio_sink_caps = gst_static_caps_get (&prop->audio_sink_caps);
+
+    /* create the type now */
+    type = g_type_register_static (GST_TYPE_ELEMENT, prop->type_name, &typeinfo,
+        0);
+    g_type_set_qdata (type, GST_QT_MUX_PARAMS_QDATA, (gpointer) params);
+    g_type_add_interface_static (type, GST_TYPE_TAG_SETTER, &tag_setter_info);
+    g_type_add_interface_static (type, GST_TYPE_TAG_XMP_WRITER,
+        &tag_xmp_writer_info);
+
+    if (!gst_element_register (plugin, prop->name, prop->rank, type))
+      return FALSE;
+
+    i++;
+  }
+
+  GST_LOG ("Finished registering muxers");
+
+  /* FIXME: ideally classification tag should be added and
+     registered in gstreamer core gsttaglist
+   */
+
+  GST_LOG ("Registering tags");
+
+  gst_tag_register (GST_TAG_3GP_CLASSIFICATION, GST_TAG_FLAG_META,
+      G_TYPE_STRING, GST_TAG_3GP_CLASSIFICATION, "content classification",
+      gst_tag_merge_use_first);
+
+  GST_LOG ("Finished registering tags");
+
+  return TRUE;
+}
diff --git a/gst/isomp4/gstqtmux.h b/gst/isomp4/gstqtmux.h
new file mode 100644
index 000000000..3a2cb492f
--- /dev/null
+++ b/gst/isomp4/gstqtmux.h
@@ -0,0 +1,228 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __GST_QT_MUX_H__
+#define __GST_QT_MUX_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstcollectpads.h>
+
+#include "fourcc.h"
+#include "atoms.h"
+#include "atomsrecovery.h"
+#include "gstqtmuxmap.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_QT_MUX (gst_qt_mux_get_type())
+#define GST_QT_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QT_MUX, GstQTMux))
+#define GST_QT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QT_MUX, GstQTMux))
+#define GST_IS_QT_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QT_MUX))
+#define GST_IS_QT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QT_MUX))
+#define GST_QT_MUX_CAST(obj) ((GstQTMux*)(obj))
+
+
+typedef struct _GstQTMux GstQTMux;
+typedef struct _GstQTMuxClass GstQTMuxClass;
+typedef struct _GstQTPad GstQTPad;
+
+/*
+ * GstQTPadPrepareBufferFunc
+ *
+ * Receives a buffer (takes ref) and returns a new buffer that should
+ * replace the passed one.
+ *
+ * Useful for when the pad/datatype needs some manipulation before
+ * being muxed. (Originally added for image/x-jpc support, for which buffers
+ * need to be wrapped into a isom box)
+ */
+typedef GstBuffer * (*GstQTPadPrepareBufferFunc) (GstQTPad * pad,
+    GstBuffer * buf, GstQTMux * qtmux);
+
+#define QTMUX_NO_OF_TS   10
+
+struct _GstQTPad
+{
+  GstCollectData collect;       /* we extend the CollectData */
+
+  /* fourcc id of stream */
+  guint32 fourcc;
+  /* whether using format that have out of order buffers */
+  gboolean is_out_of_order;
+  /* whether upstream provides valid PTS data */
+  gboolean have_dts;
+  /* if not 0, track with constant sized samples, e.g. raw audio */
+  guint sample_size;
+  /* make sync table entry */
+  gboolean sync;
+  /* bitrates */
+  guint32 avg_bitrate, max_bitrate;
+
+  GstBuffer *last_buf;
+  /* dts of last_buf */
+  GstClockTime last_dts;
+
+  /* store the first timestamp for comparing with other streams and
+   * know if there are late streams */
+  GstClockTime first_ts;
+  GstClockTime ts_entries[QTMUX_NO_OF_TS + 2];
+  guint ts_n_entries;
+  GstBuffer *buf_entries[QTMUX_NO_OF_TS + 2];
+  guint buf_head;
+  guint buf_tail;
+
+  /* all the atom and chunk book-keeping is delegated here
+   * unowned/uncounted reference, parent MOOV owns */
+  AtomTRAK *trak;
+  /* fragmented support */
+  /* meta data book-keeping delegated here */
+  AtomTRAF *traf;
+  /* fragment buffers */
+  ATOM_ARRAY (GstBuffer *) fragment_buffers;
+  /* running fragment duration */
+  gint64 fragment_duration;
+  /* optional fragment index book-keeping */
+  AtomTFRA *tfra;
+
+  /* if nothing is set, it won't be called */
+  GstQTPadPrepareBufferFunc prepare_buf_func;
+};
+
+typedef enum _GstQTMuxState
+{
+  GST_QT_MUX_STATE_NONE,
+  GST_QT_MUX_STATE_STARTED,
+  GST_QT_MUX_STATE_DATA,
+  GST_QT_MUX_STATE_EOS
+} GstQTMuxState;
+
+struct _GstQTMux
+{
+  GstElement element;
+
+  GstPad *srcpad;
+  GstCollectPads *collect;
+  GSList *sinkpads;
+
+  /* state */
+  GstQTMuxState state;
+
+  /* size of header (prefix, atoms (ftyp, mdat)) */
+  guint64 header_size;
+  /* accumulated size of raw media data (a priori not including mdat header) */
+  guint64 mdat_size;
+  /* position of mdat atom (for later updating) */
+  guint64 mdat_pos;
+
+  /* keep track of the largest chunk to fine-tune brands */
+  GstClockTime longest_chunk;
+
+  /* atom helper objects */
+  AtomsContext *context;
+  AtomFTYP *ftyp;
+  AtomMOOV *moov;
+  GSList *extra_atoms; /* list of extra top-level atoms (e.g. UUID for xmp)
+                        * Stored as AtomInfo structs */
+
+  /* fragmented file index */
+  AtomMFRA *mfra;
+
+  /* fast start */
+  FILE *fast_start_file;
+
+  /* moov recovery */
+  FILE *moov_recov_file;
+
+  /* fragment sequence */
+  guint32 fragment_sequence;
+
+  /* properties */
+  guint32 timescale;
+  guint32 trak_timescale;
+  AtomsTreeFlavor flavor;
+  gboolean fast_start;
+  gboolean guess_pts;
+  gint dts_method;
+  gchar *fast_start_file_path;
+  gchar *moov_recov_file_path;
+  guint32 fragment_duration;
+  gboolean streamable;
+
+  /* for collect pads event handling function */
+  GstPadEventFunction collect_event;
+
+  /* for request pad naming */
+  guint video_pads, audio_pads;
+};
+
+struct _GstQTMuxClass
+{
+  GstElementClass parent_class;
+
+  GstQTMuxFormat format;
+};
+
+/* type register helper struct */
+typedef struct _GstQTMuxClassParams
+{
+  GstQTMuxFormatProp *prop;
+  GstCaps *src_caps;
+  GstCaps *video_sink_caps;
+  GstCaps *audio_sink_caps;
+} GstQTMuxClassParams;
+
+#define GST_QT_MUX_PARAMS_QDATA g_quark_from_static_string("qt-mux-params")
+
+GType gst_qt_mux_get_type (void);
+gboolean gst_qt_mux_register (GstPlugin * plugin);
+
+/* FIXME: ideally classification tag should be added and
+ * registered in gstreamer core gsttaglist
+ *
+ * this tag is a string in the format: entityfourcc://table_num/content
+ * FIXME Shouldn't we add a field for 'language'?
+ */
+#define GST_TAG_3GP_CLASSIFICATION "classification"
+
+G_END_DECLS
+
+#endif /* __GST_QT_MUX_H__ */
diff --git a/gst/isomp4/gstqtmuxmap.c b/gst/isomp4/gstqtmuxmap.c
new file mode 100644
index 000000000..c3a0295ce
--- /dev/null
+++ b/gst/isomp4/gstqtmuxmap.c
@@ -0,0 +1,389 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#include "gstqtmuxmap.h"
+#include "fourcc.h"
+#include "ftypcc.h"
+
+/* static info related to various format */
+
+#define COMMON_VIDEO_CAPS \
+  "width = (int) [ 16, 4096 ], " \
+  "height = (int) [ 16, 4096 ], " \
+  "framerate = (fraction) [ 0, MAX ]"
+
+#define COMMON_VIDEO_CAPS_NO_FRAMERATE \
+  "width = (int) [ 16, 4096 ], " \
+  "height = (int) [ 16, 4096 ] "
+
+#define H263_CAPS \
+  "video/x-h263, " \
+  COMMON_VIDEO_CAPS
+
+#define H264_CAPS \
+  "video/x-h264, " \
+  "stream-format = (string) avc, " \
+  "alignment = (string) au, " \
+  COMMON_VIDEO_CAPS
+
+#define MPEG4V_CAPS \
+  "video/mpeg, " \
+  "mpegversion = (int) 4, "\
+  "systemstream = (boolean) false, " \
+  COMMON_VIDEO_CAPS "; " \
+  "video/x-divx, " \
+  "divxversion = (int) 5, "\
+  COMMON_VIDEO_CAPS
+
+#define SVQ_CAPS \
+  "video/x-svq, " \
+  "svqversion = (int) 3, " \
+  COMMON_VIDEO_CAPS
+
+#define COMMON_AUDIO_CAPS(c, r) \
+  "channels = (int) [ 1, " G_STRINGIFY (c) " ], " \
+  "rate = (int) [ 1, " G_STRINGIFY (r) " ]"
+
+#define PCM_CAPS \
+  "audio/x-raw-int, " \
+  "width = (int) 8, " \
+  "depth = (int) 8, " \
+  COMMON_AUDIO_CAPS (2, MAX) ", " \
+  "signed = (boolean) { true, false }; " \
+  "audio/x-raw-int, " \
+  "width = (int) 16, " \
+  "depth = (int) 16, " \
+  "endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
+  COMMON_AUDIO_CAPS (2, MAX) ", " \
+  "signed = (boolean) true " \
+
+#define PCM_CAPS_FULL \
+  PCM_CAPS "; " \
+  "audio/x-raw-int, " \
+  "width = (int) 24, " \
+  "depth = (int) 24, " \
+  "endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
+  COMMON_AUDIO_CAPS (2, MAX) ", " \
+  "signed = (boolean) true; " \
+  "audio/x-raw-int, " \
+  "width = (int) 32, " \
+  "depth = (int) 32, " \
+  "endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
+  COMMON_AUDIO_CAPS (2, MAX) ", " \
+  "signed = (boolean) true "
+
+#define MP3_CAPS \
+  "audio/mpeg, " \
+  "mpegversion = (int) 1, " \
+  "layer = (int) 3, " \
+  COMMON_AUDIO_CAPS (2, MAX)
+
+#define AAC_CAPS \
+  "audio/mpeg, " \
+  "mpegversion = (int) 4, " \
+  "stream-format = (string) raw, " \
+  COMMON_AUDIO_CAPS (8, MAX)
+
+#define AMR_CAPS \
+  "audio/AMR, " \
+  "rate = (int) 8000, " \
+  "channels = [ 1, 2 ]; " \
+  "audio/AMR-WB, " \
+  "rate = (int) 16000, " \
+  "channels = [ 1, 2 ] "
+
+#define ADPCM_CAPS  \
+  "audio/x-adpcm, " \
+  "layout = (string)dvi, " \
+  "block_align = (int)[64, 8096], " \
+  COMMON_AUDIO_CAPS(2, MAX)
+
+#define ALAC_CAPS \
+  "audio/x-alac, " \
+  COMMON_AUDIO_CAPS(2, MAX)
+
+/* FIXME 0.11 - take a look at bugs #580005 and #340375 */
+GstQTMuxFormatProp gst_qt_mux_format_list[] = {
+  /* original QuickTime format; see Apple site (e.g. qtff.pdf) */
+  {
+        GST_QT_MUX_FORMAT_QT,
+        GST_RANK_PRIMARY,
+        "qtmux",
+        "QuickTime",
+        "GstQTMux",
+        GST_STATIC_CAPS ("video/quicktime, variant = (string) apple; "
+            "video/quicktime"),
+        GST_STATIC_CAPS ("video/x-raw-rgb, "
+            COMMON_VIDEO_CAPS "; "
+            "video/x-raw-yuv, "
+            "format = (fourcc) UYVY, "
+            COMMON_VIDEO_CAPS "; "
+            MPEG4V_CAPS "; "
+            H263_CAPS "; "
+            H264_CAPS "; "
+            SVQ_CAPS "; "
+            "video/x-dv, "
+            "systemstream = (boolean) false, "
+            COMMON_VIDEO_CAPS "; "
+            "image/jpeg, "
+            COMMON_VIDEO_CAPS_NO_FRAMERATE "; "
+            "video/x-vp8, "
+            COMMON_VIDEO_CAPS "; " "video/x-qt-part, " COMMON_VIDEO_CAPS),
+        GST_STATIC_CAPS (PCM_CAPS_FULL "; "
+            MP3_CAPS " ; "
+            AAC_CAPS " ; "
+            ADPCM_CAPS " ; "
+            "audio/x-alaw, " COMMON_AUDIO_CAPS (2, MAX) "; "
+            AMR_CAPS " ; " ALAC_CAPS)
+      }
+  ,
+  /* ISO 14496-14: mp42 as ISO base media extension
+   * (supersedes original ISO 144996-1 mp41) */
+  {
+        GST_QT_MUX_FORMAT_MP4,
+        GST_RANK_PRIMARY,
+        "mp4mux",
+        "MP4",
+        "GstMP4Mux",
+        GST_STATIC_CAPS ("video/quicktime, variant = (string) iso"),
+        GST_STATIC_CAPS (MPEG4V_CAPS "; " H264_CAPS ";"
+            "video/x-mp4-part," COMMON_VIDEO_CAPS),
+        GST_STATIC_CAPS (MP3_CAPS "; " AAC_CAPS " ; " ALAC_CAPS)
+      }
+  ,
+  /* Microsoft Smooth Streaming fmp4/isml */
+  /* TODO add WMV/WMA support */
+  {
+        GST_QT_MUX_FORMAT_ISML,
+        GST_RANK_PRIMARY,
+        "ismlmux",
+        "ISML",
+        "GstISMLMux",
+        GST_STATIC_CAPS ("video/quicktime, variant = (string) iso"),
+        GST_STATIC_CAPS (MPEG4V_CAPS "; " H264_CAPS),
+        GST_STATIC_CAPS (MP3_CAPS "; " AAC_CAPS)
+      }
+  ,
+  /* 3GPP Technical Specification 26.244 V7.3.0
+   * (extended in 3GPP2 File Formats for Multimedia Services) */
+  {
+        GST_QT_MUX_FORMAT_3GP,
+        GST_RANK_PRIMARY,
+        "3gppmux",
+        "3GPP",
+        "Gst3GPPMux",
+        GST_STATIC_CAPS ("video/quicktime, variant = (string) 3gpp"),
+        GST_STATIC_CAPS (H263_CAPS "; " MPEG4V_CAPS "; " H264_CAPS),
+        GST_STATIC_CAPS (AMR_CAPS "; " MP3_CAPS "; " AAC_CAPS)
+      }
+  ,
+#ifndef GST_REMOVE_DEPRECATED
+  /* 3GPP Technical Specification 26.244 V7.3.0
+   * (extended in 3GPP2 File Formats for Multimedia Services) */
+  {
+        GST_QT_MUX_FORMAT_3GP,
+        GST_RANK_NONE,
+        "gppmux",
+        "3GPP",
+        "GstGPPMux",
+        GST_STATIC_CAPS ("video/quicktime, variant = (string) 3gpp"),
+        GST_STATIC_CAPS (H263_CAPS "; " MPEG4V_CAPS "; " H264_CAPS),
+        GST_STATIC_CAPS (AMR_CAPS "; " MP3_CAPS "; " AAC_CAPS)
+      }
+  ,
+#endif
+  /* ISO 15444-3: Motion-JPEG-2000 (also ISO base media extension) */
+  {
+        GST_QT_MUX_FORMAT_MJ2,
+        GST_RANK_PRIMARY,
+        "mj2mux",
+        "MJ2",
+        "GstMJ2Mux",
+        GST_STATIC_CAPS ("video/mj2"),
+        GST_STATIC_CAPS ("image/x-j2c, " COMMON_VIDEO_CAPS "; "
+            "image/x-jpc, " COMMON_VIDEO_CAPS),
+        GST_STATIC_CAPS (PCM_CAPS)
+      }
+  ,
+  {
+        GST_QT_MUX_FORMAT_NONE,
+      }
+};
+
+/* pretty static, but may turn out needed a few times */
+AtomsTreeFlavor
+gst_qt_mux_map_format_to_flavor (GstQTMuxFormat format)
+{
+  if (format == GST_QT_MUX_FORMAT_QT)
+    return ATOMS_TREE_FLAVOR_MOV;
+  else if (format == GST_QT_MUX_FORMAT_3GP)
+    return ATOMS_TREE_FLAVOR_3GP;
+  else if (format == GST_QT_MUX_FORMAT_ISML)
+    return ATOMS_TREE_FLAVOR_ISML;
+  else
+    return ATOMS_TREE_FLAVOR_ISOM;
+}
+
+static void
+gst_qt_mux_map_check_tracks (AtomMOOV * moov, gint * _video, gint * _audio,
+    gboolean * _has_h264)
+{
+  GList *it;
+  gint video = 0, audio = 0;
+  gboolean has_h264 = FALSE;
+
+  for (it = moov->traks; it != NULL; it = g_list_next (it)) {
+    AtomTRAK *track = it->data;
+
+    if (track->is_video) {
+      video++;
+      if (track->is_h264)
+        has_h264 = TRUE;
+    } else
+      audio++;
+  }
+
+  if (_video)
+    *_video = video;
+  if (_audio)
+    *_audio = audio;
+  if (_has_h264)
+    *_has_h264 = has_h264;
+}
+
+/* pretty static, but possibly dynamic format info */
+
+/* notes:
+ * - avc1 brand is not used, since the specific extensions indicated by it
+ *   are not used (e.g. sample groupings, etc)
+ * - TODO: maybe even more 3GPP brand fine-tuning ??
+ *   (but that might need ftyp rewriting at the end) */
+void
+gst_qt_mux_map_format_to_header (GstQTMuxFormat format, GstBuffer ** _prefix,
+    guint32 * _major, guint32 * _version, GList ** _compatible, AtomMOOV * moov,
+    GstClockTime longest_chunk, gboolean faststart)
+{
+  static guint32 qt_brands[] = { 0 };
+  static guint32 mp4_brands[] = { FOURCC_mp41, FOURCC_isom, FOURCC_iso2, 0 };
+  static guint32 isml_brands[] = { FOURCC_iso2, 0 };
+  static guint32 gpp_brands[] = { FOURCC_isom, FOURCC_iso2, 0 };
+  static guint32 mjp2_brands[] = { FOURCC_isom, FOURCC_iso2, 0 };
+  static guint8 mjp2_prefix[] =
+      { 0, 0, 0, 12, 'j', 'P', ' ', ' ', 0x0D, 0x0A, 0x87, 0x0A };
+  guint32 *comp = NULL;
+  guint32 major = 0, version = 0;
+  GstBuffer *prefix = NULL;
+  GList *result = NULL;
+
+  g_return_if_fail (_prefix != NULL);
+  g_return_if_fail (_major != NULL);
+  g_return_if_fail (_version != NULL);
+  g_return_if_fail (_compatible != NULL);
+
+  switch (format) {
+    case GST_QT_MUX_FORMAT_QT:
+      major = FOURCC_qt__;
+      comp = qt_brands;
+      version = 0x20050300;
+      break;
+    case GST_QT_MUX_FORMAT_MP4:
+      major = FOURCC_mp42;
+      comp = mp4_brands;
+      break;
+    case GST_QT_MUX_FORMAT_ISML:
+      major = FOURCC_isml;
+      comp = isml_brands;
+      break;
+    case GST_QT_MUX_FORMAT_3GP:
+    {
+      gint video, audio;
+      gboolean has_h264;
+
+      gst_qt_mux_map_check_tracks (moov, &video, &audio, &has_h264);
+      /* only track restriction really matters for Basic Profile */
+      if (video <= 1 && audio <= 1) {
+        /* it seems only newer spec knows about H264 */
+        major = has_h264 ? FOURCC_3gp6 : FOURCC_3gp4;
+        version = has_h264 ? 0x100 : 0x200;
+      } else {
+        major = FOURCC_3gg6;
+        version = 0x100;
+      }
+      comp = gpp_brands;
+
+      /*
+       * We assume that we have chunks in dts order
+       */
+      if (faststart && longest_chunk <= GST_SECOND) {
+        /* add progressive download profile */
+        result = g_list_append (result, GUINT_TO_POINTER (FOURCC_3gr6));
+      }
+      break;
+    }
+    case GST_QT_MUX_FORMAT_MJ2:
+      major = FOURCC_mjp2;
+      comp = mjp2_brands;
+      version = 0;
+      prefix = gst_buffer_new_and_alloc (sizeof (mjp2_prefix));
+      memcpy (GST_BUFFER_DATA (prefix), mjp2_prefix, GST_BUFFER_SIZE (prefix));
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+
+  /* convert list to list, hm */
+  while (comp && *comp != 0) {
+    /* order matters over efficiency */
+    result = g_list_append (result, GUINT_TO_POINTER (*comp));
+    comp++;
+  }
+
+  *_major = major;
+  *_version = version;
+  *_prefix = prefix;
+  *_compatible = result;
+
+  /* TODO 3GPP may include mp42 as compatible if applicable */
+  /* TODO 3GPP major brand 3gp7 if at most 1 video and audio track */
+}
diff --git a/gst/isomp4/gstqtmuxmap.h b/gst/isomp4/gstqtmuxmap.h
new file mode 100644
index 000000000..f069a2f1d
--- /dev/null
+++ b/gst/isomp4/gstqtmuxmap.h
@@ -0,0 +1,84 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __GST_QT_MUX_MAP_H__
+#define __GST_QT_MUX_MAP_H__
+
+#include "atoms.h"
+
+#include <glib.h>
+#include <gst/gst.h>
+
+typedef enum _GstQTMuxFormat
+{
+  GST_QT_MUX_FORMAT_NONE = 0,
+  GST_QT_MUX_FORMAT_QT,
+  GST_QT_MUX_FORMAT_MP4,
+  GST_QT_MUX_FORMAT_3GP,
+  GST_QT_MUX_FORMAT_MJ2,
+  GST_QT_MUX_FORMAT_ISML
+} GstQTMuxFormat;
+
+typedef struct _GstQTMuxFormatProp
+{
+  GstQTMuxFormat format;
+  GstRank rank;
+  const gchar *name;
+  const gchar *long_name;
+  const gchar *type_name;
+  GstStaticCaps src_caps;
+  GstStaticCaps video_sink_caps;
+  GstStaticCaps audio_sink_caps;
+} GstQTMuxFormatProp;
+
+extern GstQTMuxFormatProp gst_qt_mux_format_list[];
+
+void            gst_qt_mux_map_format_to_header      (GstQTMuxFormat format, GstBuffer ** _prefix,
+                                                      guint32 * _major, guint32 * verson,
+                                                      GList ** _compatible, AtomMOOV * moov,
+                                                      GstClockTime longest_chunk,
+                                                      gboolean faststart);
+
+AtomsTreeFlavor gst_qt_mux_map_format_to_flavor      (GstQTMuxFormat format);
+
+#endif /* __GST_QT_MUX_MAP_H__ */
diff --git a/gst/isomp4/gstrtpxqtdepay.c b/gst/isomp4/gstrtpxqtdepay.c
new file mode 100644
index 000000000..66a9219d9
--- /dev/null
+++ b/gst/isomp4/gstrtpxqtdepay.c
@@ -0,0 +1,694 @@
+/* GStreamer
+ * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>
+ *
+ * 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.
+ */
+
+/*
+ * based on http://developer.apple.com/quicktime/icefloe/dispatch026.html
+ */
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <gst/rtp/gstrtpbuffer.h>
+
+#include <string.h>
+#include "gstrtpxqtdepay.h"
+
+#define MAKE_TLV(a,b)  (((a)<<8)|(b))
+
+#define TLV_sd	MAKE_TLV ('s','d')
+#define TLV_qt	MAKE_TLV ('q','t')
+#define TLV_ti	MAKE_TLV ('t','i')
+#define TLV_ly	MAKE_TLV ('l','y')
+#define TLV_vo	MAKE_TLV ('v','o')
+#define TLV_mx	MAKE_TLV ('m','x')
+#define TLV_tr	MAKE_TLV ('t','r')
+#define TLV_tw	MAKE_TLV ('t','w')
+#define TLV_th	MAKE_TLV ('t','h')
+#define TLV_la	MAKE_TLV ('l','a')
+#define TLV_rt	MAKE_TLV ('r','t')
+#define TLV_gm	MAKE_TLV ('g','m')
+#define TLV_oc	MAKE_TLV ('o','c')
+#define TLV_cr	MAKE_TLV ('c','r')
+#define TLV_du	MAKE_TLV ('d','u')
+#define TLV_po	MAKE_TLV ('p','o')
+
+#define QT_UINT32(a)  (GST_READ_UINT32_BE(a))
+#define QT_UINT24(a)  (GST_READ_UINT32_BE(a) >> 8)
+#define QT_UINT16(a)  (GST_READ_UINT16_BE(a))
+#define QT_UINT8(a)   (GST_READ_UINT8(a))
+#define QT_FP32(a)    ((GST_READ_UINT32_BE(a))/65536.0)
+#define QT_FP16(a)    ((GST_READ_UINT16_BE(a))/256.0)
+#define QT_FOURCC(a)  (GST_READ_UINT32_LE(a))
+#define QT_UINT64(a)  ((((guint64)QT_UINT32(a))<<32)|QT_UINT32(((guint8 *)a)+4))
+
+#define FOURCC_avc1     GST_MAKE_FOURCC('a','v','c','1')
+#define FOURCC_avcC     GST_MAKE_FOURCC('a','v','c','C')
+
+GST_DEBUG_CATEGORY_STATIC (rtpxqtdepay_debug);
+#define GST_CAT_DEFAULT (rtpxqtdepay_debug)
+
+/* RtpXQTDepay signals and args */
+enum
+{
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum
+{
+  ARG_0,
+};
+
+static GstStaticPadTemplate gst_rtp_xqt_depay_src_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS_ANY);
+
+static GstStaticPadTemplate gst_rtp_xqt_depay_sink_template =
+GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("application/x-rtp, "
+        "payload = (int) " GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
+        "media = (string) { \"audio\", \"video\" }, clock-rate = (int) [1, MAX], "
+        "encoding-name = (string) { \"X-QT\", \"X-QUICKTIME\" }")
+    );
+
+GST_BOILERPLATE (GstRtpXQTDepay, gst_rtp_xqt_depay, GstBaseRTPDepayload,
+    GST_TYPE_BASE_RTP_DEPAYLOAD);
+
+static void gst_rtp_xqt_depay_finalize (GObject * object);
+
+static gboolean gst_rtp_xqt_depay_setcaps (GstBaseRTPDepayload * depayload,
+    GstCaps * caps);
+static GstBuffer *gst_rtp_xqt_depay_process (GstBaseRTPDepayload * depayload,
+    GstBuffer * buf);
+
+static GstStateChangeReturn gst_rtp_xqt_depay_change_state (GstElement *
+    element, GstStateChange transition);
+
+static void
+gst_rtp_xqt_depay_base_init (gpointer klass)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_rtp_xqt_depay_src_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_rtp_xqt_depay_sink_template));
+
+  gst_element_class_set_details_simple (element_class, "RTP packet depayloader",
+      "Codec/Depayloader/Network",
+      "Extracts Quicktime audio/video from RTP packets",
+      "Wim Taymans <wim@fluendo.com>");
+}
+
+static void
+gst_rtp_xqt_depay_class_init (GstRtpXQTDepayClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+  GstBaseRTPDepayloadClass *gstbasertpdepayload_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+  gstbasertpdepayload_class = (GstBaseRTPDepayloadClass *) klass;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->finalize = gst_rtp_xqt_depay_finalize;
+
+  gstelement_class->change_state = gst_rtp_xqt_depay_change_state;
+
+  gstbasertpdepayload_class->set_caps = gst_rtp_xqt_depay_setcaps;
+  gstbasertpdepayload_class->process = gst_rtp_xqt_depay_process;
+
+  GST_DEBUG_CATEGORY_INIT (rtpxqtdepay_debug, "rtpxqtdepay", 0,
+      "QT Media RTP Depayloader");
+}
+
+static void
+gst_rtp_xqt_depay_init (GstRtpXQTDepay * rtpxqtdepay,
+    GstRtpXQTDepayClass * klass)
+{
+  rtpxqtdepay->adapter = gst_adapter_new ();
+}
+
+static void
+gst_rtp_xqt_depay_finalize (GObject * object)
+{
+  GstRtpXQTDepay *rtpxqtdepay;
+
+  rtpxqtdepay = GST_RTP_XQT_DEPAY (object);
+
+  g_object_unref (rtpxqtdepay->adapter);
+  rtpxqtdepay->adapter = NULL;
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static gboolean
+gst_rtp_quicktime_parse_sd (GstRtpXQTDepay * rtpxqtdepay, guint8 * data,
+    guint data_len)
+{
+  gint len;
+  guint32 fourcc;
+
+  if (data_len < 8)
+    goto too_short;
+
+  len = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
+  if (len > data_len)
+    goto too_short;
+
+  fourcc = QT_FOURCC (data + 4);
+
+  GST_DEBUG_OBJECT (rtpxqtdepay, "parsing %" GST_FOURCC_FORMAT,
+      GST_FOURCC_ARGS (fourcc));
+
+  switch (fourcc) {
+    case FOURCC_avc1:
+    {
+      guint32 chlen;
+
+      if (len < 0x56)
+        goto too_short;
+      len -= 0x56;
+      data += 0x56;
+
+      /* find avcC */
+      while (len >= 8) {
+        chlen = QT_UINT32 (data);
+        fourcc = QT_FOURCC (data + 4);
+        if (fourcc == FOURCC_avcC) {
+          GstBuffer *buf;
+          gint size;
+          GstCaps *caps;
+
+          GST_DEBUG_OBJECT (rtpxqtdepay, "found avcC codec_data in sd, %u",
+              chlen);
+
+          /* parse, if found */
+          if (chlen < len)
+            size = chlen - 8;
+          else
+            size = len - 8;
+
+          buf = gst_buffer_new_and_alloc (size);
+          memcpy (GST_BUFFER_DATA (buf), data + 8, size);
+          caps = gst_caps_new_simple ("video/x-h264",
+              "codec_data", GST_TYPE_BUFFER, buf, NULL);
+          gst_buffer_unref (buf);
+          gst_pad_set_caps (GST_BASE_RTP_DEPAYLOAD (rtpxqtdepay)->srcpad, caps);
+          gst_caps_unref (caps);
+          break;
+        }
+        len -= chlen;
+        data += chlen;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return TRUE;
+
+  /* ERRORS */
+too_short:
+  {
+    return FALSE;
+  }
+}
+
+static gboolean
+gst_rtp_xqt_depay_setcaps (GstBaseRTPDepayload * depayload, GstCaps * caps)
+{
+  GstStructure *structure;
+  gint clock_rate = 90000;      /* default */
+
+  structure = gst_caps_get_structure (caps, 0);
+
+  gst_structure_get_int (structure, "clock-rate", &clock_rate);
+  depayload->clock_rate = clock_rate;
+
+  return TRUE;
+}
+
+static GstBuffer *
+gst_rtp_xqt_depay_process (GstBaseRTPDepayload * depayload, GstBuffer * buf)
+{
+  GstRtpXQTDepay *rtpxqtdepay;
+  GstBuffer *outbuf;
+  gboolean m;
+
+  rtpxqtdepay = GST_RTP_XQT_DEPAY (depayload);
+
+  if (!gst_rtp_buffer_validate (buf))
+    goto bad_packet;
+
+  if (GST_BUFFER_IS_DISCONT (buf)) {
+    /* discont, clear adapter and try to find a new packet start */
+    gst_adapter_clear (rtpxqtdepay->adapter);
+    rtpxqtdepay->need_resync = TRUE;
+    GST_DEBUG_OBJECT (rtpxqtdepay, "we need resync");
+  }
+
+  m = gst_rtp_buffer_get_marker (buf);
+  GST_LOG_OBJECT (rtpxqtdepay, "marker: %d", m);
+
+  {
+    gint payload_len;
+    guint avail;
+    guint8 *payload;
+    guint8 ver, pck;
+    gboolean s, q, l, d;
+
+    payload_len = gst_rtp_buffer_get_payload_len (buf);
+    payload = gst_rtp_buffer_get_payload (buf);
+
+    /*                      1                   2                   3 
+     *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+     * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     * | VER   |PCK|S|Q|L| RES         |D| QuickTime Payload ID        |
+     * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     */
+    if (payload_len <= 4)
+      goto wrong_length;
+
+    ver = (payload[0] & 0xf0) >> 4;
+    if (ver > 1)
+      goto wrong_version;
+
+    pck = (payload[0] & 0x0c) >> 2;
+    if (pck == 0)
+      goto pck_reserved;
+
+    s = (payload[0] & 0x02) != 0;       /* contains sync sample */
+    q = (payload[0] & 0x01) != 0;       /* has payload description */
+    l = (payload[1] & 0x80) != 0;       /* has packet specific information description */
+    d = (payload[2] & 0x80) != 0;       /* don't cache info for payload id */
+    /* id used for caching info */
+    rtpxqtdepay->current_id = ((payload[2] & 0x7f) << 8) | payload[3];
+
+    GST_LOG_OBJECT (rtpxqtdepay,
+        "VER: %d, PCK: %d, S: %d, Q: %d, L: %d, D: %d, ID: %d", ver, pck, s, q,
+        l, d, rtpxqtdepay->current_id);
+
+    if (rtpxqtdepay->need_resync) {
+      /* we need to find the boundary of a new packet after a DISCONT */
+      if (pck != 3 || q) {
+        /* non-fragmented packet or payload description present, packet starts
+         * here. */
+        rtpxqtdepay->need_resync = FALSE;
+      } else {
+        /* fragmented packet without description */
+        if (m) {
+          /* marker bit set, next packet is start of new one */
+          rtpxqtdepay->need_resync = FALSE;
+        }
+        goto need_resync;
+      }
+    }
+
+    payload += 4;
+    payload_len -= 4;
+
+    if (q) {
+      gboolean k, f, a, z;
+      guint pdlen, pdpadded;
+      gint padding;
+      /* media_type only used for printing */
+      guint32 G_GNUC_UNUSED media_type;
+      guint32 timescale;
+
+      /*                      1                   2                   3
+       *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * |K|F|A|Z| RES                   | QuickTime Payload Desc Length |
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * . QuickTime Payload Desc Data ... . 
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       */
+      if (payload_len <= 4)
+        goto wrong_length;
+
+      k = (payload[0] & 0x80) != 0;     /* keyframe */
+      f = (payload[0] & 0x40) != 0;     /* sparse */
+      a = (payload[0] & 0x20) != 0;     /* start of payload */
+      z = (payload[0] & 0x10) != 0;     /* end of payload */
+      pdlen = (payload[2] << 8) | payload[3];
+
+      if (pdlen < 12)
+        goto wrong_length;
+
+      /* calc padding */
+      pdpadded = pdlen + 3;
+      pdpadded -= pdpadded % 4;
+      if (payload_len < pdpadded)
+        goto wrong_length;
+
+      padding = pdpadded - pdlen;
+      GST_LOG_OBJECT (rtpxqtdepay,
+          "K: %d, F: %d, A: %d, Z: %d, len: %d, padding %d", k, f, a, z, pdlen,
+          padding);
+
+      payload += 4;
+      payload_len -= 4;
+      /*                      1                   2                   3
+       *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * | QuickTime Media Type                                          |
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * | Timescale                                                     |
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * . QuickTime TLVs ... .
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       */
+      media_type =
+          (payload[0] << 24) | (payload[1] << 16) | (payload[2] << 8) |
+          payload[3];
+      timescale =
+          (payload[4] << 24) | (payload[5] << 16) | (payload[6] << 8) |
+          payload[7];
+
+      GST_LOG_OBJECT (rtpxqtdepay, "media_type: %c%c%c%c, timescale %u",
+          payload[0], payload[1], payload[2], payload[3], timescale);
+
+      payload += 8;
+      payload_len -= 8;
+      pdlen -= 12;
+
+      /* parse TLV (type-length-value triplets */
+      while (pdlen > 3) {
+        guint16 tlv_len, tlv_type;
+
+        /*                      1                   2                   3
+         *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * | QuickTime TLV Length          | QuickTime TLV Type            |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * . QuickTime TLV Value ... .
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         */
+        tlv_len = (payload[0] << 8) | payload[1];
+        tlv_type = (payload[2] << 8) | payload[3];
+        pdlen -= 4;
+        if (tlv_len > pdlen)
+          goto wrong_length;
+
+        GST_LOG_OBJECT (rtpxqtdepay, "TLV '%c%c', len %d", payload[2],
+            payload[3], tlv_len);
+
+        payload += 4;
+        payload_len -= 4;
+
+        switch (tlv_type) {
+          case TLV_sd:
+            /* Session description */
+            if (!gst_rtp_quicktime_parse_sd (rtpxqtdepay, payload, tlv_len))
+              goto unknown_format;
+            rtpxqtdepay->have_sd = TRUE;
+            break;
+          case TLV_qt:
+          case TLV_ti:
+          case TLV_ly:
+          case TLV_vo:
+          case TLV_mx:
+          case TLV_tr:
+          case TLV_tw:
+          case TLV_th:
+          case TLV_la:
+          case TLV_rt:
+          case TLV_gm:
+          case TLV_oc:
+          case TLV_cr:
+          case TLV_du:
+          case TLV_po:
+          default:
+            break;
+        }
+
+        pdlen -= tlv_len;
+        payload += tlv_len;
+        payload_len -= tlv_len;
+      }
+      payload += padding;
+      payload_len -= padding;
+    }
+
+    if (l) {
+      guint ssilen, ssipadded;
+      gint padding;
+
+      /*                      1                   2                   3
+       *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * | RES                           | Sample-Specific Info Length   |
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       * . QuickTime TLVs ... 
+       * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       */
+      if (payload_len <= 4)
+        goto wrong_length;
+
+      ssilen = (payload[2] << 8) | payload[3];
+      if (ssilen < 4)
+        goto wrong_length;
+
+      /* calc padding */
+      ssipadded = ssilen + 3;
+      ssipadded -= ssipadded % 4;
+      if (payload_len < ssipadded)
+        goto wrong_length;
+
+      padding = ssipadded - ssilen;
+      GST_LOG_OBJECT (rtpxqtdepay, "len: %d, padding %d", ssilen, padding);
+
+      payload += 4;
+      payload_len -= 4;
+      ssilen -= 4;
+
+      /* parse TLV (type-length-value triplets */
+      while (ssilen > 3) {
+        guint16 tlv_len, tlv_type;
+
+        /*                      1                   2                   3
+         *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * | QuickTime TLV Length          | QuickTime TLV Type            |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * . QuickTime TLV Value ... .
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         */
+        tlv_len = (payload[0] << 8) | payload[1];
+        tlv_type = (payload[2] << 8) | payload[3];
+        ssilen -= 4;
+        if (tlv_len > ssilen)
+          goto wrong_length;
+
+        GST_LOG_OBJECT (rtpxqtdepay, "TLV '%c%c', len %d", payload[2],
+            payload[3], tlv_len);
+
+        payload += 4;
+        payload_len -= 4;
+
+        switch (tlv_type) {
+          case TLV_sd:
+          case TLV_qt:
+          case TLV_ti:
+          case TLV_ly:
+          case TLV_vo:
+          case TLV_mx:
+          case TLV_tr:
+          case TLV_tw:
+          case TLV_th:
+          case TLV_la:
+          case TLV_rt:
+          case TLV_gm:
+          case TLV_oc:
+          case TLV_cr:
+          case TLV_du:
+          case TLV_po:
+          default:
+            break;
+        }
+
+        ssilen -= tlv_len;
+        payload += tlv_len;
+        payload_len -= tlv_len;
+      }
+      payload += padding;
+      payload_len -= padding;
+    }
+
+    rtpxqtdepay->previous_id = rtpxqtdepay->current_id;
+
+    switch (pck) {
+      case 1:
+      {
+        /* multiple samples per packet. */
+        outbuf = gst_buffer_new_and_alloc (payload_len);
+        memcpy (GST_BUFFER_DATA (outbuf), payload, payload_len);
+        return outbuf;
+      }
+      case 2:
+      {
+        guint slen;
+
+        /* multiple samples per packet. 
+         *                      1                   2                   3
+         *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * |S| Reserved                    | Sample Length                 |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * | Sample Timestamp                                              |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * . Sample Data ...                                               .
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * |S| Reserved                    | Sample Length                 |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * | Sample Timestamp                                              |
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * . Sample Data ...                                               .
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         * . ......                                                        .
+         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         */
+        while (payload_len > 8) {
+          s = (payload[0] & 0x80) != 0; /* contains sync sample */
+          slen = (payload[2] << 8) | payload[3];
+          /* timestamp =
+           *    (payload[4] << 24) | (payload[5] << 16) | (payload[6] << 8) |
+           *    payload[7];
+           */
+
+          payload += 8;
+          payload_len -= 8;
+
+          if (slen > payload_len)
+            slen = payload_len;
+
+          outbuf = gst_buffer_new_and_alloc (slen);
+          memcpy (GST_BUFFER_DATA (outbuf), payload, slen);
+          if (!s)
+            GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
+
+          gst_base_rtp_depayload_push (depayload, outbuf);
+
+          /* aligned on 32 bit boundary */
+          slen = GST_ROUND_UP_4 (slen);
+
+          payload += slen;
+          payload_len -= slen;
+        }
+        break;
+      }
+      case 3:
+      {
+        /* one sample per packet, use adapter to combine based on marker bit. */
+        outbuf = gst_buffer_new_and_alloc (payload_len);
+        memcpy (GST_BUFFER_DATA (outbuf), payload, payload_len);
+
+        gst_adapter_push (rtpxqtdepay->adapter, outbuf);
+
+        if (!m)
+          goto done;
+
+        avail = gst_adapter_available (rtpxqtdepay->adapter);
+        outbuf = gst_adapter_take_buffer (rtpxqtdepay->adapter, avail);
+
+        GST_DEBUG_OBJECT (rtpxqtdepay,
+            "gst_rtp_xqt_depay_chain: pushing buffer of size %u", avail);
+
+        return outbuf;
+      }
+    }
+  }
+
+done:
+  return NULL;
+
+bad_packet:
+  {
+    GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
+        ("Packet did not validate."), (NULL));
+    return NULL;
+  }
+need_resync:
+  {
+    GST_DEBUG_OBJECT (rtpxqtdepay, "waiting for marker");
+    return NULL;
+  }
+wrong_version:
+  {
+    GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
+        ("Unknown payload version."), (NULL));
+    return NULL;
+  }
+pck_reserved:
+  {
+    GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
+        ("PCK reserved 0."), (NULL));
+    return NULL;
+  }
+wrong_length:
+  {
+    GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
+        ("Wrong payload length."), (NULL));
+    return NULL;
+  }
+unknown_format:
+  {
+    GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
+        ("Unknown payload format."), (NULL));
+    return NULL;
+  }
+}
+
+static GstStateChangeReturn
+gst_rtp_xqt_depay_change_state (GstElement * element, GstStateChange transition)
+{
+  GstRtpXQTDepay *rtpxqtdepay;
+  GstStateChangeReturn ret;
+
+  rtpxqtdepay = GST_RTP_XQT_DEPAY (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      gst_adapter_clear (rtpxqtdepay->adapter);
+      rtpxqtdepay->previous_id = -1;
+      rtpxqtdepay->current_id = -1;
+      rtpxqtdepay->need_resync = TRUE;
+      rtpxqtdepay->have_sd = FALSE;
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_adapter_clear (rtpxqtdepay->adapter);
+    default:
+      break;
+  }
+  return ret;
+}
diff --git a/gst/isomp4/gstrtpxqtdepay.h b/gst/isomp4/gstrtpxqtdepay.h
new file mode 100644
index 000000000..4b8a6df8b
--- /dev/null
+++ b/gst/isomp4/gstrtpxqtdepay.h
@@ -0,0 +1,64 @@
+/* GStreamer
+ * Copyright (C) <2005> Wim Taymans <wim@fluendo.com>
+ *
+ * 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_RTP_XQT_DEPAY_H__
+#define __GST_RTP_XQT_DEPAY_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstadapter.h>
+#include <gst/rtp/gstbasertpdepayload.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_RTP_XQT_DEPAY \
+  (gst_rtp_xqt_depay_get_type())
+#define GST_RTP_XQT_DEPAY(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_XQT_DEPAY,GstRtpXQTDepay))
+#define GST_RTP_XQT_DEPAY_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_XQT_DEPAY,GstRtpXQTDepayClass))
+#define GST_IS_RTP_XQT_DEPAY(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_XQT_DEPAY))
+#define GST_IS_RTP_XQT_DEPAY_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_XQT_DEPAY))
+
+typedef struct _GstRtpXQTDepay GstRtpXQTDepay;
+typedef struct _GstRtpXQTDepayClass GstRtpXQTDepayClass;
+
+struct _GstRtpXQTDepay
+{
+  GstBaseRTPDepayload depayload;
+
+  GstAdapter *adapter;
+
+  gboolean need_resync;
+  guint16 previous_id;
+  guint16 current_id;
+  gboolean have_sd;
+};
+
+struct _GstRtpXQTDepayClass
+{
+  GstBaseRTPDepayloadClass parent_class;
+};
+
+GType gst_rtp_xqt_depay_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_RTP_XQT_DEPAY_H__ */
diff --git a/gst/isomp4/isomp4-plugin.c b/gst/isomp4/isomp4-plugin.c
new file mode 100644
index 000000000..1e26d30b1
--- /dev/null
+++ b/gst/isomp4/isomp4-plugin.c
@@ -0,0 +1,74 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
+ * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include "gst/gst-i18n-plugin.h"
+
+#include "qtdemux.h"
+#include "gstrtpxqtdepay.h"
+#include "gstqtmux.h"
+#include "gstqtmoovrecover.h"
+
+#include <gst/pbutils/pbutils.h>
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+#ifdef ENABLE_NLS
+  setlocale (LC_ALL, "");
+  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+#endif /* ENABLE_NLS */
+
+  gst_pb_utils_init ();
+
+  /* ensure private tag is registered */
+  gst_tag_register (GST_QT_DEMUX_PRIVATE_TAG, GST_TAG_FLAG_META,
+      GST_TYPE_BUFFER, "QT atom", "unparsed QT tag atom",
+      gst_tag_merge_use_first);
+
+  gst_tag_register (GST_QT_DEMUX_CLASSIFICATION_TAG, GST_TAG_FLAG_META,
+      G_TYPE_STRING, GST_QT_DEMUX_CLASSIFICATION_TAG, "content classification",
+      gst_tag_merge_use_first);
+
+  if (!gst_element_register (plugin, "qtdemux",
+          GST_RANK_PRIMARY, GST_TYPE_QTDEMUX))
+    return FALSE;
+
+  if (!gst_element_register (plugin, "rtpxqtdepay",
+          GST_RANK_MARGINAL, GST_TYPE_RTP_XQT_DEPAY))
+    return FALSE;
+
+  if (!gst_qt_mux_register (plugin))
+    return FALSE;
+  if (!gst_qt_moov_recover_register (plugin))
+    return FALSE;
+
+  return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "isomp4",
+    "ISO base media file format support (mp4, 3gpp, qt, mj2)",
+    plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
diff --git a/gst/isomp4/properties.c b/gst/isomp4/properties.c
new file mode 100644
index 000000000..8dafb2e21
--- /dev/null
+++ b/gst/isomp4/properties.c
@@ -0,0 +1,210 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#include "properties.h"
+
+/* if needed, re-allocate buffer to ensure size bytes can be written into it
+ * at offset */
+void
+prop_copy_ensure_buffer (guint8 ** buffer, guint64 * bsize, guint64 * offset,
+    guint64 size)
+{
+  if (buffer && *bsize - *offset < size) {
+    *bsize += size + 10 * 1024;
+    *buffer = g_realloc (*buffer, *bsize);
+  }
+}
+
+static guint64
+copy_func (void *prop, guint size, guint8 ** buffer, guint64 * bsize,
+    guint64 * offset)
+{
+  if (buffer) {
+    prop_copy_ensure_buffer (buffer, bsize, offset, size);
+    memcpy (*buffer + *offset, prop, size);
+  }
+  *offset += size;
+  return size;
+}
+
+#define INT_ARRAY_COPY_FUNC_FAST(name, datatype) 			\
+guint64 prop_copy_ ## name ## _array (datatype *prop, guint size,	\
+    guint8 ** buffer, guint64 * bsize, guint64 * offset) { 		\
+  return copy_func (prop, sizeof (datatype) * size, buffer, bsize, offset);\
+}
+
+#define INT_ARRAY_COPY_FUNC(name, datatype) 				\
+guint64 prop_copy_ ## name ## _array (datatype *prop, guint size,	\
+    guint8 ** buffer, guint64 * bsize, guint64 * offset) { 		\
+  guint i;								\
+									\
+  for (i = 0; i < size; i++) {						\
+    prop_copy_ ## name (prop[i], buffer, bsize, offset);		\
+  }									\
+  return sizeof (datatype) * size;					\
+}
+
+/* INTEGERS */
+guint64
+prop_copy_uint8 (guint8 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  return copy_func (&prop, sizeof (guint8), buffer, size, offset);
+}
+
+guint64
+prop_copy_uint16 (guint16 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  prop = GUINT16_TO_BE (prop);
+  return copy_func (&prop, sizeof (guint16), buffer, size, offset);
+}
+
+guint64
+prop_copy_uint32 (guint32 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  prop = GUINT32_TO_BE (prop);
+  return copy_func (&prop, sizeof (guint32), buffer, size, offset);
+}
+
+guint64
+prop_copy_uint64 (guint64 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  prop = GUINT64_TO_BE (prop);
+  return copy_func (&prop, sizeof (guint64), buffer, size, offset);
+}
+
+guint64
+prop_copy_int32 (gint32 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  prop = GINT32_TO_BE (prop);
+  return copy_func (&prop, sizeof (guint32), buffer, size, offset);
+}
+
+/* uint8 can use direct copy in any case, and may be used for large quantity */
+INT_ARRAY_COPY_FUNC_FAST (uint8, guint8);
+/* not used in large quantity anyway */
+INT_ARRAY_COPY_FUNC (uint16, guint16);
+INT_ARRAY_COPY_FUNC (uint32, guint32);
+INT_ARRAY_COPY_FUNC (uint64, guint64);
+
+/* FOURCC */
+guint64
+prop_copy_fourcc (guint32 prop, guint8 ** buffer, guint64 * size,
+    guint64 * offset)
+{
+  prop = GINT32_TO_LE (prop);
+  return copy_func (&prop, sizeof (guint32), buffer, size, offset);
+}
+
+INT_ARRAY_COPY_FUNC (fourcc, guint32);
+
+/**
+ * prop_copy_fixed_size_string:
+ * @string: the string to be copied
+ * @str_size: size of the string
+ * @buffer: the array to copy the string to
+ * @offset: the position in the buffer array.
+ * This value is updated to the point right after the copied string.
+ *
+ * Copies a string of bytes without placing its size at the beginning.
+ *
+ * Returns: the number of bytes copied
+ */
+guint64
+prop_copy_fixed_size_string (guint8 * string, guint str_size, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  return copy_func (string, str_size * sizeof (guint8), buffer, size, offset);
+}
+
+/**
+ * prop_copy_size_string:
+ *
+ * @string: the string to be copied
+ * @str_size: size of the string
+ * @buffer: the array to copy the string to
+ * @offset: the position in the buffer array.
+ * This value is updated to the point right after the copied string.
+ *
+ * Copies a string and its size to an array. Example:
+ * string = 'abc\0'
+ * result in the array: [3][a][b][c]  (each [x] represents a position)
+ *
+ * Returns: the number of bytes copied
+ */
+guint64
+prop_copy_size_string (guint8 * string, guint str_size, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+
+  prop_copy_uint8 (str_size, buffer, size, offset);
+  prop_copy_fixed_size_string (string, str_size, buffer, size, offset);
+  return *offset - original_offset;
+}
+
+/**
+ * prop_copy_null_terminated_string:
+ * @string: the string to be copied
+ * @buffer: the array to copy the string to
+ * @offset: the position in the buffer array.
+ * This value is updated to the point right after the copied string.
+ *
+ * Copies a string including its null terminating char to an array.
+ *
+ * Returns: the number of bytes copied
+ */
+guint64
+prop_copy_null_terminated_string (gchar * string, guint8 ** buffer,
+    guint64 * size, guint64 * offset)
+{
+  guint64 original_offset = *offset;
+  guint len = strlen (string);
+
+  prop_copy_fixed_size_string ((guint8 *) string, len, buffer, size, offset);
+  prop_copy_uint8 ('\0', buffer, size, offset);
+  return *offset - original_offset;
+}
diff --git a/gst/isomp4/properties.h b/gst/isomp4/properties.h
new file mode 100644
index 000000000..ad67e0da0
--- /dev/null
+++ b/gst/isomp4/properties.h
@@ -0,0 +1,87 @@
+/* Quicktime muxer plugin for GStreamer
+ * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+ *
+ * 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.
+ */
+/*
+ * Unless otherwise indicated, Source Code is licensed under MIT license.
+ * See further explanation attached in License Statement (distributed in the file
+ * LICENSE).
+ *
+ * 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.
+ */
+
+#ifndef __PROPERTIES_H__
+#define __PROPERTIES_H__
+
+#include <glib.h>
+#include <string.h>
+
+/**
+ * Functions for copying atoms properties.
+ *
+ * All of them receive, as the input, the property to be copied, the destination
+ * buffer, and a pointer to an offset in the destination buffer to copy to the right place.
+ * This offset will be updated to the new value (offset + copied_size)
+ * The functions return the size of the property that has been copied or 0
+ * if it couldn't copy.
+ */
+
+void    prop_copy_ensure_buffer          (guint8 ** buffer, guint64 * bsize, guint64 * offset, guint64 size);
+
+guint64 prop_copy_uint8                  (guint8 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_uint16                 (guint16 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_uint32                 (guint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_uint64                 (guint64 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+
+guint64 prop_copy_int32                  (gint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+
+guint64 prop_copy_uint8_array            (guint8 *prop, guint size,
+                                          guint8 **buffer, guint64 *bsize, guint64 *offset);
+guint64 prop_copy_uint16_array           (guint16 *prop, guint size,
+                                          guint8 **buffer, guint64 *bsize, guint64 *offset);
+guint64 prop_copy_uint32_array           (guint32 *prop, guint size,
+                                          guint8 **buffer, guint64 *bsize, guint64 *offset);
+guint64 prop_copy_uint64_array           (guint64 *prop, guint size,
+                                          guint8 **buffer, guint64 *bsize, guint64 *offset);
+
+guint64 prop_copy_fourcc                 (guint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_fourcc_array           (guint32 *prop, guint size,
+                                          guint8 **buffer, guint64 *bsize, guint64 *offset);
+guint64 prop_copy_fixed_size_string      (guint8 *string, guint str_size,
+                                          guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_size_string            (guint8 *string, guint str_size,
+                                          guint8 **buffer, guint64 *size, guint64 *offset);
+guint64 prop_copy_null_terminated_string (gchar *string,
+                                          guint8 **buffer, guint64 *size, guint64 *offset);
+
+#endif /* __PROPERTIES_H__ */
diff --git a/gst/isomp4/qtatomparser.h b/gst/isomp4/qtatomparser.h
new file mode 100644
index 000000000..06bb3447b
--- /dev/null
+++ b/gst/isomp4/qtatomparser.h
@@ -0,0 +1,139 @@
+/* GStreamer QuickTime atom parser
+ * Copyright (C) 2009 Tim-Philipp Müller <tim centricular net>
+ * Copyright (C) <2009> STEricsson <benjamin.gaignard@stericsson.com>
+ *
+ * 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 QT_ATOM_PARSER_H
+#define QT_ATOM_PARSER_H
+
+#include <gst/base/gstbytereader.h>
+
+/* our inlined version of GstByteReader */
+
+static inline gboolean
+qt_atom_parser_has_remaining (GstByteReader * parser, guint64 bytes_needed)
+{
+  return G_LIKELY (parser->size >= bytes_needed) &&
+      G_LIKELY ((parser->size - bytes_needed) >= parser->byte);
+}
+
+static inline gboolean
+qt_atom_parser_has_chunks (GstByteReader * parser, guint32 n_chunks,
+    guint32 chunk_size)
+{
+  /* assumption: n_chunks and chunk_size are 32-bit, we cast to 64-bit here
+   * to avoid overflows, to handle e.g. (guint32)-1 * size correctly */
+  return qt_atom_parser_has_remaining (parser, (guint64) n_chunks * chunk_size);
+}
+
+static inline gboolean
+qt_atom_parser_peek_sub (GstByteReader * parser, guint offset, guint size,
+    GstByteReader * sub)
+{
+  *sub = *parser;
+
+  if (G_UNLIKELY (!gst_byte_reader_skip (sub, offset)))
+    return FALSE;
+
+  return (gst_byte_reader_get_remaining (sub) >= size);
+}
+
+static inline gboolean
+qt_atom_parser_skipn_and_get_uint32 (GstByteReader * parser,
+    guint bytes_to_skip, guint32 * val)
+{
+  if (G_UNLIKELY (gst_byte_reader_get_remaining (parser) < (bytes_to_skip + 4)))
+    return FALSE;
+
+  gst_byte_reader_skip_unchecked (parser, bytes_to_skip);
+  *val = gst_byte_reader_get_uint32_be_unchecked (parser);
+  return TRUE;
+}
+
+/* off_size must be either 4 or 8 */
+static inline gboolean
+qt_atom_parser_get_offset (GstByteReader * parser, guint off_size,
+    guint64 * val)
+{
+  if (G_UNLIKELY (gst_byte_reader_get_remaining (parser) < off_size))
+    return FALSE;
+
+  if (off_size == sizeof (guint64)) {
+    *val = gst_byte_reader_get_uint64_be_unchecked (parser);
+  } else {
+    *val = gst_byte_reader_get_uint32_be_unchecked (parser);
+  }
+  return TRUE;
+}
+
+/* off_size must be either 4 or 8 */
+static inline guint64
+qt_atom_parser_get_offset_unchecked (GstByteReader * parser, guint off_size)
+{
+  if (off_size == sizeof (guint64)) {
+    return gst_byte_reader_get_uint64_be_unchecked (parser);
+  } else {
+    return gst_byte_reader_get_uint32_be_unchecked (parser);
+  }
+}
+
+/* size must be from 1 to 4 */
+static inline guint32
+qt_atom_parser_get_uint_with_size_unchecked (GstByteReader * parser,
+    guint size)
+{
+  switch (size) {
+  case 1:
+    return gst_byte_reader_get_uint8_unchecked (parser);
+  case 2:
+    return gst_byte_reader_get_uint16_be_unchecked (parser);
+  case 3:
+    return gst_byte_reader_get_uint24_be_unchecked (parser);
+  case 4:
+    return gst_byte_reader_get_uint32_be_unchecked (parser);
+  default:
+    g_assert_not_reached ();
+    gst_byte_reader_skip_unchecked (parser, size);
+    break;
+  }
+  return 0;
+}
+
+static inline gboolean
+qt_atom_parser_get_fourcc (GstByteReader * parser, guint32 * fourcc)
+{
+  guint32 f_be;
+
+  if (G_UNLIKELY (gst_byte_reader_get_remaining (parser) < 4))
+    return FALSE;
+
+  f_be = gst_byte_reader_get_uint32_be_unchecked (parser);
+  *fourcc = GUINT32_SWAP_LE_BE (f_be);
+  return TRUE;
+}
+
+static inline guint32
+qt_atom_parser_get_fourcc_unchecked (GstByteReader * parser)
+{
+  guint32 fourcc;
+
+  fourcc = gst_byte_reader_get_uint32_be_unchecked (parser);
+  return GUINT32_SWAP_LE_BE (fourcc);
+}
+
+#endif /* QT_ATOM_PARSER_H */
diff --git a/gst/isomp4/qtdemux.c b/gst/isomp4/qtdemux.c
new file mode 100644
index 000000000..5f6b07774
--- /dev/null
+++ b/gst/isomp4/qtdemux.c
@@ -0,0 +1,9406 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
+ * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>
+ * Copyright (C) <2007> Julien Moutte <julien@fluendo.com>
+ * Copyright (C) <2009> Tim-Philipp Müller <tim centricular net>
+ * Copyright (C) <2009> STEricsson <benjamin.gaignard@stericsson.com>
+ *
+ * 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:element-qtdemux
+ *
+ * Demuxes a .mov file into raw or compressed audio and/or video streams.
+ *
+ * This element supports both push and pull-based scheduling, depending on the
+ * capabilities of the upstream elements.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch filesrc location=test.mov ! qtdemux name=demux  demux.audio_00 ! decodebin ! audioconvert ! audioresample ! autoaudiosink   demux.video_00 ! queue ! decodebin ! ffmpegcolorspace ! videoscale ! autovideosink
+ * ]| Play (parse and decode) a .mov file and try to output it to
+ * an automatically detected soundcard and videosink. If the MOV file contains
+ * compressed audio or video data, this will only work if you have the
+ * right decoder elements/plugins installed.
+ * </refsect2>
+ *
+ * Last reviewed on 2006-12-29 (0.10.5)
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gst/gst-i18n-plugin.h"
+
+#include <glib/gprintf.h>
+#include <gst/tag/tag.h>
+
+#include "qtatomparser.h"
+#include "qtdemux_types.h"
+#include "qtdemux_dump.h"
+#include "qtdemux_fourcc.h"
+#include "qtdemux_lang.h"
+#include "qtdemux.h"
+#include "qtpalette.h"
+
+#include "gst/riff/riff-media.h"
+#include "gst/riff/riff-read.h"
+
+#include <gst/pbutils/pbutils.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_ZLIB
+# include <zlib.h>
+#endif
+
+/* max. size considered 'sane' for non-mdat atoms */
+#define QTDEMUX_MAX_ATOM_SIZE (25*1024*1024)
+
+/* if the sample index is larger than this, something is likely wrong */
+#define QTDEMUX_MAX_SAMPLE_INDEX_SIZE (50*1024*1024)
+
+/* For converting qt creation times to unix epoch times */
+#define QTDEMUX_SECONDS_PER_DAY (60 * 60 * 24)
+#define QTDEMUX_LEAP_YEARS_FROM_1904_TO_1970 17
+#define QTDEMUX_SECONDS_FROM_1904_TO_1970 (((1970 - 1904) * (guint64) 365 + \
+    QTDEMUX_LEAP_YEARS_FROM_1904_TO_1970) * QTDEMUX_SECONDS_PER_DAY)
+
+GST_DEBUG_CATEGORY (qtdemux_debug);
+
+/*typedef struct _QtNode QtNode; */
+typedef struct _QtDemuxSegment QtDemuxSegment;
+typedef struct _QtDemuxSample QtDemuxSample;
+
+/*struct _QtNode
+{
+  guint32 type;
+  guint8 *data;
+  gint len;
+};*/
+
+struct _QtDemuxSample
+{
+  guint32 size;
+  gint32 pts_offset;            /* Add this value to timestamp to get the pts */
+  guint64 offset;
+  guint64 timestamp;            /* DTS In mov time */
+  guint32 duration;             /* In mov time */
+  gboolean keyframe;            /* TRUE when this packet is a keyframe */
+};
+
+/* timestamp is the DTS */
+#define QTSAMPLE_DTS(stream,sample) gst_util_uint64_scale ((sample)->timestamp,\
+    GST_SECOND, (stream)->timescale)
+/* timestamp + offset is the PTS */
+#define QTSAMPLE_PTS(stream,sample) gst_util_uint64_scale ((sample)->timestamp + \
+    (sample)->pts_offset, GST_SECOND, (stream)->timescale)
+/* timestamp + duration - dts is the duration */
+#define QTSAMPLE_DUR_DTS(stream,sample,dts) (gst_util_uint64_scale ((sample)->timestamp + \
+    (sample)->duration, GST_SECOND, (stream)->timescale) - (dts));
+/* timestamp + offset + duration - pts is the duration */
+#define QTSAMPLE_DUR_PTS(stream,sample,pts) (gst_util_uint64_scale ((sample)->timestamp + \
+    (sample)->pts_offset + (sample)->duration, GST_SECOND, (stream)->timescale) - (pts));
+
+#define QTSAMPLE_KEYFRAME(stream,sample) ((stream)->all_keyframe || (sample)->keyframe)
+
+/*
+ * Quicktime has tracks and segments. A track is a continuous piece of
+ * multimedia content. The track is not always played from start to finish but
+ * instead, pieces of the track are 'cut out' and played in sequence. This is
+ * what the segments do.
+ *
+ * Inside the track we have keyframes (K) and delta frames. The track has its
+ * own timing, which starts from 0 and extends to end. The position in the track
+ * is called the media_time.
+ *
+ * The segments now describe the pieces that should be played from this track
+ * and are basically tupples of media_time/duration/rate entries. We can have
+ * multiple segments and they are all played after one another. An example:
+ *
+ * segment 1: media_time: 1 second, duration: 1 second, rate 1
+ * segment 2: media_time: 3 second, duration: 2 second, rate 2
+ *
+ * To correctly play back this track, one must play: 1 second of media starting
+ * from media_time 1 followed by 2 seconds of media starting from media_time 3
+ * at a rate of 2.
+ *
+ * Each of the segments will be played at a specific time, the first segment at
+ * time 0, the second one after the duration of the first one, etc.. Note that
+ * the time in resulting playback is not identical to the media_time of the
+ * track anymore.
+ *
+ * Visually, assuming the track has 4 second of media_time:
+ *
+ *                (a)                   (b)          (c)              (d)
+ *         .-----------------------------------------------------------.
+ * track:  | K.....K.........K........K.......K.......K...........K... |
+ *         '-----------------------------------------------------------'
+ *         0              1              2              3              4
+ *           .------------^              ^   .----------^              ^
+ *          /              .-------------'  /       .------------------'
+ *         /              /          .-----'       /
+ *         .--------------.         .--------------.
+ *         | segment 1    |         | segment 2    |
+ *         '--------------'         '--------------'
+ *
+ * The challenge here is to cut out the right pieces of the track for each of
+ * the playback segments. This fortunatly can easily be done with the SEGMENT
+ * events of gstreamer.
+ *
+ * For playback of segment 1, we need to provide the decoder with the keyframe
+ * (a), in the above figure, but we must instruct it only to output the decoded
+ * data between second 1 and 2. We do this with a SEGMENT event for 1 to 2, time
+ * position set to the time of the segment: 0.
+ *
+ * We then proceed to push data from keyframe (a) to frame (b). The decoder
+ * decodes but clips all before media_time 1.
+ *
+ * After finishing a segment, we push out a new SEGMENT event with the clipping
+ * boundaries of the new data.
+ *
+ * This is a good usecase for the GStreamer accumulated SEGMENT events.
+ */
+
+struct _QtDemuxSegment
+{
+  /* global time and duration, all gst time */
+  guint64 time;
+  guint64 stop_time;
+  guint64 duration;
+  /* media time of trak, all gst time */
+  guint64 media_start;
+  guint64 media_stop;
+  gdouble rate;
+};
+
+struct _QtDemuxStream
+{
+  GstPad *pad;
+
+  /* stream type */
+  guint32 subtype;
+  GstCaps *caps;
+  guint32 fourcc;
+
+  /* if the stream has a redirect URI in its headers, we store it here */
+  gchar *redirect_uri;
+
+  /* track id */
+  guint track_id;
+
+  /* duration/scale */
+  guint64 duration;             /* in timescale */
+  guint32 timescale;
+
+  /* language */
+  gchar lang_id[4];             /* ISO 639-2T language code */
+
+  /* our samples */
+  guint32 n_samples;
+  QtDemuxSample *samples;
+  gboolean all_keyframe;        /* TRUE when all samples are keyframes (no stss) */
+  guint32 min_duration;         /* duration in timescale of first sample, used for figuring out
+                                   the framerate, in timescale units */
+
+  /* if we use chunks or samples */
+  gboolean sampled;
+  guint padding;
+
+  /* video info */
+  gint width;
+  gint height;
+  /* aspect ratio */
+  gint display_width;
+  gint display_height;
+  gint par_w;
+  gint par_h;
+  /* Numerator/denominator framerate */
+  gint fps_n;
+  gint fps_d;
+  guint16 bits_per_sample;
+  guint16 color_table_id;
+
+  /* audio info */
+  gdouble rate;
+  gint n_channels;
+  guint samples_per_packet;
+  guint samples_per_frame;
+  guint bytes_per_packet;
+  guint bytes_per_sample;
+  guint bytes_per_frame;
+  guint compression;
+
+  /* when a discontinuity is pending */
+  gboolean discont;
+
+  /* list of buffers to push first */
+  GSList *buffers;
+
+  /* if we need to clip this buffer. This is only needed for uncompressed
+   * data */
+  gboolean need_clip;
+
+  /* buffer needs some custom processing, e.g. subtitles */
+  gboolean need_process;
+
+  /* current position */
+  guint32 segment_index;
+  guint32 sample_index;
+  guint64 time_position;        /* in gst time */
+
+  /* the Gst segment we are processing out, used for clipping */
+  GstSegment segment;
+
+  /* last GstFlowReturn */
+  GstFlowReturn last_ret;
+
+  /* quicktime segments */
+  guint32 n_segments;
+  QtDemuxSegment *segments;
+  guint32 from_sample;
+  guint32 to_sample;
+
+  gboolean sent_eos;
+  GstTagList *pending_tags;
+  gboolean send_global_tags;
+
+  GstEvent *pending_event;
+
+  GstByteReader stco;
+  GstByteReader stsz;
+  GstByteReader stsc;
+  GstByteReader stts;
+  GstByteReader stss;
+  GstByteReader stps;
+  GstByteReader ctts;
+
+  gboolean chunks_are_chunks;
+  gint64 stbl_index;
+  /* stco */
+  guint co_size;
+  GstByteReader co_chunk;
+  guint32 first_chunk;
+  guint32 current_chunk;
+  guint32 last_chunk;
+  guint32 samples_per_chunk;
+  guint32 stco_sample_index;
+  /* stsz */
+  guint32 sample_size;          /* 0 means variable sizes are stored in stsz */
+  /* stsc */
+  guint32 stsc_index;
+  guint32 n_samples_per_chunk;
+  guint32 stsc_chunk_index;
+  guint32 stsc_sample_index;
+  guint64 chunk_offset;
+  /* stts */
+  guint32 stts_index;
+  guint32 stts_samples;
+  guint32 n_sample_times;
+  guint32 stts_sample_index;
+  guint32 stts_time;
+  guint32 stts_duration;
+  /* stss */
+  gboolean stss_present;
+  guint32 n_sample_syncs;
+  guint32 stss_index;
+  /* stps */
+  gboolean stps_present;
+  guint32 n_sample_partial_syncs;
+  guint32 stps_index;
+  /* ctts */
+  gboolean ctts_present;
+  guint32 n_composition_times;
+  guint32 ctts_index;
+  guint32 ctts_sample_index;
+  guint32 ctts_count;
+  gint32 ctts_soffset;
+
+  /* fragmented */
+  gboolean parsed_trex;
+  guint32 def_sample_duration;
+  guint32 def_sample_size;
+  guint32 def_sample_flags;
+};
+
+enum QtDemuxState
+{
+  QTDEMUX_STATE_INITIAL,        /* Initial state (haven't got the header yet) */
+  QTDEMUX_STATE_HEADER,         /* Parsing the header */
+  QTDEMUX_STATE_MOVIE,          /* Parsing/Playing the media data */
+  QTDEMUX_STATE_BUFFER_MDAT     /* Buffering the mdat atom */
+};
+
+static GNode *qtdemux_tree_get_child_by_type (GNode * node, guint32 fourcc);
+static GNode *qtdemux_tree_get_child_by_type_full (GNode * node,
+    guint32 fourcc, GstByteReader * parser);
+static GNode *qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc);
+static GNode *qtdemux_tree_get_sibling_by_type_full (GNode * node,
+    guint32 fourcc, GstByteReader * parser);
+
+static GstStaticPadTemplate gst_qtdemux_sink_template =
+    GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/quicktime; video/mj2; audio/x-m4a; "
+        "application/x-3gp")
+    );
+
+static GstStaticPadTemplate gst_qtdemux_videosrc_template =
+GST_STATIC_PAD_TEMPLATE ("video_%02d",
+    GST_PAD_SRC,
+    GST_PAD_SOMETIMES,
+    GST_STATIC_CAPS_ANY);
+
+static GstStaticPadTemplate gst_qtdemux_audiosrc_template =
+GST_STATIC_PAD_TEMPLATE ("audio_%02d",
+    GST_PAD_SRC,
+    GST_PAD_SOMETIMES,
+    GST_STATIC_CAPS_ANY);
+
+static GstStaticPadTemplate gst_qtdemux_subsrc_template =
+GST_STATIC_PAD_TEMPLATE ("subtitle_%02d",
+    GST_PAD_SRC,
+    GST_PAD_SOMETIMES,
+    GST_STATIC_CAPS_ANY);
+
+GST_BOILERPLATE (GstQTDemux, gst_qtdemux, GstQTDemux, GST_TYPE_ELEMENT);
+
+static void gst_qtdemux_dispose (GObject * object);
+
+static guint32
+gst_qtdemux_find_index_linear (GstQTDemux * qtdemux, QtDemuxStream * str,
+    guint64 media_time);
+static guint32
+gst_qtdemux_find_index_for_given_media_offset_linear (GstQTDemux * qtdemux,
+    QtDemuxStream * str, gint64 media_offset);
+
+static void gst_qtdemux_set_index (GstElement * element, GstIndex * index);
+static GstIndex *gst_qtdemux_get_index (GstElement * element);
+static GstStateChangeReturn gst_qtdemux_change_state (GstElement * element,
+    GstStateChange transition);
+static gboolean qtdemux_sink_activate (GstPad * sinkpad);
+static gboolean qtdemux_sink_activate_pull (GstPad * sinkpad, gboolean active);
+static gboolean qtdemux_sink_activate_push (GstPad * sinkpad, gboolean active);
+
+static void gst_qtdemux_loop (GstPad * pad);
+static GstFlowReturn gst_qtdemux_chain (GstPad * sinkpad, GstBuffer * inbuf);
+static gboolean gst_qtdemux_handle_sink_event (GstPad * pad, GstEvent * event);
+
+static gboolean qtdemux_parse_moov (GstQTDemux * qtdemux,
+    const guint8 * buffer, guint length);
+static gboolean qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node,
+    const guint8 * buffer, guint length);
+static gboolean qtdemux_parse_tree (GstQTDemux * qtdemux);
+
+static void gst_qtdemux_handle_esds (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, GNode * esds, GstTagList * list);
+static GstCaps *qtdemux_video_caps (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, guint32 fourcc, const guint8 * stsd_data,
+    gchar ** codec_name);
+static GstCaps *qtdemux_audio_caps (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, guint32 fourcc, const guint8 * data, int len,
+    gchar ** codec_name);
+static GstCaps *qtdemux_sub_caps (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, guint32 fourcc, const guint8 * data,
+    gchar ** codec_name);
+static gboolean qtdemux_parse_samples (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, guint32 n);
+static GstFlowReturn qtdemux_expose_streams (GstQTDemux * qtdemux);
+
+
+static void
+gst_qtdemux_base_init (gpointer klass)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_qtdemux_sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_qtdemux_videosrc_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_qtdemux_audiosrc_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_qtdemux_subsrc_template));
+  gst_element_class_set_details_simple (element_class, "QuickTime demuxer",
+      "Codec/Demuxer",
+      "Demultiplex a QuickTime file into audio and video streams",
+      "David Schleef <ds@schleef.org>, Wim Taymans <wim@fluendo.com>");
+
+  GST_DEBUG_CATEGORY_INIT (qtdemux_debug, "qtdemux", 0, "qtdemux plugin");
+}
+
+static void
+gst_qtdemux_class_init (GstQTDemuxClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->dispose = gst_qtdemux_dispose;
+
+  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_qtdemux_change_state);
+
+  gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_qtdemux_set_index);
+  gstelement_class->get_index = GST_DEBUG_FUNCPTR (gst_qtdemux_get_index);
+
+  gst_tag_register_musicbrainz_tags ();
+}
+
+static void
+gst_qtdemux_init (GstQTDemux * qtdemux, GstQTDemuxClass * klass)
+{
+  qtdemux->sinkpad =
+      gst_pad_new_from_static_template (&gst_qtdemux_sink_template, "sink");
+  gst_pad_set_activate_function (qtdemux->sinkpad, qtdemux_sink_activate);
+  gst_pad_set_activatepull_function (qtdemux->sinkpad,
+      qtdemux_sink_activate_pull);
+  gst_pad_set_activatepush_function (qtdemux->sinkpad,
+      qtdemux_sink_activate_push);
+  gst_pad_set_chain_function (qtdemux->sinkpad, gst_qtdemux_chain);
+  gst_pad_set_event_function (qtdemux->sinkpad, gst_qtdemux_handle_sink_event);
+  gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), qtdemux->sinkpad);
+
+  qtdemux->state = QTDEMUX_STATE_INITIAL;
+  qtdemux->pullbased = FALSE;
+  qtdemux->posted_redirect = FALSE;
+  qtdemux->neededbytes = 16;
+  qtdemux->todrop = 0;
+  qtdemux->adapter = gst_adapter_new ();
+  qtdemux->offset = 0;
+  qtdemux->first_mdat = -1;
+  qtdemux->got_moov = FALSE;
+  qtdemux->mdatoffset = GST_CLOCK_TIME_NONE;
+  qtdemux->mdatbuffer = NULL;
+  gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME);
+}
+
+static void
+gst_qtdemux_dispose (GObject * object)
+{
+  GstQTDemux *qtdemux = GST_QTDEMUX (object);
+
+  if (qtdemux->adapter) {
+    g_object_unref (G_OBJECT (qtdemux->adapter));
+    qtdemux->adapter = NULL;
+  }
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gst_qtdemux_post_no_playable_stream_error (GstQTDemux * qtdemux)
+{
+  if (qtdemux->posted_redirect) {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file contains no playable streams.")),
+        ("no known streams found, a redirect message has been posted"));
+  } else {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file contains no playable streams.")),
+        ("no known streams found"));
+  }
+}
+
+static GstFlowReturn
+gst_qtdemux_pull_atom (GstQTDemux * qtdemux, guint64 offset, guint64 size,
+    GstBuffer ** buf)
+{
+  GstFlowReturn flow;
+
+  if (G_UNLIKELY (size == 0)) {
+    GstFlowReturn ret;
+    GstBuffer *tmp = NULL;
+
+    ret = gst_qtdemux_pull_atom (qtdemux, offset, sizeof (guint32), &tmp);
+    if (ret != GST_FLOW_OK)
+      return ret;
+
+    size = QT_UINT32 (GST_BUFFER_DATA (tmp));
+    GST_DEBUG_OBJECT (qtdemux, "size 0x%08" G_GINT64_MODIFIER "x", size);
+
+    gst_buffer_unref (tmp);
+  }
+
+  /* Sanity check: catch bogus sizes (fuzzed/broken files) */
+  if (G_UNLIKELY (size > QTDEMUX_MAX_ATOM_SIZE)) {
+    if (qtdemux->state != QTDEMUX_STATE_MOVIE && qtdemux->got_moov) {
+      /* we're pulling header but already got most interesting bits,
+       * so never mind the rest (e.g. tags) (that much) */
+      GST_WARNING_OBJECT (qtdemux, "atom has bogus size %" G_GUINT64_FORMAT,
+          size);
+      return GST_FLOW_UNEXPECTED;
+    } else {
+      GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+          (_("This file is invalid and cannot be played.")),
+          ("atom has bogus size %" G_GUINT64_FORMAT, size));
+      return GST_FLOW_ERROR;
+    }
+  }
+
+  flow = gst_pad_pull_range (qtdemux->sinkpad, offset, size, buf);
+
+  if (G_UNLIKELY (flow != GST_FLOW_OK))
+    return flow;
+
+  /* Catch short reads - we don't want any partial atoms */
+  if (G_UNLIKELY (GST_BUFFER_SIZE (*buf) < size)) {
+    GST_WARNING_OBJECT (qtdemux, "short read: %u < %" G_GUINT64_FORMAT,
+        GST_BUFFER_SIZE (*buf), size);
+    gst_buffer_unref (*buf);
+    *buf = NULL;
+    return GST_FLOW_UNEXPECTED;
+  }
+
+  return flow;
+}
+
+#if 1
+static gboolean
+gst_qtdemux_src_convert (GstPad * pad, GstFormat src_format, gint64 src_value,
+    GstFormat dest_format, gint64 * dest_value)
+{
+  gboolean res = TRUE;
+  QtDemuxStream *stream = gst_pad_get_element_private (pad);
+  GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
+  gint32 index;
+
+  if (stream->subtype != FOURCC_vide) {
+    res = FALSE;
+    goto done;
+  }
+
+  switch (src_format) {
+    case GST_FORMAT_TIME:
+      switch (dest_format) {
+        case GST_FORMAT_BYTES:{
+          index = gst_qtdemux_find_index_linear (qtdemux, stream, src_value);
+          if (-1 == index)
+            return FALSE;
+
+          *dest_value = stream->samples[index].offset;
+
+          GST_DEBUG_OBJECT (qtdemux, "Format Conversion Time->Offset :%"
+              GST_TIME_FORMAT "->%" G_GUINT64_FORMAT,
+              GST_TIME_ARGS (src_value), *dest_value);
+          break;
+        }
+        default:
+          res = FALSE;
+          break;
+      }
+      break;
+    case GST_FORMAT_BYTES:
+      switch (dest_format) {
+        case GST_FORMAT_TIME:{
+          index =
+              gst_qtdemux_find_index_for_given_media_offset_linear (qtdemux,
+              stream, src_value);
+
+          if (-1 == index)
+            return FALSE;
+
+          *dest_value =
+              gst_util_uint64_scale (stream->samples[index].timestamp,
+              GST_SECOND, stream->timescale);
+          GST_DEBUG_OBJECT (qtdemux, "Format Conversion Offset->Time :%"
+              G_GUINT64_FORMAT "->%" GST_TIME_FORMAT,
+              src_value, GST_TIME_ARGS (*dest_value));
+          break;
+        }
+        default:
+          res = FALSE;
+          break;
+      }
+      break;
+    default:
+      res = FALSE;
+  }
+
+done:
+  gst_object_unref (qtdemux);
+
+  return res;
+}
+#endif
+
+static const GstQueryType *
+gst_qtdemux_get_src_query_types (GstPad * pad)
+{
+  static const GstQueryType src_types[] = {
+    GST_QUERY_POSITION,
+    GST_QUERY_DURATION,
+    GST_QUERY_CONVERT,
+    GST_QUERY_FORMATS,
+    GST_QUERY_SEEKING,
+    0
+  };
+
+  return src_types;
+}
+
+static gboolean
+gst_qtdemux_get_duration (GstQTDemux * qtdemux, gint64 * duration)
+{
+  gboolean res = TRUE;
+
+  *duration = GST_CLOCK_TIME_NONE;
+
+  if (qtdemux->duration != 0) {
+    if (qtdemux->duration != G_MAXINT64 && qtdemux->timescale != 0) {
+      *duration = gst_util_uint64_scale (qtdemux->duration,
+          GST_SECOND, qtdemux->timescale);
+    }
+  }
+  return res;
+}
+
+static gboolean
+gst_qtdemux_handle_src_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res = FALSE;
+  GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
+
+  GST_LOG_OBJECT (pad, "%s query", GST_QUERY_TYPE_NAME (query));
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_POSITION:
+      if (GST_CLOCK_TIME_IS_VALID (qtdemux->segment.last_stop)) {
+        gst_query_set_position (query, GST_FORMAT_TIME,
+            qtdemux->segment.last_stop);
+        res = TRUE;
+      }
+      break;
+    case GST_QUERY_DURATION:{
+      GstFormat fmt;
+
+      gst_query_parse_duration (query, &fmt, NULL);
+      if (fmt == GST_FORMAT_TIME) {
+        gint64 duration = -1;
+
+        gst_qtdemux_get_duration (qtdemux, &duration);
+        if (duration > 0) {
+          gst_query_set_duration (query, GST_FORMAT_TIME, duration);
+          res = TRUE;
+        }
+      }
+      break;
+    }
+    case GST_QUERY_CONVERT:{
+      GstFormat src_fmt, dest_fmt;
+      gint64 src_value, dest_value = 0;
+
+      gst_query_parse_convert (query, &src_fmt, &src_value, &dest_fmt, NULL);
+
+      res = gst_qtdemux_src_convert (pad,
+          src_fmt, src_value, dest_fmt, &dest_value);
+      if (res) {
+        gst_query_set_convert (query, src_fmt, src_value, dest_fmt, dest_value);
+        res = TRUE;
+      }
+      break;
+    }
+    case GST_QUERY_FORMATS:
+      gst_query_set_formats (query, 2, GST_FORMAT_TIME, GST_FORMAT_BYTES);
+      res = TRUE;
+      break;
+    case GST_QUERY_SEEKING:{
+      GstFormat fmt;
+      gboolean seekable;
+
+      gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
+      if (fmt == GST_FORMAT_TIME) {
+        gint64 duration = -1;
+
+        gst_qtdemux_get_duration (qtdemux, &duration);
+        seekable = TRUE;
+        if (!qtdemux->pullbased) {
+          GstQuery *q;
+
+          /* we might be able with help from upstream */
+          seekable = FALSE;
+          q = gst_query_new_seeking (GST_FORMAT_BYTES);
+          if (gst_pad_peer_query (qtdemux->sinkpad, q)) {
+            gst_query_parse_seeking (q, &fmt, &seekable, NULL, NULL);
+            GST_LOG_OBJECT (qtdemux, "upstream BYTE seekable %d", seekable);
+          }
+          gst_query_unref (q);
+        }
+        gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);
+        res = TRUE;
+      }
+      break;
+    }
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+
+  gst_object_unref (qtdemux);
+
+  return res;
+}
+
+static void
+gst_qtdemux_push_tags (GstQTDemux * qtdemux, QtDemuxStream * stream)
+{
+  if (G_LIKELY (stream->pad)) {
+    GST_DEBUG_OBJECT (qtdemux, "Checking pad %s:%s for tags",
+        GST_DEBUG_PAD_NAME (stream->pad));
+
+    if (G_UNLIKELY (stream->pending_tags)) {
+      GST_DEBUG_OBJECT (qtdemux, "Sending tags %" GST_PTR_FORMAT,
+          stream->pending_tags);
+      gst_pad_push_event (stream->pad,
+          gst_event_new_tag (stream->pending_tags));
+      stream->pending_tags = NULL;
+    }
+
+    if (G_UNLIKELY (stream->send_global_tags && qtdemux->tag_list)) {
+      GST_DEBUG_OBJECT (qtdemux, "Sending global tags %" GST_PTR_FORMAT,
+          qtdemux->tag_list);
+      gst_pad_push_event (stream->pad,
+          gst_event_new_tag (gst_tag_list_copy (qtdemux->tag_list)));
+      stream->send_global_tags = FALSE;
+    }
+  }
+}
+
+/* push event on all source pads; takes ownership of the event */
+static void
+gst_qtdemux_push_event (GstQTDemux * qtdemux, GstEvent * event)
+{
+  guint n;
+  gboolean has_valid_stream = FALSE;
+  GstEventType etype = GST_EVENT_TYPE (event);
+
+  GST_DEBUG_OBJECT (qtdemux, "pushing %s event on all source pads",
+      GST_EVENT_TYPE_NAME (event));
+
+  for (n = 0; n < qtdemux->n_streams; n++) {
+    GstPad *pad;
+    QtDemuxStream *stream = qtdemux->streams[n];
+
+    if ((pad = stream->pad)) {
+      has_valid_stream = TRUE;
+
+      if (etype == GST_EVENT_EOS) {
+        /* let's not send twice */
+        if (stream->sent_eos)
+          continue;
+        stream->sent_eos = TRUE;
+      }
+
+      gst_pad_push_event (pad, gst_event_ref (event));
+    }
+  }
+
+  gst_event_unref (event);
+
+  /* if it is EOS and there are no pads, post an error */
+  if (!has_valid_stream && etype == GST_EVENT_EOS) {
+    gst_qtdemux_post_no_playable_stream_error (qtdemux);
+  }
+}
+
+/* push a pending newsegment event, if any from the streaming thread */
+static void
+gst_qtdemux_push_pending_newsegment (GstQTDemux * qtdemux)
+{
+  if (qtdemux->pending_newsegment) {
+    gst_qtdemux_push_event (qtdemux, qtdemux->pending_newsegment);
+    qtdemux->pending_newsegment = NULL;
+  }
+}
+
+typedef struct
+{
+  guint64 media_time;
+} FindData;
+
+static gint
+find_func (QtDemuxSample * s1, guint64 * media_time, gpointer user_data)
+{
+  if (s1->timestamp > *media_time)
+    return 1;
+
+  return -1;
+}
+
+/* find the index of the sample that includes the data for @media_time using a
+ * binary search.  Only to be called in optimized cases of linear search below.
+ *
+ * Returns the index of the sample.
+ */
+static guint32
+gst_qtdemux_find_index (GstQTDemux * qtdemux, QtDemuxStream * str,
+    guint64 media_time)
+{
+  QtDemuxSample *result;
+  guint32 index;
+
+  /* convert media_time to mov format */
+  media_time =
+      gst_util_uint64_scale_ceil (media_time, str->timescale, GST_SECOND);
+
+  result = gst_util_array_binary_search (str->samples, str->stbl_index + 1,
+      sizeof (QtDemuxSample), (GCompareDataFunc) find_func,
+      GST_SEARCH_MODE_BEFORE, &media_time, NULL);
+
+  if (G_LIKELY (result))
+    index = result - str->samples;
+  else
+    index = 0;
+
+  return index;
+}
+
+
+
+/* find the index of the sample that includes the data for @media_offset using a
+ * linear search
+ *
+ * Returns the index of the sample.
+ */
+static guint32
+gst_qtdemux_find_index_for_given_media_offset_linear (GstQTDemux * qtdemux,
+    QtDemuxStream * str, gint64 media_offset)
+{
+  QtDemuxSample *result = str->samples;
+  guint32 index = 0;
+
+  if (result == NULL || str->n_samples == 0)
+    return -1;
+
+  if (media_offset == result->offset)
+    return index;
+
+  result++;
+  while (index < str->n_samples - 1) {
+    if (!qtdemux_parse_samples (qtdemux, str, index + 1))
+      goto parse_failed;
+
+    if (media_offset < result->offset)
+      break;
+
+    index++;
+    result++;
+  }
+  return index;
+
+  /* ERRORS */
+parse_failed:
+  {
+    GST_LOG_OBJECT (qtdemux, "Parsing of index %u failed!", index + 1);
+    return -1;
+  }
+}
+
+/* find the index of the sample that includes the data for @media_time using a
+ * linear search, and keeping in mind that not all samples may have been parsed
+ * yet.  If possible, it will delegate to binary search.
+ *
+ * Returns the index of the sample.
+ */
+static guint32
+gst_qtdemux_find_index_linear (GstQTDemux * qtdemux, QtDemuxStream * str,
+    guint64 media_time)
+{
+  guint32 index = 0;
+  guint64 mov_time;
+
+  /* convert media_time to mov format */
+  mov_time =
+      gst_util_uint64_scale_ceil (media_time, str->timescale, GST_SECOND);
+
+  if (mov_time == str->samples[0].timestamp)
+    return index;
+
+  /* use faster search if requested time in already parsed range */
+  if (str->stbl_index >= 0 &&
+      mov_time <= str->samples[str->stbl_index].timestamp)
+    return gst_qtdemux_find_index (qtdemux, str, media_time);
+
+  while (index < str->n_samples - 1) {
+    if (!qtdemux_parse_samples (qtdemux, str, index + 1))
+      goto parse_failed;
+
+    if (mov_time < str->samples[index + 1].timestamp)
+      break;
+
+    index++;
+  }
+  return index;
+
+  /* ERRORS */
+parse_failed:
+  {
+    GST_LOG_OBJECT (qtdemux, "Parsing of index %u failed!", index + 1);
+    return -1;
+  }
+}
+
+/* find the index of the keyframe needed to decode the sample at @index
+ * of stream @str.
+ *
+ * Returns the index of the keyframe.
+ */
+static guint32
+gst_qtdemux_find_keyframe (GstQTDemux * qtdemux, QtDemuxStream * str,
+    guint32 index)
+{
+  guint32 new_index = index;
+
+  if (index >= str->n_samples) {
+    new_index = str->n_samples;
+    goto beach;
+  }
+
+  /* all keyframes, return index */
+  if (str->all_keyframe) {
+    new_index = index;
+    goto beach;
+  }
+
+  /* else go back until we have a keyframe */
+  while (TRUE) {
+    if (str->samples[new_index].keyframe)
+      break;
+
+    if (new_index == 0)
+      break;
+
+    new_index--;
+  }
+
+beach:
+  GST_DEBUG_OBJECT (qtdemux, "searching for keyframe index before index %u "
+      "gave %u", index, new_index);
+
+  return new_index;
+}
+
+/* find the segment for @time_position for @stream
+ *
+ * Returns -1 if the segment cannot be found.
+ */
+static guint32
+gst_qtdemux_find_segment (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint64 time_position)
+{
+  gint i;
+  guint32 seg_idx;
+
+  GST_LOG_OBJECT (qtdemux, "finding segment for %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (time_position));
+
+  /* find segment corresponding to time_position if we are looking
+   * for a segment. */
+  seg_idx = -1;
+  for (i = 0; i < stream->n_segments; i++) {
+    QtDemuxSegment *segment = &stream->segments[i];
+
+    GST_LOG_OBJECT (qtdemux,
+        "looking at segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT,
+        GST_TIME_ARGS (segment->time), GST_TIME_ARGS (segment->stop_time));
+
+    /* For the last segment we include stop_time in the last segment */
+    if (i < stream->n_segments - 1) {
+      if (segment->time <= time_position && time_position < segment->stop_time) {
+        GST_LOG_OBJECT (qtdemux, "segment %d matches", i);
+        seg_idx = i;
+        break;
+      }
+    } else {
+      if (segment->time <= time_position && time_position <= segment->stop_time) {
+        GST_LOG_OBJECT (qtdemux, "segment %d matches", i);
+        seg_idx = i;
+        break;
+      }
+    }
+  }
+  return seg_idx;
+}
+
+/* move the stream @str to the sample position @index.
+ *
+ * Updates @str->sample_index and marks discontinuity if needed.
+ */
+static void
+gst_qtdemux_move_stream (GstQTDemux * qtdemux, QtDemuxStream * str,
+    guint32 index)
+{
+  /* no change needed */
+  if (index == str->sample_index)
+    return;
+
+  GST_DEBUG_OBJECT (qtdemux, "moving to sample %u of %u", index,
+      str->n_samples);
+
+  /* position changed, we have a discont */
+  str->sample_index = index;
+  /* Each time we move in the stream we store the position where we are
+   * starting from */
+  str->from_sample = index;
+  str->discont = TRUE;
+}
+
+static void
+gst_qtdemux_adjust_seek (GstQTDemux * qtdemux, gint64 desired_time,
+    gint64 * key_time, gint64 * key_offset)
+{
+  guint64 min_offset;
+  gint64 min_byte_offset = -1;
+  gint n;
+
+  min_offset = desired_time;
+
+  /* for each stream, find the index of the sample in the segment
+   * and move back to the previous keyframe. */
+  for (n = 0; n < qtdemux->n_streams; n++) {
+    QtDemuxStream *str;
+    guint32 index, kindex;
+    guint32 seg_idx;
+    guint64 media_start;
+    guint64 media_time;
+    guint64 seg_time;
+    QtDemuxSegment *seg;
+
+    str = qtdemux->streams[n];
+
+    seg_idx = gst_qtdemux_find_segment (qtdemux, str, desired_time);
+    GST_DEBUG_OBJECT (qtdemux, "align segment %d", seg_idx);
+
+    /* segment not found, continue with normal flow */
+    if (seg_idx == -1)
+      continue;
+
+    /* get segment and time in the segment */
+    seg = &str->segments[seg_idx];
+    seg_time = desired_time - seg->time;
+
+    /* get the media time in the segment */
+    media_start = seg->media_start + seg_time;
+
+    /* get the index of the sample with media time */
+    index = gst_qtdemux_find_index_linear (qtdemux, str, media_start);
+    GST_DEBUG_OBJECT (qtdemux, "sample for %" GST_TIME_FORMAT " at %u",
+        GST_TIME_ARGS (media_start), index);
+
+    /* find previous keyframe */
+    kindex = gst_qtdemux_find_keyframe (qtdemux, str, index);
+
+    /* if the keyframe is at a different position, we need to update the
+     * requested seek time */
+    if (index != kindex) {
+      index = kindex;
+
+      /* get timestamp of keyframe */
+      media_time =
+          gst_util_uint64_scale (str->samples[kindex].timestamp, GST_SECOND,
+          str->timescale);
+      GST_DEBUG_OBJECT (qtdemux, "keyframe at %u with time %" GST_TIME_FORMAT,
+          kindex, GST_TIME_ARGS (media_time));
+
+      /* keyframes in the segment get a chance to change the
+       * desired_offset. keyframes out of the segment are
+       * ignored. */
+      if (media_time >= seg->media_start) {
+        guint64 seg_time;
+
+        /* this keyframe is inside the segment, convert back to
+         * segment time */
+        seg_time = (media_time - seg->media_start) + seg->time;
+        if (seg_time < min_offset)
+          min_offset = seg_time;
+      }
+    }
+
+    if (min_byte_offset < 0 || str->samples[index].offset < min_byte_offset)
+      min_byte_offset = str->samples[index].offset;
+  }
+
+  if (key_time)
+    *key_time = min_offset;
+  if (key_offset)
+    *key_offset = min_byte_offset;
+}
+
+static gboolean
+gst_qtdemux_convert_seek (GstPad * pad, GstFormat * format,
+    GstSeekType cur_type, gint64 * cur, GstSeekType stop_type, gint64 * stop)
+{
+  gboolean res;
+  GstFormat fmt;
+
+  g_return_val_if_fail (format != NULL, FALSE);
+  g_return_val_if_fail (cur != NULL, FALSE);
+  g_return_val_if_fail (stop != NULL, FALSE);
+
+  if (*format == GST_FORMAT_TIME)
+    return TRUE;
+
+  fmt = GST_FORMAT_TIME;
+  res = TRUE;
+  if (cur_type != GST_SEEK_TYPE_NONE)
+    res = gst_pad_query_convert (pad, *format, *cur, &fmt, cur);
+  if (res && stop_type != GST_SEEK_TYPE_NONE)
+    res = gst_pad_query_convert (pad, *format, *stop, &fmt, stop);
+
+  if (res)
+    *format = GST_FORMAT_TIME;
+
+  return res;
+}
+
+/* perform seek in push based mode:
+   find BYTE position to move to based on time and delegate to upstream
+*/
+static gboolean
+gst_qtdemux_do_push_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event)
+{
+  gdouble rate;
+  GstFormat format;
+  GstSeekFlags flags;
+  GstSeekType cur_type, stop_type;
+  gint64 cur, stop;
+  gboolean res;
+  gint64 byte_cur;
+
+  GST_DEBUG_OBJECT (qtdemux, "doing push-based seek");
+
+  gst_event_parse_seek (event, &rate, &format, &flags,
+      &cur_type, &cur, &stop_type, &stop);
+
+  /* FIXME, always play to the end */
+  stop = -1;
+
+  /* only forward streaming and seeking is possible */
+  if (rate <= 0)
+    goto unsupported_seek;
+
+  /* convert to TIME if needed and possible */
+  if (!gst_qtdemux_convert_seek (pad, &format, cur_type, &cur,
+          stop_type, &stop))
+    goto no_format;
+
+  /* find reasonable corresponding BYTE position,
+   * also try to mind about keyframes, since we can not go back a bit for them
+   * later on */
+  gst_qtdemux_adjust_seek (qtdemux, cur, NULL, &byte_cur);
+
+  if (byte_cur == -1)
+    goto abort_seek;
+
+  GST_DEBUG_OBJECT (qtdemux, "Pushing BYTE seek rate %g, "
+      "start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT, rate, byte_cur,
+      stop);
+
+  if (!(flags & GST_SEEK_FLAG_KEY_UNIT)) {
+    GST_DEBUG_OBJECT (qtdemux,
+        "Requested seek time: %" GST_TIME_FORMAT ", calculated seek offset: %"
+        G_GUINT64_FORMAT, GST_TIME_ARGS (cur), byte_cur);
+    GST_OBJECT_LOCK (qtdemux);
+    qtdemux->requested_seek_time = cur;
+    qtdemux->seek_offset = byte_cur;
+    GST_OBJECT_UNLOCK (qtdemux);
+  }
+
+  /* BYTE seek event */
+  event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, byte_cur,
+      stop_type, stop);
+  res = gst_pad_push_event (qtdemux->sinkpad, event);
+
+  return res;
+
+  /* ERRORS */
+abort_seek:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "could not determine byte position to seek to, "
+        "seek aborted.");
+    return FALSE;
+  }
+unsupported_seek:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "unsupported seek, seek aborted.");
+    return FALSE;
+  }
+no_format:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "unsupported format given, seek aborted.");
+    return FALSE;
+  }
+}
+
+/* perform the seek.
+ *
+ * We set all segment_indexes in the streams to unknown and
+ * adjust the time_position to the desired position. this is enough
+ * to trigger a segment switch in the streaming thread to start
+ * streaming from the desired position.
+ *
+ * Keyframe seeking is a little more complicated when dealing with
+ * segments. Ideally we want to move to the previous keyframe in
+ * the segment but there might not be a keyframe in the segment. In
+ * fact, none of the segments could contain a keyframe. We take a
+ * practical approach: seek to the previous keyframe in the segment,
+ * if there is none, seek to the beginning of the segment.
+ *
+ * Called with STREAM_LOCK
+ */
+static gboolean
+gst_qtdemux_perform_seek (GstQTDemux * qtdemux, GstSegment * segment)
+{
+  gint64 desired_offset;
+  gint n;
+
+  desired_offset = segment->last_stop;
+
+  GST_DEBUG_OBJECT (qtdemux, "seeking to %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (desired_offset));
+
+  if (segment->flags & GST_SEEK_FLAG_KEY_UNIT) {
+    gint64 min_offset;
+
+    gst_qtdemux_adjust_seek (qtdemux, desired_offset, &min_offset, NULL);
+    GST_DEBUG_OBJECT (qtdemux, "keyframe seek, align to %"
+        GST_TIME_FORMAT, GST_TIME_ARGS (min_offset));
+    desired_offset = min_offset;
+  }
+
+  /* and set all streams to the final position */
+  for (n = 0; n < qtdemux->n_streams; n++) {
+    QtDemuxStream *stream = qtdemux->streams[n];
+
+    stream->time_position = desired_offset;
+    stream->sample_index = -1;
+    stream->segment_index = -1;
+    stream->last_ret = GST_FLOW_OK;
+    stream->sent_eos = FALSE;
+  }
+  segment->last_stop = desired_offset;
+  segment->time = desired_offset;
+
+  /* we stop at the end */
+  if (segment->stop == -1)
+    segment->stop = segment->duration;
+
+  return TRUE;
+}
+
+/* do a seek in pull based mode */
+static gboolean
+gst_qtdemux_do_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event)
+{
+  gdouble rate;
+  GstFormat format;
+  GstSeekFlags flags;
+  GstSeekType cur_type, stop_type;
+  gint64 cur, stop;
+  gboolean flush;
+  gboolean update;
+  GstSegment seeksegment;
+  int i;
+
+  if (event) {
+    GST_DEBUG_OBJECT (qtdemux, "doing seek with event");
+
+    gst_event_parse_seek (event, &rate, &format, &flags,
+        &cur_type, &cur, &stop_type, &stop);
+
+    /* we have to have a format as the segment format. Try to convert
+     * if not. */
+    if (!gst_qtdemux_convert_seek (pad, &format, cur_type, &cur,
+            stop_type, &stop))
+      goto no_format;
+
+    GST_DEBUG_OBJECT (qtdemux, "seek format %s", gst_format_get_name (format));
+  } else {
+    GST_DEBUG_OBJECT (qtdemux, "doing seek without event");
+    flags = 0;
+  }
+
+  flush = flags & GST_SEEK_FLAG_FLUSH;
+
+  /* stop streaming, either by flushing or by pausing the task */
+  if (flush) {
+    /* unlock upstream pull_range */
+    gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_start ());
+    /* make sure out loop function exits */
+    gst_qtdemux_push_event (qtdemux, gst_event_new_flush_start ());
+  } else {
+    /* non flushing seek, pause the task */
+    gst_pad_pause_task (qtdemux->sinkpad);
+  }
+
+  /* wait for streaming to finish */
+  GST_PAD_STREAM_LOCK (qtdemux->sinkpad);
+
+  /* copy segment, we need this because we still need the old
+   * segment when we close the current segment. */
+  memcpy (&seeksegment, &qtdemux->segment, sizeof (GstSegment));
+
+  if (event) {
+    /* configure the segment with the seek variables */
+    GST_DEBUG_OBJECT (qtdemux, "configuring seek");
+    gst_segment_set_seek (&seeksegment, rate, format, flags,
+        cur_type, cur, stop_type, stop, &update);
+  }
+
+  /* now do the seek, this actually never returns FALSE */
+  gst_qtdemux_perform_seek (qtdemux, &seeksegment);
+
+  /* prepare for streaming again */
+  if (flush) {
+    gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_stop ());
+    gst_qtdemux_push_event (qtdemux, gst_event_new_flush_stop ());
+  } else if (qtdemux->segment_running) {
+    /* we are running the current segment and doing a non-flushing seek,
+     * close the segment first based on the last_stop. */
+    GST_DEBUG_OBJECT (qtdemux, "closing running segment %" G_GINT64_FORMAT
+        " to %" G_GINT64_FORMAT, qtdemux->segment.start,
+        qtdemux->segment.last_stop);
+
+    if (qtdemux->segment.rate >= 0) {
+      /* FIXME, rate is the product of the global rate and the (quicktime)
+       * segment rate. */
+      qtdemux->pending_newsegment = gst_event_new_new_segment (TRUE,
+          qtdemux->segment.rate, qtdemux->segment.format,
+          qtdemux->segment.start, qtdemux->segment.last_stop,
+          qtdemux->segment.time);
+    } else {                    /* For Reverse Playback */
+      guint64 stop;
+
+      if ((stop = qtdemux->segment.stop) == -1)
+        stop = qtdemux->segment.duration;
+      /* for reverse playback, we played from stop to last_stop. */
+      qtdemux->pending_newsegment = gst_event_new_new_segment (TRUE,
+          qtdemux->segment.rate, qtdemux->segment.format,
+          qtdemux->segment.last_stop, stop, qtdemux->segment.last_stop);
+    }
+  }
+
+  /* commit the new segment */
+  memcpy (&qtdemux->segment, &seeksegment, sizeof (GstSegment));
+
+  if (qtdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
+    gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
+        gst_message_new_segment_start (GST_OBJECT_CAST (qtdemux),
+            qtdemux->segment.format, qtdemux->segment.last_stop));
+  }
+
+  /* restart streaming, NEWSEGMENT will be sent from the streaming
+   * thread. */
+  qtdemux->segment_running = TRUE;
+  for (i = 0; i < qtdemux->n_streams; i++)
+    qtdemux->streams[i]->last_ret = GST_FLOW_OK;
+
+  gst_pad_start_task (qtdemux->sinkpad, (GstTaskFunction) gst_qtdemux_loop,
+      qtdemux->sinkpad);
+
+  GST_PAD_STREAM_UNLOCK (qtdemux->sinkpad);
+
+  return TRUE;
+
+  /* ERRORS */
+no_format:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "unsupported format given, seek aborted.");
+    return FALSE;
+  }
+}
+
+static gboolean
+qtdemux_ensure_index (GstQTDemux * qtdemux)
+{
+  guint i;
+
+  GST_DEBUG_OBJECT (qtdemux, "collecting all metadata for all streams");
+
+  /* Build complete index */
+  for (i = 0; i < qtdemux->n_streams; i++) {
+    QtDemuxStream *stream = qtdemux->streams[i];
+
+    if (!qtdemux_parse_samples (qtdemux, stream, stream->n_samples - 1))
+      goto parse_error;
+  }
+  return TRUE;
+
+  /* ERRORS */
+parse_error:
+  {
+    GST_LOG_OBJECT (qtdemux,
+        "Building complete index of stream %u for seeking failed!", i);
+    return FALSE;
+  }
+}
+
+static gboolean
+gst_qtdemux_handle_src_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res = TRUE;
+  GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_SEEK:
+    {
+#ifndef GST_DISABLE_GST_DEBUG
+      GstClockTime ts = gst_util_get_timestamp ();
+#endif
+      /* Build complete index for seeking;
+       * if not a fragmented file at least */
+      if (!qtdemux->fragmented)
+        if (!qtdemux_ensure_index (qtdemux))
+          goto index_failed;
+#ifndef GST_DISABLE_GST_DEBUG
+      ts = gst_util_get_timestamp () - ts;
+      GST_INFO_OBJECT (qtdemux,
+          "Time taken to parse index %" GST_TIME_FORMAT, GST_TIME_ARGS (ts));
+#endif
+    }
+      if (qtdemux->pullbased) {
+        res = gst_qtdemux_do_seek (qtdemux, pad, event);
+      } else if (qtdemux->state == QTDEMUX_STATE_MOVIE && qtdemux->n_streams &&
+          !qtdemux->fragmented) {
+        res = gst_qtdemux_do_push_seek (qtdemux, pad, event);
+      } else {
+        GST_DEBUG_OBJECT (qtdemux,
+            "ignoring seek in push mode in current state");
+        res = FALSE;
+      }
+      gst_event_unref (event);
+      break;
+    case GST_EVENT_QOS:
+    case GST_EVENT_NAVIGATION:
+      res = FALSE;
+      gst_event_unref (event);
+      break;
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (qtdemux);
+
+done:
+  return res;
+
+  /* ERRORS */
+index_failed:
+  {
+    GST_ERROR_OBJECT (qtdemux, "Index failed");
+    gst_event_unref (event);
+    res = FALSE;
+    goto done;
+  }
+}
+
+/* stream/index return sample that is min/max w.r.t. byte position,
+ * time is min/max w.r.t. time of samples,
+ * the latter need not be time of the former sample */
+static void
+gst_qtdemux_find_sample (GstQTDemux * qtdemux, gint64 byte_pos, gboolean fw,
+    gboolean set, QtDemuxStream ** _stream, gint * _index, gint64 * _time)
+{
+  gint i, n, index;
+  gint64 time, min_time;
+  QtDemuxStream *stream;
+
+  min_time = -1;
+  stream = NULL;
+  index = -1;
+
+  for (n = 0; n < qtdemux->n_streams; ++n) {
+    QtDemuxStream *str;
+    gint inc;
+    gboolean set_sample;
+
+    str = qtdemux->streams[n];
+    set_sample = !set;
+
+    if (fw) {
+      i = 0;
+      inc = 1;
+    } else {
+      i = str->n_samples - 1;
+      inc = -1;
+    }
+    for (; (i >= 0) && (i < str->n_samples); i += inc) {
+      if (str->samples[i].size &&
+          ((fw && (str->samples[i].offset >= byte_pos)) ||
+              (!fw &&
+                  (str->samples[i].offset + str->samples[i].size <=
+                      byte_pos)))) {
+        /* move stream to first available sample */
+        if (set) {
+          gst_qtdemux_move_stream (qtdemux, str, i);
+          set_sample = TRUE;
+        }
+        /* determine min/max time */
+        time = str->samples[i].timestamp + str->samples[i].pts_offset;
+        time = gst_util_uint64_scale (time, GST_SECOND, str->timescale);
+        if (min_time == -1 || (!fw && time > min_time) ||
+            (fw && time < min_time)) {
+          min_time = time;
+        }
+        /* determine stream with leading sample, to get its position */
+        if (!stream || (fw
+                && (str->samples[i].offset < stream->samples[index].offset))
+            || (!fw
+                && (str->samples[i].offset > stream->samples[index].offset))) {
+          stream = str;
+          index = i;
+        }
+        break;
+      }
+    }
+    /* no sample for this stream, mark eos */
+    if (!set_sample)
+      gst_qtdemux_move_stream (qtdemux, str, str->n_samples);
+  }
+
+  if (_time)
+    *_time = min_time;
+  if (_stream)
+    *_stream = stream;
+  if (_index)
+    *_index = index;
+}
+
+static gboolean
+gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstEvent * event)
+{
+  GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
+  gboolean res;
+
+  GST_LOG_OBJECT (demux, "handling %s event", GST_EVENT_TYPE_NAME (event));
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_NEWSEGMENT:
+    {
+      GstFormat format;
+      gdouble rate, arate;
+      gint64 start, stop, time, offset = 0;
+      QtDemuxStream *stream;
+      gint idx;
+      gboolean update;
+      GstSegment segment;
+
+      /* some debug output */
+      gst_segment_init (&segment, GST_FORMAT_UNDEFINED);
+      gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
+          &start, &stop, &time);
+      gst_segment_set_newsegment_full (&segment, update, rate, arate, format,
+          start, stop, time);
+      GST_DEBUG_OBJECT (demux,
+          "received format %d newsegment %" GST_SEGMENT_FORMAT, format,
+          &segment);
+
+      /* chain will send initial newsegment after pads have been added */
+      if (demux->state != QTDEMUX_STATE_MOVIE || !demux->n_streams) {
+        GST_DEBUG_OBJECT (demux, "still starting, eating event");
+        goto exit;
+      }
+
+      /* we only expect a BYTE segment, e.g. following a seek */
+      if (format == GST_FORMAT_BYTES) {
+        if (start > 0) {
+          gint64 requested_seek_time;
+          guint64 seek_offset;
+
+          offset = start;
+
+          GST_OBJECT_LOCK (demux);
+          requested_seek_time = demux->requested_seek_time;
+          seek_offset = demux->seek_offset;
+          demux->requested_seek_time = -1;
+          demux->seek_offset = -1;
+          GST_OBJECT_UNLOCK (demux);
+
+          if (offset == seek_offset) {
+            start = requested_seek_time;
+          } else {
+            gst_qtdemux_find_sample (demux, start, TRUE, FALSE, NULL, NULL,
+                &start);
+            start = MAX (start, 0);
+          }
+        }
+        if (stop > 0) {
+          gst_qtdemux_find_sample (demux, stop, FALSE, FALSE, NULL, NULL,
+              &stop);
+          /* keyframe seeking should already arrange for start >= stop,
+           * but make sure in other rare cases */
+          stop = MAX (stop, start);
+        }
+      } else {
+        GST_DEBUG_OBJECT (demux, "unsupported segment format, ignoring");
+        goto exit;
+      }
+
+      /* accept upstream's notion of segment and distribute along */
+      gst_segment_set_newsegment_full (&demux->segment, update, rate, arate,
+          GST_FORMAT_TIME, start, stop, start);
+      GST_DEBUG_OBJECT (demux, "Pushing newseg update %d, rate %g, "
+          "applied rate %g, format %d, start %" GST_TIME_FORMAT ", "
+          "stop %" GST_TIME_FORMAT, update, rate, arate, GST_FORMAT_TIME,
+          GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
+
+      gst_qtdemux_push_event (demux,
+          gst_event_new_new_segment_full (update, rate, arate, GST_FORMAT_TIME,
+              start, stop, start));
+
+      /* clear leftover in current segment, if any */
+      gst_adapter_clear (demux->adapter);
+      /* set up streaming thread */
+      gst_qtdemux_find_sample (demux, offset, TRUE, TRUE, &stream, &idx, NULL);
+      demux->offset = offset;
+      if (stream) {
+        demux->todrop = stream->samples[idx].offset - offset;
+        demux->neededbytes = demux->todrop + stream->samples[idx].size;
+      } else {
+        /* set up for EOS */
+        demux->neededbytes = -1;
+        demux->todrop = 0;
+      }
+    exit:
+      gst_event_unref (event);
+      res = TRUE;
+      goto drop;
+      break;
+    }
+    case GST_EVENT_FLUSH_STOP:
+    {
+      gint i;
+
+      /* clean up, force EOS if no more info follows */
+      gst_adapter_clear (demux->adapter);
+      demux->offset = 0;
+      demux->neededbytes = -1;
+      /* reset flow return, e.g. following seek */
+      for (i = 0; i < demux->n_streams; i++) {
+        demux->streams[i]->last_ret = GST_FLOW_OK;
+        demux->streams[i]->sent_eos = FALSE;
+      }
+      break;
+    }
+    case GST_EVENT_EOS:
+      /* If we are in push mode, and get an EOS before we've seen any streams,
+       * then error out - we have nowhere to send the EOS */
+      if (!demux->pullbased) {
+        gint i;
+        gboolean has_valid_stream = FALSE;
+        for (i = 0; i < demux->n_streams; i++) {
+          if (demux->streams[i]->pad != NULL) {
+            has_valid_stream = TRUE;
+            break;
+          }
+        }
+        if (!has_valid_stream)
+          gst_qtdemux_post_no_playable_stream_error (demux);
+      }
+      break;
+    default:
+      break;
+  }
+
+  res = gst_pad_event_default (demux->sinkpad, event);
+
+drop:
+  return res;
+}
+
+static void
+gst_qtdemux_set_index (GstElement * element, GstIndex * index)
+{
+  GstQTDemux *demux = GST_QTDEMUX (element);
+
+  GST_OBJECT_LOCK (demux);
+  if (demux->element_index)
+    gst_object_unref (demux->element_index);
+  if (index) {
+    demux->element_index = gst_object_ref (index);
+  } else {
+    demux->element_index = NULL;
+  }
+  GST_OBJECT_UNLOCK (demux);
+  /* object lock might be taken again */
+  if (index)
+    gst_index_get_writer_id (index, GST_OBJECT (element), &demux->index_id);
+  GST_DEBUG_OBJECT (demux, "Set index %" GST_PTR_FORMAT "for writer id %d",
+      demux->element_index, demux->index_id);
+}
+
+static GstIndex *
+gst_qtdemux_get_index (GstElement * element)
+{
+  GstIndex *result = NULL;
+  GstQTDemux *demux = GST_QTDEMUX (element);
+
+  GST_OBJECT_LOCK (demux);
+  if (demux->element_index)
+    result = gst_object_ref (demux->element_index);
+  GST_OBJECT_UNLOCK (demux);
+
+  GST_DEBUG_OBJECT (demux, "Returning index %" GST_PTR_FORMAT, result);
+
+  return result;
+}
+
+static void
+gst_qtdemux_stbl_free (QtDemuxStream * stream)
+{
+  g_free ((gpointer) stream->stco.data);
+  stream->stco.data = NULL;
+  g_free ((gpointer) stream->stsz.data);
+  stream->stsz.data = NULL;
+  g_free ((gpointer) stream->stsc.data);
+  stream->stsc.data = NULL;
+  g_free ((gpointer) stream->stts.data);
+  stream->stts.data = NULL;
+  g_free ((gpointer) stream->stss.data);
+  stream->stss.data = NULL;
+  g_free ((gpointer) stream->stps.data);
+  stream->stps.data = NULL;
+  g_free ((gpointer) stream->ctts.data);
+  stream->ctts.data = NULL;
+}
+
+static void
+gst_qtdemux_stream_free (GstQTDemux * qtdemux, QtDemuxStream * stream)
+{
+  while (stream->buffers) {
+    gst_buffer_unref (GST_BUFFER_CAST (stream->buffers->data));
+    stream->buffers = g_slist_delete_link (stream->buffers, stream->buffers);
+  }
+  if (stream->pad)
+    gst_element_remove_pad (GST_ELEMENT_CAST (qtdemux), stream->pad);
+  g_free (stream->samples);
+  if (stream->caps)
+    gst_caps_unref (stream->caps);
+  g_free (stream->segments);
+  if (stream->pending_tags)
+    gst_tag_list_free (stream->pending_tags);
+  g_free (stream->redirect_uri);
+  /* free stbl sub-atoms */
+  gst_qtdemux_stbl_free (stream);
+  g_free (stream);
+}
+
+static GstStateChangeReturn
+gst_qtdemux_change_state (GstElement * element, GstStateChange transition)
+{
+  GstQTDemux *qtdemux = GST_QTDEMUX (element);
+  GstStateChangeReturn result = GST_STATE_CHANGE_FAILURE;
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      break;
+    default:
+      break;
+  }
+
+  result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:{
+      gint n;
+
+      qtdemux->state = QTDEMUX_STATE_INITIAL;
+      qtdemux->neededbytes = 16;
+      qtdemux->todrop = 0;
+      qtdemux->pullbased = FALSE;
+      qtdemux->posted_redirect = FALSE;
+      qtdemux->offset = 0;
+      qtdemux->first_mdat = -1;
+      qtdemux->got_moov = FALSE;
+      qtdemux->mdatoffset = GST_CLOCK_TIME_NONE;
+      if (qtdemux->mdatbuffer)
+        gst_buffer_unref (qtdemux->mdatbuffer);
+      qtdemux->mdatbuffer = NULL;
+      if (qtdemux->comp_brands)
+        gst_buffer_unref (qtdemux->comp_brands);
+      qtdemux->comp_brands = NULL;
+      if (qtdemux->tag_list)
+        gst_tag_list_free (qtdemux->tag_list);
+      qtdemux->tag_list = NULL;
+      if (qtdemux->element_index)
+        gst_object_unref (qtdemux->element_index);
+      qtdemux->element_index = NULL;
+      gst_adapter_clear (qtdemux->adapter);
+      for (n = 0; n < qtdemux->n_streams; n++) {
+        gst_qtdemux_stream_free (qtdemux, qtdemux->streams[n]);
+        qtdemux->streams[n] = NULL;
+      }
+      qtdemux->major_brand = 0;
+      qtdemux->n_streams = 0;
+      qtdemux->n_video_streams = 0;
+      qtdemux->n_audio_streams = 0;
+      qtdemux->n_sub_streams = 0;
+      gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME);
+      qtdemux->requested_seek_time = GST_CLOCK_TIME_NONE;
+      qtdemux->seek_offset = 0;
+      break;
+    }
+    default:
+      break;
+  }
+
+  return result;
+}
+
+static void
+qtdemux_post_global_tags (GstQTDemux * qtdemux)
+{
+  if (qtdemux->tag_list) {
+    /* all header tags ready and parsed, push them */
+    GST_INFO_OBJECT (qtdemux, "posting global tags: %" GST_PTR_FORMAT,
+        qtdemux->tag_list);
+    /* post now, send event on pads later */
+    gst_element_post_message (GST_ELEMENT (qtdemux),
+        gst_message_new_tag (GST_OBJECT (qtdemux),
+            gst_tag_list_copy (qtdemux->tag_list)));
+  }
+}
+
+static void
+qtdemux_parse_ftyp (GstQTDemux * qtdemux, const guint8 * buffer, gint length)
+{
+  /* only consider at least a sufficiently complete ftyp atom */
+  if (length >= 20) {
+    GstBuffer *buf;
+
+    qtdemux->major_brand = QT_FOURCC (buffer + 8);
+    GST_DEBUG_OBJECT (qtdemux, "major brand: %" GST_FOURCC_FORMAT,
+        GST_FOURCC_ARGS (qtdemux->major_brand));
+    buf = qtdemux->comp_brands = gst_buffer_new_and_alloc (length - 16);
+    memcpy (GST_BUFFER_DATA (buf), buffer + 16, GST_BUFFER_SIZE (buf));
+  }
+}
+
+static void
+qtdemux_handle_xmp_taglist (GstQTDemux * qtdemux, GstTagList * taglist)
+{
+  /* Strip out bogus fields */
+  if (taglist) {
+    gst_tag_list_remove_tag (taglist, GST_TAG_VIDEO_CODEC);
+
+    GST_DEBUG_OBJECT (qtdemux, "Found XMP tags %" GST_PTR_FORMAT, taglist);
+
+    if (qtdemux->tag_list) {
+      /* prioritize native tags using _KEEP mode */
+      gst_tag_list_insert (qtdemux->tag_list, taglist, GST_TAG_MERGE_KEEP);
+      gst_tag_list_free (taglist);
+    } else
+      qtdemux->tag_list = taglist;
+  }
+}
+
+static void
+qtdemux_parse_uuid (GstQTDemux * qtdemux, const guint8 * buffer, gint length)
+{
+  static guint8 xmp_uuid[] = { 0xBE, 0x7A, 0xCF, 0xCB,
+    0x97, 0xA9, 0x42, 0xE8,
+    0x9C, 0x71, 0x99, 0x94,
+    0x91, 0xE3, 0xAF, 0xAC
+  };
+  guint offset;
+
+  offset = (QT_UINT32 (buffer) == 0) ? 16 : 8;
+
+  if (length <= offset + 16) {
+    GST_DEBUG_OBJECT (qtdemux, "uuid atom is too short, skipping");
+    return;
+  }
+
+  if (memcmp (buffer + offset, xmp_uuid, 16) == 0) {
+    GstBuffer *buf;
+    GstTagList *taglist;
+
+    buf = gst_buffer_new ();
+    GST_BUFFER_DATA (buf) = (guint8 *) buffer + offset + 16;
+    GST_BUFFER_SIZE (buf) = length - offset - 16;
+
+    taglist = gst_tag_list_from_xmp_buffer (buf);
+    gst_buffer_unref (buf);
+
+    qtdemux_handle_xmp_taglist (qtdemux, taglist);
+
+  } else {
+    GST_DEBUG_OBJECT (qtdemux, "Ignoring unknown uuid");
+  }
+}
+
+/* caller verifies at least 8 bytes in buf */
+static void
+extract_initial_length_and_fourcc (const guint8 * data, guint size,
+    guint64 * plength, guint32 * pfourcc)
+{
+  guint64 length;
+  guint32 fourcc;
+
+  length = QT_UINT32 (data);
+  GST_DEBUG ("length 0x%08" G_GINT64_MODIFIER "x", length);
+  fourcc = QT_FOURCC (data + 4);
+  GST_DEBUG ("atom type %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
+
+  if (length == 0) {
+    length = G_MAXUINT32;
+  } else if (length == 1 && size >= 16) {
+    /* this means we have an extended size, which is the 64 bit value of
+     * the next 8 bytes */
+    length = QT_UINT64 (data + 8);
+    GST_DEBUG ("length 0x%08" G_GINT64_MODIFIER "x", length);
+  }
+
+  if (plength)
+    *plength = length;
+  if (pfourcc)
+    *pfourcc = fourcc;
+}
+
+static gboolean
+qtdemux_parse_mehd (GstQTDemux * qtdemux, GstByteReader * br)
+{
+  guint32 version = 0;
+  guint64 duration = 0;
+
+  if (!gst_byte_reader_get_uint32_be (br, &version))
+    goto failed;
+
+  version >>= 24;
+  if (version == 1) {
+    if (!gst_byte_reader_get_uint64_be (br, &duration))
+      goto failed;
+  } else {
+    guint32 dur = 0;
+
+    if (!gst_byte_reader_get_uint32_be (br, &dur))
+      goto failed;
+    duration = dur;
+  }
+
+  GST_INFO_OBJECT (qtdemux, "mehd duration: %" G_GUINT64_FORMAT, duration);
+  qtdemux->duration = duration;
+
+  return TRUE;
+
+failed:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "parsing mehd failed");
+    return FALSE;
+  }
+}
+
+static gboolean
+qtdemux_parse_trex (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint32 * ds_duration, guint32 * ds_size, guint32 * ds_flags)
+{
+  if (!stream->parsed_trex && qtdemux->moov_node) {
+    GNode *mvex, *trex;
+    GstByteReader trex_data;
+
+    mvex = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_mvex);
+    if (mvex) {
+      trex = qtdemux_tree_get_child_by_type_full (mvex, FOURCC_trex,
+          &trex_data);
+      while (trex) {
+        guint32 id = 0, dur = 0, size = 0, flags = 0;
+
+        /* skip version/flags */
+        if (!gst_byte_reader_skip (&trex_data, 4))
+          goto next;
+        if (!gst_byte_reader_get_uint32_be (&trex_data, &id))
+          goto next;
+        if (id != stream->track_id)
+          goto next;
+        /* sample description index; ignore */
+        if (!gst_byte_reader_get_uint32_be (&trex_data, &dur))
+          goto next;
+        if (!gst_byte_reader_get_uint32_be (&trex_data, &dur))
+          goto next;
+        if (!gst_byte_reader_get_uint32_be (&trex_data, &size))
+          goto next;
+        if (!gst_byte_reader_get_uint32_be (&trex_data, &flags))
+          goto next;
+
+        GST_DEBUG_OBJECT (qtdemux, "fragment defaults for stream %d; "
+            "duration %d,  size %d, flags 0x%x", stream->track_id,
+            dur, size, flags);
+
+        stream->parsed_trex = TRUE;
+        stream->def_sample_duration = dur;
+        stream->def_sample_size = size;
+        stream->def_sample_flags = flags;
+
+      next:
+        /* iterate all siblings */
+        trex = qtdemux_tree_get_sibling_by_type_full (trex, FOURCC_trex,
+            &trex_data);
+      }
+    }
+  }
+
+  *ds_duration = stream->def_sample_duration;
+  *ds_size = stream->def_sample_size;
+  *ds_size = stream->def_sample_size;
+
+  /* even then, above values are better than random ... */
+  if (G_UNLIKELY (!stream->parsed_trex)) {
+    GST_WARNING_OBJECT (qtdemux,
+        "failed to find fragment defaults for stream %d", stream->track_id);
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+static gboolean
+qtdemux_parse_trun (GstQTDemux * qtdemux, GstByteReader * trun,
+    QtDemuxStream * stream, guint32 d_sample_duration, guint32 d_sample_size,
+    guint32 d_sample_flags, gint64 moof_offset, gint64 moof_length,
+    gint64 * base_offset, gint64 * running_offset)
+{
+  guint64 timestamp;
+  gint32 data_offset = 0;
+  guint32 flags = 0, first_flags = 0, samples_count = 0;
+  gint i;
+  guint8 *data;
+  guint entry_size, dur_offset, size_offset, flags_offset = 0, ct_offset = 0;
+  QtDemuxSample *sample;
+  gboolean ismv = FALSE;
+
+  GST_LOG_OBJECT (qtdemux, "parsing trun stream %d; "
+      "default dur %d, size %d, flags 0x%x, base offset %" G_GINT64_FORMAT,
+      stream->track_id, d_sample_duration, d_sample_size, d_sample_flags,
+      *base_offset);
+
+  if (!gst_byte_reader_skip (trun, 1) ||
+      !gst_byte_reader_get_uint24_be (trun, &flags))
+    goto fail;
+
+  if (!gst_byte_reader_get_uint32_be (trun, &samples_count))
+    goto fail;
+
+  if (flags & TR_DATA_OFFSET) {
+    /* note this is really signed */
+    if (!gst_byte_reader_get_int32_be (trun, &data_offset))
+      goto fail;
+    GST_LOG_OBJECT (qtdemux, "trun data offset %d", data_offset);
+    /* default base offset = first byte of moof */
+    if (*base_offset == -1) {
+      GST_LOG_OBJECT (qtdemux, "base_offset at moof");
+      *base_offset = moof_offset;
+    }
+    *running_offset = *base_offset + data_offset;
+  } else {
+    /* if no offset at all, that would mean data starts at moof start,
+     * which is a bit wrong and is ismv crappy way, so compensate
+     * assuming data is in mdat following moof */
+    if (*base_offset == -1) {
+      *base_offset = moof_offset + moof_length + 8;
+      GST_LOG_OBJECT (qtdemux, "base_offset assumed in mdat after moof");
+      ismv = TRUE;
+    }
+    if (*running_offset == -1)
+      *running_offset = *base_offset;
+  }
+
+  GST_LOG_OBJECT (qtdemux, "running offset now %" G_GINT64_FORMAT,
+      *running_offset);
+  GST_LOG_OBJECT (qtdemux, "trun offset %d, flags 0x%x, entries %d",
+      data_offset, flags, samples_count);
+
+  if (flags & TR_FIRST_SAMPLE_FLAGS) {
+    if (G_UNLIKELY (flags & TR_SAMPLE_FLAGS)) {
+      GST_DEBUG_OBJECT (qtdemux,
+          "invalid flags; SAMPLE and FIRST_SAMPLE present, discarding latter");
+      flags ^= TR_FIRST_SAMPLE_FLAGS;
+    } else {
+      if (!gst_byte_reader_get_uint32_be (trun, &first_flags))
+        goto fail;
+      GST_LOG_OBJECT (qtdemux, "first flags: 0x%x", first_flags);
+    }
+  }
+
+  /* FIXME ? spec says other bits should also be checked to determine
+   * entry size (and prefix size for that matter) */
+  entry_size = 0;
+  dur_offset = size_offset = 0;
+  if (flags & TR_SAMPLE_DURATION) {
+    GST_LOG_OBJECT (qtdemux, "entry duration present");
+    dur_offset = entry_size;
+    entry_size += 4;
+  }
+  if (flags & TR_SAMPLE_SIZE) {
+    GST_LOG_OBJECT (qtdemux, "entry size present");
+    size_offset = entry_size;
+    entry_size += 4;
+  }
+  if (flags & TR_SAMPLE_FLAGS) {
+    GST_LOG_OBJECT (qtdemux, "entry flags present");
+    flags_offset = entry_size;
+    entry_size += 4;
+  }
+  if (flags & TR_COMPOSITION_TIME_OFFSETS) {
+    GST_LOG_OBJECT (qtdemux, "entry ct offset present");
+    ct_offset = entry_size;
+    entry_size += 4;
+  }
+
+  if (!qt_atom_parser_has_chunks (trun, samples_count, entry_size))
+    goto fail;
+  data = (guint8 *) gst_byte_reader_peek_data_unchecked (trun);
+
+  if (stream->n_samples >=
+      QTDEMUX_MAX_SAMPLE_INDEX_SIZE / sizeof (QtDemuxSample))
+    goto index_too_big;
+
+  GST_DEBUG_OBJECT (qtdemux, "allocating n_samples %u * %u (%.2f MB)",
+      stream->n_samples, (guint) sizeof (QtDemuxSample),
+      stream->n_samples * sizeof (QtDemuxSample) / (1024.0 * 1024.0));
+
+  /* create a new array of samples if it's the first sample parsed */
+  if (stream->n_samples == 0)
+    stream->samples = g_try_new0 (QtDemuxSample, samples_count);
+  /* or try to reallocate it with space enough to insert the new samples */
+  else
+    stream->samples = g_try_renew (QtDemuxSample, stream->samples,
+        stream->n_samples + samples_count);
+  if (stream->samples == NULL)
+    goto out_of_memory;
+
+  if (G_UNLIKELY (stream->n_samples == 0)) {
+    /* the timestamp of the first sample is also provided by the tfra entry
+     * but we shouldn't rely on it as it is at the end of files */
+    timestamp = 0;
+  } else {
+    /* subsequent fragments extend stream */
+    timestamp =
+        stream->samples[stream->n_samples - 1].timestamp +
+        stream->samples[stream->n_samples - 1].duration;
+  }
+  sample = stream->samples + stream->n_samples;
+  for (i = 0; i < samples_count; i++) {
+    guint32 dur, size, sflags, ct;
+
+    /* first read sample data */
+    if (flags & TR_SAMPLE_DURATION) {
+      dur = QT_UINT32 (data + dur_offset);
+    } else {
+      dur = d_sample_duration;
+    }
+    if (flags & TR_SAMPLE_SIZE) {
+      size = QT_UINT32 (data + size_offset);
+    } else {
+      size = d_sample_size;
+    }
+    if (flags & TR_FIRST_SAMPLE_FLAGS) {
+      if (i == 0) {
+        sflags = first_flags;
+      } else {
+        sflags = d_sample_flags;
+      }
+    } else if (flags & TR_SAMPLE_FLAGS) {
+      sflags = QT_UINT32 (data + flags_offset);
+    } else {
+      sflags = d_sample_flags;
+    }
+    if (flags & TR_COMPOSITION_TIME_OFFSETS) {
+      ct = QT_UINT32 (data + ct_offset);
+    } else {
+      ct = 0;
+    }
+    data += entry_size;
+
+    /* fill the sample information */
+    sample->offset = *running_offset;
+    sample->pts_offset = ct;
+    sample->size = size;
+    sample->timestamp = timestamp;
+    sample->duration = dur;
+    /* sample-is-difference-sample */
+    /* ismv seems to use 0x40 for keyframe, 0xc0 for non-keyframe,
+     * now idea how it relates to bitfield other than massive LE/BE confusion */
+    sample->keyframe = ismv ? ((sflags & 0xff) == 0x40) : !(sflags & 0x10000);
+    *running_offset += size;
+    timestamp += dur;
+    sample++;
+  }
+
+  stream->n_samples += samples_count;
+
+  return TRUE;
+
+fail:
+  {
+    GST_WARNING_OBJECT (qtdemux, "failed to parse trun");
+    return FALSE;
+  }
+out_of_memory:
+  {
+    GST_WARNING_OBJECT (qtdemux, "failed to allocate %d samples",
+        stream->n_samples);
+    return FALSE;
+  }
+index_too_big:
+  {
+    GST_WARNING_OBJECT (qtdemux, "not allocating index of %d samples, would "
+        "be larger than %uMB (broken file?)", stream->n_samples,
+        QTDEMUX_MAX_SAMPLE_INDEX_SIZE >> 20);
+    return FALSE;
+  }
+}
+
+/* find stream with @id */
+static inline QtDemuxStream *
+qtdemux_find_stream (GstQTDemux * qtdemux, guint32 id)
+{
+  QtDemuxStream *stream;
+  gint i;
+
+  /* check */
+  if (G_UNLIKELY (!id)) {
+    GST_DEBUG_OBJECT (qtdemux, "invalid track id 0");
+    return NULL;
+  }
+
+  /* try to get it fast and simple */
+  if (G_LIKELY (id <= qtdemux->n_streams)) {
+    stream = qtdemux->streams[id - 1];
+    if (G_LIKELY (stream->track_id == id))
+      return stream;
+  }
+
+  /* linear search otherwise */
+  for (i = 0; i < qtdemux->n_streams; i++) {
+    stream = qtdemux->streams[i];
+    if (stream->track_id == id)
+      return stream;
+  }
+
+  return NULL;
+}
+
+static gboolean
+qtdemux_parse_tfhd (GstQTDemux * qtdemux, GstByteReader * tfhd,
+    QtDemuxStream ** stream, guint32 * default_sample_duration,
+    guint32 * default_sample_size, guint32 * default_sample_flags,
+    gint64 * base_offset)
+{
+  guint32 flags = 0;
+  guint32 track_id = 0;
+
+  if (!gst_byte_reader_skip (tfhd, 1) ||
+      !gst_byte_reader_get_uint24_be (tfhd, &flags))
+    goto invalid_track;
+
+  if (!gst_byte_reader_get_uint32_be (tfhd, &track_id))
+    goto invalid_track;
+
+  *stream = qtdemux_find_stream (qtdemux, track_id);
+  if (G_UNLIKELY (!*stream))
+    goto unknown_stream;
+
+  if (flags & TF_BASE_DATA_OFFSET)
+    if (!gst_byte_reader_get_uint64_be (tfhd, (guint64 *) base_offset))
+      goto invalid_track;
+
+  /* obtain stream defaults */
+  qtdemux_parse_trex (qtdemux, *stream,
+      default_sample_duration, default_sample_size, default_sample_flags);
+
+  /* FIXME: Handle TF_SAMPLE_DESCRIPTION_INDEX properly */
+  if (flags & TF_SAMPLE_DESCRIPTION_INDEX)
+    if (!gst_byte_reader_skip (tfhd, 4))
+      goto invalid_track;
+
+  if (flags & TF_DEFAULT_SAMPLE_DURATION)
+    if (!gst_byte_reader_get_uint32_be (tfhd, default_sample_duration))
+      goto invalid_track;
+
+  if (flags & TF_DEFAULT_SAMPLE_SIZE)
+    if (!gst_byte_reader_get_uint32_be (tfhd, default_sample_size))
+      goto invalid_track;
+
+  if (flags & TF_DEFAULT_SAMPLE_FLAGS)
+    if (!gst_byte_reader_get_uint32_be (tfhd, default_sample_flags))
+      goto invalid_track;
+
+  return TRUE;
+
+invalid_track:
+  {
+    GST_WARNING_OBJECT (qtdemux, "invalid track fragment header");
+    return FALSE;
+  }
+unknown_stream:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "unknown stream in tfhd");
+    return TRUE;
+  }
+}
+
+static gboolean
+qtdemux_parse_moof (GstQTDemux * qtdemux, const guint8 * buffer, guint length,
+    guint64 moof_offset, QtDemuxStream * stream)
+{
+  GNode *moof_node, *traf_node, *tfhd_node, *trun_node;
+  GstByteReader trun_data, tfhd_data;
+  guint32 ds_size = 0, ds_duration = 0, ds_flags = 0;
+  gint64 base_offset, running_offset;
+
+  /* NOTE @stream ignored */
+
+  moof_node = g_node_new ((guint8 *) buffer);
+  qtdemux_parse_node (qtdemux, moof_node, buffer, length);
+  qtdemux_node_dump (qtdemux, moof_node);
+
+  /* unknown base_offset to start with */
+  base_offset = running_offset = -1;
+  traf_node = qtdemux_tree_get_child_by_type (moof_node, FOURCC_traf);
+  while (traf_node) {
+    /* Fragment Header node */
+    tfhd_node =
+        qtdemux_tree_get_child_by_type_full (traf_node, FOURCC_tfhd,
+        &tfhd_data);
+    if (!tfhd_node)
+      goto missing_tfhd;
+    if (!qtdemux_parse_tfhd (qtdemux, &tfhd_data, &stream, &ds_duration,
+            &ds_size, &ds_flags, &base_offset))
+      goto missing_tfhd;
+    if (G_UNLIKELY (!stream)) {
+      /* we lost track of offset, we'll need to regain it,
+       * but can delay complaining until later or avoid doing so altogether */
+      base_offset = -2;
+      goto next;
+    }
+    if (G_UNLIKELY (base_offset < -1))
+      goto lost_offset;
+    /* Track Run node */
+    trun_node =
+        qtdemux_tree_get_child_by_type_full (traf_node, FOURCC_trun,
+        &trun_data);
+    while (trun_node) {
+      qtdemux_parse_trun (qtdemux, &trun_data, stream,
+          ds_duration, ds_size, ds_flags, moof_offset, length, &base_offset,
+          &running_offset);
+      /* iterate all siblings */
+      trun_node = qtdemux_tree_get_sibling_by_type_full (trun_node, FOURCC_trun,
+          &trun_data);
+    }
+    /* if no new base_offset provided for next traf,
+     * base is end of current traf */
+    base_offset = running_offset;
+    running_offset = -1;
+  next:
+    /* iterate all siblings */
+    traf_node = qtdemux_tree_get_sibling_by_type (traf_node, FOURCC_traf);
+  }
+  g_node_destroy (moof_node);
+  return TRUE;
+
+missing_tfhd:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "missing tfhd box");
+    goto fail;
+  }
+lost_offset:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "lost offset");
+    goto fail;
+  }
+fail:
+  {
+    g_node_destroy (moof_node);
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+}
+
+/* might be used if some day we actually use mfra & co
+ * for random access to fragments,
+ * but that will require quite some modifications and much less relying
+ * on a sample array */
+#if 0
+static gboolean
+qtdemux_parse_tfra (GstQTDemux * qtdemux, GNode * tfra_node,
+    QtDemuxStream * stream)
+{
+  guint64 time = 0, moof_offset = 0;
+  guint32 ver_flags, track_id, len, num_entries, i;
+  guint value_size, traf_size, trun_size, sample_size;
+  GstBuffer *buf = NULL;
+  GstFlowReturn ret;
+  GstByteReader tfra;
+
+  gst_byte_reader_init (&tfra, (guint8 *) tfra_node->data + (4 + 4),
+      QT_UINT32 ((guint8 *) tfra_node->data) - (4 + 4));
+
+  if (!gst_byte_reader_get_uint32_be (&tfra, &ver_flags))
+    return FALSE;
+
+  if (!(gst_byte_reader_get_uint32_be (&tfra, &track_id) &&
+          gst_byte_reader_get_uint32_be (&tfra, &len) &&
+          gst_byte_reader_get_uint32_be (&tfra, &num_entries)))
+    return FALSE;
+
+  GST_LOG_OBJECT (qtdemux, "id %d == stream id %d ?",
+      track_id, stream->track_id);
+  if (track_id != stream->track_id) {
+    return FALSE;
+  }
+
+  value_size = ((ver_flags >> 24) == 1) ? sizeof (guint64) : sizeof (guint32);
+  sample_size = (len & 3) + 1;
+  trun_size = ((len & 12) >> 2) + 1;
+  traf_size = ((len & 48) >> 4) + 1;
+
+  if (num_entries == 0)
+    goto no_samples;
+
+  if (!qt_atom_parser_has_chunks (&tfra, num_entries,
+          value_size + value_size + traf_size + trun_size + sample_size))
+    goto corrupt_file;
+
+  for (i = 0; i < num_entries; i++) {
+    qt_atom_parser_get_offset (&tfra, value_size, &time);
+    qt_atom_parser_get_offset (&tfra, value_size, &moof_offset);
+    qt_atom_parser_get_uint_with_size_unchecked (&tfra, traf_size);
+    qt_atom_parser_get_uint_with_size_unchecked (&tfra, trun_size);
+    qt_atom_parser_get_uint_with_size_unchecked (&tfra, sample_size);
+
+    GST_LOG_OBJECT (qtdemux,
+        "fragment time: %" GST_TIME_FORMAT " moof_offset: %u",
+        GST_TIME_ARGS (gst_util_uint64_scale (time, GST_SECOND,
+                stream->timescale)), moof_offset);
+
+    ret = gst_qtdemux_pull_atom (qtdemux, moof_offset, 0, &buf);
+    if (ret != GST_FLOW_OK)
+      goto corrupt_file;
+    qtdemux_parse_moof (qtdemux, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf),
+        moof_offset, stream);
+    gst_buffer_unref (buf);
+  }
+
+  return TRUE;
+
+/* ERRORS */
+corrupt_file:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+no_samples:
+  {
+    GST_WARNING_OBJECT (qtdemux, "stream has no samples");
+    return FALSE;
+  }
+}
+
+static gboolean
+qtdemux_parse_mfra (GstQTDemux * qtdemux, QtDemuxStream * stream)
+{
+  GstFlowReturn ret;
+  GNode *mfra_node, *tfra_node;
+  GstBuffer *buffer;
+
+  if (!qtdemux->mfra_offset)
+    return FALSE;
+
+  ret = gst_qtdemux_pull_atom (qtdemux, qtdemux->mfra_offset, 0, &buffer);
+  if (ret != GST_FLOW_OK)
+    goto corrupt_file;
+
+  mfra_node = g_node_new ((guint8 *) GST_BUFFER_DATA (buffer));
+  qtdemux_parse_node (qtdemux, mfra_node, GST_BUFFER_DATA (buffer),
+      GST_BUFFER_SIZE (buffer));
+
+  tfra_node = qtdemux_tree_get_child_by_type (mfra_node, FOURCC_tfra);
+
+  while (tfra_node) {
+    qtdemux_parse_tfra (qtdemux, tfra_node, stream);
+    /* iterate all siblings */
+    tfra_node = qtdemux_tree_get_sibling_by_type (tfra_node, FOURCC_tfra);
+  }
+  g_node_destroy (mfra_node);
+  gst_buffer_unref (buffer);
+
+  return TRUE;
+
+corrupt_file:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+}
+
+static GstFlowReturn
+qtdemux_parse_mfro (GstQTDemux * qtdemux, guint64 * mfra_offset,
+    guint32 * mfro_size)
+{
+  GstFlowReturn ret = GST_FLOW_ERROR;
+  GstBuffer *mfro = NULL;
+  guint32 fourcc;
+  gint64 len;
+  GstFormat fmt = GST_FORMAT_BYTES;
+
+  if (!gst_pad_query_peer_duration (qtdemux->sinkpad, &fmt, &len)) {
+    GST_DEBUG_OBJECT (qtdemux, "upstream size not available; "
+        "can not locate mfro");
+    goto exit;
+  }
+
+  ret = gst_qtdemux_pull_atom (qtdemux, len - 16, 16, &mfro);
+  if (ret != GST_FLOW_OK)
+    goto exit;
+
+  fourcc = QT_FOURCC (GST_BUFFER_DATA (mfro) + 4);
+  if (fourcc != FOURCC_mfro)
+    goto exit;
+
+  GST_INFO_OBJECT (qtdemux, "Found mfro atom: fragmented mp4 container");
+  if (GST_BUFFER_SIZE (mfro) >= 16) {
+    GST_DEBUG_OBJECT (qtdemux, "parsing 'mfro' atom");
+    *mfro_size = QT_UINT32 (GST_BUFFER_DATA (mfro) + 12);
+    if (*mfro_size >= len) {
+      GST_WARNING_OBJECT (qtdemux, "mfro.size is invalid");
+      ret = GST_FLOW_ERROR;
+      goto exit;
+    }
+    *mfra_offset = len - *mfro_size;
+  }
+
+exit:
+  if (mfro)
+    gst_buffer_unref (mfro);
+
+  return ret;
+}
+
+static void
+qtdemux_parse_fragmented (GstQTDemux * qtdemux)
+{
+  GstFlowReturn ret;
+  guint32 mfra_size = 0;
+  guint64 mfra_offset = 0;
+
+  /* default */
+  qtdemux->fragmented = FALSE;
+
+  /* We check here if it is a fragmented mp4 container */
+  ret = qtdemux_parse_mfro (qtdemux, &mfra_offset, &mfra_size);
+  if (ret == GST_FLOW_OK && mfra_size != 0 && mfra_offset != 0) {
+    qtdemux->fragmented = TRUE;
+    GST_DEBUG_OBJECT (qtdemux,
+        "mfra atom expected at offset %" G_GUINT64_FORMAT, mfra_offset);
+    qtdemux->mfra_offset = mfra_offset;
+  }
+}
+#endif
+
+static GstFlowReturn
+gst_qtdemux_loop_state_header (GstQTDemux * qtdemux)
+{
+  guint64 length = 0;
+  guint32 fourcc = 0;
+  GstBuffer *buf = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+  guint64 cur_offset = qtdemux->offset;
+
+  ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, 16, &buf);
+  if (G_UNLIKELY (ret != GST_FLOW_OK))
+    goto beach;
+  if (G_LIKELY (GST_BUFFER_SIZE (buf) >= 8))
+    extract_initial_length_and_fourcc (GST_BUFFER_DATA (buf),
+        GST_BUFFER_SIZE (buf), &length, &fourcc);
+  gst_buffer_unref (buf);
+
+  /* maybe we already got most we needed, so only consider this eof */
+  if (G_UNLIKELY (length == 0)) {
+    GST_ELEMENT_WARNING (qtdemux, STREAM, DEMUX,
+        (_("Invalid atom size.")),
+        ("Header atom '%" GST_FOURCC_FORMAT "' has empty length",
+            GST_FOURCC_ARGS (fourcc)));
+    ret = GST_FLOW_UNEXPECTED;
+    goto beach;
+  }
+
+  switch (fourcc) {
+    case FOURCC_moof:
+      /* record for later parsing when needed */
+      if (!qtdemux->moof_offset) {
+        qtdemux->moof_offset = qtdemux->offset;
+      }
+      /* fall-through */
+    case FOURCC_mdat:
+    case FOURCC_free:
+    case FOURCC_wide:
+    case FOURCC_PICT:
+    case FOURCC_pnot:
+    {
+      GST_LOG_OBJECT (qtdemux,
+          "skipping atom '%" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT,
+          GST_FOURCC_ARGS (fourcc), cur_offset);
+      qtdemux->offset += length;
+      break;
+    }
+    case FOURCC_moov:
+    {
+      GstBuffer *moov;
+
+      if (qtdemux->got_moov) {
+        GST_DEBUG_OBJECT (qtdemux, "Skipping moov atom as we have one already");
+        qtdemux->offset += length;
+        goto beach;
+      }
+
+      ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, length, &moov);
+      if (ret != GST_FLOW_OK)
+        goto beach;
+      if (length != GST_BUFFER_SIZE (moov)) {
+        /* Some files have a 'moov' atom at the end of the file which contains
+         * a terminal 'free' atom where the body of the atom is missing.
+         * Check for, and permit, this special case.
+         */
+        if (GST_BUFFER_SIZE (moov) >= 8) {
+          guint8 *final_data = GST_BUFFER_DATA (moov) +
+              (GST_BUFFER_SIZE (moov) - 8);
+          guint32 final_length = QT_UINT32 (final_data);
+          guint32 final_fourcc = QT_FOURCC (final_data + 4);
+          if (final_fourcc == FOURCC_free &&
+              GST_BUFFER_SIZE (moov) + final_length - 8 == length) {
+            /* Ok, we've found that special case. Allocate a new buffer with
+             * that free atom actually present. */
+            GstBuffer *newmoov = gst_buffer_new_and_alloc (length);
+            gst_buffer_copy_metadata (newmoov, moov,
+                GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS |
+                GST_BUFFER_COPY_CAPS);
+            memcpy (GST_BUFFER_DATA (newmoov), GST_BUFFER_DATA (moov),
+                GST_BUFFER_SIZE (moov));
+            memset (GST_BUFFER_DATA (newmoov) + GST_BUFFER_SIZE (moov), 0,
+                final_length - 8);
+            gst_buffer_unref (moov);
+            moov = newmoov;
+          }
+        }
+      }
+
+      if (length != GST_BUFFER_SIZE (moov)) {
+        GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+            (_("This file is incomplete and cannot be played.")),
+            ("We got less than expected (received %u, wanted %u, offset %"
+                G_GUINT64_FORMAT ")",
+                GST_BUFFER_SIZE (moov), (guint) length, cur_offset));
+        ret = GST_FLOW_ERROR;
+        goto beach;
+      }
+      qtdemux->offset += length;
+
+      qtdemux_parse_moov (qtdemux, GST_BUFFER_DATA (moov), length);
+      qtdemux_node_dump (qtdemux, qtdemux->moov_node);
+
+      qtdemux_parse_tree (qtdemux);
+      g_node_destroy (qtdemux->moov_node);
+      gst_buffer_unref (moov);
+      qtdemux->moov_node = NULL;
+      qtdemux->got_moov = TRUE;
+
+      break;
+    }
+    case FOURCC_ftyp:
+    {
+      GstBuffer *ftyp;
+
+      /* extract major brand; might come in handy for ISO vs QT issues */
+      ret = gst_qtdemux_pull_atom (qtdemux, cur_offset, length, &ftyp);
+      if (ret != GST_FLOW_OK)
+        goto beach;
+      qtdemux->offset += length;
+      qtdemux_parse_ftyp (qtdemux, GST_BUFFER_DATA (ftyp),
+          GST_BUFFER_SIZE (ftyp));
+      gst_buffer_unref (ftyp);
+      break;
+    }
+    case FOURCC_uuid:
+    {
+      GstBuffer *uuid;
+
+      /* uuid are extension atoms */
+      ret = gst_qtdemux_pull_atom (qtdemux, cur_offset, length, &uuid);
+      if (ret != GST_FLOW_OK)
+        goto beach;
+      qtdemux->offset += length;
+      qtdemux_parse_uuid (qtdemux, GST_BUFFER_DATA (uuid),
+          GST_BUFFER_SIZE (uuid));
+      gst_buffer_unref (uuid);
+      break;
+    }
+    default:
+    {
+      GstBuffer *unknown;
+
+      GST_LOG_OBJECT (qtdemux,
+          "unknown %08x '%" GST_FOURCC_FORMAT "' of size %" G_GUINT64_FORMAT
+          " at %" G_GUINT64_FORMAT, fourcc, GST_FOURCC_ARGS (fourcc), length,
+          cur_offset);
+      ret = gst_qtdemux_pull_atom (qtdemux, cur_offset, length, &unknown);
+      if (ret != GST_FLOW_OK)
+        goto beach;
+      GST_MEMDUMP ("Unknown tag", GST_BUFFER_DATA (unknown),
+          GST_BUFFER_SIZE (unknown));
+      gst_buffer_unref (unknown);
+      qtdemux->offset += length;
+      break;
+    }
+  }
+
+beach:
+  if (ret == GST_FLOW_UNEXPECTED && qtdemux->got_moov) {
+    /* digested all data, show what we have */
+    ret = qtdemux_expose_streams (qtdemux);
+
+    /* Only post, event on pads is done after newsegment */
+    qtdemux_post_global_tags (qtdemux);
+
+    qtdemux->state = QTDEMUX_STATE_MOVIE;
+    GST_DEBUG_OBJECT (qtdemux, "switching state to STATE_MOVIE (%d)",
+        qtdemux->state);
+    return ret;
+  }
+  return ret;
+}
+
+/* Seeks to the previous keyframe of the indexed stream and
+ * aligns other streams with respect to the keyframe timestamp
+ * of indexed stream. Only called in case of Reverse Playback
+ */
+static GstFlowReturn
+gst_qtdemux_seek_to_previous_keyframe (GstQTDemux * qtdemux)
+{
+  guint8 n = 0;
+  guint32 seg_idx = 0, k_index = 0;
+  guint32 ref_seg_idx, ref_k_index;
+  guint64 k_pos = 0, last_stop = 0;
+  QtDemuxSegment *seg = NULL;
+  QtDemuxStream *ref_str = NULL;
+  guint64 seg_media_start_mov;  /* segment media start time in mov format */
+
+  /* Now we choose an arbitrary stream, get the previous keyframe timestamp
+   * and finally align all the other streams on that timestamp with their
+   * respective keyframes */
+  for (n = 0; n < qtdemux->n_streams; n++) {
+    QtDemuxStream *str = qtdemux->streams[n];
+
+    seg_idx = gst_qtdemux_find_segment (qtdemux, str,
+        qtdemux->segment.last_stop);
+
+    /* segment not found, continue with normal flow */
+    if (seg_idx == -1)
+      continue;
+
+    /* No candidate yet, take that one */
+    if (!ref_str) {
+      ref_str = str;
+      continue;
+    }
+
+    /* So that stream has a segment, we prefer video streams */
+    if (str->subtype == FOURCC_vide) {
+      ref_str = str;
+      break;
+    }
+  }
+
+  if (G_UNLIKELY (!ref_str)) {
+    GST_DEBUG_OBJECT (qtdemux, "couldn't find any stream");
+    goto eos;
+  }
+
+  if (G_UNLIKELY (!ref_str->from_sample)) {
+    GST_DEBUG_OBJECT (qtdemux, "reached the beginning of the file");
+    goto eos;
+  }
+
+  /* So that stream has been playing from from_sample to to_sample. We will
+   * get the timestamp of the previous sample and search for a keyframe before
+   * that. For audio streams we do an arbitrary jump in the past (10 samples) */
+  if (ref_str->subtype == FOURCC_vide) {
+    k_index = gst_qtdemux_find_keyframe (qtdemux, ref_str,
+        ref_str->from_sample - 1);
+  } else {
+    if (ref_str->from_sample >= 10)
+      k_index = ref_str->from_sample - 10;
+    else
+      k_index = 0;
+  }
+
+  /* get current segment for that stream */
+  seg = &ref_str->segments[ref_str->segment_index];
+  /* convert seg->media_start to mov format time for timestamp comparison */
+  seg_media_start_mov =
+      gst_util_uint64_scale (seg->media_start, ref_str->timescale, GST_SECOND);
+  /* Crawl back through segments to find the one containing this I frame */
+  while (ref_str->samples[k_index].timestamp < seg_media_start_mov) {
+    GST_DEBUG_OBJECT (qtdemux, "keyframe position is out of segment %u",
+        ref_str->segment_index);
+    if (G_UNLIKELY (!ref_str->segment_index)) {
+      /* Reached first segment, let's consider it's EOS */
+      goto eos;
+    }
+    ref_str->segment_index--;
+    seg = &ref_str->segments[ref_str->segment_index];
+    /* convert seg->media_start to mov format time for timestamp comparison */
+    seg_media_start_mov =
+        gst_util_uint64_scale (seg->media_start, ref_str->timescale,
+        GST_SECOND);
+  }
+  /* Calculate time position of the keyframe and where we should stop */
+  k_pos =
+      (gst_util_uint64_scale (ref_str->samples[k_index].timestamp, GST_SECOND,
+          ref_str->timescale) - seg->media_start) + seg->time;
+  last_stop =
+      gst_util_uint64_scale (ref_str->samples[ref_str->from_sample].timestamp,
+      GST_SECOND, ref_str->timescale);
+  last_stop = (last_stop - seg->media_start) + seg->time;
+
+  GST_DEBUG_OBJECT (qtdemux, "preferred stream played from sample %u, "
+      "now going to sample %u (pts %" GST_TIME_FORMAT ")", ref_str->from_sample,
+      k_index, GST_TIME_ARGS (k_pos));
+
+  /* Set last_stop with the keyframe timestamp we pushed of that stream */
+  gst_segment_set_last_stop (&qtdemux->segment, GST_FORMAT_TIME, last_stop);
+  GST_DEBUG_OBJECT (qtdemux, "last_stop now is %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (last_stop));
+
+  if (G_UNLIKELY (last_stop < qtdemux->segment.start)) {
+    GST_DEBUG_OBJECT (qtdemux, "reached the beginning of segment");
+    goto eos;
+  }
+
+  ref_seg_idx = ref_str->segment_index;
+  ref_k_index = k_index;
+
+  /* Align them all on this */
+  for (n = 0; n < qtdemux->n_streams; n++) {
+    guint32 index = 0;
+    guint64 media_start = 0, seg_time = 0;
+    QtDemuxStream *str = qtdemux->streams[n];
+
+    /* aligning reference stream again might lead to backing up to yet another
+     * keyframe (due to timestamp rounding issues),
+     * potentially putting more load on downstream; so let's try to avoid */
+    if (str == ref_str) {
+      seg_idx = ref_seg_idx;
+      seg = &str->segments[seg_idx];
+      k_index = ref_k_index;
+      GST_DEBUG_OBJECT (qtdemux, "reference stream segment %d, "
+          "sample at index %d", ref_str->segment_index, k_index);
+    } else {
+      seg_idx = gst_qtdemux_find_segment (qtdemux, str, k_pos);
+      GST_DEBUG_OBJECT (qtdemux, "align segment %d", seg_idx);
+
+      /* segment not found, continue with normal flow */
+      if (seg_idx == -1)
+        continue;
+
+      /* get segment and time in the segment */
+      seg = &str->segments[seg_idx];
+      seg_time = k_pos - seg->time;
+
+      /* get the media time in the segment */
+      media_start = seg->media_start + seg_time;
+
+      /* get the index of the sample with media time */
+      index = gst_qtdemux_find_index_linear (qtdemux, str, media_start);
+      GST_DEBUG_OBJECT (qtdemux, "sample for %" GST_TIME_FORMAT " at %u",
+          GST_TIME_ARGS (media_start), index);
+
+      /* find previous keyframe */
+      k_index = gst_qtdemux_find_keyframe (qtdemux, str, index);
+    }
+
+    /* Remember until where we want to go */
+    str->to_sample = str->from_sample - 1;
+    /* Define our time position */
+    str->time_position =
+        (gst_util_uint64_scale (str->samples[k_index].timestamp, GST_SECOND,
+            str->timescale) - seg->media_start) + seg->time;
+    /* Now seek back in time */
+    gst_qtdemux_move_stream (qtdemux, str, k_index);
+    GST_DEBUG_OBJECT (qtdemux, "keyframe at %u, time position %"
+        GST_TIME_FORMAT " playing from sample %u to %u", k_index,
+        GST_TIME_ARGS (str->time_position), str->from_sample, str->to_sample);
+  }
+
+  return GST_FLOW_OK;
+
+eos:
+  return GST_FLOW_UNEXPECTED;
+}
+
+/* activate the given segment number @seg_idx of @stream at time @offset.
+ * @offset is an absolute global position over all the segments.
+ *
+ * This will push out a NEWSEGMENT event with the right values and
+ * position the stream index to the first decodable sample before
+ * @offset.
+ */
+static gboolean
+gst_qtdemux_activate_segment (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint32 seg_idx, guint64 offset)
+{
+  GstEvent *event;
+  QtDemuxSegment *segment;
+  guint32 index, kf_index;
+  guint64 seg_time;
+  guint64 start, stop, time;
+  gdouble rate;
+
+  GST_LOG_OBJECT (qtdemux, "activate segment %d, offset %" G_GUINT64_FORMAT,
+      seg_idx, offset);
+
+  /* update the current segment */
+  stream->segment_index = seg_idx;
+
+  /* get the segment */
+  segment = &stream->segments[seg_idx];
+
+  if (G_UNLIKELY (offset < segment->time)) {
+    GST_WARNING_OBJECT (qtdemux, "offset < segment->time %" G_GUINT64_FORMAT,
+        segment->time);
+    return FALSE;
+  }
+
+  /* segment lies beyond total indicated duration */
+  if (G_UNLIKELY (qtdemux->segment.duration != -1 &&
+          segment->time > qtdemux->segment.duration)) {
+    GST_WARNING_OBJECT (qtdemux, "file duration %" G_GINT64_FORMAT
+        " < segment->time %" G_GUINT64_FORMAT, qtdemux->segment.duration,
+        segment->time);
+    return FALSE;
+  }
+
+  /* get time in this segment */
+  seg_time = offset - segment->time;
+
+  GST_LOG_OBJECT (qtdemux, "seg_time %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (seg_time));
+
+  if (G_UNLIKELY (seg_time > segment->duration)) {
+    GST_LOG_OBJECT (qtdemux, "seg_time > segment->duration %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (segment->duration));
+    return FALSE;
+  }
+
+  /* qtdemux->segment.stop is in outside-time-realm, whereas
+   * segment->media_stop is in track-time-realm.
+   *
+   * In order to compare the two, we need to bring segment.stop
+   * into the track-time-realm */
+
+  stop = qtdemux->segment.stop;
+  if (stop == -1)
+    stop = qtdemux->segment.duration;
+  if (stop == -1)
+    stop = segment->media_stop;
+  else
+    stop =
+        MIN (segment->media_stop, stop - segment->time + segment->media_start);
+
+  if (qtdemux->segment.rate >= 0) {
+    start = MIN (segment->media_start + seg_time, stop);
+    time = offset;
+  } else {
+    if (segment->media_start >= qtdemux->segment.start) {
+      start = segment->media_start;
+      time = segment->time;
+    } else {
+      start = qtdemux->segment.start;
+      time = segment->time + (qtdemux->segment.start - segment->media_start);
+    }
+
+    start = MAX (segment->media_start, qtdemux->segment.start);
+    stop = MIN (segment->media_start + seg_time, stop);
+  }
+
+  GST_DEBUG_OBJECT (qtdemux, "newsegment %d from %" GST_TIME_FORMAT
+      " to %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT, seg_idx,
+      GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (time));
+
+  /* combine global rate with that of the segment */
+  rate = segment->rate * qtdemux->segment.rate;
+
+  /* update the segment values used for clipping */
+  gst_segment_init (&stream->segment, GST_FORMAT_TIME);
+  gst_segment_set_newsegment (&stream->segment, FALSE, rate, GST_FORMAT_TIME,
+      start, stop, time);
+
+  /* now prepare and send the segment */
+  if (stream->pad) {
+    event = gst_event_new_new_segment (FALSE, rate, GST_FORMAT_TIME,
+        start, stop, time);
+    gst_pad_push_event (stream->pad, event);
+    /* assume we can send more data now */
+    stream->last_ret = GST_FLOW_OK;
+    /* clear to send tags on this pad now */
+    gst_qtdemux_push_tags (qtdemux, stream);
+  }
+
+  /* and move to the keyframe before the indicated media time of the
+   * segment */
+  if (qtdemux->segment.rate >= 0) {
+    index = gst_qtdemux_find_index_linear (qtdemux, stream, start);
+    stream->to_sample = G_MAXUINT32;
+    GST_DEBUG_OBJECT (qtdemux, "moving data pointer to %" GST_TIME_FORMAT
+        ", index: %u, pts %" GST_TIME_FORMAT, GST_TIME_ARGS (start), index,
+        GST_TIME_ARGS (gst_util_uint64_scale (stream->samples[index].timestamp,
+                GST_SECOND, stream->timescale)));
+  } else {
+    index = gst_qtdemux_find_index_linear (qtdemux, stream, stop);
+    stream->to_sample = index;
+    GST_DEBUG_OBJECT (qtdemux, "moving data pointer to %" GST_TIME_FORMAT
+        ", index: %u, pts %" GST_TIME_FORMAT, GST_TIME_ARGS (stop), index,
+        GST_TIME_ARGS (gst_util_uint64_scale (stream->samples[index].timestamp,
+                GST_SECOND, stream->timescale)));
+  }
+
+  /* gst_qtdemux_parse_sample () called from gst_qtdemux_find_index_linear ()
+   * encountered an error and printed a message so we return appropriately */
+  if (index == -1)
+    return FALSE;
+
+  /* we're at the right spot */
+  if (index == stream->sample_index) {
+    GST_DEBUG_OBJECT (qtdemux, "we are at the right index");
+    return TRUE;
+  }
+
+  /* find keyframe of the target index */
+  kf_index = gst_qtdemux_find_keyframe (qtdemux, stream, index);
+
+/* *INDENT-OFF* */
+/* indent does stupid stuff with stream->samples[].timestamp */
+
+  /* if we move forwards, we don't have to go back to the previous
+   * keyframe since we already sent that. We can also just jump to
+   * the keyframe right before the target index if there is one. */
+  if (index > stream->sample_index) {
+    /* moving forwards check if we move past a keyframe */
+    if (kf_index > stream->sample_index) {
+      GST_DEBUG_OBJECT (qtdemux,
+          "moving forwards to keyframe at %u (pts %" GST_TIME_FORMAT, kf_index,
+          GST_TIME_ARGS (gst_util_uint64_scale (
+                  stream->samples[kf_index].timestamp,
+                  GST_SECOND, stream->timescale)));
+      gst_qtdemux_move_stream (qtdemux, stream, kf_index);
+    } else {
+      GST_DEBUG_OBJECT (qtdemux,
+          "moving forwards, keyframe at %u (pts %" GST_TIME_FORMAT
+          " already sent", kf_index,
+          GST_TIME_ARGS (gst_util_uint64_scale (
+                  stream->samples[kf_index].timestamp,
+                  GST_SECOND, stream->timescale)));
+    }
+  } else {
+    GST_DEBUG_OBJECT (qtdemux,
+        "moving backwards to keyframe at %u (pts %" GST_TIME_FORMAT, kf_index,
+        GST_TIME_ARGS (gst_util_uint64_scale (
+                stream->samples[kf_index].timestamp,
+                GST_SECOND, stream->timescale)));
+    gst_qtdemux_move_stream (qtdemux, stream, kf_index);
+  }
+
+/* *INDENT-ON* */
+
+  return TRUE;
+}
+
+/* prepare to get the current sample of @stream, getting essential values.
+ *
+ * This function will also prepare and send the segment when needed.
+ *
+ * Return FALSE if the stream is EOS.
+ */
+static gboolean
+gst_qtdemux_prepare_current_sample (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, guint64 * offset, guint * size, guint64 * timestamp,
+    guint64 * duration, gboolean * keyframe)
+{
+  QtDemuxSample *sample;
+  guint64 time_position;
+  guint32 seg_idx;
+
+  g_return_val_if_fail (stream != NULL, FALSE);
+
+  time_position = stream->time_position;
+  if (G_UNLIKELY (time_position == -1))
+    goto eos;
+
+  seg_idx = stream->segment_index;
+  if (G_UNLIKELY (seg_idx == -1)) {
+    /* find segment corresponding to time_position if we are looking
+     * for a segment. */
+    seg_idx = gst_qtdemux_find_segment (qtdemux, stream, time_position);
+
+    /* nothing found, we're really eos */
+    if (seg_idx == -1)
+      goto eos;
+  }
+
+  /* different segment, activate it, sample_index will be set. */
+  if (G_UNLIKELY (stream->segment_index != seg_idx))
+    gst_qtdemux_activate_segment (qtdemux, stream, seg_idx, time_position);
+
+  GST_LOG_OBJECT (qtdemux, "segment active, index = %u of %u",
+      stream->sample_index, stream->n_samples);
+
+  if (G_UNLIKELY (stream->sample_index >= stream->n_samples))
+    goto eos;
+
+  if (!qtdemux_parse_samples (qtdemux, stream, stream->sample_index)) {
+    GST_LOG_OBJECT (qtdemux, "Parsing of index %u failed!",
+        stream->sample_index);
+    return FALSE;
+  }
+
+  /* now get the info for the sample we're at */
+  sample = &stream->samples[stream->sample_index];
+
+  *timestamp = QTSAMPLE_PTS (stream, sample);
+  *offset = sample->offset;
+  *size = sample->size;
+  *duration = QTSAMPLE_DUR_PTS (stream, sample, *timestamp);
+  *keyframe = QTSAMPLE_KEYFRAME (stream, sample);
+
+  return TRUE;
+
+  /* special cases */
+eos:
+  {
+    stream->time_position = -1;
+    return FALSE;
+  }
+}
+
+/* move to the next sample in @stream.
+ *
+ * Moves to the next segment when needed.
+ */
+static void
+gst_qtdemux_advance_sample (GstQTDemux * qtdemux, QtDemuxStream * stream)
+{
+  QtDemuxSample *sample;
+  QtDemuxSegment *segment;
+
+  if (G_UNLIKELY (stream->sample_index >= stream->to_sample)) {
+    /* Mark the stream as EOS */
+    GST_DEBUG_OBJECT (qtdemux,
+        "reached max allowed sample %u, mark EOS", stream->to_sample);
+    stream->time_position = -1;
+    return;
+  }
+
+  /* move to next sample */
+  stream->sample_index++;
+
+  /* get current segment */
+  segment = &stream->segments[stream->segment_index];
+
+  /* reached the last sample, we need the next segment */
+  if (G_UNLIKELY (stream->sample_index >= stream->n_samples))
+    goto next_segment;
+
+  if (!qtdemux_parse_samples (qtdemux, stream, stream->sample_index)) {
+    GST_LOG_OBJECT (qtdemux, "Parsing of index %u failed!",
+        stream->sample_index);
+    return;
+  }
+
+  /* get next sample */
+  sample = &stream->samples[stream->sample_index];
+
+  /* see if we are past the segment */
+  if (G_UNLIKELY (gst_util_uint64_scale (sample->timestamp,
+              GST_SECOND, stream->timescale) >= segment->media_stop))
+    goto next_segment;
+
+  if (gst_util_uint64_scale (sample->timestamp, GST_SECOND,
+          stream->timescale) >= segment->media_start) {
+    /* inside the segment, update time_position, looks very familiar to
+     * GStreamer segments, doesn't it? */
+    stream->time_position =
+        (gst_util_uint64_scale (sample->timestamp, GST_SECOND,
+            stream->timescale) - segment->media_start) + segment->time;
+  } else {
+    /* not yet in segment, time does not yet increment. This means
+     * that we are still prerolling keyframes to the decoder so it can
+     * decode the first sample of the segment. */
+    stream->time_position = segment->time;
+  }
+  return;
+
+  /* move to the next segment */
+next_segment:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "segment %d ended ", stream->segment_index);
+
+    if (stream->segment_index == stream->n_segments - 1) {
+      /* are we at the end of the last segment, we're EOS */
+      stream->time_position = -1;
+    } else {
+      /* else we're only at the end of the current segment */
+      stream->time_position = segment->stop_time;
+    }
+    /* make sure we select a new segment */
+    stream->segment_index = -1;
+  }
+}
+
+static void
+gst_qtdemux_sync_streams (GstQTDemux * demux)
+{
+  gint i;
+
+  if (demux->n_streams <= 1)
+    return;
+
+  for (i = 0; i < demux->n_streams; i++) {
+    QtDemuxStream *stream;
+    GstClockTime end_time;
+
+    stream = demux->streams[i];
+
+    if (!stream->pad)
+      continue;
+
+    /* TODO advance time on subtitle streams here, if any some day */
+
+    /* some clips/trailers may have unbalanced streams at the end,
+     * so send EOS on shorter stream to prevent stalling others */
+
+    /* do not mess with EOS if SEGMENT seeking */
+    if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT)
+      continue;
+
+    if (demux->pullbased) {
+      /* loop mode is sample time based */
+      if (stream->time_position != -1)
+        continue;
+    } else {
+      /* push mode is byte position based */
+      if (stream->n_samples &&
+          stream->samples[stream->n_samples - 1].offset >= demux->offset)
+        continue;
+    }
+
+    if (stream->sent_eos)
+      continue;
+
+    /* only act if some gap */
+    end_time = stream->segments[stream->n_segments - 1].stop_time;
+    GST_LOG_OBJECT (demux, "current position: %" GST_TIME_FORMAT
+        ", stream end: %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (demux->segment.last_stop), GST_TIME_ARGS (end_time));
+    if (end_time + 2 * GST_SECOND < demux->segment.last_stop) {
+      GST_DEBUG_OBJECT (demux, "sending EOS for stream %s",
+          GST_PAD_NAME (stream->pad));
+      stream->sent_eos = TRUE;
+      gst_pad_push_event (stream->pad, gst_event_new_eos ());
+    }
+  }
+}
+
+/* UNEXPECTED and NOT_LINKED need to be combined. This means that we return:
+ *
+ *  GST_FLOW_NOT_LINKED: when all pads NOT_LINKED.
+ *  GST_FLOW_UNEXPECTED: when all pads UNEXPECTED or NOT_LINKED.
+ */
+static GstFlowReturn
+gst_qtdemux_combine_flows (GstQTDemux * demux, QtDemuxStream * stream,
+    GstFlowReturn ret)
+{
+  gint i;
+  gboolean unexpected = FALSE, not_linked = TRUE;
+
+  GST_LOG_OBJECT (demux, "flow return: %s", gst_flow_get_name (ret));
+
+  /* store the value */
+  stream->last_ret = ret;
+
+  /* any other error that is not-linked or eos can be returned right away */
+  if (G_LIKELY (ret != GST_FLOW_UNEXPECTED && ret != GST_FLOW_NOT_LINKED))
+    goto done;
+
+  /* only return NOT_LINKED if all other pads returned NOT_LINKED */
+  for (i = 0; i < demux->n_streams; i++) {
+    QtDemuxStream *ostream = demux->streams[i];
+
+    ret = ostream->last_ret;
+
+    /* no unexpected or unlinked, return */
+    if (G_LIKELY (ret != GST_FLOW_UNEXPECTED && ret != GST_FLOW_NOT_LINKED))
+      goto done;
+
+    /* we check to see if we have at least 1 unexpected or all unlinked */
+    unexpected |= (ret == GST_FLOW_UNEXPECTED);
+    not_linked &= (ret == GST_FLOW_NOT_LINKED);
+  }
+
+  /* when we get here, we all have unlinked or unexpected */
+  if (not_linked)
+    ret = GST_FLOW_NOT_LINKED;
+  else if (unexpected)
+    ret = GST_FLOW_UNEXPECTED;
+done:
+  GST_LOG_OBJECT (demux, "combined flow return: %s", gst_flow_get_name (ret));
+  return ret;
+}
+
+/* the input buffer metadata must be writable. Returns NULL when the buffer is
+ * completely cliped */
+static GstBuffer *
+gst_qtdemux_clip_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    GstBuffer * buf)
+{
+  gint64 start, stop, cstart, cstop, diff;
+  GstClockTime timestamp = GST_CLOCK_TIME_NONE, duration = GST_CLOCK_TIME_NONE;
+  guint8 *data;
+  guint size;
+  gint num_rate, denom_rate;
+  gint frame_size;
+  gboolean clip_data;
+
+  data = GST_BUFFER_DATA (buf);
+  size = GST_BUFFER_SIZE (buf);
+
+  /* depending on the type, setup the clip parameters */
+  if (stream->subtype == FOURCC_soun) {
+    frame_size = stream->bytes_per_frame;
+    num_rate = GST_SECOND;
+    denom_rate = (gint) stream->rate;
+    clip_data = TRUE;
+  } else if (stream->subtype == FOURCC_vide) {
+    frame_size = size;
+    num_rate = stream->fps_n;
+    denom_rate = stream->fps_d;
+    clip_data = FALSE;
+  } else
+    goto wrong_type;
+
+  /* we can only clip if we have a valid timestamp */
+  timestamp = GST_BUFFER_TIMESTAMP (buf);
+  if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (timestamp)))
+    goto no_timestamp;
+
+  if (G_LIKELY (GST_BUFFER_DURATION_IS_VALID (buf))) {
+    duration = GST_BUFFER_DURATION (buf);
+  } else {
+    duration =
+        gst_util_uint64_scale_int (size / frame_size, num_rate, denom_rate);
+  }
+
+  start = timestamp;
+  stop = start + duration;
+
+  if (G_UNLIKELY (!gst_segment_clip (&stream->segment,
+              GST_FORMAT_TIME, start, stop, &cstart, &cstop)))
+    goto clipped;
+
+  /* see if some clipping happened */
+  diff = cstart - start;
+  if (diff > 0) {
+    timestamp = cstart;
+    duration -= diff;
+
+    if (clip_data) {
+      /* bring clipped time to samples and to bytes */
+      diff = gst_util_uint64_scale_int (diff, denom_rate, num_rate);
+      diff *= frame_size;
+
+      GST_DEBUG_OBJECT (qtdemux,
+          "clipping start to %" GST_TIME_FORMAT " %"
+          G_GUINT64_FORMAT " bytes", GST_TIME_ARGS (cstart), diff);
+
+      data += diff;
+      size -= diff;
+    }
+  }
+  diff = stop - cstop;
+  if (diff > 0) {
+    duration -= diff;
+
+    if (clip_data) {
+      /* bring clipped time to samples and then to bytes */
+      diff = gst_util_uint64_scale_int (diff, denom_rate, num_rate);
+      diff *= frame_size;
+      GST_DEBUG_OBJECT (qtdemux,
+          "clipping stop to %" GST_TIME_FORMAT " %" G_GUINT64_FORMAT
+          " bytes", GST_TIME_ARGS (cstop), diff);
+      size -= diff;
+    }
+  }
+
+  GST_BUFFER_TIMESTAMP (buf) = timestamp;
+  GST_BUFFER_DURATION (buf) = duration;
+  GST_BUFFER_SIZE (buf) = size;
+  GST_BUFFER_DATA (buf) = data;
+
+  return buf;
+
+  /* dropped buffer */
+wrong_type:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "unknown stream type");
+    return buf;
+  }
+no_timestamp:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "no timestamp on buffer");
+    return buf;
+  }
+clipped:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "clipped buffer");
+    gst_buffer_unref (buf);
+    return NULL;
+  }
+}
+
+/* the input buffer metadata must be writable,
+ * but time/duration etc not yet set and need not be preserved */
+static GstBuffer *
+gst_qtdemux_process_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    GstBuffer * buf)
+{
+  guint8 *data;
+  guint size, nsize = 0;
+  gchar *str;
+
+  data = GST_BUFFER_DATA (buf);
+  size = GST_BUFFER_SIZE (buf);
+
+  /* not many cases for now */
+  if (G_UNLIKELY (stream->fourcc == FOURCC_mp4s)) {
+    /* send a one time dvd clut event */
+    if (stream->pending_event && stream->pad)
+      gst_pad_push_event (stream->pad, stream->pending_event);
+    stream->pending_event = NULL;
+    /* no further processing needed */
+    stream->need_process = FALSE;
+  }
+
+  if (G_UNLIKELY (stream->subtype != FOURCC_text)) {
+    return buf;
+  }
+
+  if (G_LIKELY (size >= 2)) {
+    nsize = GST_READ_UINT16_BE (data);
+    nsize = MIN (nsize, size - 2);
+  }
+
+  GST_LOG_OBJECT (qtdemux, "3GPP timed text subtitle: %d/%d", nsize, size);
+
+  /* takes care of UTF-8 validation or UTF-16 recognition,
+   * no other encoding expected */
+  str = gst_tag_freeform_string_to_utf8 ((gchar *) data + 2, nsize, NULL);
+  if (str) {
+    gst_buffer_unref (buf);
+    buf = gst_buffer_new ();
+    GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = (guint8 *) str;
+    GST_BUFFER_SIZE (buf) = strlen (str);
+  } else {
+    /* may be 0-size subtitle, which is also sent to keep pipeline going */
+    GST_BUFFER_DATA (buf) = data + 2;
+    GST_BUFFER_SIZE (buf) = nsize;
+  }
+
+  /* FIXME ? convert optional subsequent style info to markup */
+
+  return buf;
+}
+
+/* Sets a buffer's attributes properly and pushes it downstream.
+ * Also checks for additional actions and custom processing that may
+ * need to be done first.
+ */
+static gboolean
+gst_qtdemux_decorate_and_push_buffer (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, GstBuffer * buf,
+    guint64 timestamp, guint64 duration, gboolean keyframe, guint64 position,
+    guint64 byte_position)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  if (G_UNLIKELY (stream->fourcc == FOURCC_rtsp)) {
+    gchar *url;
+
+    url = g_strndup ((gchar *) GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
+    if (url != NULL && strlen (url) != 0) {
+      /* we have RTSP redirect now */
+      gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
+          gst_message_new_element (GST_OBJECT_CAST (qtdemux),
+              gst_structure_new ("redirect",
+                  "new-location", G_TYPE_STRING, url, NULL)));
+      qtdemux->posted_redirect = TRUE;
+    } else {
+      GST_WARNING_OBJECT (qtdemux, "Redirect URI of stream is empty, not "
+          "posting");
+    }
+    g_free (url);
+  }
+
+  /* position reporting */
+  if (qtdemux->segment.rate >= 0) {
+    gst_segment_set_last_stop (&qtdemux->segment, GST_FORMAT_TIME, position);
+    gst_qtdemux_sync_streams (qtdemux);
+  }
+
+  if (G_UNLIKELY (!stream->pad)) {
+    GST_DEBUG_OBJECT (qtdemux, "No output pad for stream, ignoring");
+    gst_buffer_unref (buf);
+    goto exit;
+  }
+
+  /* send out pending buffers */
+  while (stream->buffers) {
+    GstBuffer *buffer = (GstBuffer *) stream->buffers->data;
+
+    if (G_UNLIKELY (stream->discont)) {
+      GST_LOG_OBJECT (qtdemux, "marking discont buffer");
+      GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+      stream->discont = FALSE;
+    }
+    gst_buffer_set_caps (buffer, stream->caps);
+
+    gst_pad_push (stream->pad, buffer);
+
+    stream->buffers = g_slist_delete_link (stream->buffers, stream->buffers);
+  }
+
+  /* we're going to modify the metadata */
+  buf = gst_buffer_make_metadata_writable (buf);
+
+  if (G_UNLIKELY (stream->need_process))
+    buf = gst_qtdemux_process_buffer (qtdemux, stream, buf);
+
+  GST_BUFFER_TIMESTAMP (buf) = timestamp;
+  GST_BUFFER_DURATION (buf) = duration;
+  GST_BUFFER_OFFSET (buf) = -1;
+  GST_BUFFER_OFFSET_END (buf) = -1;
+
+  if (G_UNLIKELY (stream->padding)) {
+    GST_BUFFER_DATA (buf) += stream->padding;
+    GST_BUFFER_SIZE (buf) -= stream->padding;
+  }
+
+  if (G_UNLIKELY (qtdemux->element_index)) {
+    GstClockTime stream_time;
+
+    stream_time =
+        gst_segment_to_stream_time (&stream->segment, GST_FORMAT_TIME,
+        timestamp);
+    if (GST_CLOCK_TIME_IS_VALID (stream_time)) {
+      GST_LOG_OBJECT (qtdemux,
+          "adding association %" GST_TIME_FORMAT "-> %"
+          G_GUINT64_FORMAT, GST_TIME_ARGS (stream_time), byte_position);
+      gst_index_add_association (qtdemux->element_index,
+          qtdemux->index_id,
+          keyframe ? GST_ASSOCIATION_FLAG_KEY_UNIT :
+          GST_ASSOCIATION_FLAG_DELTA_UNIT, GST_FORMAT_TIME, stream_time,
+          GST_FORMAT_BYTES, byte_position, NULL);
+    }
+  }
+
+  if (stream->need_clip)
+    buf = gst_qtdemux_clip_buffer (qtdemux, stream, buf);
+
+  if (G_UNLIKELY (buf == NULL))
+    goto exit;
+
+  if (G_UNLIKELY (stream->discont)) {
+    GST_LOG_OBJECT (qtdemux, "marking discont buffer");
+    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
+    stream->discont = FALSE;
+  }
+
+  if (!keyframe)
+    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
+
+  gst_buffer_set_caps (buf, stream->caps);
+
+  GST_LOG_OBJECT (qtdemux,
+      "Pushing buffer with time %" GST_TIME_FORMAT ", duration %"
+      GST_TIME_FORMAT " on pad %s", GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
+      GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_PAD_NAME (stream->pad));
+
+  ret = gst_pad_push (stream->pad, buf);
+
+exit:
+  return ret;
+}
+
+static GstFlowReturn
+gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *buf = NULL;
+  QtDemuxStream *stream;
+  guint64 min_time;
+  guint64 offset = 0;
+  guint64 timestamp = GST_CLOCK_TIME_NONE;
+  guint64 duration = 0;
+  gboolean keyframe = FALSE;
+  guint size = 0;
+  gint index;
+  gint i;
+
+  gst_qtdemux_push_pending_newsegment (qtdemux);
+
+  /* Figure out the next stream sample to output, min_time is expressed in
+   * global time and runs over the edit list segments. */
+  min_time = G_MAXUINT64;
+  index = -1;
+  for (i = 0; i < qtdemux->n_streams; i++) {
+    guint64 position;
+
+    stream = qtdemux->streams[i];
+    position = stream->time_position;
+
+    /* position of -1 is EOS */
+    if (position != -1 && position < min_time) {
+      min_time = position;
+      index = i;
+    }
+  }
+  /* all are EOS */
+  if (G_UNLIKELY (index == -1)) {
+    GST_DEBUG_OBJECT (qtdemux, "all streams are EOS");
+    goto eos;
+  }
+
+  /* check for segment end */
+  if (G_UNLIKELY (qtdemux->segment.stop != -1
+          && qtdemux->segment.stop < min_time)) {
+    GST_DEBUG_OBJECT (qtdemux, "we reached the end of our segment.");
+    goto eos;
+  }
+
+  stream = qtdemux->streams[index];
+
+  /* fetch info for the current sample of this stream */
+  if (G_UNLIKELY (!gst_qtdemux_prepare_current_sample (qtdemux, stream, &offset,
+              &size, &timestamp, &duration, &keyframe)))
+    goto eos_stream;
+
+  GST_LOG_OBJECT (qtdemux,
+      "pushing from stream %d, offset %" G_GUINT64_FORMAT
+      ", size %d, timestamp=%" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT,
+      index, offset, size, GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration));
+
+  /* hmm, empty sample, skip and move to next sample */
+  if (G_UNLIKELY (size <= 0))
+    goto next;
+
+  /* last pushed sample was out of boundary, goto next sample */
+  if (G_UNLIKELY (stream->last_ret == GST_FLOW_UNEXPECTED))
+    goto next;
+
+  GST_LOG_OBJECT (qtdemux, "reading %d bytes @ %" G_GUINT64_FORMAT, size,
+      offset);
+
+  ret = gst_qtdemux_pull_atom (qtdemux, offset, size, &buf);
+  if (G_UNLIKELY (ret != GST_FLOW_OK))
+    goto beach;
+
+  ret = gst_qtdemux_decorate_and_push_buffer (qtdemux, stream, buf,
+      timestamp, duration, keyframe, min_time, offset);
+
+  /* combine flows */
+  ret = gst_qtdemux_combine_flows (qtdemux, stream, ret);
+  /* ignore unlinked, we will not push on the pad anymore and we will EOS when
+   * we have no more data for the pad to push */
+  if (ret == GST_FLOW_UNEXPECTED)
+    ret = GST_FLOW_OK;
+
+next:
+  gst_qtdemux_advance_sample (qtdemux, stream);
+
+beach:
+  return ret;
+
+  /* special cases */
+eos:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "No samples left for any streams - EOS");
+    ret = GST_FLOW_UNEXPECTED;
+    goto beach;
+  }
+eos_stream:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "No samples left for stream");
+    /* EOS will be raised if all are EOS */
+    ret = GST_FLOW_OK;
+    goto beach;
+  }
+}
+
+static void
+gst_qtdemux_loop (GstPad * pad)
+{
+  GstQTDemux *qtdemux;
+  guint64 cur_offset;
+  GstFlowReturn ret;
+
+  qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
+
+  cur_offset = qtdemux->offset;
+  GST_LOG_OBJECT (qtdemux, "loop at position %" G_GUINT64_FORMAT ", state %d",
+      cur_offset, qtdemux->state);
+
+  switch (qtdemux->state) {
+    case QTDEMUX_STATE_INITIAL:
+    case QTDEMUX_STATE_HEADER:
+      ret = gst_qtdemux_loop_state_header (qtdemux);
+      break;
+    case QTDEMUX_STATE_MOVIE:
+      ret = gst_qtdemux_loop_state_movie (qtdemux);
+      if (qtdemux->segment.rate < 0 && ret == GST_FLOW_UNEXPECTED) {
+        ret = gst_qtdemux_seek_to_previous_keyframe (qtdemux);
+      }
+      break;
+    default:
+      /* ouch */
+      goto invalid_state;
+  }
+
+  /* if something went wrong, pause */
+  if (ret != GST_FLOW_OK)
+    goto pause;
+
+done:
+  gst_object_unref (qtdemux);
+  return;
+
+  /* ERRORS */
+invalid_state:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, FAILED,
+        (NULL), ("streaming stopped, invalid state"));
+    qtdemux->segment_running = FALSE;
+    gst_pad_pause_task (pad);
+    gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
+    goto done;
+  }
+pause:
+  {
+    const gchar *reason = gst_flow_get_name (ret);
+
+    GST_LOG_OBJECT (qtdemux, "pausing task, reason %s", reason);
+
+    qtdemux->segment_running = FALSE;
+    gst_pad_pause_task (pad);
+
+    /* fatal errors need special actions */
+    /* check EOS */
+    if (ret == GST_FLOW_UNEXPECTED) {
+      if (qtdemux->n_streams == 0) {
+        /* we have no streams, post an error */
+        gst_qtdemux_post_no_playable_stream_error (qtdemux);
+      }
+      if (qtdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
+        gint64 stop;
+
+        /* FIXME: I am not sure this is the right fix. If the sinks are
+         * supposed to detect the segment is complete and accumulate
+         * automatically, it does not seem to work here. Need more work */
+        qtdemux->segment_running = TRUE;
+
+        if ((stop = qtdemux->segment.stop) == -1)
+          stop = qtdemux->segment.duration;
+
+        if (qtdemux->segment.rate >= 0) {
+          GST_LOG_OBJECT (qtdemux, "Sending segment done, at end of segment");
+          gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
+              gst_message_new_segment_done (GST_OBJECT_CAST (qtdemux),
+                  GST_FORMAT_TIME, stop));
+        } else {
+          /*  For Reverse Playback */
+          GST_LOG_OBJECT (qtdemux, "Sending segment done, at start of segment");
+          gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
+              gst_message_new_segment_done (GST_OBJECT_CAST (qtdemux),
+                  GST_FORMAT_TIME, qtdemux->segment.start));
+        }
+      } else {
+        GST_LOG_OBJECT (qtdemux, "Sending EOS at end of segment");
+        gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
+      }
+    } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_UNEXPECTED) {
+      GST_ELEMENT_ERROR (qtdemux, STREAM, FAILED,
+          (NULL), ("streaming stopped, reason %s", reason));
+      gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
+    }
+    goto done;
+  }
+}
+
+/*
+ * next_entry_size
+ *
+ * Returns the size of the first entry at the current offset.
+ * If -1, there are none (which means EOS or empty file).
+ */
+static guint64
+next_entry_size (GstQTDemux * demux)
+{
+  QtDemuxStream *stream;
+  int i;
+  int smallidx = -1;
+  guint64 smalloffs = (guint64) - 1;
+  QtDemuxSample *sample;
+
+  GST_LOG_OBJECT (demux, "Finding entry at offset %" G_GUINT64_FORMAT,
+      demux->offset);
+
+  for (i = 0; i < demux->n_streams; i++) {
+    stream = demux->streams[i];
+
+    if (stream->sample_index == -1)
+      stream->sample_index = 0;
+
+    if (stream->sample_index >= stream->n_samples) {
+      GST_LOG_OBJECT (demux, "stream %d samples exhausted", i);
+      continue;
+    }
+
+    if (!qtdemux_parse_samples (demux, stream, stream->sample_index)) {
+      GST_LOG_OBJECT (demux, "Parsing of index %u from stbl atom failed!",
+          stream->sample_index);
+      return -1;
+    }
+
+    sample = &stream->samples[stream->sample_index];
+
+    GST_LOG_OBJECT (demux,
+        "Checking Stream %d (sample_index:%d / offset:%" G_GUINT64_FORMAT
+        " / size:%" G_GUINT32_FORMAT ")", i, stream->sample_index,
+        sample->offset, sample->size);
+
+    if (((smalloffs == -1)
+            || (sample->offset < smalloffs)) && (sample->size)) {
+      smallidx = i;
+      smalloffs = sample->offset;
+    }
+  }
+
+  GST_LOG_OBJECT (demux,
+      "stream %d offset %" G_GUINT64_FORMAT " demux->offset :%"
+      G_GUINT64_FORMAT, smallidx, smalloffs, demux->offset);
+
+  if (smallidx == -1)
+    return -1;
+
+  stream = demux->streams[smallidx];
+  sample = &stream->samples[stream->sample_index];
+
+  if (sample->offset >= demux->offset) {
+    demux->todrop = sample->offset - demux->offset;
+    return sample->size + demux->todrop;
+  }
+
+  GST_DEBUG_OBJECT (demux,
+      "There wasn't any entry at offset %" G_GUINT64_FORMAT, demux->offset);
+  return -1;
+}
+
+static void
+gst_qtdemux_post_progress (GstQTDemux * demux, gint num, gint denom)
+{
+  gint perc = (gint) ((gdouble) num * 100.0 / (gdouble) denom);
+
+  gst_element_post_message (GST_ELEMENT_CAST (demux),
+      gst_message_new_element (GST_OBJECT_CAST (demux),
+          gst_structure_new ("progress", "percent", G_TYPE_INT, perc, NULL)));
+}
+
+static gboolean
+qtdemux_seek_offset (GstQTDemux * demux, guint64 offset)
+{
+  GstEvent *event;
+  gboolean res = 0;
+
+  GST_DEBUG_OBJECT (demux, "Seeking to %" G_GUINT64_FORMAT, offset);
+
+  event =
+      gst_event_new_seek (1.0, GST_FORMAT_BYTES,
+      GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE, GST_SEEK_TYPE_SET, offset,
+      GST_SEEK_TYPE_NONE, -1);
+
+  res = gst_pad_push_event (demux->sinkpad, event);
+
+  return res;
+}
+
+/* FIXME, unverified after edit list updates */
+static GstFlowReturn
+gst_qtdemux_chain (GstPad * sinkpad, GstBuffer * inbuf)
+{
+  GstQTDemux *demux;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  demux = GST_QTDEMUX (gst_pad_get_parent (sinkpad));
+
+  gst_adapter_push (demux->adapter, inbuf);
+
+  /* we never really mean to buffer that much */
+  if (demux->neededbytes == -1)
+    goto eos;
+
+  GST_DEBUG_OBJECT (demux, "pushing in inbuf %p, neededbytes:%u, available:%u",
+      inbuf, demux->neededbytes, gst_adapter_available (demux->adapter));
+
+  while (((gst_adapter_available (demux->adapter)) >= demux->neededbytes) &&
+      (ret == GST_FLOW_OK)) {
+
+    GST_DEBUG_OBJECT (demux,
+        "state:%d , demux->neededbytes:%d, demux->offset:%" G_GUINT64_FORMAT,
+        demux->state, demux->neededbytes, demux->offset);
+
+    switch (demux->state) {
+      case QTDEMUX_STATE_INITIAL:{
+        const guint8 *data;
+        guint32 fourcc;
+        guint64 size;
+
+        data = gst_adapter_peek (demux->adapter, demux->neededbytes);
+
+        /* get fourcc/length, set neededbytes */
+        extract_initial_length_and_fourcc ((guint8 *) data, demux->neededbytes,
+            &size, &fourcc);
+        GST_DEBUG_OBJECT (demux, "Peeking found [%" GST_FOURCC_FORMAT "] "
+            "size: %" G_GUINT64_FORMAT, GST_FOURCC_ARGS (fourcc), size);
+        if (size == 0) {
+          GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
+              (_("This file is invalid and cannot be played.")),
+              ("initial atom '%" GST_FOURCC_FORMAT "' has empty length",
+                  GST_FOURCC_ARGS (fourcc)));
+          ret = GST_FLOW_ERROR;
+          break;
+        }
+        if (fourcc == FOURCC_mdat) {
+          if (demux->n_streams > 0) {
+            /* we have the headers, start playback */
+            demux->state = QTDEMUX_STATE_MOVIE;
+            demux->neededbytes = next_entry_size (demux);
+            demux->mdatleft = size;
+
+            /* Only post, event on pads is done after newsegment */
+            qtdemux_post_global_tags (demux);
+
+          } else {
+            /* no headers yet, try to get them */
+            guint bs;
+            gboolean res;
+            guint64 old, target;
+
+          buffer_data:
+            old = demux->offset;
+            target = old + size;
+
+            /* try to jump over the atom with a seek */
+            res = qtdemux_seek_offset (demux, target);
+
+            if (res) {
+              GST_DEBUG_OBJECT (demux, "seek success");
+              /* remember the offset fo the first mdat so we can seek back to it
+               * after we have the headers */
+              if (fourcc == FOURCC_mdat && demux->first_mdat == -1) {
+                demux->first_mdat = old;
+                GST_DEBUG_OBJECT (demux, "first mdat at %" G_GUINT64_FORMAT,
+                    demux->first_mdat);
+              }
+              /* seek worked, continue reading */
+              demux->offset = target;
+              demux->neededbytes = 16;
+              demux->state = QTDEMUX_STATE_INITIAL;
+            } else {
+              /* seek failed, need to buffer */
+              demux->offset = old;
+              GST_DEBUG_OBJECT (demux, "seek failed");
+              /* there may be multiple mdat (or alike) buffers */
+              /* sanity check */
+              if (demux->mdatbuffer)
+                bs = GST_BUFFER_SIZE (demux->mdatbuffer);
+              else
+                bs = 0;
+              if (size + bs > 10 * (1 << 20))
+                goto no_moov;
+              demux->state = QTDEMUX_STATE_BUFFER_MDAT;
+              demux->neededbytes = size;
+              if (!demux->mdatbuffer)
+                demux->mdatoffset = demux->offset;
+            }
+          }
+        } else if (G_UNLIKELY (size > QTDEMUX_MAX_ATOM_SIZE)) {
+          GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
+              (_("This file is invalid and cannot be played.")),
+              ("atom %" GST_FOURCC_FORMAT " has bogus size %" G_GUINT64_FORMAT,
+                  GST_FOURCC_ARGS (fourcc), size));
+          ret = GST_FLOW_ERROR;
+          break;
+        } else {
+          /* this means we already started buffering and still no moov header,
+           * let's continue buffering everything till we get moov */
+          if (demux->mdatbuffer && (fourcc != FOURCC_moov))
+            goto buffer_data;
+          demux->neededbytes = size;
+          demux->state = QTDEMUX_STATE_HEADER;
+        }
+        break;
+      }
+      case QTDEMUX_STATE_HEADER:{
+        const guint8 *data;
+        guint32 fourcc;
+
+        GST_DEBUG_OBJECT (demux, "In header");
+
+        data = gst_adapter_peek (demux->adapter, demux->neededbytes);
+
+        /* parse the header */
+        extract_initial_length_and_fourcc (data, demux->neededbytes, NULL,
+            &fourcc);
+        if (fourcc == FOURCC_moov) {
+          GST_DEBUG_OBJECT (demux, "Parsing [moov]");
+
+          demux->got_moov = TRUE;
+
+          /* prepare newsegment to send when streaming actually starts */
+          if (!demux->pending_newsegment) {
+            demux->pending_newsegment =
+                gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME,
+                0, GST_CLOCK_TIME_NONE, 0);
+          }
+
+          qtdemux_parse_moov (demux, data, demux->neededbytes);
+          qtdemux_node_dump (demux, demux->moov_node);
+          qtdemux_parse_tree (demux);
+          qtdemux_expose_streams (demux);
+
+          g_node_destroy (demux->moov_node);
+          demux->moov_node = NULL;
+          GST_DEBUG_OBJECT (demux, "Finished parsing the header");
+        } else if (fourcc == FOURCC_moof) {
+          if (demux->got_moov && demux->fragmented) {
+            GST_DEBUG_OBJECT (demux, "Parsing [moof]");
+            if (!qtdemux_parse_moof (demux, data, demux->neededbytes,
+                    demux->offset, NULL)) {
+              ret = GST_FLOW_ERROR;
+              goto done;
+            }
+          } else {
+            GST_DEBUG_OBJECT (demux, "Discarding [moof]");
+          }
+        } else if (fourcc == FOURCC_ftyp) {
+          GST_DEBUG_OBJECT (demux, "Parsing [ftyp]");
+          qtdemux_parse_ftyp (demux, data, demux->neededbytes);
+        } else if (fourcc == FOURCC_uuid) {
+          GST_DEBUG_OBJECT (demux, "Parsing [uuid]");
+          qtdemux_parse_uuid (demux, data, demux->neededbytes);
+        } else {
+          GST_WARNING_OBJECT (demux,
+              "Unknown fourcc while parsing header : %" GST_FOURCC_FORMAT,
+              GST_FOURCC_ARGS (fourcc));
+          /* Let's jump that one and go back to initial state */
+        }
+
+        if (demux->mdatbuffer && demux->n_streams) {
+          /* the mdat was before the header */
+          GST_DEBUG_OBJECT (demux, "We have n_streams:%d and mdatbuffer:%p",
+              demux->n_streams, demux->mdatbuffer);
+          /* restore our adapter/offset view of things with upstream;
+           * put preceding buffered data ahead of current moov data.
+           * This should also handle evil mdat, moov, mdat cases and alike */
+          gst_adapter_clear (demux->adapter);
+          demux->mdatbuffer = NULL;
+          demux->offset = demux->mdatoffset;
+          demux->neededbytes = next_entry_size (demux);
+          demux->state = QTDEMUX_STATE_MOVIE;
+          demux->mdatleft = gst_adapter_available (demux->adapter);
+
+          /* Only post, event on pads is done after newsegment */
+          qtdemux_post_global_tags (demux);
+
+        } else {
+          GST_DEBUG_OBJECT (demux, "Carrying on normally");
+          gst_adapter_flush (demux->adapter, demux->neededbytes);
+
+          if (demux->got_moov && demux->first_mdat != -1) {
+            gboolean res;
+
+            /* we need to seek back */
+            res = qtdemux_seek_offset (demux, demux->first_mdat);
+            if (res) {
+              demux->offset = demux->first_mdat;
+            } else {
+              GST_DEBUG_OBJECT (demux, "Seek back failed");
+            }
+          } else {
+            demux->offset += demux->neededbytes;
+          }
+          demux->neededbytes = 16;
+          demux->state = QTDEMUX_STATE_INITIAL;
+        }
+
+        break;
+      }
+      case QTDEMUX_STATE_BUFFER_MDAT:{
+        GstBuffer *buf;
+
+        GST_DEBUG_OBJECT (demux, "Got our buffer at offset %" G_GUINT64_FORMAT,
+            demux->offset);
+        buf = gst_adapter_take_buffer (demux->adapter, demux->neededbytes);
+        GST_DEBUG_OBJECT (demux, "mdatbuffer starts with %" GST_FOURCC_FORMAT,
+            GST_FOURCC_ARGS (QT_FOURCC (GST_BUFFER_DATA (buf) + 4)));
+        if (demux->mdatbuffer)
+          demux->mdatbuffer = gst_buffer_join (demux->mdatbuffer, buf);
+        else
+          demux->mdatbuffer = buf;
+        demux->offset += demux->neededbytes;
+        demux->neededbytes = 16;
+        demux->state = QTDEMUX_STATE_INITIAL;
+        gst_qtdemux_post_progress (demux, 1, 1);
+
+        break;
+      }
+      case QTDEMUX_STATE_MOVIE:{
+        GstBuffer *outbuf;
+        QtDemuxStream *stream = NULL;
+        QtDemuxSample *sample;
+        int i = -1;
+        guint64 timestamp, duration, position;
+        gboolean keyframe;
+
+        GST_DEBUG_OBJECT (demux,
+            "BEGIN // in MOVIE for offset %" G_GUINT64_FORMAT, demux->offset);
+
+        if (demux->fragmented) {
+          GST_DEBUG_OBJECT (demux, "mdat remaining %" G_GUINT64_FORMAT,
+              demux->mdatleft);
+          if (G_LIKELY (demux->todrop < demux->mdatleft)) {
+            /* if needed data starts within this atom,
+             * then it should not exceed this atom */
+            if (G_UNLIKELY (demux->neededbytes > demux->mdatleft)) {
+              GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
+                  (_("This file is invalid and cannot be played.")),
+                  ("sample data crosses atom boundary"));
+              ret = GST_FLOW_ERROR;
+              break;
+            }
+            demux->mdatleft -= demux->neededbytes;
+          } else {
+            GST_DEBUG_OBJECT (demux, "data atom emptied; resuming atom scan");
+            /* so we are dropping more than left in this atom */
+            demux->todrop -= demux->mdatleft;
+            demux->neededbytes -= demux->mdatleft;
+            demux->mdatleft = 0;
+            /* need to resume atom parsing so we do not miss any other pieces */
+            demux->state = QTDEMUX_STATE_INITIAL;
+            demux->neededbytes = 16;
+            break;
+          }
+        }
+
+        if (demux->todrop) {
+          GST_LOG_OBJECT (demux, "Dropping %d bytes", demux->todrop);
+          gst_adapter_flush (demux->adapter, demux->todrop);
+          demux->neededbytes -= demux->todrop;
+          demux->offset += demux->todrop;
+        }
+
+        /* first buffer? */
+        /* initial newsegment sent here after having added pads,
+         * possible others in sink_event */
+        if (G_UNLIKELY (demux->pending_newsegment)) {
+          gst_qtdemux_push_event (demux, demux->pending_newsegment);
+          demux->pending_newsegment = NULL;
+          /* clear to send tags on all streams */
+          for (i = 0; i < demux->n_streams; i++) {
+            gst_qtdemux_push_tags (demux, demux->streams[i]);
+          }
+        }
+
+        /* Figure out which stream this is packet belongs to */
+        for (i = 0; i < demux->n_streams; i++) {
+          stream = demux->streams[i];
+          if (stream->sample_index >= stream->n_samples)
+            continue;
+          GST_LOG_OBJECT (demux,
+              "Checking stream %d (sample_index:%d / offset:%" G_GUINT64_FORMAT
+              " / size:%d)", i, stream->sample_index,
+              stream->samples[stream->sample_index].offset,
+              stream->samples[stream->sample_index].size);
+
+          if (stream->samples[stream->sample_index].offset == demux->offset)
+            break;
+        }
+
+        if (G_UNLIKELY (stream == NULL || i == demux->n_streams))
+          goto unknown_stream;
+
+        /* Put data in a buffer, set timestamps, caps, ... */
+        outbuf = gst_adapter_take_buffer (demux->adapter, demux->neededbytes);
+        GST_DEBUG_OBJECT (demux, "stream : %" GST_FOURCC_FORMAT,
+            GST_FOURCC_ARGS (stream->fourcc));
+
+        g_return_val_if_fail (outbuf != NULL, GST_FLOW_ERROR);
+
+        sample = &stream->samples[stream->sample_index];
+
+        position = QTSAMPLE_DTS (stream, sample);
+        timestamp = QTSAMPLE_PTS (stream, sample);
+        duration = QTSAMPLE_DUR_DTS (stream, sample, position);
+        keyframe = QTSAMPLE_KEYFRAME (stream, sample);
+
+        ret = gst_qtdemux_decorate_and_push_buffer (demux, stream, outbuf,
+            timestamp, duration, keyframe, position, demux->offset);
+
+        /* combine flows */
+        ret = gst_qtdemux_combine_flows (demux, stream, ret);
+
+        stream->sample_index++;
+
+        /* update current offset and figure out size of next buffer */
+        GST_LOG_OBJECT (demux, "increasing offset %" G_GUINT64_FORMAT " by %u",
+            demux->offset, demux->neededbytes);
+        demux->offset += demux->neededbytes;
+        GST_LOG_OBJECT (demux, "offset is now %" G_GUINT64_FORMAT,
+            demux->offset);
+
+        if ((demux->neededbytes = next_entry_size (demux)) == -1) {
+          if (demux->fragmented) {
+            GST_DEBUG_OBJECT (demux, "(temporarily) out of fragmented samples");
+            /* there may be more to follow, only finish this atom */
+            demux->todrop = demux->mdatleft;
+            demux->neededbytes = demux->todrop;
+            break;
+          }
+          goto eos;
+        }
+        break;
+      }
+      default:
+        goto invalid_state;
+    }
+  }
+
+  /* when buffering movie data, at least show user something is happening */
+  if (ret == GST_FLOW_OK && demux->state == QTDEMUX_STATE_BUFFER_MDAT &&
+      gst_adapter_available (demux->adapter) <= demux->neededbytes) {
+    gst_qtdemux_post_progress (demux, gst_adapter_available (demux->adapter),
+        demux->neededbytes);
+  }
+done:
+  gst_object_unref (demux);
+
+  return ret;
+
+  /* ERRORS */
+unknown_stream:
+  {
+    GST_ELEMENT_ERROR (demux, STREAM, FAILED, (NULL), ("unknown stream found"));
+    ret = GST_FLOW_ERROR;
+    goto done;
+  }
+eos:
+  {
+    GST_DEBUG_OBJECT (demux, "no next entry, EOS");
+    ret = GST_FLOW_UNEXPECTED;
+    goto done;
+  }
+invalid_state:
+  {
+    GST_ELEMENT_ERROR (demux, STREAM, FAILED,
+        (NULL), ("qtdemuxer invalid state %d", demux->state));
+    ret = GST_FLOW_ERROR;
+    goto done;
+  }
+no_moov:
+  {
+    GST_ELEMENT_ERROR (demux, STREAM, FAILED,
+        (NULL), ("no 'moov' atom within the first 10 MB"));
+    ret = GST_FLOW_ERROR;
+    goto done;
+  }
+}
+
+static gboolean
+qtdemux_sink_activate (GstPad * sinkpad)
+{
+  if (gst_pad_check_pull_range (sinkpad))
+    return gst_pad_activate_pull (sinkpad, TRUE);
+  else
+    return gst_pad_activate_push (sinkpad, TRUE);
+}
+
+static gboolean
+qtdemux_sink_activate_pull (GstPad * sinkpad, gboolean active)
+{
+  GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
+
+  if (active) {
+    demux->pullbased = TRUE;
+    demux->segment_running = TRUE;
+    return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_qtdemux_loop,
+        sinkpad);
+  } else {
+    demux->segment_running = FALSE;
+    return gst_pad_stop_task (sinkpad);
+  }
+}
+
+static gboolean
+qtdemux_sink_activate_push (GstPad * sinkpad, gboolean active)
+{
+  GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
+
+  demux->pullbased = FALSE;
+
+  return TRUE;
+}
+
+#ifdef HAVE_ZLIB
+static void *
+qtdemux_zalloc (void *opaque, unsigned int items, unsigned int size)
+{
+  return g_malloc (items * size);
+}
+
+static void
+qtdemux_zfree (void *opaque, void *addr)
+{
+  g_free (addr);
+}
+
+static void *
+qtdemux_inflate (void *z_buffer, guint z_length, guint length)
+{
+  guint8 *buffer;
+  z_stream *z;
+  int ret;
+
+  z = g_new0 (z_stream, 1);
+  z->zalloc = qtdemux_zalloc;
+  z->zfree = qtdemux_zfree;
+  z->opaque = NULL;
+
+  z->next_in = z_buffer;
+  z->avail_in = z_length;
+
+  buffer = (guint8 *) g_malloc (length);
+  ret = inflateInit (z);
+  while (z->avail_in > 0) {
+    if (z->avail_out == 0) {
+      length += 1024;
+      buffer = (guint8 *) g_realloc (buffer, length);
+      z->next_out = buffer + z->total_out;
+      z->avail_out = 1024;
+    }
+    ret = inflate (z, Z_SYNC_FLUSH);
+    if (ret != Z_OK)
+      break;
+  }
+  if (ret != Z_STREAM_END) {
+    g_warning ("inflate() returned %d", ret);
+  }
+
+  g_free (z);
+  return buffer;
+}
+#endif /* HAVE_ZLIB */
+
+static gboolean
+qtdemux_parse_moov (GstQTDemux * qtdemux, const guint8 * buffer, guint length)
+{
+  GNode *cmov;
+
+  qtdemux->moov_node = g_node_new ((guint8 *) buffer);
+
+  GST_DEBUG_OBJECT (qtdemux, "parsing 'moov' atom");
+  qtdemux_parse_node (qtdemux, qtdemux->moov_node, buffer, length);
+
+  cmov = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_cmov);
+  if (cmov) {
+    guint32 method;
+    GNode *dcom;
+    GNode *cmvd;
+
+    dcom = qtdemux_tree_get_child_by_type (cmov, FOURCC_dcom);
+    cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd);
+    if (dcom == NULL || cmvd == NULL)
+      goto invalid_compression;
+
+    method = QT_FOURCC ((guint8 *) dcom->data + 8);
+    switch (method) {
+#ifdef HAVE_ZLIB
+      case GST_MAKE_FOURCC ('z', 'l', 'i', 'b'):{
+        guint uncompressed_length;
+        guint compressed_length;
+        guint8 *buf;
+
+        uncompressed_length = QT_UINT32 ((guint8 *) cmvd->data + 8);
+        compressed_length = QT_UINT32 ((guint8 *) cmvd->data + 4) - 12;
+        GST_LOG ("length = %u", uncompressed_length);
+
+        buf =
+            (guint8 *) qtdemux_inflate ((guint8 *) cmvd->data + 12,
+            compressed_length, uncompressed_length);
+
+        qtdemux->moov_node_compressed = qtdemux->moov_node;
+        qtdemux->moov_node = g_node_new (buf);
+
+        qtdemux_parse_node (qtdemux, qtdemux->moov_node, buf,
+            uncompressed_length);
+        break;
+      }
+#endif /* HAVE_ZLIB */
+      default:
+        GST_WARNING_OBJECT (qtdemux, "unknown or unhandled header compression "
+            "type %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (method));
+        break;
+    }
+  }
+  return TRUE;
+
+  /* ERRORS */
+invalid_compression:
+  {
+    GST_ERROR_OBJECT (qtdemux, "invalid compressed header");
+    return FALSE;
+  }
+}
+
+static gboolean
+qtdemux_parse_container (GstQTDemux * qtdemux, GNode * node, const guint8 * buf,
+    const guint8 * end)
+{
+  while (G_UNLIKELY (buf < end)) {
+    GNode *child;
+    guint32 len;
+
+    if (G_UNLIKELY (buf + 4 > end)) {
+      GST_LOG_OBJECT (qtdemux, "buffer overrun");
+      break;
+    }
+    len = QT_UINT32 (buf);
+    if (G_UNLIKELY (len == 0)) {
+      GST_LOG_OBJECT (qtdemux, "empty container");
+      break;
+    }
+    if (G_UNLIKELY (len < 8)) {
+      GST_WARNING_OBJECT (qtdemux, "length too short (%d < 8)", len);
+      break;
+    }
+    if (G_UNLIKELY (len > (end - buf))) {
+      GST_WARNING_OBJECT (qtdemux, "length too long (%d > %d)", len,
+          (gint) (end - buf));
+      break;
+    }
+
+    child = g_node_new ((guint8 *) buf);
+    g_node_append (node, child);
+    GST_LOG_OBJECT (qtdemux, "adding new node of len %d", len);
+    qtdemux_parse_node (qtdemux, child, buf, len);
+
+    buf += len;
+  }
+  return TRUE;
+}
+
+static gboolean
+qtdemux_parse_theora_extension (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    GNode * xdxt)
+{
+  int len = QT_UINT32 (xdxt->data);
+  guint8 *buf = xdxt->data;
+  guint8 *end = buf + len;
+  GstBuffer *buffer;
+
+  /* skip size and type */
+  buf += 8;
+  end -= 8;
+
+  while (buf < end) {
+    gint size;
+    guint32 type;
+
+    size = QT_UINT32 (buf);
+    type = QT_FOURCC (buf + 4);
+
+    GST_LOG_OBJECT (qtdemux, "%p %p", buf, end);
+
+    if (buf + size > end || size <= 0)
+      break;
+
+    buf += 8;
+    size -= 8;
+
+    GST_WARNING_OBJECT (qtdemux, "have cookie %" GST_FOURCC_FORMAT,
+        GST_FOURCC_ARGS (type));
+
+    switch (type) {
+      case FOURCC_tCtH:
+        buffer = gst_buffer_new_and_alloc (size);
+        memcpy (GST_BUFFER_DATA (buffer), buf, size);
+        stream->buffers = g_slist_append (stream->buffers, buffer);
+        GST_LOG_OBJECT (qtdemux, "parsing theora header");
+        break;
+      case FOURCC_tCt_:
+        buffer = gst_buffer_new_and_alloc (size);
+        memcpy (GST_BUFFER_DATA (buffer), buf, size);
+        stream->buffers = g_slist_append (stream->buffers, buffer);
+        GST_LOG_OBJECT (qtdemux, "parsing theora comment");
+        break;
+      case FOURCC_tCtC:
+        buffer = gst_buffer_new_and_alloc (size);
+        memcpy (GST_BUFFER_DATA (buffer), buf, size);
+        stream->buffers = g_slist_append (stream->buffers, buffer);
+        GST_LOG_OBJECT (qtdemux, "parsing theora codebook");
+        break;
+      default:
+        GST_WARNING_OBJECT (qtdemux,
+            "unknown theora cookie %" GST_FOURCC_FORMAT,
+            GST_FOURCC_ARGS (type));
+        break;
+    }
+    buf += size;
+  }
+  return TRUE;
+}
+
+static gboolean
+qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node, const guint8 * buffer,
+    guint length)
+{
+  guint32 fourcc = 0;
+  guint32 node_length = 0;
+  const QtNodeType *type;
+  const guint8 *end;
+
+  GST_LOG_OBJECT (qtdemux, "qtdemux_parse buffer %p length %u", buffer, length);
+
+  if (G_UNLIKELY (length < 8))
+    goto not_enough_data;
+
+  node_length = QT_UINT32 (buffer);
+  fourcc = QT_FOURCC (buffer + 4);
+
+  /* ignore empty nodes */
+  if (G_UNLIKELY (fourcc == 0 || node_length == 8))
+    return TRUE;
+
+  type = qtdemux_type_get (fourcc);
+
+  end = buffer + length;
+
+  GST_LOG_OBJECT (qtdemux,
+      "parsing '%" GST_FOURCC_FORMAT "', length=%u, name '%s'",
+      GST_FOURCC_ARGS (fourcc), node_length, type->name);
+
+  if (node_length > length)
+    goto broken_atom_size;
+
+  if (type->flags & QT_FLAG_CONTAINER) {
+    qtdemux_parse_container (qtdemux, node, buffer + 8, end);
+  } else {
+    switch (fourcc) {
+      case FOURCC_stsd:
+      {
+        if (node_length < 20) {
+          GST_LOG_OBJECT (qtdemux, "skipping small stsd box");
+          break;
+        }
+        GST_DEBUG_OBJECT (qtdemux,
+            "parsing stsd (sample table, sample description) atom");
+        qtdemux_parse_container (qtdemux, node, buffer + 16, end);
+        break;
+      }
+      case FOURCC_mp4a:
+      case FOURCC_alac:
+      {
+        guint32 version;
+        guint32 offset;
+        guint min_size;
+
+        /* also read alac (or whatever) in stead of mp4a in the following,
+         * since a similar layout is used in other cases as well */
+        if (fourcc == FOURCC_mp4a)
+          min_size = 20;
+        else
+          min_size = 40;
+
+        /* There are two things we might encounter here: a true mp4a atom, and
+           an mp4a entry in an stsd atom. The latter is what we're interested
+           in, and it looks like an atom, but isn't really one. The true mp4a
+           atom is short, so we detect it based on length here. */
+        if (length < min_size) {
+          GST_LOG_OBJECT (qtdemux, "skipping small %" GST_FOURCC_FORMAT " box",
+              GST_FOURCC_ARGS (fourcc));
+          break;
+        }
+
+        /* 'version' here is the sound sample description version. Types 0 and
+           1 are documented in the QTFF reference, but type 2 is not: it's
+           described in Apple header files instead (struct SoundDescriptionV2
+           in Movies.h) */
+        version = QT_UINT16 (buffer + 16);
+
+        GST_DEBUG_OBJECT (qtdemux, "%" GST_FOURCC_FORMAT " version 0x%08x",
+            GST_FOURCC_ARGS (fourcc), version);
+
+        /* parse any esds descriptors */
+        switch (version) {
+          case 0:
+            offset = 0x24;
+            break;
+          case 1:
+            offset = 0x34;
+            break;
+          case 2:
+            offset = 0x48;
+            break;
+          default:
+            GST_WARNING_OBJECT (qtdemux,
+                "unhandled %" GST_FOURCC_FORMAT " version 0x%08x",
+                GST_FOURCC_ARGS (fourcc), version);
+            offset = 0;
+            break;
+        }
+        if (offset)
+          qtdemux_parse_container (qtdemux, node, buffer + offset, end);
+        break;
+      }
+      case FOURCC_mp4v:
+      case FOURCC_MP4V:
+      case FOURCC_fmp4:
+      case FOURCC_FMP4:
+      {
+        const guint8 *buf;
+        guint32 version;
+        int tlen;
+
+        GST_DEBUG_OBJECT (qtdemux, "parsing in %" GST_FOURCC_FORMAT,
+            GST_FOURCC_ARGS (fourcc));
+        version = QT_UINT32 (buffer + 16);
+        GST_DEBUG_OBJECT (qtdemux, "version %08x", version);
+        if (1 || version == 0x00000000) {
+          buf = buffer + 0x32;
+
+          /* FIXME Quicktime uses PASCAL string while
+           * the iso format uses C strings. Check the file
+           * type before attempting to parse the string here. */
+          tlen = QT_UINT8 (buf);
+          GST_DEBUG_OBJECT (qtdemux, "tlen = %d", tlen);
+          buf++;
+          GST_DEBUG_OBJECT (qtdemux, "string = %.*s", tlen, (char *) buf);
+          /* the string has a reserved space of 32 bytes so skip
+           * the remaining 31 */
+          buf += 31;
+          buf += 4;             /* and 4 bytes reserved */
+
+          GST_MEMDUMP_OBJECT (qtdemux, "mp4v", buf, end - buf);
+
+          qtdemux_parse_container (qtdemux, node, buf, end);
+        }
+        break;
+      }
+      case FOURCC_avc1:
+      {
+        GST_MEMDUMP_OBJECT (qtdemux, "avc1", buffer, end - buffer);
+        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
+        break;
+      }
+      case FOURCC_mjp2:
+      {
+        qtdemux_parse_container (qtdemux, node, buffer + 86, end);
+        break;
+      }
+      case FOURCC_meta:
+      {
+        GST_DEBUG_OBJECT (qtdemux, "parsing meta atom");
+        qtdemux_parse_container (qtdemux, node, buffer + 12, end);
+        break;
+      }
+      case FOURCC_XiTh:
+      {
+        guint32 version;
+        guint32 offset;
+
+        version = QT_UINT32 (buffer + 12);
+        GST_DEBUG_OBJECT (qtdemux, "parsing XiTh atom version 0x%08x", version);
+
+        switch (version) {
+          case 0x00000001:
+            offset = 0x62;
+            break;
+          default:
+            GST_DEBUG_OBJECT (qtdemux, "unknown version 0x%08x", version);
+            offset = 0;
+            break;
+        }
+        if (offset)
+          qtdemux_parse_container (qtdemux, node, buffer + offset, end);
+        break;
+      }
+      case FOURCC_in24:
+      {
+        qtdemux_parse_container (qtdemux, node, buffer + 0x34, end);
+        break;
+      }
+      default:
+        if (!strcmp (type->name, "unknown"))
+          GST_MEMDUMP ("Unknown tag", buffer + 4, end - buffer - 4);
+        break;
+    }
+  }
+  GST_LOG_OBJECT (qtdemux, "parsed '%" GST_FOURCC_FORMAT "'",
+      GST_FOURCC_ARGS (fourcc));
+  return TRUE;
+
+/* ERRORS */
+not_enough_data:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")),
+        ("Not enough data for an atom header, got only %u bytes", length));
+    return FALSE;
+  }
+broken_atom_size:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")),
+        ("Atom '%" GST_FOURCC_FORMAT "' has size of %u bytes, but we have only "
+            "%u bytes available.", GST_FOURCC_ARGS (fourcc), node_length,
+            length));
+    return FALSE;
+  }
+}
+
+static GNode *
+qtdemux_tree_get_child_by_type (GNode * node, guint32 fourcc)
+{
+  GNode *child;
+  guint8 *buffer;
+  guint32 child_fourcc;
+
+  for (child = g_node_first_child (node); child;
+      child = g_node_next_sibling (child)) {
+    buffer = (guint8 *) child->data;
+
+    child_fourcc = QT_FOURCC (buffer + 4);
+
+    if (G_UNLIKELY (child_fourcc == fourcc)) {
+      return child;
+    }
+  }
+  return NULL;
+}
+
+static GNode *
+qtdemux_tree_get_child_by_type_full (GNode * node, guint32 fourcc,
+    GstByteReader * parser)
+{
+  GNode *child;
+  guint8 *buffer;
+  guint32 child_fourcc, child_len;
+
+  for (child = g_node_first_child (node); child;
+      child = g_node_next_sibling (child)) {
+    buffer = (guint8 *) child->data;
+
+    child_len = QT_UINT32 (buffer);
+    child_fourcc = QT_FOURCC (buffer + 4);
+
+    if (G_UNLIKELY (child_fourcc == fourcc)) {
+      if (G_UNLIKELY (child_len < (4 + 4)))
+        return NULL;
+      /* FIXME: must verify if atom length < parent atom length */
+      gst_byte_reader_init (parser, buffer + (4 + 4), child_len - (4 + 4));
+      return child;
+    }
+  }
+  return NULL;
+}
+
+static GNode *
+qtdemux_tree_get_sibling_by_type_full (GNode * node, guint32 fourcc,
+    GstByteReader * parser)
+{
+  GNode *child;
+  guint8 *buffer;
+  guint32 child_fourcc, child_len;
+
+  for (child = g_node_next_sibling (node); child;
+      child = g_node_next_sibling (child)) {
+    buffer = (guint8 *) child->data;
+
+    child_fourcc = QT_FOURCC (buffer + 4);
+
+    if (child_fourcc == fourcc) {
+      if (parser) {
+        child_len = QT_UINT32 (buffer);
+        if (G_UNLIKELY (child_len < (4 + 4)))
+          return NULL;
+        /* FIXME: must verify if atom length < parent atom length */
+        gst_byte_reader_init (parser, buffer + (4 + 4), child_len - (4 + 4));
+      }
+      return child;
+    }
+  }
+  return NULL;
+}
+
+static GNode *
+qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc)
+{
+  return qtdemux_tree_get_sibling_by_type_full (node, fourcc, NULL);
+}
+
+static gboolean
+gst_qtdemux_add_stream (GstQTDemux * qtdemux,
+    QtDemuxStream * stream, GstTagList * list)
+{
+  /* consistent default for push based mode */
+  gst_segment_init (&stream->segment, GST_FORMAT_TIME);
+  gst_segment_set_newsegment (&stream->segment, FALSE, 1.0, GST_FORMAT_TIME,
+      0, GST_CLOCK_TIME_NONE, 0);
+
+  if (stream->subtype == FOURCC_vide) {
+    gchar *name = g_strdup_printf ("video_%02d", qtdemux->n_video_streams);
+
+    stream->pad =
+        gst_pad_new_from_static_template (&gst_qtdemux_videosrc_template, name);
+    g_free (name);
+
+    /* fps is calculated base on the duration of the first frames since
+     * qt does not have a fixed framerate. */
+    if ((stream->n_samples == 1) && (stream->min_duration == 0)) {
+      /* still frame */
+      stream->fps_n = 0;
+      stream->fps_d = 1;
+    } else {
+      stream->fps_n = stream->timescale;
+      if (stream->min_duration == 0)
+        stream->fps_d = 1;
+      else
+        stream->fps_d = stream->min_duration;
+    }
+
+    if (stream->caps) {
+      gboolean gray;
+      gint depth, palette_count;
+      const guint32 *palette_data = NULL;
+
+      gst_caps_set_simple (stream->caps,
+          "width", G_TYPE_INT, stream->width,
+          "height", G_TYPE_INT, stream->height,
+          "framerate", GST_TYPE_FRACTION, stream->fps_n, stream->fps_d, NULL);
+
+      /* calculate pixel-aspect-ratio using display width and height */
+      GST_DEBUG_OBJECT (qtdemux,
+          "video size %dx%d, target display size %dx%d", stream->width,
+          stream->height, stream->display_width, stream->display_height);
+
+      if (stream->display_width > 0 && stream->display_height > 0 &&
+          stream->width > 0 && stream->height > 0) {
+        gint n, d;
+
+        /* calculate the pixel aspect ratio using the display and pixel w/h */
+        n = stream->display_width * stream->height;
+        d = stream->display_height * stream->width;
+        if (n == d)
+          n = d = 1;
+        GST_DEBUG_OBJECT (qtdemux, "setting PAR to %d/%d", n, d);
+        gst_caps_set_simple (stream->caps, "pixel-aspect-ratio",
+            GST_TYPE_FRACTION, n, d, NULL);
+      }
+
+      /* qt file might have pasp atom */
+      if (stream->par_w > 0 && stream->par_h > 0) {
+        GST_DEBUG_OBJECT (qtdemux, "par %d:%d", stream->par_w, stream->par_h);
+        gst_caps_set_simple (stream->caps, "pixel-aspect-ratio",
+            GST_TYPE_FRACTION, stream->par_w, stream->par_h, NULL);
+      }
+
+      depth = stream->bits_per_sample;
+
+      /* more than 32 bits means grayscale */
+      gray = (depth > 32);
+      /* low 32 bits specify the depth  */
+      depth &= 0x1F;
+
+      /* different number of palette entries is determined by depth. */
+      palette_count = 0;
+      if ((depth == 1) || (depth == 2) || (depth == 4) || (depth == 8))
+        palette_count = (1 << depth);
+
+      switch (palette_count) {
+        case 0:
+          break;
+        case 2:
+          palette_data = ff_qt_default_palette_2;
+          break;
+        case 4:
+          palette_data = ff_qt_default_palette_4;
+          break;
+        case 16:
+          if (gray)
+            palette_data = ff_qt_grayscale_palette_16;
+          else
+            palette_data = ff_qt_default_palette_16;
+          break;
+        case 256:
+          if (gray)
+            palette_data = ff_qt_grayscale_palette_256;
+          else
+            palette_data = ff_qt_default_palette_256;
+          break;
+        default:
+          GST_ELEMENT_WARNING (qtdemux, STREAM, DEMUX,
+              (_("The video in this file might not play correctly.")),
+              ("unsupported palette depth %d", depth));
+          break;
+      }
+      if (palette_data) {
+        GstBuffer *palette;
+
+        /* make sure it's not writable. We leave MALLOCDATA to NULL so that we
+         * don't free any of the buffer data. */
+        palette = gst_buffer_new ();
+        GST_BUFFER_FLAG_SET (palette, GST_BUFFER_FLAG_READONLY);
+        GST_BUFFER_DATA (palette) = (guint8 *) palette_data;
+        GST_BUFFER_SIZE (palette) = sizeof (guint32) * palette_count;
+
+        gst_caps_set_simple (stream->caps, "palette_data",
+            GST_TYPE_BUFFER, palette, NULL);
+        gst_buffer_unref (palette);
+      } else if (palette_count != 0) {
+        GST_ELEMENT_WARNING (qtdemux, STREAM, NOT_IMPLEMENTED,
+            (NULL), ("Unsupported palette depth %d. Ignoring stream.", depth));
+
+        gst_object_unref (stream->pad);
+        stream->pad = NULL;
+      }
+    }
+    qtdemux->n_video_streams++;
+  } else if (stream->subtype == FOURCC_soun) {
+    gchar *name = g_strdup_printf ("audio_%02d", qtdemux->n_audio_streams);
+
+    stream->pad =
+        gst_pad_new_from_static_template (&gst_qtdemux_audiosrc_template, name);
+    g_free (name);
+    if (stream->caps) {
+      gst_caps_set_simple (stream->caps,
+          "rate", G_TYPE_INT, (int) stream->rate,
+          "channels", G_TYPE_INT, stream->n_channels, NULL);
+    }
+    qtdemux->n_audio_streams++;
+  } else if (stream->subtype == FOURCC_strm) {
+    GST_DEBUG_OBJECT (qtdemux, "stream type, not creating pad");
+  } else if (stream->subtype == FOURCC_subp || stream->subtype == FOURCC_text) {
+    gchar *name = g_strdup_printf ("subtitle_%02d", qtdemux->n_sub_streams);
+
+    stream->pad =
+        gst_pad_new_from_static_template (&gst_qtdemux_subsrc_template, name);
+    g_free (name);
+    qtdemux->n_sub_streams++;
+  } else {
+    GST_DEBUG_OBJECT (qtdemux, "unknown stream type");
+    goto done;
+  }
+
+  if (stream->pad) {
+    GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream;
+
+    gst_pad_use_fixed_caps (stream->pad);
+    gst_pad_set_event_function (stream->pad, gst_qtdemux_handle_src_event);
+    gst_pad_set_query_type_function (stream->pad,
+        gst_qtdemux_get_src_query_types);
+    gst_pad_set_query_function (stream->pad, gst_qtdemux_handle_src_query);
+
+    GST_DEBUG_OBJECT (qtdemux, "setting caps %" GST_PTR_FORMAT, stream->caps);
+    gst_pad_set_caps (stream->pad, stream->caps);
+
+    GST_DEBUG_OBJECT (qtdemux, "adding pad %s %p to qtdemux %p",
+        GST_OBJECT_NAME (stream->pad), stream->pad, qtdemux);
+    gst_pad_set_active (stream->pad, TRUE);
+    gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), stream->pad);
+    if (stream->pending_tags)
+      gst_tag_list_free (stream->pending_tags);
+    stream->pending_tags = list;
+    if (list) {
+      /* post now, send event on pad later */
+      GST_DEBUG_OBJECT (qtdemux, "Posting tags %" GST_PTR_FORMAT, list);
+      gst_element_post_message (GST_ELEMENT (qtdemux),
+          gst_message_new_tag_full (GST_OBJECT (qtdemux), stream->pad,
+              gst_tag_list_copy (list)));
+    }
+    /* global tags go on each pad anyway */
+    stream->send_global_tags = TRUE;
+  }
+done:
+  return TRUE;
+}
+
+/* find next atom with @fourcc starting at @offset */
+static GstFlowReturn
+qtdemux_find_atom (GstQTDemux * qtdemux, guint64 * offset,
+    guint64 * length, guint32 fourcc)
+{
+  GstFlowReturn ret;
+  guint32 lfourcc;
+  GstBuffer *buf;
+
+  GST_LOG_OBJECT (qtdemux, "finding fourcc %" GST_FOURCC_FORMAT " at offset %"
+      G_GUINT64_FORMAT, GST_FOURCC_ARGS (fourcc), *offset);
+
+  while (TRUE) {
+    ret = gst_pad_pull_range (qtdemux->sinkpad, *offset, 16, &buf);
+    if (G_UNLIKELY (ret != GST_FLOW_OK))
+      goto locate_failed;
+    if (G_LIKELY (GST_BUFFER_SIZE (buf) != 16)) {
+      /* likely EOF */
+      ret = GST_FLOW_UNEXPECTED;
+      gst_buffer_unref (buf);
+      goto locate_failed;
+    }
+    extract_initial_length_and_fourcc (GST_BUFFER_DATA (buf), 16, length,
+        &lfourcc);
+    gst_buffer_unref (buf);
+
+    if (G_UNLIKELY (*length == 0)) {
+      GST_DEBUG_OBJECT (qtdemux, "invalid length 0");
+      ret = GST_FLOW_ERROR;
+      goto locate_failed;
+    }
+
+    if (lfourcc == fourcc) {
+      GST_DEBUG_OBJECT (qtdemux, "found fourcc at offset %" G_GUINT64_FORMAT,
+          *offset);
+      break;
+    } else {
+      GST_LOG_OBJECT (qtdemux,
+          "skipping atom '%" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT,
+          GST_FOURCC_ARGS (fourcc), *offset);
+      *offset += *length;
+    }
+  }
+
+  return GST_FLOW_OK;
+
+locate_failed:
+  {
+    /* might simply have had last one */
+    GST_DEBUG_OBJECT (qtdemux, "fourcc not found");
+    return ret;
+  }
+}
+
+/* should only do something in pull mode */
+/* call with OBJECT lock */
+static GstFlowReturn
+qtdemux_add_fragmented_samples (GstQTDemux * qtdemux)
+{
+  guint64 length, offset;
+  GstBuffer *buf = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstFlowReturn res = TRUE;
+
+  offset = qtdemux->moof_offset;
+  GST_DEBUG_OBJECT (qtdemux, "next moof at offset %" G_GUINT64_FORMAT, offset);
+
+  if (!offset) {
+    GST_DEBUG_OBJECT (qtdemux, "no next moof");
+    return GST_FLOW_UNEXPECTED;
+  }
+
+  /* best not do pull etc with lock held */
+  GST_OBJECT_UNLOCK (qtdemux);
+
+  ret = qtdemux_find_atom (qtdemux, &offset, &length, FOURCC_moof);
+  if (ret != GST_FLOW_OK)
+    goto flow_failed;
+
+  ret = gst_qtdemux_pull_atom (qtdemux, offset, length, &buf);
+  if (G_UNLIKELY (ret != GST_FLOW_OK))
+    goto flow_failed;
+  if (!qtdemux_parse_moof (qtdemux, GST_BUFFER_DATA (buf),
+          GST_BUFFER_SIZE (buf), offset, NULL)) {
+    gst_buffer_unref (buf);
+    buf = NULL;
+    goto parse_failed;
+  }
+
+  gst_buffer_unref (buf);
+  buf = NULL;
+
+  offset += length;
+  /* look for next moof */
+  ret = qtdemux_find_atom (qtdemux, &offset, &length, FOURCC_moof);
+  if (G_UNLIKELY (ret != GST_FLOW_OK))
+    goto flow_failed;
+
+exit:
+  GST_OBJECT_LOCK (qtdemux);
+
+  qtdemux->moof_offset = offset;
+
+  return res;
+
+parse_failed:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "failed to parse moof");
+    offset = 0;
+    res = GST_FLOW_ERROR;
+    goto exit;
+  }
+flow_failed:
+  {
+    /* maybe upstream temporarily flushing */
+    if (ret != GST_FLOW_WRONG_STATE) {
+      GST_DEBUG_OBJECT (qtdemux, "no next moof");
+      offset = 0;
+    } else {
+      GST_DEBUG_OBJECT (qtdemux, "upstream WRONG_STATE");
+      /* resume at current position next time */
+    }
+    res = ret;
+    goto exit;
+  }
+}
+
+/* initialise bytereaders for stbl sub-atoms */
+static gboolean
+qtdemux_stbl_init (GstQTDemux * qtdemux, QtDemuxStream * stream, GNode * stbl)
+{
+  stream->stbl_index = -1;      /* no samples have yet been parsed */
+
+  /* time-to-sample atom */
+  if (!qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stts, &stream->stts))
+    goto corrupt_file;
+
+  /* copy atom data into a new buffer for later use */
+  stream->stts.data = g_memdup (stream->stts.data, stream->stts.size);
+
+  /* skip version + flags */
+  if (!gst_byte_reader_skip (&stream->stts, 1 + 3) ||
+      !gst_byte_reader_get_uint32_be (&stream->stts, &stream->n_sample_times))
+    goto corrupt_file;
+  GST_LOG_OBJECT (qtdemux, "%u timestamp blocks", stream->n_sample_times);
+
+  /* make sure there's enough data */
+  if (!qt_atom_parser_has_chunks (&stream->stts, stream->n_sample_times, 2 * 4))
+    goto corrupt_file;
+
+  /* sync sample atom */
+  stream->stps_present = FALSE;
+  if ((stream->stss_present =
+          ! !qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stss,
+              &stream->stss) ? TRUE : FALSE) == TRUE) {
+    /* copy atom data into a new buffer for later use */
+    stream->stss.data = g_memdup (stream->stss.data, stream->stss.size);
+
+    /* skip version + flags */
+    if (!gst_byte_reader_skip (&stream->stss, 1 + 3) ||
+        !gst_byte_reader_get_uint32_be (&stream->stss, &stream->n_sample_syncs))
+      goto corrupt_file;
+
+    if (stream->n_sample_syncs) {
+      /* make sure there's enough data */
+      if (!qt_atom_parser_has_chunks (&stream->stss, stream->n_sample_syncs, 4))
+        goto corrupt_file;
+    }
+
+    /* partial sync sample atom */
+    if ((stream->stps_present =
+            ! !qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stps,
+                &stream->stps) ? TRUE : FALSE) == TRUE) {
+      /* copy atom data into a new buffer for later use */
+      stream->stps.data = g_memdup (stream->stps.data, stream->stps.size);
+
+      /* skip version + flags */
+      if (!gst_byte_reader_skip (&stream->stps, 1 + 3) ||
+          !gst_byte_reader_get_uint32_be (&stream->stps,
+              &stream->n_sample_partial_syncs))
+        goto corrupt_file;
+
+      /* if there are no entries, the stss table contains the real
+       * sync samples */
+      if (stream->n_sample_partial_syncs) {
+        /* make sure there's enough data */
+        if (!qt_atom_parser_has_chunks (&stream->stps,
+                stream->n_sample_partial_syncs, 4))
+          goto corrupt_file;
+      }
+    }
+  }
+
+  /* sample size */
+  if (!qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stsz, &stream->stsz))
+    goto no_samples;
+
+  /* copy atom data into a new buffer for later use */
+  stream->stsz.data = g_memdup (stream->stsz.data, stream->stsz.size);
+
+  /* skip version + flags */
+  if (!gst_byte_reader_skip (&stream->stsz, 1 + 3) ||
+      !gst_byte_reader_get_uint32_be (&stream->stsz, &stream->sample_size))
+    goto corrupt_file;
+
+  if (!gst_byte_reader_get_uint32_be (&stream->stsz, &stream->n_samples))
+    goto corrupt_file;
+
+  if (!stream->n_samples)
+    goto no_samples;
+
+  /* sample-to-chunk atom */
+  if (!qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stsc, &stream->stsc))
+    goto corrupt_file;
+
+  /* copy atom data into a new buffer for later use */
+  stream->stsc.data = g_memdup (stream->stsc.data, stream->stsc.size);
+
+  /* skip version + flags */
+  if (!gst_byte_reader_skip (&stream->stsc, 1 + 3) ||
+      !gst_byte_reader_get_uint32_be (&stream->stsc,
+          &stream->n_samples_per_chunk))
+    goto corrupt_file;
+
+  GST_DEBUG_OBJECT (qtdemux, "n_samples_per_chunk %u",
+      stream->n_samples_per_chunk);
+
+  /* make sure there's enough data */
+  if (!qt_atom_parser_has_chunks (&stream->stsc, stream->n_samples_per_chunk,
+          12))
+    goto corrupt_file;
+
+
+  /* chunk offset */
+  if (qtdemux_tree_get_child_by_type_full (stbl, FOURCC_stco, &stream->stco))
+    stream->co_size = sizeof (guint32);
+  else if (qtdemux_tree_get_child_by_type_full (stbl, FOURCC_co64,
+          &stream->stco))
+    stream->co_size = sizeof (guint64);
+  else
+    goto corrupt_file;
+
+  /* copy atom data into a new buffer for later use */
+  stream->stco.data = g_memdup (stream->stco.data, stream->stco.size);
+
+  /* skip version + flags */
+  if (!gst_byte_reader_skip (&stream->stco, 1 + 3))
+    goto corrupt_file;
+
+  /* chunks_are_chunks == 0 means treat chunks as samples */
+  stream->chunks_are_chunks = !stream->sample_size || stream->sampled;
+  if (stream->chunks_are_chunks) {
+    /* skip number of entries */
+    if (!gst_byte_reader_skip (&stream->stco, 4))
+      goto corrupt_file;
+
+    /* make sure there are enough data in the stsz atom */
+    if (!stream->sample_size) {
+      /* different sizes for each sample */
+      if (!qt_atom_parser_has_chunks (&stream->stsz, stream->n_samples, 4))
+        goto corrupt_file;
+    }
+  } else {
+    /* treat chunks as samples */
+    if (!gst_byte_reader_get_uint32_be (&stream->stco, &stream->n_samples))
+      goto corrupt_file;
+  }
+
+  GST_DEBUG_OBJECT (qtdemux, "allocating n_samples %u * %u (%.2f MB)",
+      stream->n_samples, (guint) sizeof (QtDemuxSample),
+      stream->n_samples * sizeof (QtDemuxSample) / (1024.0 * 1024.0));
+
+  if (stream->n_samples >=
+      QTDEMUX_MAX_SAMPLE_INDEX_SIZE / sizeof (QtDemuxSample)) {
+    GST_WARNING_OBJECT (qtdemux, "not allocating index of %d samples, would "
+        "be larger than %uMB (broken file?)", stream->n_samples,
+        QTDEMUX_MAX_SAMPLE_INDEX_SIZE >> 20);
+    return FALSE;
+  }
+
+  stream->samples = g_try_new0 (QtDemuxSample, stream->n_samples);
+  if (!stream->samples) {
+    GST_WARNING_OBJECT (qtdemux, "failed to allocate %d samples",
+        stream->n_samples);
+    return FALSE;
+  }
+
+
+  /* composition time-to-sample */
+  if ((stream->ctts_present =
+          ! !qtdemux_tree_get_child_by_type_full (stbl, FOURCC_ctts,
+              &stream->ctts) ? TRUE : FALSE) == TRUE) {
+    /* copy atom data into a new buffer for later use */
+    stream->ctts.data = g_memdup (stream->ctts.data, stream->ctts.size);
+
+    /* skip version + flags */
+    if (!gst_byte_reader_skip (&stream->ctts, 1 + 3)
+        || !gst_byte_reader_get_uint32_be (&stream->ctts,
+            &stream->n_composition_times))
+      goto corrupt_file;
+
+    /* make sure there's enough data */
+    if (!qt_atom_parser_has_chunks (&stream->ctts, stream->n_composition_times,
+            4 + 4))
+      goto corrupt_file;
+  }
+
+  return TRUE;
+
+corrupt_file:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+no_samples:
+  {
+    gst_qtdemux_stbl_free (stream);
+    if (!qtdemux->fragmented) {
+      /* not quite good */
+      GST_WARNING_OBJECT (qtdemux, "stream has no samples");
+      return FALSE;
+    } else {
+      /* may pick up samples elsewhere */
+      return TRUE;
+    }
+  }
+}
+
+/* collect samples from the next sample to be parsed up to sample @n for @stream
+ * by reading the info from @stbl
+ *
+ * This code can be executed from both the streaming thread and the seeking
+ * thread so it takes the object lock to protect itself
+ */
+static gboolean
+qtdemux_parse_samples (GstQTDemux * qtdemux, QtDemuxStream * stream, guint32 n)
+{
+  gint i, j, k;
+  QtDemuxSample *samples, *first, *cur, *last;
+  guint32 n_samples_per_chunk;
+  guint32 n_samples;
+
+  GST_LOG_OBJECT (qtdemux, "parsing samples for stream fourcc %"
+      GST_FOURCC_FORMAT ", pad %s", GST_FOURCC_ARGS (stream->fourcc),
+      stream->pad ? GST_PAD_NAME (stream->pad) : "(NULL)");
+
+  n_samples = stream->n_samples;
+
+  if (n >= n_samples)
+    goto out_of_samples;
+
+  GST_OBJECT_LOCK (qtdemux);
+  if (n <= stream->stbl_index)
+    goto already_parsed;
+
+  GST_DEBUG_OBJECT (qtdemux, "parsing up to sample %u", n);
+
+  if (!stream->stsz.data) {
+    /* so we already parsed and passed all the moov samples;
+     * onto fragmented ones */
+    g_assert (qtdemux->fragmented);
+    goto done;
+  }
+
+  /* pointer to the sample table */
+  samples = stream->samples;
+
+  /* starts from -1, moves to the next sample index to parse */
+  stream->stbl_index++;
+
+  /* keep track of the first and last sample to fill */
+  first = &samples[stream->stbl_index];
+  last = &samples[n];
+
+  if (stream->chunks_are_chunks) {
+    /* set the sample sizes */
+    if (stream->sample_size == 0) {
+      /* different sizes for each sample */
+      for (cur = first; cur <= last; cur++) {
+        cur->size = gst_byte_reader_get_uint32_be_unchecked (&stream->stsz);
+        GST_LOG_OBJECT (qtdemux, "sample %d has size %u",
+            (guint) (cur - samples), cur->size);
+      }
+    } else {
+      /* samples have the same size */
+      GST_LOG_OBJECT (qtdemux, "all samples have size %u", stream->sample_size);
+      for (cur = first; cur <= last; cur++)
+        cur->size = stream->sample_size;
+    }
+  }
+
+  n_samples_per_chunk = stream->n_samples_per_chunk;
+  cur = first;
+
+  for (i = stream->stsc_index; i < n_samples_per_chunk; i++) {
+    guint32 last_chunk;
+
+    if (stream->stsc_chunk_index >= stream->last_chunk
+        || stream->stsc_chunk_index < stream->first_chunk) {
+      stream->first_chunk =
+          gst_byte_reader_get_uint32_be_unchecked (&stream->stsc);
+      stream->samples_per_chunk =
+          gst_byte_reader_get_uint32_be_unchecked (&stream->stsc);
+      gst_byte_reader_skip_unchecked (&stream->stsc, 4);
+
+      /* chunk numbers are counted from 1 it seems */
+      if (G_UNLIKELY (stream->first_chunk == 0))
+        goto corrupt_file;
+
+      --stream->first_chunk;
+
+      /* the last chunk of each entry is calculated by taking the first chunk
+       * of the next entry; except if there is no next, where we fake it with
+       * INT_MAX */
+      if (G_UNLIKELY (i == (stream->n_samples_per_chunk - 1))) {
+        stream->last_chunk = G_MAXUINT32;
+      } else {
+        stream->last_chunk =
+            gst_byte_reader_peek_uint32_be_unchecked (&stream->stsc);
+        if (G_UNLIKELY (stream->last_chunk == 0))
+          goto corrupt_file;
+
+        --stream->last_chunk;
+      }
+
+      GST_LOG_OBJECT (qtdemux,
+          "entry %d has first_chunk %d, last_chunk %d, samples_per_chunk %d", i,
+          stream->first_chunk, stream->last_chunk, stream->samples_per_chunk);
+
+      if (G_UNLIKELY (stream->last_chunk < stream->first_chunk))
+        goto corrupt_file;
+
+      if (stream->last_chunk != G_MAXUINT32) {
+        if (!qt_atom_parser_peek_sub (&stream->stco,
+                stream->first_chunk * stream->co_size,
+                (stream->last_chunk - stream->first_chunk) * stream->co_size,
+                &stream->co_chunk))
+          goto corrupt_file;
+
+      } else {
+        stream->co_chunk = stream->stco;
+        if (!gst_byte_reader_skip (&stream->co_chunk,
+                stream->first_chunk * stream->co_size))
+          goto corrupt_file;
+      }
+
+      stream->stsc_chunk_index = stream->first_chunk;
+    }
+
+    last_chunk = stream->last_chunk;
+
+    if (stream->chunks_are_chunks) {
+      for (j = stream->stsc_chunk_index; j < last_chunk; j++) {
+        guint32 samples_per_chunk;
+        guint64 chunk_offset;
+
+        if (!stream->stsc_sample_index
+            && !qt_atom_parser_get_offset (&stream->co_chunk, stream->co_size,
+                &stream->chunk_offset))
+          goto corrupt_file;
+
+        samples_per_chunk = stream->samples_per_chunk;
+        chunk_offset = stream->chunk_offset;
+
+        for (k = stream->stsc_sample_index; k < samples_per_chunk; k++) {
+          GST_LOG_OBJECT (qtdemux, "Creating entry %d with offset %"
+              G_GUINT64_FORMAT, (guint) (cur - samples), stream->chunk_offset);
+
+          cur->offset = chunk_offset;
+          chunk_offset += cur->size;
+          cur++;
+
+          if (G_UNLIKELY (cur > last)) {
+            /* save state */
+            stream->stsc_sample_index = k + 1;
+            stream->chunk_offset = chunk_offset;
+            stream->stsc_chunk_index = j;
+            goto done2;
+          }
+        }
+        stream->stsc_sample_index = 0;
+      }
+      stream->stsc_chunk_index = j;
+    } else {
+      cur = &samples[stream->stsc_chunk_index];
+
+      for (j = stream->stsc_chunk_index; j < last_chunk; j++) {
+        if (j > n) {
+          /* save state */
+          stream->stsc_chunk_index = j;
+          goto done;
+        }
+
+        cur->offset =
+            qt_atom_parser_get_offset_unchecked (&stream->co_chunk,
+            stream->co_size);
+
+        GST_LOG_OBJECT (qtdemux, "Created entry %d with offset "
+            "%" G_GUINT64_FORMAT, j, cur->offset);
+
+        if (stream->samples_per_frame * stream->bytes_per_frame) {
+          cur->size =
+              (stream->samples_per_chunk * stream->n_channels) /
+              stream->samples_per_frame * stream->bytes_per_frame;
+        } else {
+          cur->size = stream->samples_per_chunk;
+        }
+
+        GST_DEBUG_OBJECT (qtdemux,
+            "keyframe sample %d: timestamp %" GST_TIME_FORMAT ", size %u",
+            j, GST_TIME_ARGS (gst_util_uint64_scale (stream->stco_sample_index,
+                    GST_SECOND, stream->timescale)), cur->size);
+
+        cur->timestamp = stream->stco_sample_index;
+        cur->duration = stream->samples_per_chunk;
+        cur->keyframe = TRUE;
+        cur++;
+
+        stream->stco_sample_index += stream->samples_per_chunk;
+      }
+      stream->stsc_chunk_index = j;
+    }
+    stream->stsc_index++;
+  }
+
+  if (!stream->chunks_are_chunks)
+    goto ctts;
+done2:
+  {
+    guint32 n_sample_times;
+
+    n_sample_times = stream->n_sample_times;
+    cur = first;
+
+    for (i = stream->stts_index; i < n_sample_times; i++) {
+      guint32 stts_samples;
+      guint32 stts_duration;
+      guint32 stts_time;
+
+      if (stream->stts_sample_index >= stream->stts_samples
+          || !stream->stts_sample_index) {
+
+        stream->stts_samples =
+            gst_byte_reader_get_uint32_be_unchecked (&stream->stts);
+        stream->stts_duration =
+            gst_byte_reader_get_uint32_be_unchecked (&stream->stts);
+
+        GST_LOG_OBJECT (qtdemux, "block %d, %u timestamps, duration %u",
+            i, stream->stts_samples, stream->stts_duration);
+
+        stream->stts_sample_index = 0;
+      }
+
+      stts_samples = stream->stts_samples;
+      stts_duration = stream->stts_duration;
+      stts_time = stream->stts_time;
+
+      for (j = stream->stts_sample_index; j < stts_samples; j++) {
+        GST_DEBUG_OBJECT (qtdemux,
+            "sample %d: index %d, timestamp %" GST_TIME_FORMAT,
+            (guint) (cur - samples), j,
+            GST_TIME_ARGS (gst_util_uint64_scale (stts_time, GST_SECOND,
+                    stream->timescale)));
+
+        cur->timestamp = stts_time;
+        cur->duration = stts_duration;
+
+        stts_time += stts_duration;
+        cur++;
+
+        if (G_UNLIKELY (cur > last)) {
+          /* save values */
+          stream->stts_time = stts_time;
+          stream->stts_sample_index = j + 1;
+          goto done3;
+        }
+      }
+      stream->stts_sample_index = 0;
+      stream->stts_time = stts_time;
+      stream->stts_index++;
+    }
+    /* fill up empty timestamps with the last timestamp, this can happen when
+     * the last samples do not decode and so we don't have timestamps for them.
+     * We however look at the last timestamp to estimate the track length so we
+     * need something in here. */
+    for (; cur < last; cur++) {
+      GST_DEBUG_OBJECT (qtdemux,
+          "fill sample %d: timestamp %" GST_TIME_FORMAT,
+          (guint) (cur - samples),
+          GST_TIME_ARGS (gst_util_uint64_scale (stream->stts_time, GST_SECOND,
+                  stream->timescale)));
+      cur->timestamp = stream->stts_time;
+      cur->duration = -1;
+    }
+  }
+done3:
+  {
+    /* sample sync, can be NULL */
+    if (stream->stss_present == TRUE) {
+      guint32 n_sample_syncs;
+
+      n_sample_syncs = stream->n_sample_syncs;
+
+      if (!n_sample_syncs) {
+        GST_DEBUG_OBJECT (qtdemux, "all samples are keyframes");
+        stream->all_keyframe = TRUE;
+      } else {
+        for (i = stream->stss_index; i < n_sample_syncs; i++) {
+          /* note that the first sample is index 1, not 0 */
+          guint32 index;
+
+          index = gst_byte_reader_get_uint32_be_unchecked (&stream->stss);
+
+          if (G_LIKELY (index > 0 && index <= n_samples)) {
+            index -= 1;
+            samples[index].keyframe = TRUE;
+            GST_DEBUG_OBJECT (qtdemux, "samples at %u is keyframe", index);
+            /* and exit if we have enough samples */
+            if (G_UNLIKELY (index >= n)) {
+              i++;
+              break;
+            }
+          }
+        }
+        /* save state */
+        stream->stss_index = i;
+      }
+
+      /* stps marks partial sync frames like open GOP I-Frames */
+      if (stream->stps_present == TRUE) {
+        guint32 n_sample_partial_syncs;
+
+        n_sample_partial_syncs = stream->n_sample_partial_syncs;
+
+        /* if there are no entries, the stss table contains the real
+         * sync samples */
+        if (n_sample_partial_syncs) {
+          for (i = stream->stps_index; i < n_sample_partial_syncs; i++) {
+            /* note that the first sample is index 1, not 0 */
+            guint32 index;
+
+            index = gst_byte_reader_get_uint32_be_unchecked (&stream->stps);
+
+            if (G_LIKELY (index > 0 && index <= n_samples)) {
+              index -= 1;
+              samples[index].keyframe = TRUE;
+              GST_DEBUG_OBJECT (qtdemux, "samples at %u is keyframe", index);
+              /* and exit if we have enough samples */
+              if (G_UNLIKELY (index >= n)) {
+                i++;
+                break;
+              }
+            }
+          }
+          /* save state */
+          stream->stps_index = i;
+        }
+      }
+    } else {
+      /* no stss, all samples are keyframes */
+      stream->all_keyframe = TRUE;
+      GST_DEBUG_OBJECT (qtdemux, "setting all keyframes");
+    }
+  }
+
+ctts:
+  /* composition time to sample */
+  if (stream->ctts_present == TRUE) {
+    guint32 n_composition_times;
+    guint32 ctts_count;
+    gint32 ctts_soffset;
+
+    /* Fill in the pts_offsets */
+    cur = first;
+    n_composition_times = stream->n_composition_times;
+
+    for (i = stream->ctts_index; i < n_composition_times; i++) {
+      if (stream->ctts_sample_index >= stream->ctts_count
+          || !stream->ctts_sample_index) {
+        stream->ctts_count =
+            gst_byte_reader_get_uint32_be_unchecked (&stream->ctts);
+        stream->ctts_soffset =
+            gst_byte_reader_get_int32_be_unchecked (&stream->ctts);
+        stream->ctts_sample_index = 0;
+      }
+
+      ctts_count = stream->ctts_count;
+      ctts_soffset = stream->ctts_soffset;
+
+      for (j = stream->ctts_sample_index; j < ctts_count; j++) {
+        cur->pts_offset = ctts_soffset;
+        cur++;
+
+        if (G_UNLIKELY (cur > last)) {
+          /* save state */
+          stream->ctts_sample_index = j + 1;
+          goto done;
+        }
+      }
+      stream->ctts_sample_index = 0;
+      stream->ctts_index++;
+    }
+  }
+done:
+  stream->stbl_index = n;
+  /* if index has been completely parsed, free data that is no-longer needed */
+  if (n + 1 == stream->n_samples) {
+    gst_qtdemux_stbl_free (stream);
+    GST_DEBUG_OBJECT (qtdemux,
+        "parsed all available samples; checking for more");
+    while (n + 1 == stream->n_samples)
+      if (qtdemux_add_fragmented_samples (qtdemux) != GST_FLOW_OK)
+        break;
+  }
+  GST_OBJECT_UNLOCK (qtdemux);
+
+  return TRUE;
+
+  /* SUCCESS */
+already_parsed:
+  {
+    GST_LOG_OBJECT (qtdemux,
+        "Tried to parse up to sample %u but this sample has already been parsed",
+        n);
+    /* if fragmented, there may be more */
+    if (qtdemux->fragmented && n == stream->stbl_index)
+      goto done;
+    GST_OBJECT_UNLOCK (qtdemux);
+    return TRUE;
+  }
+  /* ERRORS */
+out_of_samples:
+  {
+    GST_LOG_OBJECT (qtdemux,
+        "Tried to parse up to sample %u but there are only %u samples", n + 1,
+        stream->n_samples);
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+corrupt_file:
+  {
+    GST_OBJECT_UNLOCK (qtdemux);
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    return FALSE;
+  }
+}
+
+/* collect all segment info for @stream.
+ */
+static gboolean
+qtdemux_parse_segments (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    GNode * trak)
+{
+  GNode *edts;
+
+  /* parse and prepare segment info from the edit list */
+  GST_DEBUG_OBJECT (qtdemux, "looking for edit list container");
+  stream->n_segments = 0;
+  stream->segments = NULL;
+  if ((edts = qtdemux_tree_get_child_by_type (trak, FOURCC_edts))) {
+    GNode *elst;
+    gint n_segments;
+    gint i, count;
+    guint64 time, stime;
+    guint8 *buffer;
+
+    GST_DEBUG_OBJECT (qtdemux, "looking for edit list");
+    if (!(elst = qtdemux_tree_get_child_by_type (edts, FOURCC_elst)))
+      goto done;
+
+    buffer = elst->data;
+
+    n_segments = QT_UINT32 (buffer + 12);
+
+    /* we might allocate a bit too much, at least allocate 1 segment */
+    stream->segments = g_new (QtDemuxSegment, MAX (n_segments, 1));
+
+    /* segments always start from 0 */
+    time = 0;
+    stime = 0;
+    count = 0;
+    for (i = 0; i < n_segments; i++) {
+      guint64 duration;
+      guint64 media_time;
+      QtDemuxSegment *segment;
+      guint32 rate_int;
+
+      media_time = QT_UINT32 (buffer + 20 + i * 12);
+
+      /* -1 media time is an empty segment, just ignore it */
+      if (media_time == G_MAXUINT32)
+        continue;
+
+      duration = QT_UINT32 (buffer + 16 + i * 12);
+
+      segment = &stream->segments[count++];
+
+      /* time and duration expressed in global timescale */
+      segment->time = stime;
+      /* add non scaled values so we don't cause roundoff errors */
+      time += duration;
+      stime = gst_util_uint64_scale (time, GST_SECOND, qtdemux->timescale);
+      segment->stop_time = stime;
+      segment->duration = stime - segment->time;
+      /* media_time expressed in stream timescale */
+      segment->media_start =
+          gst_util_uint64_scale (media_time, GST_SECOND, stream->timescale);
+      segment->media_stop = segment->media_start + segment->duration;
+      rate_int = GST_READ_UINT32_BE (buffer + 24 + i * 12);
+
+      if (rate_int <= 1) {
+        /* 0 is not allowed, some programs write 1 instead of the floating point
+         * value */
+        GST_WARNING_OBJECT (qtdemux, "found suspicious rate %" G_GUINT32_FORMAT,
+            rate_int);
+        segment->rate = 1;
+      } else {
+        segment->rate = rate_int / 65536.0;
+      }
+
+      GST_DEBUG_OBJECT (qtdemux, "created segment %d time %" GST_TIME_FORMAT
+          ", duration %" GST_TIME_FORMAT ", media_time %" GST_TIME_FORMAT
+          ", rate %g, (%d)", i, GST_TIME_ARGS (segment->time),
+          GST_TIME_ARGS (segment->duration),
+          GST_TIME_ARGS (segment->media_start), segment->rate, rate_int);
+    }
+    GST_DEBUG_OBJECT (qtdemux, "found %d non-empty segments", count);
+    stream->n_segments = count;
+  }
+done:
+
+  /* push based does not handle segments, so act accordingly here,
+   * and warn if applicable */
+  if (!qtdemux->pullbased) {
+    GST_WARNING_OBJECT (qtdemux, "streaming; discarding edit list segments");
+    /* remove and use default one below, we stream like it anyway */
+    g_free (stream->segments);
+    stream->segments = NULL;
+    stream->n_segments = 0;
+  }
+
+  /* no segments, create one to play the complete trak */
+  if (stream->n_segments == 0) {
+    GstClockTime stream_duration =
+        gst_util_uint64_scale (stream->duration, GST_SECOND, stream->timescale);
+
+    if (stream->segments == NULL)
+      stream->segments = g_new (QtDemuxSegment, 1);
+
+    /* represent unknown our way */
+    if (stream_duration == 0)
+      stream_duration = -1;
+
+    stream->segments[0].time = 0;
+    stream->segments[0].stop_time = stream_duration;
+    stream->segments[0].duration = stream_duration;
+    stream->segments[0].media_start = 0;
+    stream->segments[0].media_stop = stream_duration;
+    stream->segments[0].rate = 1.0;
+
+    GST_DEBUG_OBJECT (qtdemux, "created dummy segment %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (stream_duration));
+    stream->n_segments = 1;
+  }
+  GST_DEBUG_OBJECT (qtdemux, "using %d segments", stream->n_segments);
+
+  return TRUE;
+}
+
+/*
+ * Parses the stsd atom of a svq3 trak looking for
+ * the SMI and gama atoms.
+ */
+static void
+qtdemux_parse_svq3_stsd_data (GstQTDemux * qtdemux, GNode * stsd,
+    guint8 ** gamma, GstBuffer ** seqh)
+{
+  guint8 *_gamma = NULL;
+  GstBuffer *_seqh = NULL;
+  guint8 *stsd_data = stsd->data;
+  guint32 length = QT_UINT32 (stsd_data);
+  guint16 version;
+
+  if (length < 32) {
+    GST_WARNING_OBJECT (qtdemux, "stsd too short");
+    goto end;
+  }
+
+  stsd_data += 32;
+  length -= 32;
+  version = QT_UINT16 (stsd_data);
+  if (version == 3) {
+    if (length >= 70) {
+      length -= 70;
+      stsd_data += 70;
+      while (length > 8) {
+        guint32 fourcc, size;
+        guint8 *data;
+        size = QT_UINT32 (stsd_data);
+        fourcc = QT_FOURCC (stsd_data + 4);
+        data = stsd_data + 8;
+
+        switch (fourcc) {
+          case FOURCC_gama:{
+            if (size == 12) {
+              _gamma = data;
+            } else {
+              GST_WARNING_OBJECT (qtdemux, "Unexpected size %" G_GUINT32_FORMAT
+                  " for gama atom, expected 12", size);
+            }
+            break;
+          }
+          case FOURCC_SMI_:{
+            if (size > 16 && QT_FOURCC (data) == FOURCC_SEQH) {
+              guint32 seqh_size;
+              if (_seqh != NULL) {
+                GST_WARNING_OBJECT (qtdemux, "Unexpected second SEQH SMI atom "
+                    " found, ignoring");
+              } else {
+                seqh_size = QT_UINT32 (data + 4);
+                if (seqh_size > 0) {
+                  _seqh = gst_buffer_new_and_alloc (seqh_size);
+                  memcpy (GST_BUFFER_DATA (_seqh), data + 8, seqh_size);
+                }
+              }
+            }
+            break;
+          }
+          default:{
+            GST_WARNING_OBJECT (qtdemux, "Unhandled atom %" GST_FOURCC_FORMAT
+                " in SVQ3 entry in stsd atom", GST_FOURCC_ARGS (fourcc));
+          }
+        }
+
+        if (size <= length) {
+          length -= size;
+          stsd_data += size;
+        }
+      }
+    } else {
+      GST_WARNING_OBJECT (qtdemux, "SVQ3 entry too short in stsd atom");
+    }
+  } else {
+    GST_WARNING_OBJECT (qtdemux, "Unexpected version for SVQ3 entry %"
+        G_GUINT16_FORMAT, version);
+    goto end;
+  }
+
+end:
+  if (gamma) {
+    *gamma = _gamma;
+  }
+  if (seqh) {
+    *seqh = _seqh;
+  } else if (_seqh) {
+    gst_buffer_unref (_seqh);
+  }
+}
+
+static gchar *
+qtdemux_get_rtsp_uri_from_hndl (GstQTDemux * qtdemux, GNode * minf)
+{
+  GNode *dinf;
+  GstByteReader dref;
+  gchar *uri = NULL;
+
+  /*
+   * Get 'dinf', to get its child 'dref', that might contain a 'hndl'
+   * atom that might contain a 'data' atom with the rtsp uri.
+   * This case was reported in bug #597497, some info about
+   * the hndl atom can be found in TN1195
+   */
+  dinf = qtdemux_tree_get_child_by_type (minf, FOURCC_dinf);
+  GST_DEBUG_OBJECT (qtdemux, "Trying to obtain rtsp URI for stream trak");
+
+  if (dinf) {
+    guint32 dref_num_entries = 0;
+    if (qtdemux_tree_get_child_by_type_full (dinf, FOURCC_dref, &dref) &&
+        gst_byte_reader_skip (&dref, 4) &&
+        gst_byte_reader_get_uint32_be (&dref, &dref_num_entries)) {
+      gint i;
+
+      /* search dref entries for hndl atom */
+      for (i = 0; i < dref_num_entries; i++) {
+        guint32 size = 0, type;
+        guint8 string_len = 0;
+        if (gst_byte_reader_get_uint32_be (&dref, &size) &&
+            qt_atom_parser_get_fourcc (&dref, &type)) {
+          if (type == FOURCC_hndl) {
+            GST_DEBUG_OBJECT (qtdemux, "Found hndl atom");
+
+            /* skip data reference handle bytes and the
+             * following pascal string and some extra 4
+             * bytes I have no idea what are */
+            if (!gst_byte_reader_skip (&dref, 4) ||
+                !gst_byte_reader_get_uint8 (&dref, &string_len) ||
+                !gst_byte_reader_skip (&dref, string_len + 4)) {
+              GST_WARNING_OBJECT (qtdemux, "Failed to parse hndl atom");
+              break;
+            }
+
+            /* iterate over the atoms to find the data atom */
+            while (gst_byte_reader_get_remaining (&dref) >= 8) {
+              guint32 atom_size;
+              guint32 atom_type;
+
+              if (gst_byte_reader_get_uint32_be (&dref, &atom_size) &&
+                  qt_atom_parser_get_fourcc (&dref, &atom_type)) {
+                if (atom_type == FOURCC_data) {
+                  const guint8 *uri_aux = NULL;
+
+                  /* found the data atom that might contain the rtsp uri */
+                  GST_DEBUG_OBJECT (qtdemux, "Found data atom inside "
+                      "hndl atom, interpreting it as an URI");
+                  if (gst_byte_reader_peek_data (&dref, atom_size - 8,
+                          &uri_aux)) {
+                    if (g_strstr_len ((gchar *) uri_aux, 7, "rtsp://") != NULL)
+                      uri = g_strndup ((gchar *) uri_aux, atom_size - 8);
+                    else
+                      GST_WARNING_OBJECT (qtdemux, "Data atom in hndl atom "
+                          "didn't contain a rtsp address");
+                  } else {
+                    GST_WARNING_OBJECT (qtdemux, "Failed to get the data "
+                        "atom contents");
+                  }
+                  break;
+                }
+                /* skipping to the next entry */
+                gst_byte_reader_skip (&dref, atom_size - 8);
+              } else {
+                GST_WARNING_OBJECT (qtdemux, "Failed to parse hndl child "
+                    "atom header");
+                break;
+              }
+            }
+            break;
+          }
+          /* skip to the next entry */
+          gst_byte_reader_skip (&dref, size - 8);
+        } else {
+          GST_WARNING_OBJECT (qtdemux, "Error parsing dref atom");
+        }
+      }
+      GST_DEBUG_OBJECT (qtdemux, "Finished parsing dref atom");
+    }
+  }
+  return uri;
+}
+
+static gint
+less_than (gconstpointer a, gconstpointer b)
+{
+  const guint32 *av = a, *bv = b;
+
+  return *av - *bv;
+}
+
+/* parse the traks.
+ * With each track we associate a new QtDemuxStream that contains all the info
+ * about the trak.
+ * traks that do not decode to something (like strm traks) will not have a pad.
+ */
+static gboolean
+qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
+{
+  GstByteReader tkhd;
+  int offset;
+  GNode *mdia;
+  GNode *mdhd;
+  GNode *hdlr;
+  GNode *minf;
+  GNode *stbl;
+  GNode *stsd;
+  GNode *mp4a;
+  GNode *mp4v;
+  GNode *wave;
+  GNode *esds;
+  GNode *pasp;
+  QtDemuxStream *stream;
+  GstTagList *list = NULL;
+  gchar *codec = NULL;
+  const guint8 *stsd_data;
+  guint16 lang_code;            /* quicktime lang code or packed iso code */
+  guint32 version;
+  guint32 tkhd_flags = 0;
+  guint8 tkhd_version = 0;
+  guint32 fourcc;
+  guint value_size, len;
+
+  stream = g_new0 (QtDemuxStream, 1);
+  /* new streams always need a discont */
+  stream->discont = TRUE;
+  /* we enable clipping for raw audio/video streams */
+  stream->need_clip = FALSE;
+  stream->need_process = FALSE;
+  stream->segment_index = -1;
+  stream->time_position = 0;
+  stream->sample_index = -1;
+  stream->last_ret = GST_FLOW_OK;
+
+  if (!qtdemux_tree_get_child_by_type_full (trak, FOURCC_tkhd, &tkhd)
+      || !gst_byte_reader_get_uint8 (&tkhd, &tkhd_version)
+      || !gst_byte_reader_get_uint24_be (&tkhd, &tkhd_flags))
+    goto corrupt_file;
+
+  /* pick between 64 or 32 bits */
+  value_size = tkhd_version == 1 ? 8 : 4;
+  if (!gst_byte_reader_skip (&tkhd, value_size * 2) ||
+      !gst_byte_reader_get_uint32_be (&tkhd, &stream->track_id))
+    goto corrupt_file;
+
+  GST_LOG_OBJECT (qtdemux, "track[tkhd] version/flags/id: 0x%02x/%06x/%u",
+      tkhd_version, tkhd_flags, stream->track_id);
+
+  if (!(mdia = qtdemux_tree_get_child_by_type (trak, FOURCC_mdia)))
+    goto corrupt_file;
+
+  if (!(mdhd = qtdemux_tree_get_child_by_type (mdia, FOURCC_mdhd))) {
+    /* be nice for some crooked mjp2 files that use mhdr for mdhd */
+    if (qtdemux->major_brand != FOURCC_mjp2 ||
+        !(mdhd = qtdemux_tree_get_child_by_type (mdia, FOURCC_mhdr)))
+      goto corrupt_file;
+  }
+
+  len = QT_UINT32 ((guint8 *) mdhd->data);
+  version = QT_UINT32 ((guint8 *) mdhd->data + 8);
+  GST_LOG_OBJECT (qtdemux, "track version/flags: %08x", version);
+  if (version == 0x01000000) {
+    if (len < 38)
+      goto corrupt_file;
+    stream->timescale = QT_UINT32 ((guint8 *) mdhd->data + 28);
+    stream->duration = QT_UINT64 ((guint8 *) mdhd->data + 32);
+    lang_code = QT_UINT16 ((guint8 *) mdhd->data + 36);
+  } else {
+    if (len < 30)
+      goto corrupt_file;
+    stream->timescale = QT_UINT32 ((guint8 *) mdhd->data + 20);
+    stream->duration = QT_UINT32 ((guint8 *) mdhd->data + 24);
+    lang_code = QT_UINT16 ((guint8 *) mdhd->data + 28);
+  }
+
+  if (lang_code < 0x800) {
+    qtdemux_lang_map_qt_code_to_iso (stream->lang_id, lang_code);
+  } else {
+    stream->lang_id[0] = 0x60 + ((lang_code >> 10) & 0x1F);
+    stream->lang_id[1] = 0x60 + ((lang_code >> 5) & 0x1F);
+    stream->lang_id[2] = 0x60 + (lang_code & 0x1F);
+    stream->lang_id[3] = 0;
+  }
+
+  GST_LOG_OBJECT (qtdemux, "track timescale: %" G_GUINT32_FORMAT,
+      stream->timescale);
+  GST_LOG_OBJECT (qtdemux, "track duration: %" G_GUINT64_FORMAT,
+      stream->duration);
+  GST_LOG_OBJECT (qtdemux, "track language code/id: 0x%04x/%s",
+      lang_code, stream->lang_id);
+
+  if (G_UNLIKELY (stream->timescale == 0 || qtdemux->timescale == 0))
+    goto corrupt_file;
+
+  /* fragmented files may have bogus duration in moov */
+  if (!qtdemux->fragmented &&
+      qtdemux->duration != G_MAXINT64 && stream->duration != G_MAXINT32) {
+    guint64 tdur1, tdur2;
+
+    /* don't overflow */
+    tdur1 = stream->timescale * (guint64) qtdemux->duration;
+    tdur2 = qtdemux->timescale * (guint64) stream->duration;
+
+    /* HACK:
+     * some of those trailers, nowadays, have prologue images that are
+     * themselves vide tracks as well. I haven't really found a way to
+     * identify those yet, except for just looking at their duration. */
+    if (tdur1 != 0 && (tdur2 * 10 / tdur1) < 2) {
+      GST_WARNING_OBJECT (qtdemux,
+          "Track shorter than 20%% (%" G_GUINT64_FORMAT "/%" G_GUINT32_FORMAT
+          " vs. %" G_GUINT64_FORMAT "/%" G_GUINT32_FORMAT ") of the stream "
+          "found, assuming preview image or something; skipping track",
+          stream->duration, stream->timescale, qtdemux->duration,
+          qtdemux->timescale);
+      g_free (stream);
+      return TRUE;
+    }
+  }
+
+  if (!(hdlr = qtdemux_tree_get_child_by_type (mdia, FOURCC_hdlr)))
+    goto corrupt_file;
+
+  GST_LOG_OBJECT (qtdemux, "track type: %" GST_FOURCC_FORMAT,
+      GST_FOURCC_ARGS (QT_FOURCC ((guint8 *) hdlr->data + 12)));
+
+  len = QT_UINT32 ((guint8 *) hdlr->data);
+  if (len >= 20)
+    stream->subtype = QT_FOURCC ((guint8 *) hdlr->data + 16);
+  GST_LOG_OBJECT (qtdemux, "track subtype: %" GST_FOURCC_FORMAT,
+      GST_FOURCC_ARGS (stream->subtype));
+
+  if (!(minf = qtdemux_tree_get_child_by_type (mdia, FOURCC_minf)))
+    goto corrupt_file;
+
+  if (!(stbl = qtdemux_tree_get_child_by_type (minf, FOURCC_stbl)))
+    goto corrupt_file;
+
+  /* parse stsd */
+  if (!(stsd = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsd)))
+    goto corrupt_file;
+  stsd_data = (const guint8 *) stsd->data;
+
+  /* stsd should at least have one entry */
+  len = QT_UINT32 (stsd_data);
+  if (len < 24)
+    goto corrupt_file;
+
+  /* and that entry should fit within stsd */
+  len = QT_UINT32 (stsd_data + 16);
+  if (len > QT_UINT32 (stsd_data) + 16)
+    goto corrupt_file;
+  GST_LOG_OBJECT (qtdemux, "stsd len:           %d", len);
+
+  stream->fourcc = fourcc = QT_FOURCC (stsd_data + 16 + 4);
+  GST_LOG_OBJECT (qtdemux, "stsd type:          %" GST_FOURCC_FORMAT,
+      GST_FOURCC_ARGS (stream->fourcc));
+
+  if ((fourcc == FOURCC_drms) || (fourcc == FOURCC_drmi) ||
+      ((fourcc & 0xFFFFFF00) == GST_MAKE_FOURCC ('e', 'n', 'c', 0)))
+    goto error_encrypted;
+
+  if (stream->subtype == FOURCC_vide) {
+    guint32 w = 0, h = 0;
+
+    stream->sampled = TRUE;
+
+    /* version 1 uses some 64-bit ints */
+    if (!gst_byte_reader_skip (&tkhd, 56 + value_size)
+        || !gst_byte_reader_get_uint32_be (&tkhd, &w)
+        || !gst_byte_reader_get_uint32_be (&tkhd, &h))
+      goto corrupt_file;
+
+    stream->display_width = w >> 16;
+    stream->display_height = h >> 16;
+
+    offset = 16;
+    if (len < 86)
+      goto corrupt_file;
+
+    stream->width = QT_UINT16 (stsd_data + offset + 32);
+    stream->height = QT_UINT16 (stsd_data + offset + 34);
+    stream->fps_n = 0;          /* this is filled in later */
+    stream->fps_d = 0;          /* this is filled in later */
+    stream->bits_per_sample = QT_UINT16 (stsd_data + offset + 82);
+    stream->color_table_id = QT_UINT16 (stsd_data + offset + 84);
+
+    GST_LOG_OBJECT (qtdemux, "frame count:   %u",
+        QT_UINT16 (stsd_data + offset + 48));
+
+    stream->caps =
+        qtdemux_video_caps (qtdemux, stream, fourcc, stsd_data, &codec);
+    if (codec) {
+      list = gst_tag_list_new ();
+      gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+          GST_TAG_VIDEO_CODEC, codec, NULL);
+      g_free (codec);
+      codec = NULL;
+    }
+
+    esds = NULL;
+    pasp = NULL;
+    /* pick 'the' stsd child */
+    mp4v = qtdemux_tree_get_child_by_type (stsd, fourcc);
+    if (mp4v) {
+      esds = qtdemux_tree_get_child_by_type (mp4v, FOURCC_esds);
+      pasp = qtdemux_tree_get_child_by_type (mp4v, FOURCC_pasp);
+    }
+
+    if (pasp) {
+      const guint8 *pasp_data = (const guint8 *) pasp->data;
+
+      stream->par_w = QT_UINT32 (pasp_data + 8);
+      stream->par_h = QT_UINT32 (pasp_data + 12);
+    } else {
+      stream->par_w = 0;
+      stream->par_h = 0;
+    }
+
+    if (esds) {
+      gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
+    } else {
+      switch (fourcc) {
+        case FOURCC_avc1:
+        {
+          gint len = QT_UINT32 (stsd_data) - 0x66;
+          const guint8 *avc_data = stsd_data + 0x66;
+
+          /* find avcC */
+          while (len >= 0x8) {
+            gint size;
+
+            if (QT_UINT32 (avc_data) <= len)
+              size = QT_UINT32 (avc_data) - 0x8;
+            else
+              size = len - 0x8;
+
+            if (size < 1)
+              /* No real data, so break out */
+              break;
+
+            switch (QT_FOURCC (avc_data + 0x4)) {
+              case FOURCC_avcC:
+              {
+                /* parse, if found */
+                GstBuffer *buf;
+
+                GST_DEBUG_OBJECT (qtdemux, "found avcC codec_data in stsd");
+
+                /* First 4 bytes are the length of the atom, the next 4 bytes
+                 * are the fourcc, the next 1 byte is the version, and the
+                 * subsequent bytes are sequence parameter set like data. */
+                gst_codec_utils_h264_caps_set_level_and_profile (stream->caps,
+                    avc_data + 8 + 1, size - 1);
+
+                buf = gst_buffer_new_and_alloc (size);
+                memcpy (GST_BUFFER_DATA (buf), avc_data + 0x8, size);
+                gst_caps_set_simple (stream->caps,
+                    "codec_data", GST_TYPE_BUFFER, buf, NULL);
+                gst_buffer_unref (buf);
+
+                break;
+              }
+              case FOURCC_btrt:
+              {
+                guint avg_bitrate, max_bitrate;
+
+                /* bufferSizeDB, maxBitrate and avgBitrate - 4 bytes each */
+                if (size < 12)
+                  break;
+
+                max_bitrate = QT_UINT32 (avc_data + 0xc);
+                avg_bitrate = QT_UINT32 (avc_data + 0x10);
+
+                if (!max_bitrate && !avg_bitrate)
+                  break;
+
+                /* Some muxers seem to swap the average and maximum bitrates
+                 * (I'm looking at you, YouTube), so we swap for sanity. */
+                if (max_bitrate > 0 && max_bitrate < avg_bitrate) {
+                  guint temp = avg_bitrate;
+
+                  avg_bitrate = max_bitrate;
+                  max_bitrate = temp;
+                }
+
+                if (!list)
+                  list = gst_tag_list_new ();
+
+                if (max_bitrate > 0 && max_bitrate < G_MAXUINT32) {
+                  gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+                      GST_TAG_MAXIMUM_BITRATE, max_bitrate, NULL);
+                }
+                if (avg_bitrate > 0 && avg_bitrate < G_MAXUINT32) {
+                  gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+                      GST_TAG_BITRATE, avg_bitrate, NULL);
+                }
+
+                break;
+              }
+
+              default:
+                break;
+            }
+
+            len -= size + 8;
+            avc_data += size + 8;
+          }
+
+          break;
+        }
+        case FOURCC_mp4v:
+        case FOURCC_MP4V:
+        case FOURCC_fmp4:
+        case FOURCC_FMP4:
+        {
+          GNode *glbl;
+
+          GST_DEBUG_OBJECT (qtdemux, "found %" GST_FOURCC_FORMAT,
+              GST_FOURCC_ARGS (fourcc));
+
+          /* codec data might be in glbl extension atom */
+          glbl = mp4v ?
+              qtdemux_tree_get_child_by_type (mp4v, FOURCC_glbl) : NULL;
+          if (glbl) {
+            guint8 *data;
+            GstBuffer *buf;
+            gint len;
+
+            GST_DEBUG_OBJECT (qtdemux, "found glbl data in stsd");
+            data = glbl->data;
+            len = QT_UINT32 (data);
+            if (len > 0x8) {
+              len -= 0x8;
+              buf = gst_buffer_new_and_alloc (len);
+              memcpy (GST_BUFFER_DATA (buf), data + 8, len);
+              gst_caps_set_simple (stream->caps,
+                  "codec_data", GST_TYPE_BUFFER, buf, NULL);
+              gst_buffer_unref (buf);
+            }
+          }
+          break;
+        }
+        case FOURCC_mjp2:
+        {
+          /* see annex I of the jpeg2000 spec */
+          GNode *jp2h, *ihdr, *colr, *mjp2, *field, *prefix, *cmap, *cdef;
+          const guint8 *data;
+          guint32 fourcc = 0;
+          gint ncomp = 0;
+          guint32 ncomp_map = 0;
+          gint32 *comp_map = NULL;
+          guint32 nchan_def = 0;
+          gint32 *chan_def = NULL;
+
+          GST_DEBUG_OBJECT (qtdemux, "found mjp2");
+          /* some required atoms */
+          mjp2 = qtdemux_tree_get_child_by_type (stsd, FOURCC_mjp2);
+          if (!mjp2)
+            break;
+          jp2h = qtdemux_tree_get_child_by_type (mjp2, FOURCC_jp2h);
+          if (!jp2h)
+            break;
+
+          /* number of components; redundant with info in codestream, but useful
+             to a muxer */
+          ihdr = qtdemux_tree_get_child_by_type (jp2h, FOURCC_ihdr);
+          if (!ihdr || QT_UINT32 (ihdr->data) != 22)
+            break;
+          ncomp = QT_UINT16 (((guint8 *) ihdr->data) + 16);
+
+          colr = qtdemux_tree_get_child_by_type (jp2h, FOURCC_colr);
+          if (!colr)
+            break;
+          GST_DEBUG_OBJECT (qtdemux, "found colr");
+          /* extract colour space info */
+          if (QT_UINT8 ((guint8 *) colr->data + 8) == 1) {
+            switch (QT_UINT32 ((guint8 *) colr->data + 11)) {
+              case 16:
+                fourcc = GST_MAKE_FOURCC ('s', 'R', 'G', 'B');
+                break;
+              case 17:
+                fourcc = GST_MAKE_FOURCC ('G', 'R', 'A', 'Y');
+                break;
+              case 18:
+                fourcc = GST_MAKE_FOURCC ('s', 'Y', 'U', 'V');
+                break;
+              default:
+                break;
+            }
+          }
+          if (!fourcc)
+            /* colr is required, and only values 16, 17, and 18 are specified,
+               so error if we have no fourcc */
+            break;
+
+          /* extract component mapping */
+          cmap = qtdemux_tree_get_child_by_type (jp2h, FOURCC_cmap);
+          if (cmap) {
+            guint32 cmap_len = 0;
+            int i;
+            cmap_len = QT_UINT32 (cmap->data);
+            if (cmap_len >= 8) {
+              /* normal box, subtract off header */
+              cmap_len -= 8;
+              /* cmap: { u16 cmp; u8 mtyp; u8 pcol; }* */
+              if (cmap_len % 4 == 0) {
+                ncomp_map = (cmap_len / 4);
+                comp_map = g_new0 (gint32, ncomp_map);
+                for (i = 0; i < ncomp_map; i++) {
+                  guint16 cmp;
+                  guint8 mtyp, pcol;
+                  cmp = QT_UINT16 (((guint8 *) cmap->data) + 8 + i * 4);
+                  mtyp = QT_UINT8 (((guint8 *) cmap->data) + 8 + i * 4 + 2);
+                  pcol = QT_UINT8 (((guint8 *) cmap->data) + 8 + i * 4 + 3);
+                  comp_map[i] = (mtyp << 24) | (pcol << 16) | cmp;
+                }
+              }
+            }
+          }
+          /* extract channel definitions */
+          cdef = qtdemux_tree_get_child_by_type (jp2h, FOURCC_cdef);
+          if (cdef) {
+            guint32 cdef_len = 0;
+            int i;
+            cdef_len = QT_UINT32 (cdef->data);
+            if (cdef_len >= 10) {
+              /* normal box, subtract off header and len */
+              cdef_len -= 10;
+              /* cdef: u16 n; { u16 cn; u16 typ; u16 asoc; }* */
+              if (cdef_len % 6 == 0) {
+                nchan_def = (cdef_len / 6);
+                chan_def = g_new0 (gint32, nchan_def);
+                for (i = 0; i < nchan_def; i++)
+                  chan_def[i] = -1;
+                for (i = 0; i < nchan_def; i++) {
+                  guint16 cn, typ, asoc;
+                  cn = QT_UINT16 (((guint8 *) cdef->data) + 10 + i * 6);
+                  typ = QT_UINT16 (((guint8 *) cdef->data) + 10 + i * 6 + 2);
+                  asoc = QT_UINT16 (((guint8 *) cdef->data) + 10 + i * 6 + 4);
+                  if (cn < nchan_def) {
+                    switch (typ) {
+                      case 0:
+                        chan_def[cn] = asoc;
+                        break;
+                      case 1:
+                        chan_def[cn] = 0;       /* alpha */
+                        break;
+                      default:
+                        chan_def[cn] = -typ;
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          gst_caps_set_simple (stream->caps,
+              "num-components", G_TYPE_INT, ncomp, NULL);
+          gst_caps_set_simple (stream->caps,
+              "fourcc", GST_TYPE_FOURCC, fourcc, NULL);
+
+          if (comp_map) {
+            GValue arr = { 0, };
+            GValue elt = { 0, };
+            int i;
+            g_value_init (&arr, GST_TYPE_ARRAY);
+            g_value_init (&elt, G_TYPE_INT);
+            for (i = 0; i < ncomp_map; i++) {
+              g_value_set_int (&elt, comp_map[i]);
+              gst_value_array_append_value (&arr, &elt);
+            }
+            gst_structure_set_value (gst_caps_get_structure (stream->caps, 0),
+                "component-map", &arr);
+            g_value_unset (&elt);
+            g_value_unset (&arr);
+            g_free (comp_map);
+          }
+
+          if (chan_def) {
+            GValue arr = { 0, };
+            GValue elt = { 0, };
+            int i;
+            g_value_init (&arr, GST_TYPE_ARRAY);
+            g_value_init (&elt, G_TYPE_INT);
+            for (i = 0; i < nchan_def; i++) {
+              g_value_set_int (&elt, chan_def[i]);
+              gst_value_array_append_value (&arr, &elt);
+            }
+            gst_structure_set_value (gst_caps_get_structure (stream->caps, 0),
+                "channel-definitions", &arr);
+            g_value_unset (&elt);
+            g_value_unset (&arr);
+            g_free (chan_def);
+          }
+
+          /* some optional atoms */
+          field = qtdemux_tree_get_child_by_type (mjp2, FOURCC_fiel);
+          prefix = qtdemux_tree_get_child_by_type (mjp2, FOURCC_jp2x);
+
+          /* indicate possible fields in caps */
+          if (field) {
+            data = (guint8 *) field->data + 8;
+            if (*data != 1)
+              gst_caps_set_simple (stream->caps, "fields", G_TYPE_INT,
+                  (gint) * data, NULL);
+          }
+          /* add codec_data if provided */
+          if (prefix) {
+            GstBuffer *buf;
+            gint len;
+
+            GST_DEBUG_OBJECT (qtdemux, "found prefix data in stsd");
+            data = prefix->data;
+            len = QT_UINT32 (data);
+            if (len > 0x8) {
+              len -= 0x8;
+              buf = gst_buffer_new_and_alloc (len);
+              memcpy (GST_BUFFER_DATA (buf), data + 8, len);
+              gst_caps_set_simple (stream->caps,
+                  "codec_data", GST_TYPE_BUFFER, buf, NULL);
+              gst_buffer_unref (buf);
+            }
+          }
+          break;
+        }
+        case FOURCC_SVQ3:
+        case FOURCC_VP31:
+        {
+          GstBuffer *buf;
+          GstBuffer *seqh = NULL;
+          guint8 *gamma_data = NULL;
+          gint len = QT_UINT32 (stsd_data);
+
+          qtdemux_parse_svq3_stsd_data (qtdemux, stsd, &gamma_data, &seqh);
+          if (gamma_data) {
+            gst_caps_set_simple (stream->caps, "applied-gamma", G_TYPE_DOUBLE,
+                QT_FP32 (gamma_data), NULL);
+          }
+          if (seqh) {
+            /* sorry for the bad name, but we don't know what this is, other
+             * than its own fourcc */
+            gst_caps_set_simple (stream->caps, "seqh", GST_TYPE_BUFFER, seqh,
+                NULL);
+          }
+
+          GST_DEBUG_OBJECT (qtdemux, "found codec_data in stsd");
+          buf = gst_buffer_new_and_alloc (len);
+          memcpy (GST_BUFFER_DATA (buf), stsd_data, len);
+          gst_caps_set_simple (stream->caps,
+              "codec_data", GST_TYPE_BUFFER, buf, NULL);
+          gst_buffer_unref (buf);
+          break;
+        }
+        case FOURCC_rle_:
+        {
+          gst_caps_set_simple (stream->caps,
+              "depth", G_TYPE_INT, QT_UINT16 (stsd_data + offset + 82), NULL);
+          break;
+        }
+        case FOURCC_XiTh:
+        {
+          GNode *xith, *xdxt;
+
+          GST_DEBUG_OBJECT (qtdemux, "found XiTh");
+          xith = qtdemux_tree_get_child_by_type (stsd, FOURCC_XiTh);
+          if (!xith)
+            break;
+
+          xdxt = qtdemux_tree_get_child_by_type (xith, FOURCC_XdxT);
+          if (!xdxt)
+            break;
+
+          GST_DEBUG_OBJECT (qtdemux, "found XdxT node");
+          /* collect the headers and store them in a stream list so that we can
+           * send them out first */
+          qtdemux_parse_theora_extension (qtdemux, stream, xdxt);
+          break;
+        }
+        case FOURCC_ovc1:
+        {
+          GNode *ovc1;
+          gchar *ovc1_data;
+          guint ovc1_len;
+          GstBuffer *buf;
+
+          GST_DEBUG_OBJECT (qtdemux, "parse ovc1 header");
+          ovc1 = qtdemux_tree_get_child_by_type (stsd, FOURCC_ovc1);
+          if (!ovc1)
+            break;
+          ovc1_data = ovc1->data;
+          ovc1_len = QT_UINT32 (ovc1_data);
+          if (ovc1_len <= 198) {
+            GST_WARNING_OBJECT (qtdemux, "Too small ovc1 header, skipping");
+            break;
+          }
+          buf = gst_buffer_new_and_alloc (ovc1_len - 198);
+          memcpy (GST_BUFFER_DATA (buf), ovc1_data + 198, ovc1_len - 198);
+          gst_caps_set_simple (stream->caps,
+              "codec_data", GST_TYPE_BUFFER, buf, NULL);
+          gst_buffer_unref (buf);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    GST_INFO_OBJECT (qtdemux,
+        "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
+        GST_FOURCC_ARGS (fourcc), stream->caps);
+
+  } else if (stream->subtype == FOURCC_soun) {
+    int version, samplesize;
+    guint16 compression_id;
+
+    offset = 32;
+    if (len < 36)
+      goto corrupt_file;
+
+    version = QT_UINT32 (stsd_data + offset);
+    stream->n_channels = QT_UINT16 (stsd_data + offset + 8);
+    samplesize = QT_UINT16 (stsd_data + offset + 10);
+    compression_id = QT_UINT16 (stsd_data + offset + 12);
+    stream->rate = QT_FP32 (stsd_data + offset + 16);
+
+    GST_LOG_OBJECT (qtdemux, "version/rev:      %08x", version);
+    GST_LOG_OBJECT (qtdemux, "vendor:           %08x",
+        QT_UINT32 (stsd_data + offset + 4));
+    GST_LOG_OBJECT (qtdemux, "n_channels:       %d", stream->n_channels);
+    GST_LOG_OBJECT (qtdemux, "sample_size:      %d", samplesize);
+    GST_LOG_OBJECT (qtdemux, "compression_id:   %d", compression_id);
+    GST_LOG_OBJECT (qtdemux, "packet size:      %d",
+        QT_UINT16 (stsd_data + offset + 14));
+    GST_LOG_OBJECT (qtdemux, "sample rate:      %g", stream->rate);
+
+    if (compression_id == 0xfffe)
+      stream->sampled = TRUE;
+
+    /* first assume uncompressed audio */
+    stream->bytes_per_sample = samplesize / 8;
+    stream->samples_per_frame = stream->n_channels;
+    stream->bytes_per_frame = stream->n_channels * stream->bytes_per_sample;
+    stream->samples_per_packet = stream->samples_per_frame;
+    stream->bytes_per_packet = stream->bytes_per_sample;
+
+    offset = 52;
+    switch (fourcc) {
+        /* Yes, these have to be hard-coded */
+      case FOURCC_MAC6:
+      {
+        stream->samples_per_packet = 6;
+        stream->bytes_per_packet = 1;
+        stream->bytes_per_frame = 1 * stream->n_channels;
+        stream->bytes_per_sample = 1;
+        stream->samples_per_frame = 6 * stream->n_channels;
+        break;
+      }
+      case FOURCC_MAC3:
+      {
+        stream->samples_per_packet = 3;
+        stream->bytes_per_packet = 1;
+        stream->bytes_per_frame = 1 * stream->n_channels;
+        stream->bytes_per_sample = 1;
+        stream->samples_per_frame = 3 * stream->n_channels;
+        break;
+      }
+      case FOURCC_ima4:
+      {
+        stream->samples_per_packet = 64;
+        stream->bytes_per_packet = 34;
+        stream->bytes_per_frame = 34 * stream->n_channels;
+        stream->bytes_per_sample = 2;
+        stream->samples_per_frame = 64 * stream->n_channels;
+        break;
+      }
+      case FOURCC_ulaw:
+      case FOURCC_alaw:
+      {
+        stream->samples_per_packet = 1;
+        stream->bytes_per_packet = 1;
+        stream->bytes_per_frame = 1 * stream->n_channels;
+        stream->bytes_per_sample = 1;
+        stream->samples_per_frame = 1 * stream->n_channels;
+        break;
+      }
+      case FOURCC_agsm:
+      {
+        stream->samples_per_packet = 160;
+        stream->bytes_per_packet = 33;
+        stream->bytes_per_frame = 33 * stream->n_channels;
+        stream->bytes_per_sample = 2;
+        stream->samples_per_frame = 160 * stream->n_channels;
+        break;
+      }
+      default:
+        break;
+    }
+
+    if (version == 0x00010000) {
+      switch (fourcc) {
+        case FOURCC_twos:
+        case FOURCC_sowt:
+        case FOURCC_raw_:
+          break;
+        default:
+        {
+          /* only parse extra decoding config for non-pcm audio */
+          stream->samples_per_packet = QT_UINT32 (stsd_data + offset);
+          stream->bytes_per_packet = QT_UINT32 (stsd_data + offset + 4);
+          stream->bytes_per_frame = QT_UINT32 (stsd_data + offset + 8);
+          stream->bytes_per_sample = QT_UINT32 (stsd_data + offset + 12);
+
+          GST_LOG_OBJECT (qtdemux, "samples/packet:   %d",
+              stream->samples_per_packet);
+          GST_LOG_OBJECT (qtdemux, "bytes/packet:     %d",
+              stream->bytes_per_packet);
+          GST_LOG_OBJECT (qtdemux, "bytes/frame:      %d",
+              stream->bytes_per_frame);
+          GST_LOG_OBJECT (qtdemux, "bytes/sample:     %d",
+              stream->bytes_per_sample);
+
+          if (!stream->sampled && stream->bytes_per_packet) {
+            stream->samples_per_frame = (stream->bytes_per_frame /
+                stream->bytes_per_packet) * stream->samples_per_packet;
+            GST_LOG_OBJECT (qtdemux, "samples/frame:    %d",
+                stream->samples_per_frame);
+          }
+          break;
+        }
+      }
+    } else if (version == 0x00020000) {
+      union
+      {
+        gdouble fp;
+        guint64 val;
+      } qtfp;
+
+      stream->samples_per_packet = QT_UINT32 (stsd_data + offset);
+      qtfp.val = QT_UINT64 (stsd_data + offset + 4);
+      stream->rate = qtfp.fp;
+      stream->n_channels = QT_UINT32 (stsd_data + offset + 12);
+
+      GST_LOG_OBJECT (qtdemux, "samples/packet:   %d",
+          stream->samples_per_packet);
+      GST_LOG_OBJECT (qtdemux, "sample rate:      %g", stream->rate);
+      GST_LOG_OBJECT (qtdemux, "n_channels:       %d", stream->n_channels);
+
+    } else {
+      GST_WARNING_OBJECT (qtdemux, "unknown version %08x", version);
+    }
+
+    stream->caps = qtdemux_audio_caps (qtdemux, stream, fourcc, NULL, 0,
+        &codec);
+
+    switch (fourcc) {
+      case FOURCC_in24:
+      {
+        GNode *enda;
+        GNode *in24;
+
+        in24 = qtdemux_tree_get_child_by_type (stsd, FOURCC_in24);
+
+        enda = qtdemux_tree_get_child_by_type (in24, FOURCC_enda);
+        if (!enda) {
+          wave = qtdemux_tree_get_child_by_type (in24, FOURCC_wave);
+          if (wave)
+            enda = qtdemux_tree_get_child_by_type (wave, FOURCC_enda);
+        }
+        if (enda) {
+          gst_caps_set_simple (stream->caps,
+              "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, NULL);
+        }
+        break;
+      }
+      case FOURCC_owma:
+      {
+        GNode *owma;
+        const gchar *owma_data, *codec_name = NULL;
+        guint owma_len;
+        GstBuffer *buf;
+        gint version = 1;
+        /* from http://msdn.microsoft.com/en-us/library/dd757720(VS.85).aspx */
+        /* FIXME this should also be gst_riff_strf_auds,
+         * but the latter one is actually missing bits-per-sample :( */
+        typedef struct
+        {
+          gint16 wFormatTag;
+          gint16 nChannels;
+          gint32 nSamplesPerSec;
+          gint32 nAvgBytesPerSec;
+          gint16 nBlockAlign;
+          gint16 wBitsPerSample;
+          gint16 cbSize;
+        } WAVEFORMATEX;
+        WAVEFORMATEX *wfex;
+
+        GST_DEBUG_OBJECT (qtdemux, "parse owma");
+        owma = qtdemux_tree_get_child_by_type (stsd, FOURCC_owma);
+        if (!owma)
+          break;
+        owma_data = owma->data;
+        owma_len = QT_UINT32 (owma_data);
+        if (owma_len <= 54) {
+          GST_WARNING_OBJECT (qtdemux, "Too small owma header, skipping");
+          break;
+        }
+        wfex = (WAVEFORMATEX *) (owma_data + 36);
+        buf = gst_buffer_new_and_alloc (owma_len - 54);
+        memcpy (GST_BUFFER_DATA (buf), owma_data + 54, owma_len - 54);
+        if (wfex->wFormatTag == 0x0161) {
+          codec_name = "Windows Media Audio";
+          version = 2;
+        } else if (wfex->wFormatTag == 0x0162) {
+          codec_name = "Windows Media Audio 9 Pro";
+          version = 3;
+        } else if (wfex->wFormatTag == 0x0163) {
+          codec_name = "Windows Media Audio 9 Lossless";
+          /* is that correct? gstffmpegcodecmap.c is missing it, but
+           * fluendo codec seems to support it */
+          version = 4;
+        }
+
+        gst_caps_set_simple (stream->caps,
+            "codec_data", GST_TYPE_BUFFER, buf,
+            "wmaversion", G_TYPE_INT, version,
+            "block_align", G_TYPE_INT, GST_READ_UINT16_LE (&wfex->nBlockAlign),
+            "bitrate", G_TYPE_INT, GST_READ_UINT32_LE (&wfex->nAvgBytesPerSec),
+            "width", G_TYPE_INT, GST_READ_UINT16_LE (&wfex->wBitsPerSample),
+            "depth", G_TYPE_INT, GST_READ_UINT16_LE (&wfex->wBitsPerSample),
+            NULL);
+        gst_buffer_unref (buf);
+
+        if (codec_name) {
+          g_free (codec);
+          codec = g_strdup (codec_name);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+
+    if (codec) {
+      list = gst_tag_list_new ();
+      gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+          GST_TAG_AUDIO_CODEC, codec, NULL);
+      g_free (codec);
+      codec = NULL;
+    }
+
+    mp4a = qtdemux_tree_get_child_by_type (stsd, FOURCC_mp4a);
+    wave = NULL;
+    esds = NULL;
+    if (mp4a) {
+      wave = qtdemux_tree_get_child_by_type (mp4a, FOURCC_wave);
+      if (wave)
+        esds = qtdemux_tree_get_child_by_type (wave, FOURCC_esds);
+      if (!esds)
+        esds = qtdemux_tree_get_child_by_type (mp4a, FOURCC_esds);
+    }
+
+
+    /* If the fourcc's bottom 16 bits gives 'sm', then the top
+       16 bits is a byte-swapped wave-style codec identifier,
+       and we can find a WAVE header internally to a 'wave' atom here.
+       This can more clearly be thought of as 'ms' as the top 16 bits, and a
+       codec id as the bottom 16 bits - but byte-swapped to store in QT (which
+       is big-endian).
+     */
+    if ((fourcc & 0xffff) == (('s' << 8) | 'm')) {
+      if (len < offset + 20) {
+        GST_WARNING_OBJECT (qtdemux, "No wave atom in MS-style audio");
+      } else {
+        guint32 datalen = QT_UINT32 (stsd_data + offset + 16);
+        const guint8 *data = stsd_data + offset + 16;
+        GNode *wavenode;
+        GNode *waveheadernode;
+
+        wavenode = g_node_new ((guint8 *) data);
+        if (qtdemux_parse_node (qtdemux, wavenode, data, datalen)) {
+          const guint8 *waveheader;
+          guint32 headerlen;
+
+          waveheadernode = qtdemux_tree_get_child_by_type (wavenode, fourcc);
+          if (waveheadernode) {
+            waveheader = (const guint8 *) waveheadernode->data;
+            headerlen = QT_UINT32 (waveheader);
+
+            if (headerlen > 8) {
+              gst_riff_strf_auds *header = NULL;
+              GstBuffer *headerbuf;
+              GstBuffer *extra;
+
+              waveheader += 8;
+              headerlen -= 8;
+
+              headerbuf = gst_buffer_new ();
+              GST_BUFFER_DATA (headerbuf) = (guint8 *) waveheader;
+              GST_BUFFER_SIZE (headerbuf) = headerlen;
+
+              if (gst_riff_parse_strf_auds (GST_ELEMENT_CAST (qtdemux),
+                      headerbuf, &header, &extra)) {
+                gst_caps_unref (stream->caps);
+                stream->caps = gst_riff_create_audio_caps (header->format, NULL,
+                    header, extra, NULL, NULL);
+
+                if (extra)
+                  gst_buffer_unref (extra);
+              }
+            }
+          } else
+            GST_DEBUG ("Didn't find waveheadernode for this codec");
+        }
+        g_node_destroy (wavenode);
+      }
+    } else if (esds) {
+      gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
+    } else {
+      switch (fourcc) {
+#if 0
+          /* FIXME: what is in the chunk? */
+        case FOURCC_QDMC:
+        {
+          gint len = QT_UINT32 (stsd_data);
+
+          /* seems to be always = 116 = 0x74 */
+          break;
+        }
+#endif
+        case FOURCC_QDM2:
+        {
+          gint len = QT_UINT32 (stsd_data);
+
+          if (len > 0x4C) {
+            GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x4C);
+
+            memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x4C, len - 0x4C);
+            gst_caps_set_simple (stream->caps,
+                "codec_data", GST_TYPE_BUFFER, buf, NULL);
+            gst_buffer_unref (buf);
+          }
+          gst_caps_set_simple (stream->caps,
+              "samplesize", G_TYPE_INT, samplesize, NULL);
+          break;
+        }
+        case FOURCC_alac:
+        {
+          GNode *alac, *wave = NULL;
+
+          /* apparently, m4a has this atom appended directly in the stsd entry,
+           * while mov has it in a wave atom */
+          alac = qtdemux_tree_get_child_by_type (stsd, FOURCC_alac);
+          if (alac) {
+            /* alac now refers to stsd entry atom */
+            wave = qtdemux_tree_get_child_by_type (alac, FOURCC_wave);
+            if (wave)
+              alac = qtdemux_tree_get_child_by_type (wave, FOURCC_alac);
+            else
+              alac = qtdemux_tree_get_child_by_type (alac, FOURCC_alac);
+          }
+          if (alac) {
+            gint len = QT_UINT32 (alac->data);
+            GstBuffer *buf;
+
+            if (len < 36) {
+              GST_DEBUG_OBJECT (qtdemux,
+                  "discarding alac atom with unexpected len %d", len);
+            } else {
+              /* codec-data contains alac atom size and prefix,
+               * ffmpeg likes it that way, not quite gst-ish though ...*/
+              buf = gst_buffer_new_and_alloc (len);
+              memcpy (GST_BUFFER_DATA (buf), alac->data, len);
+              gst_caps_set_simple (stream->caps,
+                  "codec_data", GST_TYPE_BUFFER, buf, NULL);
+              gst_buffer_unref (buf);
+            }
+          }
+          gst_caps_set_simple (stream->caps,
+              "samplesize", G_TYPE_INT, samplesize, NULL);
+          break;
+        }
+        case FOURCC_samr:
+        {
+          gint len = QT_UINT32 (stsd_data);
+
+          if (len > 0x34) {
+            GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x34);
+
+            memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x34, len - 0x34);
+
+            gst_caps_set_simple (stream->caps,
+                "codec_data", GST_TYPE_BUFFER, buf, NULL);
+            gst_buffer_unref (buf);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    GST_INFO_OBJECT (qtdemux,
+        "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
+        GST_FOURCC_ARGS (fourcc), stream->caps);
+
+  } else if (stream->subtype == FOURCC_strm) {
+    if (fourcc == FOURCC_rtsp) {
+      stream->redirect_uri = qtdemux_get_rtsp_uri_from_hndl (qtdemux, minf);
+    } else {
+      GST_INFO_OBJECT (qtdemux, "unhandled stream type %" GST_FOURCC_FORMAT,
+          GST_FOURCC_ARGS (fourcc));
+      goto unknown_stream;
+    }
+    stream->sampled = TRUE;
+  } else if (stream->subtype == FOURCC_subp || stream->subtype == FOURCC_text) {
+
+    stream->sampled = TRUE;
+
+    offset = 16;
+
+    stream->caps =
+        qtdemux_sub_caps (qtdemux, stream, fourcc, stsd_data, &codec);
+    if (codec) {
+      list = gst_tag_list_new ();
+      gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+          GST_TAG_SUBTITLE_CODEC, codec, NULL);
+      g_free (codec);
+      codec = NULL;
+    }
+
+    /* hunt for sort-of codec data */
+    switch (fourcc) {
+      case FOURCC_mp4s:
+      {
+        guint len;
+        const guint8 *data;
+
+        /* look for palette */
+        /* target mp4s atom */
+        len = QT_UINT32 (stsd_data + offset);
+        data = stsd_data + offset;
+        /* verify sufficient length,
+         * and esds present with decConfigDescr of expected size and position */
+        if ((len >= 106 + 8)
+            && (QT_FOURCC (data + 8 + 8 + 4) == FOURCC_esds)
+            && (QT_UINT16 (data + 8 + 40) == 0x0540)) {
+          GstStructure *s;
+          guint32 clut[16];
+          gint i;
+
+          /* move to decConfigDescr data */
+          data = data + 8 + 42;
+          for (i = 0; i < 16; i++) {
+            clut[i] = QT_UINT32 (data);
+            data += 4;
+          }
+
+          s = gst_structure_new ("application/x-gst-dvd", "event",
+              G_TYPE_STRING, "dvd-spu-clut-change",
+              "clut00", G_TYPE_INT, clut[0], "clut01", G_TYPE_INT, clut[1],
+              "clut02", G_TYPE_INT, clut[2], "clut03", G_TYPE_INT, clut[3],
+              "clut04", G_TYPE_INT, clut[4], "clut05", G_TYPE_INT, clut[5],
+              "clut06", G_TYPE_INT, clut[6], "clut07", G_TYPE_INT, clut[7],
+              "clut08", G_TYPE_INT, clut[8], "clut09", G_TYPE_INT, clut[9],
+              "clut10", G_TYPE_INT, clut[10], "clut11", G_TYPE_INT, clut[11],
+              "clut12", G_TYPE_INT, clut[12], "clut13", G_TYPE_INT, clut[13],
+              "clut14", G_TYPE_INT, clut[14], "clut15", G_TYPE_INT, clut[15],
+              NULL);
+
+          /* store event and trigger custom processing */
+          stream->pending_event =
+              gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
+          stream->need_process = TRUE;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  } else {
+    goto unknown_stream;
+  }
+
+  /* promote to sampled format */
+  if (stream->fourcc == FOURCC_samr) {
+    /* force mono 8000 Hz for AMR */
+    stream->sampled = TRUE;
+    stream->n_channels = 1;
+    stream->rate = 8000;
+  } else if (stream->fourcc == FOURCC_sawb) {
+    /* force mono 16000 Hz for AMR-WB */
+    stream->sampled = TRUE;
+    stream->n_channels = 1;
+    stream->rate = 16000;
+  } else if (stream->fourcc == FOURCC_mp4a) {
+    stream->sampled = TRUE;
+  }
+
+  /* collect sample information */
+  if (!qtdemux_stbl_init (qtdemux, stream, stbl))
+    goto samples_failed;
+
+  if (qtdemux->fragmented) {
+    guint32 dummy;
+    guint64 offset;
+
+    /* need all moov samples as basis; probably not many if any at all */
+    /* prevent moof parsing taking of at this time */
+    offset = qtdemux->moof_offset;
+    qtdemux->moof_offset = 0;
+    if (stream->n_samples &&
+        !qtdemux_parse_samples (qtdemux, stream, stream->n_samples - 1)) {
+      qtdemux->moof_offset = offset;
+      goto samples_failed;
+    }
+    qtdemux->moof_offset = 0;
+    /* movie duration more reliable in this case (e.g. mehd) */
+    if (qtdemux->segment.duration &&
+        GST_CLOCK_TIME_IS_VALID (qtdemux->segment.duration))
+      stream->duration = gst_util_uint64_scale (qtdemux->segment.duration,
+          stream->timescale, GST_SECOND);
+    /* need defaults for fragments */
+    qtdemux_parse_trex (qtdemux, stream, &dummy, &dummy, &dummy);
+  }
+
+  /* configure segments */
+  if (!qtdemux_parse_segments (qtdemux, stream, trak))
+    goto segments_failed;
+
+  /* add some language tag, if useful */
+  if (stream->lang_id[0] != '\0' && strcmp (stream->lang_id, "unk") &&
+      strcmp (stream->lang_id, "und")) {
+    const gchar *lang_code;
+
+    if (!list)
+      list = gst_tag_list_new ();
+
+    /* convert ISO 639-2 code to ISO 639-1 */
+    lang_code = gst_tag_get_language_code (stream->lang_id);
+    gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+        GST_TAG_LANGUAGE_CODE, (lang_code) ? lang_code : stream->lang_id, NULL);
+  }
+
+  /* now we are ready to add the stream */
+  if (qtdemux->n_streams >= GST_QTDEMUX_MAX_STREAMS)
+    goto too_many_streams;
+
+  stream->pending_tags = list;
+  qtdemux->streams[qtdemux->n_streams] = stream;
+  qtdemux->n_streams++;
+  GST_DEBUG_OBJECT (qtdemux, "n_streams is now %d", qtdemux->n_streams);
+
+  return TRUE;
+
+/* ERRORS */
+corrupt_file:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX,
+        (_("This file is corrupt and cannot be played.")), (NULL));
+    g_free (stream);
+    return FALSE;
+  }
+error_encrypted:
+  {
+    GST_ELEMENT_ERROR (qtdemux, STREAM, DECRYPT, (NULL), (NULL));
+    g_free (stream);
+    return FALSE;
+  }
+samples_failed:
+segments_failed:
+  {
+    /* we posted an error already */
+    /* free stbl sub-atoms */
+    gst_qtdemux_stbl_free (stream);
+    g_free (stream);
+    return FALSE;
+  }
+unknown_stream:
+  {
+    GST_INFO_OBJECT (qtdemux, "unknown subtype %" GST_FOURCC_FORMAT,
+        GST_FOURCC_ARGS (stream->subtype));
+    g_free (stream);
+    return TRUE;
+  }
+too_many_streams:
+  {
+    GST_ELEMENT_WARNING (qtdemux, STREAM, DEMUX,
+        (_("This file contains too many streams. Only playing first %d"),
+            GST_QTDEMUX_MAX_STREAMS), (NULL));
+    return TRUE;
+  }
+}
+
+static GstFlowReturn
+qtdemux_expose_streams (GstQTDemux * qtdemux)
+{
+  gint i;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  GST_DEBUG_OBJECT (qtdemux, "exposing streams");
+
+  for (i = 0; ret == GST_FLOW_OK && i < qtdemux->n_streams; i++) {
+    QtDemuxStream *stream = qtdemux->streams[i];
+    guint32 sample_num = 0;
+    guint samples = 20;
+    GArray *durations;
+    GstTagList *list;
+
+    GST_DEBUG_OBJECT (qtdemux, "stream %d, id %d, fourcc %" GST_FOURCC_FORMAT,
+        i, stream->track_id, GST_FOURCC_ARGS (stream->fourcc));
+
+    if (qtdemux->fragmented) {
+      /* need all moov samples first */
+      GST_OBJECT_LOCK (qtdemux);
+      while (stream->n_samples == 0)
+        if ((ret = qtdemux_add_fragmented_samples (qtdemux)) != GST_FLOW_OK)
+          break;
+      GST_OBJECT_UNLOCK (qtdemux);
+    } else {
+      /* discard any stray moof */
+      qtdemux->moof_offset = 0;
+    }
+
+    /* prepare braking */
+    if (ret != GST_FLOW_ERROR)
+      ret = GST_FLOW_OK;
+
+    /* in pull mode, we should have parsed some sample info by now;
+     * and quite some code will not handle no samples.
+     * in push mode, we'll just have to deal with it */
+    if (G_UNLIKELY (qtdemux->pullbased && !stream->n_samples)) {
+      GST_DEBUG_OBJECT (qtdemux, "no samples for stream; discarding");
+      gst_qtdemux_stream_free (qtdemux, stream);
+      memmove (&(qtdemux->streams[i]), &(qtdemux->streams[i + 1]),
+          sizeof (QtDemuxStream *) * (GST_QTDEMUX_MAX_STREAMS - i - 1));
+      qtdemux->streams[GST_QTDEMUX_MAX_STREAMS - 1] = NULL;
+      qtdemux->n_streams--;
+      i--;
+      continue;
+    }
+
+    /* parse number of initial sample to set frame rate cap */
+    while (sample_num < stream->n_samples && sample_num < samples) {
+      if (!qtdemux_parse_samples (qtdemux, stream, sample_num))
+        break;
+      ++sample_num;
+    }
+    /* collect and sort durations */
+    samples = MIN (stream->stbl_index + 1, samples);
+    GST_DEBUG_OBJECT (qtdemux, "%d samples for framerate", samples);
+    if (samples) {
+      durations = g_array_sized_new (FALSE, FALSE, sizeof (guint32), samples);
+      sample_num = 0;
+      while (sample_num < samples) {
+        g_array_append_val (durations, stream->samples[sample_num].duration);
+        sample_num++;
+      }
+      g_array_sort (durations, less_than);
+      stream->min_duration = g_array_index (durations, guint32, samples / 2);
+      g_array_free (durations, TRUE);
+    }
+
+    /* now we have all info and can expose */
+    list = stream->pending_tags;
+    stream->pending_tags = NULL;
+    gst_qtdemux_add_stream (qtdemux, stream, list);
+  }
+
+  gst_element_no_more_pads (GST_ELEMENT_CAST (qtdemux));
+
+  /* check if we should post a redirect in case there is a single trak
+   * and it is a redirecting trak */
+  if (qtdemux->n_streams == 1 && qtdemux->streams[0]->redirect_uri != NULL) {
+    GstMessage *m;
+
+    qtdemux_post_global_tags (qtdemux);
+
+    GST_INFO_OBJECT (qtdemux, "Issuing a redirect due to a single track with "
+        "an external content");
+    m = gst_message_new_element (GST_OBJECT_CAST (qtdemux),
+        gst_structure_new ("redirect",
+            "new-location", G_TYPE_STRING, qtdemux->streams[0]->redirect_uri,
+            NULL));
+    gst_element_post_message (GST_ELEMENT_CAST (qtdemux), m);
+    qtdemux->posted_redirect = TRUE;
+  }
+
+  return ret;
+}
+
+/* check if major or compatible brand is 3GP */
+static inline gboolean
+qtdemux_is_brand_3gp (GstQTDemux * qtdemux, gboolean major)
+{
+  if (major) {
+    return ((qtdemux->major_brand & GST_MAKE_FOURCC (255, 255, 0, 0)) ==
+        GST_MAKE_FOURCC ('3', 'g', 0, 0));
+  } else if (qtdemux->comp_brands != NULL) {
+    guint8 *data = GST_BUFFER_DATA (qtdemux->comp_brands);
+    guint size = GST_BUFFER_SIZE (qtdemux->comp_brands);
+    gboolean res = FALSE;
+
+    while (size >= 4) {
+      res = res || ((QT_FOURCC (data) & GST_MAKE_FOURCC (255, 255, 0, 0)) ==
+          GST_MAKE_FOURCC ('3', 'g', 0, 0));
+      data += 4;
+      size -= 4;
+    }
+    return res;
+  } else {
+    return FALSE;
+  }
+}
+
+/* check if tag is a spec'ed 3GP tag keyword storing a string */
+static inline gboolean
+qtdemux_is_string_tag_3gp (GstQTDemux * qtdemux, guint32 fourcc)
+{
+  return fourcc == FOURCC_cprt || fourcc == FOURCC_gnre || fourcc == FOURCC_titl
+      || fourcc == FOURCC_dscp || fourcc == FOURCC_perf || fourcc == FOURCC_auth
+      || fourcc == FOURCC_albm;
+}
+
+static void
+qtdemux_tag_add_location (GstQTDemux * qtdemux, const char *tag,
+    const char *dummy, GNode * node)
+{
+  const gchar *env_vars[] = { "GST_QT_TAG_ENCODING", "GST_TAG_ENCODING", NULL };
+  int offset;
+  char *name;
+  gchar *data;
+  gdouble longitude, latitude, altitude;
+  gint len;
+
+  len = QT_UINT32 (node->data);
+  if (len <= 14)
+    goto short_read;
+
+  data = node->data;
+  offset = 14;
+
+  /* TODO: language code skipped */
+
+  name = gst_tag_freeform_string_to_utf8 (data + offset, -1, env_vars);
+
+  if (!name) {
+    /* do not alarm in trivial case, but bail out otherwise */
+    if (*(data + offset) != 0) {
+      GST_DEBUG_OBJECT (qtdemux, "failed to convert %s tag to UTF-8, "
+          "giving up", tag);
+    }
+  } else {
+    gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+        GST_TAG_GEO_LOCATION_NAME, name, NULL);
+    offset += strlen (name);
+    g_free (name);
+  }
+
+  if (len < offset + 2 + 4 + 4 + 4)
+    goto short_read;
+
+  /* +1 +1 = skip null-terminator and location role byte */
+  offset += 1 + 1;
+  /* table in spec says unsigned, semantics say negative has meaning ... */
+  longitude = QT_SFP32 (data + offset);
+
+  offset += 4;
+  latitude = QT_SFP32 (data + offset);
+
+  offset += 4;
+  altitude = QT_SFP32 (data + offset);
+
+  /* one invalid means all are invalid */
+  if (longitude >= -180.0 && longitude <= 180.0 &&
+      latitude >= -90.0 && latitude <= 90.0) {
+    gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+        GST_TAG_GEO_LOCATION_LATITUDE, latitude,
+        GST_TAG_GEO_LOCATION_LONGITUDE, longitude,
+        GST_TAG_GEO_LOCATION_ELEVATION, altitude, NULL);
+  }
+
+  /* TODO: no GST_TAG_, so astronomical body and additional notes skipped */
+
+  return;
+
+  /* ERRORS */
+short_read:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "short read parsing 3GP location");
+    return;
+  }
+}
+
+
+static void
+qtdemux_tag_add_year (GstQTDemux * qtdemux, const char *tag, const char *dummy,
+    GNode * node)
+{
+  guint16 y;
+  GDate *date;
+  gint len;
+
+  len = QT_UINT32 (node->data);
+  if (len < 14)
+    return;
+
+  y = QT_UINT16 ((guint8 *) node->data + 12);
+  if (y == 0) {
+    GST_DEBUG_OBJECT (qtdemux, "year: %u is not a valid year", y);
+    return;
+  }
+  GST_DEBUG_OBJECT (qtdemux, "year: %u", y);
+
+  date = g_date_new_dmy (1, 1, y);
+  gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag, date, NULL);
+  g_date_free (date);
+}
+
+static void
+qtdemux_tag_add_classification (GstQTDemux * qtdemux, const char *tag,
+    const char *dummy, GNode * node)
+{
+  int offset;
+  char *tag_str = NULL;
+  guint8 *entity;
+  guint16 table;
+  gint len;
+
+  len = QT_UINT32 (node->data);
+  if (len <= 20)
+    goto short_read;
+
+  offset = 12;
+  entity = (guint8 *) node->data + offset;
+  if (entity[0] == 0 || entity[1] == 0 || entity[2] == 0 || entity[3] == 0) {
+    GST_DEBUG_OBJECT (qtdemux,
+        "classification info: %c%c%c%c invalid classification entity",
+        entity[0], entity[1], entity[2], entity[3]);
+    return;
+  }
+
+  offset += 4;
+  table = QT_UINT16 ((guint8 *) node->data + offset);
+
+  /* Language code skipped */
+
+  offset += 4;
+
+  /* Tag format: "XXXX://Y[YYYY]/classification info string"
+   * XXXX: classification entity, fixed length 4 chars.
+   * Y[YYYY]: classification table, max 5 chars.
+   */
+  tag_str = g_strdup_printf ("----://%u/%s",
+      table, (char *) node->data + offset);
+
+  /* memcpy To be sure we're preserving byte order */
+  memcpy (tag_str, entity, 4);
+  GST_DEBUG_OBJECT (qtdemux, "classification info: %s", tag_str);
+
+  gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_APPEND, tag,
+      tag_str, NULL);
+
+  g_free (tag_str);
+
+  return;
+
+  /* ERRORS */
+short_read:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "short read parsing 3GP classification");
+    return;
+  }
+}
+
+static gboolean
+qtdemux_tag_add_str_full (GstQTDemux * qtdemux, const char *tag,
+    const char *dummy, GNode * node)
+{
+  const gchar *env_vars[] = { "GST_QT_TAG_ENCODING", "GST_TAG_ENCODING", NULL };
+  GNode *data;
+  char *s;
+  int len;
+  guint32 type;
+  int offset;
+  gboolean ret = TRUE;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    if (type == 0x00000001 && len > 16) {
+      s = gst_tag_freeform_string_to_utf8 ((char *) data->data + 16, len - 16,
+          env_vars);
+      if (s) {
+        GST_DEBUG_OBJECT (qtdemux, "adding tag %s", GST_STR_NULL (s));
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag, s,
+            NULL);
+        g_free (s);
+      } else {
+        GST_DEBUG_OBJECT (qtdemux, "failed to convert %s tag to UTF-8", tag);
+      }
+    }
+  } else {
+    len = QT_UINT32 (node->data);
+    type = QT_UINT32 ((guint8 *) node->data + 4);
+    if ((type >> 24) == 0xa9) {
+      /* Type starts with the (C) symbol, so the next 32 bits are
+       * the language code, which we ignore */
+      offset = 12;
+      GST_DEBUG_OBJECT (qtdemux, "found international text tag");
+    } else if (len > 14 && qtdemux_is_string_tag_3gp (qtdemux,
+            QT_FOURCC ((guint8 *) node->data + 4))) {
+      guint32 type = QT_UINT32 ((guint8 *) node->data + 8);
+
+      /* we go for 3GP style encoding if major brands claims so,
+       * or if no hope for data be ok UTF-8, and compatible 3GP brand present */
+      if (qtdemux_is_brand_3gp (qtdemux, TRUE) ||
+          (qtdemux_is_brand_3gp (qtdemux, FALSE) &&
+              ((type & 0x00FFFFFF) == 0x0) && (type >> 24 <= 0xF))) {
+        offset = 14;
+        /* 16-bit Language code is ignored here as well */
+        GST_DEBUG_OBJECT (qtdemux, "found 3gpp text tag");
+      } else {
+        goto normal;
+      }
+    } else {
+    normal:
+      offset = 8;
+      GST_DEBUG_OBJECT (qtdemux, "found normal text tag");
+      ret = FALSE;              /* may have to fallback */
+    }
+    s = gst_tag_freeform_string_to_utf8 ((char *) node->data + offset,
+        len - offset, env_vars);
+    if (s) {
+      GST_DEBUG_OBJECT (qtdemux, "adding tag %s", GST_STR_NULL (s));
+      gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag, s, NULL);
+      g_free (s);
+      ret = TRUE;
+    } else {
+      GST_DEBUG_OBJECT (qtdemux, "failed to convert %s tag to UTF-8", tag);
+    }
+  }
+  return ret;
+}
+
+static void
+qtdemux_tag_add_str (GstQTDemux * qtdemux, const char *tag,
+    const char *dummy, GNode * node)
+{
+  qtdemux_tag_add_str_full (qtdemux, tag, dummy, node);
+}
+
+static void
+qtdemux_tag_add_keywords (GstQTDemux * qtdemux, const char *tag,
+    const char *dummy, GNode * node)
+{
+  const gchar *env_vars[] = { "GST_QT_TAG_ENCODING", "GST_TAG_ENCODING", NULL };
+  guint8 *data;
+  char *s, *t, *k = NULL;
+  int len;
+  int offset;
+  int count;
+
+  /* first try normal string tag if major brand not 3GP */
+  if (!qtdemux_is_brand_3gp (qtdemux, TRUE)) {
+    if (!qtdemux_tag_add_str_full (qtdemux, tag, dummy, node)) {
+      /* hm, that did not work, maybe 3gpp storage in non-3gpp major brand;
+       * let's try it 3gpp way after minor safety check */
+      data = node->data;
+      if (QT_UINT32 (data) < 15 || !qtdemux_is_brand_3gp (qtdemux, FALSE))
+        return;
+    } else
+      return;
+  }
+
+  GST_DEBUG_OBJECT (qtdemux, "found 3gpp keyword tag");
+
+  data = node->data;
+
+  len = QT_UINT32 (data);
+  if (len < 15)
+    goto short_read;
+
+  count = QT_UINT8 (data + 14);
+  offset = 15;
+  for (; count; count--) {
+    gint slen;
+
+    if (offset + 1 > len)
+      goto short_read;
+    slen = QT_UINT8 (data + offset);
+    offset += 1;
+    if (offset + slen > len)
+      goto short_read;
+    s = gst_tag_freeform_string_to_utf8 ((char *) node->data + offset,
+        slen, env_vars);
+    if (s) {
+      GST_DEBUG_OBJECT (qtdemux, "adding keyword %s", GST_STR_NULL (s));
+      if (k) {
+        t = g_strjoin (",", k, s, NULL);
+        g_free (s);
+        g_free (k);
+        k = t;
+      } else {
+        k = s;
+      }
+    } else {
+      GST_DEBUG_OBJECT (qtdemux, "failed to convert keyword to UTF-8");
+    }
+    offset += slen;
+  }
+
+done:
+  if (k) {
+    GST_DEBUG_OBJECT (qtdemux, "adding tag %s", GST_STR_NULL (k));
+    gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag, k, NULL);
+  }
+  g_free (k);
+
+  return;
+
+  /* ERRORS */
+short_read:
+  {
+    GST_DEBUG_OBJECT (qtdemux, "short read parsing 3GP keywords");
+    goto done;
+  }
+}
+
+static void
+qtdemux_tag_add_num (GstQTDemux * qtdemux, const char *tag1,
+    const char *tag2, GNode * node)
+{
+  GNode *data;
+  int len;
+  int type;
+  int n1, n2;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    if (type == 0x00000000 && len >= 22) {
+      n1 = QT_UINT16 ((guint8 *) data->data + 18);
+      n2 = QT_UINT16 ((guint8 *) data->data + 20);
+      if (n1 > 0) {
+        GST_DEBUG_OBJECT (qtdemux, "adding tag %s=%d", tag1, n1);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+            tag1, n1, NULL);
+      }
+      if (n2 > 0) {
+        GST_DEBUG_OBJECT (qtdemux, "adding tag %s=%d", tag2, n2);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+            tag2, n2, NULL);
+      }
+    }
+  }
+}
+
+static void
+qtdemux_tag_add_tmpo (GstQTDemux * qtdemux, const char *tag1, const char *dummy,
+    GNode * node)
+{
+  GNode *data;
+  int len;
+  int type;
+  int n1;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    GST_DEBUG_OBJECT (qtdemux, "have tempo tag, type=%d,len=%d", type, len);
+    /* some files wrongly have a type 0x0f=15, but it should be 0x15 */
+    if ((type == 0x00000015 || type == 0x0000000f) && len >= 18) {
+      n1 = QT_UINT16 ((guint8 *) data->data + 16);
+      if (n1) {
+        /* do not add bpm=0 */
+        GST_DEBUG_OBJECT (qtdemux, "adding tag %d", n1);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+            tag1, (gdouble) n1, NULL);
+      }
+    }
+  }
+}
+
+static void
+qtdemux_tag_add_uint32 (GstQTDemux * qtdemux, const char *tag1,
+    const char *dummy, GNode * node)
+{
+  GNode *data;
+  int len;
+  int type;
+  guint32 num;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    GST_DEBUG_OBJECT (qtdemux, "have %s tag, type=%d,len=%d", tag1, type, len);
+    /* some files wrongly have a type 0x0f=15, but it should be 0x15 */
+    if ((type == 0x00000015 || type == 0x0000000f) && len >= 20) {
+      num = QT_UINT32 ((guint8 *) data->data + 16);
+      if (num) {
+        /* do not add num=0 */
+        GST_DEBUG_OBJECT (qtdemux, "adding tag %d", num);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+            tag1, num, NULL);
+      }
+    }
+  }
+}
+
+static void
+qtdemux_tag_add_covr (GstQTDemux * qtdemux, const char *tag1, const char *dummy,
+    GNode * node)
+{
+  GNode *data;
+  int len;
+  int type;
+  GstBuffer *buf;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    GST_DEBUG_OBJECT (qtdemux, "have covr tag, type=%d,len=%d", type, len);
+    if ((type == 0x0000000d || type == 0x0000000e) && len > 16) {
+      if ((buf = gst_tag_image_data_to_image_buffer ((guint8 *) data->data + 16,
+                  len - 16, GST_TAG_IMAGE_TYPE_NONE))) {
+        GST_DEBUG_OBJECT (qtdemux, "adding tag size %d", len - 16);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+            tag1, buf, NULL);
+        gst_buffer_unref (buf);
+      }
+    }
+  }
+}
+
+static void
+qtdemux_tag_add_date (GstQTDemux * qtdemux, const char *tag, const char *dummy,
+    GNode * node)
+{
+  GNode *data;
+  char *s;
+  int len;
+  int type;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (data) {
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    if (type == 0x00000001 && len > 16) {
+      guint y, m = 1, d = 1;
+      gint ret;
+
+      s = g_strndup ((char *) data->data + 16, len - 16);
+      GST_DEBUG_OBJECT (qtdemux, "adding date '%s'", s);
+      ret = sscanf (s, "%u-%u-%u", &y, &m, &d);
+      if (ret >= 1 && y > 1500 && y < 3000) {
+        GDate *date;
+
+        date = g_date_new_dmy (d, m, y);
+        gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag,
+            date, NULL);
+        g_date_free (date);
+      } else {
+        GST_DEBUG_OBJECT (qtdemux, "could not parse date string '%s'", s);
+      }
+      g_free (s);
+    }
+  }
+}
+
+static void
+qtdemux_tag_add_gnre (GstQTDemux * qtdemux, const char *tag, const char *dummy,
+    GNode * node)
+{
+  GNode *data;
+
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+
+  /* re-route to normal string tag if major brand says so
+   * or no data atom and compatible brand suggests so */
+  if (qtdemux_is_brand_3gp (qtdemux, TRUE) ||
+      (qtdemux_is_brand_3gp (qtdemux, FALSE) && !data)) {
+    qtdemux_tag_add_str (qtdemux, tag, dummy, node);
+    return;
+  }
+
+  if (data) {
+    guint len, type, n;
+
+    len = QT_UINT32 (data->data);
+    type = QT_UINT32 ((guint8 *) data->data + 8);
+    if (type == 0x00000000 && len >= 18) {
+      n = QT_UINT16 ((guint8 *) data->data + 16);
+      if (n > 0) {
+        const gchar *genre;
+
+        genre = gst_tag_id3_genre_get (n - 1);
+        if (genre != NULL) {
+          GST_DEBUG_OBJECT (qtdemux, "adding %d [%s]", n, genre);
+          gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
+              tag, genre, NULL);
+        }
+      }
+    }
+  }
+}
+
+static void
+qtdemux_add_double_tag_from_str (GstQTDemux * demux, const gchar * tag,
+    guint8 * data, guint32 datasize)
+{
+  gdouble value;
+  gchar *datacopy;
+
+  /* make a copy to have \0 at the end */
+  datacopy = g_strndup ((gchar *) data, datasize);
+
+  /* convert the str to double */
+  if (sscanf (datacopy, "%lf", &value) == 1) {
+    GST_DEBUG_OBJECT (demux, "adding tag: %s [%s]", tag, datacopy);
+    gst_tag_list_add (demux->tag_list, GST_TAG_MERGE_REPLACE, tag, value, NULL);
+  } else {
+    GST_WARNING_OBJECT (demux, "Failed to parse double from string: %s",
+        datacopy);
+  }
+  g_free (datacopy);
+}
+
+
+static void
+qtdemux_tag_add_revdns (GstQTDemux * demux, const char *tag,
+    const char *tag_bis, GNode * node)
+{
+  GNode *mean;
+  GNode *name;
+  GNode *data;
+  guint32 meansize;
+  guint32 namesize;
+  guint32 datatype;
+  guint32 datasize;
+  const gchar *meanstr;
+  const gchar *namestr;
+
+  /* checking the whole ---- atom size for consistency */
+  if (QT_UINT32 (node->data) <= 4 + 12 + 12 + 16) {
+    GST_WARNING_OBJECT (demux, "Tag ---- atom is too small, ignoring");
+    return;
+  }
+
+  mean = qtdemux_tree_get_child_by_type (node, FOURCC_mean);
+  if (!mean) {
+    GST_WARNING_OBJECT (demux, "No 'mean' atom found");
+    return;
+  }
+
+  meansize = QT_UINT32 (mean->data);
+  if (meansize <= 12) {
+    GST_WARNING_OBJECT (demux, "Small mean atom, ignoring the whole tag");
+    return;
+  }
+  meanstr = ((gchar *) mean->data) + 12;
+
+  name = qtdemux_tree_get_child_by_type (node, FOURCC_name);
+  if (!name) {
+    GST_WARNING_OBJECT (demux, "'name' atom not found, ignoring tag");
+    return;
+  }
+
+  namesize = QT_UINT32 (name->data);
+  if (namesize <= 12) {
+    GST_WARNING_OBJECT (demux, "'name' atom is too small, ignoring tag");
+    return;
+  }
+  namestr = ((gchar *) name->data) + 12;
+
+  /*
+   * Data atom is:
+   * uint32 - size
+   * uint32 - name
+   * uint8  - version
+   * uint24 - data type
+   * uint32 - all 0
+   * rest   - the data
+   */
+  data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
+  if (!data) {
+    GST_WARNING_OBJECT (demux, "No data atom in this tag");
+    return;
+  }
+  datasize = QT_UINT32 (data->data);
+  if (datasize <= 16) {
+    GST_WARNING_OBJECT (demux, "Data atom too small");
+    return;
+  }
+  datatype = QT_UINT32 (((gchar *) data->data) + 8) & 0xFFFFFF;
+
+  if (strncmp (meanstr, "com.apple.iTunes", meansize - 12) == 0) {
+    static const struct
+    {
+      const gchar name[28];
+      const gchar tag[28];
+    } tags[] = {
+      {
+      "replaygain_track_gain", GST_TAG_TRACK_GAIN}, {
+      "replaygain_track_peak", GST_TAG_TRACK_PEAK}, {
+      "replaygain_album_gain", GST_TAG_ALBUM_GAIN}, {
+      "replaygain_album_peak", GST_TAG_ALBUM_PEAK}, {
+      "MusicBrainz Track Id", GST_TAG_MUSICBRAINZ_TRACKID}, {
+      "MusicBrainz Artist Id", GST_TAG_MUSICBRAINZ_ARTISTID}, {
+      "MusicBrainz Album Id", GST_TAG_MUSICBRAINZ_ALBUMID}, {
+      "MusicBrainz Album Artist Id", GST_TAG_MUSICBRAINZ_ALBUMARTISTID}
+    };
+    int i;
+
+    for (i = 0; i < G_N_ELEMENTS (tags); ++i) {
+      if (!g_ascii_strncasecmp (tags[i].name, namestr, namesize - 12)) {
+        switch (gst_tag_get_type (tags[i].tag)) {
+          case G_TYPE_DOUBLE:
+            qtdemux_add_double_tag_from_str (demux, tags[i].tag,
+                ((guint8 *) data->data) + 16, datasize - 16);
+            break;
+          case G_TYPE_STRING:
+            qtdemux_tag_add_str (demux, tags[i].tag, NULL, node);
+            break;
+          default:
+            /* not reached */
+            break;
+        }
+        break;
+      }
+    }
+    if (i == G_N_ELEMENTS (tags))
+      goto unknown_tag;
+  } else {
+    goto unknown_tag;
+  }
+
+  return;
+
+/* errors */
+unknown_tag:
+  {
+    gchar *namestr_dbg;
+    gchar *meanstr_dbg;
+
+    meanstr_dbg = g_strndup (meanstr, meansize - 12);
+    namestr_dbg = g_strndup (namestr, namesize - 12);
+
+    GST_WARNING_OBJECT (demux, "This tag %s:%s type:%u is not mapped, "
+        "file a bug at bugzilla.gnome.org", meanstr_dbg, namestr_dbg, datatype);
+
+    g_free (namestr_dbg);
+    g_free (meanstr_dbg);
+    return;
+  }
+}
+
+typedef void (*GstQTDemuxAddTagFunc) (GstQTDemux * demux,
+    const char *tag, const char *tag_bis, GNode * node);
+
+/* unmapped tags
+FOURCC_pcst -> if media is a podcast -> bool
+FOURCC_cpil -> if media is part of a compilation -> bool
+FOURCC_pgap -> if media is part of a gapless context -> bool
+FOURCC_tven -> the tv episode id e.g. S01E23 -> str
+*/
+
+static const struct
+{
+  guint32 fourcc;
+  const gchar *gst_tag;
+  const gchar *gst_tag_bis;
+  const GstQTDemuxAddTagFunc func;
+} add_funcs[] = {
+  {
+  FOURCC__nam, GST_TAG_TITLE, NULL, qtdemux_tag_add_str}, {
+  FOURCC_titl, GST_TAG_TITLE, NULL, qtdemux_tag_add_str}, {
+  FOURCC__grp, GST_TAG_GROUPING, NULL, qtdemux_tag_add_str}, {
+  FOURCC__wrt, GST_TAG_COMPOSER, NULL, qtdemux_tag_add_str}, {
+  FOURCC__ART, GST_TAG_ARTIST, NULL, qtdemux_tag_add_str}, {
+  FOURCC_aART, GST_TAG_ALBUM_ARTIST, NULL, qtdemux_tag_add_str}, {
+  FOURCC_perf, GST_TAG_ARTIST, NULL, qtdemux_tag_add_str}, {
+  FOURCC_auth, GST_TAG_COMPOSER, NULL, qtdemux_tag_add_str}, {
+  FOURCC__alb, GST_TAG_ALBUM, NULL, qtdemux_tag_add_str}, {
+  FOURCC_albm, GST_TAG_ALBUM, NULL, qtdemux_tag_add_str}, {
+  FOURCC_cprt, GST_TAG_COPYRIGHT, NULL, qtdemux_tag_add_str}, {
+  FOURCC__cpy, GST_TAG_COPYRIGHT, NULL, qtdemux_tag_add_str}, {
+  FOURCC__cmt, GST_TAG_COMMENT, NULL, qtdemux_tag_add_str}, {
+  FOURCC__des, GST_TAG_DESCRIPTION, NULL, qtdemux_tag_add_str}, {
+  FOURCC_desc, GST_TAG_DESCRIPTION, NULL, qtdemux_tag_add_str}, {
+  FOURCC_dscp, GST_TAG_DESCRIPTION, NULL, qtdemux_tag_add_str}, {
+  FOURCC__lyr, GST_TAG_LYRICS, NULL, qtdemux_tag_add_str}, {
+  FOURCC__day, GST_TAG_DATE, NULL, qtdemux_tag_add_date}, {
+  FOURCC_yrrc, GST_TAG_DATE, NULL, qtdemux_tag_add_year}, {
+  FOURCC__too, GST_TAG_ENCODER, NULL, qtdemux_tag_add_str}, {
+  FOURCC__inf, GST_TAG_COMMENT, NULL, qtdemux_tag_add_str}, {
+  FOURCC_trkn, GST_TAG_TRACK_NUMBER, GST_TAG_TRACK_COUNT, qtdemux_tag_add_num}, {
+  FOURCC_disk, GST_TAG_ALBUM_VOLUME_NUMBER, GST_TAG_ALBUM_VOLUME_COUNT,
+        qtdemux_tag_add_num}, {
+  FOURCC_disc, GST_TAG_ALBUM_VOLUME_NUMBER, GST_TAG_ALBUM_VOLUME_COUNT,
+        qtdemux_tag_add_num}, {
+  FOURCC__gen, GST_TAG_GENRE, NULL, qtdemux_tag_add_str}, {
+  FOURCC_gnre, GST_TAG_GENRE, NULL, qtdemux_tag_add_gnre}, {
+  FOURCC_tmpo, GST_TAG_BEATS_PER_MINUTE, NULL, qtdemux_tag_add_tmpo}, {
+  FOURCC_covr, GST_TAG_PREVIEW_IMAGE, NULL, qtdemux_tag_add_covr}, {
+  FOURCC_sonm, GST_TAG_TITLE_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_soal, GST_TAG_ALBUM_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_soar, GST_TAG_ARTIST_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_soaa, GST_TAG_ALBUM_ARTIST_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_soco, GST_TAG_COMPOSER_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_sosn, GST_TAG_SHOW_SORTNAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_tvsh, GST_TAG_SHOW_NAME, NULL, qtdemux_tag_add_str}, {
+  FOURCC_tvsn, GST_TAG_SHOW_SEASON_NUMBER, NULL, qtdemux_tag_add_uint32}, {
+  FOURCC_tves, GST_TAG_SHOW_EPISODE_NUMBER, NULL, qtdemux_tag_add_uint32}, {
+  FOURCC_kywd, GST_TAG_KEYWORDS, NULL, qtdemux_tag_add_keywords}, {
+  FOURCC_keyw, GST_TAG_KEYWORDS, NULL, qtdemux_tag_add_str}, {
+  FOURCC__enc, GST_TAG_ENCODER, NULL, qtdemux_tag_add_str}, {
+  FOURCC_loci, GST_TAG_GEO_LOCATION_NAME, NULL, qtdemux_tag_add_location}, {
+  FOURCC_clsf, GST_QT_DEMUX_CLASSIFICATION_TAG, NULL,
+        qtdemux_tag_add_classification}, {
+
+    /* This is a special case, some tags are stored in this
+     * 'reverse dns naming', according to:
+     * http://atomicparsley.sourceforge.net/mpeg-4files.html and
+     * bug #614471
+     */
+  FOURCC_____, "", NULL, qtdemux_tag_add_revdns}
+};
+
+static void
+qtdemux_tag_add_blob (GNode * node, GstQTDemux * demux)
+{
+  gint len;
+  guint8 *data;
+  GstBuffer *buf;
+  gchar *media_type;
+  const gchar *style;
+  GstCaps *caps;
+  guint i;
+  guint8 ndata[4];
+
+  data = node->data;
+  len = QT_UINT32 (data);
+  buf = gst_buffer_new_and_alloc (len);
+  memcpy (GST_BUFFER_DATA (buf), data, len);
+
+  /* heuristic to determine style of tag */
+  if (QT_FOURCC (data + 4) == FOURCC_____ ||
+      (len > 8 + 12 && QT_FOURCC (data + 12) == FOURCC_data))
+    style = "itunes";
+  else if (demux->major_brand == FOURCC_qt__)
+    style = "quicktime";
+  /* fall back to assuming iso/3gp tag style */
+  else
+    style = "iso";
+
+  /* santize the name for the caps. */
+  for (i = 0; i < 4; i++) {
+    guint8 d = data[4 + i];
+    if (g_ascii_isalnum (d))
+      ndata[i] = g_ascii_tolower (d);
+    else
+      ndata[i] = '_';
+  }
+
+  media_type = g_strdup_printf ("application/x-gst-qt-%c%c%c%c-tag",
+      ndata[0], ndata[1], ndata[2], ndata[3]);
+  GST_DEBUG_OBJECT (demux, "media type %s", media_type);
+
+  caps = gst_caps_new_simple (media_type, "style", G_TYPE_STRING, style, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+  g_free (media_type);
+
+  GST_DEBUG_OBJECT (demux, "adding private tag; size %d, caps %" GST_PTR_FORMAT,
+      GST_BUFFER_SIZE (buf), caps);
+
+  gst_tag_list_add (demux->tag_list, GST_TAG_MERGE_APPEND,
+      GST_QT_DEMUX_PRIVATE_TAG, buf, NULL);
+  gst_buffer_unref (buf);
+}
+
+static void
+qtdemux_parse_udta (GstQTDemux * qtdemux, GNode * udta)
+{
+  GNode *meta;
+  GNode *ilst;
+  GNode *xmp_;
+  GNode *node;
+  gint i;
+
+  meta = qtdemux_tree_get_child_by_type (udta, FOURCC_meta);
+  if (meta != NULL) {
+    ilst = qtdemux_tree_get_child_by_type (meta, FOURCC_ilst);
+    if (ilst == NULL) {
+      GST_LOG_OBJECT (qtdemux, "no ilst");
+      return;
+    }
+  } else {
+    ilst = udta;
+    GST_LOG_OBJECT (qtdemux, "no meta so using udta itself");
+  }
+
+  GST_DEBUG_OBJECT (qtdemux, "new tag list");
+  if (!qtdemux->tag_list)
+    qtdemux->tag_list = gst_tag_list_new ();
+
+  i = 0;
+  while (i < G_N_ELEMENTS (add_funcs)) {
+    node = qtdemux_tree_get_child_by_type (ilst, add_funcs[i].fourcc);
+    if (node) {
+      gint len;
+
+      len = QT_UINT32 (node->data);
+      if (len < 12) {
+        GST_DEBUG_OBJECT (qtdemux, "too small tag atom %" GST_FOURCC_FORMAT,
+            GST_FOURCC_ARGS (add_funcs[i].fourcc));
+      } else {
+        add_funcs[i].func (qtdemux, add_funcs[i].gst_tag,
+            add_funcs[i].gst_tag_bis, node);
+      }
+      g_node_destroy (node);
+    } else {
+      i++;
+    }
+  }
+
+  /* parsed nodes have been removed, pass along remainder as blob */
+  g_node_children_foreach (ilst, G_TRAVERSE_ALL,
+      (GNodeForeachFunc) qtdemux_tag_add_blob, qtdemux);
+
+  /* parse up XMP_ node if existing */
+  xmp_ = qtdemux_tree_get_child_by_type (udta, FOURCC_XMP_);
+  if (xmp_ != NULL) {
+    GstBuffer *buf;
+    GstTagList *taglist;
+
+    buf = gst_buffer_new ();
+    GST_BUFFER_DATA (buf) = ((guint8 *) xmp_->data) + 8;
+    GST_BUFFER_SIZE (buf) = QT_UINT32 ((guint8 *) xmp_->data) - 8;
+
+    taglist = gst_tag_list_from_xmp_buffer (buf);
+    gst_buffer_unref (buf);
+
+    qtdemux_handle_xmp_taglist (qtdemux, taglist);
+  } else {
+    GST_DEBUG_OBJECT (qtdemux, "No XMP_ node found");
+  }
+
+}
+
+typedef struct
+{
+  GstStructure *structure;      /* helper for sort function */
+  gchar *location;
+  guint min_req_bitrate;
+  guint min_req_qt_version;
+} GstQtReference;
+
+static gint
+qtdemux_redirects_sort_func (gconstpointer a, gconstpointer b)
+{
+  GstQtReference *ref_a = (GstQtReference *) a;
+  GstQtReference *ref_b = (GstQtReference *) b;
+
+  if (ref_b->min_req_qt_version != ref_a->min_req_qt_version)
+    return ref_b->min_req_qt_version - ref_a->min_req_qt_version;
+
+  /* known bitrates go before unknown; higher bitrates go first */
+  return ref_b->min_req_bitrate - ref_a->min_req_bitrate;
+}
+
+/* sort the redirects and post a message for the application.
+ */
+static void
+qtdemux_process_redirects (GstQTDemux * qtdemux, GList * references)
+{
+  GstQtReference *best;
+  GstStructure *s;
+  GstMessage *msg;
+  GValue list_val = { 0, };
+  GList *l;
+
+  g_assert (references != NULL);
+
+  references = g_list_sort (references, qtdemux_redirects_sort_func);
+
+  best = (GstQtReference *) references->data;
+
+  g_value_init (&list_val, GST_TYPE_LIST);
+
+  for (l = references; l != NULL; l = l->next) {
+    GstQtReference *ref = (GstQtReference *) l->data;
+    GValue struct_val = { 0, };
+
+    ref->structure = gst_structure_new ("redirect",
+        "new-location", G_TYPE_STRING, ref->location, NULL);
+
+    if (ref->min_req_bitrate > 0) {
+      gst_structure_set (ref->structure, "minimum-bitrate", G_TYPE_INT,
+          ref->min_req_bitrate, NULL);
+    }
+
+    g_value_init (&struct_val, GST_TYPE_STRUCTURE);
+    g_value_set_boxed (&struct_val, ref->structure);
+    gst_value_list_append_value (&list_val, &struct_val);
+    g_value_unset (&struct_val);
+    /* don't free anything here yet, since we need best->structure below */
+  }
+
+  g_assert (best != NULL);
+  s = gst_structure_copy (best->structure);
+
+  if (g_list_length (references) > 1) {
+    gst_structure_set_value (s, "locations", &list_val);
+  }
+
+  g_value_unset (&list_val);
+
+  for (l = references; l != NULL; l = l->next) {
+    GstQtReference *ref = (GstQtReference *) l->data;
+
+    gst_structure_free (ref->structure);
+    g_free (ref->location);
+    g_free (ref);
+  }
+  g_list_free (references);
+
+  GST_INFO_OBJECT (qtdemux, "posting redirect message: %" GST_PTR_FORMAT, s);
+  msg = gst_message_new_element (GST_OBJECT_CAST (qtdemux), s);
+  gst_element_post_message (GST_ELEMENT_CAST (qtdemux), msg);
+  qtdemux->posted_redirect = TRUE;
+}
+
+/* look for redirect nodes, collect all redirect information and
+ * process it.
+ */
+static gboolean
+qtdemux_parse_redirects (GstQTDemux * qtdemux)
+{
+  GNode *rmra, *rmda, *rdrf;
+
+  rmra = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_rmra);
+  if (rmra) {
+    GList *redirects = NULL;
+
+    rmda = qtdemux_tree_get_child_by_type (rmra, FOURCC_rmda);
+    while (rmda) {
+      GstQtReference ref = { NULL, NULL, 0, 0 };
+      GNode *rmdr, *rmvc;
+
+      if ((rmdr = qtdemux_tree_get_child_by_type (rmda, FOURCC_rmdr))) {
+        ref.min_req_bitrate = QT_UINT32 ((guint8 *) rmdr->data + 12);
+        GST_LOG_OBJECT (qtdemux, "data rate atom, required bitrate = %u",
+            ref.min_req_bitrate);
+      }
+
+      if ((rmvc = qtdemux_tree_get_child_by_type (rmda, FOURCC_rmvc))) {
+        guint32 package = QT_FOURCC ((guint8 *) rmvc->data + 12);
+        guint version = QT_UINT32 ((guint8 *) rmvc->data + 16);
+
+#ifndef GST_DISABLE_GST_DEBUG
+        guint bitmask = QT_UINT32 ((guint8 *) rmvc->data + 20);
+#endif
+        guint check_type = QT_UINT16 ((guint8 *) rmvc->data + 24);
+
+        GST_LOG_OBJECT (qtdemux,
+            "version check atom [%" GST_FOURCC_FORMAT "], version=0x%08x"
+            ", mask=%08x, check_type=%u", GST_FOURCC_ARGS (package), version,
+            bitmask, check_type);
+        if (package == FOURCC_qtim && check_type == 0) {
+          ref.min_req_qt_version = version;
+        }
+      }
+
+      rdrf = qtdemux_tree_get_child_by_type (rmda, FOURCC_rdrf);
+      if (rdrf) {
+        guint32 ref_type;
+        guint8 *ref_data;
+
+        ref_type = QT_FOURCC ((guint8 *) rdrf->data + 12);
+        ref_data = (guint8 *) rdrf->data + 20;
+        if (ref_type == FOURCC_alis) {
+          guint record_len, record_version, fn_len;
+
+          /* MacOSX alias record, google for alias-layout.txt */
+          record_len = QT_UINT16 (ref_data + 4);
+          record_version = QT_UINT16 (ref_data + 4 + 2);
+          fn_len = QT_UINT8 (ref_data + 50);
+          if (record_len > 50 && record_version == 2 && fn_len > 0) {
+            ref.location = g_strndup ((gchar *) ref_data + 51, fn_len);
+          }
+        } else if (ref_type == FOURCC_url_) {
+          ref.location = g_strdup ((gchar *) ref_data);
+        } else {
+          GST_DEBUG_OBJECT (qtdemux,
+              "unknown rdrf reference type %" GST_FOURCC_FORMAT,
+              GST_FOURCC_ARGS (ref_type));
+        }
+        if (ref.location != NULL) {
+          GST_INFO_OBJECT (qtdemux, "New location: %s", ref.location);
+          redirects = g_list_prepend (redirects, g_memdup (&ref, sizeof (ref)));
+        } else {
+          GST_WARNING_OBJECT (qtdemux,
+              "Failed to extract redirect location from rdrf atom");
+        }
+      }
+
+      /* look for others */
+      rmda = qtdemux_tree_get_sibling_by_type (rmda, FOURCC_rmda);
+    }
+
+    if (redirects != NULL) {
+      qtdemux_process_redirects (qtdemux, redirects);
+    }
+  }
+  return TRUE;
+}
+
+static GstTagList *
+qtdemux_add_container_format (GstQTDemux * qtdemux, GstTagList * tags)
+{
+  const gchar *fmt;
+
+  if (tags == NULL)
+    tags = gst_tag_list_new ();
+
+  if (qtdemux->major_brand == FOURCC_mjp2)
+    fmt = "Motion JPEG 2000";
+  else if ((qtdemux->major_brand & 0xffff) == GST_MAKE_FOURCC ('3', 'g', 0, 0))
+    fmt = "3GP";
+  else if (qtdemux->major_brand == FOURCC_qt__)
+    fmt = "Quicktime";
+  else if (qtdemux->fragmented)
+    fmt = "ISO fMP4";
+  else
+    fmt = "ISO MP4/M4A";
+
+  GST_LOG_OBJECT (qtdemux, "mapped %" GST_FOURCC_FORMAT " to '%s'",
+      GST_FOURCC_ARGS (qtdemux->major_brand), fmt);
+
+  gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_CONTAINER_FORMAT,
+      fmt, NULL);
+
+  return tags;
+}
+
+/* we have read th complete moov node now.
+ * This function parses all of the relevant info, creates the traks and
+ * prepares all data structures for playback
+ */
+static gboolean
+qtdemux_parse_tree (GstQTDemux * qtdemux)
+{
+  GNode *mvhd;
+  GNode *trak;
+  GNode *udta;
+  GNode *mvex;
+  gint64 duration;
+  guint64 creation_time;
+  GstDateTime *datetime = NULL;
+  gint version;
+
+  mvhd = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_mvhd);
+  if (mvhd == NULL) {
+    GST_LOG_OBJECT (qtdemux, "No mvhd node found, looking for redirects.");
+    return qtdemux_parse_redirects (qtdemux);
+  }
+
+  version = QT_UINT8 ((guint8 *) mvhd->data + 8);
+  if (version == 1) {
+    creation_time = QT_UINT64 ((guint8 *) mvhd->data + 12);
+    qtdemux->timescale = QT_UINT32 ((guint8 *) mvhd->data + 28);
+    qtdemux->duration = QT_UINT64 ((guint8 *) mvhd->data + 32);
+  } else if (version == 0) {
+    creation_time = QT_UINT32 ((guint8 *) mvhd->data + 12);
+    qtdemux->timescale = QT_UINT32 ((guint8 *) mvhd->data + 20);
+    qtdemux->duration = QT_UINT32 ((guint8 *) mvhd->data + 24);
+  } else {
+    GST_WARNING_OBJECT (qtdemux, "Unhandled mvhd version %d", version);
+    return FALSE;
+  }
+
+  /* Moving qt creation time (secs since 1904) to unix time */
+  if (creation_time != 0) {
+    if (creation_time > QTDEMUX_SECONDS_FROM_1904_TO_1970) {
+      creation_time -= QTDEMUX_SECONDS_FROM_1904_TO_1970;
+      datetime = gst_date_time_new_from_unix_epoch_local_time (creation_time);
+    } else {
+      GST_WARNING_OBJECT (qtdemux, "Can't handle datetimes before 1970 yet, "
+          "please file a bug at http://bugzilla.gnome.org");
+    }
+  }
+  if (datetime) {
+    if (!qtdemux->tag_list)
+      qtdemux->tag_list = gst_tag_list_new ();
+
+    /* Use KEEP as explicit tags should have a higher priority than mvhd tag */
+    gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_KEEP, GST_TAG_DATE_TIME,
+        datetime, NULL);
+    gst_date_time_unref (datetime);
+  }
+
+  GST_INFO_OBJECT (qtdemux, "timescale: %u", qtdemux->timescale);
+  GST_INFO_OBJECT (qtdemux, "duration: %" G_GUINT64_FORMAT, qtdemux->duration);
+
+  /* check for fragmented file and get some (default) data */
+  mvex = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_mvex);
+  if (mvex) {
+    GNode *mehd;
+    GstByteReader mehd_data;
+
+    /* let track parsing or anyone know weird stuff might happen ... */
+    qtdemux->fragmented = TRUE;
+
+    /* compensate for total duration */
+    mehd = qtdemux_tree_get_child_by_type_full (mvex, FOURCC_mehd, &mehd_data);
+    if (mehd)
+      qtdemux_parse_mehd (qtdemux, &mehd_data);
+  }
+
+  /* set duration in the segment info */
+  gst_qtdemux_get_duration (qtdemux, &duration);
+  if (duration)
+    gst_segment_set_duration (&qtdemux->segment, GST_FORMAT_TIME, duration);
+
+  /* parse all traks */
+  trak = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_trak);
+  while (trak) {
+    qtdemux_parse_trak (qtdemux, trak);
+    /* iterate all siblings */
+    trak = qtdemux_tree_get_sibling_by_type (trak, FOURCC_trak);
+  }
+
+  /* find tags */
+  udta = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_udta);
+  if (udta) {
+    qtdemux_parse_udta (qtdemux, udta);
+  } else {
+    GST_LOG_OBJECT (qtdemux, "No udta node found.");
+  }
+
+  qtdemux->tag_list = qtdemux_add_container_format (qtdemux, qtdemux->tag_list);
+
+  return TRUE;
+}
+
+/* taken from ffmpeg */
+static unsigned int
+get_size (guint8 * ptr, guint8 ** end)
+{
+  int count = 4;
+  int len = 0;
+
+  while (count--) {
+    int c = *ptr;
+
+    ptr++;
+    len = (len << 7) | (c & 0x7f);
+    if (!(c & 0x80))
+      break;
+  }
+  if (end)
+    *end = ptr;
+  return len;
+}
+
+/* this can change the codec originally present in @list */
+static void
+gst_qtdemux_handle_esds (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    GNode * esds, GstTagList * list)
+{
+  int len = QT_UINT32 (esds->data);
+  guint8 *ptr = esds->data;
+  guint8 *end = ptr + len;
+  int tag;
+  guint8 *data_ptr = NULL;
+  int data_len = 0;
+  guint8 object_type_id = 0;
+  const char *codec_name = NULL;
+  GstCaps *caps = NULL;
+
+  GST_MEMDUMP_OBJECT (qtdemux, "esds", ptr, len);
+  ptr += 8;
+  GST_DEBUG_OBJECT (qtdemux, "version/flags = %08x", QT_UINT32 (ptr));
+  ptr += 4;
+  while (ptr < end) {
+    tag = QT_UINT8 (ptr);
+    GST_DEBUG_OBJECT (qtdemux, "tag = %02x", tag);
+    ptr++;
+    len = get_size (ptr, &ptr);
+    GST_DEBUG_OBJECT (qtdemux, "len = %d", len);
+
+    switch (tag) {
+      case 0x03:
+        GST_DEBUG_OBJECT (qtdemux, "ID %04x", QT_UINT16 (ptr));
+        GST_DEBUG_OBJECT (qtdemux, "priority %04x", QT_UINT8 (ptr + 2));
+        ptr += 3;
+        break;
+      case 0x04:{
+        guint max_bitrate, avg_bitrate;
+
+        object_type_id = QT_UINT8 (ptr);
+        max_bitrate = QT_UINT32 (ptr + 5);
+        avg_bitrate = QT_UINT32 (ptr + 9);
+        GST_DEBUG_OBJECT (qtdemux, "object_type_id %02x", object_type_id);
+        GST_DEBUG_OBJECT (qtdemux, "stream_type %02x", QT_UINT8 (ptr + 1));
+        GST_DEBUG_OBJECT (qtdemux, "buffer_size_db %02x", QT_UINT24 (ptr + 2));
+        GST_DEBUG_OBJECT (qtdemux, "max bitrate %u", max_bitrate);
+        GST_DEBUG_OBJECT (qtdemux, "avg bitrate %u", avg_bitrate);
+        if (max_bitrate > 0 && max_bitrate < G_MAXUINT32) {
+          gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+              GST_TAG_MAXIMUM_BITRATE, max_bitrate, NULL);
+        }
+        if (avg_bitrate > 0 && avg_bitrate < G_MAXUINT32) {
+          gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE,
+              avg_bitrate, NULL);
+        }
+        ptr += 13;
+        break;
+      }
+      case 0x05:
+        GST_MEMDUMP_OBJECT (qtdemux, "data", ptr, len);
+        data_ptr = ptr;
+        data_len = len;
+        ptr += len;
+        break;
+      case 0x06:
+        GST_DEBUG_OBJECT (qtdemux, "data %02x", QT_UINT8 (ptr));
+        ptr += 1;
+        break;
+      default:
+        GST_ERROR_OBJECT (qtdemux, "parse error");
+        break;
+    }
+  }
+
+  /* object_type_id in the esds atom in mp4a and mp4v tells us which codec is
+   * in use, and should also be used to override some other parameters for some
+   * codecs. */
+  switch (object_type_id) {
+    case 0x20:                 /* MPEG-4 */
+      /* 4 bytes for the visual_object_sequence_start_code and 1 byte for the
+       * profile_and_level_indication */
+      if (data_ptr != NULL && data_len >= 5 &&
+          GST_READ_UINT32_BE (data_ptr) == 0x000001b0) {
+        gst_codec_utils_mpeg4video_caps_set_level_and_profile (stream->caps,
+            data_ptr + 4, data_len - 4);
+      }
+      break;                    /* Nothing special needed here */
+    case 0x21:                 /* H.264 */
+      codec_name = "H.264 / AVC";
+      caps = gst_caps_new_simple ("video/x-h264",
+          "stream-format", G_TYPE_STRING, "avc",
+          "alignment", G_TYPE_STRING, "au", NULL);
+      break;
+    case 0x40:                 /* AAC (any) */
+    case 0x66:                 /* AAC Main */
+    case 0x67:                 /* AAC LC */
+    case 0x68:                 /* AAC SSR */
+      /* Override channels and rate based on the codec_data, as it's often
+       * wrong. */
+      /* Only do so for basic setup without HE-AAC extension */
+      if (data_ptr && data_len == 2) {
+        guint channels, rateindex, rate;
+
+        /* FIXME: add gst_codec_utils_aac_get_{channels|sample_rate}()? */
+        channels = (data_ptr[1] & 0x7f) >> 3;
+        if (channels > 0 && channels < 7) {
+          stream->n_channels = channels;
+        } else if (channels == 7) {
+          stream->n_channels = 8;
+        }
+
+        rateindex = ((data_ptr[0] & 0x7) << 1) | ((data_ptr[1] & 0x80) >> 7);
+        rate = gst_codec_utils_aac_get_sample_rate_from_index (rateindex);
+        if (rate > 0)
+          stream->rate = rate;
+      }
+
+      /* Set level and profile if possible */
+      if (data_ptr != NULL && data_len >= 2) {
+        gst_codec_utils_aac_caps_set_level_and_profile (stream->caps,
+            data_ptr, data_len);
+      }
+      break;
+    case 0x60:                 /* MPEG-2, various profiles */
+    case 0x61:
+    case 0x62:
+    case 0x63:
+    case 0x64:
+    case 0x65:
+      codec_name = "MPEG-2 video";
+
+      gst_caps_unref (stream->caps);
+      stream->caps = gst_caps_new_simple ("video/mpeg",
+          "mpegversion", G_TYPE_INT, 2,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case 0x69:                 /* MP3 has two different values, accept either */
+    case 0x6B:
+      /* change to mpeg1 layer 3 audio */
+      gst_caps_set_simple (stream->caps, "layer", G_TYPE_INT, 3,
+          "mpegversion", G_TYPE_INT, 1, NULL);
+      codec_name = "MPEG-1 layer 3";
+      break;
+    case 0x6A:                 /* MPEG-1 */
+      codec_name = "MPEG-1 video";
+
+      gst_caps_unref (stream->caps);
+      stream->caps = gst_caps_new_simple ("video/mpeg",
+          "mpegversion", G_TYPE_INT, 1,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case 0x6C:                 /* MJPEG */
+      caps = gst_caps_new_simple ("image/jpeg", NULL);
+      codec_name = "Motion-JPEG";
+      break;
+    case 0x6D:                 /* PNG */
+      caps = gst_caps_new_simple ("image/png", NULL);
+      codec_name = "PNG still images";
+      break;
+    case 0x6E:                 /* JPEG2000 */
+      codec_name = "JPEG-2000";
+      caps = gst_caps_new_simple ("image/x-j2c", "fields", G_TYPE_INT, 1, NULL);
+      break;
+    case 0xA4:                 /* Dirac */
+      codec_name = "Dirac";
+      caps = gst_caps_new_simple ("video/x-dirac", NULL);
+      break;
+    case 0xA5:                 /* AC3 */
+      codec_name = "AC-3 audio";
+      caps = gst_caps_new_simple ("audio/x-ac3",
+          "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+      break;
+    case 0xE1:                 /* QCELP */
+      /* QCELP, the codec_data is a riff tag (little endian) with
+       * more info (http://ftp.3gpp2.org/TSGC/Working/2003/2003-05-SanDiego/TSG-C-2003-05-San%20Diego/WG1/SWG12/C12-20030512-006%20=%20C12-20030217-015_Draft_Baseline%20Text%20of%20FFMS_R2.doc). */
+      caps = gst_caps_new_simple ("audio/qcelp", NULL);
+      codec_name = "QCELP";
+      break;
+    default:
+      break;
+  }
+
+  /* If we have a replacement caps, then change our caps for this stream */
+  if (caps) {
+    gst_caps_unref (stream->caps);
+    stream->caps = caps;
+  }
+
+  if (codec_name && list)
+    gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
+        GST_TAG_AUDIO_CODEC, codec_name, NULL);
+
+  /* Add the codec_data attribute to caps, if we have it */
+  if (data_ptr) {
+    GstBuffer *buffer;
+
+    buffer = gst_buffer_new_and_alloc (data_len);
+    memcpy (GST_BUFFER_DATA (buffer), data_ptr, data_len);
+
+    GST_DEBUG_OBJECT (qtdemux, "setting codec_data from esds");
+    GST_MEMDUMP_OBJECT (qtdemux, "codec_data from esds", data_ptr, data_len);
+
+    gst_caps_set_simple (stream->caps, "codec_data", GST_TYPE_BUFFER,
+        buffer, NULL);
+    gst_buffer_unref (buffer);
+  }
+
+}
+
+#define _codec(name) \
+  do { \
+    if (codec_name) { \
+      *codec_name = g_strdup (name); \
+    } \
+  } while (0)
+
+static GstCaps *
+qtdemux_video_caps (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint32 fourcc, const guint8 * stsd_data, gchar ** codec_name)
+{
+  GstCaps *caps;
+  const GstStructure *s;
+  const gchar *name;
+
+  switch (fourcc) {
+    case GST_MAKE_FOURCC ('p', 'n', 'g', ' '):
+      _codec ("PNG still images");
+      caps = gst_caps_new_simple ("image/png", NULL);
+      break;
+    case GST_MAKE_FOURCC ('j', 'p', 'e', 'g'):
+      _codec ("JPEG still images");
+      caps = gst_caps_new_simple ("image/jpeg", NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'j', 'p', 'a'):
+    case GST_MAKE_FOURCC ('A', 'V', 'D', 'J'):
+    case GST_MAKE_FOURCC ('M', 'J', 'P', 'G'):
+    case GST_MAKE_FOURCC ('d', 'm', 'b', '1'):
+      _codec ("Motion-JPEG");
+      caps = gst_caps_new_simple ("image/jpeg", NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'j', 'p', 'b'):
+      _codec ("Motion-JPEG format B");
+      caps = gst_caps_new_simple ("video/x-mjpeg-b", NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'j', 'p', '2'):
+      _codec ("JPEG-2000");
+      /* override to what it should be according to spec, avoid palette_data */
+      stream->bits_per_sample = 24;
+      caps = gst_caps_new_simple ("image/x-j2c", "fields", G_TYPE_INT, 1, NULL);
+      break;
+    case GST_MAKE_FOURCC ('S', 'V', 'Q', '3'):
+      _codec ("Sorensen video v.3");
+      caps = gst_caps_new_simple ("video/x-svq",
+          "svqversion", G_TYPE_INT, 3, NULL);
+      break;
+    case GST_MAKE_FOURCC ('s', 'v', 'q', 'i'):
+    case GST_MAKE_FOURCC ('S', 'V', 'Q', '1'):
+      _codec ("Sorensen video v.1");
+      caps = gst_caps_new_simple ("video/x-svq",
+          "svqversion", G_TYPE_INT, 1, NULL);
+      break;
+    case GST_MAKE_FOURCC ('r', 'a', 'w', ' '):
+    {
+      guint16 bps;
+
+      _codec ("Raw RGB video");
+      bps = QT_UINT16 (stsd_data + 98);
+      /* set common stuff */
+      caps = gst_caps_new_simple ("video/x-raw-rgb",
+          "endianness", G_TYPE_INT, G_BYTE_ORDER, "depth", G_TYPE_INT, bps,
+          NULL);
+
+      switch (bps) {
+        case 15:
+          gst_caps_set_simple (caps,
+              "bpp", G_TYPE_INT, 16,
+              "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+              "red_mask", G_TYPE_INT, 0x7c00,
+              "green_mask", G_TYPE_INT, 0x03e0,
+              "blue_mask", G_TYPE_INT, 0x001f, NULL);
+          break;
+        case 16:
+          gst_caps_set_simple (caps,
+              "bpp", G_TYPE_INT, 16,
+              "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+              "red_mask", G_TYPE_INT, 0xf800,
+              "green_mask", G_TYPE_INT, 0x07e0,
+              "blue_mask", G_TYPE_INT, 0x001f, NULL);
+          break;
+        case 24:
+          gst_caps_set_simple (caps,
+              "bpp", G_TYPE_INT, 24,
+              "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+              "red_mask", G_TYPE_INT, 0xff0000,
+              "green_mask", G_TYPE_INT, 0x00ff00,
+              "blue_mask", G_TYPE_INT, 0x0000ff, NULL);
+          break;
+        case 32:
+          gst_caps_set_simple (caps,
+              "bpp", G_TYPE_INT, 32,
+              "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+              "alpha_mask", G_TYPE_INT, 0xff000000,
+              "red_mask", G_TYPE_INT, 0x00ff0000,
+              "green_mask", G_TYPE_INT, 0x0000ff00,
+              "blue_mask", G_TYPE_INT, 0x000000ff, NULL);
+          break;
+        default:
+          /* unknown */
+          break;
+      }
+      break;
+    }
+    case GST_MAKE_FOURCC ('y', 'v', '1', '2'):
+      _codec ("Raw planar YUV 4:2:0");
+      caps = gst_caps_new_simple ("video/x-raw-yuv",
+          "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
+          NULL);
+      break;
+    case GST_MAKE_FOURCC ('y', 'u', 'v', '2'):
+    case GST_MAKE_FOURCC ('Y', 'u', 'v', '2'):
+      _codec ("Raw packed YUV 4:2:2");
+      caps = gst_caps_new_simple ("video/x-raw-yuv",
+          "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
+          NULL);
+      break;
+    case GST_MAKE_FOURCC ('2', 'v', 'u', 'y'):
+    case GST_MAKE_FOURCC ('2', 'V', 'u', 'y'):
+      _codec ("Raw packed YUV 4:2:2");
+      caps = gst_caps_new_simple ("video/x-raw-yuv",
+          "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'),
+          NULL);
+      break;
+    case GST_MAKE_FOURCC ('v', '2', '1', '0'):
+      _codec ("Raw packed YUV 10-bit 4:2:2");
+      caps = gst_caps_new_simple ("video/x-raw-yuv",
+          "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('v', '2', '1', '0'),
+          NULL);
+      break;
+    case GST_MAKE_FOURCC ('r', '2', '1', '0'):
+      _codec ("Raw packed RGB 10-bit 4:4:4");
+      caps = gst_caps_new_simple ("video/x-raw-rgb",
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN, "depth", G_TYPE_INT, 30,
+          "bpp", G_TYPE_INT, 32,
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+          "red_mask", G_TYPE_INT, 0x3ff00000,
+          "green_mask", G_TYPE_INT, 0x000ffc00,
+          "blue_mask", G_TYPE_INT, 0x000003ff, NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'p', 'e', 'g'):
+    case GST_MAKE_FOURCC ('m', 'p', 'g', '1'):
+      _codec ("MPEG-1 video");
+      caps = gst_caps_new_simple ("video/mpeg", "mpegversion", G_TYPE_INT, 1,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('h', 'd', 'v', '1'): /* HDV 720p30 */
+    case GST_MAKE_FOURCC ('h', 'd', 'v', '2'): /* HDV 1080i60 */
+    case GST_MAKE_FOURCC ('h', 'd', 'v', '3'): /* HDV 1080i50 */
+    case GST_MAKE_FOURCC ('h', 'd', 'v', '5'): /* HDV 720p25 */
+    case GST_MAKE_FOURCC ('h', 'd', 'v', '6'): /* HDV 1080i60 */
+    case GST_MAKE_FOURCC ('m', 'x', '5', 'n'): /* MPEG2 IMX NTSC 525/60 50mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('m', 'x', '5', 'p'): /* MPEG2 IMX PAL 625/60 50mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('m', 'x', '4', 'n'): /* MPEG2 IMX NTSC 525/60 40mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('m', 'x', '4', 'p'): /* MPEG2 IMX PAL 625/60 40mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('m', 'x', '3', 'n'): /* MPEG2 IMX NTSC 525/60 30mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('m', 'x', '3', 'p'): /* MPEG2 IMX PAL 625/50 30mb/s produced by FCP */
+    case GST_MAKE_FOURCC ('x', 'd', 'v', '2'): /* XDCAM HD 1080i60 */
+    case GST_MAKE_FOURCC ('A', 'V', 'm', 'p'): /* AVID IMX PAL */
+    case GST_MAKE_FOURCC ('m', 'p', 'g', '2'): /* AVID IMX PAL */
+      _codec ("MPEG-2 video");
+      caps = gst_caps_new_simple ("video/mpeg", "mpegversion", G_TYPE_INT, 2,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('g', 'i', 'f', ' '):
+      _codec ("GIF still images");
+      caps = gst_caps_new_simple ("image/gif", NULL);
+      break;
+    case GST_MAKE_FOURCC ('h', '2', '6', '3'):
+    case GST_MAKE_FOURCC ('H', '2', '6', '3'):
+    case GST_MAKE_FOURCC ('s', '2', '6', '3'):
+    case GST_MAKE_FOURCC ('U', '2', '6', '3'):
+      _codec ("H.263");
+      /* ffmpeg uses the height/width props, don't know why */
+      caps = gst_caps_new_simple ("video/x-h263", NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
+    case GST_MAKE_FOURCC ('M', 'P', '4', 'V'):
+      _codec ("MPEG-4 video");
+      caps = gst_caps_new_simple ("video/mpeg", "mpegversion", G_TYPE_INT, 4,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('3', 'i', 'v', 'd'):
+    case GST_MAKE_FOURCC ('3', 'I', 'V', 'D'):
+      _codec ("Microsoft MPEG-4 4.3");  /* FIXME? */
+      caps = gst_caps_new_simple ("video/x-msmpeg",
+          "msmpegversion", G_TYPE_INT, 43, NULL);
+      break;
+    case GST_MAKE_FOURCC ('3', 'I', 'V', '1'):
+    case GST_MAKE_FOURCC ('3', 'I', 'V', '2'):
+      _codec ("3ivX video");
+      caps = gst_caps_new_simple ("video/x-3ivx", NULL);
+      break;
+    case GST_MAKE_FOURCC ('D', 'I', 'V', '3'):
+      _codec ("DivX 3");
+      caps = gst_caps_new_simple ("video/x-divx",
+          "divxversion", G_TYPE_INT, 3, NULL);
+      break;
+    case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
+    case GST_MAKE_FOURCC ('d', 'i', 'v', 'x'):
+      _codec ("DivX 4");
+      caps = gst_caps_new_simple ("video/x-divx",
+          "divxversion", G_TYPE_INT, 4, NULL);
+      break;
+    case GST_MAKE_FOURCC ('D', 'X', '5', '0'):
+      _codec ("DivX 5");
+      caps = gst_caps_new_simple ("video/x-divx",
+          "divxversion", G_TYPE_INT, 5, NULL);
+      break;
+    case GST_MAKE_FOURCC ('X', 'V', 'I', 'D'):
+    case GST_MAKE_FOURCC ('x', 'v', 'i', 'd'):
+      _codec ("XVID MPEG-4");
+      caps = gst_caps_new_simple ("video/x-xvid", NULL);
+      break;
+
+    case GST_MAKE_FOURCC ('F', 'M', 'P', '4'):
+    case GST_MAKE_FOURCC ('U', 'M', 'P', '4'):
+      caps = gst_caps_new_simple ("video/mpeg",
+          "mpegversion", G_TYPE_INT, 4, NULL);
+      if (codec_name)
+        *codec_name = g_strdup ("FFmpeg MPEG-4");
+      break;
+
+    case GST_MAKE_FOURCC ('c', 'v', 'i', 'd'):
+      _codec ("Cinepak");
+      caps = gst_caps_new_simple ("video/x-cinepak", NULL);
+      break;
+    case GST_MAKE_FOURCC ('q', 'd', 'r', 'w'):
+      _codec ("Apple QuickDraw");
+      caps = gst_caps_new_simple ("video/x-qdrw", NULL);
+      break;
+    case GST_MAKE_FOURCC ('r', 'p', 'z', 'a'):
+      _codec ("Apple video");
+      caps = gst_caps_new_simple ("video/x-apple-video", NULL);
+      break;
+    case GST_MAKE_FOURCC ('a', 'v', 'c', '1'):
+      _codec ("H.264 / AVC");
+      caps = gst_caps_new_simple ("video/x-h264",
+          "stream-format", G_TYPE_STRING, "avc",
+          "alignment", G_TYPE_STRING, "au", NULL);
+      break;
+    case GST_MAKE_FOURCC ('r', 'l', 'e', ' '):
+      _codec ("Run-length encoding");
+      caps = gst_caps_new_simple ("video/x-rle",
+          "layout", G_TYPE_STRING, "quicktime", NULL);
+      break;
+    case GST_MAKE_FOURCC ('I', 'V', '3', '2'):
+    case GST_MAKE_FOURCC ('i', 'v', '3', '2'):
+      _codec ("Indeo Video 3");
+      caps = gst_caps_new_simple ("video/x-indeo",
+          "indeoversion", G_TYPE_INT, 3, NULL);
+      break;
+    case GST_MAKE_FOURCC ('I', 'V', '4', '1'):
+    case GST_MAKE_FOURCC ('i', 'v', '4', '1'):
+      _codec ("Intel Video 4");
+      caps = gst_caps_new_simple ("video/x-indeo",
+          "indeoversion", G_TYPE_INT, 4, NULL);
+      break;
+    case GST_MAKE_FOURCC ('d', 'v', 'c', 'p'):
+    case GST_MAKE_FOURCC ('d', 'v', 'c', ' '):
+    case GST_MAKE_FOURCC ('d', 'v', 's', 'd'):
+    case GST_MAKE_FOURCC ('D', 'V', 'S', 'D'):
+    case GST_MAKE_FOURCC ('d', 'v', 'c', 's'):
+    case GST_MAKE_FOURCC ('D', 'V', 'C', 'S'):
+    case GST_MAKE_FOURCC ('d', 'v', '2', '5'):
+    case GST_MAKE_FOURCC ('d', 'v', 'p', 'p'):
+      _codec ("DV Video");
+      caps = gst_caps_new_simple ("video/x-dv", "dvversion", G_TYPE_INT, 25,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('d', 'v', '5', 'n'): /* DVCPRO50 NTSC */
+    case GST_MAKE_FOURCC ('d', 'v', '5', 'p'): /* DVCPRO50 PAL */
+      _codec ("DVCPro50 Video");
+      caps = gst_caps_new_simple ("video/x-dv", "dvversion", G_TYPE_INT, 50,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('d', 'v', 'h', '5'): /* DVCPRO HD 50i produced by FCP */
+    case GST_MAKE_FOURCC ('d', 'v', 'h', '6'): /* DVCPRO HD 60i produced by FCP */
+      _codec ("DVCProHD Video");
+      caps = gst_caps_new_simple ("video/x-dv", "dvversion", G_TYPE_INT, 100,
+          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('s', 'm', 'c', ' '):
+      _codec ("Apple Graphics (SMC)");
+      caps = gst_caps_new_simple ("video/x-smc", NULL);
+      break;
+    case GST_MAKE_FOURCC ('V', 'P', '3', '1'):
+      _codec ("VP3");
+      caps = gst_caps_new_simple ("video/x-vp3", NULL);
+      break;
+    case GST_MAKE_FOURCC ('X', 'i', 'T', 'h'):
+      _codec ("Theora");
+      caps = gst_caps_new_simple ("video/x-theora", NULL);
+      /* theora uses one byte of padding in the data stream because it does not
+       * allow 0 sized packets while theora does */
+      stream->padding = 1;
+      break;
+    case GST_MAKE_FOURCC ('d', 'r', 'a', 'c'):
+      _codec ("Dirac");
+      caps = gst_caps_new_simple ("video/x-dirac", NULL);
+      break;
+    case GST_MAKE_FOURCC ('t', 'i', 'f', 'f'):
+      _codec ("TIFF still images");
+      caps = gst_caps_new_simple ("image/tiff", NULL);
+      break;
+    case GST_MAKE_FOURCC ('i', 'c', 'o', 'd'):
+      _codec ("Apple Intermediate Codec");
+      caps = gst_caps_from_string ("video/x-apple-intermediate-codec");
+      break;
+    case GST_MAKE_FOURCC ('A', 'V', 'd', 'n'):
+      _codec ("AVID DNxHD");
+      caps = gst_caps_from_string ("video/x-dnxhd");
+      break;
+    case GST_MAKE_FOURCC ('V', 'P', '8', '0'):
+      _codec ("On2 VP8");
+      caps = gst_caps_from_string ("video/x-vp8");
+    case FOURCC_ovc1:
+      _codec ("VC-1");
+      caps = gst_caps_new_simple ("video/x-wmv",
+          "wmvversion", G_TYPE_INT, 3,
+          "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('W', 'V', 'C', '1'),
+          NULL);
+      break;
+    case GST_MAKE_FOURCC ('k', 'p', 'c', 'd'):
+    default:
+    {
+      char *s;
+
+      s = g_strdup_printf ("video/x-gst-fourcc-%" GST_FOURCC_FORMAT,
+          GST_FOURCC_ARGS (fourcc));
+      caps = gst_caps_new_simple (s, NULL);
+      break;
+    }
+  }
+
+  /* enable clipping for raw video streams */
+  s = gst_caps_get_structure (caps, 0);
+  name = gst_structure_get_name (s);
+  if (g_str_has_prefix (name, "video/x-raw-")) {
+    stream->need_clip = TRUE;
+  }
+  return caps;
+}
+
+static GstCaps *
+qtdemux_audio_caps (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint32 fourcc, const guint8 * data, int len, gchar ** codec_name)
+{
+  GstCaps *caps;
+  const GstStructure *s;
+  const gchar *name;
+  gint endian = 0;
+
+  GST_DEBUG_OBJECT (qtdemux, "resolve fourcc %08x", fourcc);
+
+  switch (fourcc) {
+    case GST_MAKE_FOURCC ('N', 'O', 'N', 'E'):
+    case GST_MAKE_FOURCC ('r', 'a', 'w', ' '):
+      _codec ("Raw 8-bit PCM audio");
+      caps = gst_caps_new_simple ("audio/x-raw-int", "width", G_TYPE_INT, 8,
+          "depth", G_TYPE_INT, 8, "signed", G_TYPE_BOOLEAN, FALSE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('t', 'w', 'o', 's'):
+      endian = G_BIG_ENDIAN;
+      /* fall-through */
+    case GST_MAKE_FOURCC ('s', 'o', 'w', 't'):
+    {
+      gchar *str;
+      gint depth;
+
+      if (!endian)
+        endian = G_LITTLE_ENDIAN;
+
+      depth = stream->bytes_per_packet * 8;
+      str = g_strdup_printf ("Raw %d-bit PCM audio", depth);
+      _codec (str);
+      g_free (str);
+      caps = gst_caps_new_simple ("audio/x-raw-int",
+          "width", G_TYPE_INT, depth, "depth", G_TYPE_INT, depth,
+          "endianness", G_TYPE_INT, endian,
+          "signed", G_TYPE_BOOLEAN, TRUE, NULL);
+      break;
+    }
+    case GST_MAKE_FOURCC ('f', 'l', '6', '4'):
+      _codec ("Raw 64-bit floating-point audio");
+      caps = gst_caps_new_simple ("audio/x-raw-float", "width", G_TYPE_INT, 64,
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN, NULL);
+      break;
+    case GST_MAKE_FOURCC ('f', 'l', '3', '2'):
+      _codec ("Raw 32-bit floating-point audio");
+      caps = gst_caps_new_simple ("audio/x-raw-float", "width", G_TYPE_INT, 32,
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN, NULL);
+      break;
+    case FOURCC_in24:
+      _codec ("Raw 24-bit PCM audio");
+      /* we assume BIG ENDIAN, an enda box will tell us to change this to little
+       * endian later */
+      caps = gst_caps_new_simple ("audio/x-raw-int", "width", G_TYPE_INT, 24,
+          "depth", G_TYPE_INT, 24,
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+          "signed", G_TYPE_BOOLEAN, TRUE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('i', 'n', '3', '2'):
+      _codec ("Raw 32-bit PCM audio");
+      caps = gst_caps_new_simple ("audio/x-raw-int", "width", G_TYPE_INT, 32,
+          "depth", G_TYPE_INT, 32,
+          "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+          "signed", G_TYPE_BOOLEAN, TRUE, NULL);
+      break;
+    case GST_MAKE_FOURCC ('u', 'l', 'a', 'w'):
+      _codec ("Mu-law audio");
+      caps = gst_caps_new_simple ("audio/x-mulaw", NULL);
+      break;
+    case GST_MAKE_FOURCC ('a', 'l', 'a', 'w'):
+      _codec ("A-law audio");
+      caps = gst_caps_new_simple ("audio/x-alaw", NULL);
+      break;
+    case 0x0200736d:
+    case 0x6d730002:
+      _codec ("Microsoft ADPCM");
+      /* Microsoft ADPCM-ACM code 2 */
+      caps = gst_caps_new_simple ("audio/x-adpcm",
+          "layout", G_TYPE_STRING, "microsoft", NULL);
+      break;
+    case 0x1100736d:
+    case 0x6d730011:
+      _codec ("DVI/IMA ADPCM");
+      caps = gst_caps_new_simple ("audio/x-adpcm",
+          "layout", G_TYPE_STRING, "dvi", NULL);
+      break;
+    case 0x1700736d:
+    case 0x6d730017:
+      _codec ("DVI/Intel IMA ADPCM");
+      /* FIXME DVI/Intel IMA ADPCM/ACM code 17 */
+      caps = gst_caps_new_simple ("audio/x-adpcm",
+          "layout", G_TYPE_STRING, "quicktime", NULL);
+      break;
+    case 0x5500736d:
+    case 0x6d730055:
+      /* MPEG layer 3, CBR only (pre QT4.1) */
+    case GST_MAKE_FOURCC ('.', 'm', 'p', '3'):
+      _codec ("MPEG-1 layer 3");
+      /* MPEG layer 3, CBR & VBR (QT4.1 and later) */
+      caps = gst_caps_new_simple ("audio/mpeg", "layer", G_TYPE_INT, 3,
+          "mpegversion", G_TYPE_INT, 1, NULL);
+      break;
+    case 0x20736d:
+    case GST_MAKE_FOURCC ('e', 'c', '-', '3'):
+      _codec ("EAC-3 audio");
+      caps = gst_caps_new_simple ("audio/x-eac3",
+          "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+      stream->sampled = TRUE;
+      break;
+    case GST_MAKE_FOURCC ('a', 'c', '-', '3'):
+      _codec ("AC-3 audio");
+      caps = gst_caps_new_simple ("audio/x-ac3",
+          "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+      stream->sampled = TRUE;
+      break;
+    case GST_MAKE_FOURCC ('M', 'A', 'C', '3'):
+      _codec ("MACE-3");
+      caps = gst_caps_new_simple ("audio/x-mace",
+          "maceversion", G_TYPE_INT, 3, NULL);
+      break;
+    case GST_MAKE_FOURCC ('M', 'A', 'C', '6'):
+      _codec ("MACE-6");
+      caps = gst_caps_new_simple ("audio/x-mace",
+          "maceversion", G_TYPE_INT, 6, NULL);
+      break;
+    case GST_MAKE_FOURCC ('O', 'g', 'g', 'V'):
+      /* ogg/vorbis */
+      caps = gst_caps_new_simple ("application/ogg", NULL);
+      break;
+    case GST_MAKE_FOURCC ('d', 'v', 'c', 'a'):
+      _codec ("DV audio");
+      caps = gst_caps_new_simple ("audio/x-dv", NULL);
+      break;
+    case GST_MAKE_FOURCC ('m', 'p', '4', 'a'):
+      _codec ("MPEG-4 AAC audio");
+      caps = gst_caps_new_simple ("audio/mpeg",
+          "mpegversion", G_TYPE_INT, 4, "framed", G_TYPE_BOOLEAN, TRUE,
+          "stream-format", G_TYPE_STRING, "raw", NULL);
+      break;
+    case GST_MAKE_FOURCC ('Q', 'D', 'M', 'C'):
+      _codec ("QDesign Music");
+      caps = gst_caps_new_simple ("audio/x-qdm", NULL);
+      break;
+    case GST_MAKE_FOURCC ('Q', 'D', 'M', '2'):
+      _codec ("QDesign Music v.2");
+      /* FIXME: QDesign music version 2 (no constant) */
+      if (data) {
+        caps = gst_caps_new_simple ("audio/x-qdm2",
+            "framesize", G_TYPE_INT, QT_UINT32 (data + 52),
+            "bitrate", G_TYPE_INT, QT_UINT32 (data + 40),
+            "blocksize", G_TYPE_INT, QT_UINT32 (data + 44), NULL);
+      } else {
+        caps = gst_caps_new_simple ("audio/x-qdm2", NULL);
+      }
+      break;
+    case GST_MAKE_FOURCC ('a', 'g', 's', 'm'):
+      _codec ("GSM audio");
+      caps = gst_caps_new_simple ("audio/x-gsm", NULL);
+      break;
+    case GST_MAKE_FOURCC ('s', 'a', 'm', 'r'):
+      _codec ("AMR audio");
+      caps = gst_caps_new_simple ("audio/AMR", NULL);
+      break;
+    case GST_MAKE_FOURCC ('s', 'a', 'w', 'b'):
+      _codec ("AMR-WB audio");
+      caps = gst_caps_new_simple ("audio/AMR-WB", NULL);
+      break;
+    case GST_MAKE_FOURCC ('i', 'm', 'a', '4'):
+      _codec ("Quicktime IMA ADPCM");
+      caps = gst_caps_new_simple ("audio/x-adpcm",
+          "layout", G_TYPE_STRING, "quicktime", NULL);
+      break;
+    case GST_MAKE_FOURCC ('a', 'l', 'a', 'c'):
+      _codec ("Apple lossless audio");
+      caps = gst_caps_new_simple ("audio/x-alac", NULL);
+      break;
+    case GST_MAKE_FOURCC ('Q', 'c', 'l', 'p'):
+      _codec ("QualComm PureVoice");
+      caps = gst_caps_from_string ("audio/qcelp");
+      break;
+    case FOURCC_owma:
+      _codec ("WMA");
+      caps = gst_caps_new_simple ("audio/x-wma", NULL);
+      break;
+    case GST_MAKE_FOURCC ('q', 't', 'v', 'r'):
+      /* ? */
+    default:
+    {
+      char *s;
+
+      s = g_strdup_printf ("audio/x-gst-fourcc-%" GST_FOURCC_FORMAT,
+          GST_FOURCC_ARGS (fourcc));
+      caps = gst_caps_new_simple (s, NULL);
+      break;
+    }
+  }
+
+  /* enable clipping for raw audio streams */
+  s = gst_caps_get_structure (caps, 0);
+  name = gst_structure_get_name (s);
+  if (g_str_has_prefix (name, "audio/x-raw-")) {
+    stream->need_clip = TRUE;
+  }
+  return caps;
+}
+
+static GstCaps *
+qtdemux_sub_caps (GstQTDemux * qtdemux, QtDemuxStream * stream,
+    guint32 fourcc, const guint8 * stsd_data, gchar ** codec_name)
+{
+  GstCaps *caps;
+
+  GST_DEBUG_OBJECT (qtdemux, "resolve fourcc %08x", fourcc);
+
+  switch (fourcc) {
+    case GST_MAKE_FOURCC ('m', 'p', '4', 's'):
+      _codec ("DVD subtitle");
+      caps = gst_caps_new_simple ("video/x-dvd-subpicture", NULL);
+      break;
+    case GST_MAKE_FOURCC ('t', 'e', 'x', 't'):
+      _codec ("Quicktime timed text");
+      goto text;
+    case GST_MAKE_FOURCC ('t', 'x', '3', 'g'):
+      _codec ("3GPP timed text");
+    text:
+      caps = gst_caps_new_simple ("text/plain", NULL);
+      /* actual text piece needs to be extracted */
+      stream->need_process = TRUE;
+      break;
+    default:
+    {
+      char *s;
+
+      s = g_strdup_printf ("text/x-gst-fourcc-%" GST_FOURCC_FORMAT,
+          GST_FOURCC_ARGS (fourcc));
+      caps = gst_caps_new_simple (s, NULL);
+      break;
+    }
+  }
+  return caps;
+}
diff --git a/gst/isomp4/qtdemux.h b/gst/isomp4/qtdemux.h
new file mode 100644
index 000000000..069fa72eb
--- /dev/null
+++ b/gst/isomp4/qtdemux.h
@@ -0,0 +1,122 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_QTDEMUX_H__
+#define __GST_QTDEMUX_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstadapter.h>
+
+G_BEGIN_DECLS
+
+GST_DEBUG_CATEGORY_EXTERN (qtdemux_debug);
+#define GST_CAT_DEFAULT qtdemux_debug
+
+#define GST_TYPE_QTDEMUX \
+  (gst_qtdemux_get_type())
+#define GST_QTDEMUX(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QTDEMUX,GstQTDemux))
+#define GST_QTDEMUX_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QTDEMUX,GstQTDemuxClass))
+#define GST_IS_QTDEMUX(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QTDEMUX))
+#define GST_IS_QTDEMUX_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QTDEMUX))
+
+#define GST_QTDEMUX_CAST(obj) ((GstQTDemux *)(obj))
+
+/* qtdemux produces these for atoms it cannot parse */
+#define GST_QT_DEMUX_PRIVATE_TAG "private-qt-tag"
+#define GST_QT_DEMUX_CLASSIFICATION_TAG "classification"
+
+#define GST_QTDEMUX_MAX_STREAMS         8
+
+typedef struct _GstQTDemux GstQTDemux;
+typedef struct _GstQTDemuxClass GstQTDemuxClass;
+typedef struct _QtDemuxStream QtDemuxStream;
+
+struct _GstQTDemux {
+  GstElement element;
+
+  /* pads */
+  GstPad *sinkpad;
+
+  QtDemuxStream *streams[GST_QTDEMUX_MAX_STREAMS];
+  gint     n_streams;
+  gint     n_video_streams;
+  gint     n_audio_streams;
+  gint     n_sub_streams;
+
+  guint  major_brand;
+  GstBuffer *comp_brands;
+  GNode *moov_node;
+  GNode *moov_node_compressed;
+
+  guint32 timescale;
+  guint64 duration;
+
+  gboolean fragmented;
+  /* offset of the mfra atom */
+  guint64 mfra_offset;
+  guint64 moof_offset;
+
+  gint state;
+
+  gboolean pullbased;
+  gboolean posted_redirect;
+
+  /* push based variables */
+  guint neededbytes;
+  guint todrop;
+  GstAdapter *adapter;
+  GstBuffer *mdatbuffer;
+  guint64 mdatleft;
+
+  /* offset of the media data (i.e.: Size of header) */
+  guint64 offset;
+  /* offset of the mdat atom */
+  guint64 mdatoffset;
+  guint64 first_mdat;
+  gboolean got_moov;
+
+  GstTagList *tag_list;
+
+  /* configured playback region */
+  GstSegment segment;
+  gboolean segment_running;
+  GstEvent *pending_newsegment;
+
+  /* gst index support */
+  GstIndex *element_index;
+  gint index_id;
+
+  gint64 requested_seek_time;
+  guint64 seek_offset;
+};
+
+struct _GstQTDemuxClass {
+  GstElementClass parent_class;
+};
+
+GType gst_qtdemux_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_QTDEMUX_H__ */
diff --git a/gst/isomp4/qtdemux.vcproj b/gst/isomp4/qtdemux.vcproj
new file mode 100644
index 000000000..e00260d9a
--- /dev/null
+++ b/gst/isomp4/qtdemux.vcproj
@@ -0,0 +1,148 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="qtdemux"
+	ProjectGUID="{979C216F-0ACF-4956-AE00-055A42D678C4}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../win32/Debug"
+			IntermediateDirectory="../../win32/Debug"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;qtdemux_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
+				OutputFile="$(OutDir)/gstqtdemux.dll"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="../../../gstreamer/win32/Debug;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
+				ModuleDefinitionFile=""
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/qtdemux.pdb"
+				SubSystem="2"
+				OptimizeReferences="2"
+				ImportLibrary="$(OutDir)/gstqtdemux.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy /Y $(TargetPath) c:\gstreamer\plugins"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../win32/Release"
+			IntermediateDirectory="../../win32/Release"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
+				PreprocessorDefinitions="WIN32;NDEBUG;GST_DISABLE_GST_DEBUG;_WINDOWS;_USRDLL;qtdemux_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
+				OutputFile="$(OutDir)/gstqtdemux.dll"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../gstreamer/win32/Release;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
+				ModuleDefinitionFile=""
+				GenerateDebugInformation="TRUE"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				ImportLibrary="$(OutDir)/gstqtdemux.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy /Y $(TargetPath) c:\gstreamer\plugins"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath=".\qtdemux.c">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath=".\qtdemux.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/gst/isomp4/qtdemux_dump.c b/gst/isomp4/qtdemux_dump.c
new file mode 100644
index 000000000..fa6676758
--- /dev/null
+++ b/gst/isomp4/qtdemux_dump.c
@@ -0,0 +1,809 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) 2009 Tim-Philipp Müller <tim centricular net>
+ * Copyright (C) <2009> STEricsson <benjamin.gaignard@stericsson.com>
+ *
+ * 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.
+ */
+
+#include "qtdemux_types.h"
+#include "qtdemux_dump.h"
+
+#include "qtatomparser.h"
+
+#include <string.h>
+
+#define GET_UINT8(data)   gst_byte_reader_get_uint8_unchecked(data)
+#define GET_UINT16(data)  gst_byte_reader_get_uint16_be_unchecked(data)
+#define GET_UINT32(data)  gst_byte_reader_get_uint32_be_unchecked(data)
+#define GET_UINT64(data)  gst_byte_reader_get_uint64_be_unchecked(data)
+#define GET_FP32(data)   (gst_byte_reader_get_uint32_be_unchecked(data)/65536.0)
+#define GET_FP16(data)   (gst_byte_reader_get_uint16_be_unchecked(data)/256.0)
+#define GET_FOURCC(data)  qt_atom_parser_get_fourcc_unchecked(data)
+
+gboolean
+qtdemux_dump_mvhd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 version = 0;
+
+  if (!qt_atom_parser_has_remaining (data, 100))
+    return FALSE;
+
+  version = GET_UINT32 (data);
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+
+  version = version >> 24;
+  if (version == 0) {
+    GST_LOG ("%*s  creation time: %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s  modify time:   %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s  time scale:    1/%u sec", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s  duration:      %u", depth, "", GET_UINT32 (data));
+  } else if (version == 1) {
+    GST_LOG ("%*s  creation time: %" G_GUINT64_FORMAT,
+        depth, "", GET_UINT64 (data));
+    GST_LOG ("%*s  modify time:   %" G_GUINT64_FORMAT,
+        depth, "", GET_UINT64 (data));
+    GST_LOG ("%*s  time scale:    1/%u sec", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s  duration:      %" G_GUINT64_FORMAT,
+        depth, "", GET_UINT64 (data));
+  } else
+    return FALSE;
+
+  GST_LOG ("%*s  pref. rate:    %g", depth, "", GET_FP32 (data));
+  GST_LOG ("%*s  pref. volume:  %g", depth, "", GET_FP16 (data));
+  gst_byte_reader_skip (data, 46);
+  GST_LOG ("%*s  preview time:  %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  preview dur.:  %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  poster time:   %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  select time:   %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  select dur.:   %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  current time:  %u", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  next track ID: %d", depth, "", GET_UINT32 (data));
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_tkhd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint64 duration, ctime, mtime;
+  guint32 version = 0, track_id = 0, iwidth = 0, iheight = 0;
+  guint16 layer = 0, alt_group = 0, ivol = 0;
+  guint value_size;
+
+  if (!gst_byte_reader_get_uint32_be (data, &version))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+
+  value_size = ((version >> 24) == 1) ? sizeof (guint64) : sizeof (guint32);
+
+  if (qt_atom_parser_get_offset (data, value_size, &ctime) &&
+      qt_atom_parser_get_offset (data, value_size, &mtime) &&
+      gst_byte_reader_get_uint32_be (data, &track_id) &&
+      gst_byte_reader_skip (data, 4) &&
+      qt_atom_parser_get_offset (data, value_size, &duration) &&
+      gst_byte_reader_skip (data, 4) &&
+      gst_byte_reader_get_uint16_be (data, &layer) &&
+      gst_byte_reader_get_uint16_be (data, &alt_group) &&
+      gst_byte_reader_skip (data, 4) &&
+      gst_byte_reader_get_uint16_be (data, &ivol) &&
+      gst_byte_reader_skip (data, 2 + (9 * 4)) &&
+      gst_byte_reader_get_uint32_be (data, &iwidth) &&
+      gst_byte_reader_get_uint32_be (data, &iheight)) {
+    GST_LOG ("%*s  creation time: %" G_GUINT64_FORMAT, depth, "", ctime);
+    GST_LOG ("%*s  modify time:   %" G_GUINT64_FORMAT, depth, "", mtime);
+    GST_LOG ("%*s  track ID:      %u", depth, "", track_id);
+    GST_LOG ("%*s  duration:      %" G_GUINT64_FORMAT, depth, "", duration);
+    GST_LOG ("%*s  layer:         %u", depth, "", layer);
+    GST_LOG ("%*s  alt group:     %u", depth, "", alt_group);
+    GST_LOG ("%*s  volume:        %g", depth, "", ivol / 256.0);
+    GST_LOG ("%*s  track width:   %g", depth, "", iwidth / 65536.0);
+    GST_LOG ("%*s  track height:  %g", depth, "", iheight / 65536.0);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+gboolean
+qtdemux_dump_elst (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4 + 4 + 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    track dur:     %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s    media time:    %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s    media rate:    %g", depth, "", GET_FP32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_mdhd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 version = 0;
+  guint64 duration, ctime, mtime;
+  guint32 time_scale = 0;
+  guint16 language = 0, quality = 0;
+  guint value_size;
+
+  if (!gst_byte_reader_get_uint32_be (data, &version))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+
+  value_size = ((version >> 24) == 1) ? sizeof (guint64) : sizeof (guint32);
+
+  if (qt_atom_parser_get_offset (data, value_size, &ctime) &&
+      qt_atom_parser_get_offset (data, value_size, &mtime) &&
+      gst_byte_reader_get_uint32_be (data, &time_scale) &&
+      qt_atom_parser_get_offset (data, value_size, &duration) &&
+      gst_byte_reader_get_uint16_be (data, &language) &&
+      gst_byte_reader_get_uint16_be (data, &quality)) {
+    GST_LOG ("%*s  creation time: %" G_GUINT64_FORMAT, depth, "", ctime);
+    GST_LOG ("%*s  modify time:   %" G_GUINT64_FORMAT, depth, "", mtime);
+    GST_LOG ("%*s  time scale:    1/%u sec", depth, "", time_scale);
+    GST_LOG ("%*s  duration:      %" G_GUINT64_FORMAT, depth, "", duration);
+    GST_LOG ("%*s  language:      %u", depth, "", language);
+    GST_LOG ("%*s  quality:       %u", depth, "", quality);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+gboolean
+qtdemux_dump_hdlr (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 version, type, subtype, manufacturer;
+  const gchar *name;
+
+  if (!qt_atom_parser_has_remaining (data, 4 + 4 + 4 + 4 + 4 + 4 + 1))
+    return FALSE;
+
+  version = GET_UINT32 (data);
+  type = GET_FOURCC (data);
+  subtype = GET_FOURCC (data);
+  manufacturer = GET_FOURCC (data);
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+  GST_LOG ("%*s  type:          %" GST_FOURCC_FORMAT, depth, "",
+      GST_FOURCC_ARGS (type));
+  GST_LOG ("%*s  subtype:       %" GST_FOURCC_FORMAT, depth, "",
+      GST_FOURCC_ARGS (subtype));
+  GST_LOG ("%*s  manufacturer:  %" GST_FOURCC_FORMAT, depth, "",
+      GST_FOURCC_ARGS (manufacturer));
+  GST_LOG ("%*s  flags:         %08x", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  flags mask:    %08x", depth, "", GET_UINT32 (data));
+
+  /* quicktime uses pascal string, mp4 zero-terminated string */
+  if (gst_byte_reader_peek_string (data, &name)) {
+    GST_LOG ("%*s  name:          %s", depth, "", name);
+  } else {
+    gchar buf[256];
+    guint len;
+
+    len = gst_byte_reader_get_uint8_unchecked (data);
+    if (qt_atom_parser_has_remaining (data, len)) {
+      memcpy (buf, gst_byte_reader_peek_data_unchecked (data), len);
+      buf[len] = '\0';
+      GST_LOG ("%*s  name:          %s", depth, "", buf);
+    }
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_vmhd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  if (!qt_atom_parser_has_remaining (data, 4 + 4))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  mode/color:    %08x", depth, "", GET_UINT32 (data));
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_dref (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %u", depth, "", num_entries);
+  for (i = 0; i < num_entries; i++) {
+    guint32 size = 0, fourcc;
+
+    if (!gst_byte_reader_get_uint32_be (data, &size) ||
+        !qt_atom_parser_get_fourcc (data, &fourcc) || size < 8 ||
+        !gst_byte_reader_skip (data, size - 8))
+      return FALSE;
+
+    GST_LOG ("%*s    size:          %u", depth, "", size);
+    GST_LOG ("%*s    type:          %" GST_FOURCC_FORMAT, depth, "",
+        GST_FOURCC_ARGS (fourcc));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stsd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  for (i = 0; i < num_entries; i++) {
+    GstByteReader sub;
+    guint32 size = 0, fourcc;
+
+    if (!gst_byte_reader_get_uint32_be (data, &size) ||
+        !qt_atom_parser_get_fourcc (data, &fourcc))
+      return FALSE;
+
+    GST_LOG ("%*s    size:          %u", depth, "", size);
+    GST_LOG ("%*s    type:          %" GST_FOURCC_FORMAT, depth, "",
+        GST_FOURCC_ARGS (fourcc));
+
+    if (size < (6 + 2 + 4 + 4 + 4 + 4 + 2 + 2 + 4 + 4 + 4 + 2 + 1 + 31 + 2 + 2))
+      return FALSE;
+
+    qt_atom_parser_peek_sub (data, 0, 78, &sub);
+    gst_byte_reader_skip (&sub, 6);
+    GST_LOG ("%*s    data reference:%d", depth, "", GET_UINT16 (&sub));
+    GST_LOG ("%*s    version/rev.:  %08x", depth, "", GET_UINT32 (&sub));
+    fourcc = GET_FOURCC (&sub);
+    GST_LOG ("%*s    vendor:        %" GST_FOURCC_FORMAT, depth, "",
+        GST_FOURCC_ARGS (fourcc));
+    GST_LOG ("%*s    temporal qual: %u", depth, "", GET_UINT32 (&sub));
+    GST_LOG ("%*s    spatial qual:  %u", depth, "", GET_UINT32 (&sub));
+    GST_LOG ("%*s    width:         %u", depth, "", GET_UINT16 (&sub));
+    GST_LOG ("%*s    height:        %u", depth, "", GET_UINT16 (&sub));
+    GST_LOG ("%*s    horiz. resol:  %g", depth, "", GET_FP32 (&sub));
+    GST_LOG ("%*s    vert. resol.:  %g", depth, "", GET_FP32 (&sub));
+    GST_LOG ("%*s    data size:     %u", depth, "", GET_UINT32 (&sub));
+    GST_LOG ("%*s    frame count:   %u", depth, "", GET_UINT16 (&sub));
+    /* something is not right with this, it's supposed to be a string but it's
+     * not apparently, so just skip this for now */
+    gst_byte_reader_skip (&sub, 1 + 31);
+    GST_LOG ("%*s    compressor:    (skipped)", depth, "");
+    GST_LOG ("%*s    depth:         %u", depth, "", GET_UINT16 (&sub));
+    GST_LOG ("%*s    color table ID:%u", depth, "", GET_UINT16 (&sub));
+    if (!gst_byte_reader_skip (data, size - (4 + 4)))
+      return FALSE;
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stts (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4 + 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    count:         %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s    duration:      %u", depth, "", GET_UINT32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stps (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    sample:        %u", depth, "", GET_UINT32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stss (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    sample:        %u", depth, "", GET_UINT32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stsc (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4 + 4 + 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    first chunk:   %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s    sample per ch: %u", depth, "", GET_UINT32 (data));
+    GST_LOG ("%*s    sample desc id:%08x", depth, "", GET_UINT32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stsz (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, sample_size = 0, num_entries = 0;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &sample_size))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  sample size:   %d", depth, "", sample_size);
+
+  if (sample_size == 0) {
+    if (!gst_byte_reader_get_uint32_be (data, &num_entries))
+      return FALSE;
+
+    GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+#if 0
+    if (!qt_atom_parser_has_chunks (data, num_entries, 4))
+      return FALSE;
+    for (i = 0; i < num_entries; i++) {
+      GST_LOG ("%*s    sample size:   %u", depth, "", GET_UINT32 (data));
+    }
+#endif
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_stco (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    chunk offset:  %u", depth, "", GET_UINT32 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_ctts (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i, count, offset;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 4 + 4))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    count = GET_UINT32 (data);
+    offset = GET_UINT32 (data);
+    GST_LOG ("%*s    sample count :%8d offset: %8d", depth, "", count, offset);
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_co64 (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 ver_flags = 0, num_entries = 0, i;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags) ||
+      !gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+  GST_LOG ("%*s  n entries:     %d", depth, "", num_entries);
+
+  if (!qt_atom_parser_has_chunks (data, num_entries, 8))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    GST_LOG ("%*s    chunk offset:  %" G_GUINT64_FORMAT, depth, "",
+        GET_UINT64 (data));
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_dcom (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  if (!qt_atom_parser_has_remaining (data, 4))
+    return FALSE;
+
+  GST_LOG ("%*s  compression type: %" GST_FOURCC_FORMAT, depth, "",
+      GST_FOURCC_ARGS (GET_FOURCC (data)));
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_cmvd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  if (!qt_atom_parser_has_remaining (data, 4))
+    return FALSE;
+
+  GST_LOG ("%*s  length: %d", depth, "", GET_UINT32 (data));
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_mfro (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  if (!qt_atom_parser_has_remaining (data, 4))
+    return FALSE;
+
+  GST_LOG ("%*s  size: %d", depth, "", GET_UINT32 (data));
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_tfra (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint64 time = 0, moof_offset = 0;
+  guint32 len = 0, num_entries = 0, ver_flags = 0, track_id = 0, i;
+  guint value_size, traf_size, trun_size, sample_size;
+
+  if (!gst_byte_reader_get_uint32_be (data, &ver_flags))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", ver_flags);
+
+  if (!gst_byte_reader_get_uint32_be (data, &track_id) ||
+      gst_byte_reader_get_uint32_be (data, &len) ||
+      gst_byte_reader_get_uint32_be (data, &num_entries))
+    return FALSE;
+
+  GST_LOG ("%*s  track ID:      %u", depth, "", track_id);
+  GST_LOG ("%*s  length:        0x%x", depth, "", len);
+  GST_LOG ("%*s  n entries:     %u", depth, "", num_entries);
+
+  value_size = ((ver_flags >> 24) == 1) ? sizeof (guint64) : sizeof (guint32);
+  sample_size = (len & 3) + 1;
+  trun_size = ((len & 12) >> 2) + 1;
+  traf_size = ((len & 48) >> 4) + 1;
+
+  if (!qt_atom_parser_has_chunks (data, num_entries,
+          value_size + value_size + traf_size + trun_size + sample_size))
+    return FALSE;
+
+  for (i = 0; i < num_entries; i++) {
+    qt_atom_parser_get_offset (data, value_size, &time);
+    qt_atom_parser_get_offset (data, value_size, &moof_offset);
+    GST_LOG ("%*s    time:          %" G_GUINT64_FORMAT, depth, "", time);
+    GST_LOG ("%*s    moof_offset:   %" G_GUINT64_FORMAT,
+        depth, "", moof_offset);
+    GST_LOG ("%*s    traf_number:   %u", depth, "",
+        qt_atom_parser_get_uint_with_size_unchecked (data, traf_size));
+    GST_LOG ("%*s    trun_number:   %u", depth, "",
+        qt_atom_parser_get_uint_with_size_unchecked (data, trun_size));
+    GST_LOG ("%*s    sample_number: %u", depth, "",
+        qt_atom_parser_get_uint_with_size_unchecked (data, sample_size));
+  }
+
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_tfhd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 flags = 0, n = 0, track_id = 0;
+  guint64 base_data_offset = 0;
+
+  if (!gst_byte_reader_skip (data, 1) ||
+      !gst_byte_reader_get_uint24_be (data, &flags))
+    return FALSE;
+  GST_LOG ("%*s  flags: %08x", depth, "", flags);
+
+  if (!gst_byte_reader_get_uint32_be (data, &track_id))
+    return FALSE;
+  GST_LOG ("%*s  track_id: %u", depth, "", track_id);
+
+  if (flags & TF_BASE_DATA_OFFSET) {
+    if (!gst_byte_reader_get_uint64_be (data, &base_data_offset))
+      return FALSE;
+    GST_LOG ("%*s    base-data-offset: %" G_GUINT64_FORMAT,
+        depth, "", base_data_offset);
+  }
+
+  if (flags & TF_SAMPLE_DESCRIPTION_INDEX) {
+    if (!gst_byte_reader_get_uint32_be (data, &n))
+      return FALSE;
+    GST_LOG ("%*s    sample-description-index: %u", depth, "", n);
+  }
+
+  if (flags & TF_DEFAULT_SAMPLE_DURATION) {
+    if (!gst_byte_reader_get_uint32_be (data, &n))
+      return FALSE;
+    GST_LOG ("%*s    default-sample-duration:  %u", depth, "", n);
+  }
+
+  if (flags & TF_DEFAULT_SAMPLE_SIZE) {
+    if (!gst_byte_reader_get_uint32_be (data, &n))
+      return FALSE;
+    GST_LOG ("%*s    default-sample-size:  %u", depth, "", n);
+  }
+
+  if (flags & TF_DEFAULT_SAMPLE_FLAGS) {
+    if (!gst_byte_reader_get_uint32_be (data, &n))
+      return FALSE;
+    GST_LOG ("%*s    default-sample-flags:  %u", depth, "", n);
+  }
+
+  GST_LOG ("%*s    duration-is-empty:     %s", depth, "",
+      flags & TF_DURATION_IS_EMPTY ? "yes" : "no");
+
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_trun (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 flags = 0, samples_count = 0, data_offset = 0, first_sample_flags = 0;
+  guint32 sample_duration = 0, sample_size = 0, sample_flags =
+      0, composition_time_offsets = 0;
+  int i = 0;
+
+  if (!gst_byte_reader_skip (data, 1) ||
+      !gst_byte_reader_get_uint24_be (data, &flags))
+    return FALSE;
+
+  GST_LOG ("%*s  flags: %08x", depth, "", flags);
+
+  if (!gst_byte_reader_get_uint32_be (data, &samples_count))
+    return FALSE;
+  GST_LOG ("%*s  samples_count: %u", depth, "", samples_count);
+
+  if (flags & TR_DATA_OFFSET) {
+    if (!gst_byte_reader_get_uint32_be (data, &data_offset))
+      return FALSE;
+    GST_LOG ("%*s    data-offset: %u", depth, "", data_offset);
+  }
+
+  if (flags & TR_FIRST_SAMPLE_FLAGS) {
+    if (!gst_byte_reader_get_uint32_be (data, &first_sample_flags))
+      return FALSE;
+    GST_LOG ("%*s    first-sample-flags: %u", depth, "", first_sample_flags);
+  }
+
+  for (i = 0; i < samples_count; i++) {
+    if (flags & TR_SAMPLE_DURATION) {
+      if (!gst_byte_reader_get_uint32_be (data, &sample_duration))
+        return FALSE;
+      GST_LOG ("%*s    sample-duration:  %u", depth, "", sample_duration);
+    }
+
+    if (flags & TR_SAMPLE_SIZE) {
+      if (!gst_byte_reader_get_uint32_be (data, &sample_size))
+        return FALSE;
+      GST_LOG ("%*s    sample-size:  %u", depth, "", sample_size);
+    }
+
+    if (flags & TR_SAMPLE_FLAGS) {
+      if (!gst_byte_reader_get_uint32_be (data, &sample_flags))
+        return FALSE;
+      GST_LOG ("%*s    sample-flags:  %u", depth, "", sample_flags);
+    }
+
+    if (flags & TR_COMPOSITION_TIME_OFFSETS) {
+      if (!gst_byte_reader_get_uint32_be (data, &composition_time_offsets))
+        return FALSE;
+      GST_LOG ("%*s    composition_time_offsets:  %u", depth, "",
+          composition_time_offsets);
+    }
+  }
+
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_trex (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  if (!qt_atom_parser_has_remaining (data, 4 + 4 + 4 + 4 + 4 + 4))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  track ID:      %08x", depth, "", GET_UINT32 (data));
+  GST_LOG ("%*s  default sample desc. index: %08x", depth, "",
+      GET_UINT32 (data));
+  GST_LOG ("%*s  default sample duration:    %08x", depth, "",
+      GET_UINT32 (data));
+  GST_LOG ("%*s  default sample size:        %08x", depth, "",
+      GET_UINT32 (data));
+  GST_LOG ("%*s  default sample flags:       %08x", depth, "",
+      GET_UINT32 (data));
+
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_mehd (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 version = 0;
+  guint64 fragment_duration;
+  guint value_size;
+
+  if (!gst_byte_reader_get_uint32_be (data, &version))
+    return FALSE;
+
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+
+  value_size = ((version >> 24) == 1) ? sizeof (guint64) : sizeof (guint32);
+  if (qt_atom_parser_get_offset (data, value_size, &fragment_duration)) {
+    GST_LOG ("%*s  fragment duration: %" G_GUINT64_FORMAT,
+        depth, "", fragment_duration);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+gboolean
+qtdemux_dump_sdtp (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  guint32 version;
+  guint8 val;
+  guint i = 1;
+
+  version = GET_UINT32 (data);
+  GST_LOG ("%*s  version/flags: %08x", depth, "", version);
+
+  /* the sample_count is specified in the stsz or stz2 box.
+   * the information for a sample is stored in a single byte,
+   * so we read until there are no remaining bytes */
+  while (qt_atom_parser_has_remaining (data, 1)) {
+    val = GET_UINT8 (data);
+    GST_LOG ("%*s     sample number: %d", depth, "", i);
+    GST_LOG ("%*s     sample_depends_on: %d", depth, "",
+        ((guint16) (val)) & 0x3);
+    GST_LOG ("%*s     sample_is_depended_on: %d", depth, "",
+        ((guint16) (val >> 2)) & 0x3);
+    GST_LOG ("%*s     sample_has_redundancy: %d", depth, "",
+        ((guint16) (val >> 4)) & 0x3);
+    ++i;
+  }
+  return TRUE;
+}
+
+gboolean
+qtdemux_dump_unknown (GstQTDemux * qtdemux, GstByteReader * data, int depth)
+{
+  int len;
+
+  len = gst_byte_reader_get_remaining (data);
+  GST_LOG ("%*s  length: %d", depth, "", len);
+
+  GST_MEMDUMP_OBJECT (qtdemux, "unknown atom data",
+      gst_byte_reader_peek_data_unchecked (data), len);
+  return TRUE;
+}
+
+static gboolean
+qtdemux_node_dump_foreach (GNode * node, gpointer qtdemux)
+{
+  GstByteReader parser;
+  guint8 *buffer = (guint8 *) node->data;       /* FIXME: move to byte reader */
+  guint32 node_length;
+  guint32 fourcc;
+  const QtNodeType *type;
+  int depth;
+
+  node_length = GST_READ_UINT32_BE (buffer);
+  fourcc = GST_READ_UINT32_LE (buffer + 4);
+
+  g_warn_if_fail (node_length >= 8);
+
+  gst_byte_reader_init (&parser, buffer + 8, node_length - 8);
+
+  type = qtdemux_type_get (fourcc);
+
+  depth = (g_node_depth (node) - 1) * 2;
+  GST_LOG ("%*s'%" GST_FOURCC_FORMAT "', [%d], %s",
+      depth, "", GST_FOURCC_ARGS (fourcc), node_length, type->name);
+
+  if (type->dump) {
+    gboolean ret;
+
+    ret = type->dump (GST_QTDEMUX_CAST (qtdemux), &parser, depth);
+
+    if (!ret) {
+      GST_WARNING ("%*s  not enough data parsing atom %" GST_FOURCC_FORMAT,
+          depth, "", GST_FOURCC_ARGS (fourcc));
+    }
+  }
+
+  return FALSE;
+}
+
+gboolean
+qtdemux_node_dump (GstQTDemux * qtdemux, GNode * node)
+{
+  if (__gst_debug_min < GST_LEVEL_LOG)
+    return TRUE;
+
+  g_node_traverse (node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+      qtdemux_node_dump_foreach, qtdemux);
+  return TRUE;
+}
diff --git a/gst/isomp4/qtdemux_dump.h b/gst/isomp4/qtdemux_dump.h
new file mode 100644
index 000000000..9bb1f95d4
--- /dev/null
+++ b/gst/isomp4/qtdemux_dump.h
@@ -0,0 +1,84 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2009> STEricsson <benjamin.gaignard@stericsson.com>
+ *
+ * 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_QTDEMUX_DUMP_H__
+#define __GST_QTDEMUX_DUMP_H__
+
+#include <gst/gst.h>
+#include <qtdemux.h>
+
+G_BEGIN_DECLS
+    gboolean qtdemux_dump_mvhd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_tkhd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_elst (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_mdhd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_hdlr (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_vmhd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_dref (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stsd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stts (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stss (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stps (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stsc (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stsz (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_stco (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_co64 (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_dcom (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_cmvd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_ctts (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_mfro (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_tfra (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_tfhd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_trun (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_trex (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_mehd (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_sdtp (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+gboolean qtdemux_dump_unknown (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+
+gboolean qtdemux_node_dump (GstQTDemux * qtdemux, GNode * node);
+
+G_END_DECLS
+#endif /* __GST_QTDEMUX_DUMP_H__ */
diff --git a/gst/isomp4/qtdemux_fourcc.h b/gst/isomp4/qtdemux_fourcc.h
new file mode 100644
index 000000000..29ad155a3
--- /dev/null
+++ b/gst/isomp4/qtdemux_fourcc.h
@@ -0,0 +1,232 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GST_QTDEMUX_FOURCC_H__
+#define __GST_QTDEMUX_FOURCC_H__
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+#define FOURCC_ftyp     GST_MAKE_FOURCC('f','t','y','p')
+#define FOURCC_qt__     GST_MAKE_FOURCC('q','t',' ',' ')
+#define FOURCC_moov     GST_MAKE_FOURCC('m','o','o','v')
+#define FOURCC_mvhd     GST_MAKE_FOURCC('m','v','h','d')
+#define FOURCC_clip     GST_MAKE_FOURCC('c','l','i','p')
+#define FOURCC_trak     GST_MAKE_FOURCC('t','r','a','k')
+#define FOURCC_udta     GST_MAKE_FOURCC('u','d','t','a')
+#define FOURCC_ctab     GST_MAKE_FOURCC('c','t','a','b')
+#define FOURCC_tkhd     GST_MAKE_FOURCC('t','k','h','d')
+#define FOURCC_crgn     GST_MAKE_FOURCC('c','r','g','n')
+#define FOURCC_matt     GST_MAKE_FOURCC('m','a','t','t')
+#define FOURCC_kmat     GST_MAKE_FOURCC('k','m','a','t')
+#define FOURCC_edts     GST_MAKE_FOURCC('e','d','t','s')
+#define FOURCC_elst     GST_MAKE_FOURCC('e','l','s','t')
+#define FOURCC_load     GST_MAKE_FOURCC('l','o','a','d')
+#define FOURCC_tref     GST_MAKE_FOURCC('t','r','e','f')
+#define FOURCC_imap     GST_MAKE_FOURCC('i','m','a','p')
+#define FOURCC___in     GST_MAKE_FOURCC(' ',' ','i','n')
+#define FOURCC___ty     GST_MAKE_FOURCC(' ',' ','t','y')
+#define FOURCC_mdia     GST_MAKE_FOURCC('m','d','i','a')
+#define FOURCC_mdhd     GST_MAKE_FOURCC('m','d','h','d')
+#define FOURCC_hdlr     GST_MAKE_FOURCC('h','d','l','r')
+#define FOURCC_hndl     GST_MAKE_FOURCC('h','n','d','l')
+#define FOURCC_minf     GST_MAKE_FOURCC('m','i','n','f')
+#define FOURCC_vmhd     GST_MAKE_FOURCC('v','m','h','d')
+#define FOURCC_smhd     GST_MAKE_FOURCC('s','m','h','d')
+#define FOURCC_gmhd     GST_MAKE_FOURCC('g','m','h','d')
+#define FOURCC_gmin     GST_MAKE_FOURCC('g','m','i','n')
+#define FOURCC_dinf     GST_MAKE_FOURCC('d','i','n','f')
+#define FOURCC_dref     GST_MAKE_FOURCC('d','r','e','f')
+#define FOURCC_stbl     GST_MAKE_FOURCC('s','t','b','l')
+#define FOURCC_stsd     GST_MAKE_FOURCC('s','t','s','d')
+#define FOURCC_stts     GST_MAKE_FOURCC('s','t','t','s')
+#define FOURCC_stss     GST_MAKE_FOURCC('s','t','s','s')
+#define FOURCC_stps     GST_MAKE_FOURCC('s','t','p','s')
+#define FOURCC_stsc     GST_MAKE_FOURCC('s','t','s','c')
+#define FOURCC_stsz     GST_MAKE_FOURCC('s','t','s','z')
+#define FOURCC_stco     GST_MAKE_FOURCC('s','t','c','o')
+#define FOURCC_vide     GST_MAKE_FOURCC('v','i','d','e')
+#define FOURCC_soun     GST_MAKE_FOURCC('s','o','u','n')
+#define FOURCC_subp     GST_MAKE_FOURCC('s','u','b','p')
+#define FOURCC_strm     GST_MAKE_FOURCC('s','t','r','m')
+#define FOURCC_rtsp     GST_MAKE_FOURCC('r','t','s','p')
+#define FOURCC_co64     GST_MAKE_FOURCC('c','o','6','4')
+#define FOURCC_cmov     GST_MAKE_FOURCC('c','m','o','v')
+#define FOURCC_dcom     GST_MAKE_FOURCC('d','c','o','m')
+#define FOURCC_cmvd     GST_MAKE_FOURCC('c','m','v','d')
+#define FOURCC_hint     GST_MAKE_FOURCC('h','i','n','t')
+#define FOURCC_mp4a     GST_MAKE_FOURCC('m','p','4','a')
+#define FOURCC_mp4v     GST_MAKE_FOURCC('m','p','4','v')
+#define FOURCC_MP4V     GST_MAKE_FOURCC('M','P','4','V')
+#define FOURCC_fmp4     GST_MAKE_FOURCC('f','m','p','4')
+#define FOURCC_FMP4     GST_MAKE_FOURCC('F','M','P','4')
+#define FOURCC_glbl     GST_MAKE_FOURCC('g','l','b','l')
+#define FOURCC_wave     GST_MAKE_FOURCC('w','a','v','e')
+#define FOURCC_appl     GST_MAKE_FOURCC('a','p','p','l')
+#define FOURCC_esds     GST_MAKE_FOURCC('e','s','d','s')
+#define FOURCC_pasp     GST_MAKE_FOURCC('p','a','s','p')
+#define FOURCC_hnti     GST_MAKE_FOURCC('h','n','t','i')
+#define FOURCC_rtp_     GST_MAKE_FOURCC('r','t','p',' ')
+#define FOURCC_sdp_     GST_MAKE_FOURCC('s','d','p',' ')
+#define FOURCC_meta     GST_MAKE_FOURCC('m','e','t','a')
+#define FOURCC_ilst     GST_MAKE_FOURCC('i','l','s','t')
+#define FOURCC__nam     GST_MAKE_FOURCC(0xa9,'n','a','m')
+#define FOURCC__cmt     GST_MAKE_FOURCC(0xa9,'c','m','t')
+#define FOURCC__des     GST_MAKE_FOURCC(0xa9,'d','e','s')
+#define FOURCC_desc     GST_MAKE_FOURCC('d','e','s','c')
+#define FOURCC__lyr     GST_MAKE_FOURCC(0xa9,'l','y','r')
+#define FOURCC__cpy     GST_MAKE_FOURCC(0xa9,'c','p','y')
+#define FOURCC__ART     GST_MAKE_FOURCC(0xa9,'A','R','T')
+#define FOURCC_aART     GST_MAKE_FOURCC('a','A','R','T')
+#define FOURCC__wrt     GST_MAKE_FOURCC(0xa9,'w','r','t')
+#define FOURCC__grp     GST_MAKE_FOURCC(0xa9,'g','r','p')
+#define FOURCC__alb     GST_MAKE_FOURCC(0xa9,'a','l','b')
+#define FOURCC__day     GST_MAKE_FOURCC(0xa9,'d','a','y')
+#define FOURCC__req     GST_MAKE_FOURCC(0xa9,'r','e','q')
+#define FOURCC__enc     GST_MAKE_FOURCC(0xa9,'e','n','c')
+#define FOURCC__inf     GST_MAKE_FOURCC(0xa9,'i','n','f')
+#define FOURCC_cprt     GST_MAKE_FOURCC('c','p','r','t')
+#define FOURCC_gnre     GST_MAKE_FOURCC('g','n','r','e')
+#define FOURCC_disc     GST_MAKE_FOURCC('d','i','s','c')
+#define FOURCC_disk     GST_MAKE_FOURCC('d','i','s','k')
+#define FOURCC_trkn     GST_MAKE_FOURCC('t','r','k','n')
+#define FOURCC_cpil     GST_MAKE_FOURCC('c','p','i','l')
+#define FOURCC_pgap     GST_MAKE_FOURCC('p','g','a','p')
+#define FOURCC_pcst     GST_MAKE_FOURCC('p','c','s','t')
+#define FOURCC_tmpo     GST_MAKE_FOURCC('t','m','p','o')
+#define FOURCC_covr     GST_MAKE_FOURCC('c','o','v','r')
+#define FOURCC__too     GST_MAKE_FOURCC(0xa9,'t','o','o')
+#define FOURCC_tvsh     GST_MAKE_FOURCC('t','v','s','h')
+#define FOURCC_tven     GST_MAKE_FOURCC('t','v','e','n')
+#define FOURCC_tvsn     GST_MAKE_FOURCC('t','v','s','n')
+#define FOURCC_tves     GST_MAKE_FOURCC('t','v','e','s')
+#define FOURCC_sonm     GST_MAKE_FOURCC('s','o','n','m')
+#define FOURCC_soal     GST_MAKE_FOURCC('s','o','a','l')
+#define FOURCC_soar     GST_MAKE_FOURCC('s','o','a','r')
+#define FOURCC_soaa     GST_MAKE_FOURCC('s','o','a','a')
+#define FOURCC_soco     GST_MAKE_FOURCC('s','o','c','o')
+#define FOURCC_sosn     GST_MAKE_FOURCC('s','o','s','n')
+#define FOURCC_____     GST_MAKE_FOURCC('-','-','-','-')
+#define FOURCC_mean     GST_MAKE_FOURCC('m','e','a','n')
+#define FOURCC_name     GST_MAKE_FOURCC('n','a','m','e')
+#define FOURCC_free     GST_MAKE_FOURCC('f','r','e','e')
+#define FOURCC_data     GST_MAKE_FOURCC('d','a','t','a')
+#define FOURCC_SVQ3     GST_MAKE_FOURCC('S','V','Q','3')
+#define FOURCC_rmra     GST_MAKE_FOURCC('r','m','r','a')
+#define FOURCC_rmda     GST_MAKE_FOURCC('r','m','d','a')
+#define FOURCC_rdrf     GST_MAKE_FOURCC('r','d','r','f')
+#define FOURCC__gen     GST_MAKE_FOURCC(0xa9, 'g', 'e', 'n')
+#define FOURCC_rmdr     GST_MAKE_FOURCC('r','m','d','r')
+#define FOURCC_rmvc     GST_MAKE_FOURCC('r','m','v','c')
+#define FOURCC_qtim     GST_MAKE_FOURCC('q','t','i','m')
+#define FOURCC_drms     GST_MAKE_FOURCC('d','r','m','s')
+#define FOURCC_drmi     GST_MAKE_FOURCC('d','r','m','i')
+#define FOURCC_avc1     GST_MAKE_FOURCC('a','v','c','1')
+#define FOURCC_avcC     GST_MAKE_FOURCC('a','v','c','C')
+#define FOURCC_btrt     GST_MAKE_FOURCC('b','t','r','t')
+#define FOURCC_VP31     GST_MAKE_FOURCC('V','P','3','1')
+#define FOURCC_rle_     GST_MAKE_FOURCC('r','l','e',' ')
+#define FOURCC_MAC6     GST_MAKE_FOURCC('M','A','C','6')
+#define FOURCC_MAC3     GST_MAKE_FOURCC('M','A','C','3')
+#define FOURCC_ima4     GST_MAKE_FOURCC('i','m','a','4')
+#define FOURCC_ulaw     GST_MAKE_FOURCC('u','l','a','w')
+#define FOURCC_alaw     GST_MAKE_FOURCC('a','l','a','w')
+#define FOURCC_twos     GST_MAKE_FOURCC('t','w','o','s')
+#define FOURCC_sowt     GST_MAKE_FOURCC('s','o','w','t')
+#define FOURCC_raw_     GST_MAKE_FOURCC('r','a','w',' ')
+#define FOURCC_in24     GST_MAKE_FOURCC('i','n','2','4')
+#define FOURCC_enda     GST_MAKE_FOURCC('e','n','d','a')
+#define FOURCC_QDM2     GST_MAKE_FOURCC('Q','D','M','2')
+#define FOURCC_alac     GST_MAKE_FOURCC('a','l','a','c')
+#define FOURCC_samr     GST_MAKE_FOURCC('s','a','m','r')
+#define FOURCC_sawb     GST_MAKE_FOURCC('s','a','w','b')
+#define FOURCC_mdat     GST_MAKE_FOURCC('m','d','a','t')
+#define FOURCC_wide     GST_MAKE_FOURCC('w','i','d','e')
+#define FOURCC_PICT     GST_MAKE_FOURCC('P','I','C','T')
+#define FOURCC_pnot     GST_MAKE_FOURCC('p','n','o','t')
+#define FOURCC_zlib     GST_MAKE_FOURCC('z','l','i','b')
+#define FOURCC_alis     GST_MAKE_FOURCC('a','l','i','s')
+#define FOURCC_url_     GST_MAKE_FOURCC('u','r','l',' ')
+#define FOURCC_frma     GST_MAKE_FOURCC('f','r','m','a')
+#define FOURCC_ctts     GST_MAKE_FOURCC('c','t','t','s')
+#define FOURCC_keyw     GST_MAKE_FOURCC('k','e','y','w')
+#define FOURCC_kywd     GST_MAKE_FOURCC('k','y','w','d')
+#define FOURCC_agsm     GST_MAKE_FOURCC('a','g','s','m')
+#define FOURCC_text     GST_MAKE_FOURCC('t','e','x','t')
+#define FOURCC_tx3g     GST_MAKE_FOURCC('t','x','3','g')
+#define FOURCC_mp4s     GST_MAKE_FOURCC('m','p','4','s')
+#define FOURCC_gama     GST_MAKE_FOURCC('g','a','m','a')
+
+/* SVQ3 fourcc */
+#define FOURCC_SEQH     GST_MAKE_FOURCC('S','E','Q','H')
+#define FOURCC_SMI_     GST_MAKE_FOURCC('S','M','I',' ')
+
+/* 3gpp asset meta data fourcc */
+#define FOURCC_titl     GST_MAKE_FOURCC('t','i','t','l')
+#define FOURCC_dscp     GST_MAKE_FOURCC('d','s','c','p')
+#define FOURCC_perf     GST_MAKE_FOURCC('p','e','r','f')
+#define FOURCC_auth     GST_MAKE_FOURCC('a','u','t','h')
+#define FOURCC_rtng     GST_MAKE_FOURCC('r','t','n','g')
+#define FOURCC_clsf     GST_MAKE_FOURCC('c','l','s','f')
+#define FOURCC_loci     GST_MAKE_FOURCC('l','o','c','i')
+#define FOURCC_albm     GST_MAKE_FOURCC('a','l','b','m')
+#define FOURCC_yrrc     GST_MAKE_FOURCC('y','r','r','c')
+
+/* ISO Motion JPEG 2000 fourcc */
+#define FOURCC_mjp2     GST_MAKE_FOURCC('m','j','p','2')
+#define FOURCC_jp2h     GST_MAKE_FOURCC('j','p','2','h')
+#define FOURCC_ihdr     GST_MAKE_FOURCC('i','h','d','r')
+#define FOURCC_colr     GST_MAKE_FOURCC('c','o','l','r')
+#define FOURCC_fiel     GST_MAKE_FOURCC('f','i','e','l')
+#define FOURCC_jp2x     GST_MAKE_FOURCC('j','p','2','x')
+#define FOURCC_cmap     GST_MAKE_FOURCC('c','m','a','p')
+#define FOURCC_cdef     GST_MAKE_FOURCC('c','d','e','f')
+/* some buggy hardware's notion of mdhd */
+#define FOURCC_mhdr     GST_MAKE_FOURCC('m','h','d','r')
+
+/* Xiph fourcc */
+#define FOURCC_XiTh     GST_MAKE_FOURCC('X','i','T','h')
+#define FOURCC_XdxT     GST_MAKE_FOURCC('X','d','x','T')
+#define FOURCC_tCtH     GST_MAKE_FOURCC('t','C','t','H')
+#define FOURCC_tCt_     GST_MAKE_FOURCC('t','C','t','#')
+#define FOURCC_tCtC     GST_MAKE_FOURCC('t','C','t','C')
+
+#define FOURCC_XMP_     GST_MAKE_FOURCC('X','M','P','_')
+#define FOURCC_uuid     GST_MAKE_FOURCC('u','u','i','d')
+
+/* Fragmented MP4 */
+#define FOURCC_mehd     GST_MAKE_FOURCC('m','e','h','d')
+#define FOURCC_mfhd     GST_MAKE_FOURCC('m','f','h','d')
+#define FOURCC_mfra     GST_MAKE_FOURCC('m','f','r','a')
+#define FOURCC_mfro     GST_MAKE_FOURCC('m','f','r','o')
+#define FOURCC_moof     GST_MAKE_FOURCC('m','o','o','f')
+#define FOURCC_mvex     GST_MAKE_FOURCC('m','v','e','x')
+#define FOURCC_sdtp     GST_MAKE_FOURCC('s','d','t','p')
+#define FOURCC_tfhd     GST_MAKE_FOURCC('t','f','h','d')
+#define FOURCC_tfra     GST_MAKE_FOURCC('t','f','r','a')
+#define FOURCC_traf     GST_MAKE_FOURCC('t','r','a','f')
+#define FOURCC_trex     GST_MAKE_FOURCC('t','r','e','x')
+#define FOURCC_trun     GST_MAKE_FOURCC('t','r','u','n')
+#define FOURCC_ovc1     GST_MAKE_FOURCC('o','v','c','1')
+#define FOURCC_owma     GST_MAKE_FOURCC('o','w','m','a')
+
+G_END_DECLS
+
+#endif /* __GST_QTDEMUX_FOURCC_H__ */
diff --git a/gst/isomp4/qtdemux_lang.c b/gst/isomp4/qtdemux_lang.c
new file mode 100644
index 000000000..9a46d9075
--- /dev/null
+++ b/gst/isomp4/qtdemux_lang.c
@@ -0,0 +1,205 @@
+/* GStreamer Quicktime/ISO demuxer language utility functions
+ * Copyright (C) 2010 Tim-Philipp Müller <tim centricular net>
+ *
+ * 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.
+ */
+
+#include "qtdemux.h"
+#include "qtdemux_lang.h"
+
+#include <string.h>
+
+/* http://developer.apple.com/mac/library/documentation/QuickTime/QTFF/QTFFChap4/qtff4.html */
+
+static const gchar qt_lang_map[][4] = {
+
+/* 000 English
+ * 001 French
+ * 002 German
+ * 003 Italian
+ * 004 Dutch
+ * 005 Swedish
+ * 006 Spanish
+ * 007 Danish
+ * 008 Portuguese
+ * 009 Norwegian
+ */
+  "eng", "fre", "deu", "ita", "nld", "swe", "spa", "dan", "por", "nor",
+
+/* 010 Hebrew
+ * 011 Japanese
+ * 012 Arabic
+ * 013 Finnish
+ * 014 Greek
+ * 015 Icelandic
+ * 016 Maltese
+ * 017 Turkish
+ * 018 Croatian
+ * 019 Traditional Chinese (ISO 639-2 can't express script differences, so zho)
+ */
+  "heb", "jpn", "ara", "fin", "ell", "isl", "mlt", "tur", "hrv", "zho",
+
+/* 020 Urdu
+ * 021 Hindi
+ * 022 Thai
+ * 023 Korean
+ * 024 Lithuanian
+ * 025 Polish
+ * 026 Hungarian
+ * 027 Estonian
+ * 028 Latvian / Lettish
+ * 029 Lappish / Saamish (used code for Nothern Sami)
+ */
+  "urd", "hin", "tha", "kor", "lit", "pol", "hun", "est", "lav", "sme",
+
+/* 030 Faeroese
+ * 031 Farsi
+ * 032 Russian
+ * 033 Simplified Chinese (ISO 639-2 can't express script differences, so zho)
+ * 034 Flemish (no ISO 639-2 code, used Dutch code)
+ * 035 Irish
+ * 036 Albanian
+ * 037 Romanian
+ * 038 Czech
+ * 039 Slovak
+ */
+  "fao", "fas", "rus", "zho", "nld", "gle", "sqi", "ron", "ces", "slk",
+
+/* 040 Slovenian
+ * 041 Yiddish
+ * 042 Serbian
+ * 043 Macedonian
+ * 044 Bulgarian
+ * 045 Ukrainian
+ * 046 Byelorussian
+ * 047 Uzbek
+ * 048 Kazakh
+ * 049 Azerbaijani
+ */
+  "slv", "yid", "srp", "mkd", "bul", "ukr", "bel", "uzb", "kaz", "aze",
+
+/* 050 AzerbaijanAr (presumably script difference? used aze here)
+ * 051 Armenian
+ * 052 Georgian
+ * 053 Moldavian
+ * 054 Kirghiz
+ * 055 Tajiki
+ * 056 Turkmen
+ * 057 Mongolian
+ * 058 MongolianCyr (presumably script difference? used mon here)
+ * 059 Pashto
+ */
+
+  "aze", "hye", "kat", "mol", "kir", "tgk", "tuk", "mon", "mon", "pus",
+
+
+/* 060 Kurdish
+ * 061 Kashmiri
+ * 062 Sindhi
+ * 063 Tibetan
+ * 064 Nepali
+ * 065 Sanskrit
+ * 066 Marathi
+ * 067 Bengali
+ * 068 Assamese
+ * 069 Gujarati
+ */
+  "kur", "kas", "snd", "bod", "nep", "san", "mar", "ben", "asm", "guj",
+
+/* 070 Punjabi
+ * 071 Oriya
+ * 072 Malayalam
+ * 073 Kannada
+ * 074 Tamil
+ * 075 Telugu
+ * 076 Sinhalese
+ * 077 Burmese
+ * 078 Khmer
+ * 079 Lao
+ */
+  "pan", "ori", "mal", "kan", "tam", "tel", "sin", "mya", "khm", "lao",
+
+/* 080 Vietnamese
+ * 081 Indonesian
+ * 082 Tagalog
+ * 083 MalayRoman
+ * 084 MalayArabic
+ * 085 Amharic
+ * 087 Galla (same as Oromo?)
+ * 087 Oromo
+ * 088 Somali
+ * 089 Swahili
+ */
+  "vie", "ind", "tgl", "msa", "msa", "amh", "orm", "orm", "som", "swa",
+
+/* 090 Ruanda
+ * 091 Rundi
+ * 092 Chewa
+ * 093 Malagasy
+ * 094 Esperanto
+ * 095 ---
+ * 096 ---
+ * 097 ---
+ * 098 ---
+ * 099 ---
+ */
+  "kin", "run", "nya", "mlg", "ep", "und", "und", "und", "und", "und",
+
+/* 100-109 ---
+ * 110-119 ---
+ */
+  "und", "und", "und", "und", "und", "und", "und", "und", "und", "und",
+  "und", "und", "und", "und", "und", "und", "und", "und", "und", "und",
+
+/* 120-127 ---
+ * 128 Welsh
+ * 129 Basque
+ */
+  "und", "und", "und", "und", "und", "und", "und", "und", "cym", "eus",
+
+/* 130 Catalan
+ * 131 Latin
+ * 132 Quechua
+ * 133 Guarani
+ * 134 Aymara
+ * 135 Tatar
+ * 136 Uighur
+ * 137 Dzongkha
+ * 138 JavaneseRom
+ */
+  "cat", "lat", "que", "grn", "aym", "tat", "uig", "dzo", "jav"
+};
+
+/* map quicktime language code to ISO-639-2T id, returns "und" if unknown */
+void
+qtdemux_lang_map_qt_code_to_iso (gchar id[4], guint16 qt_lang_code)
+{
+  const gchar *iso_code;
+
+  g_assert (qt_lang_code < 0x800);
+
+  if (qt_lang_code < G_N_ELEMENTS (qt_lang_map))
+    iso_code = qt_lang_map[qt_lang_code];
+  else
+    iso_code = "und";
+
+  GST_DEBUG ("mapped quicktime language code %u to ISO 639-2T code '%s'",
+      qt_lang_code, iso_code);
+
+  memcpy (id, iso_code, 4);
+
+  g_assert (id[3] == '\0');
+}
diff --git a/gst/isomp4/qtdemux_lang.h b/gst/isomp4/qtdemux_lang.h
new file mode 100644
index 000000000..a5fdec0fd
--- /dev/null
+++ b/gst/isomp4/qtdemux_lang.h
@@ -0,0 +1,31 @@
+/* GStreamer Quicktime/ISO demuxer language utility functions
+ * Copyright (C) 2010 Tim-Philipp Müller <tim centricular net>
+ *
+ * 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_QTDEMUX_LANG_H__
+#define __GST_QTDEMUX_LANG_H__
+
+G_BEGIN_DECLS
+
+#include <glib.h>
+
+void qtdemux_lang_map_qt_code_to_iso (gchar id[4], guint16 qt_lang_code);
+
+G_END_DECLS
+
+#endif /* __GST_QTDEMUX_LANG_H__ */
diff --git a/gst/isomp4/qtdemux_types.c b/gst/isomp4/qtdemux_types.c
new file mode 100644
index 000000000..38da35b3d
--- /dev/null
+++ b/gst/isomp4/qtdemux_types.c
@@ -0,0 +1,194 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "qtdemux_types.h"
+#include "qtdemux_dump.h"
+#include "qtdemux_fourcc.h"
+
+static const QtNodeType qt_node_types[] = {
+  {FOURCC_moov, "movie", QT_FLAG_CONTAINER,},
+  {FOURCC_mvhd, "movie header", 0,
+      qtdemux_dump_mvhd},
+  {FOURCC_clip, "clipping", QT_FLAG_CONTAINER,},
+  {FOURCC_trak, "track", QT_FLAG_CONTAINER,},
+  {FOURCC_udta, "user data", QT_FLAG_CONTAINER,},       /* special container */
+  {FOURCC_ctab, "color table", 0,},
+  {FOURCC_tkhd, "track header", 0,
+      qtdemux_dump_tkhd},
+  {FOURCC_crgn, "clipping region", 0,},
+  {FOURCC_matt, "track matte", QT_FLAG_CONTAINER,},
+  {FOURCC_kmat, "compressed matte", 0,},
+  {FOURCC_edts, "edit", QT_FLAG_CONTAINER,},
+  {FOURCC_elst, "edit list", 0,
+      qtdemux_dump_elst},
+  {FOURCC_load, "track load settings", 0,},
+  {FOURCC_tref, "track reference", QT_FLAG_CONTAINER,},
+  {FOURCC_imap, "track input map", QT_FLAG_CONTAINER,},
+  {FOURCC___in, "track input", 0,},     /* special container */
+  {FOURCC___ty, "input type", 0,},
+  {FOURCC_mdia, "media", QT_FLAG_CONTAINER},
+  {FOURCC_mdhd, "media header", 0,
+      qtdemux_dump_mdhd},
+  {FOURCC_hdlr, "handler reference", 0,
+      qtdemux_dump_hdlr},
+  {FOURCC_minf, "media information", QT_FLAG_CONTAINER},
+  {FOURCC_vmhd, "video media information", 0,
+      qtdemux_dump_vmhd},
+  {FOURCC_smhd, "sound media information", 0},
+  {FOURCC_gmhd, "base media information header", 0},
+  {FOURCC_gmin, "base media info", 0},
+  {FOURCC_dinf, "data information", QT_FLAG_CONTAINER},
+  {FOURCC_dref, "data reference", 0,
+      qtdemux_dump_dref},
+  {FOURCC_stbl, "sample table", QT_FLAG_CONTAINER},
+  {FOURCC_stsd, "sample description", 0,
+      qtdemux_dump_stsd},
+  {FOURCC_stts, "time-to-sample", 0,
+      qtdemux_dump_stts},
+  {FOURCC_stps, "partial sync sample", 0,
+      qtdemux_dump_stps},
+  {FOURCC_stss, "sync sample", 0,
+      qtdemux_dump_stss},
+  {FOURCC_stsc, "sample-to-chunk", 0,
+      qtdemux_dump_stsc},
+  {FOURCC_stsz, "sample size", 0,
+      qtdemux_dump_stsz},
+  {FOURCC_stco, "chunk offset", 0,
+      qtdemux_dump_stco},
+  {FOURCC_co64, "64-bit chunk offset", 0,
+      qtdemux_dump_co64},
+  {FOURCC_vide, "video media", 0},
+  {FOURCC_cmov, "compressed movie", QT_FLAG_CONTAINER},
+  {FOURCC_dcom, "compressed data", 0, qtdemux_dump_dcom},
+  {FOURCC_cmvd, "compressed movie data", 0, qtdemux_dump_cmvd},
+  {FOURCC_hint, "hint", 0,},
+  {FOURCC_mp4a, "mp4a", 0,},
+  {FOURCC_mp4v, "mp4v", 0,},
+  {FOURCC_mjp2, "mjp2", 0,},
+  {FOURCC_mhdr, "mhdr", QT_FLAG_CONTAINER,},
+  {FOURCC_jp2h, "jp2h", QT_FLAG_CONTAINER,},
+  {FOURCC_colr, "colr", 0,},
+  {FOURCC_fiel, "fiel", 0,},
+  {FOURCC_jp2x, "jp2x", 0,},
+  {FOURCC_alac, "alac", 0,},
+  {FOURCC_wave, "wave", QT_FLAG_CONTAINER},
+  {FOURCC_appl, "appl", QT_FLAG_CONTAINER},
+  {FOURCC_esds, "esds", 0},
+  {FOURCC_hnti, "hnti", QT_FLAG_CONTAINER},
+  {FOURCC_rtp_, "rtp ", 0, qtdemux_dump_unknown},
+  {FOURCC_sdp_, "sdp ", 0, qtdemux_dump_unknown},
+  {FOURCC_meta, "meta", 0, qtdemux_dump_unknown},
+  {FOURCC_ilst, "ilst", QT_FLAG_CONTAINER,},
+  {FOURCC__nam, "Name", QT_FLAG_CONTAINER,},
+  {FOURCC_titl, "Title", QT_FLAG_CONTAINER,},
+  {FOURCC__ART, "Artist", QT_FLAG_CONTAINER,},
+  {FOURCC_aART, "Album Artist", QT_FLAG_CONTAINER,},
+  {FOURCC_auth, "Author", QT_FLAG_CONTAINER,},
+  {FOURCC_perf, "Performer", QT_FLAG_CONTAINER,},
+  {FOURCC__wrt, "Writer", QT_FLAG_CONTAINER,},
+  {FOURCC__grp, "Grouping", QT_FLAG_CONTAINER,},
+  {FOURCC__alb, "Album", QT_FLAG_CONTAINER,},
+  {FOURCC_albm, "Album", QT_FLAG_CONTAINER,},
+  {FOURCC__day, "Date", QT_FLAG_CONTAINER,},
+  {FOURCC__cpy, "Copyright", QT_FLAG_CONTAINER,},
+  {FOURCC__cmt, "Comment", QT_FLAG_CONTAINER,},
+  {FOURCC__des, "Description", QT_FLAG_CONTAINER,},
+  {FOURCC_desc, "Description", QT_FLAG_CONTAINER,},
+  {FOURCC_dscp, "Description", QT_FLAG_CONTAINER,},
+  {FOURCC__lyr, "Lyrics", QT_FLAG_CONTAINER,},
+  {FOURCC__req, "Requirement", QT_FLAG_CONTAINER,},
+  {FOURCC__enc, "Encoder", QT_FLAG_CONTAINER,},
+  {FOURCC_gnre, "Genre", QT_FLAG_CONTAINER,},
+  {FOURCC_trkn, "Track Number", QT_FLAG_CONTAINER,},
+  {FOURCC_disc, "Disc Number", QT_FLAG_CONTAINER,},
+  {FOURCC_disk, "Disc Number", QT_FLAG_CONTAINER,},
+  {FOURCC_cprt, "Copyright", QT_FLAG_CONTAINER,},
+  {FOURCC_cpil, "Compilation", QT_FLAG_CONTAINER,},
+  {FOURCC_pgap, "Gapless", QT_FLAG_CONTAINER,},
+  {FOURCC_pcst, "Podcast", QT_FLAG_CONTAINER,},
+  {FOURCC_tmpo, "Tempo", QT_FLAG_CONTAINER,},
+  {FOURCC_covr, "Cover", QT_FLAG_CONTAINER,},
+  {FOURCC_sonm, "Sort Title", QT_FLAG_CONTAINER,},
+  {FOURCC_soal, "Sort Album", QT_FLAG_CONTAINER,},
+  {FOURCC_soar, "Sort Artist", QT_FLAG_CONTAINER,},
+  {FOURCC_soaa, "Sort Album Artist", QT_FLAG_CONTAINER,},
+  {FOURCC_soco, "Sort Composer", QT_FLAG_CONTAINER,},
+  {FOURCC_sosn, "Sort TV Show", QT_FLAG_CONTAINER,},
+  {FOURCC_tvsh, "TV Show", QT_FLAG_CONTAINER,},
+  {FOURCC_tven, "TV Episode ID", QT_FLAG_CONTAINER,},
+  {FOURCC_tvsn, "TV Season Number", QT_FLAG_CONTAINER,},
+  {FOURCC_tves, "TV Episode Number", QT_FLAG_CONTAINER,},
+  {FOURCC_keyw, "Keywords", QT_FLAG_CONTAINER,},
+  {FOURCC_kywd, "Keywords", QT_FLAG_CONTAINER,},
+  {FOURCC__too, "Encoder", QT_FLAG_CONTAINER,},
+  {FOURCC_____, "----", QT_FLAG_CONTAINER,},
+  {FOURCC_data, "data", 0, qtdemux_dump_unknown},
+  {FOURCC_free, "free", 0,},
+  {FOURCC_SVQ3, "SVQ3", 0,},
+  {FOURCC_rmra, "rmra", QT_FLAG_CONTAINER,},
+  {FOURCC_rmda, "rmda", QT_FLAG_CONTAINER,},
+  {FOURCC_rdrf, "rdrf", 0,},
+  {FOURCC__gen, "Custom Genre", QT_FLAG_CONTAINER,},
+  {FOURCC_ctts, "Composition time to sample", 0, qtdemux_dump_ctts},
+  {FOURCC_XiTh, "XiTh", 0},
+  {FOURCC_XdxT, "XdxT", 0},
+  {FOURCC_loci, "loci", 0},
+  {FOURCC_clsf, "clsf", 0},
+  {FOURCC_mfra, "movie fragment random access",
+      QT_FLAG_CONTAINER,},
+  {FOURCC_tfra, "track fragment random access", 0,
+      qtdemux_dump_tfra},
+  {FOURCC_mfro, "movie fragment random access offset", 0,
+      qtdemux_dump_mfro},
+  {FOURCC_moof, "movie fragment", QT_FLAG_CONTAINER,},
+  {FOURCC_mfhd, "movie fragment header", 0,},
+  {FOURCC_traf, "track fragment", QT_FLAG_CONTAINER,},
+  {FOURCC_tfhd, "track fragment header", 0,
+      qtdemux_dump_tfhd},
+  {FOURCC_sdtp, "independent and disposable samples", 0,
+      qtdemux_dump_sdtp},
+  {FOURCC_trun, "track fragment run", 0, qtdemux_dump_trun},
+  {FOURCC_mdat, "moovie data", 0, qtdemux_dump_unknown},
+  {FOURCC_trex, "moovie data", 0, qtdemux_dump_trex},
+  {FOURCC_mvex, "mvex", QT_FLAG_CONTAINER,},
+  {FOURCC_mehd, "movie extends header", 0,
+      qtdemux_dump_mehd},
+  {FOURCC_ovc1, "ovc1", 0},
+  {FOURCC_owma, "owma", 0},
+  {0, "unknown", 0,},
+};
+
+static const int n_qt_node_types =
+    sizeof (qt_node_types) / sizeof (qt_node_types[0]);
+
+const QtNodeType *
+qtdemux_type_get (guint32 fourcc)
+{
+  int i;
+
+  for (i = 0; i < n_qt_node_types; i++) {
+    if (G_UNLIKELY (qt_node_types[i].fourcc == fourcc))
+      return qt_node_types + i;
+  }
+
+  GST_WARNING ("unknown QuickTime node type %" GST_FOURCC_FORMAT,
+      GST_FOURCC_ARGS (fourcc));
+
+  return qt_node_types + n_qt_node_types - 1;
+}
diff --git a/gst/isomp4/qtdemux_types.h b/gst/isomp4/qtdemux_types.h
new file mode 100644
index 000000000..a22efb8bf
--- /dev/null
+++ b/gst/isomp4/qtdemux_types.h
@@ -0,0 +1,82 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2009> STEricsson <benjamin.gaignard@stericsson.com>
+ *
+ * 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_QTDEMUX_TYPES_H__
+#define __GST_QTDEMUX_TYPES_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstbytereader.h>
+
+#include "qtdemux.h"
+
+G_BEGIN_DECLS
+
+typedef gboolean (*QtDumpFunc) (GstQTDemux * qtdemux, GstByteReader * data,
+    int depth);
+
+typedef struct _QtNodeType QtNodeType;
+
+#define QT_UINT32(a)  (GST_READ_UINT32_BE(a))
+#define QT_UINT24(a)  (GST_READ_UINT32_BE(a) >> 8)
+#define QT_UINT16(a)  (GST_READ_UINT16_BE(a))
+#define QT_UINT8(a)   (GST_READ_UINT8(a))
+#define QT_FP32(a)    ((GST_READ_UINT32_BE(a))/65536.0)
+#define QT_SFP32(a)   (((gint)(GST_READ_UINT32_BE(a)))/65536.0)
+#define QT_FP16(a)    ((GST_READ_UINT16_BE(a))/256.0)
+#define QT_FOURCC(a)  (GST_READ_UINT32_LE(a))
+#define QT_UINT64(a)  ((((guint64)QT_UINT32(a))<<32)|QT_UINT32(((guint8 *)a)+4))
+
+typedef enum {
+  QT_FLAG_NONE      = (0),
+  QT_FLAG_CONTAINER = (1 << 0)
+} QtFlags;
+
+struct _QtNodeType {
+  guint32      fourcc;
+  const gchar *name;
+  QtFlags      flags;
+  QtDumpFunc   dump;
+};
+
+enum TfFlags
+{
+  TF_BASE_DATA_OFFSET         = 0x000001,   /* base-data-offset-present */
+  TF_SAMPLE_DESCRIPTION_INDEX = 0x000002,   /* sample-description-index-present */
+  TF_DEFAULT_SAMPLE_DURATION  = 0x000008,   /* default-sample-duration-present */
+  TF_DEFAULT_SAMPLE_SIZE      = 0x000010,   /* default-sample-size-present */
+  TF_DEFAULT_SAMPLE_FLAGS     = 0x000020,   /* default-sample-flags-present */
+  TF_DURATION_IS_EMPTY        = 0x100000    /* duration-is-empty */
+};
+
+enum TrFlags
+{
+  TR_DATA_OFFSET              = 0x000001,   /* data-offset-present */
+  TR_FIRST_SAMPLE_FLAGS       = 0x000004,   /* first-sample-flags-present */
+  TR_SAMPLE_DURATION          = 0x000100,   /* sample-duration-present */
+  TR_SAMPLE_SIZE              = 0x000200,   /* sample-size-present */
+  TR_SAMPLE_FLAGS             = 0x000400,   /* sample-flags-present */
+  TR_COMPOSITION_TIME_OFFSETS = 0x000800    /* sample-composition-time-offsets-presents */
+};
+
+const QtNodeType *qtdemux_type_get (guint32 fourcc);
+
+G_END_DECLS
+
+#endif /* __GST_QTDEMUX_TYPES_H__ */
diff --git a/gst/isomp4/qtpalette.h b/gst/isomp4/qtpalette.h
new file mode 100644
index 000000000..80ece2aea
--- /dev/null
+++ b/gst/isomp4/qtpalette.h
@@ -0,0 +1,137 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_QTPALLETE_H__
+#define __GST_QTPALLETE_H__
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+static const guint32 ff_qt_default_palette_2[2] = {
+  0xffffff, 0x000000
+};
+
+static const guint32 ff_qt_default_palette_4[4] = {
+  0x93655e, 0xffffff, 0xdfd0ab, 0x000000
+};
+
+static const guint32 ff_qt_default_palette_16[16] = {
+  0xfffbff, 0xefd9bb, 0xe8c9b1, 0x93655e,
+  0xfcdee8, 0x9d8891, 0xffffff, 0xffffff,
+  0xffffff, 0x474837, 0x7a5e55, 0xdfd0ab,
+  0xfffbf9, 0xe8cac5, 0x8a7c77, 0x000000
+};
+static const guint32 ff_qt_default_palette_256[256] = {
+  0xFFFFFF, 0xFFFFCC, 0xFFFF99, 0xFFFF66, 0xFFFF33, 0xFFFF00,
+  0xFFCCFF, 0xFFCCCC, 0xFFCC99, 0xFFCC66, 0xFFCC33, 0xFFCC00,
+  0xFF99FF, 0xFF99CC, 0xFF9999, 0xFF9966, 0xFF9933, 0xFF9900,
+  0xFF66FF, 0xFF66CC, 0xFF6699, 0xFF6666, 0xFF6633, 0xFF6600,
+  0xFF33FF, 0xFF33CC, 0xFF3399, 0xFF3366, 0xFF3333, 0xFF3300,
+  0xFF00FF, 0xFF00CC, 0xFF0099, 0xFF0066, 0xFF0033, 0xFF0000,
+  0xCCFFFF, 0xCCFFCC, 0xCCFF99, 0xCCFF66, 0xCCFF33, 0xCCFF00,
+  0xCCCCFF, 0xCCCCCC, 0xCCCC99, 0xCCCC66, 0xCCCC33, 0xCCCC00,
+  0xCC99FF, 0xCC99CC, 0xCC9999, 0xCC9966, 0xCC9933, 0xCC9900,
+  0xCC66FF, 0xCC66CC, 0xCC6699, 0xCC6666, 0xCC6633, 0xCC6600,
+  0xCC33FF, 0xCC33CC, 0xCC3399, 0xCC3366, 0xCC3333, 0xCC3300,
+  0xCC00FF, 0xCC00CC, 0xCC0099, 0xCC0066, 0xCC0033, 0xCC0000,
+  0x99FFFF, 0x99FFCC, 0x99FF99, 0x99FF66, 0x99FF33, 0x99FF00,
+  0x99CCFF, 0x99CCCC, 0x99CC99, 0x99CC66, 0x99CC33, 0x99CC00,
+  0x9999FF, 0x9999CC, 0x999999, 0x999966, 0x999933, 0x999900,
+  0x9966FF, 0x9966CC, 0x996699, 0x996666, 0x996633, 0x996600,
+  0x9933FF, 0x9933CC, 0x993399, 0x993366, 0x993333, 0x993300,
+  0x9900FF, 0x9900CC, 0x990099, 0x990066, 0x990033, 0x990000,
+  0x66FFFF, 0x66FFCC, 0x66FF99, 0x66FF66, 0x66FF33, 0x66FF00,
+  0x66CCFF, 0x66CCCC, 0x66CC99, 0x66CC66, 0x66CC33, 0x66CC00,
+  0x6699FF, 0x6699CC, 0x669999, 0x669966, 0x669933, 0x669900,
+  0x6666FF, 0x6666CC, 0x666699, 0x666666, 0x666633, 0x666600,
+  0x6633FF, 0x6633CC, 0x663399, 0x663366, 0x663333, 0x663300,
+  0x6600FF, 0x6600CC, 0x660099, 0x660066, 0x660033, 0x660000,
+  0x33FFFF, 0x33FFCC, 0x33FF99, 0x33FF66, 0x33FF33, 0x33FF00,
+  0x33CCFF, 0x33CCCC, 0x33CC99, 0x33CC66, 0x33CC33, 0x33CC00,
+  0x3399FF, 0x3399CC, 0x339999, 0x339966, 0x339933, 0x339900,
+  0x3366FF, 0x3366CC, 0x336699, 0x336666, 0x336633, 0x336600,
+  0x3333FF, 0x3333CC, 0x333399, 0x333366, 0x333333, 0x333300,
+  0x3300FF, 0x3300CC, 0x330099, 0x330066, 0x330033, 0x330000,
+  0x00FFFF, 0x00FFCC, 0x00FF99, 0x00FF66, 0x00FF33, 0x00FF00,
+  0x00CCFF, 0x00CCCC, 0x00CC99, 0x00CC66, 0x00CC33, 0x00CC00,
+  0x0099FF, 0x0099CC, 0x009999, 0x009966, 0x009933, 0x009900,
+  0x0066FF, 0x0066CC, 0x006699, 0x006666, 0x006633, 0x006600,
+  0x0033FF, 0x0033CC, 0x003399, 0x003366, 0x003333, 0x003300,
+  0x0000FF, 0x0000CC, 0x000099, 0x000066, 0x000033, 0xEE0000,
+  0xDD0000, 0xBB0000, 0xAA0000, 0x880000, 0x770000, 0x550000,
+  0x440000, 0x220000, 0x110000, 0x00EE00, 0x00DD00, 0x00BB00,
+  0x00AA00, 0x008800, 0x007700, 0x005500, 0x004400, 0x002200,
+  0x001100, 0x0000EE, 0x0000DD, 0x0000BB, 0x0000AA, 0x000088,
+  0x000077, 0x000055, 0x000044, 0x000022, 0x000011, 0xEEEEEE,
+  0xDDDDDD, 0xBBBBBB, 0xAAAAAA, 0x888888, 0x777777, 0x555555,
+  0x444444, 0x222222, 0x111111, 0x000000
+};
+
+static const guint32 ff_qt_grayscale_palette_16[16] = {
+  0xffffff, 0xeeeeee, 0xdddddd, 0xcccccc,
+  0xbbbbbb, 0xaaaaaa, 0x999999, 0x888888,
+  0x777777, 0x666666, 0x555555, 0x444444,
+  0x333333, 0x222222, 0x111111, 0x000000
+};
+
+static const guint32 ff_qt_grayscale_palette_256[256] = {
+  0xffffff, 0xfefefe, 0xfdfdfd, 0xfcfcfc, 0xfbfbfb, 0xfafafa, 0xf9f9f9,
+  0xf8f8f8, 0xf7f7f7, 0xf6f6f6, 0xf5f5f5, 0xf4f4f4, 0xf3f3f3, 0xf2f2f2,
+  0xf1f1f1, 0xf0f0f0, 0xefefef, 0xeeeeee, 0xededed, 0xececec, 0xebebeb,
+  0xeaeaea, 0xe9e9e9, 0xe8e8e8, 0xe7e7e7, 0xe6e6e6, 0xe5e5e5, 0xe4e4e4,
+  0xe3e3e3, 0xe2e2e2, 0xe1e1e1, 0xe0e0e0, 0xdfdfdf, 0xdedede, 0xdddddd,
+  0xdcdcdc, 0xdbdbdb, 0xdadada, 0xd9d9d9, 0xd8d8d8, 0xd7d7d7, 0xd6d6d6,
+  0xd5d5d5, 0xd4d4d4, 0xd3d3d3, 0xd2d2d2, 0xd1d1d1, 0xd0d0d0, 0xcfcfcf,
+  0xcecece, 0xcdcdcd, 0xcccccc, 0xcbcbcb, 0xcacaca, 0xc9c9c9, 0xc8c8c8,
+  0xc7c7c7, 0xc6c6c6, 0xc5c5c5, 0xc4c4c4, 0xc3c3c3, 0xc2c2c2, 0xc1c1c1,
+  0xc0c0c0, 0xbfbfbf, 0xbebebe, 0xbdbdbd, 0xbcbcbc, 0xbbbbbb, 0xbababa,
+  0xb9b9b9, 0xb8b8b8, 0xb7b7b7, 0xb6b6b6, 0xb5b5b5, 0xb4b4b4, 0xb3b3b3,
+  0xb2b2b2, 0xb1b1b1, 0xb0b0b0, 0xafafaf, 0xaeaeae, 0xadadad, 0xacacac,
+  0xababab, 0xaaaaaa, 0xa9a9a9, 0xa8a8a8, 0xa7a7a7, 0xa6a6a6, 0xa5a5a5,
+  0xa4a4a4, 0xa3a3a3, 0xa2a2a2, 0xa1a1a1, 0xa0a0a0, 0x9f9f9f, 0x9e9e9e,
+  0x9d9d9d, 0x9c9c9c, 0x9b9b9b, 0x9a9a9a, 0x999999, 0x989898, 0x979797,
+  0x969696, 0x959595, 0x949494, 0x939393, 0x929292, 0x919191, 0x909090,
+  0x8f8f8f, 0x8e8e8e, 0x8d8d8d, 0x8c8c8c, 0x8b8b8b, 0x8a8a8a, 0x898989,
+  0x888888, 0x878787, 0x868686, 0x858585, 0x848484, 0x838383, 0x828282,
+  0x818181, 0x808080, 0x7f7f7f, 0x7e7e7e, 0x7d7d7d, 0x7c7c7c, 0x7b7b7b,
+  0x7a7a7a, 0x797979, 0x787878, 0x777777, 0x767676, 0x757575, 0x747474,
+  0x737373, 0x727272, 0x717171, 0x707070, 0x6f6f6f, 0x6e6e6e, 0x6d6d6d,
+  0x6c6c6c, 0x6b6b6b, 0x6a6a6a, 0x696969, 0x686868, 0x676767, 0x666666,
+  0x656565, 0x646464, 0x636363, 0x626262, 0x616161, 0x606060, 0x5f5f5f,
+  0x5e5e5e, 0x5d5d5d, 0x5c5c5c, 0x5b5b5b, 0x5a5a5a, 0x595959, 0x585858,
+  0x575757, 0x565656, 0x555555, 0x545454, 0x535353, 0x525252, 0x515151,
+  0x505050, 0x4f4f4f, 0x4e4e4e, 0x4d4d4d, 0x4c4c4c, 0x4b4b4b, 0x4a4a4a,
+  0x494949, 0x484848, 0x474747, 0x464646, 0x454545, 0x444444, 0x434343,
+  0x424242, 0x414141, 0x404040, 0x3f3f3f, 0x3e3e3e, 0x3d3d3d, 0x3c3c3c,
+  0x3b3b3b, 0x3a3a3a, 0x393939, 0x383838, 0x373737, 0x363636, 0x353535,
+  0x343434, 0x333333, 0x323232, 0x313131, 0x303030, 0x2f2f2f, 0x2e2e2e,
+  0x2d2d2d, 0x2c2c2c, 0x2b2b2b, 0x2a2a2a, 0x292929, 0x282828, 0x272727,
+  0x262626, 0x252525, 0x242424, 0x232323, 0x222222, 0x212121, 0x202020,
+  0x1f1f1f, 0x1e1e1e, 0x1d1d1d, 0x1c1c1c, 0x1b1b1b, 0x1a1a1a, 0x191919,
+  0x181818, 0x171717, 0x161616, 0x151515, 0x141414, 0x131313, 0x121212,
+  0x111111, 0x101010, 0x0f0f0f, 0x0e0e0e, 0x0d0d0d, 0x0c0c0c, 0x0b0b0b,
+  0x0a0a0a, 0x090909, 0x080808, 0x070707, 0x060606, 0x050505, 0x040404,
+  0x030303, 0x020202, 0x010101, 0x000000
+};
+
+G_END_DECLS
+
+#endif /* __GST_QTPALETTE_H__ */