Statistics
| Branch: | Revision:

ffmpeg / libavformat / mov.c @ e60b4ced

History | View | Annotate | Download (85 KB)

1
/*
2
 * MOV decoder.
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
 */
19

    
20
#include <limits.h>
21

    
22
#include "avformat.h"
23
#include "avi.h"
24
#include "mov.h"
25

    
26
#ifdef CONFIG_ZLIB
27
#include <zlib.h>
28
#endif
29

    
30
/*
31
 * First version by Francois Revol revol@free.fr
32
 * Seek function by Gael Chardon gael.dev@4now.net
33
 *
34
 * Features and limitations:
35
 * - reads most of the QT files I have (at least the structure),
36
 *   the exceptions are .mov with zlib compressed headers ('cmov' section). It shouldn't be hard to implement.
37
 *   FIXED, Francois Revol, 07/17/2002
38
 * - ffmpeg has nearly none of the usual QuickTime codecs,
39
 *   although I succesfully dumped raw and mp3 audio tracks off .mov files.
40
 *   Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html
41
 * - .mp4 parsing is still hazardous, although the format really is QuickTime with some minor changes
42
 *   (to make .mov parser crash maybe ?), despite what they say in the MPEG FAQ at
43
 *   http://mpeg.telecomitalialab.com/faq.htm
44
 * - the code is quite ugly... maybe I won't do it recursive next time :-)
45
 * - seek is not supported with files that contain edit list
46
 *
47
 * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/
48
 * when coding this :) (it's a writer anyway)
49
 *
50
 * Reference documents:
51
 * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt
52
 * Apple:
53
 *  http://developer.apple.com/documentation/QuickTime/QTFF/
54
 *  http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf
55
 * QuickTime is a trademark of Apple (AFAIK :))
56
 */
57

    
58
//#define DEBUG
59
#ifdef DEBUG
60
#include <stdio.h>
61
#include <fcntl.h>
62
#endif
63

    
64
#include "qtpalette.h"
65

    
66

    
67
#undef NDEBUG
68
#include <assert.h>
69

    
70
/* Allows seeking (MOV_SPLIT_CHUNKS should also be defined) */
71
#define MOV_SEEK
72

    
73
/* allows chunk splitting - should work now... */
74
/* in case you can't read a file, try commenting */
75
#define MOV_SPLIT_CHUNKS
76

    
77
/* Special handling for movies created with Minolta Dimaxe Xi*/
78
/* this fix should not interfere with other .mov files, but just in case*/
79
#define MOV_MINOLTA_FIX
80

    
81
/* some streams in QT (and in MP4 mostly) aren't either video nor audio */
82
/* so we first list them as this, then clean up the list of streams we give back, */
83
/* getting rid of these */
84
#define CODEC_TYPE_MOV_OTHER    (enum CodecType) 2
85

    
86
/* http://gpac.sourceforge.net/tutorial/mediatypes.htm */
87
const CodecTag ff_mov_obj_type[] = {
88
    { CODEC_ID_MPEG4     ,  32 },
89
    { CODEC_ID_H264      ,  33 },
90
    { CODEC_ID_AAC       ,  64 },
91
    { CODEC_ID_MPEG2VIDEO,  96 }, /* MPEG2 Simple */
92
    { CODEC_ID_MPEG2VIDEO,  97 }, /* MPEG2 Main */
93
    { CODEC_ID_MPEG2VIDEO,  98 }, /* MPEG2 SNR */
94
    { CODEC_ID_MPEG2VIDEO,  99 }, /* MPEG2 Spatial */
95
    { CODEC_ID_MPEG2VIDEO, 100 }, /* MPEG2 High */
96
    { CODEC_ID_MPEG2VIDEO, 101 }, /* MPEG2 422 */
97
    { CODEC_ID_AAC       , 102 }, /* MPEG2 AAC Main */
98
    { CODEC_ID_AAC       , 103 }, /* MPEG2 AAC Low */
99
    { CODEC_ID_AAC       , 104 }, /* MPEG2 AAC SSR */
100
    { CODEC_ID_MP3       , 105 },
101
    { CODEC_ID_MPEG1VIDEO, 106 },
102
    { CODEC_ID_MP2       , 107 },
103
    { CODEC_ID_MJPEG     , 108 },
104
    { CODEC_ID_PCM_S16LE , 224 },
105
    { CODEC_ID_VORBIS    , 225 },
106
    { CODEC_ID_AC3       , 226 },
107
    { CODEC_ID_PCM_ALAW  , 227 },
108
    { CODEC_ID_PCM_MULAW , 228 },
109
    { CODEC_ID_PCM_S16BE , 230 },
110
    { CODEC_ID_H263      , 242 },
111
    { CODEC_ID_H261      , 243 },
112
    { 0, 0 },
113
};
114

    
115
static const CodecTag mov_video_tags[] = {
116
/*  { CODEC_ID_, MKTAG('c', 'v', 'i', 'd') }, *//* Cinepak */
117
/*  { CODEC_ID_H263, MKTAG('r', 'a', 'w', ' ') }, *//* Uncompressed RGB */
118
/*  { CODEC_ID_H263, MKTAG('Y', 'u', 'v', '2') }, *//* Uncompressed YUV422 */
119
/*    { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'U', 'I') }, *//* YUV with alpha-channel (AVID Uncompressed) */
120
/* Graphics */
121
/* Animation */
122
/* Apple video */
123
/* Kodak Photo CD */
124
    { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */
125
    { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */
126
    { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */
127
    { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */
128
    { CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */
129
/*    { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, *//* MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */
130
/*    { CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, *//* embedded gif files as frames (usually one "click to play movie" frame) */
131
/* Sorenson video */
132
    { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') }, /* Sorenson Video v1 */
133
    { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') }, /* Sorenson Video v1 */
134
    { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', 'i') }, /* Sorenson Video v1 (from QT specs)*/
135
    { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') }, /* Sorenson Video v3 */
136
    { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
137
    { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, /* OpenDiVX *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
138
    { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
139
    { CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') }, /* experimental: 3IVX files before ivx D4 4.5.1 */
140
/*    { CODEC_ID_, MKTAG('I', 'V', '5', '0') }, *//* Indeo 5.0 */
141
    { CODEC_ID_H263, MKTAG('h', '2', '6', '3') }, /* H263 */
142
    { CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */
143
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */
144
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */
145
/*    { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, *//* AVID dv */
146
    { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */
147
    { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */
148
    { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */
149
    { CODEC_ID_8BPS, MKTAG('8', 'B', 'P', 'S') }, /* Planar RGB (8BPS) */
150
    { CODEC_ID_SMC, MKTAG('s', 'm', 'c', ' ') }, /* Apple Graphics (SMC) */
151
    { CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') }, /* Apple Animation (RLE) */
152
    { CODEC_ID_QDRAW, MKTAG('q', 'd', 'r', 'w') }, /* QuickDraw */
153
    { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') }, /* AVC-1/H.264 */
154
    { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '2') }, /* MPEG2 produced by Sony HD camera */
155
    { CODEC_ID_NONE, 0 },
156
};
157

    
158
static const CodecTag mov_audio_tags[] = {
159
/*    { CODEC_ID_PCM_S16BE, MKTAG('N', 'O', 'N', 'E') }, *//* uncompressed */
160
    { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') }, /* 16 bits */
161
    /* { CODEC_ID_PCM_S8, MKTAG('t', 'w', 'o', 's') },*/ /* 8 bits */
162
    { CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') }, /* 8 bits unsigned */
163
    { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') }, /*  */
164
    { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') }, /*  */
165
    { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') }, /*  */
166
    { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') }, /* IMA-4 ADPCM */
167
    { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') }, /* Macintosh Audio Compression and Expansion 3:1 */
168
    { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') }, /* Macintosh Audio Compression and Expansion 6:1 */
169

    
170
    { CODEC_ID_MP2, MKTAG('.', 'm', 'p', '3') }, /* MPEG layer 3 */ /* sample files at http://www.3ivx.com/showcase.html use this tag */
171
    { CODEC_ID_MP2, 0x6D730055 }, /* MPEG layer 3 */
172
    { CODEC_ID_MP2, 0x5500736D }, /* MPEG layer 3 *//* XXX: check endianness */
173
/*    { CODEC_ID_OGG_VORBIS, MKTAG('O', 'g', 'g', 'S') }, *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */
174
/* MP4 tags */
175
    { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') }, /* MPEG-4 AAC */
176
    /* The standard for mpeg4 audio is still not normalised AFAIK anyway */
177
    { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') }, /* AMR-NB 3gp */
178
    { CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') }, /* AMR-WB 3gp */
179
    { CODEC_ID_AC3, MKTAG('m', 's', 0x20, 0x00) }, /* Dolby AC-3 */
180
    { CODEC_ID_ALAC,MKTAG('a', 'l', 'a', 'c') }, /* Apple Lossless */
181
    { CODEC_ID_QDM2,MKTAG('Q', 'D', 'M', '2') }, /* QDM2 */
182
    { CODEC_ID_NONE, 0 },
183
};
184

    
185
/* map numeric codes from mdhd atom to ISO 639 */
186
/* cf. QTFileFormat.pdf p253, qtff.pdf p205 */
187
/* http://developer.apple.com/documentation/mac/Text/Text-368.html */
188
/* deprecated by putting the code as 3*5bit ascii */
189
static const char *mov_mdhd_language_map[] = {
190
/* 0-9 */
191
"eng", "fra", "ger", "ita", "dut", "sve", "spa", "dan", "por", "nor",
192
"heb", "jpn", "ara", "fin", "gre", "ice", "mlt", "tur", "hr "/*scr*/, "chi"/*ace?*/,
193
"urd", "hin", "tha", "kor", "lit", "pol", "hun", "est", "lav",  NULL,
194
"fo ",  NULL, "rus", "chi",  NULL, "iri", "alb", "ron", "ces", "slk",
195
"slv", "yid", "sr ", "mac", "bul", "ukr", "bel", "uzb", "kaz", "aze",
196
/*?*/
197
"aze", "arm", "geo", "mol", "kir", "tgk", "tuk", "mon",  NULL, "pus",
198
"kur", "kas", "snd", "tib", "nep", "san", "mar", "ben", "asm", "guj",
199
"pa ", "ori", "mal", "kan", "tam", "tel",  NULL, "bur", "khm", "lao",
200
/*                   roman? arabic? */
201
"vie", "ind", "tgl", "may", "may", "amh", "tir", "orm", "som", "swa",
202
/*==rundi?*/
203
 NULL, "run",  NULL, "mlg", "epo",  NULL,  NULL,  NULL,  NULL,  NULL,
204
/* 100 */
205
 NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
206
 NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
207
 NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL, "wel", "baq",
208
"cat", "lat", "que", "grn", "aym", "tat", "uig", "dzo", "jav"
209
};
210

    
211
/* the QuickTime file format is quite convoluted...
212
 * it has lots of index tables, each indexing something in another one...
213
 * Here we just use what is needed to read the chunks
214
 */
215

    
216
typedef struct MOV_sample_to_chunk_tbl {
217
    long first;
218
    long count;
219
    long id;
220
} MOV_sample_to_chunk_tbl;
221

    
222
typedef struct {
223
    uint32_t type;
224
    int64_t offset;
225
    int64_t size; /* total size (excluding the size and type fields) */
226
} MOV_atom_t;
227

    
228
typedef struct {
229
    int seed;
230
    int flags;
231
    int size;
232
    void* clrs;
233
} MOV_ctab_t;
234

    
235
typedef struct {
236
    uint8_t  version;
237
    uint32_t flags; // 24bit
238

    
239
    /* 0x03 ESDescrTag */
240
    uint16_t es_id;
241
#define MP4ODescrTag                    0x01
242
#define MP4IODescrTag                   0x02
243
#define MP4ESDescrTag                   0x03
244
#define MP4DecConfigDescrTag            0x04
245
#define MP4DecSpecificDescrTag          0x05
246
#define MP4SLConfigDescrTag             0x06
247
#define MP4ContentIdDescrTag            0x07
248
#define MP4SupplContentIdDescrTag       0x08
249
#define MP4IPIPtrDescrTag               0x09
250
#define MP4IPMPPtrDescrTag              0x0A
251
#define MP4IPMPDescrTag                 0x0B
252
#define MP4RegistrationDescrTag         0x0D
253
#define MP4ESIDIncDescrTag              0x0E
254
#define MP4ESIDRefDescrTag              0x0F
255
#define MP4FileIODescrTag               0x10
256
#define MP4FileODescrTag                0x11
257
#define MP4ExtProfileLevelDescrTag      0x13
258
#define MP4ExtDescrTagsStart            0x80
259
#define MP4ExtDescrTagsEnd              0xFE
260
    uint8_t  stream_priority;
261

    
262
    /* 0x04 DecConfigDescrTag */
263
    uint8_t  object_type_id;
264
    uint8_t  stream_type;
265
    /* XXX: really streamType is
266
     * only 6bit, followed by:
267
     * 1bit  upStream
268
     * 1bit  reserved
269
     */
270
    uint32_t buffer_size_db; // 24
271
    uint32_t max_bitrate;
272
    uint32_t avg_bitrate;
273

    
274
    /* 0x05 DecSpecificDescrTag */
275
    uint8_t  decoder_cfg_len;
276
    uint8_t *decoder_cfg;
277

    
278
    /* 0x06 SLConfigDescrTag */
279
    uint8_t  sl_config_len;
280
    uint8_t *sl_config;
281
} MOV_esds_t;
282

    
283
struct MOVParseTableEntry;
284

    
285
typedef struct Time2Sample{
286
    int count;
287
    int duration;
288
}Time2Sample;
289

    
290
typedef struct MOVStreamContext {
291
    int ffindex; /* the ffmpeg stream id */
292
    int is_ff_stream; /* Is this stream presented to ffmpeg ? i.e. is this an audio or video stream ? */
293
    long next_chunk;
294
    long chunk_count;
295
    int64_t *chunk_offsets;
296
    int stts_count;
297
    Time2Sample *stts_data;
298
    int ctts_count;
299
    Time2Sample *ctts_data;
300
    int edit_count;             /* number of 'edit' (elst atom) */
301
    long sample_to_chunk_sz;
302
    MOV_sample_to_chunk_tbl *sample_to_chunk;
303
    long sample_to_chunk_index;
304
    int sample_to_time_index;
305
    long sample_to_time_sample;
306
    uint64_t sample_to_time_time;
307
    int sample_to_ctime_index;
308
    int sample_to_ctime_sample;
309
    long sample_size;
310
    long sample_count;
311
    long *sample_sizes;
312
    long keyframe_count;
313
    long *keyframes;
314
    int time_scale;
315
    int time_rate;
316
    long current_sample;
317
    long left_in_chunk; /* how many samples before next chunk */
318
    MOV_esds_t esds;
319
} MOVStreamContext;
320

    
321
typedef struct MOVContext {
322
    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) */
323
    AVFormatContext *fc;
324
    int time_scale;
325
    int duration; /* duration of the longest track */
326
    int found_moov; /* when both 'moov' and 'mdat' sections has been found */
327
    int found_mdat; /* we suppose we have enough data to read the file */
328
    int64_t mdat_size;
329
    int64_t mdat_offset;
330
    int ni;                                         ///< non interleaved mode
331
    int total_streams;
332
    /* some streams listed here aren't presented to the ffmpeg API, since they aren't either video nor audio
333
     * but we need the info to be able to skip data from those streams in the 'mdat' section
334
     */
335
    MOVStreamContext *streams[MAX_STREAMS];
336

    
337
    int64_t next_chunk_offset;
338
    MOVStreamContext *partial; /* != 0 : there is still to read in the current chunk */
339
    int ctab_size;
340
    MOV_ctab_t **ctab;           /* color tables */
341
    const struct MOVParseTableEntry *parse_table; /* could be eventually used to change the table */
342
    /* NOTE: for recursion save to/ restore from local variable! */
343

    
344
    AVPaletteControl palette_control;
345
} MOVContext;
346

    
347

    
348
/* XXX: it's the first time I make a recursive parser I think... sorry if it's ugly :P */
349

    
350
/* those functions parse an atom */
351
/* return code:
352
 1: found what I wanted, exit
353
 0: continue to parse next atom
354
 -1: error occured, exit
355
 */
356
typedef int (*mov_parse_function)(MOVContext *ctx, ByteIOContext *pb, MOV_atom_t atom);
357

    
358
/* links atom IDs to parse functions */
359
typedef struct MOVParseTableEntry {
360
    uint32_t type;
361
    mov_parse_function func;
362
} MOVParseTableEntry;
363

    
364
#ifdef DEBUG
365
/*
366
 * XXX: static sux, even more in a multithreaded environment...
367
 * Avoid them. This is here just to help debugging.
368
 */
369
static int debug_indent = 0;
370
void print_atom(const char *str, MOV_atom_t atom)
371
{
372
    unsigned int tag, i;
373
    tag = (unsigned int) atom.type;
374
    i=debug_indent;
375
    if(tag == 0) tag = MKTAG('N', 'U', 'L', 'L');
376
    while(i--)
377
        av_log(NULL, AV_LOG_DEBUG, "|");
378
    av_log(NULL, AV_LOG_DEBUG, "parse:");
379
    av_log(NULL, AV_LOG_DEBUG, " %s: tag=%c%c%c%c offset=0x%x size=0x%x\n",
380
           str, tag & 0xff,
381
           (tag >> 8) & 0xff,
382
           (tag >> 16) & 0xff,
383
           (tag >> 24) & 0xff,
384
           (unsigned int)atom.offset,
385
           (unsigned int)atom.size);
386
    assert((unsigned int)atom.size < 0x7fffffff);// catching errors
387
}
388
#else
389
#define print_atom(a,b)
390
#endif
391

    
392
static int ff_mov_lang_to_iso639(int code, char *to)
393
{
394
    int i;
395
    /* is it the mangled iso code? */
396
    /* see http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt */
397
    if (code > 138) {
398
        for (i = 2; i >= 0; i--) {
399
            to[i] = 0x60 + (code & 0x1f);
400
            code >>= 5;
401
        }
402
        return 1;
403
    }
404
    /* old fashion apple lang code */
405
    if (code >= (sizeof(mov_mdhd_language_map)/sizeof(char *)))
406
        return 0;
407
    if (!mov_mdhd_language_map[code])
408
        return 0;
409
    strncpy(to, mov_mdhd_language_map[code], 4);
410
    return 1;
411
}
412

    
413
extern int ff_mov_iso639_to_lang(const char *lang, int mp4); /* for movenc.c */
414
int ff_mov_iso639_to_lang(const char *lang, int mp4)
415
{
416
    int i, code = 0;
417

    
418
    /* old way, only for QT? */
419
    for (i = 0; !mp4 && (i < (sizeof(mov_mdhd_language_map)/sizeof(char *))); i++) {
420
        if (mov_mdhd_language_map[i] && !strcmp(lang, mov_mdhd_language_map[i]))
421
            return i;
422
    }
423
    /* XXX:can we do that in mov too? */
424
    if (!mp4)
425
        return 0;
426
    /* handle undefined as such */
427
    if (lang[0] == '\0')
428
        lang = "und";
429
    /* 5bit ascii */
430
    for (i = 0; i < 3; i++) {
431
        unsigned char c = (unsigned char)lang[i];
432
        if (c < 0x60)
433
            return 0;
434
        if (c > 0x60 + 0x1f)
435
            return 0;
436
        code <<= 5;
437
        code |= (c - 0x60);
438
    }
439
    return code;
440
}
441

    
442
static int mov_read_leaf(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
443
{
444
    print_atom("leaf", atom);
445

    
446
    if (atom.size>1)
447
        url_fskip(pb, atom.size);
448
/*        url_seek(pb, atom_offset+atom.size, SEEK_SET); */
449
    return 0;
450
}
451

    
452
static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
453
{
454
    int64_t total_size = 0;
455
    MOV_atom_t a;
456
    int i;
457
    int err = 0;
458

    
459
#ifdef DEBUG
460
    print_atom("default", atom);
461
    debug_indent++;
462
#endif
463

    
464
    a.offset = atom.offset;
465

    
466
    if (atom.size < 0)
467
        atom.size = 0x7fffffffffffffffLL;
468
    while(((total_size + 8) < atom.size) && !url_feof(pb) && !err) {
469
        a.size = atom.size;
470
        a.type=0L;
471
        if(atom.size >= 8) {
472
            a.size = get_be32(pb);
473
            a.type = get_le32(pb);
474
        }
475
        total_size += 8;
476
        a.offset += 8;
477
        //av_log(NULL, AV_LOG_DEBUG, "type: %08x  %.4s  sz: %Lx  %Lx   %Lx\n", type, (char*)&type, size, atom.size, total_size);
478
        if (a.size == 1) { /* 64 bit extended size */
479
            a.size = get_be64(pb) - 8;
480
            a.offset += 8;
481
            total_size += 8;
482
        }
483
        if (a.size == 0) {
484
            a.size = atom.size - total_size;
485
            if (a.size <= 8)
486
                break;
487
        }
488
        for (i = 0; c->parse_table[i].type != 0L
489
             && c->parse_table[i].type != a.type; i++)
490
            /* empty */;
491

    
492
        a.size -= 8;
493

    
494
        if(a.size < 0)
495
            break;
496

    
497
//        av_log(NULL, AV_LOG_DEBUG, " i=%ld\n", i);
498
        if (c->parse_table[i].type == 0) { /* skip leaf atoms data */
499
//            url_seek(pb, atom.offset+atom.size, SEEK_SET);
500
#ifdef DEBUG
501
            print_atom("unknown", a);
502
#endif
503
            url_fskip(pb, a.size);
504
        } else {
505
#ifdef DEBUG
506
            //char b[5] = { type & 0xff, (type >> 8) & 0xff, (type >> 16) & 0xff, (type >> 24) & 0xff, 0 };
507
            //print_atom(b, type, offset, size);
508
#endif
509
            err = (c->parse_table[i].func)(c, pb, a);
510
        }
511

    
512
        a.offset += a.size;
513
        total_size += a.size;
514
    }
515

    
516
    if (!err && total_size < atom.size && atom.size < 0x7ffff) {
517
        //av_log(NULL, AV_LOG_DEBUG, "RESET  %Ld  %Ld  err:%d\n", atom.size, total_size, err);
518
        url_fskip(pb, atom.size - total_size);
519
    }
520

    
521
#ifdef DEBUG
522
    debug_indent--;
523
#endif
524
    return err;
525
}
526

    
527
static int mov_read_ctab(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
528
{
529
#if 1
530
    url_fskip(pb, atom.size); // for now
531
#else
532
    VERY VERY BROKEN, NEVER execute this, needs rewrite
533
    unsigned int len;
534
    MOV_ctab_t *t;
535
    c->ctab = av_realloc(c->ctab, ++c->ctab_size);
536
    t = c->ctab[c->ctab_size];
537
    t->seed = get_be32(pb);
538
    t->flags = get_be16(pb);
539
    t->size = get_be16(pb) + 1;
540
    len = 2 * t->size * 4;
541
    if (len > 0) {
542
        t->clrs = av_malloc(len); // 16bit A R G B
543
        if (t->clrs)
544
            get_buffer(pb, t->clrs, len);
545
    }
546
#endif
547

    
548
    return 0;
549
}
550

    
551
static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
552
{
553
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
554
    int len = 0;
555
    uint32_t type;
556
    uint32_t ctype;
557

    
558
    print_atom("hdlr", atom);
559

    
560
    get_byte(pb); /* version */
561
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
562

    
563
    /* component type */
564
    ctype = get_le32(pb);
565
    type = get_le32(pb); /* component subtype */
566

    
567
#ifdef DEBUG
568
    av_log(NULL, AV_LOG_DEBUG, "ctype= %c%c%c%c (0x%08lx)\n", *((char *)&ctype), ((char *)&ctype)[1], ((char *)&ctype)[2], ((char *)&ctype)[3], (long) ctype);
569
    av_log(NULL, AV_LOG_DEBUG, "stype= %c%c%c%c\n", *((char *)&type), ((char *)&type)[1], ((char *)&type)[2], ((char *)&type)[3]);
570
#endif
571
#ifdef DEBUG
572
/* XXX: yeah this is ugly... */
573
    if(ctype == MKTAG('m', 'h', 'l', 'r')) { /* MOV */
574
        if(type == MKTAG('v', 'i', 'd', 'e'))
575
            puts("hdlr: vide");
576
        else if(type == MKTAG('s', 'o', 'u', 'n'))
577
            puts("hdlr: soun");
578
    } else if(ctype == 0) { /* MP4 */
579
        if(type == MKTAG('v', 'i', 'd', 'e'))
580
            puts("hdlr: vide");
581
        else if(type == MKTAG('s', 'o', 'u', 'n'))
582
            puts("hdlr: soun");
583
        else if(type == MKTAG('o', 'd', 's', 'm'))
584
            puts("hdlr: odsm");
585
        else if(type == MKTAG('s', 'd', 's', 'm'))
586
            puts("hdlr: sdsm");
587
    } else puts("hdlr: meta");
588
#endif
589

    
590
    if(ctype == MKTAG('m', 'h', 'l', 'r')) { /* MOV */
591
        /* helps parsing the string hereafter... */
592
        c->mp4 = 0;
593
        if(type == MKTAG('v', 'i', 'd', 'e'))
594
            st->codec->codec_type = CODEC_TYPE_VIDEO;
595
        else if(type == MKTAG('s', 'o', 'u', 'n'))
596
            st->codec->codec_type = CODEC_TYPE_AUDIO;
597
    } else if(ctype == 0) { /* MP4 */
598
        /* helps parsing the string hereafter... */
599
        c->mp4 = 1;
600
        if(type == MKTAG('v', 'i', 'd', 'e'))
601
            st->codec->codec_type = CODEC_TYPE_VIDEO;
602
        else if(type == MKTAG('s', 'o', 'u', 'n'))
603
            st->codec->codec_type = CODEC_TYPE_AUDIO;
604
    }
605
    get_be32(pb); /* component  manufacture */
606
    get_be32(pb); /* component flags */
607
    get_be32(pb); /* component flags mask */
608

    
609
    if(atom.size <= 24)
610
        return 0; /* nothing left to read */
611
    /* XXX: MP4 uses a C string, not a pascal one */
612
    /* component name */
613

    
614
    if(c->mp4) {
615
        /* .mp4: C string */
616
        while(get_byte(pb) && (++len < (atom.size - 24)));
617
    } else {
618
        /* .mov: PASCAL string */
619
#ifdef DEBUG
620
        char* buf;
621
#endif
622
        len = get_byte(pb);
623
#ifdef DEBUG
624
        buf = (uint8_t*) av_malloc(len+1);
625
        if (buf) {
626
            get_buffer(pb, buf, len);
627
            buf[len] = '\0';
628
            av_log(NULL, AV_LOG_DEBUG, "**buf='%s'\n", buf);
629
            av_free(buf);
630
        } else
631
#endif
632
            url_fskip(pb, len);
633
    }
634

    
635
    url_fskip(pb, atom.size - (url_ftell(pb) - atom.offset));
636
    return 0;
637
}
638

    
639
static int mov_mp4_read_descr_len(ByteIOContext *pb)
640
{
641
    int len = 0;
642
    int count = 4;
643
    while (count--) {
644
        int c = get_byte(pb);
645
        len = (len << 7) | (c & 0x7f);
646
        if (!(c & 0x80))
647
            break;
648
    }
649
    return len;
650
}
651

    
652
static int mov_mp4_read_descr(ByteIOContext *pb, int *tag)
653
{
654
    int len;
655
    *tag = get_byte(pb);
656
    len = mov_mp4_read_descr_len(pb);
657
#ifdef DEBUG
658
    av_log(NULL, AV_LOG_DEBUG, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
659
#endif
660
    return len;
661
}
662

    
663
static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
664
{
665
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
666
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
667
    int64_t start_pos = url_ftell(pb);
668
    int tag, len;
669

    
670
    print_atom("esds", atom);
671

    
672
    /* Well, broken but suffisant for some MP4 streams */
673
    get_be32(pb); /* version + flags */
674
    len = mov_mp4_read_descr(pb, &tag);
675
    if (tag == MP4ESDescrTag) {
676
        get_be16(pb); /* ID */
677
        get_byte(pb); /* priority */
678
    } else
679
        get_be16(pb); /* ID */
680

    
681
    len = mov_mp4_read_descr(pb, &tag);
682
    if (tag == MP4DecConfigDescrTag) {
683
        sc->esds.object_type_id = get_byte(pb);
684
        sc->esds.stream_type = get_byte(pb);
685
        sc->esds.buffer_size_db = get_be24(pb);
686
        sc->esds.max_bitrate = get_be32(pb);
687
        sc->esds.avg_bitrate = get_be32(pb);
688

    
689
        st->codec->codec_id= codec_get_id(ff_mov_obj_type, sc->esds.object_type_id);
690
        len = mov_mp4_read_descr(pb, &tag);
691
        //av_log(NULL, AV_LOG_DEBUG, "LEN %d  TAG %d  m:%d a:%d\n", len, tag, sc->esds.max_bitrate, sc->esds.avg_bitrate);
692
        if (tag == MP4DecSpecificDescrTag) {
693
#ifdef DEBUG
694
            av_log(NULL, AV_LOG_DEBUG, "Specific MPEG4 header len=%d\n", len);
695
#endif
696
            st->codec->extradata = (uint8_t*) av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
697
            if (st->codec->extradata) {
698
                get_buffer(pb, st->codec->extradata, len);
699
                st->codec->extradata_size = len;
700
            }
701
        }
702
    }
703
    /* in any case, skip garbage */
704
    url_fskip(pb, atom.size - ((url_ftell(pb) - start_pos)));
705
    return 0;
706
}
707

    
708
/* this atom contains actual media data */
709
static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
710
{
711
    print_atom("mdat", atom);
712

    
713
    if(atom.size == 0) /* wrong one (MP4) */
714
        return 0;
715
    c->found_mdat=1;
716
    c->mdat_offset = atom.offset;
717
    c->mdat_size = atom.size;
718
    if(c->found_moov)
719
        return 1; /* found both, just go */
720
    url_fskip(pb, atom.size);
721
    return 0; /* now go for moov */
722
}
723

    
724
/* this atom should contain all header atoms */
725
static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
726
{
727
    int err;
728

    
729
    print_atom("moov", atom);
730

    
731
    err = mov_read_default(c, pb, atom);
732
    /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
733
    /* so we don't parse the whole file if over a network */
734
    c->found_moov=1;
735
    if(c->found_mdat)
736
        return 1; /* found both, just go */
737
    return 0; /* now go for mdat */
738
}
739

    
740

    
741
static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
742
{
743
    int version;
744
    int lang;
745
    print_atom("mdhd", atom);
746

    
747
    version = get_byte(pb); /* version */
748
    if (version > 1)
749
        return 1; /* unsupported */
750

    
751
    get_byte(pb); get_byte(pb);
752
    get_byte(pb); /* flags */
753

    
754
    (version==1)?get_be64(pb):get_be32(pb); /* creation time */
755
    (version==1)?get_be64(pb):get_be32(pb); /* modification time */
756

    
757
    c->streams[c->fc->nb_streams-1]->time_scale = get_be32(pb);
758

    
759
#ifdef DEBUG
760
    av_log(NULL, AV_LOG_DEBUG, "track[%i].time_scale = %i\n", c->fc->nb_streams-1, c->streams[c->fc->nb_streams-1]->time_scale); /* time scale */
761
#endif
762
    c->fc->streams[c->fc->nb_streams-1]->duration = (version==1)?get_be64(pb):get_be32(pb); /* duration */
763

    
764
    lang = get_be16(pb); /* language */
765
    ff_mov_lang_to_iso639(lang, c->fc->streams[c->fc->nb_streams-1]->language);
766
    get_be16(pb); /* quality */
767

    
768
    return 0;
769
}
770

    
771
static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
772
{
773
    print_atom("mvhd", atom);
774

    
775
    get_byte(pb); /* version */
776
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
777

    
778
    get_be32(pb); /* creation time */
779
    get_be32(pb); /* modification time */
780
    c->time_scale = get_be32(pb); /* time scale */
781
#ifdef DEBUG
782
    av_log(NULL, AV_LOG_DEBUG, "time scale = %i\n", c->time_scale);
783
#endif
784
    c->duration = get_be32(pb); /* duration */
785
    get_be32(pb); /* preferred scale */
786

    
787
    get_be16(pb); /* preferred volume */
788

    
789
    url_fskip(pb, 10); /* reserved */
790

    
791
    url_fskip(pb, 36); /* display matrix */
792

    
793
    get_be32(pb); /* preview time */
794
    get_be32(pb); /* preview duration */
795
    get_be32(pb); /* poster time */
796
    get_be32(pb); /* selection time */
797
    get_be32(pb); /* selection duration */
798
    get_be32(pb); /* current time */
799
    get_be32(pb); /* next track ID */
800

    
801
    return 0;
802
}
803

    
804
static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
805
{
806
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
807

    
808
    if((uint64_t)atom.size > (1<<30))
809
        return -1;
810

    
811
    // currently SVQ3 decoder expect full STSD header - so let's fake it
812
    // this should be fixed and just SMI header should be passed
813
    av_free(st->codec->extradata);
814
    st->codec->extradata_size = 0x5a + atom.size;
815
    st->codec->extradata = (uint8_t*) av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
816

    
817
    if (st->codec->extradata) {
818
        strcpy(st->codec->extradata, "SVQ3"); // fake
819
        get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
820
        //av_log(NULL, AV_LOG_DEBUG, "Reading SMI %Ld  %s\n", atom.size, (char*)st->codec->extradata + 0x5a);
821
    } else
822
        url_fskip(pb, atom.size);
823

    
824
    return 0;
825
}
826

    
827
static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
828
{
829
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
830

    
831
    if((uint64_t)atom.size > (1<<30))
832
        return -1;
833

    
834
    // pass all frma atom to codec, needed at least for QDM2
835
    av_free(st->codec->extradata);
836
    st->codec->extradata_size = atom.size;
837
    st->codec->extradata = (uint8_t*) av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
838

    
839
    if (st->codec->extradata) {
840
        get_buffer(pb, st->codec->extradata, atom.size);
841
        //av_log(NULL, AV_LOG_DEBUG, "Reading frma %Ld  %s\n", atom.size, (char*)st->codec->extradata);
842
    } else
843
        url_fskip(pb, atom.size);
844

    
845
    return 0;
846
}
847

    
848
static int mov_read_avcC(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
849
{
850
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
851

    
852
    if((uint64_t)atom.size > (1<<30))
853
        return -1;
854

    
855
    av_free(st->codec->extradata);
856

    
857
    st->codec->extradata_size = atom.size;
858
    st->codec->extradata = (uint8_t*) av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
859

    
860
    if (st->codec->extradata) {
861
        get_buffer(pb, st->codec->extradata, atom.size);
862
    } else
863
        url_fskip(pb, atom.size);
864

    
865
    return 0;
866
}
867

    
868
static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
869
{
870
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
871
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
872
    unsigned int i, entries;
873

    
874
    print_atom("stco", atom);
875

    
876
    get_byte(pb); /* version */
877
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
878

    
879
    entries = get_be32(pb);
880

    
881
    if(entries >= UINT_MAX/sizeof(int64_t))
882
        return -1;
883

    
884
    sc->chunk_count = entries;
885
    sc->chunk_offsets = (int64_t*) av_malloc(entries * sizeof(int64_t));
886
    if (!sc->chunk_offsets)
887
        return -1;
888
    if (atom.type == MKTAG('s', 't', 'c', 'o')) {
889
        for(i=0; i<entries; i++) {
890
            sc->chunk_offsets[i] = get_be32(pb);
891
        }
892
    } else if (atom.type == MKTAG('c', 'o', '6', '4')) {
893
        for(i=0; i<entries; i++) {
894
            sc->chunk_offsets[i] = get_be64(pb);
895
        }
896
    } else
897
        return -1;
898

    
899
    for(i=0; i<c->fc->nb_streams; i++){
900
        MOVStreamContext *sc2 = (MOVStreamContext *)c->fc->streams[i]->priv_data;
901
        if(sc2 && sc2->chunk_offsets){
902
            int64_t first= sc2->chunk_offsets[0];
903
            int64_t last= sc2->chunk_offsets[sc2->chunk_count-1];
904
            if(first >= sc->chunk_offsets[entries-1] || last <= sc->chunk_offsets[0])
905
                c->ni=1;
906
        }
907
    }
908
#ifdef DEBUG
909
/*
910
    for(i=0; i<entries; i++) {
911
        av_log(NULL, AV_LOG_DEBUG, "chunk offset=0x%Lx\n", sc->chunk_offsets[i]);
912
    }
913
*/
914
#endif
915
    return 0;
916
}
917

    
918
static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
919
{
920
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
921
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
922
    int entries, frames_per_sample;
923
    uint32_t format;
924
    uint8_t codec_name[32];
925

    
926
    /* for palette traversal */
927
    int color_depth;
928
    int color_start;
929
    int color_count;
930
    int color_end;
931
    int color_index;
932
    int color_dec;
933
    int color_greyscale;
934
    unsigned char *color_table;
935
    int j;
936
    unsigned char r, g, b;
937

    
938
    print_atom("stsd", atom);
939

    
940
    get_byte(pb); /* version */
941
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
942

    
943
    entries = get_be32(pb);
944

    
945
    while(entries--) { //Parsing Sample description table
946
        enum CodecID id;
947
        int size = get_be32(pb); /* size */
948
        format = get_le32(pb); /* data format */
949

    
950
        get_be32(pb); /* reserved */
951
        get_be16(pb); /* reserved */
952
        get_be16(pb); /* index */
953

    
954
        /* for MPEG4: set codec type by looking for it */
955
        id = codec_get_id(mov_video_tags, format);
956
        if(id <= 0)
957
            id = codec_get_id(codec_bmp_tags, format);
958
        if (id >= 0) {
959
            AVCodec *codec;
960
            codec = avcodec_find_decoder(id);
961
            if (codec)
962
                st->codec->codec_type = codec->type;
963
        }
964
#ifdef DEBUG
965
        av_log(NULL, AV_LOG_DEBUG, "size=%d 4CC= %c%c%c%c codec_type=%d\n",
966
               size,
967
               (format >> 0) & 0xff,
968
               (format >> 8) & 0xff,
969
               (format >> 16) & 0xff,
970
               (format >> 24) & 0xff,
971
               st->codec->codec_type);
972
#endif
973
        st->codec->codec_tag = format;
974
        if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
975
            MOV_atom_t a = { 0, 0, 0 };
976
            st->codec->codec_id = id;
977
            get_be16(pb); /* version */
978
            get_be16(pb); /* revision level */
979
            get_be32(pb); /* vendor */
980
            get_be32(pb); /* temporal quality */
981
            get_be32(pb); /* spacial quality */
982
            if(st->codec->codec_id == CODEC_ID_MPEG4){ //FIXME this is silly
983
                get_be16(pb);
984
                get_be16(pb);
985
            }else{
986
                st->codec->width = get_be16(pb); /* width */
987
                st->codec->height = get_be16(pb); /* height */
988
            }
989
            get_be32(pb); /* horiz resolution */
990
            get_be32(pb); /* vert resolution */
991
            get_be32(pb); /* data size, always 0 */
992
            frames_per_sample = get_be16(pb); /* frames per samples */
993
#ifdef DEBUG
994
            av_log(NULL, AV_LOG_DEBUG, "frames/samples = %d\n", frames_per_sample);
995
#endif
996
        get_buffer(pb, codec_name, 32); /* codec name, pascal string (FIXME: true for mp4?) */
997
        if (codec_name[0] <= 31) {
998
            memcpy(st->codec->codec_name, &codec_name[1],codec_name[0]);
999
            st->codec->codec_name[codec_name[0]] = 0;
1000
        }
1001

    
1002
            st->codec->bits_per_sample = get_be16(pb); /* depth */
1003
            st->codec->color_table_id = get_be16(pb); /* colortable id */
1004

    
1005
/*          These are set in mov_read_stts and might already be set!
1006
            st->codec->time_base.den      = 25;
1007
            st->codec->time_base.num = 1;
1008
*/
1009
            size -= (16+8*4+2+32+2*2);
1010
#if 0
1011
            while (size >= 8) {
1012
                MOV_atom_t a;
1013
                int64_t start_pos;
1014

1015
                a.size = get_be32(pb);
1016
                a.type = get_le32(pb);
1017
                size -= 8;
1018
#ifdef DEBUG
1019
                av_log(NULL, AV_LOG_DEBUG, "VIDEO: atom_type=%c%c%c%c atom.size=%Ld size_left=%d\n",
1020
                       (a.type >> 0) & 0xff,
1021
                       (a.type >> 8) & 0xff,
1022
                       (a.type >> 16) & 0xff,
1023
                       (a.type >> 24) & 0xff,
1024
                       a.size, size);
1025
#endif
1026
                start_pos = url_ftell(pb);
1027

    
1028
                switch(a.type) {
1029
                case MKTAG('e', 's', 'd', 's'):
1030
                    {
1031
                        int tag, len;
1032
                        /* Well, broken but suffisant for some MP4 streams */
1033
                        get_be32(pb); /* version + flags */
1034
                        len = mov_mp4_read_descr(pb, &tag);
1035
                        if (tag == 0x03) {
1036
                            /* MP4ESDescrTag */
1037
                            get_be16(pb); /* ID */
1038
                            get_byte(pb); /* priority */
1039
                            len = mov_mp4_read_descr(pb, &tag);
1040
                            if (tag != 0x04)
1041
                                goto fail;
1042
                            /* MP4DecConfigDescrTag */
1043
                            get_byte(pb); /* objectTypeId */
1044
                            get_be32(pb); /* streamType + buffer size */
1045
                            get_be32(pb); /* max bit rate */
1046
                            get_be32(pb); /* avg bit rate */
1047
                            len = mov_mp4_read_descr(pb, &tag);
1048
                            if (tag != 0x05)
1049
                                goto fail;
1050
                            /* MP4DecSpecificDescrTag */
1051
#ifdef DEBUG
1052
                            av_log(NULL, AV_LOG_DEBUG, "Specific MPEG4 header len=%d\n", len);
1053
#endif
1054
                            sc->header_data = av_mallocz(len);
1055
                            if (sc->header_data) {
1056
                                get_buffer(pb, sc->header_data, len);
1057
                                sc->header_len = len;
1058
                            }
1059
                        }
1060
                        /* in any case, skip garbage */
1061
                    }
1062
                    break;
1063
                default:
1064
                    break;
1065
                }
1066
            fail:
1067
                av_log(NULL, AV_LOG_DEBUG, "ATOMENEWSIZE %Ld   %d\n", atom.size, url_ftell(pb) - start_pos);
1068
                if (atom.size > 8) {
1069
                    url_fskip(pb, (atom.size - 8) -
1070
                              ((url_ftell(pb) - start_pos)));
1071
                    size -= atom.size - 8;
1072
                }
1073
            }
1074
            if (size > 0) {
1075
                /* unknown extension */
1076
                url_fskip(pb, size);
1077
            }
1078
#else
1079

    
1080
            /* figure out the palette situation */
1081
            color_depth = st->codec->bits_per_sample & 0x1F;
1082
            color_greyscale = st->codec->bits_per_sample & 0x20;
1083

    
1084
            /* if the depth is 2, 4, or 8 bpp, file is palettized */
1085
            if ((color_depth == 2) || (color_depth == 4) ||
1086
                (color_depth == 8)) {
1087

    
1088
                if (color_greyscale) {
1089

    
1090
                    /* compute the greyscale palette */
1091
                    color_count = 1 << color_depth;
1092
                    color_index = 255;
1093
                    color_dec = 256 / (color_count - 1);
1094
                    for (j = 0; j < color_count; j++) {
1095
                        r = g = b = color_index;
1096
                        c->palette_control.palette[j] =
1097
                            (r << 16) | (g << 8) | (b);
1098
                        color_index -= color_dec;
1099
                        if (color_index < 0)
1100
                            color_index = 0;
1101
                    }
1102

    
1103
                } else if (st->codec->color_table_id & 0x08) {
1104

    
1105
                    /* if flag bit 3 is set, use the default palette */
1106
                    color_count = 1 << color_depth;
1107
                    if (color_depth == 2)
1108
                        color_table = ff_qt_default_palette_4;
1109
                    else if (color_depth == 4)
1110
                        color_table = ff_qt_default_palette_16;
1111
                    else
1112
                        color_table = ff_qt_default_palette_256;
1113

    
1114
                    for (j = 0; j < color_count; j++) {
1115
                        r = color_table[j * 4 + 0];
1116
                        g = color_table[j * 4 + 1];
1117
                        b = color_table[j * 4 + 2];
1118
                        c->palette_control.palette[j] =
1119
                            (r << 16) | (g << 8) | (b);
1120
                    }
1121

    
1122
                } else {
1123

    
1124
                    /* load the palette from the file */
1125
                    color_start = get_be32(pb);
1126
                    color_count = get_be16(pb);
1127
                    color_end = get_be16(pb);
1128
                    for (j = color_start; j <= color_end; j++) {
1129
                        /* each R, G, or B component is 16 bits;
1130
                         * only use the top 8 bits; skip alpha bytes
1131
                         * up front */
1132
                        get_byte(pb);
1133
                        get_byte(pb);
1134
                        r = get_byte(pb);
1135
                        get_byte(pb);
1136
                        g = get_byte(pb);
1137
                        get_byte(pb);
1138
                        b = get_byte(pb);
1139
                        get_byte(pb);
1140
                        c->palette_control.palette[j] =
1141
                            (r << 16) | (g << 8) | (b);
1142
                    }
1143
                }
1144

    
1145
                st->codec->palctrl = &c->palette_control;
1146
                st->codec->palctrl->palette_changed = 1;
1147
            } else
1148
                st->codec->palctrl = NULL;
1149

    
1150
            a.size = size;
1151
            mov_read_default(c, pb, a);
1152
#endif
1153
        } else {
1154
            st->codec->codec_id = codec_get_id(mov_audio_tags, format);
1155
            if(st->codec->codec_id==CODEC_ID_AMR_NB || st->codec->codec_id==CODEC_ID_AMR_WB) //from TS26.244
1156
            {
1157
#ifdef DEBUG
1158
               av_log(NULL, AV_LOG_DEBUG, "AMR-NB or AMR-WB audio identified!!\n");
1159
#endif
1160
               get_be32(pb);get_be32(pb); //Reserved_8
1161
               get_be16(pb);//Reserved_2
1162
               get_be16(pb);//Reserved_2
1163
               get_be32(pb);//Reserved_4
1164
               get_be16(pb);//TimeScale
1165
               get_be16(pb);//Reserved_2
1166

    
1167
                //AMRSpecificBox.(10 bytes)
1168

    
1169
               get_be32(pb); //size
1170
               get_be32(pb); //type=='damr'
1171
               get_be32(pb); //vendor
1172
               get_byte(pb); //decoder version
1173
               get_be16(pb); //mode_set
1174
               get_byte(pb); //mode_change_period
1175
               get_byte(pb); //frames_per_sample
1176

    
1177
               st->duration = AV_NOPTS_VALUE;//Not possible to get from this info, must count number of AMR frames
1178
               if(st->codec->codec_id==CODEC_ID_AMR_NB)
1179
               {
1180
                   st->codec->sample_rate=8000;
1181
                   st->codec->channels=1;
1182
               }
1183
               else //AMR-WB
1184
               {
1185
                   st->codec->sample_rate=16000;
1186
                   st->codec->channels=1;
1187
               }
1188
               st->codec->bits_per_sample=16;
1189
               st->codec->bit_rate=0; /*It is not possible to tell this before we have
1190
                                       an audio frame and even then every frame can be different*/
1191
            }
1192
            else if( st->codec->codec_tag == MKTAG( 'm', 'p', '4', 's' ))
1193
            {
1194
                //This is some stuff for the hint track, lets ignore it!
1195
                //Do some mp4 auto detect.
1196
                c->mp4=1;
1197
                size-=(16);
1198
                url_fskip(pb, size); /* The mp4s atom also contians a esds atom that we can skip*/
1199
            }
1200
            else if( st->codec->codec_tag == MKTAG( 'm', 'p', '4', 'a' ))
1201
            {
1202
                MOV_atom_t a;
1203
                int mp4_version;
1204

    
1205
                /* Handle mp4 audio tag */
1206
                mp4_version=get_be16(pb);/*version*/
1207
                get_be16(pb); /*revesion*/
1208
                get_be32(pb);
1209
                st->codec->channels = get_be16(pb); /* channels */
1210
                st->codec->bits_per_sample = get_be16(pb); /* bits per sample */
1211
                get_be32(pb);
1212
                st->codec->sample_rate = get_be16(pb); /* sample rate, not always correct */
1213
                if(st->codec->sample_rate == 1) //nonsese rate? -> ignore
1214
                    st->codec->sample_rate= 0;
1215

    
1216
                get_be16(pb);
1217
                c->mp4=1;
1218

    
1219
                if(mp4_version==1)
1220
                {
1221
                    url_fskip(pb,16);
1222
                    a.size=size-(16+20+16);
1223
                }
1224
                else
1225
                    a.size=size-(16+20);
1226

    
1227
                a.offset=url_ftell(pb);
1228

    
1229
                mov_read_default(c, pb, a);
1230

    
1231
                /* Get correct sample rate from extradata */
1232
                if(st->codec->extradata_size) {
1233
                   const int samplerate_table[] = {
1234
                     96000, 88200, 64000, 48000, 44100, 32000,
1235
                     24000, 22050, 16000, 12000, 11025, 8000,
1236
                     7350, 0, 0, 0
1237
                   };
1238
                   unsigned char *px = st->codec->extradata;
1239
                   // 5 bits objectTypeIndex, 4 bits sampleRateIndex, 4 bits channels
1240
                   int samplerate_index = ((px[0] & 7) << 1) + ((px[1] >> 7) & 1);
1241
                   st->codec->sample_rate = samplerate_table[samplerate_index];
1242
                   st->codec->channels = (px[1] >> 3) & 15;
1243
                }
1244
            }
1245
            else if( st->codec->codec_tag == MKTAG( 'a', 'l', 'a', 'c' ))
1246
            {
1247
                /* Handle alac audio tag + special extradata */
1248
                get_be32(pb); /* version */
1249
                get_be32(pb);
1250
                st->codec->channels = get_be16(pb); /* channels */
1251
                st->codec->bits_per_sample = get_be16(pb); /* bits per sample */
1252
                get_be32(pb);
1253
                st->codec->sample_rate = get_be16(pb);
1254
                get_be16(pb);
1255

    
1256
                /* fetch the 36-byte extradata needed for alac decoding */
1257
                st->codec->extradata_size = 36;
1258
                st->codec->extradata = (uint8_t*)
1259
                    av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1260
                get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
1261
            }
1262
            else if(size>=(16+20))
1263
            {//16 bytes read, reading atleast 20 more
1264
                uint16_t version;
1265
#ifdef DEBUG
1266
                av_log(NULL, AV_LOG_DEBUG, "audio size=0x%X\n",size);
1267
#endif
1268
                version = get_be16(pb); /* version */
1269
                get_be16(pb); /* revision level */
1270
                get_be32(pb); /* vendor */
1271

    
1272
                st->codec->channels = get_be16(pb);             /* channel count */
1273
                st->codec->bits_per_sample = get_be16(pb);      /* sample size */
1274

    
1275
                /* handle specific s8 codec */
1276
                get_be16(pb); /* compression id = 0*/
1277
                get_be16(pb); /* packet size = 0 */
1278

    
1279
                st->codec->sample_rate = ((get_be32(pb) >> 16));
1280
                //av_log(NULL, AV_LOG_DEBUG, "CODECID %d  %d  %.4s\n", st->codec->codec_id, CODEC_ID_PCM_S16BE, (char*)&format);
1281

    
1282
                switch (st->codec->codec_id) {
1283
                case CODEC_ID_PCM_S16BE:
1284
                    if (st->codec->bits_per_sample == 8)
1285
                        st->codec->codec_id = CODEC_ID_PCM_S8;
1286
                    /* fall */
1287
                case CODEC_ID_PCM_U8:
1288
                    st->codec->bit_rate = st->codec->sample_rate * 8;
1289
                    break;
1290
                default:
1291
                    ;
1292
                }
1293

    
1294
                //Read QT version 1 fields. In version 0 theese dont exist
1295
#ifdef DEBUG
1296
                av_log(NULL, AV_LOG_DEBUG, "version =%d mp4=%d\n",version,c->mp4);
1297
                av_log(NULL, AV_LOG_DEBUG, "size-(16+20+16)=%d\n",size-(16+20+16));
1298
#endif
1299
                if((version==1) && size>=(16+20+16))
1300
                {
1301
                    get_be32(pb); /* samples per packet */
1302
                    get_be32(pb); /* bytes per packet */
1303
                    get_be32(pb); /* bytes per frame */
1304
                    get_be32(pb); /* bytes per sample */
1305
                    if(size>(16+20+16))
1306
                    {
1307
                        //Optional, additional atom-based fields
1308
                        MOV_atom_t a = { format, url_ftell(pb), size - (16 + 20 + 16 + 8) };
1309
#ifdef DEBUG
1310
                        av_log(NULL, AV_LOG_DEBUG, "offest=0x%X, sizeleft=%d=0x%x,format=%c%c%c%c\n",(int)url_ftell(pb),size - (16 + 20 + 16 ),size - (16 + 20 + 16 ),
1311
                            (format >> 0) & 0xff,
1312
                            (format >> 8) & 0xff,
1313
                            (format >> 16) & 0xff,
1314
                            (format >> 24) & 0xff);
1315
#endif
1316
                        mov_read_default(c, pb, a);
1317
                    }
1318
                }
1319
                else
1320
                {
1321
                    //We should be down to 0 bytes here, but lets make sure.
1322
                    size-=(16+20);
1323
#ifdef DEBUG
1324
                    if(size>0)
1325
                        av_log(NULL, AV_LOG_DEBUG, "skipping 0x%X bytes\n",size-(16+20));
1326
#endif
1327
                    url_fskip(pb, size);
1328
                }
1329
            }
1330
            else
1331
            {
1332
                size-=16;
1333
                //Unknown size, but lets do our best and skip the rest.
1334
#ifdef DEBUG
1335
                av_log(NULL, AV_LOG_DEBUG, "Strange size, skipping 0x%X bytes\n",size);
1336
#endif
1337
                url_fskip(pb, size);
1338
            }
1339
        }
1340
    }
1341

    
1342
    if(st->codec->codec_type==CODEC_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1) {
1343
        st->codec->sample_rate= sc->time_scale;
1344
    }
1345

    
1346
    return 0;
1347
}
1348

    
1349
static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1350
{
1351
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1352
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1353
    unsigned int i, entries;
1354

    
1355
    print_atom("stsc", atom);
1356

    
1357
    get_byte(pb); /* version */
1358
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1359

    
1360
    entries = get_be32(pb);
1361

    
1362
    if(entries >= UINT_MAX / sizeof(MOV_sample_to_chunk_tbl))
1363
        return -1;
1364

    
1365
#ifdef DEBUG
1366
av_log(NULL, AV_LOG_DEBUG, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1367
#endif
1368
    sc->sample_to_chunk_sz = entries;
1369
    sc->sample_to_chunk = (MOV_sample_to_chunk_tbl*) av_malloc(entries * sizeof(MOV_sample_to_chunk_tbl));
1370
    if (!sc->sample_to_chunk)
1371
        return -1;
1372
    for(i=0; i<entries; i++) {
1373
        sc->sample_to_chunk[i].first = get_be32(pb);
1374
        sc->sample_to_chunk[i].count = get_be32(pb);
1375
        sc->sample_to_chunk[i].id = get_be32(pb);
1376
#ifdef DEBUG
1377
/*        av_log(NULL, AV_LOG_DEBUG, "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); */
1378
#endif
1379
    }
1380
    return 0;
1381
}
1382

    
1383
static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1384
{
1385
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1386
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1387
    unsigned int i, entries;
1388

    
1389
    print_atom("stss", atom);
1390

    
1391
    get_byte(pb); /* version */
1392
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1393

    
1394
    entries = get_be32(pb);
1395

    
1396
    if(entries >= UINT_MAX / sizeof(long))
1397
        return -1;
1398

    
1399
    sc->keyframe_count = entries;
1400
#ifdef DEBUG
1401
    av_log(NULL, AV_LOG_DEBUG, "keyframe_count = %ld\n", sc->keyframe_count);
1402
#endif
1403
    sc->keyframes = (long*) av_malloc(entries * sizeof(long));
1404
    if (!sc->keyframes)
1405
        return -1;
1406
    for(i=0; i<entries; i++) {
1407
        sc->keyframes[i] = get_be32(pb);
1408
#ifdef DEBUG
1409
/*        av_log(NULL, AV_LOG_DEBUG, "keyframes[]=%ld\n", sc->keyframes[i]); */
1410
#endif
1411
    }
1412
    return 0;
1413
}
1414

    
1415
static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1416
{
1417
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1418
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1419
    unsigned int i, entries;
1420

    
1421
    print_atom("stsz", atom);
1422

    
1423
    get_byte(pb); /* version */
1424
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1425

    
1426
    sc->sample_size = get_be32(pb);
1427
    entries = get_be32(pb);
1428
    if(entries >= UINT_MAX / sizeof(long))
1429
        return -1;
1430

    
1431
    sc->sample_count = entries;
1432
#ifdef DEBUG
1433
    av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
1434
#endif
1435
    if(sc->sample_size)
1436
        return 0; /* there isn't any table following */
1437
    sc->sample_sizes = (long*) av_malloc(entries * sizeof(long));
1438
    if (!sc->sample_sizes)
1439
        return -1;
1440
    for(i=0; i<entries; i++) {
1441
        sc->sample_sizes[i] = get_be32(pb);
1442
#ifdef DEBUG
1443
        av_log(NULL, AV_LOG_DEBUG, "sample_sizes[]=%ld\n", sc->sample_sizes[i]);
1444
#endif
1445
    }
1446
    return 0;
1447
}
1448

    
1449
static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1450
{
1451
    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1452
    MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1453
    unsigned int i, entries;
1454
    int64_t duration=0;
1455
    int64_t total_sample_count=0;
1456

    
1457
    print_atom("stts", atom);
1458

    
1459
    get_byte(pb); /* version */
1460
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1461
    entries = get_be32(pb);
1462
    if(entries >= UINT_MAX / sizeof(Time2Sample))
1463
        return -1;
1464

    
1465
    sc->stts_count = entries;
1466
    sc->stts_data = av_malloc(entries * sizeof(Time2Sample));
1467

    
1468
#ifdef DEBUG
1469
av_log(NULL, AV_LOG_DEBUG, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
1470
#endif
1471

    
1472
    sc->time_rate=0;
1473

    
1474
    for(i=0; i<entries; i++) {
1475
        int sample_duration;
1476
        int sample_count;
1477

    
1478
        sample_count=get_be32(pb);
1479
        sample_duration = get_be32(pb);
1480
        sc->stts_data[i].count= sample_count;
1481
        sc->stts_data[i].duration= sample_duration;
1482

    
1483
        sc->time_rate= ff_gcd(sc->time_rate, sample_duration);
1484

    
1485
#ifdef DEBUG
1486
        av_log(NULL, AV_LOG_DEBUG, "sample_count=%d, sample_duration=%d\n",sample_count,sample_duration);
1487
#endif
1488
        duration+=sample_duration*sample_count;
1489
        total_sample_count+=sample_count;
1490
    }
1491

    
1492
    st->nb_frames= total_sample_count;
1493
    if(duration)
1494
        st->duration= duration;
1495
    return 0;
1496
}
1497

    
1498
static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1499
{
1500
//    AVStream *st = c->fc->streams[c->fc->nb_streams-1];
1501
    //MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
1502
    unsigned int i, entries;
1503

    
1504
    print_atom("ctts", atom);
1505

    
1506
    get_byte(pb); /* version */
1507
    get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1508
    entries = get_be32(pb);
1509
    if(entries >= UINT_MAX / sizeof(Time2Sample))
1510
        return -1;
1511

    
1512
    c->streams[c->fc->nb_streams-1]->ctts_count = entries;
1513
    c->streams[c->fc->nb_streams-1]->ctts_data = av_malloc(entries * sizeof(Time2Sample));
1514

    
1515
// #ifdef DEBUG
1516
av_log(NULL, AV_LOG_DEBUG, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
1517
// #endif
1518
    for(i=0; i<entries; i++) {
1519
        c->streams[c->fc->nb_streams - 1]->ctts_data[i].count= get_be32(pb);
1520
        c->streams[c->fc->nb_streams - 1]->ctts_data[i].duration= get_be32(pb);
1521
    }
1522
    return 0;
1523
}
1524

    
1525
static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1526
{
1527
    AVStream *st;
1528
    MOVStreamContext *sc;
1529

    
1530
    print_atom("trak", atom);
1531

    
1532
    st = av_new_stream(c->fc, c->fc->nb_streams);
1533
    if (!st) return -2;
1534
    sc = (MOVStreamContext*) av_mallocz(sizeof(MOVStreamContext));
1535
    if (!sc) {
1536
        av_free(st);
1537
        return -1;
1538
    }
1539

    
1540
    sc->sample_to_chunk_index = -1;
1541
    st->priv_data = sc;
1542
    st->codec->codec_type = CODEC_TYPE_MOV_OTHER;
1543
    st->start_time = 0; /* XXX: check */
1544
    c->streams[c->fc->nb_streams-1] = sc;
1545

    
1546
    return mov_read_default(c, pb, atom);
1547
}
1548

    
1549
static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1550
{
1551
    AVStream *st;
1552

    
1553
    print_atom("tkhd", atom);
1554

    
1555
    st = c->fc->streams[c->fc->nb_streams-1];
1556

    
1557
    get_byte(pb); /* version */
1558

    
1559
    get_byte(pb); get_byte(pb);
1560
    get_byte(pb); /* flags */
1561
    /*
1562
    MOV_TRACK_ENABLED 0x0001
1563
    MOV_TRACK_IN_MOVIE 0x0002
1564
    MOV_TRACK_IN_PREVIEW 0x0004
1565
    MOV_TRACK_IN_POSTER 0x0008
1566
    */
1567

    
1568
    get_be32(pb); /* creation time */
1569
    get_be32(pb); /* modification time */
1570
    st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/
1571
    get_be32(pb); /* reserved */
1572
    st->start_time = 0; /* check */
1573
    get_be32(pb); /* highlevel (considering edits) duration in movie timebase */
1574
    get_be32(pb); /* reserved */
1575
    get_be32(pb); /* reserved */
1576

    
1577
    get_be16(pb); /* layer */
1578
    get_be16(pb); /* alternate group */
1579
    get_be16(pb); /* volume */
1580
    get_be16(pb); /* reserved */
1581

    
1582
    url_fskip(pb, 36); /* display matrix */
1583

    
1584
    /* those are fixed-point */
1585
    /*st->codec->width =*/ get_be32(pb) >> 16; /* track width */
1586
    /*st->codec->height =*/ get_be32(pb) >> 16; /* track height */
1587

    
1588
    return 0;
1589
}
1590

    
1591
/* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
1592
/* like the files created with Adobe Premiere 5.0, for samples see */
1593
/* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
1594
static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1595
{
1596
    int err;
1597

    
1598
#ifdef DEBUG
1599
    print_atom("wide", atom);
1600
    debug_indent++;
1601
#endif
1602
    if (atom.size < 8)
1603
        return 0; /* continue */
1604
    if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
1605
        url_fskip(pb, atom.size - 4);
1606
        return 0;
1607
    }
1608
    atom.type = get_le32(pb);
1609
    atom.offset += 8;
1610
    atom.size -= 8;
1611
    if (atom.type != MKTAG('m', 'd', 'a', 't')) {
1612
        url_fskip(pb, atom.size);
1613
        return 0;
1614
    }
1615
    err = mov_read_mdat(c, pb, atom);
1616
#ifdef DEBUG
1617
    debug_indent--;
1618
#endif
1619
    return err;
1620
}
1621

    
1622

    
1623
#ifdef CONFIG_ZLIB
1624
static int null_read_packet(void *opaque, uint8_t *buf, int buf_size)
1625
{
1626
    return -1;
1627
}
1628

    
1629
static int mov_read_cmov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1630
{
1631
    ByteIOContext ctx;
1632
    uint8_t *cmov_data;
1633
    uint8_t *moov_data; /* uncompressed data */
1634
    long cmov_len, moov_len;
1635
    int ret;
1636

    
1637
    print_atom("cmov", atom);
1638

    
1639
    get_be32(pb); /* dcom atom */
1640
    if (get_le32(pb) != MKTAG( 'd', 'c', 'o', 'm' ))
1641
        return -1;
1642
    if (get_le32(pb) != MKTAG( 'z', 'l', 'i', 'b' )) {
1643
        av_log(NULL, AV_LOG_DEBUG, "unknown compression for cmov atom !");
1644
        return -1;
1645
    }
1646
    get_be32(pb); /* cmvd atom */
1647
    if (get_le32(pb) != MKTAG( 'c', 'm', 'v', 'd' ))
1648
        return -1;
1649
    moov_len = get_be32(pb); /* uncompressed size */
1650
    cmov_len = atom.size - 6 * 4;
1651

    
1652
    cmov_data = (uint8_t *) av_malloc(cmov_len);
1653
    if (!cmov_data)
1654
        return -1;
1655
    moov_data = (uint8_t *) av_malloc(moov_len);
1656
    if (!moov_data) {
1657
        av_free(cmov_data);
1658
        return -1;
1659
    }
1660
    get_buffer(pb, cmov_data, cmov_len);
1661
    if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
1662
        return -1;
1663
    if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, null_read_packet, NULL, NULL) != 0)
1664
        return -1;
1665
    ctx.buf_end = ctx.buffer + moov_len;
1666
    atom.type = MKTAG( 'm', 'o', 'o', 'v' );
1667
    atom.offset = 0;
1668
    atom.size = moov_len;
1669
#ifdef DEBUG
1670
    { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
1671
#endif
1672
    ret = mov_read_default(c, &ctx, atom);
1673
    av_free(moov_data);
1674
    av_free(cmov_data);
1675

    
1676
    return ret;
1677
}
1678
#endif
1679

    
1680
/* edit list atom */
1681
static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
1682
{
1683
  int i, edit_count;
1684
  print_atom("elst", atom);
1685

    
1686
  get_byte(pb); /* version */
1687
  get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
1688
  edit_count= c->streams[c->fc->nb_streams-1]->edit_count = get_be32(pb);     /* entries */
1689

    
1690
  for(i=0; i<edit_count; i++){
1691
    get_be32(pb); /* Track duration */
1692
    get_be32(pb); /* Media time */
1693
    get_be32(pb); /* Media rate */
1694
  }
1695
#ifdef DEBUG
1696
  av_log(NULL, AV_LOG_DEBUG, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, c->streams[c->fc->nb_streams-1]->edit_count);
1697
#endif
1698
  return 0;
1699
}
1700

    
1701
static const MOVParseTableEntry mov_default_parse_table[] = {
1702
/* mp4 atoms */
1703
{ MKTAG( 'c', 'o', '6', '4' ), mov_read_stco },
1704
{ MKTAG( 'c', 'p', 'r', 't' ), mov_read_default },
1705
{ MKTAG( 'c', 'r', 'h', 'd' ), mov_read_default },
1706
{ MKTAG( 'c', 't', 't', 's' ), mov_read_ctts }, /* composition time to sample */
1707
{ MKTAG( 'd', 'i', 'n', 'f' ), mov_read_default }, /* data information */
1708
{ MKTAG( 'd', 'p', 'n', 'd' ), mov_read_leaf },
1709
{ MKTAG( 'd', 'r', 'e', 'f' ), mov_read_leaf },
1710
{ MKTAG( 'e', 'd', 't', 's' ), mov_read_default },
1711
{ MKTAG( 'e', 'l', 's', 't' ), mov_read_elst },
1712
{ MKTAG( 'f', 'r', 'e', 'e' ), mov_read_leaf },
1713
{ MKTAG( 'h', 'd', 'l', 'r' ), mov_read_hdlr },
1714
{ MKTAG( 'h', 'i', 'n', 't' ), mov_read_leaf },
1715
{ MKTAG( 'h', 'm', 'h', 'd' ), mov_read_leaf },
1716
{ MKTAG( 'i', 'o', 'd', 's' ), mov_read_leaf },
1717
{ MKTAG( 'm', 'd', 'a', 't' ), mov_read_mdat },
1718
{ MKTAG( 'm', 'd', 'h', 'd' ), mov_read_mdhd },
1719
{ MKTAG( 'm', 'd', 'i', 'a' ), mov_read_default },
1720
{ MKTAG( 'm', 'i', 'n', 'f' ), mov_read_default },
1721
{ MKTAG( 'm', 'o', 'o', 'v' ), mov_read_moov },
1722
{ MKTAG( 'm', 'p', '4', 'a' ), mov_read_default },
1723
{ MKTAG( 'm', 'p', '4', 's' ), mov_read_default },
1724
{ MKTAG( 'm', 'p', '4', 'v' ), mov_read_default },
1725
{ MKTAG( 'm', 'p', 'o', 'd' ), mov_read_leaf },
1726
{ MKTAG( 'm', 'v', 'h', 'd' ), mov_read_mvhd },
1727
{ MKTAG( 'n', 'm', 'h', 'd' ), mov_read_leaf },
1728
{ MKTAG( 'o', 'd', 'h', 'd' ), mov_read_default },
1729
{ MKTAG( 's', 'd', 'h', 'd' ), mov_read_default },
1730
{ MKTAG( 's', 'k', 'i', 'p' ), mov_read_leaf },
1731
{ MKTAG( 's', 'm', 'h', 'd' ), mov_read_leaf }, /* sound media info header */
1732
{ MKTAG( 'S', 'M', 'I', ' ' ), mov_read_smi }, /* Sorenson extension ??? */
1733
{ MKTAG( 'a', 'v', 'c', 'C' ), mov_read_avcC },
1734
{ MKTAG( 's', 't', 'b', 'l' ), mov_read_default },
1735
{ MKTAG( 's', 't', 'c', 'o' ), mov_read_stco },
1736
{ MKTAG( 's', 't', 'd', 'p' ), mov_read_default },
1737
{ MKTAG( 's', 't', 's', 'c' ), mov_read_stsc },
1738
{ MKTAG( 's', 't', 's', 'd' ), mov_read_stsd }, /* sample description */
1739
{ MKTAG( 's', 't', 's', 'h' ), mov_read_default },
1740
{ MKTAG( 's', 't', 's', 's' ), mov_read_stss }, /* sync sample */
1741
{ MKTAG( 's', 't', 's', 'z' ), mov_read_stsz }, /* sample size */
1742
{ MKTAG( 's', 't', 't', 's' ), mov_read_stts },
1743
{ MKTAG( 't', 'k', 'h', 'd' ), mov_read_tkhd }, /* track header */
1744
{ MKTAG( 't', 'r', 'a', 'k' ), mov_read_trak },
1745
{ MKTAG( 't', 'r', 'e', 'f' ), mov_read_default }, /* not really */
1746
{ MKTAG( 'u', 'd', 't', 'a' ), mov_read_leaf },
1747
{ MKTAG( 'u', 'r', 'l', ' ' ), mov_read_leaf },
1748
{ MKTAG( 'u', 'r', 'n', ' ' ), mov_read_leaf },
1749
{ MKTAG( 'u', 'u', 'i', 'd' ), mov_read_leaf },
1750
{ MKTAG( 'v', 'm', 'h', 'd' ), mov_read_leaf }, /* video media info header */
1751
{ MKTAG( 'w', 'a', 'v', 'e' ), mov_read_wave },
1752
/* extra mp4 */
1753
{ MKTAG( 'M', 'D', 'E', 'S' ), mov_read_leaf },
1754
/* QT atoms */
1755
{ MKTAG( 'c', 'h', 'a', 'p' ), mov_read_leaf },
1756
{ MKTAG( 'c', 'l', 'i', 'p' ), mov_read_default },
1757
{ MKTAG( 'c', 'r', 'g', 'n' ), mov_read_leaf },
1758
{ MKTAG( 'c', 't', 'a', 'b' ), mov_read_ctab },
1759
{ MKTAG( 'e', 's', 'd', 's' ), mov_read_esds },
1760
{ MKTAG( 'k', 'm', 'a', 't' ), mov_read_leaf },
1761
{ MKTAG( 'm', 'a', 't', 't' ), mov_read_default },
1762
{ MKTAG( 'r', 'd', 'r', 'f' ), mov_read_leaf },
1763
{ MKTAG( 'r', 'm', 'd', 'a' ), mov_read_default },
1764
{ MKTAG( 'r', 'm', 'd', 'r' ), mov_read_leaf },
1765
{ MKTAG( 'r', 'm', 'r', 'a' ), mov_read_default },
1766
{ MKTAG( 's', 'c', 'p', 't' ), mov_read_leaf },
1767
{ MKTAG( 's', 's', 'r', 'c' ), mov_read_leaf },
1768
{ MKTAG( 's', 'y', 'n', 'c' ), mov_read_leaf },
1769
{ MKTAG( 't', 'c', 'm', 'd' ), mov_read_leaf },
1770
{ MKTAG( 'w', 'i', 'd', 'e' ), mov_read_wide }, /* place holder */
1771
//{ MKTAG( 'r', 'm', 'q', 'u' ), mov_read_leaf },
1772
#ifdef CONFIG_ZLIB
1773
{ MKTAG( 'c', 'm', 'o', 'v' ), mov_read_cmov },
1774
#else
1775
{ MKTAG( 'c', 'm', 'o', 'v' ), mov_read_leaf },
1776
#endif
1777
{ 0L, mov_read_leaf }
1778
};
1779

    
1780
static void mov_free_stream_context(MOVStreamContext *sc)
1781
{
1782
    if(sc) {
1783
        av_freep(&sc->chunk_offsets);
1784
        av_freep(&sc->sample_to_chunk);
1785
        av_freep(&sc->sample_sizes);
1786
        av_freep(&sc->keyframes);
1787
        av_freep(&sc->stts_data);
1788
        av_freep(&sc->ctts_data);
1789
        av_freep(&sc);
1790
    }
1791
}
1792

    
1793
static inline uint32_t mov_to_tag(uint8_t *buf)
1794
{
1795
    return MKTAG(buf[0], buf[1], buf[2], buf[3]);
1796
}
1797

    
1798
static inline uint32_t to_be32(uint8_t *buf)
1799
{
1800
    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
1801
}
1802

    
1803
/* XXX: is it sufficient ? */
1804
static int mov_probe(AVProbeData *p)
1805
{
1806
    unsigned int offset;
1807
    uint32_t tag;
1808
    int score = 0;
1809

    
1810
    /* check file header */
1811
    if (p->buf_size <= 12)
1812
        return 0;
1813
    offset = 0;
1814
    for(;;) {
1815
        /* ignore invalid offset */
1816
        if ((offset + 8) > (unsigned int)p->buf_size)
1817
            return score;
1818
        tag = mov_to_tag(p->buf + offset + 4);
1819
        switch(tag) {
1820
        /* check for obvious tags */
1821
        case MKTAG( 'm', 'o', 'o', 'v' ):
1822
        case MKTAG( 'm', 'd', 'a', 't' ):
1823
        case MKTAG( 'p', 'n', 'o', 't' ): /* detect movs with preview pics like ew.mov and april.mov */
1824
        case MKTAG( 'u', 'd', 't', 'a' ): /* Packet Video PVAuthor adds this and a lot of more junk */
1825
            return AVPROBE_SCORE_MAX;
1826
        /* those are more common words, so rate then a bit less */
1827
        case MKTAG( 'w', 'i', 'd', 'e' ):
1828
        case MKTAG( 'f', 'r', 'e', 'e' ):
1829
        case MKTAG( 'j', 'u', 'n', 'k' ):
1830
        case MKTAG( 'p', 'i', 'c', 't' ):
1831
            return AVPROBE_SCORE_MAX - 5;
1832
        case MKTAG( 'f', 't', 'y', 'p' ):
1833
        case MKTAG( 's', 'k', 'i', 'p' ):
1834
        case MKTAG( 'u', 'u', 'i', 'd' ):
1835
            offset = to_be32(p->buf+offset) + offset;
1836
            /* if we only find those cause probedata is too small at least rate them */
1837
            score = AVPROBE_SCORE_MAX - 50;
1838
            break;
1839
        default:
1840
            /* unrecognized tag */
1841
            return score;
1842
        }
1843
    }
1844
    return score;
1845
}
1846

    
1847
static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
1848
{
1849
    MOVContext *mov = (MOVContext *) s->priv_data;
1850
    ByteIOContext *pb = &s->pb;
1851
    int i, j, nb, err;
1852
    MOV_atom_t atom = { 0, 0, 0 };
1853

    
1854
    mov->fc = s;
1855
    mov->parse_table = mov_default_parse_table;
1856
#if 0
1857
    /* XXX: I think we should auto detect */
1858
    if(s->iformat->name[1] == 'p')
1859
        mov->mp4 = 1;
1860
#endif
1861
    if(!url_is_streamed(pb)) /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
1862
        atom.size = url_fsize(pb);
1863
    else
1864
        atom.size = 0x7FFFFFFFFFFFFFFFLL;
1865

    
1866
#ifdef DEBUG
1867
    av_log(NULL, AV_LOG_DEBUG, "filesz=%Ld\n", atom.size);
1868
#endif
1869

    
1870
    /* check MOV header */
1871
    err = mov_read_default(mov, pb, atom);
1872
    if (err<0 || (!mov->found_moov && !mov->found_mdat)) {
1873
        av_log(s, AV_LOG_ERROR, "mov: header not found !!! (err:%d, moov:%d, mdat:%d) pos:%"PRId64"\n",
1874
                err, mov->found_moov, mov->found_mdat, url_ftell(pb));
1875
        return -1;
1876
    }
1877
#ifdef DEBUG
1878
    av_log(NULL, AV_LOG_DEBUG, "on_parse_exit_offset=%d\n", (int) url_ftell(pb));
1879
#endif
1880
    /* some cleanup : make sure we are on the mdat atom */
1881
    if(!url_is_streamed(pb) && (url_ftell(pb) != mov->mdat_offset))
1882
        url_fseek(pb, mov->mdat_offset, SEEK_SET);
1883

    
1884
    mov->next_chunk_offset = mov->mdat_offset; /* initialise reading */
1885

    
1886
#ifdef DEBUG
1887
    av_log(NULL, AV_LOG_DEBUG, "mdat_reset_offset=%d\n", (int) url_ftell(pb));
1888
#endif
1889

    
1890
#ifdef DEBUG
1891
    av_log(NULL, AV_LOG_DEBUG, "streams= %d\n", s->nb_streams);
1892
#endif
1893
    mov->total_streams = nb = s->nb_streams;
1894

    
1895
#if 1
1896
    for(i=0; i<s->nb_streams;) {
1897
        if(s->streams[i]->codec->codec_type == CODEC_TYPE_MOV_OTHER) {/* not audio, not video, delete */
1898
            av_free(s->streams[i]);
1899
            for(j=i+1; j<s->nb_streams; j++)
1900
                s->streams[j-1] = s->streams[j];
1901
            s->nb_streams--;
1902
        } else
1903
            i++;
1904
    }
1905
    for(i=0; i<s->nb_streams;i++) {
1906
        MOVStreamContext *sc = (MOVStreamContext *)s->streams[i]->priv_data;
1907

    
1908
        if(!sc->time_rate)
1909
            sc->time_rate=1;
1910
        av_set_pts_info(s->streams[i], 64, sc->time_rate, sc->time_scale);
1911

    
1912
        assert(s->streams[i]->duration % sc->time_rate == 0);
1913
        s->streams[i]->duration /= sc->time_rate;
1914

    
1915
        sc->ffindex = i;
1916
        sc->is_ff_stream = 1;
1917
    }
1918
#endif
1919
#ifdef DEBUG
1920
    av_log(NULL, AV_LOG_DEBUG, "real streams= %d\n", s->nb_streams);
1921
#endif
1922
    return 0;
1923
}
1924

    
1925
/* Yes, this is ugly... I didn't write the specs of QT :p */
1926
/* XXX:remove useless commented code sometime */
1927
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
1928
{
1929
    MOVContext *mov = (MOVContext *) s->priv_data;
1930
    MOVStreamContext *sc;
1931
    AVStream *st;
1932
    int64_t offset = INT64_MAX;
1933
    int64_t best_dts = INT64_MAX;
1934
    int i, a, b, m;
1935
    int size;
1936
    int idx;
1937
    size = 0x0FFFFFFF;
1938

    
1939
#ifdef MOV_SPLIT_CHUNKS
1940
    if (mov->partial) {
1941
        sc = mov->partial;
1942
        idx = sc->sample_to_chunk_index;
1943

    
1944
        if (idx < 0) return 0;
1945
#ifdef DEBUG
1946
        fprintf(stderr, "sc[ffid %d]->sample_size = %d\n", sc->ffindex, sc->sample_size);
1947
#endif
1948
        //size = sc->sample_sizes[sc->current_sample];
1949
        // that ain't working...
1950
        //size = (sc->sample_size)?sc->sample_size:sc->sample_sizes[sc->current_sample];
1951
        size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample];
1952

    
1953
        sc->current_sample++;
1954
        sc->left_in_chunk--;
1955

    
1956
        if (sc->left_in_chunk <= 0)
1957
            mov->partial = 0;
1958
        offset = mov->next_chunk_offset;
1959
        /* extract the sample */
1960

    
1961
        goto readchunk;
1962
    }
1963
#endif
1964

    
1965
again:
1966
    sc = 0;
1967
    if(offset == INT64_MAX)
1968
        best_dts= INT64_MAX;
1969
    for(i=0; i<mov->total_streams; i++) {
1970
        MOVStreamContext *msc = mov->streams[i];
1971

    
1972
        if ((msc->next_chunk < msc->chunk_count) && msc->next_chunk >= 0){
1973
            if (msc->sample_to_time_index < msc->stts_count && mov->ni) {
1974
                int64_t dts;
1975
                int index= msc->sample_to_time_index;
1976
                int sample= msc->sample_to_time_sample;
1977
                int time= msc->sample_to_time_time;
1978
                int duration = msc->stts_data[index].duration;
1979
                int count = msc->stts_data[index].count;
1980
                if (sample + count < msc->current_sample) {
1981
                    sample += count;
1982
                    time   += count*duration;
1983
                    index ++;
1984
                    duration = msc->stts_data[index].duration;
1985
                }
1986
                dts = time + (msc->current_sample-1 - sample) * (int64_t)duration;
1987
                dts = av_rescale(dts, AV_TIME_BASE, msc->time_scale);
1988
//                av_log(NULL, AV_LOG_DEBUG, "%d %Ld %Ld %Ld \n", i, dts, best_dts, offset);
1989
                if(dts < best_dts){
1990
                    best_dts= dts;
1991
                    sc = msc;
1992
                    offset = msc->chunk_offsets[msc->next_chunk];
1993
                }
1994
            }else{
1995
            //av_log(NULL, AV_LOG_DEBUG, "MOCHUNK %ld  %d   %p  pos:%Ld\n", mov->streams[i]->next_chunk, mov->total_streams, mov->streams[i], url_ftell(&s->pb));
1996
                if ((msc->chunk_offsets[msc->next_chunk] < offset)) {
1997
                    sc = msc;
1998
                    offset = msc->chunk_offsets[msc->next_chunk];
1999
                    //av_log(NULL, AV_LOG_DEBUG, "SELETED  %Ld  i:%d\n", offset, i);
2000
                }
2001
            }
2002
        }
2003
    }
2004
    if (!sc || offset==INT64_MAX)
2005
        return -1;
2006

    
2007
    sc->next_chunk++;
2008

    
2009
    if(mov->next_chunk_offset < offset) { /* some meta data */
2010
        url_fskip(&s->pb, (offset - mov->next_chunk_offset));
2011
        mov->next_chunk_offset = offset;
2012
    }
2013

    
2014
//av_log(NULL, AV_LOG_DEBUG, "chunk: [%i] %lli -> %lli\n", st_id, mov->next_chunk_offset, offset);
2015
    if(!sc->is_ff_stream || (s->streams[sc->ffindex]->discard >= AVDISCARD_ALL)) {
2016
        url_fskip(&s->pb, (offset - mov->next_chunk_offset));
2017
        mov->next_chunk_offset = offset;
2018
        offset = INT64_MAX;
2019
        goto again;
2020
    }
2021

    
2022
    /* now get the chunk size... */
2023

    
2024
    for(i=0; i<mov->total_streams; i++) {
2025
        MOVStreamContext *msc = mov->streams[i];
2026
        if ((msc->next_chunk < msc->chunk_count)
2027
            && msc->chunk_offsets[msc->next_chunk] - offset < size
2028
            && msc->chunk_offsets[msc->next_chunk] > offset)
2029
            size = msc->chunk_offsets[msc->next_chunk] - offset;
2030
    }
2031

    
2032
#ifdef MOV_MINOLTA_FIX
2033
    //Make sure that size is according to sample_size (Needed by .mov files
2034
    //created on a Minolta Dimage Xi where audio chunks contains waste data in the end)
2035
    //Maybe we should really not only check sc->sample_size, but also sc->sample_sizes
2036
    //but I have no such movies
2037
    if (sc->sample_size > 0) {
2038
        int foundsize=0;
2039
        for(i=0; i<(sc->sample_to_chunk_sz); i++) {
2040
            if( (sc->sample_to_chunk[i].first)<=(sc->next_chunk) )
2041
            {
2042
                // I can't figure out why for PCM audio sample_size is always 1
2043
                // (it should actually be channels*bits_per_second/8) but it is.
2044
                AVCodecContext* cod = s->streams[sc->ffindex]->codec;
2045
                if (sc->sample_size == 1 && (cod->codec_id == CODEC_ID_PCM_S16BE || cod->codec_id == CODEC_ID_PCM_S16LE))
2046
                    foundsize=(sc->sample_to_chunk[i].count*cod->channels*cod->bits_per_sample)/8;
2047
                else
2048
                    foundsize=sc->sample_to_chunk[i].count*sc->sample_size;
2049
            }
2050
#ifdef DEBUG
2051
            av_log(NULL, AV_LOG_DEBUG, "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);
2052
#endif
2053
        }
2054
        if( (foundsize>0) && (foundsize<size) )
2055
        {
2056
#ifdef DEBUG
2057
            /*av_log(NULL, AV_LOG_DEBUG, "this size should actually be %d\n",foundsize);*/
2058
#endif
2059
            size=foundsize;
2060
        }
2061
    }
2062
#endif //MOV_MINOLTA_FIX
2063

    
2064
    idx = sc->sample_to_chunk_index;
2065
    if (idx + 1 < sc->sample_to_chunk_sz && sc->next_chunk >= sc->sample_to_chunk[idx + 1].first)
2066
        idx++;
2067
    sc->sample_to_chunk_index = idx;
2068
#ifdef MOV_SPLIT_CHUNKS
2069
    /* split chunks into samples */
2070
    if (sc->sample_size == 0 || sc->sample_size > 100) {
2071
        if (idx >= 0 && sc->sample_to_chunk[idx].count != 1) {
2072
            mov->partial = sc;
2073
            /* we'll have to get those samples before next chunk */
2074
            sc->left_in_chunk = sc->sample_to_chunk[idx].count - 1;
2075
            size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample];
2076
        }
2077

    
2078
        sc->current_sample++;
2079
    }else if(idx + 1 < sc->sample_to_chunk_sz){
2080
        sc->current_sample += sc->sample_size * sc->sample_to_chunk[idx].count;
2081
    }
2082
#endif
2083

    
2084
readchunk:
2085
#ifdef DEBUG
2086
    av_log(NULL, AV_LOG_DEBUG, "chunk: %lli -> %lli (%i)\n", offset, offset + size, size);
2087
#endif
2088
    if(size == 0x0FFFFFFF)
2089
        size = mov->mdat_size + mov->mdat_offset - offset;
2090
    if(size < 0)
2091
        return -1;
2092
    if(size == 0)
2093
        return -1;
2094
    url_fseek(&s->pb, offset, SEEK_SET);
2095

    
2096
    av_get_packet(&s->pb, pkt, size);
2097
    pkt->stream_index = sc->ffindex;
2098

    
2099
    // If the keyframes table exists, mark any samples that are in the table as key frames.
2100
    // If no table exists, treat very sample as a key frame.
2101
    if (sc->keyframes) {
2102
        a = 0;
2103
        b = sc->keyframe_count - 1;
2104

    
2105
        while (a < b) {
2106
            m = (a + b + 1) >> 1;
2107
            if (sc->keyframes[m] > sc->current_sample) {
2108
                b = m - 1;
2109
            } else {
2110
                a = m;
2111
            }
2112
        }
2113

    
2114
        if (sc->keyframes[a] == sc->current_sample)
2115
            pkt->flags |= PKT_FLAG_KEY;
2116
    }
2117
    else
2118
        pkt->flags |= PKT_FLAG_KEY;
2119

    
2120
#ifdef DEBUG
2121
/*
2122
    av_log(NULL, AV_LOG_DEBUG, "Packet (%d, %ld) ", pkt->stream_index, pkt->size);
2123
    for(i=0; i<8; i++)
2124
        av_log(NULL, AV_LOG_DEBUG, "%02x ", pkt->data[i]);
2125
    for(i=0; i<8; i++)
2126
        av_log(NULL, AV_LOG_DEBUG, "%c ", (pkt->data[i]) & 0x7F);
2127
    av_log(NULL, AV_LOG_DEBUG, "\n");
2128
*/
2129
#endif
2130

    
2131
    mov->next_chunk_offset = offset + size;
2132

    
2133
    /* find the corresponding dts */
2134
    if (sc && sc->sample_to_time_index < sc->stts_count && pkt) {
2135
      unsigned int count;
2136
      uint64_t dts, pts;
2137
      unsigned int duration = sc->stts_data[sc->sample_to_time_index].duration;
2138
      count = sc->stts_data[sc->sample_to_time_index].count;
2139
      if ((sc->sample_to_time_sample + count) < sc->current_sample) {
2140
        sc->sample_to_time_sample += count;
2141
        sc->sample_to_time_time   += count*duration;
2142
        sc->sample_to_time_index ++;
2143
        duration = sc->stts_data[sc->sample_to_time_index].duration;
2144
      }
2145
      dts = sc->sample_to_time_time + (sc->current_sample-1 - sc->sample_to_time_sample) * (int64_t)duration;
2146
        /* find the corresponding pts */
2147
        if (sc->sample_to_ctime_index < sc->ctts_count) {
2148
            int duration = sc->ctts_data[sc->sample_to_ctime_index].duration;
2149
            int count = sc->ctts_data[sc->sample_to_ctime_index].count;
2150

    
2151
            if ((sc->sample_to_ctime_sample + count) < sc->current_sample) {
2152
                sc->sample_to_ctime_sample += count;
2153
                sc->sample_to_ctime_index ++;
2154
                duration = sc->ctts_data[sc->sample_to_ctime_index].duration;
2155
            }
2156
            pts = dts + duration;
2157
        }else
2158
            pts = dts;
2159

    
2160
        st= s->streams[ sc->ffindex ];
2161
        assert(pts % st->time_base.num == 0);
2162
        assert(dts % st->time_base.num == 0);
2163

    
2164
        pkt->pts = pts / st->time_base.num;
2165
        pkt->dts = dts / st->time_base.num;
2166
#ifdef DEBUG
2167
    av_log(NULL, AV_LOG_DEBUG, "stream #%d smp #%ld dts = %lld pts = %lld (smp:%ld time:%lld idx:%d ent:%d count:%d dur:%d)\n"
2168
      , pkt->stream_index, sc->current_sample-1, pkt->dts, pkt->pts
2169
      , sc->sample_to_time_sample
2170
      , sc->sample_to_time_time
2171
      , sc->sample_to_time_index
2172
      , sc->stts_count
2173
      , count
2174
      , duration);
2175
#endif
2176
    }
2177

    
2178
    return 0;
2179
}
2180

    
2181
#if defined(MOV_SPLIT_CHUNKS) && defined(MOV_SEEK)
2182
/**
2183
 * Seek method based on the one described in the Appendix C of QTFileFormat.pdf
2184
 */
2185
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2186
{
2187
    MOVContext* mov = (MOVContext *) s->priv_data;
2188
    MOVStreamContext* sc;
2189
    int32_t i, a, b, m;
2190
    int64_t start_time;
2191
    int32_t seek_sample, sample;
2192
    int32_t duration;
2193
    int32_t count;
2194
    int32_t chunk;
2195
    int32_t left_in_chunk;
2196
    int64_t chunk_file_offset;
2197
    int64_t sample_file_offset;
2198
    int32_t first_chunk_sample;
2199
    int32_t sample_to_chunk_idx;
2200
    int sample_to_time_index;
2201
    long sample_to_time_sample = 0;
2202
    uint64_t sample_to_time_time = 0;
2203
    int mov_idx;
2204

    
2205
    // Find the corresponding mov stream
2206
    for (mov_idx = 0; mov_idx < mov->total_streams; mov_idx++)
2207
        if (mov->streams[mov_idx]->ffindex == stream_index)
2208
            break;
2209
    if (mov_idx == mov->total_streams) {
2210
        av_log(s, AV_LOG_ERROR, "mov: requested stream was not found in mov streams (idx=%i)\n", stream_index);
2211
        return -1;
2212
    }
2213
    sc = mov->streams[mov_idx];
2214

    
2215
    sample_time *= s->streams[stream_index]->time_base.num;
2216

    
2217
    // Step 1. Find the edit that contains the requested time (elst)
2218
    if (sc->edit_count && 0) {
2219
        // FIXME should handle edit list
2220
        av_log(s, AV_LOG_ERROR, "mov: does not handle seeking in files that contain edit list (c:%d)\n", sc->edit_count);
2221
        return -1;
2222
    }
2223

    
2224
    // Step 2. Find the corresponding sample using the Time-to-sample atom (stts) */
2225
#ifdef DEBUG
2226
  av_log(s, AV_LOG_DEBUG, "Searching for time %li in stream #%i (time_scale=%i)\n", (long)timestamp, mov_idx, sc->time_scale);
2227
#endif
2228
    start_time = 0; // FIXME use elst atom
2229
    sample = 1; // sample are 0 based in table
2230
#ifdef DEBUG
2231
    av_log(s, AV_LOG_DEBUG, "Searching for sample_time %li \n", (long)sample_time);
2232
#endif
2233
    for (i = 0; i < sc->stts_count; i++) {
2234
        count = sc->stts_data[i].count;
2235
        duration = sc->stts_data[i].duration;
2236
//av_log(s, AV_LOG_DEBUG, "> sample_time %lli \n", (long)sample_time);
2237
//av_log(s, AV_LOG_DEBUG, "> count=%i duration=%i\n", count, duration);
2238
        if ((start_time + count*duration) > sample_time) {
2239
            sample_to_time_time = start_time;
2240
            sample_to_time_index = i;
2241
            sample_to_time_sample = sample;
2242
            sample += (sample_time - start_time) / duration;
2243
            break;
2244
        }
2245
        sample += count;
2246
        start_time += count * duration;
2247
    }
2248
    sample_to_time_time = start_time;
2249
    sample_to_time_index = i;
2250
    /* NOTE: despite what qt doc say, the dt value (Display Time in qt vocabulary) computed with the stts atom
2251
       is a decoding time stamp (dts) not a presentation time stamp. And as usual dts != pts for stream with b frames */
2252

    
2253
#ifdef DEBUG
2254
    av_log(s, AV_LOG_DEBUG, "Found time %li at sample #%u\n", (long)sample_time, sample);
2255
#endif
2256
    if (sample > sc->sample_count) {
2257
        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);
2258
        return -1;
2259
    }
2260

    
2261
    // Step 3. Find the prior sync. sample using the Sync sample atom (stss)
2262
    if (sc->keyframes) {
2263
        a = 0;
2264
        b = sc->keyframe_count - 1;
2265
        while (a < b) {
2266
            m = (a + b + 1) >> 1;
2267
            if (sc->keyframes[m] > sample) {
2268
                b = m - 1;
2269
            } else {
2270
                a = m;
2271
            }
2272
#ifdef DEBUG
2273
         // av_log(s, AV_LOG_DEBUG, "a=%i (%i) b=%i (%i) m=%i (%i) stream #%i\n", a, sc->keyframes[a], b, sc->keyframes[b], m, sc->keyframes[m], mov_idx);
2274
#endif
2275
        }
2276
        // for low latency prob: always use the previous keyframe, just uncomment the next line
2277
        // if (a) a--;
2278
        seek_sample = sc->keyframes[a];
2279
    }
2280
    else
2281
        seek_sample = sample; // else all samples are key frames
2282
#ifdef DEBUG
2283
    av_log(s, AV_LOG_DEBUG, "Found nearest keyframe at sample #%i \n", seek_sample);
2284
#endif
2285

    
2286
    // Step 4. Find the chunk of the sample using the Sample-to-chunk-atom (stsc)
2287
    for (first_chunk_sample = 1, i = 0; i < (sc->sample_to_chunk_sz - 1); i++) {
2288
        b = (sc->sample_to_chunk[i + 1].first - sc->sample_to_chunk[i].first) * sc->sample_to_chunk[i].count;
2289
        if (seek_sample >= first_chunk_sample && seek_sample < (first_chunk_sample + b))
2290
            break;
2291
        first_chunk_sample += b;
2292
    }
2293
    chunk = sc->sample_to_chunk[i].first + (seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count;
2294
    left_in_chunk = sc->sample_to_chunk[i].count - (seek_sample - first_chunk_sample) % sc->sample_to_chunk[i].count;
2295
    first_chunk_sample += ((seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count) * sc->sample_to_chunk[i].count;
2296
    sample_to_chunk_idx = i;
2297
#ifdef DEBUG
2298
    av_log(s, AV_LOG_DEBUG, "Sample was found in chunk #%i at sample offset %i (idx %i)\n", chunk, seek_sample - first_chunk_sample, sample_to_chunk_idx);
2299
#endif
2300

    
2301
    // Step 5. Find the offset of the chunk using the chunk offset atom
2302
    if (!sc->chunk_offsets) {
2303
        av_log(s, AV_LOG_ERROR, "mov: no chunk offset atom, unable to seek\n");
2304
        return -1;
2305
    }
2306
    if (chunk > sc->chunk_count) {
2307
        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);
2308
        return -1;
2309
    }
2310
    chunk_file_offset = sc->chunk_offsets[chunk - 1];
2311
#ifdef DEBUG
2312
    av_log(s, AV_LOG_DEBUG, "Chunk file offset is #%llu \n", chunk_file_offset);
2313
#endif
2314

    
2315
    // Step 6. Find the byte offset within the chunk using the sample size atom
2316
    sample_file_offset = chunk_file_offset;
2317
    if (sc->sample_size)
2318
        sample_file_offset += (seek_sample - first_chunk_sample) * sc->sample_size;
2319
    else {
2320
        for (i = 0; i < (seek_sample - first_chunk_sample); i++) {
2321
        sample_file_offset += sc->sample_sizes[first_chunk_sample + i - 1];
2322
        }
2323
    }
2324
#ifdef DEBUG
2325
    av_log(s, AV_LOG_DEBUG, "Sample file offset is #%llu \n", sample_file_offset);
2326
#endif
2327

    
2328
    // Step 6. Update the parser
2329
    mov->partial = sc;
2330
    mov->next_chunk_offset = sample_file_offset;
2331
    // Update current stream state
2332
    sc->current_sample = seek_sample - 1;  // zero based
2333
    sc->left_in_chunk = left_in_chunk;
2334
    sc->next_chunk = chunk; // +1 -1 (zero based)
2335
    sc->sample_to_chunk_index = sample_to_chunk_idx;
2336

    
2337
    // Update other streams
2338
    for (i = 0; i<mov->total_streams; i++) {
2339
        MOVStreamContext *msc;
2340
        if (i == mov_idx) continue;
2341
        // Find the nearest 'next' chunk
2342
        msc = mov->streams[i];
2343
        a = 0;
2344
        b = msc->chunk_count - 1;
2345
        while (a < b) {
2346
            m = (a + b + 1) >> 1;
2347
            if (msc->chunk_offsets[m] > chunk_file_offset) {
2348
                b = m - 1;
2349
            } else {
2350
                a = m;
2351
            }
2352
#ifdef DEBUG
2353
/*            av_log(s, AV_LOG_DEBUG, "a=%i (%li) b=%i (%li) m=%i (%li) stream #%i\n"
2354
            , a, (long)msc->chunk_offsets[a], b, (long)msc->chunk_offsets[b], m, (long)msc->chunk_offsets[m],  i); */
2355
#endif
2356
        }
2357
        msc->next_chunk = a;
2358
        if (msc->chunk_offsets[a] < chunk_file_offset && a < (msc->chunk_count-1))
2359
            msc->next_chunk ++;
2360
#ifdef DEBUG
2361
        av_log(s, AV_LOG_DEBUG, "Nearest next chunk for stream #%i is #%i @%lli\n", i, msc->next_chunk+1, msc->chunk_offsets[msc->next_chunk]);
2362
#endif
2363
        // Compute sample count and index in the sample_to_chunk table (what a pity)
2364
        msc->sample_to_chunk_index = 0;
2365
        msc->current_sample = 0;
2366
        for(;  msc->sample_to_chunk_index < (msc->sample_to_chunk_sz - 1)
2367
            && msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first <= (1 + msc->next_chunk); msc->sample_to_chunk_index++) {
2368
            msc->current_sample += (msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first - msc->sample_to_chunk[msc->sample_to_chunk_index].first) \
2369
            * msc->sample_to_chunk[msc->sample_to_chunk_index].count;
2370
        }
2371
        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;
2372
        msc->left_in_chunk = msc->sample_to_chunk[msc->sample_to_chunk_index].count - 1;
2373
        // Find corresponding position in stts (used later to compute dts)
2374
        sample = 0;
2375
        start_time = 0;
2376
        for (msc->sample_to_time_index = 0; msc->sample_to_time_index < msc->stts_count; msc->sample_to_time_index++) {
2377
            count = msc->stts_data[msc->sample_to_time_index].count;
2378
            duration = msc->stts_data[msc->sample_to_time_index].duration;
2379
            if ((sample + count - 1) > msc->current_sample) {
2380
                msc->sample_to_time_time = start_time;
2381
                msc->sample_to_time_sample = sample;
2382
                break;
2383
            }
2384
            sample += count;
2385
            start_time += count * duration;
2386
        }
2387
        sample = 0;
2388
        for (msc->sample_to_ctime_index = 0; msc->sample_to_ctime_index < msc->ctts_count; msc->sample_to_ctime_index++) {
2389
            count = msc->ctts_data[msc->sample_to_ctime_index].count;
2390
            duration = msc->ctts_data[msc->sample_to_ctime_index].duration;
2391
            if ((sample + count - 1) > msc->current_sample) {
2392
                msc->sample_to_ctime_sample = sample;
2393
                break;
2394
            }
2395
            sample += count;
2396
        }
2397
#ifdef DEBUG
2398
        av_log(s, AV_LOG_DEBUG, "Next Sample for stream #%i is #%i @%i\n", i, msc->current_sample + 1, msc->sample_to_chunk_index + 1);
2399
#endif
2400
    }
2401
    return 0;
2402
}
2403
#endif
2404

    
2405
static int mov_read_close(AVFormatContext *s)
2406
{
2407
    int i;
2408
    MOVContext *mov = (MOVContext *) s->priv_data;
2409
    for(i=0; i<mov->total_streams; i++)
2410
        mov_free_stream_context(mov->streams[i]);
2411
    /* free color tabs */
2412
    for(i=0; i<mov->ctab_size; i++)
2413
        av_freep(&mov->ctab[i]);
2414
    av_freep(&mov->ctab);
2415
    return 0;
2416
}
2417

    
2418
static AVInputFormat mov_iformat = {
2419
    "mov,mp4,m4a,3gp,3g2",
2420
    "QuickTime/MPEG4 format",
2421
    sizeof(MOVContext),
2422
    mov_probe,
2423
    mov_read_header,
2424
    mov_read_packet,
2425
    mov_read_close,
2426
#if defined(MOV_SPLIT_CHUNKS) && defined(MOV_SEEK)
2427
    mov_read_seek,
2428
#endif
2429
};
2430

    
2431
int mov_init(void)
2432
{
2433
    av_register_input_format(&mov_iformat);
2434
    return 0;
2435
}