Complete rewrite. Not finished, nothing to see here.

Original commit message from CVS:
Complete rewrite.  Not finished, nothing to see here.

2 files changed, 1249 insertions, 570 deletions

diff --git a/gst/qtdemux/qtdemux.c b/gst/qtdemux/qtdemux.c
index 4512f757e..516da94e8 100644
--- a/gst/qtdemux/qtdemux.c
+++ b/gst/qtdemux/qtdemux.c
@@ -1,5 +1,6 @@
 /* GStreamer
  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -17,27 +18,70 @@
  * Boston, MA 02111-1307, USA.
  */
 
+#include "qtdemux.h"
 
-#include <stdlib.h>
 #include <string.h>
-#include "qtdemux.h"
 
-/* elementfactory information */
+typedef struct _QtNode QtNode;
+typedef struct _QtNodeType QtNodeType;
+typedef struct _QtDemuxSample QtDemuxSample;
+//typedef struct _QtDemuxStream QtDemuxStream;
+
+struct _QtNode {
+  guint32 type;
+  gpointer data;
+  int len;
+};
+
+struct _QtNodeType {
+  guint32 fourcc;
+  char *name;
+  int flags;
+  void (*dump)(GstQTDemux *qtdemux, void *buffer, int depth);
+};
+
+struct _QtDemuxSample {
+  int sample_index;
+  int chunk;
+  int size;
+  guint32 offset;
+  guint64 timestamp;
+};
+
+struct _QtDemuxStream {
+  guint32 subtype;
+  GstCaps *caps;
+  GstPad *pad;
+  int n_samples;
+  QtDemuxSample *samples;
+  int timescale;
+
+  int sample_index;
+};
+
+enum QtDemuxState {
+  QTDEMUX_STATE_NULL,
+  QTDEMUX_STATE_HEADER,
+  QTDEMUX_STATE_SEEKING,
+  QTDEMUX_STATE_MOVIE,
+  QTDEMUX_STATE_SEEKING_EOS,
+  QTDEMUX_STATE_EOS,
+};
+
 static GstElementDetails 
 gst_qtdemux_details = 
 {
-  "quicktime parser",
-  "Codec/Parser",
+  "QuickTime Demuxer",
+  "Codec/Demuxer",
   "LGPL",
-  "Parses a quicktime stream into audio and video substreams",
+  "Demultiplex a QuickTime file into audio and video streams",
   VERSION,
-  "A.Baguinski <artm@v2.nl>",
-  "(C) 2002",
+  "David Schleef <ds@schleef.org>",
+  "(C) 2003",
 };
 
 static GstCaps* quicktime_type_find (GstBuffer *buf, gpointer private);
 
-/* typefactory for 'quicktime' */
 static GstTypeDefinition quicktimedefinition = {
   "qtdemux_video/quicktime",
   "video/quicktime",
@@ -64,78 +108,37 @@ GST_PAD_TEMPLATE_FACTORY (sink_templ,
   )
 )
 
-/* 
- * so far i only support Photo Jpeg videos and no audio. 
- * after this one works ok, i'll see what's next.
- */
 GST_PAD_TEMPLATE_FACTORY (src_video_templ,
   "video_%02d",
   GST_PAD_SRC,
   GST_PAD_SOMETIMES,
-  GST_CAPS_NEW (
-    "qtdemux_src_video",
-    "video/jpeg",
-      "width", GST_PROPS_INT_RANGE (16, 4096),
-      "height", GST_PROPS_INT_RANGE (16, 4096)
-  )
+  NULL
 )
 
-static GstElementClass *parent_class = NULL;
-/* 
- * contains correspondence between atom types and
- * GstQtpAtomType structures 
- */
-static GHashTable * gst_qtp_type_registry; 
-
-typedef struct {
-  guint32 type;
-  GstQtpAtomType atype;
-} GstQtpTypePair;
-
-static void gst_qtp_trak_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_tkhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_hdlr_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_stsd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_stts_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_stsc_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_stsz_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_stco_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_mdhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-static void gst_qtp_mdat_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-
-GstQtpTypePair gst_qtp_type_table[] = {
-  { GST_MAKE_FOURCC('m','o','o','v'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('t','r','a','k'), {GST_QTP_CONTAINER_ATOM,gst_qtp_trak_handler} },
-  { GST_MAKE_FOURCC('e','d','t','s'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('m','d','i','a'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('m','i','n','f'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('d','i','n','f'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('s','t','b','l'), {GST_QTP_CONTAINER_ATOM,NULL} },
-  { GST_MAKE_FOURCC('m','d','a','t'), {0,gst_qtp_mdat_handler} },
-  { GST_MAKE_FOURCC('m','v','h','d'), {0,NULL} },
-  { GST_MAKE_FOURCC('t','k','h','d'), {0,gst_qtp_tkhd_handler} },
-  { GST_MAKE_FOURCC('e','l','s','t'), {0,NULL} },
-  { GST_MAKE_FOURCC('m','d','h','d'), {0,gst_qtp_mdhd_handler} },
-  { GST_MAKE_FOURCC('h','d','l','r'), {0,gst_qtp_hdlr_handler} },
-  { GST_MAKE_FOURCC('v','m','h','d'), {0,NULL} },
-  { GST_MAKE_FOURCC('d','r','e','f'), {0,NULL} },
-  { GST_MAKE_FOURCC('s','t','t','s'), {0,gst_qtp_stts_handler} },
-  { GST_MAKE_FOURCC('s','t','s','d'), {0,gst_qtp_stsd_handler} },
-  { GST_MAKE_FOURCC('s','t','s','z'), {0,gst_qtp_stsz_handler} },
-  { GST_MAKE_FOURCC('s','t','s','c'), {0,gst_qtp_stsc_handler} },
-  { GST_MAKE_FOURCC('s','t','c','o'), {0,gst_qtp_stco_handler} }
-};
+GST_PAD_TEMPLATE_FACTORY (src_audio_templ,
+  "audio_%02d",
+  GST_PAD_SRC,
+  GST_PAD_SOMETIMES,
+  NULL
+)
 
-#define GST_QTP_TYPE_CNT sizeof(gst_qtp_type_table)/sizeof(GstQtpTypePair)
+static GstElementClass *parent_class = NULL;
 
 static void gst_qtdemux_class_init (GstQTDemuxClass *klass);
 static void gst_qtdemux_init (GstQTDemux *quicktime_demux);
-static void gst_qtdemux_loop (GstElement *element);
-static GstElementStateReturn gst_qtdemux_change_state (GstElement * element);
-static gint gst_guint32_compare(gconstpointer _a, gconstpointer _b);
-
-static GType
-gst_qtdemux_get_type (void) 
+static GstElementStateReturn gst_qtdemux_change_state(GstElement *element);
+static void gst_qtdemux_loop_header (GstElement *element);
+static gboolean gst_qtdemux_handle_sink_event (GstQTDemux *qtdemux);
+
+static void qtdemux_parse_moov(GstQTDemux *qtdemux, void *buffer, int length);
+static void qtdemux_parse(GstQTDemux *qtdemux, GNode *node, void *buffer, int length);
+static QtNodeType *qtdemux_type_get(guint32 fourcc);
+static void qtdemux_node_dump(GstQTDemux *qtdemux, GNode *node);
+static void qtdemux_parse_tree(GstQTDemux *qtdemux);
+static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc);
+static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc);
+
+static GType gst_qtdemux_get_type (void) 
 {
   static GType qtdemux_type = 0;
 
@@ -151,12 +154,10 @@ gst_qtdemux_get_type (void)
   return qtdemux_type;
 }
 
-static void
-gst_qtdemux_class_init (GstQTDemuxClass *klass) 
+static void gst_qtdemux_class_init (GstQTDemuxClass *klass) 
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
-  int i;
 
   gobject_class = (GObjectClass*)klass;
   gstelement_class = (GstElementClass*)klass;
@@ -164,50 +165,14 @@ gst_qtdemux_class_init (GstQTDemuxClass *klass)
   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 
   gstelement_class->change_state = gst_qtdemux_change_state;
-
-  gst_qtp_type_registry = g_hash_table_new(g_int_hash,g_int_equal);
-  for(i=0;i<GST_QTP_TYPE_CNT;i++) {
-    g_hash_table_insert(gst_qtp_type_registry,&(gst_qtp_type_table[i].type),&(gst_qtp_type_table[i].atype));
-  }
-}
-
-static GstElementStateReturn
-gst_qtdemux_change_state (GstElement * element)
-{
-  GstQTDemux * qtdemux = GST_QTDEMUX (element);
-
-  switch (GST_STATE_TRANSITION (element)) {
-    case GST_STATE_READY_TO_PAUSED:
-      qtdemux->bs = gst_bytestream_new (qtdemux->sinkpad);
-      break;
-    case GST_STATE_PAUSED_TO_READY:
-      gst_bytestream_destroy (qtdemux->bs);
-      break;
-    default:
-      break;
-  }
-  parent_class->change_state (element);
-  return GST_STATE_SUCCESS;
 }
 
 static void 
 gst_qtdemux_init (GstQTDemux *qtdemux) 
 {
-  guint i;
-		
   qtdemux->sinkpad = gst_pad_new_from_template (GST_PAD_TEMPLATE_GET (sink_templ), "sink");
-  gst_element_set_loop_function (GST_ELEMENT (qtdemux), gst_qtdemux_loop);
+  gst_element_set_loop_function (GST_ELEMENT (qtdemux), gst_qtdemux_loop_header);
   gst_element_add_pad (GST_ELEMENT (qtdemux), qtdemux->sinkpad);
-
-  for (i=0; i<GST_QTDEMUX_MAX_VIDEO_PADS; i++) 
-	  qtdemux->video_pad[i] = NULL;
-  qtdemux->num_video_pads = 0;
-
-  qtdemux->bs_pos = 0;
-  qtdemux->nested = NULL;
-  qtdemux->nested_cnt = 0;
-  qtdemux->tracks = NULL;
-  qtdemux->samples = NULL;
 }
 
 static GstCaps*
@@ -215,14 +180,15 @@ quicktime_type_find (GstBuffer *buf, gpointer private)
 {
   gchar *data = GST_BUFFER_DATA (buf);
 
-  /* we could get a NULL buffer, for example when the input could not be
-   * mmap'd */
   g_return_val_if_fail (data != NULL, NULL);
   
-  /* exactly like in the old version */
-  if (!strncmp (&data[4], "wide", 4) ||
-      !strncmp (&data[4], "moov", 4) ||
-      !strncmp (&data[4], "mdat", 4))  {
+  if(GST_BUFFER_SIZE(buf) < 8){
+    return NULL;
+  }
+  if (strncmp (&data[4], "wide", 4)==0 ||
+      strncmp (&data[4], "moov", 4)==0 ||
+      strncmp (&data[4], "mdat", 4)==0 ||
+      strncmp (&data[4], "free", 4)==0) {
     return gst_caps_new ("quicktime_type_find",
 		         "video/quicktime", 
 			 NULL);
@@ -246,6 +212,7 @@ plugin_init (GModule *module, GstPlugin *plugin)
 
   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (sink_templ));
   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_video_templ));
+  gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_audio_templ));
 
   type = gst_type_factory_new (&quicktimedefinition);
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
@@ -262,447 +229,1246 @@ GstPluginDesc plugin_desc = {
   plugin_init
 };
 
-static gboolean
-gst_qtdemux_handle_event (GstQTDemux * qtdemux)
+static gboolean gst_qtdemux_handle_sink_event (GstQTDemux *qtdemux)
 {
   guint32 remaining;
-  GstEvent * event;
+  GstEvent *event;
   GstEventType type;
 
-  gst_bytestream_get_status (qtdemux->bs,&remaining,&event);
-  type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
+  gst_bytestream_get_status(qtdemux->bs, &remaining, &event);
+
+  type = event ? GST_EVENT_TYPE(event) : GST_EVENT_UNKNOWN;
+  GST_DEBUG(0,"qtdemux: event %p %d", event, type);
 
-  switch (type) {
+  switch(GST_EVENT_TYPE(event)){
     case GST_EVENT_EOS:
-      gst_pad_event_default (qtdemux->sinkpad,event);
+      gst_bytestream_flush(qtdemux->bs, remaining);
+      gst_pad_event_default(qtdemux->sinkpad, event);
+      return FALSE;
+    case GST_EVENT_FLUSH:
+      g_warning("flush event");
       break;
     case GST_EVENT_DISCONTINUOUS:
-      gst_bytestream_flush_fast (qtdemux->bs, remaining);
+      GST_DEBUG(0,"discontinuous event\n");
+      //gst_bytestream_flush_fast(qtdemux->bs, remaining);
+      break;
     default:
-      gst_pad_event_default (qtdemux->sinkpad,event);
+      g_warning("unhandled event %d",type);
       break;
   }
+
+  gst_event_unref(event);
   return TRUE;
 }
 
-static gboolean gst_qtp_read_bytes_atom_head(GstQTDemux * qtdemux,GstQtpAtom * atom);
-static gboolean gst_qtp_skip(GstQTDemux * qtdemux, guint64 skip);
-static gboolean gst_qtp_skip_atom(GstQTDemux * qtdemux, GstQtpAtom * atom);
-static gboolean gst_qtp_skip_container(GstQTDemux * qtdemux, guint32 type);
+static GstElementStateReturn gst_qtdemux_change_state(GstElement *element)
+{
+  GstQTDemux *qtdemux = GST_QTDEMUX(element);
 
-/* new track emerges here */
-static GstQtpTrack * track_to_be = NULL;
+  switch(GST_STATE_TRANSITION(element)){
+    case GST_STATE_NULL_TO_READY:
+      break;
+    case GST_STATE_READY_TO_PAUSED:
+      qtdemux->bs = gst_bytestream_new(qtdemux->sinkpad);
+      qtdemux->state = QTDEMUX_STATE_HEADER;
+      /* FIXME */
+      break;
+    case GST_STATE_PAUSED_TO_PLAYING:
+      break;
+    case GST_STATE_PLAYING_TO_PAUSED:
+      break;
+    case GST_STATE_PAUSED_TO_READY:
+      gst_bytestream_destroy(qtdemux->bs);
+      break;
+    case GST_STATE_READY_TO_NULL:
+      break;
+    default:
+      break;
+  }
 
-/* 
- * - gst_qtp_* functions together with gst_qtdemux_loop implement quicktime
- * parser.
- */
+  return GST_ELEMENT_CLASS(parent_class)->change_state(element);
+}
 
-static void
-gst_qtdemux_loop (GstElement *element)
-{
-  GstQTDemux * qtdemux = GST_QTDEMUX (element);
-  GstQtpAtom atom;
-  GstQtpAtomType * atom_type;
-
-  /* ain't we out of the current container? */
-  if (qtdemux->nested) {
-    GstQtpAtom * current = (GstQtpAtom *) qtdemux->nested->data;
-    while (current && (current->size!=0) && (current->start+current->size <= qtdemux->bs_pos)) {
-      /* indeed we are! */
-      qtdemux->nested = qtdemux->nested->next;
-      qtdemux->nested_cnt--;
-      /* if atom type has a handler call it with enter=FALSE (i.e. leave) */
-      atom_type = g_hash_table_lookup (gst_qtp_type_registry,&(current->type));
-      if (atom_type && atom_type->handler) 
-	atom_type->handler(qtdemux,current,FALSE);
-      free(current);
-      current = qtdemux->nested?(GstQtpAtom *) qtdemux->nested->data:NULL;
+static void gst_qtdemux_loop_header (GstElement *element)
+{
+  GstQTDemux *qtdemux = GST_QTDEMUX(element);
+  guint8 *data;
+  guint32 length;
+  guint32 fourcc;
+  GstBuffer *buf;
+  int offset;
+  int cur_offset;
+  int size;
+  int ret;
+
+
+  GST_DEBUG(0,"loop at position %d",(int)gst_bytestream_tell(qtdemux->bs));
+
+  switch(qtdemux->state){
+  case QTDEMUX_STATE_HEADER:
+  {
+    ret = gst_bytestream_peek_bytes(qtdemux->bs, &data, 16);
+    if(ret<16){
+      gst_qtdemux_handle_sink_event(qtdemux);
+      return;
     }
-  }
-
-  gst_qtp_read_bytes_atom_head(qtdemux,&atom);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtdemux_loop: atom(%c%c%c%c,%" G_GUINT64_FORMAT ",%" G_GUINT64_FORMAT")\n",GST_FOURCC_TO_CHARSEQ(atom.type),atom.start,atom.size);
 
-  atom_type = g_hash_table_lookup (gst_qtp_type_registry,&atom.type);
-  if (!atom_type) {
-    gst_qtp_skip_atom(qtdemux,&atom);
-    return;
+    length = GUINT32_FROM_BE(*(guint32 *)data);
+    GST_DEBUG(0,"length %08x",length);
+    fourcc = GUINT32_FROM_LE(*(guint32 *)(data+4));
+    GST_DEBUG(0,"fourcc " GST_FOURCC_FORMAT, GST_FOURCC_ARGS(fourcc));
+    if(length==0){
+      length = gst_bytestream_length(qtdemux->bs) - gst_bytestream_tell(qtdemux->bs);
+    }
+    if(length==1){
+      guint32 length1, length2;
+  
+      length1 = GUINT32_FROM_BE(*(guint32 *)(data+8));
+      GST_DEBUG(0,"length1 %08x",length1);
+      length2 = GUINT32_FROM_BE(*(guint32 *)(data+12));
+      GST_DEBUG(0,"length2 %08x",length2);
+  
+      length=length2;
+    }
+  
+    switch(fourcc){
+      case GST_MAKE_FOURCC('m','d','a','t'):
+      {
+        int ret;
+        int pos;
+  
+        pos = gst_bytestream_tell(qtdemux->bs);
+        ret = gst_bytestream_seek(qtdemux->bs, pos + length, GST_SEEK_METHOD_SET);
+        GST_DEBUG(0,"seek returned %d",ret);
+        return;
+      }
+      case GST_MAKE_FOURCC('m','o','o','v'):
+      {
+        GstBuffer *moov;
+        guint32 n_read;
+  
+        n_read = gst_bytestream_read(qtdemux->bs, &moov, length);
+        if(n_read<length){
+	  /* FIXME */
+	  g_warning("need to handle event\n");
+        }
+        qtdemux_parse_moov(qtdemux, GST_BUFFER_DATA(moov), length);
+        if(0)qtdemux_node_dump(qtdemux, qtdemux->moov_node);
+        qtdemux_parse_tree(qtdemux);
+        qtdemux->state = QTDEMUX_STATE_MOVIE;
+        break;
+      }
+      case GST_MAKE_FOURCC('f','r','e','e'):
+      {
+        gst_bytestream_flush(qtdemux->bs, length);
+        break;
+      }
+      case GST_MAKE_FOURCC('w','i','d','e'):
+      {
+        gst_bytestream_flush(qtdemux->bs, length);
+        break;
+      }
+      default:
+      {
+        g_print("unknown %08x '" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT "\n",
+            GST_MAKE_FOURCC('1','2','3','4'),
+            GST_FOURCC_ARGS(GST_MAKE_FOURCC('1','2','3','4')),gst_bytestream_tell(qtdemux->bs));
+        gst_bytestream_flush(qtdemux->bs, length);
+        break;
+      }
+    }
+    break;
   }
+  case QTDEMUX_STATE_SEEKING_EOS:
+  {
+    guint8 *data;
+
+    do{
+      ret = gst_bytestream_peek_bytes(qtdemux->bs, &data, 1);
+      g_print("peek_bytes returned %d after EOS seek\n",ret);
+      if(ret<1){
+        if(!gst_qtdemux_handle_sink_event(qtdemux)){
+	  return;
+        }
+      }else{
+	break;
+      }
+    }while(TRUE);
+    gst_element_set_eos(element);
 
-  if (atom_type->flags & GST_QTP_CONTAINER_ATOM) {
-    GstQtpAtom * new_atom;
-    new_atom = malloc(sizeof(GstQtpAtom));
-    memcpy(new_atom,&atom,sizeof(GstQtpAtom));
-    qtdemux->nested_cnt++;
-    qtdemux->nested = g_slist_prepend (qtdemux->nested, new_atom);
-    if (atom_type->handler) 
-      atom_type->handler(qtdemux,&atom,TRUE);
-  } else {
-    /* leaf atom */
-    if (atom_type->handler)
-      atom_type->handler(qtdemux,&atom,TRUE);
-    /*
-     * if there wasn't a handler - we skip the whole atom
-     * if there was - ensure that next thing read will be after the atom
-     * (handler isn't obligated to read anything)
-     */
-    gst_qtp_skip_atom(qtdemux,&atom);
+    qtdemux->state = QTDEMUX_STATE_EOS;
     return;
   }
-}
+  case QTDEMUX_STATE_EOS:
+    g_warning("spinning in EOS\n");
+    return;
+  case QTDEMUX_STATE_MOVIE:
+  {
+    QtDemuxStream *stream;
+    guint64 min_time;
+    int index = -1;
+    int i;
+
+    min_time = G_MAXUINT64;
+    for(i=0;i<qtdemux->n_streams;i++){
+      stream = qtdemux->streams[i];
+
+      if(stream->sample_index < stream->n_samples &&
+	  stream->samples[stream->sample_index].timestamp < min_time){
+	min_time = stream->samples[stream->sample_index].timestamp;
+	index = i;
+      }
+    }
 
-/* 
- * peeks an atom header,
- * advances qtdemux->bs_pos (cause bytestream won't tell)
- * flushes bytestream
- */
-static gboolean
-gst_qtp_read_bytes_atom_head(GstQTDemux * qtdemux,GstQtpAtom * atom)
-{
-  GstByteStream * bs = qtdemux->bs;
-  GstQtpAtomMinHeader * amh = NULL;
-  guint64 * esize=NULL;
-
-  /* FIXME this can't be right, rewrite with _read */
-  do { /* do ... while (event()) is necessary for bytestream events */
-    if (!amh) {
-      if (gst_bytestream_peek_bytes (bs, (guint8**)&amh, 8) == 8)  {
-	atom->size = GUINT32_FROM_BE(amh->size);
-	atom->type = amh->type; /* don't need to turn this around magicly FIXME this can depend on endiannes */
-	atom->start = qtdemux->bs_pos;
-	gst_bytestream_flush (bs, 8);
-	qtdemux->bs_pos += 8;
+    if(index==-1){
+      for(i=0;i<qtdemux->n_streams;i++){
+        gst_pad_push(qtdemux->streams[i]->pad,
+	    GST_BUFFER(gst_event_new (GST_EVENT_EOS)));
+      }
+      ret = gst_bytestream_seek(qtdemux->bs, 0, GST_SEEK_METHOD_END);
+      GST_DEBUG(0,"seek returned %d",ret);
+
+      qtdemux->state = QTDEMUX_STATE_SEEKING_EOS;
+      return;
+    }
+
+    stream = qtdemux->streams[index];
+
+    offset = stream->samples[stream->sample_index].offset;
+    size = stream->samples[stream->sample_index].size;
+
+    cur_offset = gst_bytestream_tell(qtdemux->bs);
+    if(offset != cur_offset){
+      GST_DEBUG(0,"seeking to offset %d",offset);
+      ret = gst_bytestream_seek(qtdemux->bs, offset, GST_SEEK_METHOD_SET);
+      GST_DEBUG(0,"seek returned %d",ret);
+#if 0
+      if(!gst_bytestream_seek(qtdemux->bs, offset, GST_SEEK_METHOD_SET)){
+        GstEvent *event;
+        guint32 remaining;
+
+        g_print("seek failed\n");
+        gst_bytestream_get_status(qtdemux->bs, &remaining, &event);
+
+        gst_pad_push(stream->pad, GST_BUFFER(event));
+        return;
       }
+#endif
+      return;
     }
-    if (amh) {
-      if (atom->size == 1) { /* need to peek extended size field */
-	if (gst_bytestream_peek_bytes (bs, (guint8**)&esize, 8) == 8) {
-	  atom->size = GUINT64_FROM_BE(*esize);
-	  gst_bytestream_flush (bs, 8);
-	  qtdemux->bs_pos += 8;
-	  return TRUE;
+
+    GST_DEBUG(0,"reading %d bytes\n",size);
+    buf = NULL;
+    do{
+      ret = gst_bytestream_read(qtdemux->bs, &buf, size);
+      if(ret < size){
+        GST_DEBUG(0,"read failed (%d < %d)",ret,size);
+        if(!gst_qtdemux_handle_sink_event(qtdemux)){
+	  return;
 	}
-      } else {
-	return TRUE;
+      }else{
+	break;
       }
+    }while(TRUE);
+
+    if(buf){
+      GST_BUFFER_TIMESTAMP(buf) = stream->samples[stream->sample_index].timestamp;
+      gst_pad_push(stream->pad, buf);
     }
-  } while (gst_qtdemux_handle_event (qtdemux));
-  return TRUE;
+    stream->sample_index++;
+    break;
+  }
+  default:
+    /* unreached */
+    g_assert(0);
+  }
+
 }
 
-static void
-gst_qtp_read_bytes(GstQTDemux * qtdemux, void * buffer, size_t size)
+void gst_qtdemux_add_stream(GstQTDemux *qtdemux, QtDemuxStream *stream)
 {
-  void * data;
-  GstByteStream * bs = qtdemux->bs;
-
-  do {
-    if (gst_bytestream_peek_bytes (bs, (guint8**)&data, size) == size) {
-      memcpy(buffer,data,size);
-      gst_bytestream_flush(bs,size);
-      qtdemux->bs_pos += size;
-      return;
+  if(stream->subtype == GST_MAKE_FOURCC('v','i','d','e')){
+    stream->pad = gst_pad_new_from_template (
+        GST_PAD_TEMPLATE_GET (src_video_templ), g_strdup_printf ("video_%02d",
+	  qtdemux->n_video_streams));
+    if(stream->caps){
+      if(gst_caps_has_property(stream->caps,"width")){
+	/* FIXME */
+        gst_caps_set(stream->caps,"width",GST_PROPS_INT(100));
+      }
+      if(gst_caps_has_property(stream->caps,"height")){
+	/* FIXME */
+        gst_caps_set(stream->caps,"height",GST_PROPS_INT(100));
+      }
+    }
+    qtdemux->n_video_streams++;
+  }else{
+    stream->pad = gst_pad_new_from_template (
+        GST_PAD_TEMPLATE_GET (src_audio_templ), g_strdup_printf ("audio_%02d",
+	  qtdemux->n_audio_streams));
+#if 0
+    if(stream->caps){
+      if(gst_caps_has_property(stream->caps,"rate")){
+	/* FIXME */
+        gst_caps_set(stream->caps,"rate",GST_PROPS_INT(44100));
+      }
+      if(gst_caps_has_property(stream->caps,"channels")){
+	/* FIXME */
+        gst_caps_set(stream->caps,"channels",GST_PROPS_INT(2));
+      }
     }
-  } while (gst_qtdemux_handle_event (qtdemux));
+#endif
+    g_print("setting caps to %s\n",gst_caps_to_string(stream->caps));
+    qtdemux->n_audio_streams++;
+  }
+  gst_element_add_pad(GST_ELEMENT (qtdemux), stream->pad);
+  if(stream->caps){
+    gst_pad_try_set_caps(stream->pad, stream->caps);
+  }
+
+  qtdemux->streams[qtdemux->n_streams] = stream;
+  qtdemux->n_streams++;
 }
 
-static GstBuffer *
-gst_qtp_read(GstQTDemux * qtdemux, size_t size)
+
+#define QT_CONTAINER 1
+
+#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_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_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_co64	GST_MAKE_FOURCC('c','o','6','4')
+
+
+static void qtdemux_dump_mvhd(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_tkhd(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_elst(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_mdhd(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_hdlr(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_vmhd(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_dref(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stsd(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stts(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stss(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stsc(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stsz(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_stco(GstQTDemux *qtdemux, void *buffer, int depth);
+static void qtdemux_dump_co64(GstQTDemux *qtdemux, void *buffer, int depth);
+
+QtNodeType qt_node_types[] = {
+  { FOURCC_moov, "movie",		QT_CONTAINER, },
+  { FOURCC_mvhd, "movie header",	0,
+  	qtdemux_dump_mvhd },
+  { FOURCC_clip, "clipping",		QT_CONTAINER, },
+  { FOURCC_trak, "track",		QT_CONTAINER, },
+  { FOURCC_udta, "user data",		0, }, /* 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_CONTAINER, },
+  { FOURCC_kmat, "compressed matte",	0, },
+  { FOURCC_edts, "edit",		QT_CONTAINER, },
+  { FOURCC_elst, "edit list",		0,
+  	qtdemux_dump_elst },
+  { FOURCC_load, "track load settings",	0, },
+  { FOURCC_tref, "track reference",	QT_CONTAINER, },
+  { FOURCC_imap, "track input map",	QT_CONTAINER, },
+  { FOURCC___in, "track input",		0, }, /* special container */
+  { FOURCC___ty, "input type",		0, },
+  { FOURCC_mdia, "media",		QT_CONTAINER },
+  { FOURCC_mdhd, "media header",	0,
+  	qtdemux_dump_mdhd },
+  { FOURCC_hdlr, "handler reference",	0,
+  	qtdemux_dump_hdlr },
+  { FOURCC_minf, "media information",	QT_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_CONTAINER },
+  { FOURCC_dref, "data reference",	0,
+  	qtdemux_dump_dref },
+  { FOURCC_stbl, "sample table",	QT_CONTAINER },
+  { FOURCC_stsd, "sample description",	0,
+  	qtdemux_dump_stsd },
+  { FOURCC_stts, "time-to-sample",	0,
+  	qtdemux_dump_stts },
+  { 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 },
+  { 0, "unknown", 0 },
+};
+static int n_qt_node_types = sizeof(qt_node_types)/sizeof(qt_node_types[0]);
+
+
+
+static void qtdemux_parse_moov(GstQTDemux *qtdemux, void *buffer, int length)
 {
-  GstBuffer * buf;
-  GstByteStream * bs = qtdemux->bs;
-  do {
-    if (gst_bytestream_read (bs, &buf, size) == size) {
-      qtdemux->bs_pos += size;
-      return buf;
-    }
-  } while (gst_qtdemux_handle_event (qtdemux));
-  return NULL;
+
+  qtdemux->moov_node = g_node_new(buffer);
+
+  qtdemux_parse(qtdemux, qtdemux->moov_node, buffer, length);
+
 }
 
-/*
- * skips some input (e.g. to ignore unknown atom)
- */
-static gboolean
-gst_qtp_skip(GstQTDemux * qtdemux, guint64 skip)
+static void qtdemux_parse(GstQTDemux *qtdemux, GNode *node, void *buffer, int length)
 {
-  GstByteStream * bs = qtdemux->bs;
+  guint32 fourcc;
+  guint32 node_length;
+  QtNodeType *type;
+  void *end;
+
+  //g_print("qtdemux_parse %p %d\n",buffer, length);
+
+  node_length = GUINT32_FROM_BE(*(guint32 *)buffer);
+  fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4));
+
+  type = qtdemux_type_get(fourcc);
   
-  if (skip) {
-    gst_bytestream_flush(bs,skip);
-    qtdemux->bs_pos += skip;
+  //g_print("parsing '" GST_FOURCC_FORMAT "', length=%d\n",
+      //GST_FOURCC_ARGS(fourcc), node_length);
+
+  if(type->flags & QT_CONTAINER){
+    void *buf;
+    guint32 len;
+
+    buf = buffer + 8;
+    end = buffer + length;
+    while(buf < end){
+      GNode *child;
+
+      if(buf + 8 >= end){
+	/* FIXME: get annoyed */
+	g_print("buffer overrun\n");
+      }
+      len = GUINT32_FROM_BE(*(guint32 *)buf);
+
+      child = g_node_new(buf);
+      g_node_append(node, child);
+      qtdemux_parse(qtdemux, child, buf, len);
+
+      buf += len;
+    }
+  }else{
+    //g_print("not container\n");
+
   }
-  return TRUE;
 }
 
-/* convenience function for skipping the given atom */
-static gboolean
-gst_qtp_skip_atom(GstQTDemux * qtdemux, GstQtpAtom * atom)
+static QtNodeType *qtdemux_type_get(guint32 fourcc)
 {
-  if (qtdemux->bs_pos < atom->start + atom->size) {
-    guint64 skip = atom->start + atom->size - qtdemux->bs_pos;
-    return gst_qtp_skip(qtdemux,skip);
-  } else 
-    return FALSE;
+  int i;
+
+  for(i=0;i<n_qt_node_types;i++){
+    if(qt_node_types[i].fourcc == fourcc)
+      return qt_node_types+i;
+  }
+  return qt_node_types+n_qt_node_types-1;
 }
 
-/* skips the container with type 'type' if finds it in the nesting stack */
-static gboolean
-gst_qtp_skip_container(GstQTDemux * qtdemux, guint32 type)
+static gboolean qtdemux_node_dump_foreach(GNode *node, gpointer data)
 {
-  GSList * iter = qtdemux->nested;
+  void *buffer = node->data;
+  guint32 node_length;
+  guint32 fourcc;
+  QtNodeType *type;
+  int depth;
 
-  while (iter && ((GstQtpAtom*)(iter->data))->type != type)
-    iter = iter->next;
+  node_length = GUINT32_FROM_BE(*(guint32 *)buffer);
+  fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4));
 
-  if (iter) 
-    return gst_qtp_skip_atom(qtdemux,(GstQtpAtom*)iter->data);
-  else
-    return FALSE;
+  type = qtdemux_type_get(fourcc);
+
+  depth = (g_node_depth(node)-1)*2;
+  g_print("%*s'" GST_FOURCC_FORMAT "', [%d], %s\n",
+      depth, "",
+      GST_FOURCC_ARGS(fourcc),
+      node_length,
+      type->name);
+
+  if(type->dump)type->dump(data, buffer, depth);
+
+  return FALSE;
 }
 
-static gint 
-gst_guint32_compare(gconstpointer a, gconstpointer b)
+static void qtdemux_node_dump(GstQTDemux *qtdemux, GNode *node)
 {
-  if ((guint32*)a < (guint32*)b) 
-    return -1;
-  else if ((guint32*)a > (guint32*)b)
-    return 1;
-  else
-    return 0;
+  g_node_traverse(qtdemux->moov_node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+      qtdemux_node_dump_foreach, qtdemux);
 }
 
-static void 
-gst_qtp_trak_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
-{
-  if (enter) { /* enter trak */
-    GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: enter\n");
-    track_to_be = malloc(sizeof(GstQtpTrack));
-    track_to_be->stsd = NULL;
-    track_to_be->stts = NULL;
-    track_to_be->stsc = NULL;
-    track_to_be->stsz = NULL;
-    track_to_be->stco = NULL;
-    track_to_be->samples = NULL;
-    track_to_be->pad = NULL;
-  } else { /* leave trak */
-    GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: leave\n");
-    if (track_to_be) { /* if we didnt discard this track earlier */
-      GstQtpStscRec * stsc;
-      guint32 * stsz, * stco, offset;
-      int chunk,sample,nchunks,nsamples,stsc_idx,nstsc;
-      GstCaps * newcaps = NULL;
-
-      /* process sample tables */
-
-      /*
-       * FIXME have to check which sample tables are present and which are not
-       * and skip the track if there's not enough tables or set default values
-       * if some optional tables are missing
-       */
-
-      /*
-       * FIXME i assume that there's only one of each stsd record and stts
-       * record in the tables that's not always true, this must be changed
-       * later, as soon as i encounter qt file with bigger tables.
-       */
-      track_to_be->format = ((GstQtpStsdRec*)GST_BUFFER_DATA(track_to_be->stsd))->format;
-      GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: format: %c%c%c%c\n",GST_FOURCC_TO_CHARSEQ(track_to_be->format));
-      track_to_be->sample_duration = GUINT32_FROM_BE(((GstQtpSttsRec*)GST_BUFFER_DATA(track_to_be->stts))->duration);
-      GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: sample duration: %d\n",track_to_be->sample_duration);
-      /* 
-       * depending on format we can decide to refuse this track all together 
-       * if we don't know what for format that it. 
-       */
-      switch (track_to_be->format) {
-	case GST_MAKE_FOURCC('j','p','e','g'):
-	  track_to_be->pad = gst_pad_new_from_template(
-	      GST_PAD_TEMPLATE_GET(src_video_templ),
-	      g_strdup_printf("video_%02d",qtdemux->num_video_pads++));
-	  newcaps = GST_CAPS_NEW(
-	      "qtdemux_video_src",
-	      "video/jpeg",
-	      "width", GST_PROPS_INT(track_to_be->width),
-	      "height", GST_PROPS_INT(track_to_be->height));
-	  gst_pad_try_set_caps(track_to_be->pad,newcaps);
-	  gst_element_add_pad(GST_ELEMENT(qtdemux),track_to_be->pad);
-	  break;
-      }
+#define QTDEMUX_GUINT32_GET(a) GUINT32_FROM_BE(*(guint32 *)(a))
+#define QTDEMUX_GUINT16_GET(a) GUINT16_FROM_BE(*(guint16 *)(a))
+#define QTDEMUX_GUINT8_GET(a) (*(guint8 *)(a))
+#define QTDEMUX_FP32_GET(a) (GUINT32_FROM_BE(*(guint16 *)(a))/65536.0)
+#define QTDEMUX_FP16_GET(a) (GUINT16_FROM_BE(*(guint16 *)(a))/256.0)
+#define QTDEMUX_FOURCC_GET(a) GUINT32_FROM_LE(*(guint32 *)(a))
 
-      /* 
-       * now let's find all about individual samples and put them into samples
-       * tree
-       */
-      if (!qtdemux->samples) { 
-	qtdemux->samples = g_tree_new(gst_guint32_compare);
-      }
-      stsc = (GstQtpStscRec*)GST_BUFFER_DATA(track_to_be->stsc);
-      stsz = (guint32*)GST_BUFFER_DATA(track_to_be->stsz);
-      stco = (guint32*)GST_BUFFER_DATA(track_to_be->stco);
-      nchunks = GST_BUFFER_SIZE(track_to_be->stco)/sizeof(guint32);
-      nsamples = GST_BUFFER_SIZE(track_to_be->stsz)/sizeof(guint32);
-      nstsc = GST_BUFFER_SIZE(track_to_be->stsc)/sizeof(GstQtpStscRec);
-
-      track_to_be->samples = malloc(nsamples*sizeof(GstQtpSample));
-      for(chunk=0,sample=0,stsc_idx=0;
-	  chunk<nchunks;
-	  chunk++) {
-	int i;
-	offset = GUINT32_FROM_BE(stco[chunk]);
-	if (stsc_idx+1<nstsc && chunk+1==GUINT32_FROM_BE(stsc[stsc_idx+1].first_chunk)) {
-	  stsc_idx++;
-	}
-	for(i=0;i<GUINT32_FROM_BE(stsc[stsc_idx].samples_per_chunk);i++,sample++) {
-	  guint32 size = GUINT32_FROM_BE(stsz[sample]);
-	  track_to_be->samples[sample].offset = offset;
-	  track_to_be->samples[sample].size = size;
-	  track_to_be->samples[sample].timestamp = sample*((1000000*track_to_be->sample_duration)/track_to_be->time_scale);
-	  track_to_be->samples[sample].track = track_to_be;
-	  g_tree_insert(qtdemux->samples,&(track_to_be->samples[sample].offset),&(track_to_be->samples[sample]));
-	  offset += size;
-	}
-      }
+#define QTDEMUX_GUINT64_GET(a) ((((guint64)QTDEMUX_GUINT32_GET(a))<<32)|QTDEMUX_GUINT32_GET(((void *)a)+4))
 
-      GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: trak added to the list\n");
-      qtdemux->tracks = g_list_prepend(qtdemux->tracks,track_to_be);
+static void qtdemux_dump_mvhd(GstQTDemux *qtdemux, void *buffer, int depth)
+{
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  g_print("%*s  modify time:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16));
+  g_print("%*s  time scale:    1/%u sec\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20));
+  g_print("%*s  duration:      %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24));
+  g_print("%*s  pref. rate:    %g\n", depth, "", QTDEMUX_FP32_GET(buffer+28));
+  g_print("%*s  pref. volume:  %g\n", depth, "", QTDEMUX_FP16_GET(buffer+32));
+  g_print("%*s  preview time:  %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+80));
+  g_print("%*s  preview dur.:  %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+84));
+  g_print("%*s  poster time:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+88));
+  g_print("%*s  select time:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+92));
+  g_print("%*s  select dur.:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+96));
+  g_print("%*s  current time:  %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+100));
+  g_print("%*s  next track ID: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+104));
+}
 
-      gst_buffer_unref(track_to_be->stsd);
-      gst_buffer_unref(track_to_be->stts);
-      gst_buffer_unref(track_to_be->stsc);
-      gst_buffer_unref(track_to_be->stsz);
-      gst_buffer_unref(track_to_be->stco);
-      track_to_be = 0;
-    }
+static void qtdemux_dump_tkhd(GstQTDemux *qtdemux, void *buffer, int depth)
+{
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  g_print("%*s  modify time:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16));
+  g_print("%*s  track ID:      %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20));
+  g_print("%*s  duration:      %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+28));
+  g_print("%*s  layer:         %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+36));
+  g_print("%*s  alt group:     %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+38));
+  g_print("%*s  volume:        %g\n", depth, "", QTDEMUX_FP16_GET(buffer+44));
+  g_print("%*s  track width:   %g\n", depth, "", QTDEMUX_FP32_GET(buffer+84));
+  g_print("%*s  track height:  %g\n", depth, "", QTDEMUX_FP32_GET(buffer+88));
+
+}
+
+static void qtdemux_dump_elst(GstQTDemux *qtdemux, void *buffer, int depth)
+{
+  int i;
+  int n;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  for(i=0;i<n;i++){
+    g_print("%*s    track dur:     %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16+i*12));
+    g_print("%*s    media time:    %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20+i*12));
+    g_print("%*s    media rate:    %g\n", depth, "", QTDEMUX_FP32_GET(buffer+24+i*12));
   }
 }
 
-/* 
- * weird formats they apple guys are using 
- * weird conversion copied from openquicktime 
- * FIXME either it can be done more beautiful/fast way or this fixme has to go
- */
-static float 
-fixed32_to_float(guint32 fixed)
+static void qtdemux_dump_mdhd(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  unsigned char * data = (unsigned char*)&fixed;
-  guint32 a, b, c, d;
-  a = data[0];
-  b = data[1];
-  c = data[2];
-  d = data[3];
-  a = (a << 8) + b;
-  b = (c << 8) + d;
-  return (float)a + (float)b / 65536;
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  g_print("%*s  modify time:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16));
+  g_print("%*s  time scale:    1/%u sec\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20));
+  g_print("%*s  duration:      %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24));
+  g_print("%*s  language:      %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+28));
+  g_print("%*s  quality:       %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+30));
+
 }
 
-static void 
-gst_qtp_tkhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_hdlr(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 wh[2];
-  /* if we get here track_to_be must be not NULL */
-  g_assert(track_to_be);
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  type:          " GST_FOURCC_FORMAT "\n", depth, "",
+      GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+12)));
+  g_print("%*s  subtype:       " GST_FOURCC_FORMAT "\n", depth, "",
+      GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+16)));
+  g_print("%*s  manufacturer:  " GST_FOURCC_FORMAT "\n", depth, "",
+      GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+20)));
+  g_print("%*s  flags:         %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24));
+  g_print("%*s  flags mask:    %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+28));
+  g_print("%*s  name:          %*s\n", depth, "",
+      QTDEMUX_GUINT8_GET(buffer+32), (char *)(buffer+33));
 
-  gst_qtp_skip(qtdemux,76); /* don't need those values */
-  gst_qtp_read_bytes(qtdemux,wh,8);
-  track_to_be->width = (guint32) fixed32_to_float(wh[0]);
-  track_to_be->height = (guint32) fixed32_to_float(wh[1]);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_tkhd_handler: track dimmensions: %dx%d\n",track_to_be->width,track_to_be->height);
 }
 
-static void
-gst_qtp_hdlr_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_vmhd(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[3];
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  mode/color:    %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16));
+}
 
-  gst_qtp_read_bytes(qtdemux,a,12);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_hdlr_handler: %c%c%c%c %c%c%c%c\n",GST_FOURCC_TO_CHARSEQ(a[1]),GST_FOURCC_TO_CHARSEQ(a[2]));
-  if (a[1]==GST_MAKE_FOURCC('m','h','l','r') && a[2]!=GST_MAKE_FOURCC('v','i','d','e')) {
-    GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_hdlr_handler: rejecting the track\n");
-    /* forget about this track! */
-    free(track_to_be);
-    track_to_be = NULL;
-    gst_qtp_skip_container(qtdemux,GST_MAKE_FOURCC('t','r','a','k'));
+static void qtdemux_dump_dref(GstQTDemux *qtdemux, void *buffer, int depth)
+{
+  int n;
+  int i;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    size:          %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+    g_print("%*s    type:          " GST_FOURCC_FORMAT "\n", depth, "",
+	GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+4)));
+    offset += QTDEMUX_GUINT32_GET(buffer+offset);
   }
-  return;
 }
 
-static void
-gst_qtp_stsd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_stsd(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[2];
-  gst_qtp_read_bytes(qtdemux,a,8);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsd_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1]));
-  /* just put the rest of the atom into sample description table */
-  track_to_be->stsd = gst_qtp_read(qtdemux,atom->start + atom->size - qtdemux->bs_pos);
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    size:          %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+    g_print("%*s    type:          " GST_FOURCC_FORMAT "\n", depth, "",
+	GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+4)));
+    g_print("%*s    data reference:%d\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+14));
+
+    g_print("%*s    version/rev.:  %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+16));
+    g_print("%*s    vendor:        " GST_FOURCC_FORMAT "\n", depth, "",
+	GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+20)));
+    g_print("%*s    temporal qual: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+24));
+    g_print("%*s    spatial qual:  %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+28));
+    g_print("%*s    width:         %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+32));
+    g_print("%*s    height:        %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+34));
+    g_print("%*s    horiz. resol:  %g\n", depth, "", QTDEMUX_FP32_GET(buffer+offset+36));
+    g_print("%*s    vert. resol.:  %g\n", depth, "", QTDEMUX_FP32_GET(buffer+offset+40));
+    g_print("%*s    data size:     %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+44));
+    g_print("%*s    frame count:   %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+48));
+    g_print("%*s    compressor:    %*s\n", depth, "",
+	QTDEMUX_GUINT8_GET(buffer+offset+49), (char *)(buffer+offset+51));
+    g_print("%*s    depth:         %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+82));
+    g_print("%*s    color table ID:%u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+84));
+
+    offset += QTDEMUX_GUINT32_GET(buffer+offset);
+  }
 }
 
-static void
-gst_qtp_stts_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_stts(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[2];
-  gst_qtp_read_bytes(qtdemux,a,8);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stts_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1]));
-  track_to_be->stts = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(GstQtpSttsRec));
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    count:         %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+    g_print("%*s    duration:      %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset + 4));
+
+    offset += 8;
+  }
 }
-static void
-gst_qtp_stsc_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+
+static void qtdemux_dump_stss(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[2];
-  gst_qtp_read_bytes(qtdemux,a,8);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsc_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1]));
-  track_to_be->stsc = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(GstQtpStscRec));
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    sample:        %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+
+    offset += 4;
+  }
 }
 
-static void
-gst_qtp_stsz_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_stsc(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[3];
-  gst_qtp_read_bytes(qtdemux,a,12);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsz_handler: %d entries in the table\n",GUINT32_FROM_BE(a[2]));
-  /* FIXME have to chech a[2], it contains size if all samples if they are the same size */
-  track_to_be->stsz = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[2])*sizeof(guint32));
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    first chunk:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+    g_print("%*s    sample per ch: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+4));
+    g_print("%*s    sample desc id:%08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+8));
+
+    offset += 12;
+  }
 }
 
-static void
-gst_qtp_stco_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
+static void qtdemux_dump_stsz(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[2];
-  gst_qtp_read_bytes(qtdemux,a,8);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stco_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1]));
-  track_to_be->stco = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(guint32));
+  int i;
+  int n;
+  int offset;
+  int sample_size;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  sample size:   %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  sample_size = QTDEMUX_GUINT32_GET(buffer+12);
+  if(sample_size == 0){
+    g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16));
+    n = QTDEMUX_GUINT32_GET(buffer+16);
+    offset = 20;
+    for(i=0;i<n;i++){
+      g_print("%*s    sample size:   %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+
+      offset += 4;
+    }
+  }
 }
 
-static void
-gst_qtp_mdhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) 
+static void qtdemux_dump_stco(GstQTDemux *qtdemux, void *buffer, int depth)
 {
-  guint32 a[4];
-  gst_qtp_read_bytes(qtdemux,a,16);
-  track_to_be->time_scale = GUINT32_FROM_BE(a[3]);
-  GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_mdhd_handler: time scale: %d\n",track_to_be->time_scale);
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    chunk offset:  %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset));
+
+    offset += 4;
+  }
 }
 
-static gboolean
-gst_qtp_traverse(gpointer poffs,gpointer value,gpointer data)
-{
-  GstQtpSample * sample = (GstQtpSample*)value;
-  GstQTDemux * qtdemux = (GstQTDemux*)data;
-
-  if (qtdemux->bs_pos < sample->offset) {
-    gst_qtp_skip(qtdemux,sample->offset - qtdemux->bs_pos);
-    if (sample->track->pad && GST_PAD_IS_LINKED(sample->track->pad)) {
-      GstBuffer * buf;
-      buf = gst_qtp_read(qtdemux,sample->size);
-      GST_BUFFER_TIMESTAMP(buf) = sample->timestamp;
-      gst_pad_push(sample->track->pad,buf);
+static void qtdemux_dump_co64(GstQTDemux *qtdemux, void *buffer, int depth)
+{
+  int i;
+  int n;
+  int offset;
+
+  g_print("%*s  version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8));
+  g_print("%*s  n entries:     %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12));
+  n = QTDEMUX_GUINT32_GET(buffer+12);
+  offset = 16;
+  for(i=0;i<n;i++){
+    g_print("%*s    chunk offset:  %" G_GUINT64_FORMAT "\n", depth, "", QTDEMUX_GUINT64_GET(buffer+offset));
+
+    offset += 8;
+  }
+}
+
+
+static GNode *qtdemux_tree_get_child_by_type(GNode *node, guint32 fourcc)
+{
+  GNode *child;
+  void *buffer;
+  guint32 child_fourcc;
+
+  for(child = g_node_first_child(node); child; child = g_node_next_sibling(child)){
+    buffer = child->data;
+
+    child_fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4));
+
+    if(child_fourcc == fourcc){
+      return child;
+    }
+  }
+  return NULL;
+}
+
+static GNode *qtdemux_tree_get_sibling_by_type(GNode *node, guint32 fourcc)
+{
+  GNode *child;
+  void *buffer;
+  guint32 child_fourcc;
+
+  for(child = g_node_next_sibling(node); child; child = g_node_next_sibling(child)){
+    buffer = child->data;
+
+    child_fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4));
+
+    if(child_fourcc == fourcc){
+      return child;
+    }
+  }
+  return NULL;
+}
+
+static void qtdemux_parse_trak(GstQTDemux *qtdemux, GNode *trak);
+
+static void qtdemux_parse_tree(GstQTDemux *qtdemux)
+{
+  GNode *mvhd;
+  GNode *trak;
+
+  mvhd = qtdemux_tree_get_child_by_type(qtdemux->moov_node, FOURCC_mvhd);
+
+  qtdemux->timescale = QTDEMUX_GUINT32_GET(mvhd->data + 20);
+  qtdemux->duration = QTDEMUX_GUINT32_GET(mvhd->data + 24);
+
+  g_print("timescale: %d\n", qtdemux->timescale);
+  g_print("duration: %d\n", qtdemux->duration);
+
+  trak = qtdemux_tree_get_child_by_type(qtdemux->moov_node, FOURCC_trak);
+  qtdemux_parse_trak(qtdemux, trak);
+
+  trak = qtdemux_tree_get_sibling_by_type(trak, FOURCC_trak);
+  if(trak)qtdemux_parse_trak(qtdemux, trak);
+}
+
+static void qtdemux_parse_trak(GstQTDemux *qtdemux, GNode *trak)
+{
+  int offset;
+  GNode *tkhd;
+  GNode *mdia;
+  GNode *mdhd;
+  GNode *hdlr;
+  GNode *minf;
+  GNode *stbl;
+  GNode *stsd;
+  GNode *stsc;
+  GNode *stsz;
+  GNode *stco;
+  GNode *co64;
+  GNode *stts;
+  int n_samples;
+  QtDemuxSample *samples;
+  int n_samples_per_chunk;
+  int index;
+  int i,j,k;
+  QtDemuxStream *stream;
+  int n_sample_times;
+  guint64 timestamp;
+  int sample_size;
+  int sample_index;
+
+  stream = g_new0(QtDemuxStream,1);
+
+  tkhd = qtdemux_tree_get_child_by_type(trak, FOURCC_tkhd);
+  g_assert(tkhd);
+
+  /* track duration? */
+
+  //g_print("track duration: %u\n", QTDEMUX_GUINT32_GET(buffer+28));
+ 
+  g_print("track width:   %g\n", QTDEMUX_FP32_GET(tkhd->data+84));
+  g_print("track height:  %g\n", QTDEMUX_FP32_GET(tkhd->data+88));
+
+  mdia = qtdemux_tree_get_child_by_type(trak, FOURCC_mdia);
+  g_assert(mdia);
+
+  mdhd = qtdemux_tree_get_child_by_type(mdia, FOURCC_mdhd);
+  g_assert(mdhd);
+
+  g_print("track time scale: %d\n", QTDEMUX_GUINT32_GET(mdhd->data+20));
+  stream->timescale = QTDEMUX_GUINT32_GET(mdhd->data+20);
+  //g_print("track height:  %g\n", QTDEMUX_FP32_GET(mdhd->data+88));
+  
+  hdlr = qtdemux_tree_get_child_by_type(mdia, FOURCC_hdlr);
+  g_assert(hdlr);
+  
+  g_print("track type: " GST_FOURCC_FORMAT "\n",
+      GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(hdlr->data+12)));
+  g_print("track subtype: " GST_FOURCC_FORMAT "\n",
+      GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(hdlr->data+16)));
+
+  stream->subtype = QTDEMUX_FOURCC_GET(hdlr->data+16);
+
+  minf = qtdemux_tree_get_child_by_type(mdia, FOURCC_minf);
+  g_assert(minf);
+
+  stbl = qtdemux_tree_get_child_by_type(minf, FOURCC_stbl);
+  g_assert(stbl);
+
+  stsd = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsd);
+  g_assert(stsd);
+
+  if(stream->subtype == FOURCC_vide){
+    offset = 16;
+    g_print("st type:          " GST_FOURCC_FORMAT "\n",
+	  GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(stsd->data+offset+4)));
+
+    g_print("width:         %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+32));
+    g_print("height:        %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+34));
+
+    //g_print("data size:     %u\n", QTDEMUX_GUINT32_GET(stsd->data+offset+44));
+    //g_print("frame count:   %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+48));
+
+    //g_print("compressor:    %*s\n", QTDEMUX_GUINT8_GET(stsd->data+offset+49), (char *)(stsd->data+offset+51));
+    
+    stream->caps = qtdemux_video_caps(qtdemux,
+        QTDEMUX_FOURCC_GET(stsd->data+offset+4));
+    g_print("caps %s\n",gst_caps_to_string(stream->caps));
+  }else if(stream->subtype == FOURCC_soun){
+    g_print("st type:          " GST_FOURCC_FORMAT "\n",
+	  GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(stsd->data+16+4)));
+
+    offset = 32;
+    g_print("version/rev:      %08x\n", QTDEMUX_GUINT32_GET(stsd->data+offset));
+    g_print("vendor:           %08x\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 4));
+    g_print("n_channels:       %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 8));
+    g_print("sample_size:      %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 10));
+    g_print("compression_id:   %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 12));
+    g_print("packet size:      %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 14));
+    g_print("sample rate:      %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 16));
+
+    g_print("samples/packet:   %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 20));
+    g_print("bytes/packet:     %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 24));
+    g_print("bytes/frame:      %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 28));
+    g_print("bytes/sample:     %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 32));
+
+    stream->caps = qtdemux_audio_caps(qtdemux,
+        QTDEMUX_FOURCC_GET(stsd->data+16+4));
+    g_print("caps %s\n",gst_caps_to_string(stream->caps));
+  }else{
+    g_print("unknown subtype\n");
+    return;
+  }
+
+  /* sample to chunk */
+  stsc = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsc);
+  g_assert(stsc);
+  /* sample size */
+  stsz = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsz);
+  g_assert(stsz);
+  /* chunk offsets */
+  stco = qtdemux_tree_get_child_by_type(stbl, FOURCC_stco);
+  co64 = qtdemux_tree_get_child_by_type(stbl, FOURCC_co64);
+  g_assert(stco || co64);
+  /* sample time */
+  stts = qtdemux_tree_get_child_by_type(stbl, FOURCC_stts);
+  g_assert(stts);
+
+  sample_size = QTDEMUX_GUINT32_GET(stsz->data+12);
+  if(sample_size == 0){
+    n_samples = QTDEMUX_GUINT32_GET(stsz->data+16);
+    stream->n_samples = n_samples;
+    samples = g_malloc(sizeof(QtDemuxSample)*n_samples);
+    stream->samples = samples;
+
+    for(i=0;i<n_samples;i++){
+      samples[i].size = QTDEMUX_GUINT32_GET(stsz->data + i*4 + 20);
+    }
+    n_samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data+12);
+    index = 0;
+    offset = 16;
+    for(i=0;i<n_samples_per_chunk;i++){
+      int first_chunk, last_chunk;
+      int samples_per_chunk;
+  
+      first_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 0) - 1;
+      if(i==n_samples_per_chunk-1){
+        last_chunk = INT_MAX;
+      }else{
+        last_chunk = QTDEMUX_GUINT32_GET(stsc->data +16 + i*12 + 12) - 1;
+      }
+      samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 4);
+
+      for(j=first_chunk;j<last_chunk;j++){
+        int chunk_offset;
+        if(stco){
+          chunk_offset = QTDEMUX_GUINT32_GET(stco->data + 16 + j*4);
+        }else{
+          chunk_offset = QTDEMUX_GUINT64_GET(co64->data + 16 + j*8);
+        }
+        for(k=0;k<samples_per_chunk;k++){
+	  samples[index].chunk = j;
+	  samples[index].offset = chunk_offset;
+	  chunk_offset += samples[index].size;
+	  index++;
+	  if(index>=n_samples)goto done;
+        }
+      }
+    }
+done:
+    
+    n_sample_times = QTDEMUX_GUINT32_GET(stts->data + 12);
+    timestamp = 0;
+    index = 0;
+    for(i=0;i<n_sample_times;i++){
+      int n;
+      int duration;
+      guint64 time;
+  
+      n = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i);
+      duration = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i + 4);
+      time = (GST_SECOND * duration)/stream->timescale;
+      for(j=0;j<n;j++){
+        samples[index].timestamp = timestamp;
+        timestamp += time;
+        index++;
+      }
+    }
+  }else{
+    g_print("treating chunks as samples\n");
+
+    /* treat chunks as samples */
+    if(stco){
+      n_samples = QTDEMUX_GUINT32_GET(stco->data+12);
+    }else{
+      n_samples = QTDEMUX_GUINT32_GET(co64->data+12);
+    }
+    stream->n_samples = n_samples;
+    samples = g_malloc(sizeof(QtDemuxSample)*n_samples);
+    stream->samples = samples;
+
+    n_samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data+12);
+    offset = 16;
+    sample_index = 0;
+    for(i=0;i<n_samples_per_chunk;i++){
+      int first_chunk, last_chunk;
+      int samples_per_chunk;
+  
+      first_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 0) - 1;
+      if(i==n_samples-1){
+        last_chunk = INT_MAX;
+      }else{
+        last_chunk = QTDEMUX_GUINT32_GET(stsc->data +16 + i*12 + 12) - 1;
+      }
+      samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 4);
+
+      for(j=first_chunk;j<last_chunk;j++){
+        int chunk_offset;
+        if(stco){
+          chunk_offset = QTDEMUX_GUINT32_GET(stco->data + 16 + j*4);
+        }else{
+          chunk_offset = QTDEMUX_GUINT64_GET(co64->data + 16 + j*8);
+        }
+	samples[j].chunk = j;
+	samples[j].offset = chunk_offset;
+	samples[j].size = samples_per_chunk; /* FIXME */
+	samples[j].sample_index = sample_index;
+	sample_index += samples_per_chunk;
+	if(j>=n_samples)goto done2;
+      }
     }
+done2:
+
+    n_sample_times = QTDEMUX_GUINT32_GET(stts->data + 12);
+    g_print("n_sample_times = %d\n",n_sample_times);
+    timestamp = 0;
+    index = 0;
+    sample_index = 0;
+    for(i=0;i<n_sample_times;i++){
+      int duration;
+      guint64 time;
+  
+      sample_index += QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i);
+      duration = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i + 4);
+      for(;index < n_samples && samples[index].sample_index < sample_index;index++){
+	int size;
+
+        samples[index].timestamp = timestamp;
+	size = samples[index+1].sample_index - samples[index].sample_index;
+	time = (GST_SECOND * duration * samples[index].size)/stream->timescale ;
+        timestamp += time;
+      }
+    }
+  }
+
+
+  for(i=0;i<n_samples;i++){
+    g_print("%d: %d %d %d %d %" G_GUINT64_FORMAT "\n",i,
+	samples[i].sample_index,samples[i].chunk,
+	samples[i].offset, samples[i].size, samples[i].timestamp);
+    if(i>10)break;
+  }
+
+  gst_qtdemux_add_stream(qtdemux,stream);
+}
+
+
+static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc)
+{
+  switch(fourcc){
+    case GST_MAKE_FOURCC('3','I','V','1'):
+      return GST_CAPS_NEW("3IV1_caps","video/x-quicktime-3IV1",NULL);
+    case GST_MAKE_FOURCC('j','p','e','g'):
+      /* JPEG */
+      return GST_CAPS_NEW("jpeg_caps","video/jpeg",NULL);
+    case GST_MAKE_FOURCC('m','j','p','a'):
+      /* Motion-JPEG (format A) */
+      return GST_CAPS_NEW("mjpa_caps","video/x-mjpeg",NULL);
+    case GST_MAKE_FOURCC('m','j','p','b'):
+      /* Motion-JPEG (format B) */
+      return GST_CAPS_NEW("mjpa_caps","video/x-mjpeg",NULL);
+    case GST_MAKE_FOURCC('S','V','Q','3'):
+      return GST_CAPS_NEW("SVQ3_caps","video/x-svq",
+	  "svqversion", GST_PROPS_INT(3),NULL);
+    case GST_MAKE_FOURCC('s','v','q','i'):
+    case GST_MAKE_FOURCC('S','V','Q','1'):
+      return GST_CAPS_NEW("SVQ1_caps","video/x-svq",
+	  "svqversion", GST_PROPS_INT(1),NULL);
+    case GST_MAKE_FOURCC('r','a','w',' '):
+      /* uncompressed RGB */
+      return GST_CAPS_NEW("raw__caps","video/raw",
+	  "format",GST_PROPS_FOURCC(GST_MAKE_FOURCC('R','G','B',' ')),
+	  "width",GST_PROPS_INT_RANGE(1,G_MAXINT),
+	  "height",GST_PROPS_INT_RANGE(1,G_MAXINT));
+    case GST_MAKE_FOURCC('Y','u','v','2'):
+      /* uncompressed YUV2 */
+      return GST_CAPS_NEW("Yuv2_caps","video/raw",
+	  "format",GST_PROPS_FOURCC(GST_MAKE_FOURCC('Y','U','V','2')),
+	  "width",GST_PROPS_INT_RANGE(1,G_MAXINT),
+	  "height",GST_PROPS_INT_RANGE(1,G_MAXINT));
+    case GST_MAKE_FOURCC('m','p','e','g'):
+      /* MPEG */
+      return GST_CAPS_NEW("mpeg_caps","video/mpeg",NULL);
+    case GST_MAKE_FOURCC('g','i','f',' '):
+      return GST_CAPS_NEW("gif__caps","image/gif",NULL);
+    case GST_MAKE_FOURCC('m','p','4','v'):
+      /* MPEG-4 */
+      return NULL;
+      //return GST_CAPS_NEW("mp4v_caps", "video/mpeg",NULL);
+    case GST_MAKE_FOURCC('r','p','z','a'):
+    case GST_MAKE_FOURCC('c','v','i','d'):
+      /* Cinepak */
+    case GST_MAKE_FOURCC('r','l','e',' '):
+    case GST_MAKE_FOURCC('s','m','c',' '):
+    case GST_MAKE_FOURCC('k','p','c','d'):
+    default:
+      g_print("Don't know how to convert fourcc '" GST_FOURCC_FORMAT
+	  "' to caps\n", GST_FOURCC_ARGS(fourcc));
+      return NULL;
   }
-  return FALSE; /* == keep going (TRUE to stop) */
 }
 
-static void
-gst_qtp_mdat_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) 
+static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc)
 {
-  /* actually playing */
-  g_tree_foreach(qtdemux->samples,gst_qtp_traverse,qtdemux);
+  switch(fourcc){
+    case GST_MAKE_FOURCC('N','O','N','E'):
+      return GST_CAPS_NEW("NONE_caps","audio/raw",NULL);
+    case GST_MAKE_FOURCC('r','a','w',' '):
+      /* FIXME */
+      return GST_CAPS_NEW("raw__caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(0),
+	  "width",GST_PROPS_INT(8),
+	  "depth",GST_PROPS_INT(8),
+	  "signed",GST_PROPS_BOOLEAN(FALSE),
+	  "rate",GST_PROPS_INT_RANGE(1,G_MAXINT),
+	  "channels",GST_PROPS_INT_RANGE(1,G_MAXINT));
+    case GST_MAKE_FOURCC('t','w','o','s'):
+      /* FIXME */
+      return GST_CAPS_NEW("twos_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(0),
+	  "width",GST_PROPS_INT(16),
+	  "depth",GST_PROPS_INT(16),
+	  "endianness",GST_PROPS_INT(G_BIG_ENDIAN),
+	  "signed",GST_PROPS_BOOLEAN(TRUE));
+    case GST_MAKE_FOURCC('s','o','w','t'):
+      /* FIXME */
+      return GST_CAPS_NEW("sowt_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(0),
+	  "width",GST_PROPS_INT(16),
+	  "depth",GST_PROPS_INT(16),
+	  "endianness",GST_PROPS_INT(G_LITTLE_ENDIAN),
+	  "signed",GST_PROPS_BOOLEAN(TRUE));
+    case GST_MAKE_FOURCC('f','l','6','4'):
+      return GST_CAPS_NEW("fl64_caps","audio/raw",
+	  "format",GST_PROPS_STRING("float"),
+	  "layout",GST_PROPS_STRING("gdouble"));
+    case GST_MAKE_FOURCC('f','l','3','2'):
+      return GST_CAPS_NEW("fl32_caps","audio/raw",
+	  "format",GST_PROPS_STRING("float"),
+	  "layout",GST_PROPS_STRING("gfloat"));
+    case GST_MAKE_FOURCC('i','n','2','4'):
+      /* FIXME */
+      return GST_CAPS_NEW("in24_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(0),
+	  "width",GST_PROPS_INT(24),
+	  "depth",GST_PROPS_INT(32),
+	  "endianness",GST_PROPS_INT(G_BIG_ENDIAN),
+	  "signed",GST_PROPS_BOOLEAN(TRUE));
+    case GST_MAKE_FOURCC('i','n','3','2'):
+      /* FIXME */
+      return GST_CAPS_NEW("in32_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(0),
+	  "width",GST_PROPS_INT(24),
+	  "depth",GST_PROPS_INT(32),
+	  "endianness",GST_PROPS_INT(G_BIG_ENDIAN));
+    case GST_MAKE_FOURCC('u','l','a','w'):
+      /* FIXME */
+      return GST_CAPS_NEW("ulaw_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(2));
+    case GST_MAKE_FOURCC('a','l','a','w'):
+      /* FIXME */
+      return GST_CAPS_NEW("alaw_caps","audio/raw",
+	  "format",GST_PROPS_STRING("int"),
+	  "law", GST_PROPS_INT(1));
+    case 0x6d730002:
+      /* Microsoft ADPCM-ACM code 2 */
+      return GST_CAPS_NEW("msxx_caps","audio/adpcm",NULL);
+    case 0x6d730011:
+      /* FIXME DVI/Intel IMA ADPCM/ACM code 17 */
+      return GST_CAPS_NEW("msxx_caps","audio/adpcm",NULL);
+    case 0x6d730055:
+      /* MPEG layer 3, CBR only (pre QT4.1) */
+    case GST_MAKE_FOURCC('.','m','p','3'):
+      /* MPEG layer 3, CBR & VBR (QT4.1 and later) */
+      return GST_CAPS_NEW("msxx_caps","audio/x-mp3",NULL);
+    case GST_MAKE_FOURCC('d','v','c','a'):
+      /* DV audio */
+    case GST_MAKE_FOURCC('q','t','v','r'):
+      /* ? */
+    case GST_MAKE_FOURCC('Q','D','M','C'):
+      /* QDesign music */
+    case GST_MAKE_FOURCC('Q','D','M','2'):
+      /* QDesign music version 2 (no constant) */
+    case GST_MAKE_FOURCC('M','A','C','3'):
+      /* MACE 3:1 */
+    case GST_MAKE_FOURCC('M','A','C','6'):
+      /* MACE 6:1 */
+    case GST_MAKE_FOURCC('i','m','a','4'):
+      /* ? */
+    case GST_MAKE_FOURCC('Q','c','l','p'):
+      /* QUALCOMM PureVoice */
+    default:
+      g_print("Don't know how to convert fourcc '" GST_FOURCC_FORMAT
+	  "' to caps\n", GST_FOURCC_ARGS(fourcc));
+      return NULL;
+  }
 }
+
diff --git a/gst/qtdemux/qtdemux.h b/gst/qtdemux/qtdemux.h
index fa7e79f99..53af27b7f 100644
--- a/gst/qtdemux/qtdemux.h
+++ b/gst/qtdemux/qtdemux.h
@@ -40,121 +40,34 @@ extern "C" {
 #define GST_IS_QTDEMUX_CLASS(obj) \
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QTDEMUX))
 
-#define GST_QTDEMUX_MAX_AUDIO_PADS	8	
-#define GST_QTDEMUX_MAX_VIDEO_PADS	8	
-
-  /*
-   * smartass macross that turns guint32 into sequence of bytes separated with comma
-   * to be used in printf("%c%c%c%c",GST_FOURCC_TO_CHARSEQ(fourcc)) fashion
-   */
-#define GST_FOURCC_TO_CHARSEQ(f) f&0xff, (f>>8)&0xff , (f>>16)&0xff, f>>24
+#define GST_QTDEMUX_MAX_STREAMS		8
 
 typedef struct _GstQTDemux GstQTDemux;
 typedef struct _GstQTDemuxClass GstQTDemuxClass;
-
-typedef struct {
-  guint64 start;
-  guint64 size; /* if 0, lasts till the end of file */
-  guint32 type;
-} GstQtpAtom;
-
-typedef struct {
-  guint32 size;
-  guint32 type;
-} GstQtpAtomMinHeader;
-
-#define GST_QTP_CONTAINER_ATOM 1
-
-typedef void GstQtpAtomTypeHandler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter);
-
-typedef struct {
-  guint32 flags;
-  GstQtpAtomTypeHandler * handler;
-} GstQtpAtomType;
-
-typedef struct {
-  guint64 offset;
-  guint32 size;
-  guint32 timestamp;
-  struct _GstQtpTrack * track;
-} GstQtpSample;
-
-typedef struct _GstQtpTrack {
-  guint32 format;
-  guint32 width;
-  guint32 height;
-  guint32 time_scale; /* units per second */
-  guint32 sample_duration; /* units in sample */
-
-  /* temporary buffers with sample tables */
-  GstBuffer * stsd, * stts, * stsc, * stsz, * stco;
-
-  /* this track samples in array */
-  GstQtpSample * samples;
-
-  GstPad * pad;
-} GstQtpTrack;
-
-typedef struct {
-  guint32 size;
-  guint32 format;
-  char reserved[6];
-  guint16 dataref;
-} __attribute__((packed)) /* FIXME may it wasn't necessary? */ GstQtpStsdRec;
-
-typedef struct {
-  guint32 size;
-  guint32 format;
-  char reserved[6];
-  guint16 dataref;
-  guint16 version;
-  guint16 rev_level;
-  guint32 vendor;
-  guint32 temporal_quality;
-  guint32 spatial_quality;
-  guint16 width;
-  guint16 height;
-  guint32 hres;
-  guint32 vres;
-  guint32 data_size;
-  guint16 frame_count; /* frames per sample */
-  guint32 compressor_name;
-  guint16 depth;
-  guint16 color_table_id;
-} __attribute__((packed)) /* FIXME may it wasn't necessary? */ GstQtpStsdVideRec;
-
-typedef struct {
-  guint32 count;
-  guint32 duration;
-} GstQtpSttsRec;
-
-typedef struct {
-  guint32 first_chunk;
-  guint32 samples_per_chunk;
-  guint32 sample_desc;
-} GstQtpStscRec;
+typedef struct _QtDemuxStream QtDemuxStream;
 
 struct _GstQTDemux {
   GstElement element;
 
   /* pads */
   GstPad *sinkpad;
-  GstPad *video_pad[GST_QTDEMUX_MAX_VIDEO_PADS];
-  int num_video_pads;
+
+  QtDemuxStream *streams[GST_QTDEMUX_MAX_STREAMS];
+  int n_streams;
+  int n_video_streams;
+  int n_audio_streams;
 
   GstByteStream *bs;
-  guint64 bs_pos; /* current position in bs (coz bs won't tell) */
-
-  /* 
-   * nesting stack: everytime parser reads a header
-   * of a container atom it is added to the stack until 
-   * and removed whenever it's over (read completely)
-   */
-  GSList * nested;
-  int nested_cnt; /* just to make it simpler */
-
-  GList * tracks;
-  GTree * samples; /* samples of all the tracks ordered by the offset */
+
+  GNode *moov_node;
+
+  guint32 timescale;
+  guint32 duration;
+
+  int state;
+
+  /* track stuff */
+
 };
 
 struct _GstQTDemuxClass {