edeaa9f9f0c6908bcb22adca24da3f68f66d1ba3
[ffmpeg.git] / libavformat / mov.c
1 /*
2  * MOV decoder.
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <limits.h>
23
24 //#define DEBUG
25
26 #include "avformat.h"
27 #include "riff.h"
28 #include "isom.h"
29 #include "dv.h"
30
31 #ifdef CONFIG_ZLIB
32 #include <zlib.h>
33 #endif
34
35 /*
36  * First version by Francois Revol revol@free.fr
37  * Seek function by Gael Chardon gael.dev@4now.net
38  *
39  * Features and limitations:
40  * - reads most of the QT files I have (at least the structure),
41  *   the exceptions are .mov with zlib compressed headers ('cmov' section). It shouldn't be hard to implement.
42  *   FIXED, Francois Revol, 07/17/2002
43  * - ffmpeg has nearly none of the usual QuickTime codecs,
44  *   although I succesfully dumped raw and mp3 audio tracks off .mov files.
45  *   Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html
46  * - .mp4 parsing is still hazardous, although the format really is QuickTime with some minor changes
47  *   (to make .mov parser crash maybe ?), despite what they say in the MPEG FAQ at
48  *   http://mpeg.telecomitalialab.com/faq.htm
49  * - the code is quite ugly... maybe I won't do it recursive next time :-)
50  * - seek is not supported with files that contain edit list
51  *
52  * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/
53  * when coding this :) (it's a writer anyway)
54  *
55  * Reference documents:
56  * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt
57  * Apple:
58  *  http://developer.apple.com/documentation/QuickTime/QTFF/
59  *  http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf
60  * QuickTime is a trademark of Apple (AFAIK :))
61  */
62
63 #include "qtpalette.h"
64
65
66 #undef NDEBUG
67 #include <assert.h>
68
69 static const CodecTag mov_video_tags[] = {
70 /*  { CODEC_ID_, MKTAG('c', 'v', 'i', 'd') }, *//* Cinepak */
71 /*  { CODEC_ID_H263, MKTAG('r', 'a', 'w', ' ') }, *//* Uncompressed RGB */
72 /*  { CODEC_ID_H263, MKTAG('Y', 'u', 'v', '2') }, *//* Uncompressed YUV422 */
73 /*    { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'U', 'I') }, *//* YUV with alpha-channel (AVID Uncompressed) */
74 /* Graphics */
75 /* Animation */
76 /* Apple video */
77 /* Kodak Photo CD */
78     { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */
79     { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */
80     { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */
81     { CODEC_ID_MJPEGB, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
82     { CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */
83 /*    { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, *//* MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */
84 /*    { CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, *//* embedded gif files as frames (usually one "click to play movie" frame) */
85 /* Sorenson video */
86     { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') }, /* Sorenson Video v1 */
87     { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') }, /* Sorenson Video v1 */
88     { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', 'i') }, /* Sorenson Video v1 (from QT specs)*/
89     { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') }, /* Sorenson Video v3 */
90     { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
91     { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, /* OpenDiVX *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
92     { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
93     { CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') }, /* experimental: 3IVX files before ivx D4 4.5.1 */
94 /*    { CODEC_ID_, MKTAG('I', 'V', '5', '0') }, *//* Indeo 5.0 */
95     { CODEC_ID_H263, MKTAG('h', '2', '6', '3') }, /* H263 */
96     { CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */
97     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */
98     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */
99     { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */
100     { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */
101     { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */
102     { CODEC_ID_8BPS, MKTAG('8', 'B', 'P', 'S') }, /* Planar RGB (8BPS) */
103     { CODEC_ID_SMC, MKTAG('s', 'm', 'c', ' ') }, /* Apple Graphics (SMC) */
104     { CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') }, /* Apple Animation (RLE) */
105     { CODEC_ID_QDRAW, MKTAG('q', 'd', 'r', 'w') }, /* QuickDraw */
106     { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') }, /* AVC-1/H.264 */
107     { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '2') }, /* MPEG2 produced by Sony HD camera */
108     { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '3') }, /* HDV produced by FCP */
109     { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'n') }, /* MPEG2 IMX NTSC 525/60 50mb/s produced by FCP */
110     { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'p') }, /* MPEG2 IMX PAL 625/50 50mb/s produced by FCP */
111     { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'n') }, /* MPEG2 IMX NTSC 525/60 30mb/s produced by FCP */
112     { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'p') }, /* MPEG2 IMX PAL 625/50 30mb/s produced by FCP */
113     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'p', 'p') }, /* DVCPRO PAL produced by FCP */
114     //{ CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '5') }, /* DVCPRO HD 50i produced by FCP */
115     //{ CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '6') }, /* DVCPRO HD 60i produced by FCP */
116     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'p') }, /* DVCPRO50 PAL produced by FCP */
117     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC produced by FCP */
118     { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, /* AVID DV */
119     //{ CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') }, /* JPEG 2000 produced by FCP */
120     { CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') }, /* Truevision Targa */
121     { CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') }, /* UNCOMPRESSED 8BIT 4:2:2 */
122     { CODEC_ID_NONE, 0 },
123 };
124
125 static const CodecTag mov_audio_tags[] = {
126     { CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') },
127     { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') },
128     { CODEC_ID_PCM_S16BE, MKTAG('N', 'O', 'N', 'E') }, /* uncompressed */
129     { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') }, /* 16 bits */
130     { CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') }, /* 8 bits unsigned */
131     { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') }, /*  */
132     { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') }, /*  */
133     { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') }, /*  */
134     { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') }, /* IMA-4 ADPCM */
135     { CODEC_ID_ADPCM_MS, MKTAG('m', 's', 0x00, 0x02) }, /* MS ADPCM */
136     { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') }, /* Macintosh Audio Compression and Expansion 3:1 */
137     { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') }, /* Macintosh Audio Compression and Expansion 6:1 */
138
139     { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') }, /* MPEG layer 3 */ /* sample files at http://www.3ivx.com/showcase.html use this tag */
140     { CODEC_ID_MP2, 0x6D730055 }, /* MPEG layer 3 */
141     { CODEC_ID_MP2, 0x5500736D }, /* MPEG layer 3 *//* XXX: check endianness */
142 /*    { CODEC_ID_OGG_VORBIS, MKTAG('O', 'g', 'g', 'S') }, *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
143 /* MP4 tags */
144     { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') }, /* MPEG-4 AAC */
145     /* The standard for mpeg4 audio is still not normalised AFAIK anyway */
146     { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') }, /* AMR-NB 3gp */
147     { CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') }, /* AMR-WB 3gp */
148     { CODEC_ID_AC3, MKTAG('m', 's', 0x20, 0x00) }, /* Dolby AC-3 */
149     { CODEC_ID_ALAC,MKTAG('a', 'l', 'a', 'c') }, /* Apple Lossless */
150     { CODEC_ID_QDM2,MKTAG('Q', 'D', 'M', '2') }, /* QDM2 */
151     { CODEC_ID_DVAUDIO, MKTAG('v', 'd', 'v', 'a') },
152     { CODEC_ID_DVAUDIO, MKTAG('d', 'v', 'c', 'a') },
153     { CODEC_ID_PCM_S16LE, MKTAG('l', 'p', 'c', 'm') },
154     { CODEC_ID_NONE, 0 },
155 };
156
157 /* the QuickTime file format is quite convoluted...
158  * it has lots of index tables, each indexing something in another one...
159  * Here we just use what is needed to read the chunks
160  */
161
162 typedef struct MOV_sample_to_chunk_tbl {
163     long first;
164     long count;
165     long id;
166 } MOV_sample_to_chunk_tbl;
167
168 typedef struct {
169     uint32_t type;
170     int64_t offset;
171     int64_t size; /* total size (excluding the size and type fields) */
172 } MOV_atom_t;
173
174 typedef struct {
175     int seed;
176     int flags;
177     int size;
178     void* clrs;
179 } MOV_ctab_t;
180
181 typedef struct MOV_mdat_atom_s {
182     offset_t offset;
183     int64_t size;
184 } MOV_mdat_atom_t;
185
186 typedef struct {
187     uint8_t  version;
188     uint32_t flags; // 24bit
189
190     /* 0x03 ESDescrTag */
191     uint16_t es_id;
192 #define MP4ODescrTag                    0x01
193 #define MP4IODescrTag                   0x02
194 #define MP4ESDescrTag                   0x03
195 #define MP4DecConfigDescrTag            0x04
196 #define MP4DecSpecificDescrTag          0x05
197 #define MP4SLConfigDescrTag             0x06
198 #define MP4ContentIdDescrTag            0x07
199 #define MP4SupplContentIdDescrTag       0x08
200 #define MP4IPIPtrDescrTag               0x09
201 #define MP4IPMPPtrDescrTag              0x0A
202 #define MP4IPMPDescrTag                 0x0B
203 #define MP4RegistrationDescrTag         0x0D
204 #define MP4ESIDIncDescrTag              0x0E
205 #define MP4ESIDRefDescrTag              0x0F
206 #define MP4FileIODescrTag               0x10
207 #define MP4FileODescrTag                0x11
208 #define MP4ExtProfileLevelDescrTag      0x13
209 #define MP4ExtDescrTagsStart            0x80
210 #define MP4ExtDescrTagsEnd              0xFE
211     uint8_t  stream_priority;
212
213     /* 0x04 DecConfigDescrTag */
214     uint8_t  object_type_id;
215     uint8_t  stream_type;
216     /* XXX: really streamType is
217      * only 6bit, followed by:
218      * 1bit  upStream
219      * 1bit  reserved
220      */
221     uint32_t buffer_size_db; // 24
222     uint32_t max_bitrate;
223     uint32_t avg_bitrate;
224
225     /* 0x05 DecSpecificDescrTag */
226     uint8_t  decoder_cfg_len;
227     uint8_t *decoder_cfg;
228
229     /* 0x06 SLConfigDescrTag */
230     uint8_t  sl_config_len;
231     uint8_t *sl_config;
232 } MOV_esds_t;
233
234 struct MOVParseTableEntry;
235
236 typedef struct MOVStreamContext {
237     int ffindex; /* the ffmpeg stream id */
238     long next_chunk;
239     long chunk_count;
240     int64_t *chunk_offsets;
241     int stts_count;
242     Time2Sample *stts_data;
243     int ctts_count;
244     Time2Sample *ctts_data;
245     int edit_count;             /* number of 'edit' (elst atom) */
246     long sample_to_chunk_sz;
247     MOV_sample_to_chunk_tbl *sample_to_chunk;
248     int sample_to_ctime_index;
249     int sample_to_ctime_sample;
250     long sample_size;
251     long sample_count;
252     long *sample_sizes;
253     long keyframe_count;
254     long *keyframes;
255     int time_scale;
256     int time_rate;
257     long current_sample;
258     MOV_esds_t esds;
259     AVRational sample_size_v1;
260     int dv_audio_container;
261 } MOVStreamContext;
262
263 typedef struct MOVContext {
264     int mp4; /* set to 1 as soon as we are sure that the file is an .mp4 file (even some header parsing depends on this) */
265     AVFormatContext *fc;
266     int time_scale;
267     int64_t duration; /* duration of the longest track */
268     int found_moov; /* when both 'moov' and 'mdat' sections has been found */
269     int found_mdat; /* we suppose we have enough data to read the file */
270     int64_t mdat_size;
271     int64_t mdat_offset;
272     int total_streams;
273     /* some streams listed here aren't presented to the ffmpeg API, since they aren't either video nor audio
274      * but we need the info to be able to skip data from those streams in the 'mdat' section
275      */
276     MOVStreamContext *streams[MAX_STREAMS];
277
278     int ctab_size;
279     MOV_ctab_t **ctab;           /* color tables */
280     const struct MOVParseTableEntry *parse_table; /* could be eventually used to change the table */
281     /* NOTE: for recursion save to/ restore from local variable! */
282
283     AVPaletteControl palette_control;
284     MOV_mdat_atom_t *mdat_list;
285     int mdat_count;
286     DVDemuxContext *dv_demux;
287     AVFormatContext *dv_fctx;
288 } MOVContext;
289
290
291 /* XXX: it's the first time I make a recursive parser I think... sorry if it's ugly :P */
292
293 /* those functions parse an atom */
294 /* return code:
295  1: found what I wanted, exit
296  0: continue to parse next atom
297  -1: error occured, exit
298  */
299 typedef int (*mov_parse_function)(MOVContext *ctx, ByteIOContext *pb, MOV_atom_t atom);
300
301 /* links atom IDs to parse functions */
302 typedef struct MOVParseTableEntry {
303     uint32_t type;
304     mov_parse_function func;
305 } MOVParseTableEntry;
306
307 static int mov_read_leaf(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
308 {
309     if (atom.size>1)
310         url_fskip(pb, atom.size);
311 /*        url_seek(pb, atom_offset+atom.size, SEEK_SET); */
312     return 0;
313 }
314
315 static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
316 {
317     int64_t total_size = 0;
318     MOV_atom_t a;
319     int i;
320     int err = 0;
321
322     a.offset = atom.offset;
323
324     if (atom.size < 0)
325         atom.size = 0x7fffffffffffffffLL;
326     while(((total_size + 8) < atom.size) && !url_feof(pb) && !err) {
327         a.size = atom.size;
328         a.type=0L;
329         if(atom.size >= 8) {
330             a.size = get_be32(pb);
331             a.type = get_le32(pb);
332         }
333         total_size += 8;
334         a.offset += 8;
335         dprintf("type: %08x  %.4s  sz: %"PRIx64"  %"PRIx64"   %"PRIx64"\n", a.type, (char*)&a.type, a.size, atom.size, total_size);
336         if (a.size == 1) { /* 64 bit extended size */
337             a.size = get_be64(pb) - 8;
338             a.offset += 8;
339             total_size += 8;
340         }
341         if (a.size == 0) {
342             a.size = atom.size - total_size;
343             if (a.size <= 8)
344                 break;
345         }
346         for (i = 0; c->parse_table[i].type != 0L
347              && c->parse_table[i].type != a.type; i++)
348             /* empty */;
349
350         a.size -= 8;
351
352         if(a.size < 0)
353             break;
354
355         if (c->parse_table[i].type == 0) { /* skip leaf atoms data */
356             url_fskip(pb, a.size);
357         } else {
358             offset_t start_pos = url_ftell(pb);
359             int64_t left;
360             err = (c->parse_table[i].func)(c, pb, a);
361             left = a.size - url_ftell(pb) + start_pos;
362             if (left > 0) /* skip garbage at atom end */
363                 url_fskip(pb, left);
364         }
365
366         a.offset += a.size;
367         total_size += a.size;
368     }
369
370     if (!err && total_size < atom.size && atom.size < 0x7ffff) {
371         url_fskip(pb, atom.size - total_size);
372     }
373
374     return err;
375 }
376
377 static int mov_read_ctab(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
378 {
379 #if 1
380     url_fskip(pb, atom.size); // for now
381 #else
382     VERY VERY BROKEN, NEVER execute this, needs rewrite
383     unsigned int len;
384     MOV_ctab_t *t;
385     c->ctab = av_realloc(c->ctab, ++c->ctab_size);
386     t = c->ctab[c->ctab_size];
387     t->seed = get_be32(pb);
388     t->flags = get_be16(pb);
389     t->size = get_be16(pb) + 1;
390     len = 2 * t->size * 4;
391     if (len > 0) {
392         t->clrs = av_malloc(len); // 16bit A R G B
393         if (t->clrs)
394             get_buffer(pb, t->clrs, len);
395     }
396 #endif
397
398     return 0;
399 }
400
401 static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
402 {
403     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
404     int len = 0;
405     uint32_t type;
406     uint32_t ctype;
407
408     get_byte(pb); /* version */
409     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
410
411     /* component type */
412     ctype = get_le32(pb);
413     type = get_le32(pb); /* component subtype */
414
415     dprintf("ctype= %c%c%c%c (0x%08lx)\n", *((char *)&ctype), ((char *)&ctype)[1], ((char *)&ctype)[2], ((char *)&ctype)[3], (long) ctype);
416     dprintf("stype= %c%c%c%c\n", *((char *)&type), ((char *)&type)[1], ((char *)&type)[2], ((char *)&type)[3]);
417     if(ctype == MKTAG('m', 'h', 'l', 'r')) /* MOV */
418         c->mp4 = 0;
419     else if(ctype == 0)
420         c->mp4 = 1;
421     if(type == MKTAG('v', 'i', 'd', 'e'))
422         st->codec->codec_type = CODEC_TYPE_VIDEO;
423     else if(type == MKTAG('s', 'o', 'u', 'n'))
424         st->codec->codec_type = CODEC_TYPE_AUDIO;
425     get_be32(pb); /* component  manufacture */
426     get_be32(pb); /* component flags */
427     get_be32(pb); /* component flags mask */
428
429     if(atom.size <= 24)
430         return 0; /* nothing left to read */
431     /* XXX: MP4 uses a C string, not a pascal one */
432     /* component name */
433
434     if(c->mp4) {
435         /* .mp4: C string */
436         while(get_byte(pb) && (++len < (atom.size - 24)));
437     } else {
438         /* .mov: PASCAL string */
439         len = get_byte(pb);
440         url_fskip(pb, len);
441     }
442
443     url_fskip(pb, atom.size - (url_ftell(pb) - atom.offset));
444     return 0;
445 }
446
447 static int mov_mp4_read_descr_len(ByteIOContext *pb)
448 {
449     int len = 0;
450     int count = 4;
451     while (count--) {
452         int c = get_byte(pb);
453         len = (len << 7) | (c & 0x7f);
454         if (!(c & 0x80))
455             break;
456     }
457     return len;
458 }
459
460 static int mov_mp4_read_descr(ByteIOContext *pb, int *tag)
461 {
462     int len;
463     *tag = get_byte(pb);
464     len = mov_mp4_read_descr_len(pb);
465     dprintf("MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
466     return len;
467 }
468
469 static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
470 {
471     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
472     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
473     int tag, len;
474
475     /* Well, broken but suffisant for some MP4 streams */
476     get_be32(pb); /* version + flags */
477     len = mov_mp4_read_descr(pb, &tag);
478     if (tag == MP4ESDescrTag) {
479         get_be16(pb); /* ID */
480         get_byte(pb); /* priority */
481     } else
482         get_be16(pb); /* ID */
483
484     len = mov_mp4_read_descr(pb, &tag);
485     if (tag == MP4DecConfigDescrTag) {
486         sc->esds.object_type_id = get_byte(pb);
487         sc->esds.stream_type = get_byte(pb);
488         sc->esds.buffer_size_db = get_be24(pb);
489         sc->esds.max_bitrate = get_be32(pb);
490         sc->esds.avg_bitrate = get_be32(pb);
491
492         st->codec->codec_id= codec_get_id(ff_mov_obj_type, sc->esds.object_type_id);
493         dprintf("esds object type id %d\n", sc->esds.object_type_id);
494         len = mov_mp4_read_descr(pb, &tag);
495         if (tag == MP4DecSpecificDescrTag) {
496             dprintf("Specific MPEG4 header len=%d\n", len);
497             st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
498             if (st->codec->extradata) {
499                 get_buffer(pb, st->codec->extradata, len);
500                 st->codec->extradata_size = len;
501                 /* from mplayer */
502                 if ((*st->codec->extradata >> 3) == 29) {
503                     st->codec->codec_id = CODEC_ID_MP3ON4;
504                 }
505             }
506         }
507     }
508     return 0;
509 }
510
511 /* this atom contains actual media data */
512 static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
513 {
514     if(atom.size == 0) /* wrong one (MP4) */
515         return 0;
516     c->mdat_list = av_realloc(c->mdat_list, (c->mdat_count + 1) * sizeof(*c->mdat_list));
517     c->mdat_list[c->mdat_count].offset = atom.offset;
518     c->mdat_list[c->mdat_count].size = atom.size;
519     c->mdat_count++;
520     c->found_mdat=1;
521     c->mdat_offset = atom.offset;
522     c->mdat_size = atom.size;
523     if(c->found_moov)
524         return 1; /* found both, just go */
525     url_fskip(pb, atom.size);
526     return 0; /* now go for moov */
527 }
528
529 static int mov_read_ftyp(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
530 {
531     uint32_t type = get_le32(pb);
532
533     /* from mplayer */
534     switch (type) {
535     case MKTAG('i', 's', 'o', 'm'):
536     case MKTAG('m', 'p', '4', '1'):
537     case MKTAG('m', 'p', '4', '2'):
538     case MKTAG('3', 'g', 'p', '1'):
539     case MKTAG('3', 'g', 'p', '2'):
540     case MKTAG('3', 'g', '2', 'a'):
541     case MKTAG('3', 'g', 'p', '3'):
542     case MKTAG('3', 'g', 'p', '4'):
543     case MKTAG('3', 'g', 'p', '5'):
544     case MKTAG('m', 'm', 'p', '4'): /* Mobile MP4 */
545     case MKTAG('M', '4', 'A', ' '): /* Apple iTunes AAC-LC Audio */
546     case MKTAG('M', '4', 'P', ' '): /* Apple iTunes AAC-LC Protected Audio */
547     case MKTAG('m', 'j', 'p', '2'): /* Motion Jpeg 2000 */
548         c->mp4 = 1;
549     case MKTAG('q', 't', ' ', ' '):
550     default:
551         av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
552     }
553     get_be32(pb); /* minor version */
554     url_fskip(pb, atom.size - 8);
555     return 0;
556 }
557
558 /* this atom should contain all header atoms */
559 static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
560 {
561     int err;
562
563     err = mov_read_default(c, pb, atom);
564     /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
565     /* so we don't parse the whole file if over a network */
566     c->found_moov=1;
567     if(c->found_mdat)
568         return 1; /* found both, just go */
569     return 0; /* now go for mdat */
570 }
571
572
573 static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
574 {
575     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
576     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
577     int version = get_byte(pb);
578     int lang;
579
580     if (version > 1)
581         return 1; /* unsupported */
582
583     get_byte(pb); get_byte(pb);
584     get_byte(pb); /* flags */
585
586     if (version == 1) {
587         get_be64(pb);
588         get_be64(pb);
589     } else {
590         get_be32(pb); /* creation time */
591         get_be32(pb); /* modification time */
592     }
593
594     sc->time_scale = get_be32(pb);
595     st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
596
597     lang = get_be16(pb); /* language */
598     ff_mov_lang_to_iso639(lang, st->language);
599     get_be16(pb); /* quality */
600
601     return 0;
602 }
603
604 static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
605 {
606     int version = get_byte(pb); /* version */
607     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
608
609     if (version == 1) {
610         get_be64(pb);
611         get_be64(pb);
612     } else {
613         get_be32(pb); /* creation time */
614         get_be32(pb); /* modification time */
615     }
616     c->time_scale = get_be32(pb); /* time scale */
617 #ifdef DEBUG
618     av_log(NULL, AV_LOG_DEBUG, "time scale = %i\n", c->time_scale);
619 #endif
620     c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
621     get_be32(pb); /* preferred scale */
622
623     get_be16(pb); /* preferred volume */
624
625     url_fskip(pb, 10); /* reserved */
626
627     url_fskip(pb, 36); /* display matrix */
628
629     get_be32(pb); /* preview time */
630     get_be32(pb); /* preview duration */
631     get_be32(pb); /* poster time */
632     get_be32(pb); /* selection time */
633     get_be32(pb); /* selection duration */
634     get_be32(pb); /* current time */
635     get_be32(pb); /* next track ID */
636
637     return 0;
638 }
639
640 static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
641 {
642     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
643
644     if((uint64_t)atom.size > (1<<30))
645         return -1;
646
647     // currently SVQ3 decoder expect full STSD header - so let's fake it
648     // this should be fixed and just SMI header should be passed
649     av_free(st->codec->extradata);
650     st->codec->extradata_size = 0x5a + atom.size;
651     st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
652
653     if (st->codec->extradata) {
654         strcpy(st->codec->extradata, "SVQ3"); // fake
655         get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
656         dprintf("Reading SMI %"PRId64"  %s\n", atom.size, st->codec->extradata + 0x5a);
657     } else
658         url_fskip(pb, atom.size);
659
660     return 0;
661 }
662
663 static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
664 {
665     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
666     int little_endian = get_be16(pb);
667
668     if (little_endian) {
669         switch (st->codec->codec_id) {
670         case CODEC_ID_PCM_S24BE:
671             st->codec->codec_id = CODEC_ID_PCM_S24LE;
672             break;
673         case CODEC_ID_PCM_S32BE:
674             st->codec->codec_id = CODEC_ID_PCM_S32LE;
675             break;
676         default:
677             break;
678         }
679     }
680     return 0;
681 }
682
683 static int mov_read_alac(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
684 {
685     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
686
687     // currently ALAC decoder expect full atom header - so let's fake it
688     // this should be fixed and just ALAC header should be passed
689
690     av_free(st->codec->extradata);
691     st->codec->extradata_size = 36;
692     st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
693
694     if (st->codec->extradata) {
695         strcpy(st->codec->extradata + 4, "alac"); // fake
696         get_buffer(pb, st->codec->extradata + 8, 36 - 8);
697         dprintf("Reading alac %d  %s\n", st->codec->extradata_size, st->codec->extradata);
698     } else
699         url_fskip(pb, atom.size);
700     return 0;
701 }
702
703 static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
704 {
705     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
706
707     if((uint64_t)atom.size > (1<<30))
708         return -1;
709
710     if (st->codec->codec_id == CODEC_ID_QDM2) {
711         // pass all frma atom to codec, needed at least for QDM2
712         av_free(st->codec->extradata);
713         st->codec->extradata_size = atom.size;
714         st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
715
716         if (st->codec->extradata) {
717             get_buffer(pb, st->codec->extradata, atom.size);
718         } else
719             url_fskip(pb, atom.size);
720     } else if (atom.size > 8) { /* to read frma, esds atoms */
721         mov_read_default(c, pb, atom);
722     } else
723         url_fskip(pb, atom.size);
724     return 0;
725 }
726
727 static int mov_read_jp2h(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
728 {
729     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
730
731     if((uint64_t)atom.size > (1<<30))
732         return -1;
733
734     av_free(st->codec->extradata);
735
736     st->codec->extradata_size = atom.size + 8;
737     st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
738
739     /* pass all jp2h atom to codec */
740     if (st->codec->extradata) {
741         strcpy(st->codec->extradata + 4, "jp2h");
742         get_buffer(pb, st->codec->extradata + 8, atom.size);
743     } else
744         url_fskip(pb, atom.size);
745     return 0;
746 }
747
748 static int mov_read_avcC(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
749 {
750     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
751
752     if((uint64_t)atom.size > (1<<30))
753         return -1;
754
755     av_free(st->codec->extradata);
756
757     st->codec->extradata_size = atom.size;
758     st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
759
760     if (st->codec->extradata) {
761         get_buffer(pb, st->codec->extradata, atom.size);
762     } else
763         url_fskip(pb, atom.size);
764
765     return 0;
766 }
767
768 static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
769 {
770     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
771     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
772     unsigned int i, entries;
773
774     get_byte(pb); /* version */
775     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
776
777     entries = get_be32(pb);
778
779     if(entries >= UINT_MAX/sizeof(int64_t))
780         return -1;
781
782     sc->chunk_count = entries;
783     sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
784     if (!sc->chunk_offsets)
785         return -1;
786     if (atom.type == MKTAG('s', 't', 'c', 'o')) {
787         for(i=0; i<entries; i++) {
788             sc->chunk_offsets[i] = get_be32(pb);
789         }
790     } else if (atom.type == MKTAG('c', 'o', '6', '4')) {
791         for(i=0; i<entries; i++) {
792             sc->chunk_offsets[i] = get_be64(pb);
793         }
794     } else
795         return -1;
796
797     return 0;
798 }
799
800 static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
801 {
802     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
803     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
804     int entries, frames_per_sample;
805     uint32_t format;
806     uint8_t codec_name[32];
807
808     /* for palette traversal */
809     int color_depth;
810     int color_start;
811     int color_count;
812     int color_end;
813     int color_index;
814     int color_dec;
815     int color_greyscale;
816     unsigned char *color_table;
817     int j;
818     unsigned char r, g, b;
819
820     get_byte(pb); /* version */
821     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
822
823     entries = get_be32(pb);
824
825     while(entries--) { //Parsing Sample description table
826         enum CodecID id;
827         MOV_atom_t a = { 0, 0, 0 };
828         offset_t start_pos = url_ftell(pb);
829         int size = get_be32(pb); /* size */
830         format = get_le32(pb); /* data format */
831
832         get_be32(pb); /* reserved */
833         get_be16(pb); /* reserved */
834         get_be16(pb); /* index */
835
836         if (st->codec->codec_tag) {
837             /* multiple fourcc, just skip for now */
838             url_fskip(pb, size - (url_ftell(pb) - start_pos));
839             continue;
840         }
841
842         st->codec->codec_tag = format;
843         id = codec_get_id(mov_audio_tags, format);
844         if (id > 0) {
845             st->codec->codec_type = CODEC_TYPE_AUDIO;
846         } else if (format && format != MKTAG('m', 'p', '4', 's')) { /* skip old asf mpeg4 tag */
847             id = codec_get_id(mov_video_tags, format);
848             if (id <= 0)
849                 id = codec_get_id(codec_bmp_tags, format);
850             if (id > 0)
851                 st->codec->codec_type = CODEC_TYPE_VIDEO;
852         }
853
854         dprintf("size=%d 4CC= %c%c%c%c codec_type=%d\n",
855                 size,
856                 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, (format >> 24) & 0xff,
857                 st->codec->codec_type);
858
859         if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
860             st->codec->codec_id = id;
861             get_be16(pb); /* version */
862             get_be16(pb); /* revision level */
863             get_be32(pb); /* vendor */
864             get_be32(pb); /* temporal quality */
865             get_be32(pb); /* spacial quality */
866
867             st->codec->width = get_be16(pb); /* width */
868             st->codec->height = get_be16(pb); /* height */
869
870             get_be32(pb); /* horiz resolution */
871             get_be32(pb); /* vert resolution */
872             get_be32(pb); /* data size, always 0 */
873             frames_per_sample = get_be16(pb); /* frames per samples */
874 #ifdef DEBUG
875             av_log(NULL, AV_LOG_DEBUG, "frames/samples = %d\n", frames_per_sample);
876 #endif
877             get_buffer(pb, codec_name, 32); /* codec name, pascal string (FIXME: true for mp4?) */
878             if (codec_name[0] <= 31) {
879                 memcpy(st->codec->codec_name, &codec_name[1],codec_name[0]);
880                 st->codec->codec_name[codec_name[0]] = 0;
881             }
882
883             st->codec->bits_per_sample = get_be16(pb); /* depth */
884             st->codec->color_table_id = get_be16(pb); /* colortable id */
885
886             /* figure out the palette situation */
887             color_depth = st->codec->bits_per_sample & 0x1F;
888             color_greyscale = st->codec->bits_per_sample & 0x20;
889
890             /* if the depth is 2, 4, or 8 bpp, file is palettized */
891             if ((color_depth == 2) || (color_depth == 4) ||
892                 (color_depth == 8)) {
893
894                 if (color_greyscale) {
895
896                     /* compute the greyscale palette */
897                     color_count = 1 << color_depth;
898                     color_index = 255;
899                     color_dec = 256 / (color_count - 1);
900                     for (j = 0; j < color_count; j++) {
901                         r = g = b = color_index;
902                         c->palette_control.palette[j] =
903                             (r << 16) | (g << 8) | (b);
904                         color_index -= color_dec;
905                         if (color_index < 0)
906                             color_index = 0;
907                     }
908
909                 } else if (st->codec->color_table_id & 0x08) {
910
911                     /* if flag bit 3 is set, use the default palette */
912                     color_count = 1 << color_depth;
913                     if (color_depth == 2)
914                         color_table = ff_qt_default_palette_4;
915                     else if (color_depth == 4)
916                         color_table = ff_qt_default_palette_16;
917                     else
918                         color_table = ff_qt_default_palette_256;
919
920                     for (j = 0; j < color_count; j++) {
921                         r = color_table[j * 4 + 0];
922                         g = color_table[j * 4 + 1];
923                         b = color_table[j * 4 + 2];
924                         c->palette_control.palette[j] =
925                             (r << 16) | (g << 8) | (b);
926                     }
927
928                 } else {
929
930                     /* load the palette from the file */
931                     color_start = get_be32(pb);
932                     color_count = get_be16(pb);
933                     color_end = get_be16(pb);
934                     for (j = color_start; j <= color_end; j++) {
935                         /* each R, G, or B component is 16 bits;
936                          * only use the top 8 bits; skip alpha bytes
937                          * up front */
938                         get_byte(pb);
939                         get_byte(pb);
940                         r = get_byte(pb);
941                         get_byte(pb);
942                         g = get_byte(pb);
943                         get_byte(pb);
944                         b = get_byte(pb);
945                         get_byte(pb);
946                         c->palette_control.palette[j] =
947                             (r << 16) | (g << 8) | (b);
948                     }
949                 }
950
951                 st->codec->palctrl = &c->palette_control;
952                 st->codec->palctrl->palette_changed = 1;
953             } else
954                 st->codec->palctrl = NULL;
955         } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) {
956             int bits_per_sample;
957             uint16_t version = get_be16(pb);
958
959             st->codec->codec_id = id;
960             get_be16(pb); /* revision level */
961             get_be32(pb); /* vendor */
962
963             st->codec->channels = get_be16(pb);             /* channel count */
964             dprintf("audio channels %d\n", st->codec->channels);
965             st->codec->bits_per_sample = get_be16(pb);      /* sample size */
966             /* do we need to force to 16 for AMR ? */
967
968             /* handle specific s8 codec */
969             get_be16(pb); /* compression id = 0*/
970             get_be16(pb); /* packet size = 0 */
971
972             st->codec->sample_rate = ((get_be32(pb) >> 16));
973
974             switch (st->codec->codec_id) {
975             case CODEC_ID_PCM_S8:
976             case CODEC_ID_PCM_U8:
977                 if (st->codec->bits_per_sample == 16)
978                     st->codec->codec_id = CODEC_ID_PCM_S16BE;
979                 break;
980             case CODEC_ID_PCM_S16LE:
981             case CODEC_ID_PCM_S16BE:
982                 if (st->codec->bits_per_sample == 8)
983                     st->codec->codec_id = CODEC_ID_PCM_S8;
984                 else if (st->codec->bits_per_sample == 24)
985                     st->codec->codec_id = CODEC_ID_PCM_S24BE;
986                 break;
987             default:
988                 break;
989             }
990
991             //Read QT version 1 fields. In version 0 theese dont exist
992             dprintf("version =%d mp4=%d\n",version,c->mp4);
993             if(version==1) {
994                 sc->sample_size_v1.den = get_be32(pb); /* samples per packet */
995                 get_be32(pb); /* bytes per packet */
996                 sc->sample_size_v1.num = get_be32(pb); /* bytes per frame */
997                 get_be32(pb); /* bytes per sample */
998             } else if(version==2) {
999                 get_be32(pb); /* sizeof struct only */
1000                 st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */
1001                 st->codec->channels = get_be32(pb);
1002                 get_be32(pb); /* always 0x7F000000 */
1003                 get_be32(pb); /* bits per channel if sound is uncompressed */
1004                 get_be32(pb); /* lcpm format specific flag */
1005                 get_be32(pb); /* bytes per audio packet if constant */
1006                 get_be32(pb); /* lpcm frames per audio packet if constant */
1007             }
1008
1009             bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
1010             if (bits_per_sample) {
1011                 st->codec->bits_per_sample = bits_per_sample;
1012                 sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
1013             }
1014         } else {
1015             /* other codec type, just skip (rtp, mp4s, tmcd ...) */
1016             url_fskip(pb, size - (url_ftell(pb) - start_pos));
1017         }
1018         /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
1019         a.size = size - (url_ftell(pb) - start_pos);
1020         if (a.size > 8)
1021             mov_read_default(c, pb, a);
1022         else if (a.size > 0)
1023             url_fskip(pb, a.size);
1024     }
1025
1026     if(st->codec->codec_type==CODEC_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1) {
1027         st->codec->sample_rate= sc->time_scale;
1028     }
1029
1030     /* special codec parameters handling */
1031     switch (st->codec->codec_id) {
1032 #ifdef CONFIG_H261_DECODER
1033     case CODEC_ID_H261:
1034 #endif
1035 #ifdef CONFIG_H263_DECODER
1036     case CODEC_ID_H263:
1037 #endif
1038 #ifdef CONFIG_MPEG4_DECODER
1039     case CODEC_ID_MPEG4:
1040 #endif
1041         st->codec->width= 0; /* let decoder init width/height */
1042         st->codec->height= 0;
1043         break;
1044 #ifdef CONFIG_FAAD
1045     case CODEC_ID_AAC:
1046 #endif
1047 #ifdef CONFIG_VORBIS_DECODER
1048     case CODEC_ID_VORBIS:
1049 #endif
1050     case CODEC_ID_MP3ON4:
1051         st->codec->sample_rate= 0; /* let decoder init parameters properly */
1052         break;
1053 #ifdef CONFIG_DV_DEMUXER
1054     case CODEC_ID_DVAUDIO:
1055         c->dv_fctx = av_alloc_format_context();
1056         c->dv_demux = dv_init_demux(c->dv_fctx);
1057         if (!c->dv_demux) {
1058             av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
1059             return -1;
1060         }
1061         sc->dv_audio_container = 1;
1062         st->codec->codec_id = CODEC_ID_PCM_S16LE;
1063         break;
1064 #endif
1065     /* no ifdef since parameters are always those */
1066     case CODEC_ID_AMR_WB:
1067         st->codec->sample_rate= 16000;
1068         st->codec->channels= 1; /* really needed */
1069         break;
1070     case CODEC_ID_AMR_NB:
1071         st->codec->sample_rate= 8000;
1072         st->codec->channels= 1; /* really needed */
1073         break;
1074     case CODEC_ID_MP2:
1075         st->need_parsing = 1;
1076         break;
1077     default:
1078         break;
1079     }
1080
1081     return 0;
1082 }
1083
1084 static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1085 {
1086     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1087     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1088     unsigned int i, entries;
1089
1090     get_byte(pb); /* version */
1091     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1092
1093     entries = get_be32(pb);
1094
1095     if(entries >= UINT_MAX / sizeof(MOV_sample_to_chunk_tbl))
1096         return -1;
1097
1098 #ifdef DEBUG
1099 av_log(NULL, AV_LOG_DEBUG, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1100 #endif
1101     sc->sample_to_chunk_sz = entries;
1102     sc->sample_to_chunk = av_malloc(entries * sizeof(MOV_sample_to_chunk_tbl));
1103     if (!sc->sample_to_chunk)
1104         return -1;
1105     for(i=0; i<entries; i++) {
1106         sc->sample_to_chunk[i].first = get_be32(pb);
1107         sc->sample_to_chunk[i].count = get_be32(pb);
1108         sc->sample_to_chunk[i].id = get_be32(pb);
1109     }
1110     return 0;
1111 }
1112
1113 static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1114 {
1115     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1116     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1117     unsigned int i, entries;
1118
1119     get_byte(pb); /* version */
1120     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1121
1122     entries = get_be32(pb);
1123
1124     if(entries >= UINT_MAX / sizeof(long))
1125         return -1;
1126
1127     sc->keyframe_count = entries;
1128 #ifdef DEBUG
1129     av_log(NULL, AV_LOG_DEBUG, "keyframe_count = %ld\n", sc->keyframe_count);
1130 #endif
1131     sc->keyframes = av_malloc(entries * sizeof(long));
1132     if (!sc->keyframes)
1133         return -1;
1134     for(i=0; i<entries; i++) {
1135         sc->keyframes[i] = get_be32(pb);
1136 #ifdef DEBUG
1137 /*        av_log(NULL, AV_LOG_DEBUG, "keyframes[]=%ld\n", sc->keyframes[i]); */
1138 #endif
1139     }
1140     return 0;
1141 }
1142
1143 static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1144 {
1145     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1146     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1147     unsigned int i, entries, sample_size;
1148
1149     get_byte(pb); /* version */
1150     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1151
1152     sample_size = get_be32(pb);
1153     if (!sc->sample_size) /* do not overwrite value computed in stsd */
1154         sc->sample_size = sample_size;
1155     entries = get_be32(pb);
1156     if(entries >= UINT_MAX / sizeof(long))
1157         return -1;
1158
1159     sc->sample_count = entries;
1160     if (sample_size)
1161         return 0;
1162
1163 #ifdef DEBUG
1164     av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
1165 #endif
1166     sc->sample_sizes = av_malloc(entries * sizeof(long));
1167     if (!sc->sample_sizes)
1168         return -1;
1169     for(i=0; i<entries; i++) {
1170         sc->sample_sizes[i] = get_be32(pb);
1171 #ifdef DEBUG
1172         av_log(NULL, AV_LOG_DEBUG, "sample_sizes[]=%ld\n", sc->sample_sizes[i]);
1173 #endif
1174     }
1175     return 0;
1176 }
1177
1178 static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1179 {
1180     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1181     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1182     unsigned int i, entries;
1183     int64_t duration=0;
1184     int64_t total_sample_count=0;
1185
1186     get_byte(pb); /* version */
1187     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1188     entries = get_be32(pb);
1189     if(entries >= UINT_MAX / sizeof(Time2Sample))
1190         return -1;
1191
1192     sc->stts_count = entries;
1193     sc->stts_data = av_malloc(entries * sizeof(Time2Sample));
1194
1195 #ifdef DEBUG
1196 av_log(NULL, AV_LOG_DEBUG, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
1197 #endif
1198
1199     sc->time_rate=0;
1200
1201     for(i=0; i<entries; i++) {
1202         int sample_duration;
1203         int sample_count;
1204
1205         sample_count=get_be32(pb);
1206         sample_duration = get_be32(pb);
1207         sc->stts_data[i].count= sample_count;
1208         sc->stts_data[i].duration= sample_duration;
1209
1210         sc->time_rate= ff_gcd(sc->time_rate, sample_duration);
1211
1212         dprintf("sample_count=%d, sample_duration=%d\n",sample_count,sample_duration);
1213
1214         duration+=(int64_t)sample_duration*sample_count;
1215         total_sample_count+=sample_count;
1216     }
1217
1218     st->nb_frames= total_sample_count;
1219     if(duration)
1220         st->duration= duration;
1221     return 0;
1222 }
1223
1224 static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1225 {
1226     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1227     MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1228     unsigned int i, entries;
1229
1230     get_byte(pb); /* version */
1231     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1232     entries = get_be32(pb);
1233     if(entries >= UINT_MAX / sizeof(Time2Sample))
1234         return -1;
1235
1236     sc->ctts_count = entries;
1237     sc->ctts_data = av_malloc(entries * sizeof(Time2Sample));
1238
1239     dprintf("track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
1240
1241     for(i=0; i<entries; i++) {
1242         int count    =get_be32(pb);
1243         int duration =get_be32(pb);
1244
1245         if (duration < 0) {
1246             av_log(c->fc, AV_LOG_ERROR, "negative ctts, ignoring\n");
1247             sc->ctts_count = 0;
1248             url_fskip(pb, 8 * (entries - i - 1));
1249             break;
1250         }
1251         sc->ctts_data[i].count   = count;
1252         sc->ctts_data[i].duration= duration;
1253
1254         sc->time_rate= ff_gcd(sc->time_rate, duration);
1255     }
1256     return 0;
1257 }
1258
1259 static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1260 {
1261     AVStream *st;
1262     MOVStreamContext *sc;
1263
1264     st = av_new_stream(c->fc, c->fc->nb_streams);
1265     if (!st) return -2;
1266     sc = av_mallocz(sizeof(MOVStreamContext));
1267     if (!sc) {
1268         av_free(st);
1269         return -1;
1270     }
1271
1272     st->priv_data = sc;
1273     st->codec->codec_type = CODEC_TYPE_DATA;
1274     st->start_time = 0; /* XXX: check */
1275     c->streams[c->fc->nb_streams-1] = sc;
1276
1277     return mov_read_default(c, pb, atom);
1278 }
1279
1280 static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1281 {
1282     AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1283     int version = get_byte(pb);
1284
1285     get_byte(pb); get_byte(pb);
1286     get_byte(pb); /* flags */
1287     /*
1288     MOV_TRACK_ENABLED 0x0001
1289     MOV_TRACK_IN_MOVIE 0x0002
1290     MOV_TRACK_IN_PREVIEW 0x0004
1291     MOV_TRACK_IN_POSTER 0x0008
1292     */
1293
1294     if (version == 1) {
1295         get_be64(pb);
1296         get_be64(pb);
1297     } else {
1298         get_be32(pb); /* creation time */
1299         get_be32(pb); /* modification time */
1300     }
1301     st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/
1302     get_be32(pb); /* reserved */
1303     st->start_time = 0; /* check */
1304     (version == 1) ? get_be64(pb) : get_be32(pb); /* highlevel (considering edits) duration in movie timebase */
1305     get_be32(pb); /* reserved */
1306     get_be32(pb); /* reserved */
1307
1308     get_be16(pb); /* layer */
1309     get_be16(pb); /* alternate group */
1310     get_be16(pb); /* volume */
1311     get_be16(pb); /* reserved */
1312
1313     url_fskip(pb, 36); /* display matrix */
1314
1315     /* those are fixed-point */
1316     get_be32(pb); /* track width */
1317     get_be32(pb); /* track height */
1318
1319     return 0;
1320 }
1321
1322 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
1323 /* like the files created with Adobe Premiere 5.0, for samples see */
1324 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
1325 static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1326 {
1327     int err;
1328
1329     if (atom.size < 8)
1330         return 0; /* continue */
1331     if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
1332         url_fskip(pb, atom.size - 4);
1333         return 0;
1334     }
1335     atom.type = get_le32(pb);
1336     atom.offset += 8;
1337     atom.size -= 8;
1338     if (atom.type != MKTAG('m', 'd', 'a', 't')) {
1339         url_fskip(pb, atom.size);
1340         return 0;
1341     }
1342     err = mov_read_mdat(c, pb, atom);
1343     return err;
1344 }
1345
1346
1347 #ifdef CONFIG_ZLIB
1348 static int null_read_packet(void *opaque, uint8_t *buf, int buf_size)
1349 {
1350     return -1;
1351 }
1352
1353 static int mov_read_cmov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1354 {
1355     ByteIOContext ctx;
1356     uint8_t *cmov_data;
1357     uint8_t *moov_data; /* uncompressed data */
1358     long cmov_len, moov_len;
1359     int ret;
1360
1361     get_be32(pb); /* dcom atom */
1362     if (get_le32(pb) != MKTAG( 'd', 'c', 'o', 'm' ))
1363         return -1;
1364     if (get_le32(pb) != MKTAG( 'z', 'l', 'i', 'b' )) {
1365         av_log(NULL, AV_LOG_ERROR, "unknown compression for cmov atom !");
1366         return -1;
1367     }
1368     get_be32(pb); /* cmvd atom */
1369     if (get_le32(pb) != MKTAG( 'c', 'm', 'v', 'd' ))
1370         return -1;
1371     moov_len = get_be32(pb); /* uncompressed size */
1372     cmov_len = atom.size - 6 * 4;
1373
1374     cmov_data = av_malloc(cmov_len);
1375     if (!cmov_data)
1376         return -1;
1377     moov_data = av_malloc(moov_len);
1378     if (!moov_data) {
1379         av_free(cmov_data);
1380         return -1;
1381     }
1382     get_buffer(pb, cmov_data, cmov_len);
1383     if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
1384         return -1;
1385     if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, null_read_packet, NULL, NULL) != 0)
1386         return -1;
1387     ctx.buf_end = ctx.buffer + moov_len;
1388     atom.type = MKTAG( 'm', 'o', 'o', 'v' );
1389     atom.offset = 0;
1390     atom.size = moov_len;
1391 #ifdef DEBUG
1392 //    { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
1393 #endif
1394     ret = mov_read_default(c, &ctx, atom);
1395     av_free(moov_data);
1396     av_free(cmov_data);
1397
1398     return ret;
1399 }
1400 #endif
1401
1402 /* edit list atom */
1403 static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1404 {
1405     int i, edit_count;
1406
1407     get_byte(pb); /* version */
1408     get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1409     edit_count= c->streams[c->fc->nb_streams-1]->edit_count = get_be32(pb);     /* entries */
1410
1411     for(i=0; i<edit_count; i++){
1412         get_be32(pb); /* Track duration */
1413         get_be32(pb); /* Media time */
1414         get_be32(pb); /* Media rate */
1415     }
1416     dprintf("track[%i].edit_count = %i\n", c->fc->nb_streams-1, c->streams[c->fc->nb_streams-1]->edit_count);
1417     return 0;
1418 }
1419
1420 static const MOVParseTableEntry mov_default_parse_table[] = {
1421 /* mp4 atoms */
1422 { MKTAG( 'c', 'o', '6', '4' ), mov_read_stco },
1423 { MKTAG( 'c', 'p', 'r', 't' ), mov_read_default },
1424 { MKTAG( 'c', 'r', 'h', 'd' ), mov_read_default },
1425 { MKTAG( 'c', 't', 't', 's' ), mov_read_ctts }, /* composition time to sample */
1426 { MKTAG( 'd', 'i', 'n', 'f' ), mov_read_default }, /* data information */
1427 { MKTAG( 'd', 'p', 'n', 'd' ), mov_read_leaf },
1428 { MKTAG( 'd', 'r', 'e', 'f' ), mov_read_leaf },
1429 { MKTAG( 'e', 'd', 't', 's' ), mov_read_default },
1430 { MKTAG( 'e', 'l', 's', 't' ), mov_read_elst },
1431 { MKTAG( 'e', 'n', 'd', 'a' ), mov_read_enda },
1432 { MKTAG( 'f', 'r', 'e', 'e' ), mov_read_leaf },
1433 { MKTAG( 'f', 't', 'y', 'p' ), mov_read_ftyp },
1434 { MKTAG( 'h', 'd', 'l', 'r' ), mov_read_hdlr },
1435 { MKTAG( 'h', 'i', 'n', 't' ), mov_read_leaf },
1436 { MKTAG( 'h', 'm', 'h', 'd' ), mov_read_leaf },
1437 { MKTAG( 'i', 'o', 'd', 's' ), mov_read_leaf },
1438 { MKTAG( 'j', 'p', '2', 'h' ), mov_read_jp2h },
1439 { MKTAG( 'm', 'd', 'a', 't' ), mov_read_mdat },
1440 { MKTAG( 'm', 'd', 'h', 'd' ), mov_read_mdhd },
1441 { MKTAG( 'm', 'd', 'i', 'a' ), mov_read_default },
1442 { MKTAG( 'm', 'i', 'n', 'f' ), mov_read_default },
1443 { MKTAG( 'm', 'o', 'o', 'v' ), mov_read_moov },
1444 { MKTAG( 'm', 'p', '4', 'a' ), mov_read_default },
1445 { MKTAG( 'm', 'p', '4', 's' ), mov_read_default },
1446 { MKTAG( 'm', 'p', '4', 'v' ), mov_read_default },
1447 { MKTAG( 'm', 'p', 'o', 'd' ), mov_read_leaf },
1448 { MKTAG( 'm', 'v', 'h', 'd' ), mov_read_mvhd },
1449 { MKTAG( 'n', 'm', 'h', 'd' ), mov_read_leaf },
1450 { MKTAG( 'o', 'd', 'h', 'd' ), mov_read_default },
1451 { MKTAG( 's', 'd', 'h', 'd' ), mov_read_default },
1452 { MKTAG( 's', 'k', 'i', 'p' ), mov_read_leaf },
1453 { MKTAG( 's', 'm', 'h', 'd' ), mov_read_leaf }, /* sound media info header */
1454 { MKTAG( 'S', 'M', 'I', ' ' ), mov_read_smi }, /* Sorenson extension ??? */
1455 { MKTAG( 'a', 'l', 'a', 'c' ), mov_read_alac }, /* alac specific atom */
1456 { MKTAG( 'a', 'v', 'c', 'C' ), mov_read_avcC },
1457 { MKTAG( 's', 't', 'b', 'l' ), mov_read_default },
1458 { MKTAG( 's', 't', 'c', 'o' ), mov_read_stco },
1459 { MKTAG( 's', 't', 'd', 'p' ), mov_read_default },
1460 { MKTAG( 's', 't', 's', 'c' ), mov_read_stsc },
1461 { MKTAG( 's', 't', 's', 'd' ), mov_read_stsd }, /* sample description */
1462 { MKTAG( 's', 't', 's', 'h' ), mov_read_default },
1463 { MKTAG( 's', 't', 's', 's' ), mov_read_stss }, /* sync sample */
1464 { MKTAG( 's', 't', 's', 'z' ), mov_read_stsz }, /* sample size */
1465 { MKTAG( 's', 't', 't', 's' ), mov_read_stts },
1466 { MKTAG( 't', 'k', 'h', 'd' ), mov_read_tkhd }, /* track header */
1467 { MKTAG( 't', 'r', 'a', 'k' ), mov_read_trak },
1468 { MKTAG( 't', 'r', 'e', 'f' ), mov_read_default }, /* not really */
1469 { MKTAG( 'u', 'd', 't', 'a' ), mov_read_leaf },
1470 { MKTAG( 'u', 'r', 'l', ' ' ), mov_read_leaf },
1471 { MKTAG( 'u', 'r', 'n', ' ' ), mov_read_leaf },
1472 { MKTAG( 'u', 'u', 'i', 'd' ), mov_read_leaf },
1473 { MKTAG( 'v', 'm', 'h', 'd' ), mov_read_leaf }, /* video media info header */
1474 { MKTAG( 'w', 'a', 'v', 'e' ), mov_read_wave },
1475 /* extra mp4 */
1476 { MKTAG( 'M', 'D', 'E', 'S' ), mov_read_leaf },
1477 /* QT atoms */
1478 { MKTAG( 'c', 'h', 'a', 'p' ), mov_read_leaf },
1479 { MKTAG( 'c', 'l', 'i', 'p' ), mov_read_default },
1480 { MKTAG( 'c', 'r', 'g', 'n' ), mov_read_leaf },
1481 { MKTAG( 'c', 't', 'a', 'b' ), mov_read_ctab },
1482 { MKTAG( 'e', 's', 'd', 's' ), mov_read_esds },
1483 { MKTAG( 'k', 'm', 'a', 't' ), mov_read_leaf },
1484 { MKTAG( 'm', 'a', 't', 't' ), mov_read_default },
1485 { MKTAG( 'r', 'd', 'r', 'f' ), mov_read_leaf },
1486 { MKTAG( 'r', 'm', 'd', 'a' ), mov_read_default },
1487 { MKTAG( 'r', 'm', 'd', 'r' ), mov_read_leaf },
1488 { MKTAG( 'r', 'm', 'r', 'a' ), mov_read_default },
1489 { MKTAG( 's', 'c', 'p', 't' ), mov_read_leaf },
1490 { MKTAG( 's', 's', 'r', 'c' ), mov_read_leaf },
1491 { MKTAG( 's', 'y', 'n', 'c' ), mov_read_leaf },
1492 { MKTAG( 't', 'c', 'm', 'd' ), mov_read_leaf },
1493 { MKTAG( 'w', 'i', 'd', 'e' ), mov_read_wide }, /* place holder */
1494 //{ MKTAG( 'r', 'm', 'q', 'u' ), mov_read_leaf },
1495 #ifdef CONFIG_ZLIB
1496 { MKTAG( 'c', 'm', 'o', 'v' ), mov_read_cmov },
1497 #else
1498 { MKTAG( 'c', 'm', 'o', 'v' ), mov_read_leaf },
1499 #endif
1500 { 0L, mov_read_leaf }
1501 };
1502
1503 static void mov_free_stream_context(MOVStreamContext *sc)
1504 {
1505     if(sc) {
1506         av_freep(&sc->ctts_data);
1507         av_freep(&sc);
1508     }
1509 }
1510
1511 /* XXX: is it sufficient ? */
1512 static int mov_probe(AVProbeData *p)
1513 {
1514     unsigned int offset;
1515     uint32_t tag;
1516     int score = 0;
1517
1518     /* check file header */
1519     if (p->buf_size <= 12)
1520         return 0;
1521     offset = 0;
1522     for(;;) {
1523         /* ignore invalid offset */
1524         if ((offset + 8) > (unsigned int)p->buf_size)
1525             return score;
1526         tag = LE_32(p->buf + offset + 4);
1527         switch(tag) {
1528         /* check for obvious tags */
1529         case MKTAG( 'j', 'P', ' ', ' ' ): /* jpeg 2000 signature */
1530         case MKTAG( 'm', 'o', 'o', 'v' ):
1531         case MKTAG( 'm', 'd', 'a', 't' ):
1532         case MKTAG( 'p', 'n', 'o', 't' ): /* detect movs with preview pics like ew.mov and april.mov */
1533         case MKTAG( 'u', 'd', 't', 'a' ): /* Packet Video PVAuthor adds this and a lot of more junk */
1534             return AVPROBE_SCORE_MAX;
1535         /* those are more common words, so rate then a bit less */
1536         case MKTAG( 'w', 'i', 'd', 'e' ):
1537         case MKTAG( 'f', 'r', 'e', 'e' ):
1538         case MKTAG( 'j', 'u', 'n', 'k' ):
1539         case MKTAG( 'p', 'i', 'c', 't' ):
1540             return AVPROBE_SCORE_MAX - 5;
1541         case MKTAG( 'f', 't', 'y', 'p' ):
1542         case MKTAG( 's', 'k', 'i', 'p' ):
1543         case MKTAG( 'u', 'u', 'i', 'd' ):
1544             offset = BE_32(p->buf+offset) + offset;
1545             /* if we only find those cause probedata is too small at least rate them */
1546             score = AVPROBE_SCORE_MAX - 50;
1547             break;
1548         default:
1549             /* unrecognized tag */
1550             return score;
1551         }
1552     }
1553     return score;
1554 }
1555
1556 static void mov_build_index(MOVContext *mov, AVStream *st)
1557 {
1558     MOVStreamContext *sc = st->priv_data;
1559     offset_t current_offset;
1560     int64_t current_dts = 0;
1561     int stts_index = 0;
1562     int stsc_index = 0;
1563     int stss_index = 0;
1564     int i, j, k;
1565
1566     if (sc->sample_sizes || st->codec->codec_type == CODEC_TYPE_VIDEO || sc->dv_audio_container) {
1567         int keyframe, sample_size;
1568         int current_sample = 0;
1569         int stts_sample = 0;
1570         int distance = 0;
1571
1572         st->nb_frames = sc->sample_count;
1573         for (i = 0; i < sc->chunk_count; i++) {
1574             current_offset = sc->chunk_offsets[i];
1575             if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first)
1576                 stsc_index++;
1577             for (j = 0; j < sc->sample_to_chunk[stsc_index].count; j++) {
1578                 keyframe = !sc->keyframe_count || current_sample + 1 == sc->keyframes[stss_index];
1579                 if (keyframe) {
1580                     distance = 0;
1581                     if (stss_index + 1 < sc->keyframe_count)
1582                         stss_index++;
1583                 }
1584                 sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
1585                 dprintf("AVIndex stream %d, sample %d, offset %llx, dts %lld, size %d, distance %d, keyframe %d\n",
1586                         st->index, current_sample, current_offset, current_dts, sample_size, distance, keyframe);
1587                 av_add_index_entry(st, current_offset, current_dts, sample_size, distance, keyframe ? AVINDEX_KEYFRAME : 0);
1588                 current_offset += sample_size;
1589                 assert(sc->stts_data[stts_index].duration % sc->time_rate == 0);
1590                 current_dts += sc->stts_data[stts_index].duration / sc->time_rate;
1591                 distance++;
1592                 stts_sample++;
1593                 if (current_sample + 1 < sc->sample_count)
1594                     current_sample++;
1595                 if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
1596                     stts_sample = 0;
1597                     stts_index++;
1598                 }
1599             }
1600         }
1601     } else { /* read whole chunk */
1602         int chunk_samples, chunk_size, chunk_duration;
1603
1604         for (i = 0; i < sc->chunk_count; i++) {
1605             current_offset = sc->chunk_offsets[i];
1606             if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first)
1607                 stsc_index++;
1608             chunk_samples = sc->sample_to_chunk[stsc_index].count;
1609             /* get chunk size */
1610             if (sc->sample_size > 1 || st->codec->codec_id == CODEC_ID_PCM_U8 || st->codec->codec_id == CODEC_ID_PCM_S8)
1611                 chunk_size = chunk_samples * sc->sample_size;
1612             else if (sc->sample_size_v1.den > 0 && (chunk_samples * sc->sample_size_v1.num % sc->sample_size_v1.den == 0))
1613                 chunk_size = chunk_samples * sc->sample_size_v1.num / sc->sample_size_v1.den;
1614             else { /* workaround to find nearest next chunk offset */
1615                 chunk_size = INT_MAX;
1616                 for (j = 0; j < mov->total_streams; j++) {
1617                     MOVStreamContext *msc = mov->streams[j];
1618
1619                     for (k = msc->next_chunk; k < msc->chunk_count; k++) {
1620                         if (msc->chunk_offsets[k] > current_offset && msc->chunk_offsets[k] - current_offset < chunk_size) {
1621                             chunk_size = msc->chunk_offsets[k] - current_offset;
1622                             msc->next_chunk = k;
1623                             break;
1624                         }
1625                     }
1626                 }
1627                 /* check for last chunk */
1628                 if (chunk_size == INT_MAX)
1629                     for (j = 0; j < mov->mdat_count; j++) {
1630                         dprintf("mdat %d, offset %llx, size %lld, current offset %llx\n",
1631                                 j, mov->mdat_list[j].offset, mov->mdat_list[j].size, current_offset);
1632                         if (mov->mdat_list[j].offset <= current_offset && mov->mdat_list[j].offset + mov->mdat_list[j].size > current_offset)
1633                             chunk_size = mov->mdat_list[j].offset + mov->mdat_list[j].size - current_offset;
1634                     }
1635                 assert(chunk_size != INT_MAX);
1636                 for (j = 0; j < mov->total_streams; j++) {
1637                     mov->streams[j]->next_chunk = 0;
1638                 }
1639             }
1640             av_add_index_entry(st, current_offset, current_dts, chunk_size, 0, AVINDEX_KEYFRAME);
1641             /* get chunk duration */
1642             chunk_duration = 0;
1643             while (chunk_samples > 0) {
1644                 if (chunk_samples < sc->stts_data[stts_index].count) {
1645                     chunk_duration += sc->stts_data[stts_index].duration * chunk_samples;
1646                     sc->stts_data[stts_index].count -= chunk_samples;
1647                     break;
1648                 } else {
1649                     chunk_duration += sc->stts_data[stts_index].duration * chunk_samples;
1650                     chunk_samples -= sc->stts_data[stts_index].count;
1651                     if (stts_index + 1 < sc->stts_count) {
1652                         stts_index++;
1653                     }
1654                 }
1655             }
1656             dprintf("AVIndex stream %d, chunk %d, offset %llx, dts %lld, size %d, duration %d\n",
1657                     st->index, i, current_offset, current_dts, chunk_size, chunk_duration);
1658             assert(chunk_duration % sc->time_rate == 0);
1659             current_dts += chunk_duration / sc->time_rate;
1660         }
1661     }
1662     /* adjust sample count to avindex entries */
1663     sc->sample_count = st->nb_index_entries;
1664 }
1665
1666 static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
1667 {
1668     MOVContext *mov = (MOVContext *) s->priv_data;
1669     ByteIOContext *pb = &s->pb;
1670     int i, err;
1671     MOV_atom_t atom = { 0, 0, 0 };
1672
1673     mov->fc = s;
1674     mov->parse_table = mov_default_parse_table;
1675
1676     if(!url_is_streamed(pb)) /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
1677         atom.size = url_fsize(pb);
1678     else
1679         atom.size = 0x7FFFFFFFFFFFFFFFLL;
1680
1681     /* check MOV header */
1682     err = mov_read_default(mov, pb, atom);
1683     if (err<0 || (!mov->found_moov && !mov->found_mdat)) {
1684         av_log(s, AV_LOG_ERROR, "mov: header not found !!! (err:%d, moov:%d, mdat:%d) pos:%"PRId64"\n",
1685                 err, mov->found_moov, mov->found_mdat, url_ftell(pb));
1686         return -1;
1687     }
1688     dprintf("on_parse_exit_offset=%d\n", (int) url_ftell(pb));
1689
1690     /* some cleanup : make sure we are on the mdat atom */
1691     if(!url_is_streamed(pb) && (url_ftell(pb) != mov->mdat_offset))
1692         url_fseek(pb, mov->mdat_offset, SEEK_SET);
1693
1694     mov->total_streams = s->nb_streams;
1695
1696     for(i=0; i<mov->total_streams; i++) {
1697         MOVStreamContext *sc = mov->streams[i];
1698
1699         if(!sc->time_rate)
1700             sc->time_rate=1;
1701         if(!sc->time_scale)
1702             sc->time_scale= mov->time_scale;
1703         av_set_pts_info(s->streams[i], 64, sc->time_rate, sc->time_scale);
1704
1705         if(s->streams[i]->duration != AV_NOPTS_VALUE){
1706             assert(s->streams[i]->duration % sc->time_rate == 0);
1707             s->streams[i]->duration /= sc->time_rate;
1708         }
1709         sc->ffindex = i;
1710         mov_build_index(mov, s->streams[i]);
1711     }
1712
1713     for(i=0; i<mov->total_streams; i++) {
1714         /* dont need those anymore */
1715         av_freep(&mov->streams[i]->chunk_offsets);
1716         av_freep(&mov->streams[i]->sample_to_chunk);
1717         av_freep(&mov->streams[i]->sample_sizes);
1718         av_freep(&mov->streams[i]->keyframes);
1719         av_freep(&mov->streams[i]->stts_data);
1720     }
1721     av_freep(&mov->mdat_list);
1722     return 0;
1723 }
1724
1725 static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
1726 {
1727     MOVContext *mov = s->priv_data;
1728     MOVStreamContext *sc = 0;
1729     AVIndexEntry *sample = 0;
1730     int64_t best_dts = INT64_MAX;
1731     int i;
1732
1733     for (i = 0; i < mov->total_streams; i++) {
1734         MOVStreamContext *msc = mov->streams[i];
1735
1736         if (s->streams[i]->discard != AVDISCARD_ALL && msc->current_sample < msc->sample_count) {
1737             AVIndexEntry *current_sample = &s->streams[i]->index_entries[msc->current_sample];
1738             int64_t dts = av_rescale(current_sample->timestamp * (int64_t)msc->time_rate, AV_TIME_BASE, msc->time_scale);
1739
1740             dprintf("stream %d, sample %ld, dts %lld\n", i, msc->current_sample, dts);
1741             if (dts < best_dts) {
1742                 sample = current_sample;
1743                 best_dts = dts;
1744                 sc = msc;
1745             }
1746         }
1747     }
1748     if (!sample)
1749         return -1;
1750     /* must be done just before reading, to avoid infinite loop on sample */
1751     sc->current_sample++;
1752     if (sample->pos >= url_fsize(&s->pb)) {
1753         av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%llx: partial file\n", sc->ffindex, sample->pos);
1754         return -1;
1755     }
1756 #ifdef CONFIG_DV_DEMUXER
1757     if (sc->dv_audio_container) {
1758         dv_get_packet(mov->dv_demux, pkt);
1759         dprintf("dv audio pkt size %d\n", pkt->size);
1760     } else {
1761 #endif
1762         url_fseek(&s->pb, sample->pos, SEEK_SET);
1763         av_get_packet(&s->pb, pkt, sample->size);
1764 #ifdef CONFIG_DV_DEMUXER
1765         if (mov->dv_demux) {
1766             void *pkt_destruct_func = pkt->destruct;
1767             dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);
1768             pkt->destruct = pkt_destruct_func;
1769         }
1770     }
1771 #endif
1772     pkt->stream_index = sc->ffindex;
1773     pkt->dts = sample->timestamp;
1774     if (sc->ctts_data) {
1775         assert(sc->ctts_data[sc->sample_to_ctime_index].duration % sc->time_rate == 0);
1776         pkt->pts = pkt->dts + sc->ctts_data[sc->sample_to_ctime_index].duration / sc->time_rate;
1777         /* update ctts context */
1778         sc->sample_to_ctime_sample++;
1779         if (sc->sample_to_ctime_index < sc->ctts_count && sc->ctts_data[sc->sample_to_ctime_index].count == sc->sample_to_ctime_sample) {
1780             sc->sample_to_ctime_index++;
1781             sc->sample_to_ctime_sample = 0;
1782         }
1783     } else {
1784         pkt->pts = pkt->dts;
1785     }
1786     pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0;
1787     pkt->pos = sample->pos;
1788     dprintf("stream %d, pts %lld, dts %lld, pos 0x%llx, duration %d\n", pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
1789     return 0;
1790 }
1791
1792 static int mov_seek_stream(AVStream *st, int64_t timestamp, int flags)
1793 {
1794     MOVStreamContext *sc = st->priv_data;
1795     int sample, time_sample;
1796     int i;
1797
1798     sample = av_index_search_timestamp(st, timestamp, flags);
1799     dprintf("stream %d, timestamp %lld, sample %d\n", st->index, timestamp, sample);
1800     if (sample < 0) /* not sure what to do */
1801         return -1;
1802     sc->current_sample = sample;
1803     dprintf("stream %d, found sample %ld\n", st->index, sc->current_sample);
1804     /* adjust ctts index */
1805     if (sc->ctts_data) {
1806         time_sample = 0;
1807         for (i = 0; i < sc->ctts_count; i++) {
1808             time_sample += sc->ctts_data[i].count;
1809             if (time_sample >= sc->current_sample) {
1810                 sc->sample_to_ctime_index = i;
1811                 sc->sample_to_ctime_sample = time_sample - sc->current_sample;
1812                 break;
1813             }
1814         }
1815     }
1816     return sample;
1817 }
1818
1819 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
1820 {
1821     AVStream *st;
1822     int64_t seek_timestamp, timestamp;
1823     int sample;
1824     int i;
1825
1826     if (stream_index >= s->nb_streams)
1827         return -1;
1828
1829     st = s->streams[stream_index];
1830     sample = mov_seek_stream(st, sample_time, flags);
1831     if (sample < 0)
1832         return -1;
1833
1834     /* adjust seek timestamp to found sample timestamp */
1835     seek_timestamp = st->index_entries[sample].timestamp;
1836
1837     for (i = 0; i < s->nb_streams; i++) {
1838         st = s->streams[i];
1839         if (stream_index == i || st->discard == AVDISCARD_ALL)
1840             continue;
1841
1842         timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
1843         mov_seek_stream(st, timestamp, flags);
1844     }
1845     return 0;
1846 }
1847
1848 static int mov_read_close(AVFormatContext *s)
1849 {
1850     int i;
1851     MOVContext *mov = (MOVContext *) s->priv_data;
1852     for(i=0; i<mov->total_streams; i++)
1853         mov_free_stream_context(mov->streams[i]);
1854     /* free color tabs */
1855     for(i=0; i<mov->ctab_size; i++)
1856         av_freep(&mov->ctab[i]);
1857     if(mov->dv_demux){
1858         for(i=0; i<mov->dv_fctx->nb_streams; i++){
1859             av_freep(&mov->dv_fctx->streams[i]->codec);
1860             av_freep(&mov->dv_fctx->streams[i]);
1861         }
1862         av_freep(&mov->dv_fctx);
1863         av_freep(&mov->dv_demux);
1864     }
1865     av_freep(&mov->ctab);
1866     return 0;
1867 }
1868
1869 AVInputFormat mov_demuxer = {
1870     "mov,mp4,m4a,3gp,3g2,mj2",
1871     "QuickTime/MPEG4/Motion JPEG 2000 format",
1872     sizeof(MOVContext),
1873     mov_probe,
1874     mov_read_header,
1875     mov_read_packet,
1876     mov_read_close,
1877     mov_read_seek,
1878 };