put dv demuxing code around ifdef
[libav.git] / libavformat / mov.c
index 71043c6..cb28dbb 100644 (file)
@@ -22,8 +22,9 @@
 //#define DEBUG
 
 #include "avformat.h"
-#include "avi.h"
-#include "mov.h"
+#include "riff.h"
+#include "isom.h"
+#include "dv.h"
 
 #ifdef CONFIG_ZLIB
 #include <zlib.h>
 #undef NDEBUG
 #include <assert.h>
 
-/* Allows seeking */
-#define MOV_SEEK
-
-/* Special handling for movies created with Minolta Dimaxe Xi*/
-/* this fix should not interfere with other .mov files, but just in case*/
-#define MOV_MINOLTA_FIX
-
-/* some streams in QT (and in MP4 mostly) aren't either video nor audio */
-/* so we first list them as this, then clean up the list of streams we give back, */
-/* getting rid of these */
-#define CODEC_TYPE_MOV_OTHER    (enum CodecType) 2
-
-/* http://gpac.sourceforge.net/tutorial/mediatypes.htm */
-const CodecTag ff_mov_obj_type[] = {
-    { CODEC_ID_MPEG4     ,  32 },
-    { CODEC_ID_H264      ,  33 },
-    { CODEC_ID_AAC       ,  64 },
-    { CODEC_ID_MPEG2VIDEO,  96 }, /* MPEG2 Simple */
-    { CODEC_ID_MPEG2VIDEO,  97 }, /* MPEG2 Main */
-    { CODEC_ID_MPEG2VIDEO,  98 }, /* MPEG2 SNR */
-    { CODEC_ID_MPEG2VIDEO,  99 }, /* MPEG2 Spatial */
-    { CODEC_ID_MPEG2VIDEO, 100 }, /* MPEG2 High */
-    { CODEC_ID_MPEG2VIDEO, 101 }, /* MPEG2 422 */
-    { CODEC_ID_AAC       , 102 }, /* MPEG2 AAC Main */
-    { CODEC_ID_AAC       , 103 }, /* MPEG2 AAC Low */
-    { CODEC_ID_AAC       , 104 }, /* MPEG2 AAC SSR */
-    { CODEC_ID_MP3       , 105 },
-    { CODEC_ID_MPEG1VIDEO, 106 },
-    { CODEC_ID_MP2       , 107 },
-    { CODEC_ID_MJPEG     , 108 },
-    { CODEC_ID_PCM_S16LE , 224 },
-    { CODEC_ID_VORBIS    , 221 },
-    { CODEC_ID_AC3       , 226 },
-    { CODEC_ID_PCM_ALAW  , 227 },
-    { CODEC_ID_PCM_MULAW , 228 },
-    { CODEC_ID_PCM_S16BE , 230 },
-    { CODEC_ID_H263      , 242 },
-    { CODEC_ID_H261      , 243 },
-    { 0, 0 },
-};
-
 static const CodecTag mov_video_tags[] = {
 /*  { CODEC_ID_, MKTAG('c', 'v', 'i', 'd') }, *//* Cinepak */
 /*  { CODEC_ID_H263, MKTAG('r', 'a', 'w', ' ') }, *//* Uncompressed RGB */
@@ -116,7 +76,7 @@ static const CodecTag mov_video_tags[] = {
     { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */
     { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */
     { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */
-    { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
+    { CODEC_ID_MJPEGB, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
     { CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */
 /*    { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, *//* MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */
 /*    { CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, *//* embedded gif files as frames (usually one "click to play movie" frame) */
@@ -134,7 +94,6 @@ static const CodecTag mov_video_tags[] = {
     { CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */
     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */
     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */
-/*    { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, *//* AVID dv */
     { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */
     { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */
     { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */
@@ -156,24 +115,25 @@ static const CodecTag mov_video_tags[] = {
     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC produced by FCP */
     { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, /* AVID DV */
     //{ CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') }, /* JPEG 2000 produced by FCP */
+    { CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') }, /* UNCOMPRESSED 8BIT 4:2:2 */
     { CODEC_ID_NONE, 0 },
 };
 
 static const CodecTag mov_audio_tags[] = {
     { CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') },
     { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') },
-/*    { CODEC_ID_PCM_S16BE, MKTAG('N', 'O', 'N', 'E') }, *//* uncompressed */
+    { CODEC_ID_PCM_S16BE, MKTAG('N', 'O', 'N', 'E') }, /* uncompressed */
     { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') }, /* 16 bits */
-    /* { CODEC_ID_PCM_S8, MKTAG('t', 'w', 'o', 's') },*/ /* 8 bits */
     { CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') }, /* 8 bits unsigned */
     { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') }, /*  */
     { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') }, /*  */
     { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') }, /*  */
     { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') }, /* IMA-4 ADPCM */
+    { CODEC_ID_ADPCM_MS, MKTAG('m', 's', 0x00, 0x02) }, /* MS ADPCM */
     { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') }, /* Macintosh Audio Compression and Expansion 3:1 */
     { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') }, /* Macintosh Audio Compression and Expansion 6:1 */
 
-    { CODEC_ID_MP2, MKTAG('.', 'm', 'p', '3') }, /* MPEG layer 3 */ /* sample files at http://www.3ivx.com/showcase.html use this tag */
+    { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') }, /* MPEG layer 3 */ /* sample files at http://www.3ivx.com/showcase.html use this tag */
     { CODEC_ID_MP2, 0x6D730055 }, /* MPEG layer 3 */
     { CODEC_ID_MP2, 0x5500736D }, /* MPEG layer 3 *//* XXX: check endianness */
 /*    { CODEC_ID_OGG_VORBIS, MKTAG('O', 'g', 'g', 'S') }, *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
@@ -185,35 +145,11 @@ static const CodecTag mov_audio_tags[] = {
     { CODEC_ID_AC3, MKTAG('m', 's', 0x20, 0x00) }, /* Dolby AC-3 */
     { CODEC_ID_ALAC,MKTAG('a', 'l', 'a', 'c') }, /* Apple Lossless */
     { CODEC_ID_QDM2,MKTAG('Q', 'D', 'M', '2') }, /* QDM2 */
+    { CODEC_ID_DVAUDIO, MKTAG('v', 'd', 'v', 'a') },
+    { CODEC_ID_DVAUDIO, MKTAG('d', 'v', 'c', 'a') },
     { CODEC_ID_NONE, 0 },
 };
 
-/* map numeric codes from mdhd atom to ISO 639 */
-/* cf. QTFileFormat.pdf p253, qtff.pdf p205 */
-/* http://developer.apple.com/documentation/mac/Text/Text-368.html */
-/* deprecated by putting the code as 3*5bit ascii */
-static const char *mov_mdhd_language_map[] = {
-/* 0-9 */
-"eng", "fra", "ger", "ita", "dut", "sve", "spa", "dan", "por", "nor",
-"heb", "jpn", "ara", "fin", "gre", "ice", "mlt", "tur", "hr "/*scr*/, "chi"/*ace?*/,
-"urd", "hin", "tha", "kor", "lit", "pol", "hun", "est", "lav",  NULL,
-"fo ",  NULL, "rus", "chi",  NULL, "iri", "alb", "ron", "ces", "slk",
-"slv", "yid", "sr ", "mac", "bul", "ukr", "bel", "uzb", "kaz", "aze",
-/*?*/
-"aze", "arm", "geo", "mol", "kir", "tgk", "tuk", "mon",  NULL, "pus",
-"kur", "kas", "snd", "tib", "nep", "san", "mar", "ben", "asm", "guj",
-"pa ", "ori", "mal", "kan", "tam", "tel",  NULL, "bur", "khm", "lao",
-/*                   roman? arabic? */
-"vie", "ind", "tgl", "may", "may", "amh", "tir", "orm", "som", "swa",
-/*==rundi?*/
- NULL, "run",  NULL, "mlg", "epo",  NULL,  NULL,  NULL,  NULL,  NULL,
-/* 100 */
- NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
- NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
- NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL, "wel", "baq",
-"cat", "lat", "que", "grn", "aym", "tat", "uig", "dzo", "jav"
-};
-
 /* the QuickTime file format is quite convoluted...
  * it has lots of index tables, each indexing something in another one...
  * Here we just use what is needed to read the chunks
@@ -238,6 +174,11 @@ typedef struct {
     void* clrs;
 } MOV_ctab_t;
 
+typedef struct MOV_mdat_atom_s {
+    offset_t offset;
+    int64_t size;
+} MOV_mdat_atom_t;
+
 typedef struct {
     uint8_t  version;
     uint32_t flags; // 24bit
@@ -290,7 +231,6 @@ struct MOVParseTableEntry;
 
 typedef struct MOVStreamContext {
     int ffindex; /* the ffmpeg stream id */
-    int is_ff_stream; /* Is this stream presented to ffmpeg ? i.e. is this an audio or video stream ? */
     long next_chunk;
     long chunk_count;
     int64_t *chunk_offsets;
@@ -301,10 +241,6 @@ typedef struct MOVStreamContext {
     int edit_count;             /* number of 'edit' (elst atom) */
     long sample_to_chunk_sz;
     MOV_sample_to_chunk_tbl *sample_to_chunk;
-    long sample_to_chunk_index;
-    int sample_to_time_index;
-    long sample_to_time_sample;
-    uint64_t sample_to_time_time;
     int sample_to_ctime_index;
     int sample_to_ctime_sample;
     long sample_size;
@@ -315,8 +251,9 @@ typedef struct MOVStreamContext {
     int time_scale;
     int time_rate;
     long current_sample;
-    long left_in_chunk; /* how many samples before next chunk */
     MOV_esds_t esds;
+    AVRational sample_size_v1;
+    int dv_audio_container;
 } MOVStreamContext;
 
 typedef struct MOVContext {
@@ -328,21 +265,22 @@ typedef struct MOVContext {
     int found_mdat; /* we suppose we have enough data to read the file */
     int64_t mdat_size;
     int64_t mdat_offset;
-    int ni;                                         ///< non interleaved mode
     int total_streams;
     /* some streams listed here aren't presented to the ffmpeg API, since they aren't either video nor audio
      * but we need the info to be able to skip data from those streams in the 'mdat' section
      */
     MOVStreamContext *streams[MAX_STREAMS];
 
-    int64_t next_chunk_offset;
-    MOVStreamContext *partial; /* != 0 : there is still to read in the current chunk */
     int ctab_size;
     MOV_ctab_t **ctab;           /* color tables */
     const struct MOVParseTableEntry *parse_table; /* could be eventually used to change the table */
     /* NOTE: for recursion save to/ restore from local variable! */
 
     AVPaletteControl palette_control;
+    MOV_mdat_atom_t *mdat_list;
+    int mdat_count;
+    DVDemuxContext *dv_demux;
+    AVFormatContext *dv_fctx;
 } MOVContext;
 
 
@@ -362,55 +300,6 @@ typedef struct MOVParseTableEntry {
     mov_parse_function func;
 } MOVParseTableEntry;
 
-static int ff_mov_lang_to_iso639(int code, char *to)
-{
-    int i;
-    /* is it the mangled iso code? */
-    /* see http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt */
-    if (code > 138) {
-        for (i = 2; i >= 0; i--) {
-            to[i] = 0x60 + (code & 0x1f);
-            code >>= 5;
-        }
-        return 1;
-    }
-    /* old fashion apple lang code */
-    if (code >= (sizeof(mov_mdhd_language_map)/sizeof(char *)))
-        return 0;
-    if (!mov_mdhd_language_map[code])
-        return 0;
-    strncpy(to, mov_mdhd_language_map[code], 4);
-    return 1;
-}
-
-int ff_mov_iso639_to_lang(const char *lang, int mp4)
-{
-    int i, code = 0;
-
-    /* old way, only for QT? */
-    for (i = 0; !mp4 && (i < (sizeof(mov_mdhd_language_map)/sizeof(char *))); i++) {
-        if (mov_mdhd_language_map[i] && !strcmp(lang, mov_mdhd_language_map[i]))
-            return i;
-    }
-    /* XXX:can we do that in mov too? */
-    if (!mp4)
-        return 0;
-    /* handle undefined as such */
-    if (lang[0] == '\0')
-        lang = "und";
-    /* 5bit ascii */
-    for (i = 0; i < 3; i++) {
-        unsigned char c = (unsigned char)lang[i];
-        if (c < 0x60)
-            return 0;
-        if (c > 0x60 + 0x1f)
-            return 0;
-        code <<= 5;
-        code |= (c - 0x60);
-    }
-    return code;
-}
-
 static int mov_read_leaf(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
 {
     if (atom.size>1)
@@ -597,6 +486,7 @@ static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
         sc->esds.avg_bitrate = get_be32(pb);
 
         st->codec->codec_id= codec_get_id(ff_mov_obj_type, sc->esds.object_type_id);
+        dprintf("esds object type id %d\n", sc->esds.object_type_id);
         len = mov_mp4_read_descr(pb, &tag);
         if (tag == MP4DecSpecificDescrTag) {
             dprintf("Specific MPEG4 header len=%d\n", len);
@@ -619,6 +509,10 @@ static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
 {
     if(atom.size == 0) /* wrong one (MP4) */
         return 0;
+    c->mdat_list = av_realloc(c->mdat_list, (c->mdat_count + 1) * sizeof(*c->mdat_list));
+    c->mdat_list[c->mdat_count].offset = atom.offset;
+    c->mdat_list[c->mdat_count].size = atom.size;
+    c->mdat_count++;
     c->found_mdat=1;
     c->mdat_offset = atom.offset;
     c->mdat_size = atom.size;
@@ -896,15 +790,6 @@ static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
     } else
         return -1;
 
-    for(i=0; i<c->fc->nb_streams; i++){
-        MOVStreamContext *sc2 = (MOVStreamContext *)c->fc->streams[i]->priv_data;
-        if(sc2 && sc2->chunk_offsets){
-            int64_t first= sc2->chunk_offsets[0];
-            int64_t last= sc2->chunk_offsets[sc2->chunk_count-1];
-            if(first >= sc->chunk_offsets[entries-1] || last <= sc->chunk_offsets[0])
-                c->ni=1;
-        }
-    }
     return 0;
 }
 
@@ -944,15 +829,17 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
         get_be16(pb); /* reserved */
         get_be16(pb); /* index */
 
-        dprintf("size=%d 4CC= %c%c%c%c codec_type=%d\n",
-                size,
-                (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, (format >> 24) & 0xff,
-                st->codec->codec_type);
+        if (st->codec->codec_tag) {
+            /* multiple fourcc, just skip for now */
+            url_fskip(pb, size - (url_ftell(pb) - start_pos));
+            continue;
+        }
+
         st->codec->codec_tag = format;
         id = codec_get_id(mov_audio_tags, format);
         if (id > 0) {
             st->codec->codec_type = CODEC_TYPE_AUDIO;
-        } else if (format != MKTAG('m', 'p', '4', 's')) { /* skip old asf mpeg4 tag */
+        } else if (format && format != MKTAG('m', 'p', '4', 's')) { /* skip old asf mpeg4 tag */
             id = codec_get_id(mov_video_tags, format);
             if (id <= 0)
                 id = codec_get_id(codec_bmp_tags, format);
@@ -960,6 +847,11 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
                 st->codec->codec_type = CODEC_TYPE_VIDEO;
         }
 
+        dprintf("size=%d 4CC= %c%c%c%c codec_type=%d\n",
+                size,
+                (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, (format >> 24) & 0xff,
+                st->codec->codec_type);
+
         if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
             st->codec->codec_id = id;
             get_be16(pb); /* version */
@@ -987,11 +879,6 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
             st->codec->bits_per_sample = get_be16(pb); /* depth */
             st->codec->color_table_id = get_be16(pb); /* colortable id */
 
-/*          These are set in mov_read_stts and might already be set!
-            st->codec->time_base.den      = 25;
-            st->codec->time_base.num = 1;
-*/
-
             /* figure out the palette situation */
             color_depth = st->codec->bits_per_sample & 0x1F;
             color_greyscale = st->codec->bits_per_sample & 0x20;
@@ -1062,6 +949,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
             } else
                 st->codec->palctrl = NULL;
         } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) {
+            int bits_per_sample;
             uint16_t version = get_be16(pb);
 
             st->codec->codec_id = id;
@@ -1069,6 +957,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
             get_be32(pb); /* vendor */
 
             st->codec->channels = get_be16(pb);             /* channel count */
+            dprintf("audio channels %d\n", st->codec->channels);
             st->codec->bits_per_sample = get_be16(pb);      /* sample size */
             /* do we need to force to 16 for AMR ? */
 
@@ -1079,16 +968,15 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
             st->codec->sample_rate = ((get_be32(pb) >> 16));
 
             switch (st->codec->codec_id) {
+            case CODEC_ID_PCM_S8:
+            case CODEC_ID_PCM_U8:
+                if (st->codec->bits_per_sample == 16)
+                    st->codec->codec_id = CODEC_ID_PCM_S16BE;
+                break;
             case CODEC_ID_PCM_S16LE:
             case CODEC_ID_PCM_S16BE:
                 if (st->codec->bits_per_sample == 8)
                     st->codec->codec_id = CODEC_ID_PCM_S8;
-                st->codec->bit_rate = st->codec->sample_rate * 8;
-                break;
-            case CODEC_ID_PCM_U8:
-                if (st->codec->bits_per_sample == 16)
-                    st->codec->codec_id = CODEC_ID_PCM_S16BE;
-                st->codec->bit_rate = st->codec->sample_rate * 8;
                 break;
             case CODEC_ID_AMR_WB:
                 st->codec->sample_rate = 16000; /* should really we ? */
@@ -1102,12 +990,18 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
                 break;
             }
 
+            bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
+            if (bits_per_sample) {
+                st->codec->bits_per_sample = bits_per_sample;
+                sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
+            }
+
             //Read QT version 1 fields. In version 0 theese dont exist
             dprintf("version =%d mp4=%d\n",version,c->mp4);
             if(version==1) {
-                get_be32(pb); /* samples per packet */
+                sc->sample_size_v1.den = get_be32(pb); /* samples per packet */
                 get_be32(pb); /* bytes per packet */
-                get_be32(pb); /* bytes per frame */
+                sc->sample_size_v1.num = get_be32(pb); /* bytes per frame */
                 get_be32(pb); /* bytes per sample */
             } else if(version==2) {
                 get_be32(pb); /* sizeof struct only */
@@ -1145,6 +1039,18 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
     case CODEC_ID_MP3ON4:
         st->codec->sample_rate= 0; /* let decoder init parameters properly */
         break;
+#ifdef CONFIG_DV_DEMUXER
+    case CODEC_ID_DVAUDIO:
+        c->dv_fctx = av_alloc_format_context();
+        c->dv_demux = dv_init_demux(c->dv_fctx);
+        if (!c->dv_demux) {
+            av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
+            return -1;
+        }
+        sc->dv_audio_container = 1;
+        st->codec->codec_id = CODEC_ID_PCM_S16LE;
+        break;
+#endif
     default:
         break;
     }
@@ -1215,47 +1121,25 @@ static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
 {
     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
-    unsigned int i, entries;
+    unsigned int i, entries, sample_size;
 
     get_byte(pb); /* version */
     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
 
-    sc->sample_size = get_be32(pb);
+    sample_size = get_be32(pb);
+    if (!sc->sample_size) /* do not overwrite value computed in stsd */
+        sc->sample_size = sample_size;
     entries = get_be32(pb);
     if(entries >= UINT_MAX / sizeof(long))
         return -1;
 
     sc->sample_count = entries;
+    if (sample_size)
+        return 0;
+
 #ifdef DEBUG
     av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
 #endif
-    if(sc->sample_size) {
-        /* override sample size for uncompressed sound */
-        switch (st->codec->codec_id) {
-        case CODEC_ID_PCM_S32BE:
-        case CODEC_ID_PCM_S32LE:
-            sc->sample_size = 4 * st->codec->channels;
-            break;
-        case CODEC_ID_PCM_S24BE:
-        case CODEC_ID_PCM_S24LE:
-            sc->sample_size = 3 * st->codec->channels;
-            break;
-        case CODEC_ID_PCM_S16BE:
-        case CODEC_ID_PCM_S16LE:
-            sc->sample_size = 2 * st->codec->channels;
-            break;
-        case CODEC_ID_PCM_MULAW:
-        case CODEC_ID_PCM_ALAW:
-        case CODEC_ID_PCM_S8:
-        case CODEC_ID_PCM_U8:
-            sc->sample_size = 1 * st->codec->channels;
-            break;
-        default:
-            break;
-        }
-        assert(sc->sample_size);
-        return 0; /* there isn't any table following */
-    }
     sc->sample_sizes = (long*) av_malloc(entries * sizeof(long));
     if (!sc->sample_sizes)
         return -1;
@@ -1362,9 +1246,8 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
         return -1;
     }
 
-    sc->sample_to_chunk_index = -1;
     st->priv_data = sc;
-    st->codec->codec_type = CODEC_TYPE_MOV_OTHER;
+    st->codec->codec_type = CODEC_TYPE_DATA;
     st->start_time = 0; /* XXX: check */
     c->streams[c->fc->nb_streams-1] = sc;
 
@@ -1407,8 +1290,8 @@ static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
     url_fskip(pb, 36); /* display matrix */
 
     /* those are fixed-point */
-    /*st->codec->width =*/ get_be32(pb) >> 16; /* track width */
-    /*st->codec->height =*/ get_be32(pb) >> 16; /* track height */
+    get_be32(pb); /* track width */
+    get_be32(pb); /* track height */
 
     return 0;
 }
@@ -1597,26 +1480,11 @@ static const MOVParseTableEntry mov_default_parse_table[] = {
 static void mov_free_stream_context(MOVStreamContext *sc)
 {
     if(sc) {
-        av_freep(&sc->chunk_offsets);
-        av_freep(&sc->sample_to_chunk);
-        av_freep(&sc->sample_sizes);
-        av_freep(&sc->keyframes);
-        av_freep(&sc->stts_data);
         av_freep(&sc->ctts_data);
         av_freep(&sc);
     }
 }
 
-static inline uint32_t mov_to_tag(uint8_t *buf)
-{
-    return MKTAG(buf[0], buf[1], buf[2], buf[3]);
-}
-
-static inline uint32_t to_be32(uint8_t *buf)
-{
-    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
-}
-
 /* XXX: is it sufficient ? */
 static int mov_probe(AVProbeData *p)
 {
@@ -1632,7 +1500,7 @@ static int mov_probe(AVProbeData *p)
         /* ignore invalid offset */
         if ((offset + 8) > (unsigned int)p->buf_size)
             return score;
-        tag = mov_to_tag(p->buf + offset + 4);
+        tag = LE_32(p->buf + offset + 4);
         switch(tag) {
         /* check for obvious tags */
         case MKTAG( 'j', 'P', ' ', ' ' ): /* jpeg 2000 signature */
@@ -1650,7 +1518,7 @@ static int mov_probe(AVProbeData *p)
         case MKTAG( 'f', 't', 'y', 'p' ):
         case MKTAG( 's', 'k', 'i', 'p' ):
         case MKTAG( 'u', 'u', 'i', 'd' ):
-            offset = to_be32(p->buf+offset) + offset;
+            offset = BE_32(p->buf+offset) + offset;
             /* if we only find those cause probedata is too small at least rate them */
             score = AVPROBE_SCORE_MAX - 50;
             break;
@@ -1662,11 +1530,121 @@ static int mov_probe(AVProbeData *p)
     return score;
 }
 
+static void mov_build_index(MOVContext *mov, AVStream *st)
+{
+    MOVStreamContext *sc = st->priv_data;
+    offset_t current_offset;
+    int64_t current_dts = 0;
+    int stts_index = 0;
+    int stsc_index = 0;
+    int stss_index = 0;
+    int i, j, k;
+
+    if (sc->sample_sizes || st->codec->codec_type == CODEC_TYPE_VIDEO || sc->dv_audio_container) {
+        int keyframe, sample_size;
+        int current_sample = 0;
+        int stts_sample = 0;
+        int distance = 0;
+
+        st->nb_frames = sc->sample_count;
+        for (i = 0; i < sc->chunk_count; i++) {
+            current_offset = sc->chunk_offsets[i];
+            if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first)
+                stsc_index++;
+            for (j = 0; j < sc->sample_to_chunk[stsc_index].count; j++) {
+                keyframe = !sc->keyframe_count || current_sample + 1 == sc->keyframes[stss_index];
+                if (keyframe) {
+                    distance = 0;
+                    if (stss_index + 1 < sc->keyframe_count)
+                        stss_index++;
+                }
+                sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
+                dprintf("AVIndex stream %d, sample %d, offset %llx, dts %lld, size %d, distance %d, keyframe %d\n",
+                        st->index, current_sample, current_offset, current_dts, sample_size, distance, keyframe);
+                av_add_index_entry(st, current_offset, current_dts, sample_size, distance, keyframe ? AVINDEX_KEYFRAME : 0);
+                current_offset += sample_size;
+                assert(sc->stts_data[stts_index].duration % sc->time_rate == 0);
+                current_dts += sc->stts_data[stts_index].duration / sc->time_rate;
+                distance++;
+                stts_sample++;
+                if (current_sample + 1 < sc->sample_count)
+                    current_sample++;
+                if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
+                    stts_sample = 0;
+                    stts_index++;
+                }
+            }
+        }
+    } else { /* read whole chunk */
+        int chunk_samples, chunk_size, chunk_duration;
+
+        for (i = 0; i < sc->chunk_count; i++) {
+            current_offset = sc->chunk_offsets[i];
+            if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first)
+                stsc_index++;
+            chunk_samples = sc->sample_to_chunk[stsc_index].count;
+            /* get chunk size */
+            if (sc->sample_size > 1 || st->codec->bits_per_sample == 8)
+                chunk_size = chunk_samples * sc->sample_size;
+            else if (sc->sample_size_v1.den > 0 && (chunk_samples * sc->sample_size_v1.num % sc->sample_size_v1.den == 0))
+                chunk_size = chunk_samples * sc->sample_size_v1.num / sc->sample_size_v1.den;
+            else { /* workaround to find nearest next chunk offset */
+                chunk_size = INT_MAX;
+                for (j = 0; j < mov->total_streams; j++) {
+                    MOVStreamContext *msc = mov->streams[j];
+
+                    for (k = msc->next_chunk; k < msc->chunk_count; k++) {
+                        if (msc->chunk_offsets[k] > current_offset && msc->chunk_offsets[k] - current_offset < chunk_size) {
+                            chunk_size = msc->chunk_offsets[k] - current_offset;
+                            msc->next_chunk = k;
+                            break;
+                        }
+                    }
+                }
+                /* check for last chunk */
+                if (chunk_size == INT_MAX)
+                    for (j = 0; j < mov->mdat_count; j++) {
+                        dprintf("mdat %d, offset %llx, size %lld, current offset %llx\n",
+                                j, mov->mdat_list[j].offset, mov->mdat_list[j].size, current_offset);
+                        if (mov->mdat_list[j].offset <= current_offset && mov->mdat_list[j].offset + mov->mdat_list[j].size > current_offset)
+                            chunk_size = mov->mdat_list[j].offset + mov->mdat_list[j].size - current_offset;
+                    }
+                assert(chunk_size != INT_MAX);
+                for (j = 0; j < mov->total_streams; j++) {
+                    mov->streams[j]->next_chunk = 0;
+                }
+            }
+            av_add_index_entry(st, current_offset, current_dts, chunk_size, 0, AVINDEX_KEYFRAME);
+            /* get chunk duration */
+            chunk_duration = 0;
+            while (chunk_samples > 0) {
+                if (chunk_samples < sc->stts_data[stts_index].count) {
+                    chunk_duration += sc->stts_data[stts_index].duration * chunk_samples;
+                    sc->stts_data[stts_index].count -= chunk_samples;
+                    break;
+                } else {
+                    chunk_duration += sc->stts_data[stts_index].duration * chunk_samples;
+                    chunk_samples -= sc->stts_data[stts_index].count;
+                    if (stts_index + 1 < sc->stts_count) {
+                        stts_index++;
+                    }
+                }
+            }
+            dprintf("AVIndex stream %d, chunk %d, offset %llx, dts %lld, size %d, duration %d\n",
+                    st->index, i, current_offset, current_dts, chunk_size, chunk_duration);
+            assert(chunk_duration % sc->time_rate == 0);
+            current_dts += chunk_duration / sc->time_rate;
+        }
+    }
+    /* adjust sample count to avindex entries */
+    sc->sample_count = st->nb_index_entries;
+}
+
 static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
     MOVContext *mov = (MOVContext *) s->priv_data;
     ByteIOContext *pb = &s->pb;
-    int i, j, nb, err;
+    int i, err;
     MOV_atom_t atom = { 0, 0, 0 };
 
     mov->fc = s;
@@ -1690,21 +1668,10 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
     if(!url_is_streamed(pb) && (url_ftell(pb) != mov->mdat_offset))
         url_fseek(pb, mov->mdat_offset, SEEK_SET);
 
-    mov->next_chunk_offset = mov->mdat_offset; /* initialise reading */
-    mov->total_streams = nb = s->nb_streams;
+    mov->total_streams = s->nb_streams;
 
-#if 1
-    for(i=0; i<s->nb_streams;) {
-        if(s->streams[i]->codec->codec_type == CODEC_TYPE_MOV_OTHER) {/* not audio, not video, delete */
-            av_free(s->streams[i]);
-            for(j=i+1; j<s->nb_streams; j++)
-                s->streams[j-1] = s->streams[j];
-            s->nb_streams--;
-        } else
-            i++;
-    }
-    for(i=0; i<s->nb_streams;i++) {
-        MOVStreamContext *sc = (MOVStreamContext *)s->streams[i]->priv_data;
+    for(i=0; i<mov->total_streams; i++) {
+        MOVStreamContext *sc = mov->streams[i];
 
         if(!sc->time_rate)
             sc->time_rate=1;
@@ -1716,438 +1683,141 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
             assert(s->streams[i]->duration % sc->time_rate == 0);
             s->streams[i]->duration /= sc->time_rate;
         }
-
         sc->ffindex = i;
-        sc->is_ff_stream = 1;
+        mov_build_index(mov, s->streams[i]);
     }
-#endif
+
+    for(i=0; i<mov->total_streams; i++) {
+        /* dont need those anymore */
+        av_freep(&mov->streams[i]->chunk_offsets);
+        av_freep(&mov->streams[i]->sample_to_chunk);
+        av_freep(&mov->streams[i]->sample_sizes);
+        av_freep(&mov->streams[i]->keyframes);
+        av_freep(&mov->streams[i]->stts_data);
+    }
+    av_freep(&mov->mdat_list);
     return 0;
 }
 
-/* Yes, this is ugly... I didn't write the specs of QT :p */
-/* XXX:remove useless commented code sometime */
 static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
-    MOVContext *mov = (MOVContext *) s->priv_data;
-    MOVStreamContext *sc;
-    AVStream *st;
-    int64_t offset = INT64_MAX;
+    MOVContext *mov = s->priv_data;
+    MOVStreamContext *sc = 0;
+    AVIndexEntry *sample = 0;
     int64_t best_dts = INT64_MAX;
-    int i, a, b, m;
-    int next_sample= -99;
-    int size;
-    int idx;
-    size = 0x0FFFFFFF;
-
-    if (mov->partial) {
-        sc = mov->partial;
-        idx = sc->sample_to_chunk_index;
-
-        if (idx < 0) return 0;
-        dprintf("sc[ffid %d]->sample_size = %ld\n", sc->ffindex, sc->sample_size);
-        //size = sc->sample_sizes[sc->current_sample];
-        // that ain't working...
-        //size = (sc->sample_size)?sc->sample_size:sc->sample_sizes[sc->current_sample];
-        size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample];
-
-        next_sample= sc->current_sample+1;
-
-        sc->left_in_chunk--;
-
-        if (sc->left_in_chunk <= 0)
-            mov->partial = 0;
-        offset = mov->next_chunk_offset;
-        /* extract the sample */
-
-        goto readchunk;
-    }
+    int i;
 
-again:
-    sc = 0;
-    if(offset == INT64_MAX)
-        best_dts= INT64_MAX;
-    for(i=0; i<mov->total_streams; i++) {
+    for (i = 0; i < mov->total_streams; i++) {
         MOVStreamContext *msc = mov->streams[i];
 
-        if ((msc->next_chunk < msc->chunk_count) && msc->next_chunk >= 0){
-            if (msc->sample_to_time_index < msc->stts_count && mov->ni) {
-                int64_t dts;
-                int index= msc->sample_to_time_index;
-                int sample= msc->sample_to_time_sample;
-                int time= msc->sample_to_time_time;
-                int duration = msc->stts_data[index].duration;
-                int count = msc->stts_data[index].count;
-                if (sample + count <= msc->current_sample) {
-                    sample += count;
-                    time   += count*duration;
-                    index ++;
-                    duration = msc->stts_data[index].duration;
-                }
-                dts = time + (msc->current_sample - sample) * (int64_t)duration;
-                dts = av_rescale(dts, AV_TIME_BASE, msc->time_scale);
-                dprintf("stream: %d dts: %"PRId64" best_dts: %"PRId64" offset: %"PRId64"\n", i, dts, best_dts, offset);
-                if(dts < best_dts){
-                    best_dts= dts;
-                    sc = msc;
-                    offset = msc->chunk_offsets[msc->next_chunk];
-                }
-            }else{
-                if ((msc->chunk_offsets[msc->next_chunk] < offset)) {
-                    sc = msc;
-                    offset = msc->chunk_offsets[msc->next_chunk];
-                }
+        if (s->streams[i]->discard != AVDISCARD_ALL && msc->current_sample < msc->sample_count) {
+            AVIndexEntry *current_sample = &s->streams[i]->index_entries[msc->current_sample];
+            int64_t dts = av_rescale(current_sample->timestamp * (int64_t)msc->time_rate, AV_TIME_BASE, msc->time_scale);
+
+            dprintf("stream %d, sample %ld, dts %lld\n", i, msc->current_sample, dts);
+            if (dts < best_dts) {
+                sample = current_sample;
+                best_dts = dts;
+                sc = msc;
             }
         }
     }
-    if (!sc || offset==INT64_MAX)
+    if (!sample)
+        return -1;
+    /* must be done just before reading, to avoid infinite loop on sample */
+    sc->current_sample++;
+    if (sample->pos >= url_fsize(&s->pb)) {
+        av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%llx: partial file\n", sc->ffindex, sample->pos);
         return -1;
-
-    sc->next_chunk++;
-
-    if(mov->next_chunk_offset < offset) { /* some meta data */
-        url_fskip(&s->pb, (offset - mov->next_chunk_offset));
-        mov->next_chunk_offset = offset;
-    }
-
-    if(!sc->is_ff_stream || (s->streams[sc->ffindex]->discard >= AVDISCARD_ALL)) {
-        url_fskip(&s->pb, (offset - mov->next_chunk_offset));
-        mov->next_chunk_offset = offset;
-        offset = INT64_MAX;
-        goto again;
-    }
-
-    /* now get the chunk size... */
-
-    for(i=0; i<mov->total_streams; i++) {
-        MOVStreamContext *msc = mov->streams[i];
-        if ((msc->next_chunk < msc->chunk_count)
-            && msc->chunk_offsets[msc->next_chunk] - offset < size
-            && msc->chunk_offsets[msc->next_chunk] > offset)
-            size = msc->chunk_offsets[msc->next_chunk] - offset;
     }
 
-#ifdef MOV_MINOLTA_FIX
-    //Make sure that size is according to sample_size (Needed by .mov files
-    //created on a Minolta Dimage Xi where audio chunks contains waste data in the end)
-    //Maybe we should really not only check sc->sample_size, but also sc->sample_sizes
-    //but I have no such movies
-    if (sc->sample_size > 0) {
-        int foundsize=0;
-        for(i=0; i<(sc->sample_to_chunk_sz); i++) {
-            if( (sc->sample_to_chunk[i].first)<=(sc->next_chunk) )
-            {
-                foundsize=sc->sample_to_chunk[i].count*sc->sample_size;
-            }
-            dprintf("sample_to_chunk first=%ld count=%ld, id=%ld\n", sc->sample_to_chunk[i].first, sc->sample_to_chunk[i].count, sc->sample_to_chunk[i].id);
-        }
-        if( (foundsize>0) && (foundsize<size) )
-        {
-            size=foundsize;
+    if (sc->dv_audio_container) {
+        dv_get_packet(mov->dv_demux, pkt);
+        dprintf("dv audio pkt size %d\n", pkt->size);
+    } else {
+        url_fseek(&s->pb, sample->pos, SEEK_SET);
+        av_get_packet(&s->pb, pkt, sample->size);
+        if (mov->dv_demux) {
+            void *pkt_destruct_func = pkt->destruct;
+            dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);
+            pkt->destruct = pkt_destruct_func;
         }
     }
-#endif //MOV_MINOLTA_FIX
-
-    idx = sc->sample_to_chunk_index;
-    if (idx + 1 < sc->sample_to_chunk_sz && sc->next_chunk >= sc->sample_to_chunk[idx + 1].first)
-        idx++;
-    sc->sample_to_chunk_index = idx;
-    /* split chunks into samples */
-    if (sc->sample_size == 0 || sc->sample_size > 100) {
-        if (idx >= 0 && sc->sample_to_chunk[idx].count != 1) {
-            mov->partial = sc;
-            /* we'll have to get those samples before next chunk */
-            sc->left_in_chunk = sc->sample_to_chunk[idx].count - 1;
-            size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample];
-        }
-
-        next_sample= sc->current_sample+1;
-    }else if(idx < sc->sample_to_chunk_sz){
-        next_sample= sc->current_sample + sc->sample_to_chunk[idx].count;
-    }else
-        next_sample= sc->current_sample;
-
-readchunk:
-    dprintf("chunk: %"PRId64" -> %"PRId64" (%i)\n", offset, offset + size, size);
-    if(size == 0x0FFFFFFF)
-        size = mov->mdat_size + mov->mdat_offset - offset;
-    if(size < 0)
-        return -1;
-    if(size == 0)
-        return -1;
-    url_fseek(&s->pb, offset, SEEK_SET);
-
-    av_get_packet(&s->pb, pkt, size);
     pkt->stream_index = sc->ffindex;
-
-    // If the keyframes table exists, mark any samples that are in the table as key frames.
-    // If no table exists, treat very sample as a key frame.
-    if (sc->keyframes) {
-        a = 0;
-        b = sc->keyframe_count - 1;
-
-        while (a < b) {
-            m = (a + b + 1) >> 1;
-            if (sc->keyframes[m] > sc->current_sample) {
-                b = m - 1;
-            } else {
-                a = m;
-            }
+    pkt->dts = sample->timestamp;
+    if (sc->ctts_data) {
+        assert(sc->ctts_data[sc->sample_to_ctime_index].duration % sc->time_rate == 0);
+        pkt->pts = pkt->dts + sc->ctts_data[sc->sample_to_ctime_index].duration / sc->time_rate;
+        /* update ctts context */
+        sc->sample_to_ctime_sample++;
+        if (sc->sample_to_ctime_index < sc->ctts_count && sc->ctts_data[sc->sample_to_ctime_index].count == sc->sample_to_ctime_sample) {
+            sc->sample_to_ctime_index++;
+            sc->sample_to_ctime_sample = 0;
         }
-
-        if (sc->keyframes[a] == sc->current_sample)
-            pkt->flags |= PKT_FLAG_KEY;
-    }
-    else
-        pkt->flags |= PKT_FLAG_KEY;
-
-    mov->next_chunk_offset = offset + size;
-
-    /* find the corresponding dts */
-    if (sc && sc->sample_to_time_index < sc->stts_count && pkt) {
-      unsigned int count;
-      uint64_t dts, pts;
-      unsigned int duration = sc->stts_data[sc->sample_to_time_index].duration;
-      count = sc->stts_data[sc->sample_to_time_index].count;
-      if ((sc->sample_to_time_sample + count) <= sc->current_sample) {
-        sc->sample_to_time_sample += count;
-        sc->sample_to_time_time   += count*duration;
-        sc->sample_to_time_index ++;
-        duration = sc->stts_data[sc->sample_to_time_index].duration;
-      }
-      dts = sc->sample_to_time_time + (sc->current_sample - sc->sample_to_time_sample) * (int64_t)duration;
-        /* find the corresponding pts */
-        if (sc->sample_to_ctime_index < sc->ctts_count) {
-            int duration = sc->ctts_data[sc->sample_to_ctime_index].duration;
-            int count = sc->ctts_data[sc->sample_to_ctime_index].count;
-
-            if ((sc->sample_to_ctime_sample + count) <= sc->current_sample) {
-                sc->sample_to_ctime_sample += count;
-                sc->sample_to_ctime_index ++;
-                duration = sc->ctts_data[sc->sample_to_ctime_index].duration;
-            }
-            pts = dts + duration;
-        }else
-            pts = dts;
-
-        st= s->streams[ sc->ffindex ];
-        assert(pts % st->time_base.num == 0);
-        assert(dts % st->time_base.num == 0);
-
-        pkt->pts = pts / st->time_base.num;
-        pkt->dts = dts / st->time_base.num;
-        dprintf("stream #%d smp #%ld dts = %"PRId64" pts = %"PRId64" (smp:%ld time:%"PRId64" idx:%d ent:%d count:%d dur:%d)\n"
-                , pkt->stream_index, sc->current_sample-1, pkt->dts, pkt->pts
-                , sc->sample_to_time_sample
-                , sc->sample_to_time_time
-                , sc->sample_to_time_index
-                , sc->stts_count
-                , count
-                , duration);
+    } else {
+        pkt->pts = pkt->dts;
     }
-
-    assert(next_sample>=0);
-    sc->current_sample= next_sample;
-
+    pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0;
+    pkt->pos = sample->pos;
+    dprintf("stream %d, pts %lld, dts %lld, pos 0x%llx, duration %d\n", pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
     return 0;
 }
 
-#if defined(MOV_SEEK)
-/**
- * Seek method based on the one described in the Appendix C of QTFileFormat.pdf
- */
-static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
+static int mov_seek_stream(AVStream *st, int64_t timestamp, int flags)
 {
-    MOVContext* mov = (MOVContext *) s->priv_data;
-    MOVStreamContext* sc;
-    int32_t i, a, b, m;
-    int64_t start_time;
-    int32_t seek_sample, sample;
-    int32_t duration;
-    int32_t count;
-    int32_t chunk;
-    int32_t left_in_chunk;
-    int64_t chunk_file_offset;
-    int64_t sample_file_offset;
-    int32_t first_chunk_sample;
-    int32_t sample_to_chunk_idx;
-    int sample_to_time_index;
-    long sample_to_time_sample = 0;
-    uint64_t sample_to_time_time = 0;
-    int mov_idx;
-
-    // Find the corresponding mov stream
-    for (mov_idx = 0; mov_idx < mov->total_streams; mov_idx++)
-        if (mov->streams[mov_idx]->ffindex == stream_index)
-            break;
-    if (mov_idx == mov->total_streams) {
-        av_log(s, AV_LOG_ERROR, "mov: requested stream was not found in mov streams (idx=%i)\n", stream_index);
+    MOVStreamContext *sc = st->priv_data;
+    int sample, time_sample;
+    int i;
+
+    sample = av_index_search_timestamp(st, timestamp, flags);
+    dprintf("stream %d, timestamp %lld, sample %d\n", st->index, timestamp, sample);
+    if (sample < 0) /* not sure what to do */
         return -1;
+    sc->current_sample = sample;
+    dprintf("stream %d, found sample %ld\n", st->index, sc->current_sample);
+    /* adjust ctts index */
+    if (sc->ctts_data) {
+        time_sample = 0;
+        for (i = 0; i < sc->ctts_count; i++) {
+            time_sample += sc->ctts_data[i].count;
+            if (time_sample >= sc->current_sample) {
+                sc->sample_to_ctime_index = i;
+                sc->sample_to_ctime_sample = time_sample - sc->current_sample;
+                break;
+            }
+        }
     }
-    sc = mov->streams[mov_idx];
+    return sample;
+}
 
-    sample_time *= s->streams[stream_index]->time_base.num;
+static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
+{
+    AVStream *st;
+    int64_t seek_timestamp, timestamp;
+    int sample;
+    int i;
 
-    // Step 1. Find the edit that contains the requested time (elst)
-    if (sc->edit_count && 0) {
-        // FIXME should handle edit list
-        av_log(s, AV_LOG_ERROR, "mov: does not handle seeking in files that contain edit list (c:%d)\n", sc->edit_count);
+    if (stream_index >= s->nb_streams)
         return -1;
-    }
 
-    // Step 2. Find the corresponding sample using the Time-to-sample atom (stts) */
-    dprintf("Searching for time %li in stream #%i (time_scale=%i)\n", (long)sample_time, mov_idx, sc->time_scale);
-    start_time = 0; // FIXME use elst atom
-    sample = 1; // sample are 0 based in table
-
-    for (i = 0; i < sc->stts_count; i++) {
-        count = sc->stts_data[i].count;
-        duration = sc->stts_data[i].duration;
-        if ((start_time + count*duration) > sample_time) {
-            sample_to_time_time = start_time;
-            sample_to_time_index = i;
-            sample_to_time_sample = sample;
-            sample += (sample_time - start_time) / duration;
-            break;
-        }
-        sample += count;
-        start_time += count * duration;
-    }
-    sample_to_time_time = start_time;
-    sample_to_time_index = i;
-    /* NOTE: despite what qt doc say, the dt value (Display Time in qt vocabulary) computed with the stts atom
-       is a decoding time stamp (dts) not a presentation time stamp. And as usual dts != pts for stream with b frames */
-
-    dprintf("Found time %li at sample #%u\n", (long)sample_time, sample);
-    if (sample > sc->sample_count) {
-        av_log(s, AV_LOG_ERROR, "mov: sample pos is too high, unable to seek (req. sample=%i, sample count=%ld)\n", sample, sc->sample_count);
+    st = s->streams[stream_index];
+    sample = mov_seek_stream(st, sample_time, flags);
+    if (sample < 0)
         return -1;
-    }
 
-    // Step 3. Find the prior sync. sample using the Sync sample atom (stss)
-    if (sc->keyframes) {
-        a = 0;
-        b = sc->keyframe_count - 1;
-        while (a < b) {
-            m = (a + b + 1) >> 1;
-            if (sc->keyframes[m] > sample) {
-                b = m - 1;
-            } else {
-                a = m;
-            }
-        }
-        // for low latency prob: always use the previous keyframe, just uncomment the next line
-        // if (a) a--;
-        seek_sample = sc->keyframes[a];
-    }
-    else
-        seek_sample = sample; // else all samples are key frames
-    dprintf("Found nearest keyframe at sample #%i \n", seek_sample);
+    /* adjust seek timestamp to found sample timestamp */
+    seek_timestamp = st->index_entries[sample].timestamp;
 
-    // Step 4. Find the chunk of the sample using the Sample-to-chunk-atom (stsc)
-    for (first_chunk_sample = 1, i = 0; i < (sc->sample_to_chunk_sz - 1); i++) {
-        b = (sc->sample_to_chunk[i + 1].first - sc->sample_to_chunk[i].first) * sc->sample_to_chunk[i].count;
-        if (seek_sample >= first_chunk_sample && seek_sample < (first_chunk_sample + b))
-            break;
-        first_chunk_sample += b;
-    }
-    chunk = sc->sample_to_chunk[i].first + (seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count;
-    left_in_chunk = sc->sample_to_chunk[i].count - (seek_sample - first_chunk_sample) % sc->sample_to_chunk[i].count;
-    first_chunk_sample += ((seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count) * sc->sample_to_chunk[i].count;
-    sample_to_chunk_idx = i;
-    dprintf("Sample was found in chunk #%i at sample offset %i (idx %i)\n", chunk, seek_sample - first_chunk_sample, sample_to_chunk_idx);
-
-    // Step 5. Find the offset of the chunk using the chunk offset atom
-    if (!sc->chunk_offsets) {
-        av_log(s, AV_LOG_ERROR, "mov: no chunk offset atom, unable to seek\n");
-        return -1;
-    }
-    if (chunk > sc->chunk_count) {
-        av_log(s, AV_LOG_ERROR, "mov: chunk offset atom too short, unable to seek (req. chunk=%i, chunk count=%li)\n", chunk, sc->chunk_count);
-        return -1;
-    }
-    chunk_file_offset = sc->chunk_offsets[chunk - 1];
-    dprintf("Chunk file offset is #%"PRIu64"\n", chunk_file_offset);
-
-    // Step 6. Find the byte offset within the chunk using the sample size atom
-    sample_file_offset = chunk_file_offset;
-    if (sc->sample_size)
-        sample_file_offset += (seek_sample - first_chunk_sample) * sc->sample_size;
-    else {
-        for (i = 0; i < (seek_sample - first_chunk_sample); i++) {
-        sample_file_offset += sc->sample_sizes[first_chunk_sample + i - 1];
-        }
-    }
-    dprintf("Sample file offset is #%"PRIu64"\n", sample_file_offset);
-
-    // Step 6. Update the parser
-    mov->partial = sc;
-    mov->next_chunk_offset = sample_file_offset;
-    // Update current stream state
-    sc->current_sample = seek_sample - 1;  // zero based
-    sc->left_in_chunk = left_in_chunk;
-    sc->next_chunk = chunk; // +1 -1 (zero based)
-    sc->sample_to_chunk_index = sample_to_chunk_idx;
-
-    // Update other streams
-    for (i = 0; i<mov->total_streams; i++) {
-        MOVStreamContext *msc;
-        if (i == mov_idx) continue;
-        // Find the nearest 'next' chunk
-        msc = mov->streams[i];
-        a = 0;
-        b = msc->chunk_count - 1;
-        while (a < b) {
-            m = (a + b + 1) >> 1;
-            if (msc->chunk_offsets[m] > chunk_file_offset) {
-                b = m - 1;
-            } else {
-                a = m;
-            }
-        }
-        msc->next_chunk = a;
-        if (msc->chunk_offsets[a] < chunk_file_offset && a < (msc->chunk_count-1))
-            msc->next_chunk ++;
-        dprintf("Nearest next chunk for stream #%i is #%li @%"PRId64"\n", i, msc->next_chunk+1, msc->chunk_offsets[msc->next_chunk]);
-
-        // Compute sample count and index in the sample_to_chunk table (what a pity)
-        msc->sample_to_chunk_index = 0;
-        msc->current_sample = 0;
-        for(;  msc->sample_to_chunk_index < (msc->sample_to_chunk_sz - 1)
-            && msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first <= (1 + msc->next_chunk); msc->sample_to_chunk_index++) {
-            msc->current_sample += (msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first - msc->sample_to_chunk[msc->sample_to_chunk_index].first) \
-            * msc->sample_to_chunk[msc->sample_to_chunk_index].count;
-        }
-        msc->current_sample += (msc->next_chunk - (msc->sample_to_chunk[msc->sample_to_chunk_index].first - 1)) * sc->sample_to_chunk[msc->sample_to_chunk_index].count;
-        msc->left_in_chunk = msc->sample_to_chunk[msc->sample_to_chunk_index].count - 1;
-        // Find corresponding position in stts (used later to compute dts)
-        sample = 0;
-        start_time = 0;
-        for (msc->sample_to_time_index = 0; msc->sample_to_time_index < msc->stts_count; msc->sample_to_time_index++) {
-            count = msc->stts_data[msc->sample_to_time_index].count;
-            duration = msc->stts_data[msc->sample_to_time_index].duration;
-            if ((sample + count - 1) > msc->current_sample) {
-                msc->sample_to_time_time = start_time;
-                msc->sample_to_time_sample = sample;
-                break;
-            }
-            sample += count;
-            start_time += count * duration;
-        }
-        sample = 0;
-        for (msc->sample_to_ctime_index = 0; msc->sample_to_ctime_index < msc->ctts_count; msc->sample_to_ctime_index++) {
-            count = msc->ctts_data[msc->sample_to_ctime_index].count;
-            duration = msc->ctts_data[msc->sample_to_ctime_index].duration;
-            if ((sample + count - 1) > msc->current_sample) {
-                msc->sample_to_ctime_sample = sample;
-                break;
-            }
-            sample += count;
-        }
-        dprintf("Next Sample for stream #%i is #%li @%li\n", i, msc->current_sample + 1, msc->sample_to_chunk_index + 1);
+    for (i = 0; i < s->nb_streams; i++) {
+        st = s->streams[i];
+        if (stream_index == i || st->discard == AVDISCARD_ALL)
+            continue;
+
+        timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
+        mov_seek_stream(st, timestamp, flags);
     }
     return 0;
 }
-#endif
 
 static int mov_read_close(AVFormatContext *s)
 {
@@ -2158,11 +1828,19 @@ static int mov_read_close(AVFormatContext *s)
     /* free color tabs */
     for(i=0; i<mov->ctab_size; i++)
         av_freep(&mov->ctab[i]);
+    if(mov->dv_demux){
+        for(i=0; i<mov->dv_fctx->nb_streams; i++){
+            av_freep(&mov->dv_fctx->streams[i]->codec);
+            av_freep(&mov->dv_fctx->streams[i]);
+        }
+        av_freep(&mov->dv_fctx);
+        av_freep(&mov->dv_demux);
+    }
     av_freep(&mov->ctab);
     return 0;
 }
 
-static AVInputFormat mov_iformat = {
+AVInputFormat mov_demuxer = {
     "mov,mp4,m4a,3gp,3g2,mj2",
     "QuickTime/MPEG4/Motion JPEG 2000 format",
     sizeof(MOVContext),
@@ -2170,13 +1848,5 @@ static AVInputFormat mov_iformat = {
     mov_read_header,
     mov_read_packet,
     mov_read_close,
-#if defined(MOV_SEEK)
     mov_read_seek,
-#endif
 };
-
-int mov_init(void)
-{
-    av_register_input_format(&mov_iformat);
-    return 0;
-}