Statistics
| Branch: | Revision:

ffmpeg / libavformat / mov.c @ 2f412421

History | View | Annotate | Download (87.5 KB)

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

    
23
#include <limits.h>
24

    
25
//#define DEBUG
26
//#define DEBUG_METADATA
27
//#define MOV_EXPORT_ALL_METADATA
28

    
29
#include "libavutil/intreadwrite.h"
30
#include "libavutil/avstring.h"
31
#include "avformat.h"
32
#include "riff.h"
33
#include "isom.h"
34
#include "libavcodec/mpeg4audio.h"
35
#include "libavcodec/mpegaudiodata.h"
36
#include "libavcodec/get_bits.h"
37

    
38
#if CONFIG_ZLIB
39
#include <zlib.h>
40
#endif
41

    
42
/*
43
 * First version by Francois Revol revol@free.fr
44
 * Seek function by Gael Chardon gael.dev@4now.net
45
 *
46
 * Features and limitations:
47
 * - reads most of the QT files I have (at least the structure),
48
 *   Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html
49
 * - the code is quite ugly... maybe I won't do it recursive next time :-)
50
 *
51
 * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/
52
 * when coding this :) (it's a writer anyway)
53
 *
54
 * Reference documents:
55
 * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt
56
 * Apple:
57
 *  http://developer.apple.com/documentation/QuickTime/QTFF/
58
 *  http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf
59
 * QuickTime is a trademark of Apple (AFAIK :))
60
 */
61

    
62
#include "qtpalette.h"
63

    
64

    
65
#undef NDEBUG
66
#include <assert.h>
67

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

    
70
/* those functions parse an atom */
71
/* return code:
72
  0: continue to parse next atom
73
 <0: error occurred, exit
74
*/
75
/* links atom IDs to parse functions */
76
typedef struct MOVParseTableEntry {
77
    uint32_t type;
78
    int (*parse)(MOVContext *ctx, ByteIOContext *pb, MOVAtom atom);
79
} MOVParseTableEntry;
80

    
81
static const MOVParseTableEntry mov_default_parse_table[];
82

    
83
static int mov_metadata_trkn(MOVContext *c, ByteIOContext *pb, unsigned len)
84
{
85
    char buf[16];
86

    
87
    get_be16(pb); // unknown
88
    snprintf(buf, sizeof(buf), "%d", get_be16(pb));
89
    av_metadata_set2(&c->fc->metadata, "track", buf, 0);
90

    
91
    get_be16(pb); // total tracks
92

    
93
    return 0;
94
}
95

    
96
static const uint32_t mac_to_unicode[128] = {
97
    0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
98
    0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
99
    0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
100
    0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
101
    0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
102
    0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
103
    0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
104
    0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
105
    0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
106
    0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
107
    0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
108
    0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
109
    0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
110
    0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
111
    0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
112
    0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
113
};
114

    
115
static int mov_read_mac_string(MOVContext *c, ByteIOContext *pb, int len,
116
                               char *dst, int dstlen)
117
{
118
    char *p = dst;
119
    char *end = dst+dstlen-1;
120
    int i;
121

    
122
    for (i = 0; i < len; i++) {
123
        uint8_t t, c = get_byte(pb);
124
        if (c < 0x80 && p < end)
125
            *p++ = c;
126
        else
127
            PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
128
    }
129
    *p = 0;
130
    return p - dst;
131
}
132

    
133
static int mov_read_udta_string(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
134
{
135
#ifdef MOV_EXPORT_ALL_METADATA
136
    char tmp_key[5];
137
#endif
138
    char str[1024], key2[16], language[4] = {0};
139
    const char *key = NULL;
140
    uint16_t str_size, langcode = 0;
141
    uint32_t data_type = 0;
142
    int (*parse)(MOVContext*, ByteIOContext*, unsigned) = NULL;
143

    
144
    switch (atom.type) {
145
    case MKTAG(0xa9,'n','a','m'): key = "title";     break;
146
    case MKTAG(0xa9,'a','u','t'):
147
    case MKTAG(0xa9,'A','R','T'): key = "artist";    break;
148
    case MKTAG(0xa9,'w','r','t'): key = "composer";  break;
149
    case MKTAG( 'c','p','r','t'):
150
    case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
151
    case MKTAG(0xa9,'c','m','t'):
152
    case MKTAG(0xa9,'i','n','f'): key = "comment";   break;
153
    case MKTAG(0xa9,'a','l','b'): key = "album";     break;
154
    case MKTAG(0xa9,'d','a','y'): key = "date";      break;
155
    case MKTAG(0xa9,'g','e','n'): key = "genre";     break;
156
    case MKTAG(0xa9,'t','o','o'):
157
    case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;
158
    case MKTAG( 'd','e','s','c'): key = "description";break;
159
    case MKTAG( 'l','d','e','s'): key = "synopsis";  break;
160
    case MKTAG( 't','v','s','h'): key = "show";      break;
161
    case MKTAG( 't','v','e','n'): key = "episode_id";break;
162
    case MKTAG( 't','v','n','n'): key = "network";   break;
163
    case MKTAG( 't','r','k','n'): key = "track";
164
        parse = mov_metadata_trkn; break;
165
    }
166

    
167
    if (c->itunes_metadata && atom.size > 8) {
168
        int data_size = get_be32(pb);
169
        int tag = get_le32(pb);
170
        if (tag == MKTAG('d','a','t','a')) {
171
            data_type = get_be32(pb); // type
172
            get_be32(pb); // unknown
173
            str_size = data_size - 16;
174
            atom.size -= 16;
175
        } else return 0;
176
    } else if (atom.size > 4 && key && !c->itunes_metadata) {
177
        str_size = get_be16(pb); // string length
178
        langcode = get_be16(pb);
179
        ff_mov_lang_to_iso639(langcode, language);
180
        atom.size -= 4;
181
    } else
182
        str_size = atom.size;
183

    
184
#ifdef MOV_EXPORT_ALL_METADATA
185
    if (!key) {
186
        snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
187
        key = tmp_key;
188
    }
189
#endif
190

    
191
    if (!key)
192
        return 0;
193
    if (atom.size < 0)
194
        return -1;
195

    
196
    str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
197

    
198
    if (parse)
199
        parse(c, pb, str_size);
200
    else {
201
        if (data_type == 3 || (data_type == 0 && langcode < 0x800)) { // MAC Encoded
202
            mov_read_mac_string(c, pb, str_size, str, sizeof(str));
203
        } else {
204
            get_buffer(pb, str, str_size);
205
            str[str_size] = 0;
206
        }
207
        av_metadata_set2(&c->fc->metadata, key, str, 0);
208
        if (*language && strcmp(language, "und")) {
209
            snprintf(key2, sizeof(key2), "%s-%s", key, language);
210
            av_metadata_set2(&c->fc->metadata, key2, str, 0);
211
        }
212
    }
213
#ifdef DEBUG_METADATA
214
    av_log(c->fc, AV_LOG_DEBUG, "lang \"%3s\" ", language);
215
    av_log(c->fc, AV_LOG_DEBUG, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %lld\n",
216
           key, str, (char*)&atom.type, str_size, atom.size);
217
#endif
218

    
219
    return 0;
220
}
221

    
222
static int mov_read_chpl(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
223
{
224
    int64_t start;
225
    int i, nb_chapters, str_len, version;
226
    char str[256+1];
227

    
228
    if ((atom.size -= 5) < 0)
229
        return 0;
230

    
231
    version = get_byte(pb);
232
    get_be24(pb);
233
    if (version)
234
        get_be32(pb); // ???
235
    nb_chapters = get_byte(pb);
236

    
237
    for (i = 0; i < nb_chapters; i++) {
238
        if (atom.size < 9)
239
            return 0;
240

    
241
        start = get_be64(pb);
242
        str_len = get_byte(pb);
243

    
244
        if ((atom.size -= 9+str_len) < 0)
245
            return 0;
246

    
247
        get_buffer(pb, str, str_len);
248
        str[str_len] = 0;
249
        ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
250
    }
251
    return 0;
252
}
253

    
254
static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
255
{
256
    int64_t total_size = 0;
257
    MOVAtom a;
258
    int i;
259

    
260
    if (atom.size < 0)
261
        atom.size = INT64_MAX;
262
    while (total_size + 8 < atom.size && !url_feof(pb)) {
263
        int (*parse)(MOVContext*, ByteIOContext*, MOVAtom) = NULL;
264
        a.size = atom.size;
265
        a.type=0;
266
        if(atom.size >= 8) {
267
            a.size = get_be32(pb);
268
            a.type = get_le32(pb);
269
        }
270
        dprintf(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
271
                a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
272
        total_size += 8;
273
        if (a.size == 1) { /* 64 bit extended size */
274
            a.size = get_be64(pb) - 8;
275
            total_size += 8;
276
        }
277
        if (a.size == 0) {
278
            a.size = atom.size - total_size;
279
            if (a.size <= 8)
280
                break;
281
        }
282
        a.size -= 8;
283
        if(a.size < 0)
284
            break;
285
        a.size = FFMIN(a.size, atom.size - total_size);
286

    
287
        for (i = 0; mov_default_parse_table[i].type; i++)
288
            if (mov_default_parse_table[i].type == a.type) {
289
                parse = mov_default_parse_table[i].parse;
290
                break;
291
            }
292

    
293
        // container is user data
294
        if (!parse && (atom.type == MKTAG('u','d','t','a') ||
295
                       atom.type == MKTAG('i','l','s','t')))
296
            parse = mov_read_udta_string;
297

    
298
        if (!parse) { /* skip leaf atoms data */
299
            url_fskip(pb, a.size);
300
        } else {
301
            int64_t start_pos = url_ftell(pb);
302
            int64_t left;
303
            int err = parse(c, pb, a);
304
            if (err < 0)
305
                return err;
306
            if (c->found_moov && c->found_mdat &&
307
                (url_is_streamed(pb) || start_pos + a.size == url_fsize(pb)))
308
                return 0;
309
            left = a.size - url_ftell(pb) + start_pos;
310
            if (left > 0) /* skip garbage at atom end */
311
                url_fskip(pb, left);
312
        }
313

    
314
        total_size += a.size;
315
    }
316

    
317
    if (total_size < atom.size && atom.size < 0x7ffff)
318
        url_fskip(pb, atom.size - total_size);
319

    
320
    return 0;
321
}
322

    
323
static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
324
{
325
    AVStream *st;
326
    MOVStreamContext *sc;
327
    int entries, i, j;
328

    
329
    if (c->fc->nb_streams < 1)
330
        return 0;
331
    st = c->fc->streams[c->fc->nb_streams-1];
332
    sc = st->priv_data;
333

    
334
    get_be32(pb); // version + flags
335
    entries = get_be32(pb);
336
    if (entries >= UINT_MAX / sizeof(*sc->drefs))
337
        return -1;
338
    sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
339
    if (!sc->drefs)
340
        return AVERROR(ENOMEM);
341
    sc->drefs_count = entries;
342

    
343
    for (i = 0; i < sc->drefs_count; i++) {
344
        MOVDref *dref = &sc->drefs[i];
345
        uint32_t size = get_be32(pb);
346
        int64_t next = url_ftell(pb) + size - 4;
347

    
348
        if (size < 12)
349
            return -1;
350

    
351
        dref->type = get_le32(pb);
352
        get_be32(pb); // version + flags
353
        dprintf(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
354

    
355
        if (dref->type == MKTAG('a','l','i','s') && size > 150) {
356
            /* macintosh alias record */
357
            uint16_t volume_len, len;
358
            int16_t type;
359

    
360
            url_fskip(pb, 10);
361

    
362
            volume_len = get_byte(pb);
363
            volume_len = FFMIN(volume_len, 27);
364
            get_buffer(pb, dref->volume, 27);
365
            dref->volume[volume_len] = 0;
366
            av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
367

    
368
            url_fskip(pb, 12);
369

    
370
            len = get_byte(pb);
371
            len = FFMIN(len, 63);
372
            get_buffer(pb, dref->filename, 63);
373
            dref->filename[len] = 0;
374
            av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
375

    
376
            url_fskip(pb, 16);
377

    
378
            /* read next level up_from_alias/down_to_target */
379
            dref->nlvl_from = get_be16(pb);
380
            dref->nlvl_to   = get_be16(pb);
381
            av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
382
                   dref->nlvl_from, dref->nlvl_to);
383

    
384
            url_fskip(pb, 16);
385

    
386
            for (type = 0; type != -1 && url_ftell(pb) < next; ) {
387
                type = get_be16(pb);
388
                len = get_be16(pb);
389
                av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
390
                if (len&1)
391
                    len += 1;
392
                if (type == 2) { // absolute path
393
                    av_free(dref->path);
394
                    dref->path = av_mallocz(len+1);
395
                    if (!dref->path)
396
                        return AVERROR(ENOMEM);
397
                    get_buffer(pb, dref->path, len);
398
                    if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
399
                        len -= volume_len;
400
                        memmove(dref->path, dref->path+volume_len, len);
401
                        dref->path[len] = 0;
402
                    }
403
                    for (j = 0; j < len; j++)
404
                        if (dref->path[j] == ':')
405
                            dref->path[j] = '/';
406
                    av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
407
                } else if (type == 0) { // directory name
408
                    av_free(dref->dir);
409
                    dref->dir = av_malloc(len+1);
410
                    if (!dref->dir)
411
                        return AVERROR(ENOMEM);
412
                    get_buffer(pb, dref->dir, len);
413
                    dref->dir[len] = 0;
414
                    for (j = 0; j < len; j++)
415
                        if (dref->dir[j] == ':')
416
                            dref->dir[j] = '/';
417
                    av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
418
                } else
419
                    url_fskip(pb, len);
420
            }
421
        }
422
        url_fseek(pb, next, SEEK_SET);
423
    }
424
    return 0;
425
}
426

    
427
static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
428
{
429
    AVStream *st;
430
    uint32_t type;
431
    uint32_t ctype;
432

    
433
    if (c->fc->nb_streams < 1) // meta before first trak
434
        return 0;
435

    
436
    st = c->fc->streams[c->fc->nb_streams-1];
437

    
438
    get_byte(pb); /* version */
439
    get_be24(pb); /* flags */
440

    
441
    /* component type */
442
    ctype = get_le32(pb);
443
    type = get_le32(pb); /* component subtype */
444

    
445
    dprintf(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
446
    dprintf(c->fc, "stype= %.4s\n", (char*)&type);
447

    
448
    if     (type == MKTAG('v','i','d','e'))
449
        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
450
    else if(type == MKTAG('s','o','u','n'))
451
        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
452
    else if(type == MKTAG('m','1','a',' '))
453
        st->codec->codec_id = CODEC_ID_MP2;
454
    else if(type == MKTAG('s','u','b','p'))
455
        st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
456

    
457
    get_be32(pb); /* component  manufacture */
458
    get_be32(pb); /* component flags */
459
    get_be32(pb); /* component flags mask */
460

    
461
    return 0;
462
}
463

    
464
int ff_mp4_read_descr_len(ByteIOContext *pb)
465
{
466
    int len = 0;
467
    int count = 4;
468
    while (count--) {
469
        int c = get_byte(pb);
470
        len = (len << 7) | (c & 0x7f);
471
        if (!(c & 0x80))
472
            break;
473
    }
474
    return len;
475
}
476

    
477
static int mp4_read_descr(AVFormatContext *fc, ByteIOContext *pb, int *tag)
478
{
479
    int len;
480
    *tag = get_byte(pb);
481
    len = ff_mp4_read_descr_len(pb);
482
    dprintf(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
483
    return len;
484
}
485

    
486
#define MP4ESDescrTag                   0x03
487
#define MP4DecConfigDescrTag            0x04
488
#define MP4DecSpecificDescrTag          0x05
489

    
490
static const AVCodecTag mp4_audio_types[] = {
491
    { CODEC_ID_MP3ON4, AOT_PS   }, /* old mp3on4 draft */
492
    { CODEC_ID_MP3ON4, AOT_L1   }, /* layer 1 */
493
    { CODEC_ID_MP3ON4, AOT_L2   }, /* layer 2 */
494
    { CODEC_ID_MP3ON4, AOT_L3   }, /* layer 3 */
495
    { CODEC_ID_MP4ALS, AOT_ALS  }, /* MPEG-4 ALS */
496
    { CODEC_ID_NONE,   AOT_NULL },
497
};
498

    
499
int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom)
500
{
501
    AVStream *st;
502
    int tag, len;
503

    
504
    if (fc->nb_streams < 1)
505
        return 0;
506
    st = fc->streams[fc->nb_streams-1];
507

    
508
    get_be32(pb); /* version + flags */
509
    len = mp4_read_descr(fc, pb, &tag);
510
    if (tag == MP4ESDescrTag) {
511
        get_be16(pb); /* ID */
512
        get_byte(pb); /* priority */
513
    } else
514
        get_be16(pb); /* ID */
515

    
516
    len = mp4_read_descr(fc, pb, &tag);
517
    if (tag == MP4DecConfigDescrTag) {
518
        int object_type_id = get_byte(pb);
519
        get_byte(pb); /* stream type */
520
        get_be24(pb); /* buffer size db */
521
        get_be32(pb); /* max bitrate */
522
        get_be32(pb); /* avg bitrate */
523

    
524
        st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
525
        dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
526
        len = mp4_read_descr(fc, pb, &tag);
527
        if (tag == MP4DecSpecificDescrTag) {
528
            dprintf(fc, "Specific MPEG4 header len=%d\n", len);
529
            if((uint64_t)len > (1<<30))
530
                return -1;
531
            av_free(st->codec->extradata);
532
            st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
533
            if (!st->codec->extradata)
534
                return AVERROR(ENOMEM);
535
            get_buffer(pb, st->codec->extradata, len);
536
            st->codec->extradata_size = len;
537
            if (st->codec->codec_id == CODEC_ID_AAC) {
538
                MPEG4AudioConfig cfg;
539
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
540
                                         st->codec->extradata_size);
541
                st->codec->channels = cfg.channels;
542
                if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
543
                    st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
544
                else if (cfg.ext_sample_rate)
545
                    st->codec->sample_rate = cfg.ext_sample_rate;
546
                else
547
                    st->codec->sample_rate = cfg.sample_rate;
548
                dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
549
                        "sample rate %d ext sample rate %d\n", st->codec->channels,
550
                        cfg.object_type, cfg.ext_object_type,
551
                        cfg.sample_rate, cfg.ext_sample_rate);
552
                if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
553
                                                            cfg.object_type)))
554
                    st->codec->codec_id = CODEC_ID_AAC;
555
            }
556
        }
557
    }
558
    return 0;
559
}
560

    
561
static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
562
{
563
    return ff_mov_read_esds(c->fc, pb, atom);
564
}
565

    
566
static int mov_read_dac3(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
567
{
568
    AVStream *st;
569
    int ac3info, acmod, lfeon;
570

    
571
    if (c->fc->nb_streams < 1)
572
        return 0;
573
    st = c->fc->streams[c->fc->nb_streams-1];
574

    
575
    ac3info = get_be24(pb);
576
    acmod = (ac3info >> 11) & 0x7;
577
    lfeon = (ac3info >> 10) & 0x1;
578
    st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
579

    
580
    return 0;
581
}
582

    
583
static int mov_read_pasp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
584
{
585
    const int num = get_be32(pb);
586
    const int den = get_be32(pb);
587
    AVStream *st;
588

    
589
    if (c->fc->nb_streams < 1)
590
        return 0;
591
    st = c->fc->streams[c->fc->nb_streams-1];
592

    
593
    if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
594
        (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
595
        av_log(c->fc, AV_LOG_WARNING,
596
               "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
597
               st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
598
               num, den);
599
    } else if (den != 0) {
600
        st->sample_aspect_ratio.num = num;
601
        st->sample_aspect_ratio.den = den;
602
    }
603
    return 0;
604
}
605

    
606
/* this atom contains actual media data */
607
static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
608
{
609
    if(atom.size == 0) /* wrong one (MP4) */
610
        return 0;
611
    c->found_mdat=1;
612
    return 0; /* now go for moov */
613
}
614

    
615
/* read major brand, minor version and compatible brands and store them as metadata */
616
static int mov_read_ftyp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
617
{
618
    uint32_t minor_ver;
619
    int comp_brand_size;
620
    char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */
621
    char* comp_brands_str;
622
    uint8_t type[5] = {0};
623

    
624
    get_buffer(pb, type, 4);
625
    if (strcmp(type, "qt  "))
626
        c->isom = 1;
627
    av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
628
    av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);
629
    minor_ver = get_be32(pb); /* minor version */
630
    snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
631
    av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);
632

    
633
    comp_brand_size = atom.size - 8;
634
    if (comp_brand_size < 0)
635
        return -1;
636
    comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
637
    if (!comp_brands_str)
638
        return AVERROR(ENOMEM);
639
    get_buffer(pb, comp_brands_str, comp_brand_size);
640
    comp_brands_str[comp_brand_size] = 0;
641
    av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
642
    av_freep(&comp_brands_str);
643

    
644
    return 0;
645
}
646

    
647
/* this atom should contain all header atoms */
648
static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
649
{
650
    if (mov_read_default(c, pb, atom) < 0)
651
        return -1;
652
    /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
653
    /* so we don't parse the whole file if over a network */
654
    c->found_moov=1;
655
    return 0; /* now go for mdat */
656
}
657

    
658
static int mov_read_moof(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
659
{
660
    c->fragment.moof_offset = url_ftell(pb) - 8;
661
    dprintf(c->fc, "moof offset %llx\n", c->fragment.moof_offset);
662
    return mov_read_default(c, pb, atom);
663
}
664

    
665
static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
666
{
667
    AVStream *st;
668
    MOVStreamContext *sc;
669
    int version;
670
    char language[4] = {0};
671
    unsigned lang;
672

    
673
    if (c->fc->nb_streams < 1)
674
        return 0;
675
    st = c->fc->streams[c->fc->nb_streams-1];
676
    sc = st->priv_data;
677

    
678
    version = get_byte(pb);
679
    if (version > 1)
680
        return -1; /* unsupported */
681

    
682
    get_be24(pb); /* flags */
683
    if (version == 1) {
684
        get_be64(pb);
685
        get_be64(pb);
686
    } else {
687
        get_be32(pb); /* creation time */
688
        get_be32(pb); /* modification time */
689
    }
690

    
691
    sc->time_scale = get_be32(pb);
692
    st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
693

    
694
    lang = get_be16(pb); /* language */
695
    if (ff_mov_lang_to_iso639(lang, language))
696
        av_metadata_set2(&st->metadata, "language", language, 0);
697
    get_be16(pb); /* quality */
698

    
699
    return 0;
700
}
701

    
702
static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
703
{
704
    int version = get_byte(pb); /* version */
705
    get_be24(pb); /* flags */
706

    
707
    if (version == 1) {
708
        get_be64(pb);
709
        get_be64(pb);
710
    } else {
711
        get_be32(pb); /* creation time */
712
        get_be32(pb); /* modification time */
713
    }
714
    c->time_scale = get_be32(pb); /* time scale */
715

    
716
    dprintf(c->fc, "time scale = %i\n", c->time_scale);
717

    
718
    c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
719
    get_be32(pb); /* preferred scale */
720

    
721
    get_be16(pb); /* preferred volume */
722

    
723
    url_fskip(pb, 10); /* reserved */
724

    
725
    url_fskip(pb, 36); /* display matrix */
726

    
727
    get_be32(pb); /* preview time */
728
    get_be32(pb); /* preview duration */
729
    get_be32(pb); /* poster time */
730
    get_be32(pb); /* selection time */
731
    get_be32(pb); /* selection duration */
732
    get_be32(pb); /* current time */
733
    get_be32(pb); /* next track ID */
734

    
735
    return 0;
736
}
737

    
738
static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
739
{
740
    AVStream *st;
741

    
742
    if (c->fc->nb_streams < 1)
743
        return 0;
744
    st = c->fc->streams[c->fc->nb_streams-1];
745

    
746
    if((uint64_t)atom.size > (1<<30))
747
        return -1;
748

    
749
    // currently SVQ3 decoder expect full STSD header - so let's fake it
750
    // this should be fixed and just SMI header should be passed
751
    av_free(st->codec->extradata);
752
    st->codec->extradata = av_mallocz(atom.size + 0x5a + FF_INPUT_BUFFER_PADDING_SIZE);
753
    if (!st->codec->extradata)
754
        return AVERROR(ENOMEM);
755
    st->codec->extradata_size = 0x5a + atom.size;
756
    memcpy(st->codec->extradata, "SVQ3", 4); // fake
757
    get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
758
    dprintf(c->fc, "Reading SMI %"PRId64"  %s\n", atom.size, st->codec->extradata + 0x5a);
759
    return 0;
760
}
761

    
762
static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
763
{
764
    AVStream *st;
765
    int little_endian;
766

    
767
    if (c->fc->nb_streams < 1)
768
        return 0;
769
    st = c->fc->streams[c->fc->nb_streams-1];
770

    
771
    little_endian = get_be16(pb);
772
    dprintf(c->fc, "enda %d\n", little_endian);
773
    if (little_endian == 1) {
774
        switch (st->codec->codec_id) {
775
        case CODEC_ID_PCM_S24BE:
776
            st->codec->codec_id = CODEC_ID_PCM_S24LE;
777
            break;
778
        case CODEC_ID_PCM_S32BE:
779
            st->codec->codec_id = CODEC_ID_PCM_S32LE;
780
            break;
781
        case CODEC_ID_PCM_F32BE:
782
            st->codec->codec_id = CODEC_ID_PCM_F32LE;
783
            break;
784
        case CODEC_ID_PCM_F64BE:
785
            st->codec->codec_id = CODEC_ID_PCM_F64LE;
786
            break;
787
        default:
788
            break;
789
        }
790
    }
791
    return 0;
792
}
793

    
794
/* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */
795
static int mov_read_extradata(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
796
{
797
    AVStream *st;
798
    uint64_t size;
799
    uint8_t *buf;
800

    
801
    if (c->fc->nb_streams < 1) // will happen with jp2 files
802
        return 0;
803
    st= c->fc->streams[c->fc->nb_streams-1];
804
    size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
805
    if(size > INT_MAX || (uint64_t)atom.size > INT_MAX)
806
        return -1;
807
    buf= av_realloc(st->codec->extradata, size);
808
    if(!buf)
809
        return -1;
810
    st->codec->extradata= buf;
811
    buf+= st->codec->extradata_size;
812
    st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
813
    AV_WB32(       buf    , atom.size + 8);
814
    AV_WL32(       buf + 4, atom.type);
815
    get_buffer(pb, buf + 8, atom.size);
816
    return 0;
817
}
818

    
819
static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
820
{
821
    AVStream *st;
822

    
823
    if (c->fc->nb_streams < 1)
824
        return 0;
825
    st = c->fc->streams[c->fc->nb_streams-1];
826

    
827
    if((uint64_t)atom.size > (1<<30))
828
        return -1;
829

    
830
    if (st->codec->codec_id == CODEC_ID_QDM2) {
831
        // pass all frma atom to codec, needed at least for QDM2
832
        av_free(st->codec->extradata);
833
        st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
834
        if (!st->codec->extradata)
835
            return AVERROR(ENOMEM);
836
        st->codec->extradata_size = atom.size;
837
        get_buffer(pb, st->codec->extradata, atom.size);
838
    } else if (atom.size > 8) { /* to read frma, esds atoms */
839
        if (mov_read_default(c, pb, atom) < 0)
840
            return -1;
841
    } else
842
        url_fskip(pb, atom.size);
843
    return 0;
844
}
845

    
846
/**
847
 * This function reads atom content and puts data in extradata without tag
848
 * nor size unlike mov_read_extradata.
849
 */
850
static int mov_read_glbl(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
851
{
852
    AVStream *st;
853

    
854
    if (c->fc->nb_streams < 1)
855
        return 0;
856
    st = c->fc->streams[c->fc->nb_streams-1];
857

    
858
    if((uint64_t)atom.size > (1<<30))
859
        return -1;
860

    
861
    av_free(st->codec->extradata);
862
    st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
863
    if (!st->codec->extradata)
864
        return AVERROR(ENOMEM);
865
    st->codec->extradata_size = atom.size;
866
    get_buffer(pb, st->codec->extradata, atom.size);
867
    return 0;
868
}
869

    
870
/**
871
 * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
872
 * but can have extradata appended at the end after the 40 bytes belonging
873
 * to the struct.
874
 */
875
static int mov_read_strf(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
876
{
877
    AVStream *st;
878

    
879
    if (c->fc->nb_streams < 1)
880
        return 0;
881
    if (atom.size <= 40)
882
        return 0;
883
    st = c->fc->streams[c->fc->nb_streams-1];
884

    
885
    if((uint64_t)atom.size > (1<<30))
886
        return -1;
887

    
888
    av_free(st->codec->extradata);
889
    st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);
890
    if (!st->codec->extradata)
891
        return AVERROR(ENOMEM);
892
    st->codec->extradata_size = atom.size - 40;
893
    url_fskip(pb, 40);
894
    get_buffer(pb, st->codec->extradata, atom.size - 40);
895
    return 0;
896
}
897

    
898
static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
899
{
900
    AVStream *st;
901
    MOVStreamContext *sc;
902
    unsigned int i, entries;
903

    
904
    if (c->fc->nb_streams < 1)
905
        return 0;
906
    st = c->fc->streams[c->fc->nb_streams-1];
907
    sc = st->priv_data;
908

    
909
    get_byte(pb); /* version */
910
    get_be24(pb); /* flags */
911

    
912
    entries = get_be32(pb);
913

    
914
    if(entries >= UINT_MAX/sizeof(int64_t))
915
        return -1;
916

    
917
    sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
918
    if (!sc->chunk_offsets)
919
        return AVERROR(ENOMEM);
920
    sc->chunk_count = entries;
921

    
922
    if      (atom.type == MKTAG('s','t','c','o'))
923
        for(i=0; i<entries; i++)
924
            sc->chunk_offsets[i] = get_be32(pb);
925
    else if (atom.type == MKTAG('c','o','6','4'))
926
        for(i=0; i<entries; i++)
927
            sc->chunk_offsets[i] = get_be64(pb);
928
    else
929
        return -1;
930

    
931
    return 0;
932
}
933

    
934
/**
935
 * Compute codec id for 'lpcm' tag.
936
 * See CoreAudioTypes and AudioStreamBasicDescription at Apple.
937
 */
938
enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
939
{
940
    if (flags & 1) { // floating point
941
        if (flags & 2) { // big endian
942
            if      (bps == 32) return CODEC_ID_PCM_F32BE;
943
            else if (bps == 64) return CODEC_ID_PCM_F64BE;
944
        } else {
945
            if      (bps == 32) return CODEC_ID_PCM_F32LE;
946
            else if (bps == 64) return CODEC_ID_PCM_F64LE;
947
        }
948
    } else {
949
        if (flags & 2) {
950
            if      (bps == 8)
951
                // signed integer
952
                if (flags & 4)  return CODEC_ID_PCM_S8;
953
                else            return CODEC_ID_PCM_U8;
954
            else if (bps == 16) return CODEC_ID_PCM_S16BE;
955
            else if (bps == 24) return CODEC_ID_PCM_S24BE;
956
            else if (bps == 32) return CODEC_ID_PCM_S32BE;
957
        } else {
958
            if      (bps == 8)
959
                if (flags & 4)  return CODEC_ID_PCM_S8;
960
                else            return CODEC_ID_PCM_U8;
961
            else if (bps == 16) return CODEC_ID_PCM_S16LE;
962
            else if (bps == 24) return CODEC_ID_PCM_S24LE;
963
            else if (bps == 32) return CODEC_ID_PCM_S32LE;
964
        }
965
    }
966
    return CODEC_ID_NONE;
967
}
968

    
969
int ff_mov_read_stsd_entries(MOVContext *c, ByteIOContext *pb, int entries)
970
{
971
    AVStream *st;
972
    MOVStreamContext *sc;
973
    int j, pseudo_stream_id;
974

    
975
    if (c->fc->nb_streams < 1)
976
        return 0;
977
    st = c->fc->streams[c->fc->nb_streams-1];
978
    sc = st->priv_data;
979

    
980
    for(pseudo_stream_id=0; pseudo_stream_id<entries; pseudo_stream_id++) {
981
        //Parsing Sample description table
982
        enum CodecID id;
983
        int dref_id = 1;
984
        MOVAtom a = { AV_RL32("stsd") };
985
        int64_t start_pos = url_ftell(pb);
986
        int size = get_be32(pb); /* size */
987
        uint32_t format = get_le32(pb); /* data format */
988

    
989
        if (size >= 16) {
990
            get_be32(pb); /* reserved */
991
            get_be16(pb); /* reserved */
992
            dref_id = get_be16(pb);
993
        }
994

    
995
        if (st->codec->codec_tag &&
996
            st->codec->codec_tag != format &&
997
            (c->fc->video_codec_id ? ff_codec_get_id(codec_movvideo_tags, format) != c->fc->video_codec_id
998
                                   : st->codec->codec_tag != MKTAG('j','p','e','g'))
999
           ){
1000
            /* Multiple fourcc, we skip JPEG. This is not correct, we should
1001
             * export it as a separate AVStream but this needs a few changes
1002
             * in the MOV demuxer, patch welcome. */
1003
            av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
1004
            url_fskip(pb, size - (url_ftell(pb) - start_pos));
1005
            continue;
1006
        }
1007
        sc->pseudo_stream_id = st->codec->codec_tag ? -1 : pseudo_stream_id;
1008
        sc->dref_id= dref_id;
1009

    
1010
        st->codec->codec_tag = format;
1011
        id = ff_codec_get_id(codec_movaudio_tags, format);
1012
        if (id<=0 && ((format&0xFFFF) == 'm'+('s'<<8) || (format&0xFFFF) == 'T'+('S'<<8)))
1013
            id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format)&0xFFFF);
1014

    
1015
        if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
1016
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
1017
        } else if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO && /* do not overwrite codec type */
1018
                   format && format != MKTAG('m','p','4','s')) { /* skip old asf mpeg4 tag */
1019
            id = ff_codec_get_id(codec_movvideo_tags, format);
1020
            if (id <= 0)
1021
                id = ff_codec_get_id(ff_codec_bmp_tags, format);
1022
            if (id > 0)
1023
                st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
1024
            else if(st->codec->codec_type == AVMEDIA_TYPE_DATA){
1025
                id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
1026
                if(id > 0)
1027
                    st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
1028
            }
1029
        }
1030

    
1031
        dprintf(c->fc, "size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
1032
                (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
1033
                (format >> 24) & 0xff, st->codec->codec_type);
1034

    
1035
        if(st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
1036
            unsigned int color_depth, len;
1037
            int color_greyscale;
1038

    
1039
            st->codec->codec_id = id;
1040
            get_be16(pb); /* version */
1041
            get_be16(pb); /* revision level */
1042
            get_be32(pb); /* vendor */
1043
            get_be32(pb); /* temporal quality */
1044
            get_be32(pb); /* spatial quality */
1045

    
1046
            st->codec->width = get_be16(pb); /* width */
1047
            st->codec->height = get_be16(pb); /* height */
1048

    
1049
            get_be32(pb); /* horiz resolution */
1050
            get_be32(pb); /* vert resolution */
1051
            get_be32(pb); /* data size, always 0 */
1052
            get_be16(pb); /* frames per samples */
1053

    
1054
            len = get_byte(pb); /* codec name, pascal string */
1055
            if (len > 31)
1056
                len = 31;
1057
            mov_read_mac_string(c, pb, len, st->codec->codec_name, 32);
1058
            if (len < 31)
1059
                url_fskip(pb, 31 - len);
1060
            /* codec_tag YV12 triggers an UV swap in rawdec.c */
1061
            if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
1062
                st->codec->codec_tag=MKTAG('I', '4', '2', '0');
1063

    
1064
            st->codec->bits_per_coded_sample = get_be16(pb); /* depth */
1065
            st->codec->color_table_id = get_be16(pb); /* colortable id */
1066
            dprintf(c->fc, "depth %d, ctab id %d\n",
1067
                   st->codec->bits_per_coded_sample, st->codec->color_table_id);
1068
            /* figure out the palette situation */
1069
            color_depth = st->codec->bits_per_coded_sample & 0x1F;
1070
            color_greyscale = st->codec->bits_per_coded_sample & 0x20;
1071

    
1072
            /* if the depth is 2, 4, or 8 bpp, file is palettized */
1073
            if ((color_depth == 2) || (color_depth == 4) ||
1074
                (color_depth == 8)) {
1075
                /* for palette traversal */
1076
                unsigned int color_start, color_count, color_end;
1077
                unsigned char r, g, b;
1078

    
1079
                st->codec->palctrl = av_malloc(sizeof(*st->codec->palctrl));
1080
                if (color_greyscale) {
1081
                    int color_index, color_dec;
1082
                    /* compute the greyscale palette */
1083
                    st->codec->bits_per_coded_sample = color_depth;
1084
                    color_count = 1 << color_depth;
1085
                    color_index = 255;
1086
                    color_dec = 256 / (color_count - 1);
1087
                    for (j = 0; j < color_count; j++) {
1088
                        r = g = b = color_index;
1089
                        st->codec->palctrl->palette[j] =
1090
                            (r << 16) | (g << 8) | (b);
1091
                        color_index -= color_dec;
1092
                        if (color_index < 0)
1093
                            color_index = 0;
1094
                    }
1095
                } else if (st->codec->color_table_id) {
1096
                    const uint8_t *color_table;
1097
                    /* if flag bit 3 is set, use the default palette */
1098
                    color_count = 1 << color_depth;
1099
                    if (color_depth == 2)
1100
                        color_table = ff_qt_default_palette_4;
1101
                    else if (color_depth == 4)
1102
                        color_table = ff_qt_default_palette_16;
1103
                    else
1104
                        color_table = ff_qt_default_palette_256;
1105

    
1106
                    for (j = 0; j < color_count; j++) {
1107
                        r = color_table[j * 3 + 0];
1108
                        g = color_table[j * 3 + 1];
1109
                        b = color_table[j * 3 + 2];
1110
                        st->codec->palctrl->palette[j] =
1111
                            (r << 16) | (g << 8) | (b);
1112
                    }
1113
                } else {
1114
                    /* load the palette from the file */
1115
                    color_start = get_be32(pb);
1116
                    color_count = get_be16(pb);
1117
                    color_end = get_be16(pb);
1118
                    if ((color_start <= 255) &&
1119
                        (color_end <= 255)) {
1120
                        for (j = color_start; j <= color_end; j++) {
1121
                            /* each R, G, or B component is 16 bits;
1122
                             * only use the top 8 bits; skip alpha bytes
1123
                             * up front */
1124
                            get_byte(pb);
1125
                            get_byte(pb);
1126
                            r = get_byte(pb);
1127
                            get_byte(pb);
1128
                            g = get_byte(pb);
1129
                            get_byte(pb);
1130
                            b = get_byte(pb);
1131
                            get_byte(pb);
1132
                            st->codec->palctrl->palette[j] =
1133
                                (r << 16) | (g << 8) | (b);
1134
                        }
1135
                    }
1136
                }
1137
                st->codec->palctrl->palette_changed = 1;
1138
            }
1139
        } else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
1140
            int bits_per_sample, flags;
1141
            uint16_t version = get_be16(pb);
1142

    
1143
            st->codec->codec_id = id;
1144
            get_be16(pb); /* revision level */
1145
            get_be32(pb); /* vendor */
1146

    
1147
            st->codec->channels = get_be16(pb);             /* channel count */
1148
            dprintf(c->fc, "audio channels %d\n", st->codec->channels);
1149
            st->codec->bits_per_coded_sample = get_be16(pb);      /* sample size */
1150

    
1151
            sc->audio_cid = get_be16(pb);
1152
            get_be16(pb); /* packet size = 0 */
1153

    
1154
            st->codec->sample_rate = ((get_be32(pb) >> 16));
1155

    
1156
            //Read QT version 1 fields. In version 0 these do not exist.
1157
            dprintf(c->fc, "version =%d, isom =%d\n",version,c->isom);
1158
            if(!c->isom) {
1159
                if(version==1) {
1160
                    sc->samples_per_frame = get_be32(pb);
1161
                    get_be32(pb); /* bytes per packet */
1162
                    sc->bytes_per_frame = get_be32(pb);
1163
                    get_be32(pb); /* bytes per sample */
1164
                } else if(version==2) {
1165
                    get_be32(pb); /* sizeof struct only */
1166
                    st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */
1167
                    st->codec->channels = get_be32(pb);
1168
                    get_be32(pb); /* always 0x7F000000 */
1169
                    st->codec->bits_per_coded_sample = get_be32(pb); /* bits per channel if sound is uncompressed */
1170
                    flags = get_be32(pb); /* lpcm format specific flag */
1171
                    sc->bytes_per_frame = get_be32(pb); /* bytes per audio packet if constant */
1172
                    sc->samples_per_frame = get_be32(pb); /* lpcm frames per audio packet if constant */
1173
                    if (format == MKTAG('l','p','c','m'))
1174
                        st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);
1175
                }
1176
            }
1177

    
1178
            switch (st->codec->codec_id) {
1179
            case CODEC_ID_PCM_S8:
1180
            case CODEC_ID_PCM_U8:
1181
                if (st->codec->bits_per_coded_sample == 16)
1182
                    st->codec->codec_id = CODEC_ID_PCM_S16BE;
1183
                break;
1184
            case CODEC_ID_PCM_S16LE:
1185
            case CODEC_ID_PCM_S16BE:
1186
                if (st->codec->bits_per_coded_sample == 8)
1187
                    st->codec->codec_id = CODEC_ID_PCM_S8;
1188
                else if (st->codec->bits_per_coded_sample == 24)
1189
                    st->codec->codec_id =
1190
                        st->codec->codec_id == CODEC_ID_PCM_S16BE ?
1191
                        CODEC_ID_PCM_S24BE : CODEC_ID_PCM_S24LE;
1192
                break;
1193
            /* set values for old format before stsd version 1 appeared */
1194
            case CODEC_ID_MACE3:
1195
                sc->samples_per_frame = 6;
1196
                sc->bytes_per_frame = 2*st->codec->channels;
1197
                break;
1198
            case CODEC_ID_MACE6:
1199
                sc->samples_per_frame = 6;
1200
                sc->bytes_per_frame = 1*st->codec->channels;
1201
                break;
1202
            case CODEC_ID_ADPCM_IMA_QT:
1203
                sc->samples_per_frame = 64;
1204
                sc->bytes_per_frame = 34*st->codec->channels;
1205
                break;
1206
            case CODEC_ID_GSM:
1207
                sc->samples_per_frame = 160;
1208
                sc->bytes_per_frame = 33;
1209
                break;
1210
            default:
1211
                break;
1212
            }
1213

    
1214
            bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
1215
            if (bits_per_sample) {
1216
                st->codec->bits_per_coded_sample = bits_per_sample;
1217
                sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
1218
            }
1219
        } else if(st->codec->codec_type==AVMEDIA_TYPE_SUBTITLE){
1220
            // ttxt stsd contains display flags, justification, background
1221
            // color, fonts, and default styles, so fake an atom to read it
1222
            MOVAtom fake_atom = { .size = size - (url_ftell(pb) - start_pos) };
1223
            if (format != AV_RL32("mp4s")) // mp4s contains a regular esds atom
1224
                mov_read_glbl(c, pb, fake_atom);
1225
            st->codec->codec_id= id;
1226
            st->codec->width = sc->width;
1227
            st->codec->height = sc->height;
1228
        } else {
1229
            /* other codec type, just skip (rtp, mp4s, tmcd ...) */
1230
            url_fskip(pb, size - (url_ftell(pb) - start_pos));
1231
        }
1232
        /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
1233
        a.size = size - (url_ftell(pb) - start_pos);
1234
        if (a.size > 8) {
1235
            if (mov_read_default(c, pb, a) < 0)
1236
                return -1;
1237
        } else if (a.size > 0)
1238
            url_fskip(pb, a.size);
1239
    }
1240

    
1241
    if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1)
1242
        st->codec->sample_rate= sc->time_scale;
1243

    
1244
    /* special codec parameters handling */
1245
    switch (st->codec->codec_id) {
1246
#if CONFIG_DV_DEMUXER
1247
    case CODEC_ID_DVAUDIO:
1248
        c->dv_fctx = avformat_alloc_context();
1249
        c->dv_demux = dv_init_demux(c->dv_fctx);
1250
        if (!c->dv_demux) {
1251
            av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
1252
            return -1;
1253
        }
1254
        sc->dv_audio_container = 1;
1255
        st->codec->codec_id = CODEC_ID_PCM_S16LE;
1256
        break;
1257
#endif
1258
    /* no ifdef since parameters are always those */
1259
    case CODEC_ID_QCELP:
1260
        // force sample rate for qcelp when not stored in mov
1261
        if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
1262
            st->codec->sample_rate = 8000;
1263
        st->codec->frame_size= 160;
1264
        st->codec->channels= 1; /* really needed */
1265
        break;
1266
    case CODEC_ID_AMR_NB:
1267
    case CODEC_ID_AMR_WB:
1268
        st->codec->frame_size= sc->samples_per_frame;
1269
        st->codec->channels= 1; /* really needed */
1270
        /* force sample rate for amr, stsd in 3gp does not store sample rate */
1271
        if (st->codec->codec_id == CODEC_ID_AMR_NB)
1272
            st->codec->sample_rate = 8000;
1273
        else if (st->codec->codec_id == CODEC_ID_AMR_WB)
1274
            st->codec->sample_rate = 16000;
1275
        break;
1276
    case CODEC_ID_MP2:
1277
    case CODEC_ID_MP3:
1278
        st->codec->codec_type = AVMEDIA_TYPE_AUDIO; /* force type after stsd for m1a hdlr */
1279
        st->need_parsing = AVSTREAM_PARSE_FULL;
1280
        break;
1281
    case CODEC_ID_GSM:
1282
    case CODEC_ID_ADPCM_MS:
1283
    case CODEC_ID_ADPCM_IMA_WAV:
1284
        st->codec->block_align = sc->bytes_per_frame;
1285
        break;
1286
    case CODEC_ID_ALAC:
1287
        if (st->codec->extradata_size == 36) {
1288
            st->codec->frame_size = AV_RB32(st->codec->extradata+12);
1289
            st->codec->channels   = AV_RB8 (st->codec->extradata+21);
1290
        }
1291
        break;
1292
    default:
1293
        break;
1294
    }
1295

    
1296
    return 0;
1297
}
1298

    
1299
static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1300
{
1301
    int entries;
1302

    
1303
    get_byte(pb); /* version */
1304
    get_be24(pb); /* flags */
1305
    entries = get_be32(pb);
1306

    
1307
    return ff_mov_read_stsd_entries(c, pb, entries);
1308
}
1309

    
1310
static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1311
{
1312
    AVStream *st;
1313
    MOVStreamContext *sc;
1314
    unsigned int i, entries;
1315

    
1316
    if (c->fc->nb_streams < 1)
1317
        return 0;
1318
    st = c->fc->streams[c->fc->nb_streams-1];
1319
    sc = st->priv_data;
1320

    
1321
    get_byte(pb); /* version */
1322
    get_be24(pb); /* flags */
1323

    
1324
    entries = get_be32(pb);
1325

    
1326
    dprintf(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1327

    
1328
    if(entries >= UINT_MAX / sizeof(*sc->stsc_data))
1329
        return -1;
1330
    sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
1331
    if (!sc->stsc_data)
1332
        return AVERROR(ENOMEM);
1333
    sc->stsc_count = entries;
1334

    
1335
    for(i=0; i<entries; i++) {
1336
        sc->stsc_data[i].first = get_be32(pb);
1337
        sc->stsc_data[i].count = get_be32(pb);
1338
        sc->stsc_data[i].id = get_be32(pb);
1339
    }
1340
    return 0;
1341
}
1342

    
1343
static int mov_read_stps(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1344
{
1345
    AVStream *st;
1346
    MOVStreamContext *sc;
1347
    unsigned i, entries;
1348

    
1349
    if (c->fc->nb_streams < 1)
1350
        return 0;
1351
    st = c->fc->streams[c->fc->nb_streams-1];
1352
    sc = st->priv_data;
1353

    
1354
    get_be32(pb); // version + flags
1355

    
1356
    entries = get_be32(pb);
1357
    if (entries >= UINT_MAX / sizeof(*sc->stps_data))
1358
        return -1;
1359
    sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
1360
    if (!sc->stps_data)
1361
        return AVERROR(ENOMEM);
1362
    sc->stps_count = entries;
1363

    
1364
    for (i = 0; i < entries; i++) {
1365
        sc->stps_data[i] = get_be32(pb);
1366
        //dprintf(c->fc, "stps %d\n", sc->stps_data[i]);
1367
    }
1368

    
1369
    return 0;
1370
}
1371

    
1372
static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1373
{
1374
    AVStream *st;
1375
    MOVStreamContext *sc;
1376
    unsigned int i, entries;
1377

    
1378
    if (c->fc->nb_streams < 1)
1379
        return 0;
1380
    st = c->fc->streams[c->fc->nb_streams-1];
1381
    sc = st->priv_data;
1382

    
1383
    get_byte(pb); /* version */
1384
    get_be24(pb); /* flags */
1385

    
1386
    entries = get_be32(pb);
1387

    
1388
    dprintf(c->fc, "keyframe_count = %d\n", entries);
1389

    
1390
    if(entries >= UINT_MAX / sizeof(int))
1391
        return -1;
1392
    sc->keyframes = av_malloc(entries * sizeof(int));
1393
    if (!sc->keyframes)
1394
        return AVERROR(ENOMEM);
1395
    sc->keyframe_count = entries;
1396

    
1397
    for(i=0; i<entries; i++) {
1398
        sc->keyframes[i] = get_be32(pb);
1399
        //dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
1400
    }
1401
    return 0;
1402
}
1403

    
1404
static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1405
{
1406
    AVStream *st;
1407
    MOVStreamContext *sc;
1408
    unsigned int i, entries, sample_size, field_size, num_bytes;
1409
    GetBitContext gb;
1410
    unsigned char* buf;
1411

    
1412
    if (c->fc->nb_streams < 1)
1413
        return 0;
1414
    st = c->fc->streams[c->fc->nb_streams-1];
1415
    sc = st->priv_data;
1416

    
1417
    get_byte(pb); /* version */
1418
    get_be24(pb); /* flags */
1419

    
1420
    if (atom.type == MKTAG('s','t','s','z')) {
1421
        sample_size = get_be32(pb);
1422
        if (!sc->sample_size) /* do not overwrite value computed in stsd */
1423
            sc->sample_size = sample_size;
1424
        field_size = 32;
1425
    } else {
1426
        sample_size = 0;
1427
        get_be24(pb); /* reserved */
1428
        field_size = get_byte(pb);
1429
    }
1430
    entries = get_be32(pb);
1431

    
1432
    dprintf(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
1433

    
1434
    sc->sample_count = entries;
1435
    if (sample_size)
1436
        return 0;
1437

    
1438
    if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
1439
        av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
1440
        return -1;
1441
    }
1442

    
1443
    if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
1444
        return -1;
1445
    sc->sample_sizes = av_malloc(entries * sizeof(int));
1446
    if (!sc->sample_sizes)
1447
        return AVERROR(ENOMEM);
1448

    
1449
    num_bytes = (entries*field_size+4)>>3;
1450

    
1451
    buf = av_malloc(num_bytes+FF_INPUT_BUFFER_PADDING_SIZE);
1452
    if (!buf) {
1453
        av_freep(&sc->sample_sizes);
1454
        return AVERROR(ENOMEM);
1455
    }
1456

    
1457
    if (get_buffer(pb, buf, num_bytes) < num_bytes) {
1458
        av_freep(&sc->sample_sizes);
1459
        av_free(buf);
1460
        return -1;
1461
    }
1462

    
1463
    init_get_bits(&gb, buf, 8*num_bytes);
1464

    
1465
    for(i=0; i<entries; i++)
1466
        sc->sample_sizes[i] = get_bits_long(&gb, field_size);
1467

    
1468
    av_free(buf);
1469
    return 0;
1470
}
1471

    
1472
static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1473
{
1474
    AVStream *st;
1475
    MOVStreamContext *sc;
1476
    unsigned int i, entries;
1477
    int64_t duration=0;
1478
    int64_t total_sample_count=0;
1479

    
1480
    if (c->fc->nb_streams < 1)
1481
        return 0;
1482
    st = c->fc->streams[c->fc->nb_streams-1];
1483
    sc = st->priv_data;
1484

    
1485
    get_byte(pb); /* version */
1486
    get_be24(pb); /* flags */
1487
    entries = get_be32(pb);
1488

    
1489
    dprintf(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
1490

    
1491
    if(entries >= UINT_MAX / sizeof(*sc->stts_data))
1492
        return -1;
1493
    sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
1494
    if (!sc->stts_data)
1495
        return AVERROR(ENOMEM);
1496
    sc->stts_count = entries;
1497

    
1498
    for(i=0; i<entries; i++) {
1499
        int sample_duration;
1500
        int sample_count;
1501

    
1502
        sample_count=get_be32(pb);
1503
        sample_duration = get_be32(pb);
1504
        sc->stts_data[i].count= sample_count;
1505
        sc->stts_data[i].duration= sample_duration;
1506

    
1507
        dprintf(c->fc, "sample_count=%d, sample_duration=%d\n",sample_count,sample_duration);
1508

    
1509
        duration+=(int64_t)sample_duration*sample_count;
1510
        total_sample_count+=sample_count;
1511
    }
1512

    
1513
    st->nb_frames= total_sample_count;
1514
    if(duration)
1515
        st->duration= duration;
1516
    return 0;
1517
}
1518

    
1519
static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1520
{
1521
    AVStream *st;
1522
    MOVStreamContext *sc;
1523
    unsigned int i, entries;
1524

    
1525
    if (c->fc->nb_streams < 1)
1526
        return 0;
1527
    st = c->fc->streams[c->fc->nb_streams-1];
1528
    sc = st->priv_data;
1529

    
1530
    get_byte(pb); /* version */
1531
    get_be24(pb); /* flags */
1532
    entries = get_be32(pb);
1533

    
1534
    dprintf(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
1535

    
1536
    if(entries >= UINT_MAX / sizeof(*sc->ctts_data))
1537
        return -1;
1538
    sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
1539
    if (!sc->ctts_data)
1540
        return AVERROR(ENOMEM);
1541
    sc->ctts_count = entries;
1542

    
1543
    for(i=0; i<entries; i++) {
1544
        int count    =get_be32(pb);
1545
        int duration =get_be32(pb);
1546

    
1547
        sc->ctts_data[i].count   = count;
1548
        sc->ctts_data[i].duration= duration;
1549
        if (duration < 0)
1550
            sc->dts_shift = FFMAX(sc->dts_shift, -duration);
1551
    }
1552

    
1553
    dprintf(c->fc, "dts shift %d\n", sc->dts_shift);
1554

    
1555
    return 0;
1556
}
1557

    
1558
static void mov_build_index(MOVContext *mov, AVStream *st)
1559
{
1560
    MOVStreamContext *sc = st->priv_data;
1561
    int64_t current_offset;
1562
    int64_t current_dts = 0;
1563
    unsigned int stts_index = 0;
1564
    unsigned int stsc_index = 0;
1565
    unsigned int stss_index = 0;
1566
    unsigned int stps_index = 0;
1567
    unsigned int i, j;
1568
    uint64_t stream_size = 0;
1569

    
1570
    /* adjust first dts according to edit list */
1571
    if (sc->time_offset) {
1572
        int rescaled = sc->time_offset < 0 ? av_rescale(sc->time_offset, sc->time_scale, mov->time_scale) : sc->time_offset;
1573
        current_dts = -rescaled;
1574
        if (sc->ctts_data && sc->ctts_data[0].duration / sc->stts_data[0].duration > 16) {
1575
            /* more than 16 frames delay, dts are likely wrong
1576
               this happens with files created by iMovie */
1577
            sc->wrong_dts = 1;
1578
            st->codec->has_b_frames = 1;
1579
        }
1580
    }
1581

    
1582
    /* only use old uncompressed audio chunk demuxing when stts specifies it */
1583
    if (!(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1584
          sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
1585
        unsigned int current_sample = 0;
1586
        unsigned int stts_sample = 0;
1587
        unsigned int sample_size;
1588
        unsigned int distance = 0;
1589
        int key_off = sc->keyframes && sc->keyframes[0] == 1;
1590

    
1591
        current_dts -= sc->dts_shift;
1592

    
1593
        if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries))
1594
            return;
1595
        st->index_entries = av_malloc(sc->sample_count*sizeof(*st->index_entries));
1596
        if (!st->index_entries)
1597
            return;
1598
        st->index_entries_allocated_size = sc->sample_count*sizeof(*st->index_entries);
1599

    
1600
        for (i = 0; i < sc->chunk_count; i++) {
1601
            current_offset = sc->chunk_offsets[i];
1602
            if (stsc_index + 1 < sc->stsc_count &&
1603
                i + 1 == sc->stsc_data[stsc_index + 1].first)
1604
                stsc_index++;
1605
            for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
1606
                int keyframe = 0;
1607
                if (current_sample >= sc->sample_count) {
1608
                    av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
1609
                    return;
1610
                }
1611

    
1612
                if (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index]) {
1613
                    keyframe = 1;
1614
                    if (stss_index + 1 < sc->keyframe_count)
1615
                        stss_index++;
1616
                } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
1617
                    keyframe = 1;
1618
                    if (stps_index + 1 < sc->stps_count)
1619
                        stps_index++;
1620
                }
1621
                if (keyframe)
1622
                    distance = 0;
1623
                sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
1624
                if(sc->pseudo_stream_id == -1 ||
1625
                   sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
1626
                    AVIndexEntry *e = &st->index_entries[st->nb_index_entries++];
1627
                    e->pos = current_offset;
1628
                    e->timestamp = current_dts;
1629
                    e->size = sample_size;
1630
                    e->min_distance = distance;
1631
                    e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
1632
                    dprintf(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
1633
                            "size %d, distance %d, keyframe %d\n", st->index, current_sample,
1634
                            current_offset, current_dts, sample_size, distance, keyframe);
1635
                }
1636

    
1637
                current_offset += sample_size;
1638
                stream_size += sample_size;
1639
                current_dts += sc->stts_data[stts_index].duration;
1640
                distance++;
1641
                stts_sample++;
1642
                current_sample++;
1643
                if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
1644
                    stts_sample = 0;
1645
                    stts_index++;
1646
                }
1647
            }
1648
        }
1649
        if (st->duration > 0)
1650
            st->codec->bit_rate = stream_size*8*sc->time_scale/st->duration;
1651
    } else {
1652
        unsigned chunk_samples, total = 0;
1653

    
1654
        // compute total chunk count
1655
        for (i = 0; i < sc->stsc_count; i++) {
1656
            unsigned count, chunk_count;
1657

    
1658
            chunk_samples = sc->stsc_data[i].count;
1659
            if (sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
1660
                av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
1661
                return;
1662
            }
1663

    
1664
            if (sc->samples_per_frame >= 160) { // gsm
1665
                count = chunk_samples / sc->samples_per_frame;
1666
            } else if (sc->samples_per_frame > 1) {
1667
                unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
1668
                count = (chunk_samples+samples-1) / samples;
1669
            } else {
1670
                count = (chunk_samples+1023) / 1024;
1671
            }
1672

    
1673
            if (i < sc->stsc_count - 1)
1674
                chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
1675
            else
1676
                chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
1677
            total += chunk_count * count;
1678
        }
1679

    
1680
        dprintf(mov->fc, "chunk count %d\n", total);
1681
        if (total >= UINT_MAX / sizeof(*st->index_entries))
1682
            return;
1683
        st->index_entries = av_malloc(total*sizeof(*st->index_entries));
1684
        if (!st->index_entries)
1685
            return;
1686
        st->index_entries_allocated_size = total*sizeof(*st->index_entries);
1687

    
1688
        // populate index
1689
        for (i = 0; i < sc->chunk_count; i++) {
1690
            current_offset = sc->chunk_offsets[i];
1691
            if (stsc_index + 1 < sc->stsc_count &&
1692
                i + 1 == sc->stsc_data[stsc_index + 1].first)
1693
                stsc_index++;
1694
            chunk_samples = sc->stsc_data[stsc_index].count;
1695

    
1696
            while (chunk_samples > 0) {
1697
                AVIndexEntry *e;
1698
                unsigned size, samples;
1699

    
1700
                if (sc->samples_per_frame >= 160) { // gsm
1701
                    samples = sc->samples_per_frame;
1702
                    size = sc->bytes_per_frame;
1703
                } else {
1704
                    if (sc->samples_per_frame > 1) {
1705
                        samples = FFMIN((1024 / sc->samples_per_frame)*
1706
                                        sc->samples_per_frame, chunk_samples);
1707
                        size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
1708
                    } else {
1709
                        samples = FFMIN(1024, chunk_samples);
1710
                        size = samples * sc->sample_size;
1711
                    }
1712
                }
1713

    
1714
                if (st->nb_index_entries >= total) {
1715
                    av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %d\n", total);
1716
                    return;
1717
                }
1718
                e = &st->index_entries[st->nb_index_entries++];
1719
                e->pos = current_offset;
1720
                e->timestamp = current_dts;
1721
                e->size = size;
1722
                e->min_distance = 0;
1723
                e->flags = AVINDEX_KEYFRAME;
1724
                dprintf(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
1725
                        "size %d, duration %d\n", st->index, i, current_offset, current_dts,
1726
                        size, samples);
1727

    
1728
                current_offset += size;
1729
                current_dts += samples;
1730
                chunk_samples -= samples;
1731
            }
1732
        }
1733
    }
1734
}
1735

    
1736
static int mov_open_dref(ByteIOContext **pb, char *src, MOVDref *ref)
1737
{
1738
    /* try relative path, we do not try the absolute because it can leak information about our
1739
       system to an attacker */
1740
    if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
1741
        char filename[1024];
1742
        char *src_path;
1743
        int i, l;
1744

    
1745
        /* find a source dir */
1746
        src_path = strrchr(src, '/');
1747
        if (src_path)
1748
            src_path++;
1749
        else
1750
            src_path = src;
1751

    
1752
        /* find a next level down to target */
1753
        for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
1754
            if (ref->path[l] == '/') {
1755
                if (i == ref->nlvl_to - 1)
1756
                    break;
1757
                else
1758
                    i++;
1759
            }
1760

    
1761
        /* compose filename if next level down to target was found */
1762
        if (i == ref->nlvl_to - 1 && src_path - src  < sizeof(filename)) {
1763
            memcpy(filename, src, src_path - src);
1764
            filename[src_path - src] = 0;
1765

    
1766
            for (i = 1; i < ref->nlvl_from; i++)
1767
                av_strlcat(filename, "../", 1024);
1768

    
1769
            av_strlcat(filename, ref->path + l + 1, 1024);
1770

    
1771
            if (!url_fopen(pb, filename, URL_RDONLY))
1772
                return 0;
1773
        }
1774
    }
1775

    
1776
    return AVERROR(ENOENT);
1777
};
1778

    
1779
static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1780
{
1781
    AVStream *st;
1782
    MOVStreamContext *sc;
1783
    int ret;
1784

    
1785
    st = av_new_stream(c->fc, c->fc->nb_streams);
1786
    if (!st) return AVERROR(ENOMEM);
1787
    sc = av_mallocz(sizeof(MOVStreamContext));
1788
    if (!sc) return AVERROR(ENOMEM);
1789

    
1790
    st->priv_data = sc;
1791
    st->codec->codec_type = AVMEDIA_TYPE_DATA;
1792
    sc->ffindex = st->index;
1793

    
1794
    if ((ret = mov_read_default(c, pb, atom)) < 0)
1795
        return ret;
1796

    
1797
    /* sanity checks */
1798
    if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
1799
                            (!sc->sample_size && !sc->sample_count))) {
1800
        av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
1801
               st->index);
1802
        return 0;
1803
    }
1804

    
1805
    if (!sc->time_scale) {
1806
        av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", st->index);
1807
        sc->time_scale = c->time_scale;
1808
        if (!sc->time_scale)
1809
            sc->time_scale = 1;
1810
    }
1811

    
1812
    av_set_pts_info(st, 64, 1, sc->time_scale);
1813

    
1814
    if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1815
        !st->codec->frame_size && sc->stts_count == 1) {
1816
        st->codec->frame_size = av_rescale(sc->stts_data[0].duration,
1817
                                           st->codec->sample_rate, sc->time_scale);
1818
        dprintf(c->fc, "frame size %d\n", st->codec->frame_size);
1819
    }
1820

    
1821
    mov_build_index(c, st);
1822

    
1823
    if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
1824
        MOVDref *dref = &sc->drefs[sc->dref_id - 1];
1825
        if (mov_open_dref(&sc->pb, c->fc->filename, dref) < 0)
1826
            av_log(c->fc, AV_LOG_ERROR,
1827
                   "stream %d, error opening alias: path='%s', dir='%s', "
1828
                   "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
1829
                   st->index, dref->path, dref->dir, dref->filename,
1830
                   dref->volume, dref->nlvl_from, dref->nlvl_to);
1831
    } else
1832
        sc->pb = c->fc->pb;
1833

    
1834
    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1835
        if (!st->sample_aspect_ratio.num &&
1836
            (st->codec->width != sc->width || st->codec->height != sc->height)) {
1837
            st->sample_aspect_ratio = av_d2q(((double)st->codec->height * sc->width) /
1838
                                             ((double)st->codec->width * sc->height), INT_MAX);
1839
        }
1840

    
1841
        av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
1842
                  sc->time_scale*st->nb_frames, st->duration, INT_MAX);
1843
    }
1844

    
1845
    switch (st->codec->codec_id) {
1846
#if CONFIG_H261_DECODER
1847
    case CODEC_ID_H261:
1848
#endif
1849
#if CONFIG_H263_DECODER
1850
    case CODEC_ID_H263:
1851
#endif
1852
#if CONFIG_H264_DECODER
1853
    case CODEC_ID_H264:
1854
#endif
1855
#if CONFIG_MPEG4_DECODER
1856
    case CODEC_ID_MPEG4:
1857
#endif
1858
        st->codec->width = 0; /* let decoder init width/height */
1859
        st->codec->height= 0;
1860
        break;
1861
    }
1862

    
1863
    /* Do not need those anymore. */
1864
    av_freep(&sc->chunk_offsets);
1865
    av_freep(&sc->stsc_data);
1866
    av_freep(&sc->sample_sizes);
1867
    av_freep(&sc->keyframes);
1868
    av_freep(&sc->stts_data);
1869
    av_freep(&sc->stps_data);
1870

    
1871
    return 0;
1872
}
1873

    
1874
static int mov_read_ilst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1875
{
1876
    int ret;
1877
    c->itunes_metadata = 1;
1878
    ret = mov_read_default(c, pb, atom);
1879
    c->itunes_metadata = 0;
1880
    return ret;
1881
}
1882

    
1883
static int mov_read_meta(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1884
{
1885
    while (atom.size > 8) {
1886
        uint32_t tag = get_le32(pb);
1887
        atom.size -= 4;
1888
        if (tag == MKTAG('h','d','l','r')) {
1889
            url_fseek(pb, -8, SEEK_CUR);
1890
            atom.size += 8;
1891
            return mov_read_default(c, pb, atom);
1892
        }
1893
    }
1894
    return 0;
1895
}
1896

    
1897
static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1898
{
1899
    int i;
1900
    int width;
1901
    int height;
1902
    int64_t disp_transform[2];
1903
    int display_matrix[3][2];
1904
    AVStream *st;
1905
    MOVStreamContext *sc;
1906
    int version;
1907

    
1908
    if (c->fc->nb_streams < 1)
1909
        return 0;
1910
    st = c->fc->streams[c->fc->nb_streams-1];
1911
    sc = st->priv_data;
1912

    
1913
    version = get_byte(pb);
1914
    get_be24(pb); /* flags */
1915
    /*
1916
    MOV_TRACK_ENABLED 0x0001
1917
    MOV_TRACK_IN_MOVIE 0x0002
1918
    MOV_TRACK_IN_PREVIEW 0x0004
1919
    MOV_TRACK_IN_POSTER 0x0008
1920
    */
1921

    
1922
    if (version == 1) {
1923
        get_be64(pb);
1924
        get_be64(pb);
1925
    } else {
1926
        get_be32(pb); /* creation time */
1927
        get_be32(pb); /* modification time */
1928
    }
1929
    st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/
1930
    get_be32(pb); /* reserved */
1931

    
1932
    /* highlevel (considering edits) duration in movie timebase */
1933
    (version == 1) ? get_be64(pb) : get_be32(pb);
1934
    get_be32(pb); /* reserved */
1935
    get_be32(pb); /* reserved */
1936

    
1937
    get_be16(pb); /* layer */
1938
    get_be16(pb); /* alternate group */
1939
    get_be16(pb); /* volume */
1940
    get_be16(pb); /* reserved */
1941

    
1942
    //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
1943
    // they're kept in fixed point format through all calculations
1944
    // ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
1945
    for (i = 0; i < 3; i++) {
1946
        display_matrix[i][0] = get_be32(pb);   // 16.16 fixed point
1947
        display_matrix[i][1] = get_be32(pb);   // 16.16 fixed point
1948
        get_be32(pb);           // 2.30 fixed point (not used)
1949
    }
1950

    
1951
    width = get_be32(pb);       // 16.16 fixed point track width
1952
    height = get_be32(pb);      // 16.16 fixed point track height
1953
    sc->width = width >> 16;
1954
    sc->height = height >> 16;
1955

    
1956
    // transform the display width/height according to the matrix
1957
    // skip this if the display matrix is the default identity matrix
1958
    // or if it is rotating the picture, ex iPhone 3GS
1959
    // to keep the same scale, use [width height 1<<16]
1960
    if (width && height &&
1961
        ((display_matrix[0][0] != 65536  ||
1962
          display_matrix[1][1] != 65536) &&
1963
         !display_matrix[0][1] &&
1964
         !display_matrix[1][0] &&
1965
         !display_matrix[2][0] && !display_matrix[2][1])) {
1966
        for (i = 0; i < 2; i++)
1967
            disp_transform[i] =
1968
                (int64_t)  width  * display_matrix[0][i] +
1969
                (int64_t)  height * display_matrix[1][i] +
1970
                ((int64_t) display_matrix[2][i] << 16);
1971

    
1972
        //sample aspect ratio is new width/height divided by old width/height
1973
        st->sample_aspect_ratio = av_d2q(
1974
            ((double) disp_transform[0] * height) /
1975
            ((double) disp_transform[1] * width), INT_MAX);
1976
    }
1977
    return 0;
1978
}
1979

    
1980
static int mov_read_tfhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1981
{
1982
    MOVFragment *frag = &c->fragment;
1983
    MOVTrackExt *trex = NULL;
1984
    int flags, track_id, i;
1985

    
1986
    get_byte(pb); /* version */
1987
    flags = get_be24(pb);
1988

    
1989
    track_id = get_be32(pb);
1990
    if (!track_id)
1991
        return -1;
1992
    frag->track_id = track_id;
1993
    for (i = 0; i < c->trex_count; i++)
1994
        if (c->trex_data[i].track_id == frag->track_id) {
1995
            trex = &c->trex_data[i];
1996
            break;
1997
        }
1998
    if (!trex) {
1999
        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
2000
        return -1;
2001
    }
2002

    
2003
    if (flags & 0x01) frag->base_data_offset = get_be64(pb);
2004
    else              frag->base_data_offset = frag->moof_offset;
2005
    if (flags & 0x02) frag->stsd_id          = get_be32(pb);
2006
    else              frag->stsd_id          = trex->stsd_id;
2007

    
2008
    frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration;
2009
    frag->size     = flags & 0x10 ? get_be32(pb) : trex->size;
2010
    frag->flags    = flags & 0x20 ? get_be32(pb) : trex->flags;
2011
    dprintf(c->fc, "frag flags 0x%x\n", frag->flags);
2012
    return 0;
2013
}
2014

    
2015
static int mov_read_chap(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2016
{
2017
    c->chapter_track = get_be32(pb);
2018
    return 0;
2019
}
2020

    
2021
static int mov_read_trex(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2022
{
2023
    MOVTrackExt *trex;
2024

    
2025
    if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
2026
        return -1;
2027
    trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
2028
    if (!trex)
2029
        return AVERROR(ENOMEM);
2030
    c->trex_data = trex;
2031
    trex = &c->trex_data[c->trex_count++];
2032
    get_byte(pb); /* version */
2033
    get_be24(pb); /* flags */
2034
    trex->track_id = get_be32(pb);
2035
    trex->stsd_id  = get_be32(pb);
2036
    trex->duration = get_be32(pb);
2037
    trex->size     = get_be32(pb);
2038
    trex->flags    = get_be32(pb);
2039
    return 0;
2040
}
2041

    
2042
static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2043
{
2044
    MOVFragment *frag = &c->fragment;
2045
    AVStream *st = NULL;
2046
    MOVStreamContext *sc;
2047
    uint64_t offset;
2048
    int64_t dts;
2049
    int data_offset = 0;
2050
    unsigned entries, first_sample_flags = frag->flags;
2051
    int flags, distance, i;
2052

    
2053
    for (i = 0; i < c->fc->nb_streams; i++) {
2054
        if (c->fc->streams[i]->id == frag->track_id) {
2055
            st = c->fc->streams[i];
2056
            break;
2057
        }
2058
    }
2059
    if (!st) {
2060
        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
2061
        return -1;
2062
    }
2063
    sc = st->priv_data;
2064
    if (sc->pseudo_stream_id+1 != frag->stsd_id)
2065
        return 0;
2066
    get_byte(pb); /* version */
2067
    flags = get_be24(pb);
2068
    entries = get_be32(pb);
2069
    dprintf(c->fc, "flags 0x%x entries %d\n", flags, entries);
2070
    if (flags & 0x001) data_offset        = get_be32(pb);
2071
    if (flags & 0x004) first_sample_flags = get_be32(pb);
2072
    if (flags & 0x800) {
2073
        MOVStts *ctts_data;
2074
        if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
2075
            return -1;
2076
        ctts_data = av_realloc(sc->ctts_data,
2077
                               (entries+sc->ctts_count)*sizeof(*sc->ctts_data));
2078
        if (!ctts_data)
2079
            return AVERROR(ENOMEM);
2080
        sc->ctts_data = ctts_data;
2081
    }
2082
    dts = st->duration;
2083
    offset = frag->base_data_offset + data_offset;
2084
    distance = 0;
2085
    dprintf(c->fc, "first sample flags 0x%x\n", first_sample_flags);
2086
    for (i = 0; i < entries; i++) {
2087
        unsigned sample_size = frag->size;
2088
        int sample_flags = i ? frag->flags : first_sample_flags;
2089
        unsigned sample_duration = frag->duration;
2090
        int keyframe;
2091

    
2092
        if (flags & 0x100) sample_duration = get_be32(pb);
2093
        if (flags & 0x200) sample_size     = get_be32(pb);
2094
        if (flags & 0x400) sample_flags    = get_be32(pb);
2095
        if (flags & 0x800) {
2096
            sc->ctts_data[sc->ctts_count].count = 1;
2097
            sc->ctts_data[sc->ctts_count].duration = get_be32(pb);
2098
            sc->ctts_count++;
2099
        }
2100
        if ((keyframe = st->codec->codec_type == AVMEDIA_TYPE_AUDIO ||
2101
             (flags & 0x004 && !i && !sample_flags) || sample_flags & 0x2000000))
2102
            distance = 0;
2103
        av_add_index_entry(st, offset, dts, sample_size, distance,
2104
                           keyframe ? AVINDEX_KEYFRAME : 0);
2105
        dprintf(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
2106
                "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
2107
                offset, dts, sample_size, distance, keyframe);
2108
        distance++;
2109
        dts += sample_duration;
2110
        offset += sample_size;
2111
    }
2112
    frag->moof_offset = offset;
2113
    st->duration = dts;
2114
    return 0;
2115
}
2116

    
2117
/* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
2118
/* like the files created with Adobe Premiere 5.0, for samples see */
2119
/* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
2120
static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2121
{
2122
    int err;
2123

    
2124
    if (atom.size < 8)
2125
        return 0; /* continue */
2126
    if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
2127
        url_fskip(pb, atom.size - 4);
2128
        return 0;
2129
    }
2130
    atom.type = get_le32(pb);
2131
    atom.size -= 8;
2132
    if (atom.type != MKTAG('m','d','a','t')) {
2133
        url_fskip(pb, atom.size);
2134
        return 0;
2135
    }
2136
    err = mov_read_mdat(c, pb, atom);
2137
    return err;
2138
}
2139

    
2140
static int mov_read_cmov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2141
{
2142
#if CONFIG_ZLIB
2143
    ByteIOContext ctx;
2144
    uint8_t *cmov_data;
2145
    uint8_t *moov_data; /* uncompressed data */
2146
    long cmov_len, moov_len;
2147
    int ret = -1;
2148

    
2149
    get_be32(pb); /* dcom atom */
2150
    if (get_le32(pb) != MKTAG('d','c','o','m'))
2151
        return -1;
2152
    if (get_le32(pb) != MKTAG('z','l','i','b')) {
2153
        av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
2154
        return -1;
2155
    }
2156
    get_be32(pb); /* cmvd atom */
2157
    if (get_le32(pb) != MKTAG('c','m','v','d'))
2158
        return -1;
2159
    moov_len = get_be32(pb); /* uncompressed size */
2160
    cmov_len = atom.size - 6 * 4;
2161

    
2162
    cmov_data = av_malloc(cmov_len);
2163
    if (!cmov_data)
2164
        return AVERROR(ENOMEM);
2165
    moov_data = av_malloc(moov_len);
2166
    if (!moov_data) {
2167
        av_free(cmov_data);
2168
        return AVERROR(ENOMEM);
2169
    }
2170
    get_buffer(pb, cmov_data, cmov_len);
2171
    if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
2172
        goto free_and_return;
2173
    if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
2174
        goto free_and_return;
2175
    atom.type = MKTAG('m','o','o','v');
2176
    atom.size = moov_len;
2177
#ifdef DEBUG
2178
//    { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
2179
#endif
2180
    ret = mov_read_default(c, &ctx, atom);
2181
free_and_return:
2182
    av_free(moov_data);
2183
    av_free(cmov_data);
2184
    return ret;
2185
#else
2186
    av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
2187
    return -1;
2188
#endif
2189
}
2190

    
2191
/* edit list atom */
2192
static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2193
{
2194
    MOVStreamContext *sc;
2195
    int i, edit_count;
2196

    
2197
    if (c->fc->nb_streams < 1)
2198
        return 0;
2199
    sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
2200

    
2201
    get_byte(pb); /* version */
2202
    get_be24(pb); /* flags */
2203
    edit_count = get_be32(pb); /* entries */
2204

    
2205
    if((uint64_t)edit_count*12+8 > atom.size)
2206
        return -1;
2207

    
2208
    for(i=0; i<edit_count; i++){
2209
        int time;
2210
        int duration = get_be32(pb); /* Track duration */
2211
        time = get_be32(pb); /* Media time */
2212
        get_be32(pb); /* Media rate */
2213
        if (i == 0 && time >= -1) {
2214
            sc->time_offset = time != -1 ? time : -duration;
2215
        }
2216
    }
2217

    
2218
    if(edit_count > 1)
2219
        av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
2220
               "a/v desync might occur, patch welcome\n");
2221

    
2222
    dprintf(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
2223
    return 0;
2224
}
2225

    
2226
static const MOVParseTableEntry mov_default_parse_table[] = {
2227
{ MKTAG('a','v','s','s'), mov_read_extradata },
2228
{ MKTAG('c','h','p','l'), mov_read_chpl },
2229
{ MKTAG('c','o','6','4'), mov_read_stco },
2230
{ MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
2231
{ MKTAG('d','i','n','f'), mov_read_default },
2232
{ MKTAG('d','r','e','f'), mov_read_dref },
2233
{ MKTAG('e','d','t','s'), mov_read_default },
2234
{ MKTAG('e','l','s','t'), mov_read_elst },
2235
{ MKTAG('e','n','d','a'), mov_read_enda },
2236
{ MKTAG('f','i','e','l'), mov_read_extradata },
2237
{ MKTAG('f','t','y','p'), mov_read_ftyp },
2238
{ MKTAG('g','l','b','l'), mov_read_glbl },
2239
{ MKTAG('h','d','l','r'), mov_read_hdlr },
2240
{ MKTAG('i','l','s','t'), mov_read_ilst },
2241
{ MKTAG('j','p','2','h'), mov_read_extradata },
2242
{ MKTAG('m','d','a','t'), mov_read_mdat },
2243
{ MKTAG('m','d','h','d'), mov_read_mdhd },
2244
{ MKTAG('m','d','i','a'), mov_read_default },
2245
{ MKTAG('m','e','t','a'), mov_read_meta },
2246
{ MKTAG('m','i','n','f'), mov_read_default },
2247
{ MKTAG('m','o','o','f'), mov_read_moof },
2248
{ MKTAG('m','o','o','v'), mov_read_moov },
2249
{ MKTAG('m','v','e','x'), mov_read_default },
2250
{ MKTAG('m','v','h','d'), mov_read_mvhd },
2251
{ MKTAG('S','M','I',' '), mov_read_smi }, /* Sorenson extension ??? */
2252
{ MKTAG('a','l','a','c'), mov_read_extradata }, /* alac specific atom */
2253
{ MKTAG('a','v','c','C'), mov_read_glbl },
2254
{ MKTAG('p','a','s','p'), mov_read_pasp },
2255
{ MKTAG('s','t','b','l'), mov_read_default },
2256
{ MKTAG('s','t','c','o'), mov_read_stco },
2257
{ MKTAG('s','t','p','s'), mov_read_stps },
2258
{ MKTAG('s','t','r','f'), mov_read_strf },
2259
{ MKTAG('s','t','s','c'), mov_read_stsc },
2260
{ MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
2261
{ MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
2262
{ MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
2263
{ MKTAG('s','t','t','s'), mov_read_stts },
2264
{ MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
2265
{ MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
2266
{ MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
2267
{ MKTAG('t','r','a','k'), mov_read_trak },
2268
{ MKTAG('t','r','a','f'), mov_read_default },
2269
{ MKTAG('t','r','e','f'), mov_read_default },
2270
{ MKTAG('c','h','a','p'), mov_read_chap },
2271
{ MKTAG('t','r','e','x'), mov_read_trex },
2272
{ MKTAG('t','r','u','n'), mov_read_trun },
2273
{ MKTAG('u','d','t','a'), mov_read_default },
2274
{ MKTAG('w','a','v','e'), mov_read_wave },
2275
{ MKTAG('e','s','d','s'), mov_read_esds },
2276
{ MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
2277
{ MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
2278
{ MKTAG('c','m','o','v'), mov_read_cmov },
2279
{ 0, NULL }
2280
};
2281

    
2282
static int mov_probe(AVProbeData *p)
2283
{
2284
    unsigned int offset;
2285
    uint32_t tag;
2286
    int score = 0;
2287

    
2288
    /* check file header */
2289
    offset = 0;
2290
    for(;;) {
2291
        /* ignore invalid offset */
2292
        if ((offset + 8) > (unsigned int)p->buf_size)
2293
            return score;
2294
        tag = AV_RL32(p->buf + offset + 4);
2295
        switch(tag) {
2296
        /* check for obvious tags */
2297
        case MKTAG('j','P',' ',' '): /* jpeg 2000 signature */
2298
        case MKTAG('m','o','o','v'):
2299
        case MKTAG('m','d','a','t'):
2300
        case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
2301
        case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
2302
        case MKTAG('f','t','y','p'):
2303
            return AVPROBE_SCORE_MAX;
2304
        /* those are more common words, so rate then a bit less */
2305
        case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
2306
        case MKTAG('w','i','d','e'):
2307
        case MKTAG('f','r','e','e'):
2308
        case MKTAG('j','u','n','k'):
2309
        case MKTAG('p','i','c','t'):
2310
            return AVPROBE_SCORE_MAX - 5;
2311
        case MKTAG(0x82,0x82,0x7f,0x7d):
2312
        case MKTAG('s','k','i','p'):
2313
        case MKTAG('u','u','i','d'):
2314
        case MKTAG('p','r','f','l'):
2315
            offset = AV_RB32(p->buf+offset) + offset;
2316
            /* if we only find those cause probedata is too small at least rate them */
2317
            score = AVPROBE_SCORE_MAX - 50;
2318
            break;
2319
        default:
2320
            /* unrecognized tag */
2321
            return score;
2322
        }
2323
    }
2324
    return score;
2325
}
2326

    
2327
// must be done after parsing all trak because there's no order requirement
2328
static void mov_read_chapters(AVFormatContext *s)
2329
{
2330
    MOVContext *mov = s->priv_data;
2331
    AVStream *st = NULL;
2332
    MOVStreamContext *sc;
2333
    int64_t cur_pos;
2334
    uint8_t *title = NULL;
2335
    int i, len, i8, i16;
2336

    
2337
    for (i = 0; i < s->nb_streams; i++)
2338
        if (s->streams[i]->id == mov->chapter_track) {
2339
            st = s->streams[i];
2340
            break;
2341
        }
2342
    if (!st) {
2343
        av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
2344
        return;
2345
    }
2346

    
2347
    st->discard = AVDISCARD_ALL;
2348
    sc = st->priv_data;
2349
    cur_pos = url_ftell(sc->pb);
2350

    
2351
    for (i = 0; i < st->nb_index_entries; i++) {
2352
        AVIndexEntry *sample = &st->index_entries[i];
2353
        int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
2354

    
2355
        if (url_fseek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
2356
            av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
2357
            goto finish;
2358
        }
2359

    
2360
        title = av_malloc(sample->size+2);
2361
        get_buffer(sc->pb, title, sample->size);
2362

    
2363
        // the first two bytes are the length of the title
2364
        len = AV_RB16(title);
2365
        if (len > sample->size-2)
2366
            continue;
2367

    
2368
        // The samples could theoretically be in any encoding if there's an encd
2369
        // atom following, but in practice are only utf-8 or utf-16, distinguished
2370
        // instead by the presence of a BOM
2371
        if (AV_RB16(title+2) == 0xfeff) {
2372
            uint8_t *utf8 = av_malloc(2*len+3);
2373

    
2374
            i8 = i16 = 0;
2375
            while (i16 < len) {
2376
                uint32_t ch;
2377
                uint8_t tmp;
2378
                GET_UTF16(ch, i16 < len ? AV_RB16(title + (i16+=2)) : 0, break;)
2379
                PUT_UTF8(ch, tmp, if (i8 < 2*len) utf8[2+i8++] = tmp;)
2380
            }
2381
            utf8[2+i8] = 0;
2382
            av_freep(&title);
2383
            title = utf8;
2384
        }
2385

    
2386
        ff_new_chapter(s, i, st->time_base, sample->timestamp, end, title+2);
2387
        av_freep(&title);
2388
    }
2389
finish:
2390
    av_free(title);
2391
    url_fseek(sc->pb, cur_pos, SEEK_SET);
2392
}
2393

    
2394
static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
2395
{
2396
    MOVContext *mov = s->priv_data;
2397
    ByteIOContext *pb = s->pb;
2398
    int err;
2399
    MOVAtom atom = { AV_RL32("root") };
2400

    
2401
    mov->fc = s;
2402
    /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
2403
    if(!url_is_streamed(pb))
2404
        atom.size = url_fsize(pb);
2405
    else
2406
        atom.size = INT64_MAX;
2407

    
2408
    /* check MOV header */
2409
    if ((err = mov_read_default(mov, pb, atom)) < 0) {
2410
        av_log(s, AV_LOG_ERROR, "error reading header: %d\n", err);
2411
        return err;
2412
    }
2413
    if (!mov->found_moov) {
2414
        av_log(s, AV_LOG_ERROR, "moov atom not found\n");
2415
        return -1;
2416
    }
2417
    dprintf(mov->fc, "on_parse_exit_offset=%lld\n", url_ftell(pb));
2418

    
2419
    if (!url_is_streamed(pb) && mov->chapter_track > 0)
2420
        mov_read_chapters(s);
2421

    
2422
    return 0;
2423
}
2424

    
2425
static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
2426
{
2427
    AVIndexEntry *sample = NULL;
2428
    int64_t best_dts = INT64_MAX;
2429
    int i;
2430
    for (i = 0; i < s->nb_streams; i++) {
2431
        AVStream *avst = s->streams[i];
2432
        MOVStreamContext *msc = avst->priv_data;
2433
        if (msc->pb && msc->current_sample < avst->nb_index_entries) {
2434
            AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
2435
            int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
2436
            dprintf(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
2437
            if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) ||
2438
                (!url_is_streamed(s->pb) &&
2439
                 ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
2440
                 ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
2441
                  (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
2442
                sample = current_sample;
2443
                best_dts = dts;
2444
                *st = avst;
2445
            }
2446
        }
2447
    }
2448
    return sample;
2449
}
2450

    
2451
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
2452
{
2453
    MOVContext *mov = s->priv_data;
2454
    MOVStreamContext *sc;
2455
    AVIndexEntry *sample;
2456
    AVStream *st = NULL;
2457
    int ret;
2458
 retry:
2459
    sample = mov_find_next_sample(s, &st);
2460
    if (!sample) {
2461
        mov->found_mdat = 0;
2462
        if (!url_is_streamed(s->pb) ||
2463
            mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
2464
            url_feof(s->pb))
2465
            return AVERROR_EOF;
2466
        dprintf(s, "read fragments, offset 0x%llx\n", url_ftell(s->pb));
2467
        goto retry;
2468
    }
2469
    sc = st->priv_data;
2470
    /* must be done just before reading, to avoid infinite loop on sample */
2471
    sc->current_sample++;
2472

    
2473
    if (st->discard != AVDISCARD_ALL) {
2474
        if (url_fseek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
2475
            av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
2476
                   sc->ffindex, sample->pos);
2477
            return -1;
2478
        }
2479
        ret = av_get_packet(sc->pb, pkt, sample->size);
2480
        if (ret < 0)
2481
            return ret;
2482
#if CONFIG_DV_DEMUXER
2483
        if (mov->dv_demux && sc->dv_audio_container) {
2484
            dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);
2485
            av_free(pkt->data);
2486
            pkt->size = 0;
2487
            ret = dv_get_packet(mov->dv_demux, pkt);
2488
            if (ret < 0)
2489
                return ret;
2490
        }
2491
#endif
2492
    }
2493

    
2494
    pkt->stream_index = sc->ffindex;
2495
    pkt->dts = sample->timestamp;
2496
    if (sc->ctts_data) {
2497
        pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
2498
        /* update ctts context */
2499
        sc->ctts_sample++;
2500
        if (sc->ctts_index < sc->ctts_count &&
2501
            sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
2502
            sc->ctts_index++;
2503
            sc->ctts_sample = 0;
2504
        }
2505
        if (sc->wrong_dts)
2506
            pkt->dts = AV_NOPTS_VALUE;
2507
    } else {
2508
        int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
2509
            st->index_entries[sc->current_sample].timestamp : st->duration;
2510
        pkt->duration = next_dts - pkt->dts;
2511
        pkt->pts = pkt->dts;
2512
    }
2513
    if (st->discard == AVDISCARD_ALL)
2514
        goto retry;
2515
    pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
2516
    pkt->pos = sample->pos;
2517
    dprintf(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
2518
            pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
2519
    return 0;
2520
}
2521

    
2522
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
2523
{
2524
    MOVStreamContext *sc = st->priv_data;
2525
    int sample, time_sample;
2526
    int i;
2527

    
2528
    sample = av_index_search_timestamp(st, timestamp, flags);
2529
    dprintf(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
2530
    if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2531
        sample = 0;
2532
    if (sample < 0) /* not sure what to do */
2533
        return -1;
2534
    sc->current_sample = sample;
2535
    dprintf(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
2536
    /* adjust ctts index */
2537
    if (sc->ctts_data) {
2538
        time_sample = 0;
2539
        for (i = 0; i < sc->ctts_count; i++) {
2540
            int next = time_sample + sc->ctts_data[i].count;
2541
            if (next > sc->current_sample) {
2542
                sc->ctts_index = i;
2543
                sc->ctts_sample = sc->current_sample - time_sample;
2544
                break;
2545
            }
2546
            time_sample = next;
2547
        }
2548
    }
2549
    return sample;
2550
}
2551

    
2552
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2553
{
2554
    AVStream *st;
2555
    int64_t seek_timestamp, timestamp;
2556
    int sample;
2557
    int i;
2558

    
2559
    if (stream_index >= s->nb_streams)
2560
        return -1;
2561
    if (sample_time < 0)
2562
        sample_time = 0;
2563

    
2564
    st = s->streams[stream_index];
2565
    sample = mov_seek_stream(s, st, sample_time, flags);
2566
    if (sample < 0)
2567
        return -1;
2568

    
2569
    /* adjust seek timestamp to found sample timestamp */
2570
    seek_timestamp = st->index_entries[sample].timestamp;
2571

    
2572
    for (i = 0; i < s->nb_streams; i++) {
2573
        st = s->streams[i];
2574
        if (stream_index == i)
2575
            continue;
2576

    
2577
        timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
2578
        mov_seek_stream(s, st, timestamp, flags);
2579
    }
2580
    return 0;
2581
}
2582

    
2583
static int mov_read_close(AVFormatContext *s)
2584
{
2585
    MOVContext *mov = s->priv_data;
2586
    int i, j;
2587

    
2588
    for (i = 0; i < s->nb_streams; i++) {
2589
        AVStream *st = s->streams[i];
2590
        MOVStreamContext *sc = st->priv_data;
2591

    
2592
        av_freep(&sc->ctts_data);
2593
        for (j = 0; j < sc->drefs_count; j++) {
2594
            av_freep(&sc->drefs[j].path);
2595
            av_freep(&sc->drefs[j].dir);
2596
        }
2597
        av_freep(&sc->drefs);
2598
        if (sc->pb && sc->pb != s->pb)
2599
            url_fclose(sc->pb);
2600

    
2601
        av_freep(&st->codec->palctrl);
2602
    }
2603

    
2604
    if (mov->dv_demux) {
2605
        for(i = 0; i < mov->dv_fctx->nb_streams; i++) {
2606
            av_freep(&mov->dv_fctx->streams[i]->codec);
2607
            av_freep(&mov->dv_fctx->streams[i]);
2608
        }
2609
        av_freep(&mov->dv_fctx);
2610
        av_freep(&mov->dv_demux);
2611
    }
2612

    
2613
    av_freep(&mov->trex_data);
2614

    
2615
    return 0;
2616
}
2617

    
2618
AVInputFormat mov_demuxer = {
2619
    "mov,mp4,m4a,3gp,3g2,mj2",
2620
    NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
2621
    sizeof(MOVContext),
2622
    mov_probe,
2623
    mov_read_header,
2624
    mov_read_packet,
2625
    mov_read_close,
2626
    mov_read_seek,
2627
};