Statistics
| Branch: | Revision:

ffmpeg / libavformat / mov.c @ 6866dd12

History | View | Annotate | Download (78.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_set(&c->fc->metadata, "track", buf);
90

    
91
    get_be16(pb); // total tracks
92

    
93
    return 0;
94
}
95

    
96
static int mov_read_udta_string(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
97
{
98
#ifdef MOV_EXPORT_ALL_METADATA
99
    char tmp_key[5];
100
#endif
101
    char str[1024], key2[16], language[4] = {0};
102
    const char *key = NULL;
103
    uint16_t str_size;
104
    int (*parse)(MOVContext*, ByteIOContext*, unsigned) = NULL;
105

    
106
    switch (atom.type) {
107
    case MKTAG(0xa9,'n','a','m'): key = "title";     break;
108
    case MKTAG(0xa9,'a','u','t'):
109
    case MKTAG(0xa9,'A','R','T'): key = "author";    break;
110
    case MKTAG(0xa9,'w','r','t'): key = "composer";  break;
111
    case MKTAG( 'c','p','r','t'):
112
    case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
113
    case MKTAG(0xa9,'c','m','t'):
114
    case MKTAG(0xa9,'i','n','f'): key = "comment";   break;
115
    case MKTAG(0xa9,'a','l','b'): key = "album";     break;
116
    case MKTAG(0xa9,'d','a','y'): key = "year";      break;
117
    case MKTAG(0xa9,'g','e','n'): key = "genre";     break;
118
    case MKTAG(0xa9,'t','o','o'):
119
    case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;
120
    case MKTAG( 'd','e','s','c'): key = "description";break;
121
    case MKTAG( 'l','d','e','s'): key = "synopsis";  break;
122
    case MKTAG( 't','v','s','h'): key = "show";      break;
123
    case MKTAG( 't','v','e','n'): key = "episode_id";break;
124
    case MKTAG( 't','v','n','n'): key = "network";   break;
125
    case MKTAG( 't','r','k','n'): key = "track";
126
        parse = mov_metadata_trkn; break;
127
    }
128

    
129
    if (c->itunes_metadata && atom.size > 8) {
130
        int data_size = get_be32(pb);
131
        int tag = get_le32(pb);
132
        if (tag == MKTAG('d','a','t','a')) {
133
            get_be32(pb); // type
134
            get_be32(pb); // unknown
135
            str_size = data_size - 16;
136
            atom.size -= 16;
137
        } else return 0;
138
    } else if (atom.size > 4 && key && !c->itunes_metadata) {
139
        str_size = get_be16(pb); // string length
140
        ff_mov_lang_to_iso639(get_be16(pb), language);
141
        atom.size -= 4;
142
    } else
143
        str_size = atom.size;
144

    
145
#ifdef MOV_EXPORT_ALL_METADATA
146
    if (!key) {
147
        snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
148
        key = tmp_key;
149
    }
150
#endif
151

    
152
    if (!key)
153
        return 0;
154
    if (atom.size < 0)
155
        return -1;
156

    
157
    str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
158

    
159
    if (parse)
160
        parse(c, pb, str_size);
161
    else {
162
        get_buffer(pb, str, str_size);
163
        str[str_size] = 0;
164
        av_metadata_set(&c->fc->metadata, key, str);
165
        if (*language && strcmp(language, "und")) {
166
            snprintf(key2, sizeof(key2), "%s-%s", key, language);
167
            av_metadata_set(&c->fc->metadata, key2, str);
168
        }
169
    }
170
#ifdef DEBUG_METADATA
171
    av_log(c->fc, AV_LOG_DEBUG, "lang \"%3s\" ", language);
172
    av_log(c->fc, AV_LOG_DEBUG, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %lld\n",
173
           key, str, (char*)&atom.type, str_size, atom.size);
174
#endif
175

    
176
    return 0;
177
}
178

    
179
static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
180
{
181
    int64_t total_size = 0;
182
    MOVAtom a;
183
    int i;
184
    int err = 0;
185

    
186
    a.offset = atom.offset;
187

    
188
    if (atom.size < 0)
189
        atom.size = INT64_MAX;
190
    while(((total_size + 8) < atom.size) && !url_feof(pb) && !err) {
191
        int (*parse)(MOVContext*, ByteIOContext*, MOVAtom) = NULL;
192
        a.size = atom.size;
193
        a.type=0;
194
        if(atom.size >= 8) {
195
            a.size = get_be32(pb);
196
            a.type = get_le32(pb);
197
        }
198
        total_size += 8;
199
        a.offset += 8;
200
        dprintf(c->fc, "type: %08x  %.4s  sz: %"PRIx64"  %"PRIx64"   %"PRIx64"\n",
201
                a.type, (char*)&a.type, a.size, atom.size, total_size);
202
        if (a.size == 1) { /* 64 bit extended size */
203
            a.size = get_be64(pb) - 8;
204
            a.offset += 8;
205
            total_size += 8;
206
        }
207
        if (a.size == 0) {
208
            a.size = atom.size - total_size;
209
            if (a.size <= 8)
210
                break;
211
        }
212
        a.size -= 8;
213
        if(a.size < 0)
214
            break;
215
        a.size = FFMIN(a.size, atom.size - total_size);
216

    
217
        for (i = 0; mov_default_parse_table[i].type; i++)
218
            if (mov_default_parse_table[i].type == a.type) {
219
                parse = mov_default_parse_table[i].parse;
220
                break;
221
            }
222

    
223
        // container is user data
224
        if (!parse && (atom.type == MKTAG('u','d','t','a') ||
225
                       atom.type == MKTAG('i','l','s','t')))
226
            parse = mov_read_udta_string;
227

    
228
        if (!parse) { /* skip leaf atoms data */
229
            url_fskip(pb, a.size);
230
        } else {
231
            int64_t start_pos = url_ftell(pb);
232
            int64_t left;
233
            err = parse(c, pb, a);
234
            if (url_is_streamed(pb) && c->found_moov && c->found_mdat)
235
                break;
236
            left = a.size - url_ftell(pb) + start_pos;
237
            if (left > 0) /* skip garbage at atom end */
238
                url_fskip(pb, left);
239
        }
240

    
241
        a.offset += a.size;
242
        total_size += a.size;
243
    }
244

    
245
    if (!err && total_size < atom.size && atom.size < 0x7ffff)
246
        url_fskip(pb, atom.size - total_size);
247

    
248
    return err;
249
}
250

    
251
static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
252
{
253
    AVStream *st;
254
    MOVStreamContext *sc;
255
    int entries, i, j;
256

    
257
    if (c->fc->nb_streams < 1)
258
        return 0;
259
    st = c->fc->streams[c->fc->nb_streams-1];
260
    sc = st->priv_data;
261

    
262
    get_be32(pb); // version + flags
263
    entries = get_be32(pb);
264
    if (entries >= UINT_MAX / sizeof(*sc->drefs))
265
        return -1;
266
    sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
267
    if (!sc->drefs)
268
        return AVERROR(ENOMEM);
269
    sc->drefs_count = entries;
270

    
271
    for (i = 0; i < sc->drefs_count; i++) {
272
        MOVDref *dref = &sc->drefs[i];
273
        uint32_t size = get_be32(pb);
274
        int64_t next = url_ftell(pb) + size - 4;
275

    
276
        dref->type = get_le32(pb);
277
        get_be32(pb); // version + flags
278
        dprintf(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
279

    
280
        if (dref->type == MKTAG('a','l','i','s') && size > 150) {
281
            /* macintosh alias record */
282
            uint16_t volume_len, len;
283
            int16_t type;
284

    
285
            url_fskip(pb, 10);
286

    
287
            volume_len = get_byte(pb);
288
            volume_len = FFMIN(volume_len, 27);
289
            get_buffer(pb, dref->volume, 27);
290
            dref->volume[volume_len] = 0;
291
            av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
292

    
293
            url_fskip(pb, 12);
294

    
295
            len = get_byte(pb);
296
            len = FFMIN(len, 63);
297
            get_buffer(pb, dref->filename, 63);
298
            dref->filename[len] = 0;
299
            av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
300

    
301
            url_fskip(pb, 16);
302

    
303
            /* read next level up_from_alias/down_to_target */
304
            dref->nlvl_from = get_be16(pb);
305
            dref->nlvl_to   = get_be16(pb);
306
            av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
307
                   dref->nlvl_from, dref->nlvl_to);
308

    
309
            url_fskip(pb, 16);
310

    
311
            for (type = 0; type != -1 && url_ftell(pb) < next; ) {
312
                type = get_be16(pb);
313
                len = get_be16(pb);
314
                av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
315
                if (len&1)
316
                    len += 1;
317
                if (type == 2) { // absolute path
318
                    av_free(dref->path);
319
                    dref->path = av_mallocz(len+1);
320
                    if (!dref->path)
321
                        return AVERROR(ENOMEM);
322
                    get_buffer(pb, dref->path, len);
323
                    if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
324
                        len -= volume_len;
325
                        memmove(dref->path, dref->path+volume_len, len);
326
                        dref->path[len] = 0;
327
                    }
328
                    for (j = 0; j < len; j++)
329
                        if (dref->path[j] == ':')
330
                            dref->path[j] = '/';
331
                    av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
332
                } else if (type == 0) { // directory name
333
                    av_free(dref->dir);
334
                    dref->dir = av_malloc(len+1);
335
                    if (!dref->dir)
336
                        return AVERROR(ENOMEM);
337
                    get_buffer(pb, dref->dir, len);
338
                    dref->dir[len] = 0;
339
                    for (j = 0; j < len; j++)
340
                        if (dref->dir[j] == ':')
341
                            dref->dir[j] = '/';
342
                    av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
343
                } else
344
                    url_fskip(pb, len);
345
            }
346
        }
347
        url_fseek(pb, next, SEEK_SET);
348
    }
349
    return 0;
350
}
351

    
352
static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
353
{
354
    AVStream *st;
355
    uint32_t type;
356
    uint32_t ctype;
357

    
358
    if (c->fc->nb_streams < 1) // meta before first trak
359
        return 0;
360

    
361
    st = c->fc->streams[c->fc->nb_streams-1];
362

    
363
    get_byte(pb); /* version */
364
    get_be24(pb); /* flags */
365

    
366
    /* component type */
367
    ctype = get_le32(pb);
368
    type = get_le32(pb); /* component subtype */
369

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

    
373
    if     (type == MKTAG('v','i','d','e'))
374
        st->codec->codec_type = CODEC_TYPE_VIDEO;
375
    else if(type == MKTAG('s','o','u','n'))
376
        st->codec->codec_type = CODEC_TYPE_AUDIO;
377
    else if(type == MKTAG('m','1','a',' '))
378
        st->codec->codec_id = CODEC_ID_MP2;
379
    else if(type == MKTAG('s','u','b','p'))
380
        st->codec->codec_type = CODEC_TYPE_SUBTITLE;
381

    
382
    get_be32(pb); /* component  manufacture */
383
    get_be32(pb); /* component flags */
384
    get_be32(pb); /* component flags mask */
385

    
386
    if(atom.size <= 24)
387
        return 0; /* nothing left to read */
388

    
389
    url_fskip(pb, atom.size - (url_ftell(pb) - atom.offset));
390
    return 0;
391
}
392

    
393
int ff_mp4_read_descr_len(ByteIOContext *pb)
394
{
395
    int len = 0;
396
    int count = 4;
397
    while (count--) {
398
        int c = get_byte(pb);
399
        len = (len << 7) | (c & 0x7f);
400
        if (!(c & 0x80))
401
            break;
402
    }
403
    return len;
404
}
405

    
406
int mp4_read_descr(AVFormatContext *fc, ByteIOContext *pb, int *tag)
407
{
408
    int len;
409
    *tag = get_byte(pb);
410
    len = ff_mp4_read_descr_len(pb);
411
    dprintf(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
412
    return len;
413
}
414

    
415
#define MP4ESDescrTag                   0x03
416
#define MP4DecConfigDescrTag            0x04
417
#define MP4DecSpecificDescrTag          0x05
418

    
419
static const AVCodecTag mp4_audio_types[] = {
420
    { CODEC_ID_MP3ON4, AOT_PS   }, /* old mp3on4 draft */
421
    { CODEC_ID_MP3ON4, AOT_L1   }, /* layer 1 */
422
    { CODEC_ID_MP3ON4, AOT_L2   }, /* layer 2 */
423
    { CODEC_ID_MP3ON4, AOT_L3   }, /* layer 3 */
424
    { CODEC_ID_MP4ALS, AOT_ALS  }, /* MPEG-4 ALS */
425
    { CODEC_ID_NONE,   AOT_NULL },
426
};
427

    
428
int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom)
429
{
430
    AVStream *st;
431
    int tag, len;
432

    
433
    if (fc->nb_streams < 1)
434
        return 0;
435
    st = fc->streams[fc->nb_streams-1];
436

    
437
    get_be32(pb); /* version + flags */
438
    len = mp4_read_descr(fc, pb, &tag);
439
    if (tag == MP4ESDescrTag) {
440
        get_be16(pb); /* ID */
441
        get_byte(pb); /* priority */
442
    } else
443
        get_be16(pb); /* ID */
444

    
445
    len = mp4_read_descr(fc, pb, &tag);
446
    if (tag == MP4DecConfigDescrTag) {
447
        int object_type_id = get_byte(pb);
448
        get_byte(pb); /* stream type */
449
        get_be24(pb); /* buffer size db */
450
        get_be32(pb); /* max bitrate */
451
        get_be32(pb); /* avg bitrate */
452

    
453
        st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
454
        dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
455
        len = mp4_read_descr(fc, pb, &tag);
456
        if (tag == MP4DecSpecificDescrTag) {
457
            dprintf(fc, "Specific MPEG4 header len=%d\n", len);
458
            if((uint64_t)len > (1<<30))
459
                return -1;
460
            st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
461
            if (!st->codec->extradata)
462
                return AVERROR(ENOMEM);
463
            get_buffer(pb, st->codec->extradata, len);
464
            st->codec->extradata_size = len;
465
            if (st->codec->codec_id == CODEC_ID_AAC) {
466
                MPEG4AudioConfig cfg;
467
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
468
                                         st->codec->extradata_size);
469
                st->codec->channels = cfg.channels;
470
                if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
471
                    st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
472
                else
473
                    st->codec->sample_rate = cfg.sample_rate; // ext sample rate ?
474
                dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
475
                        "sample rate %d ext sample rate %d\n", st->codec->channels,
476
                        cfg.object_type, cfg.ext_object_type,
477
                        cfg.sample_rate, cfg.ext_sample_rate);
478
                if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
479
                                                            cfg.object_type)))
480
                    st->codec->codec_id = CODEC_ID_AAC;
481
            }
482
        }
483
    }
484
    return 0;
485
}
486

    
487
static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
488
{
489
    return ff_mov_read_esds(c->fc, pb, atom);
490
}
491

    
492
static int mov_read_pasp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
493
{
494
    const int num = get_be32(pb);
495
    const int den = get_be32(pb);
496
    AVStream *st;
497

    
498
    if (c->fc->nb_streams < 1)
499
        return 0;
500
    st = c->fc->streams[c->fc->nb_streams-1];
501

    
502
    if (den != 0) {
503
        if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
504
            (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num))
505
            av_log(c->fc, AV_LOG_WARNING,
506
                   "sample aspect ratio already set to %d:%d, overriding by 'pasp' atom\n",
507
                   st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
508
        st->sample_aspect_ratio.num = num;
509
        st->sample_aspect_ratio.den = den;
510
    }
511
    return 0;
512
}
513

    
514
/* this atom contains actual media data */
515
static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
516
{
517
    if(atom.size == 0) /* wrong one (MP4) */
518
        return 0;
519
    c->found_mdat=1;
520
    return 0; /* now go for moov */
521
}
522

    
523
/* read major brand, minor version and compatible brands and store them as metadata */
524
static int mov_read_ftyp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
525
{
526
    uint32_t minor_ver;
527
    int comp_brand_size;
528
    char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */
529
    char* comp_brands_str;
530
    uint8_t type[5] = {0};
531

    
532
    get_buffer(pb, type, 4);
533
    if (strcmp(type, "qt  "))
534
        c->isom = 1;
535
    av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
536
    av_metadata_set(&c->fc->metadata, "major_brand", type);
537
    minor_ver = get_be32(pb); /* minor version */
538
    snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
539
    av_metadata_set(&c->fc->metadata, "minor_version", minor_ver_str);
540

    
541
    comp_brand_size = atom.size - 8;
542
    if (comp_brand_size < 0)
543
        return -1;
544
    comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
545
    if (!comp_brands_str)
546
        return AVERROR(ENOMEM);
547
    get_buffer(pb, comp_brands_str, comp_brand_size);
548
    comp_brands_str[comp_brand_size] = 0;
549
    av_metadata_set(&c->fc->metadata, "compatible_brands", comp_brands_str);
550
    av_freep(&comp_brands_str);
551

    
552
    return 0;
553
}
554

    
555
/* this atom should contain all header atoms */
556
static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
557
{
558
    if (mov_read_default(c, pb, atom) < 0)
559
        return -1;
560
    /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
561
    /* so we don't parse the whole file if over a network */
562
    c->found_moov=1;
563
    return 0; /* now go for mdat */
564
}
565

    
566
static int mov_read_moof(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
567
{
568
    c->fragment.moof_offset = url_ftell(pb) - 8;
569
    dprintf(c->fc, "moof offset %llx\n", c->fragment.moof_offset);
570
    return mov_read_default(c, pb, atom);
571
}
572

    
573
static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
574
{
575
    AVStream *st;
576
    MOVStreamContext *sc;
577
    int version;
578
    char language[4] = {0};
579
    unsigned lang;
580

    
581
    if (c->fc->nb_streams < 1)
582
        return 0;
583
    st = c->fc->streams[c->fc->nb_streams-1];
584
    sc = st->priv_data;
585

    
586
    version = get_byte(pb);
587
    if (version > 1)
588
        return -1; /* unsupported */
589

    
590
    get_be24(pb); /* flags */
591
    if (version == 1) {
592
        get_be64(pb);
593
        get_be64(pb);
594
    } else {
595
        get_be32(pb); /* creation time */
596
        get_be32(pb); /* modification time */
597
    }
598

    
599
    sc->time_scale = get_be32(pb);
600
    st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
601

    
602
    lang = get_be16(pb); /* language */
603
    if (ff_mov_lang_to_iso639(lang, language))
604
        av_metadata_set(&st->metadata, "language", language);
605
    get_be16(pb); /* quality */
606

    
607
    return 0;
608
}
609

    
610
static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
611
{
612
    int version = get_byte(pb); /* version */
613
    get_be24(pb); /* flags */
614

    
615
    if (version == 1) {
616
        get_be64(pb);
617
        get_be64(pb);
618
    } else {
619
        get_be32(pb); /* creation time */
620
        get_be32(pb); /* modification time */
621
    }
622
    c->time_scale = get_be32(pb); /* time scale */
623

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

    
626
    c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
627
    get_be32(pb); /* preferred scale */
628

    
629
    get_be16(pb); /* preferred volume */
630

    
631
    url_fskip(pb, 10); /* reserved */
632

    
633
    url_fskip(pb, 36); /* display matrix */
634

    
635
    get_be32(pb); /* preview time */
636
    get_be32(pb); /* preview duration */
637
    get_be32(pb); /* poster time */
638
    get_be32(pb); /* selection time */
639
    get_be32(pb); /* selection duration */
640
    get_be32(pb); /* current time */
641
    get_be32(pb); /* next track ID */
642

    
643
    return 0;
644
}
645

    
646
static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
647
{
648
    AVStream *st;
649

    
650
    if (c->fc->nb_streams < 1)
651
        return 0;
652
    st = c->fc->streams[c->fc->nb_streams-1];
653

    
654
    if((uint64_t)atom.size > (1<<30))
655
        return -1;
656

    
657
    // currently SVQ3 decoder expect full STSD header - so let's fake it
658
    // this should be fixed and just SMI header should be passed
659
    av_free(st->codec->extradata);
660
    st->codec->extradata = av_mallocz(atom.size + 0x5a + FF_INPUT_BUFFER_PADDING_SIZE);
661
    if (!st->codec->extradata)
662
        return AVERROR(ENOMEM);
663
    st->codec->extradata_size = 0x5a + atom.size;
664
    memcpy(st->codec->extradata, "SVQ3", 4); // fake
665
    get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
666
    dprintf(c->fc, "Reading SMI %"PRId64"  %s\n", atom.size, st->codec->extradata + 0x5a);
667
    return 0;
668
}
669

    
670
static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
671
{
672
    AVStream *st;
673
    int little_endian;
674

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

    
679
    little_endian = get_be16(pb);
680
    dprintf(c->fc, "enda %d\n", little_endian);
681
    if (little_endian == 1) {
682
        switch (st->codec->codec_id) {
683
        case CODEC_ID_PCM_S24BE:
684
            st->codec->codec_id = CODEC_ID_PCM_S24LE;
685
            break;
686
        case CODEC_ID_PCM_S32BE:
687
            st->codec->codec_id = CODEC_ID_PCM_S32LE;
688
            break;
689
        case CODEC_ID_PCM_F32BE:
690
            st->codec->codec_id = CODEC_ID_PCM_F32LE;
691
            break;
692
        case CODEC_ID_PCM_F64BE:
693
            st->codec->codec_id = CODEC_ID_PCM_F64LE;
694
            break;
695
        default:
696
            break;
697
        }
698
    }
699
    return 0;
700
}
701

    
702
/* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */
703
static int mov_read_extradata(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
704
{
705
    AVStream *st;
706
    uint64_t size;
707
    uint8_t *buf;
708

    
709
    if (c->fc->nb_streams < 1) // will happen with jp2 files
710
        return 0;
711
    st= c->fc->streams[c->fc->nb_streams-1];
712
    size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
713
    if(size > INT_MAX || (uint64_t)atom.size > INT_MAX)
714
        return -1;
715
    buf= av_realloc(st->codec->extradata, size);
716
    if(!buf)
717
        return -1;
718
    st->codec->extradata= buf;
719
    buf+= st->codec->extradata_size;
720
    st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
721
    AV_WB32(       buf    , atom.size + 8);
722
    AV_WL32(       buf + 4, atom.type);
723
    get_buffer(pb, buf + 8, atom.size);
724
    return 0;
725
}
726

    
727
static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
728
{
729
    AVStream *st;
730

    
731
    if (c->fc->nb_streams < 1)
732
        return 0;
733
    st = c->fc->streams[c->fc->nb_streams-1];
734

    
735
    if((uint64_t)atom.size > (1<<30))
736
        return -1;
737

    
738
    if (st->codec->codec_id == CODEC_ID_QDM2) {
739
        // pass all frma atom to codec, needed at least for QDM2
740
        av_free(st->codec->extradata);
741
        st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
742
        if (!st->codec->extradata)
743
            return AVERROR(ENOMEM);
744
        st->codec->extradata_size = atom.size;
745
        get_buffer(pb, st->codec->extradata, atom.size);
746
    } else if (atom.size > 8) { /* to read frma, esds atoms */
747
        if (mov_read_default(c, pb, atom) < 0)
748
            return -1;
749
    } else
750
        url_fskip(pb, atom.size);
751
    return 0;
752
}
753

    
754
/**
755
 * This function reads atom content and puts data in extradata without tag
756
 * nor size unlike mov_read_extradata.
757
 */
758
static int mov_read_glbl(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
759
{
760
    AVStream *st;
761

    
762
    if (c->fc->nb_streams < 1)
763
        return 0;
764
    st = c->fc->streams[c->fc->nb_streams-1];
765

    
766
    if((uint64_t)atom.size > (1<<30))
767
        return -1;
768

    
769
    av_free(st->codec->extradata);
770
    st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
771
    if (!st->codec->extradata)
772
        return AVERROR(ENOMEM);
773
    st->codec->extradata_size = atom.size;
774
    get_buffer(pb, st->codec->extradata, atom.size);
775
    return 0;
776
}
777

    
778
static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
779
{
780
    AVStream *st;
781
    MOVStreamContext *sc;
782
    unsigned int i, entries;
783

    
784
    if (c->fc->nb_streams < 1)
785
        return 0;
786
    st = c->fc->streams[c->fc->nb_streams-1];
787
    sc = st->priv_data;
788

    
789
    get_byte(pb); /* version */
790
    get_be24(pb); /* flags */
791

    
792
    entries = get_be32(pb);
793

    
794
    if(entries >= UINT_MAX/sizeof(int64_t))
795
        return -1;
796

    
797
    sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
798
    if (!sc->chunk_offsets)
799
        return AVERROR(ENOMEM);
800
    sc->chunk_count = entries;
801

    
802
    if      (atom.type == MKTAG('s','t','c','o'))
803
        for(i=0; i<entries; i++)
804
            sc->chunk_offsets[i] = get_be32(pb);
805
    else if (atom.type == MKTAG('c','o','6','4'))
806
        for(i=0; i<entries; i++)
807
            sc->chunk_offsets[i] = get_be64(pb);
808
    else
809
        return -1;
810

    
811
    return 0;
812
}
813

    
814
/**
815
 * Compute codec id for 'lpcm' tag.
816
 * See CoreAudioTypes and AudioStreamBasicDescription at Apple.
817
 */
818
enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
819
{
820
    if (flags & 1) { // floating point
821
        if (flags & 2) { // big endian
822
            if      (bps == 32) return CODEC_ID_PCM_F32BE;
823
            else if (bps == 64) return CODEC_ID_PCM_F64BE;
824
        } else {
825
            if      (bps == 32) return CODEC_ID_PCM_F32LE;
826
            else if (bps == 64) return CODEC_ID_PCM_F64LE;
827
        }
828
    } else {
829
        if (flags & 2) {
830
            if      (bps == 8)
831
                // signed integer
832
                if (flags & 4)  return CODEC_ID_PCM_S8;
833
                else            return CODEC_ID_PCM_U8;
834
            else if (bps == 16) return CODEC_ID_PCM_S16BE;
835
            else if (bps == 24) return CODEC_ID_PCM_S24BE;
836
            else if (bps == 32) return CODEC_ID_PCM_S32BE;
837
        } else {
838
            if      (bps == 8)
839
                if (flags & 4)  return CODEC_ID_PCM_S8;
840
                else            return CODEC_ID_PCM_U8;
841
            else if (bps == 16) return CODEC_ID_PCM_S16LE;
842
            else if (bps == 24) return CODEC_ID_PCM_S24LE;
843
            else if (bps == 32) return CODEC_ID_PCM_S32LE;
844
        }
845
    }
846
    return CODEC_ID_NONE;
847
}
848

    
849
static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
850
{
851
    AVStream *st;
852
    MOVStreamContext *sc;
853
    int j, entries, pseudo_stream_id;
854

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

    
860
    get_byte(pb); /* version */
861
    get_be24(pb); /* flags */
862

    
863
    entries = get_be32(pb);
864

    
865
    for(pseudo_stream_id=0; pseudo_stream_id<entries; pseudo_stream_id++) {
866
        //Parsing Sample description table
867
        enum CodecID id;
868
        int dref_id = 1;
869
        MOVAtom a = { 0, 0, 0 };
870
        int64_t start_pos = url_ftell(pb);
871
        int size = get_be32(pb); /* size */
872
        uint32_t format = get_le32(pb); /* data format */
873

    
874
        if (size >= 16) {
875
            get_be32(pb); /* reserved */
876
            get_be16(pb); /* reserved */
877
            dref_id = get_be16(pb);
878
        }
879

    
880
        if (st->codec->codec_tag &&
881
            st->codec->codec_tag != format &&
882
            (c->fc->video_codec_id ? ff_codec_get_id(codec_movvideo_tags, format) != c->fc->video_codec_id
883
                                   : st->codec->codec_tag != MKTAG('j','p','e','g'))
884
           ){
885
            /* Multiple fourcc, we skip JPEG. This is not correct, we should
886
             * export it as a separate AVStream but this needs a few changes
887
             * in the MOV demuxer, patch welcome. */
888
            av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
889
            url_fskip(pb, size - (url_ftell(pb) - start_pos));
890
            continue;
891
        }
892
        sc->pseudo_stream_id = st->codec->codec_tag ? -1 : pseudo_stream_id;
893
        sc->dref_id= dref_id;
894

    
895
        st->codec->codec_tag = format;
896
        id = ff_codec_get_id(codec_movaudio_tags, format);
897
        if (id<=0 && ((format&0xFFFF) == 'm'+('s'<<8) || (format&0xFFFF) == 'T'+('S'<<8)))
898
            id = ff_codec_get_id(ff_codec_wav_tags, bswap_32(format)&0xFFFF);
899

    
900
        if (st->codec->codec_type != CODEC_TYPE_VIDEO && id > 0) {
901
            st->codec->codec_type = CODEC_TYPE_AUDIO;
902
        } else if (st->codec->codec_type != CODEC_TYPE_AUDIO && /* do not overwrite codec type */
903
                   format && format != MKTAG('m','p','4','s')) { /* skip old asf mpeg4 tag */
904
            id = ff_codec_get_id(codec_movvideo_tags, format);
905
            if (id <= 0)
906
                id = ff_codec_get_id(ff_codec_bmp_tags, format);
907
            if (id > 0)
908
                st->codec->codec_type = CODEC_TYPE_VIDEO;
909
            else if(st->codec->codec_type == CODEC_TYPE_DATA){
910
                id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
911
                if(id > 0)
912
                    st->codec->codec_type = CODEC_TYPE_SUBTITLE;
913
            }
914
        }
915

    
916
        dprintf(c->fc, "size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
917
                (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
918
                (format >> 24) & 0xff, st->codec->codec_type);
919

    
920
        if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
921
            uint8_t codec_name[32];
922
            unsigned int color_depth;
923
            int color_greyscale;
924

    
925
            st->codec->codec_id = id;
926
            get_be16(pb); /* version */
927
            get_be16(pb); /* revision level */
928
            get_be32(pb); /* vendor */
929
            get_be32(pb); /* temporal quality */
930
            get_be32(pb); /* spatial quality */
931

    
932
            st->codec->width = get_be16(pb); /* width */
933
            st->codec->height = get_be16(pb); /* height */
934

    
935
            get_be32(pb); /* horiz resolution */
936
            get_be32(pb); /* vert resolution */
937
            get_be32(pb); /* data size, always 0 */
938
            get_be16(pb); /* frames per samples */
939

    
940
            get_buffer(pb, codec_name, 32); /* codec name, pascal string */
941
            if (codec_name[0] <= 31) {
942
                int i;
943
                int pos = 0;
944
                for (i = 0; i < codec_name[0] && pos < sizeof(st->codec->codec_name) - 3; i++) {
945
                    uint8_t tmp;
946
                    PUT_UTF8(codec_name[i+1], tmp, st->codec->codec_name[pos++] = tmp;)
947
                }
948
                st->codec->codec_name[pos] = 0;
949
            }
950

    
951
            st->codec->bits_per_coded_sample = get_be16(pb); /* depth */
952
            st->codec->color_table_id = get_be16(pb); /* colortable id */
953
            dprintf(c->fc, "depth %d, ctab id %d\n",
954
                   st->codec->bits_per_coded_sample, st->codec->color_table_id);
955
            /* figure out the palette situation */
956
            color_depth = st->codec->bits_per_coded_sample & 0x1F;
957
            color_greyscale = st->codec->bits_per_coded_sample & 0x20;
958

    
959
            /* if the depth is 2, 4, or 8 bpp, file is palettized */
960
            if ((color_depth == 2) || (color_depth == 4) ||
961
                (color_depth == 8)) {
962
                /* for palette traversal */
963
                unsigned int color_start, color_count, color_end;
964
                unsigned char r, g, b;
965

    
966
                st->codec->palctrl = av_malloc(sizeof(*st->codec->palctrl));
967
                if (color_greyscale) {
968
                    int color_index, color_dec;
969
                    /* compute the greyscale palette */
970
                    st->codec->bits_per_coded_sample = color_depth;
971
                    color_count = 1 << color_depth;
972
                    color_index = 255;
973
                    color_dec = 256 / (color_count - 1);
974
                    for (j = 0; j < color_count; j++) {
975
                        r = g = b = color_index;
976
                        st->codec->palctrl->palette[j] =
977
                            (r << 16) | (g << 8) | (b);
978
                        color_index -= color_dec;
979
                        if (color_index < 0)
980
                            color_index = 0;
981
                    }
982
                } else if (st->codec->color_table_id) {
983
                    const uint8_t *color_table;
984
                    /* if flag bit 3 is set, use the default palette */
985
                    color_count = 1 << color_depth;
986
                    if (color_depth == 2)
987
                        color_table = ff_qt_default_palette_4;
988
                    else if (color_depth == 4)
989
                        color_table = ff_qt_default_palette_16;
990
                    else
991
                        color_table = ff_qt_default_palette_256;
992

    
993
                    for (j = 0; j < color_count; j++) {
994
                        r = color_table[j * 3 + 0];
995
                        g = color_table[j * 3 + 1];
996
                        b = color_table[j * 3 + 2];
997
                        st->codec->palctrl->palette[j] =
998
                            (r << 16) | (g << 8) | (b);
999
                    }
1000
                } else {
1001
                    /* load the palette from the file */
1002
                    color_start = get_be32(pb);
1003
                    color_count = get_be16(pb);
1004
                    color_end = get_be16(pb);
1005
                    if ((color_start <= 255) &&
1006
                        (color_end <= 255)) {
1007
                        for (j = color_start; j <= color_end; j++) {
1008
                            /* each R, G, or B component is 16 bits;
1009
                             * only use the top 8 bits; skip alpha bytes
1010
                             * up front */
1011
                            get_byte(pb);
1012
                            get_byte(pb);
1013
                            r = get_byte(pb);
1014
                            get_byte(pb);
1015
                            g = get_byte(pb);
1016
                            get_byte(pb);
1017
                            b = get_byte(pb);
1018
                            get_byte(pb);
1019
                            st->codec->palctrl->palette[j] =
1020
                                (r << 16) | (g << 8) | (b);
1021
                        }
1022
                    }
1023
                }
1024
                st->codec->palctrl->palette_changed = 1;
1025
            }
1026
        } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) {
1027
            int bits_per_sample, flags;
1028
            uint16_t version = get_be16(pb);
1029

    
1030
            st->codec->codec_id = id;
1031
            get_be16(pb); /* revision level */
1032
            get_be32(pb); /* vendor */
1033

    
1034
            st->codec->channels = get_be16(pb);             /* channel count */
1035
            dprintf(c->fc, "audio channels %d\n", st->codec->channels);
1036
            st->codec->bits_per_coded_sample = get_be16(pb);      /* sample size */
1037

    
1038
            sc->audio_cid = get_be16(pb);
1039
            get_be16(pb); /* packet size = 0 */
1040

    
1041
            st->codec->sample_rate = ((get_be32(pb) >> 16));
1042

    
1043
            //Read QT version 1 fields. In version 0 these do not exist.
1044
            dprintf(c->fc, "version =%d, isom =%d\n",version,c->isom);
1045
            if(!c->isom) {
1046
                if(version==1) {
1047
                    sc->samples_per_frame = get_be32(pb);
1048
                    get_be32(pb); /* bytes per packet */
1049
                    sc->bytes_per_frame = get_be32(pb);
1050
                    get_be32(pb); /* bytes per sample */
1051
                } else if(version==2) {
1052
                    get_be32(pb); /* sizeof struct only */
1053
                    st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */
1054
                    st->codec->channels = get_be32(pb);
1055
                    get_be32(pb); /* always 0x7F000000 */
1056
                    st->codec->bits_per_coded_sample = get_be32(pb); /* bits per channel if sound is uncompressed */
1057
                    flags = get_be32(pb); /* lpcm format specific flag */
1058
                    sc->bytes_per_frame = get_be32(pb); /* bytes per audio packet if constant */
1059
                    sc->samples_per_frame = get_be32(pb); /* lpcm frames per audio packet if constant */
1060
                    if (format == MKTAG('l','p','c','m'))
1061
                        st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);
1062
                }
1063
            }
1064

    
1065
            switch (st->codec->codec_id) {
1066
            case CODEC_ID_PCM_S8:
1067
            case CODEC_ID_PCM_U8:
1068
                if (st->codec->bits_per_coded_sample == 16)
1069
                    st->codec->codec_id = CODEC_ID_PCM_S16BE;
1070
                break;
1071
            case CODEC_ID_PCM_S16LE:
1072
            case CODEC_ID_PCM_S16BE:
1073
                if (st->codec->bits_per_coded_sample == 8)
1074
                    st->codec->codec_id = CODEC_ID_PCM_S8;
1075
                else if (st->codec->bits_per_coded_sample == 24)
1076
                    st->codec->codec_id =
1077
                        st->codec->codec_id == CODEC_ID_PCM_S16BE ?
1078
                        CODEC_ID_PCM_S24BE : CODEC_ID_PCM_S24LE;
1079
                break;
1080
            /* set values for old format before stsd version 1 appeared */
1081
            case CODEC_ID_MACE3:
1082
                sc->samples_per_frame = 6;
1083
                sc->bytes_per_frame = 2*st->codec->channels;
1084
                break;
1085
            case CODEC_ID_MACE6:
1086
                sc->samples_per_frame = 6;
1087
                sc->bytes_per_frame = 1*st->codec->channels;
1088
                break;
1089
            case CODEC_ID_ADPCM_IMA_QT:
1090
                sc->samples_per_frame = 64;
1091
                sc->bytes_per_frame = 34*st->codec->channels;
1092
                break;
1093
            case CODEC_ID_GSM:
1094
                sc->samples_per_frame = 160;
1095
                sc->bytes_per_frame = 33;
1096
                break;
1097
            default:
1098
                break;
1099
            }
1100

    
1101
            bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
1102
            if (bits_per_sample) {
1103
                st->codec->bits_per_coded_sample = bits_per_sample;
1104
                sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
1105
            }
1106
        } else if(st->codec->codec_type==CODEC_TYPE_SUBTITLE){
1107
            // ttxt stsd contains display flags, justification, background
1108
            // color, fonts, and default styles, so fake an atom to read it
1109
            MOVAtom fake_atom = { .size = size - (url_ftell(pb) - start_pos) };
1110
            if (format != AV_RL32("mp4s")) // mp4s contains a regular esds atom
1111
                mov_read_glbl(c, pb, fake_atom);
1112
            st->codec->codec_id= id;
1113
            st->codec->width = sc->width;
1114
            st->codec->height = sc->height;
1115
        } else {
1116
            /* other codec type, just skip (rtp, mp4s, tmcd ...) */
1117
            url_fskip(pb, size - (url_ftell(pb) - start_pos));
1118
        }
1119
        /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
1120
        a.size = size - (url_ftell(pb) - start_pos);
1121
        if (a.size > 8) {
1122
            if (mov_read_default(c, pb, a) < 0)
1123
                return -1;
1124
        } else if (a.size > 0)
1125
            url_fskip(pb, a.size);
1126
    }
1127

    
1128
    if(st->codec->codec_type==CODEC_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1)
1129
        st->codec->sample_rate= sc->time_scale;
1130

    
1131
    /* special codec parameters handling */
1132
    switch (st->codec->codec_id) {
1133
#if CONFIG_DV_DEMUXER
1134
    case CODEC_ID_DVAUDIO:
1135
        c->dv_fctx = avformat_alloc_context();
1136
        c->dv_demux = dv_init_demux(c->dv_fctx);
1137
        if (!c->dv_demux) {
1138
            av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
1139
            return -1;
1140
        }
1141
        sc->dv_audio_container = 1;
1142
        st->codec->codec_id = CODEC_ID_PCM_S16LE;
1143
        break;
1144
#endif
1145
    /* no ifdef since parameters are always those */
1146
    case CODEC_ID_QCELP:
1147
        // force sample rate for qcelp when not stored in mov
1148
        if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
1149
            st->codec->sample_rate = 8000;
1150
        st->codec->frame_size= 160;
1151
        st->codec->channels= 1; /* really needed */
1152
        break;
1153
    case CODEC_ID_AMR_NB:
1154
    case CODEC_ID_AMR_WB:
1155
        st->codec->frame_size= sc->samples_per_frame;
1156
        st->codec->channels= 1; /* really needed */
1157
        /* force sample rate for amr, stsd in 3gp does not store sample rate */
1158
        if (st->codec->codec_id == CODEC_ID_AMR_NB)
1159
            st->codec->sample_rate = 8000;
1160
        else if (st->codec->codec_id == CODEC_ID_AMR_WB)
1161
            st->codec->sample_rate = 16000;
1162
        break;
1163
    case CODEC_ID_MP2:
1164
    case CODEC_ID_MP3:
1165
        st->codec->codec_type = CODEC_TYPE_AUDIO; /* force type after stsd for m1a hdlr */
1166
        st->need_parsing = AVSTREAM_PARSE_FULL;
1167
        break;
1168
    case CODEC_ID_GSM:
1169
    case CODEC_ID_ADPCM_MS:
1170
    case CODEC_ID_ADPCM_IMA_WAV:
1171
        st->codec->block_align = sc->bytes_per_frame;
1172
        break;
1173
    case CODEC_ID_ALAC:
1174
        if (st->codec->extradata_size == 36) {
1175
            st->codec->frame_size = AV_RB32(st->codec->extradata+12);
1176
            st->codec->channels   = AV_RB8 (st->codec->extradata+21);
1177
        }
1178
        break;
1179
    default:
1180
        break;
1181
    }
1182

    
1183
    return 0;
1184
}
1185

    
1186
static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1187
{
1188
    AVStream *st;
1189
    MOVStreamContext *sc;
1190
    unsigned int i, entries;
1191

    
1192
    if (c->fc->nb_streams < 1)
1193
        return 0;
1194
    st = c->fc->streams[c->fc->nb_streams-1];
1195
    sc = st->priv_data;
1196

    
1197
    get_byte(pb); /* version */
1198
    get_be24(pb); /* flags */
1199

    
1200
    entries = get_be32(pb);
1201

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

    
1204
    if(entries >= UINT_MAX / sizeof(*sc->stsc_data))
1205
        return -1;
1206
    sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
1207
    if (!sc->stsc_data)
1208
        return AVERROR(ENOMEM);
1209
    sc->stsc_count = entries;
1210

    
1211
    for(i=0; i<entries; i++) {
1212
        sc->stsc_data[i].first = get_be32(pb);
1213
        sc->stsc_data[i].count = get_be32(pb);
1214
        sc->stsc_data[i].id = get_be32(pb);
1215
    }
1216
    return 0;
1217
}
1218

    
1219
static int mov_read_stps(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1220
{
1221
    AVStream *st;
1222
    MOVStreamContext *sc;
1223
    unsigned i, entries;
1224

    
1225
    if (c->fc->nb_streams < 1)
1226
        return 0;
1227
    st = c->fc->streams[c->fc->nb_streams-1];
1228
    sc = st->priv_data;
1229

    
1230
    get_be32(pb); // version + flags
1231

    
1232
    entries = get_be32(pb);
1233
    if (entries >= UINT_MAX / sizeof(*sc->stps_data))
1234
        return -1;
1235
    sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
1236
    if (!sc->stps_data)
1237
        return AVERROR(ENOMEM);
1238
    sc->stps_count = entries;
1239

    
1240
    for (i = 0; i < entries; i++) {
1241
        sc->stps_data[i] = get_be32(pb);
1242
        //dprintf(c->fc, "stps %d\n", sc->stps_data[i]);
1243
    }
1244

    
1245
    return 0;
1246
}
1247

    
1248
static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1249
{
1250
    AVStream *st;
1251
    MOVStreamContext *sc;
1252
    unsigned int i, entries;
1253

    
1254
    if (c->fc->nb_streams < 1)
1255
        return 0;
1256
    st = c->fc->streams[c->fc->nb_streams-1];
1257
    sc = st->priv_data;
1258

    
1259
    get_byte(pb); /* version */
1260
    get_be24(pb); /* flags */
1261

    
1262
    entries = get_be32(pb);
1263

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

    
1266
    if(entries >= UINT_MAX / sizeof(int))
1267
        return -1;
1268
    sc->keyframes = av_malloc(entries * sizeof(int));
1269
    if (!sc->keyframes)
1270
        return AVERROR(ENOMEM);
1271
    sc->keyframe_count = entries;
1272

    
1273
    for(i=0; i<entries; i++) {
1274
        sc->keyframes[i] = get_be32(pb);
1275
        //dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
1276
    }
1277
    return 0;
1278
}
1279

    
1280
static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1281
{
1282
    AVStream *st;
1283
    MOVStreamContext *sc;
1284
    unsigned int i, entries, sample_size, field_size, num_bytes;
1285
    GetBitContext gb;
1286
    unsigned char* buf;
1287

    
1288
    if (c->fc->nb_streams < 1)
1289
        return 0;
1290
    st = c->fc->streams[c->fc->nb_streams-1];
1291
    sc = st->priv_data;
1292

    
1293
    get_byte(pb); /* version */
1294
    get_be24(pb); /* flags */
1295

    
1296
    if (atom.type == MKTAG('s','t','s','z')) {
1297
        sample_size = get_be32(pb);
1298
        if (!sc->sample_size) /* do not overwrite value computed in stsd */
1299
            sc->sample_size = sample_size;
1300
        field_size = 32;
1301
    } else {
1302
        sample_size = 0;
1303
        get_be24(pb); /* reserved */
1304
        field_size = get_byte(pb);
1305
    }
1306
    entries = get_be32(pb);
1307

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

    
1310
    sc->sample_count = entries;
1311
    if (sample_size)
1312
        return 0;
1313

    
1314
    if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
1315
        av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
1316
        return -1;
1317
    }
1318

    
1319
    if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
1320
        return -1;
1321
    sc->sample_sizes = av_malloc(entries * sizeof(int));
1322
    if (!sc->sample_sizes)
1323
        return AVERROR(ENOMEM);
1324

    
1325
    num_bytes = (entries*field_size+4)>>3;
1326

    
1327
    buf = av_malloc(num_bytes+FF_INPUT_BUFFER_PADDING_SIZE);
1328
    if (!buf) {
1329
        av_freep(&sc->sample_sizes);
1330
        return AVERROR(ENOMEM);
1331
    }
1332

    
1333
    if (get_buffer(pb, buf, num_bytes) < num_bytes) {
1334
        av_freep(&sc->sample_sizes);
1335
        av_free(buf);
1336
        return -1;
1337
    }
1338

    
1339
    init_get_bits(&gb, buf, 8*num_bytes);
1340

    
1341
    for(i=0; i<entries; i++)
1342
        sc->sample_sizes[i] = get_bits_long(&gb, field_size);
1343

    
1344
    av_free(buf);
1345
    return 0;
1346
}
1347

    
1348
static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1349
{
1350
    AVStream *st;
1351
    MOVStreamContext *sc;
1352
    unsigned int i, entries;
1353
    int64_t duration=0;
1354
    int64_t total_sample_count=0;
1355

    
1356
    if (c->fc->nb_streams < 1)
1357
        return 0;
1358
    st = c->fc->streams[c->fc->nb_streams-1];
1359
    sc = st->priv_data;
1360

    
1361
    get_byte(pb); /* version */
1362
    get_be24(pb); /* flags */
1363
    entries = get_be32(pb);
1364

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

    
1367
    if(entries >= UINT_MAX / sizeof(*sc->stts_data))
1368
        return -1;
1369
    sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
1370
    if (!sc->stts_data)
1371
        return AVERROR(ENOMEM);
1372
    sc->stts_count = entries;
1373

    
1374
    for(i=0; i<entries; i++) {
1375
        int sample_duration;
1376
        int sample_count;
1377

    
1378
        sample_count=get_be32(pb);
1379
        sample_duration = get_be32(pb);
1380
        sc->stts_data[i].count= sample_count;
1381
        sc->stts_data[i].duration= sample_duration;
1382

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

    
1385
        duration+=(int64_t)sample_duration*sample_count;
1386
        total_sample_count+=sample_count;
1387
    }
1388

    
1389
    st->nb_frames= total_sample_count;
1390
    if(duration)
1391
        st->duration= duration;
1392
    return 0;
1393
}
1394

    
1395
static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1396
{
1397
    AVStream *st;
1398
    MOVStreamContext *sc;
1399
    unsigned int i, entries;
1400

    
1401
    if (c->fc->nb_streams < 1)
1402
        return 0;
1403
    st = c->fc->streams[c->fc->nb_streams-1];
1404
    sc = st->priv_data;
1405

    
1406
    get_byte(pb); /* version */
1407
    get_be24(pb); /* flags */
1408
    entries = get_be32(pb);
1409

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

    
1412
    if(entries >= UINT_MAX / sizeof(*sc->ctts_data))
1413
        return -1;
1414
    sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
1415
    if (!sc->ctts_data)
1416
        return AVERROR(ENOMEM);
1417
    sc->ctts_count = entries;
1418

    
1419
    for(i=0; i<entries; i++) {
1420
        int count    =get_be32(pb);
1421
        int duration =get_be32(pb);
1422

    
1423
        sc->ctts_data[i].count   = count;
1424
        sc->ctts_data[i].duration= duration;
1425
        if (duration < 0)
1426
            sc->dts_shift = FFMAX(sc->dts_shift, -duration);
1427
    }
1428

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

    
1431
    return 0;
1432
}
1433

    
1434
static void mov_build_index(MOVContext *mov, AVStream *st)
1435
{
1436
    MOVStreamContext *sc = st->priv_data;
1437
    int64_t current_offset;
1438
    int64_t current_dts = 0;
1439
    unsigned int stts_index = 0;
1440
    unsigned int stsc_index = 0;
1441
    unsigned int stss_index = 0;
1442
    unsigned int stps_index = 0;
1443
    unsigned int i, j;
1444
    uint64_t stream_size = 0;
1445

    
1446
    /* adjust first dts according to edit list */
1447
    if (sc->time_offset) {
1448
        int rescaled = sc->time_offset < 0 ? av_rescale(sc->time_offset, sc->time_scale, mov->time_scale) : sc->time_offset;
1449
        current_dts = -rescaled;
1450
        if (sc->ctts_data && sc->ctts_data[0].duration / sc->stts_data[0].duration > 16) {
1451
            /* more than 16 frames delay, dts are likely wrong
1452
               this happens with files created by iMovie */
1453
            sc->wrong_dts = 1;
1454
            st->codec->has_b_frames = 1;
1455
        }
1456
    }
1457

    
1458
    /* only use old uncompressed audio chunk demuxing when stts specifies it */
1459
    if (!(st->codec->codec_type == CODEC_TYPE_AUDIO &&
1460
          sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
1461
        unsigned int current_sample = 0;
1462
        unsigned int stts_sample = 0;
1463
        unsigned int sample_size;
1464
        unsigned int distance = 0;
1465
        int key_off = sc->keyframes && sc->keyframes[0] == 1;
1466

    
1467
        current_dts -= sc->dts_shift;
1468

    
1469
        for (i = 0; i < sc->chunk_count; i++) {
1470
            current_offset = sc->chunk_offsets[i];
1471
            if (stsc_index + 1 < sc->stsc_count &&
1472
                i + 1 == sc->stsc_data[stsc_index + 1].first)
1473
                stsc_index++;
1474
            for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
1475
                int keyframe = 0;
1476
                if (current_sample >= sc->sample_count) {
1477
                    av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
1478
                    return;
1479
                }
1480

    
1481
                if (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index]) {
1482
                    keyframe = 1;
1483
                    if (stss_index + 1 < sc->keyframe_count)
1484
                        stss_index++;
1485
                } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
1486
                    keyframe = 1;
1487
                    if (stps_index + 1 < sc->stps_count)
1488
                        stps_index++;
1489
                }
1490
                if (keyframe)
1491
                    distance = 0;
1492
                sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
1493
                if(sc->pseudo_stream_id == -1 ||
1494
                   sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
1495
                    av_add_index_entry(st, current_offset, current_dts, sample_size, distance,
1496
                                    keyframe ? AVINDEX_KEYFRAME : 0);
1497
                    dprintf(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
1498
                            "size %d, distance %d, keyframe %d\n", st->index, current_sample,
1499
                            current_offset, current_dts, sample_size, distance, keyframe);
1500
                }
1501

    
1502
                current_offset += sample_size;
1503
                stream_size += sample_size;
1504
                current_dts += sc->stts_data[stts_index].duration;
1505
                distance++;
1506
                stts_sample++;
1507
                current_sample++;
1508
                if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
1509
                    stts_sample = 0;
1510
                    stts_index++;
1511
                }
1512
            }
1513
        }
1514
        if (st->duration > 0)
1515
            st->codec->bit_rate = stream_size*8*sc->time_scale/st->duration;
1516
    } else {
1517
        for (i = 0; i < sc->chunk_count; i++) {
1518
            unsigned chunk_samples;
1519

    
1520
            current_offset = sc->chunk_offsets[i];
1521
            if (stsc_index + 1 < sc->stsc_count &&
1522
                i + 1 == sc->stsc_data[stsc_index + 1].first)
1523
                stsc_index++;
1524
            chunk_samples = sc->stsc_data[stsc_index].count;
1525

    
1526
            if (sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
1527
                av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
1528
                return;
1529
            }
1530

    
1531
            while (chunk_samples > 0) {
1532
                unsigned size, samples;
1533

    
1534
                if (sc->samples_per_frame >= 160) { // gsm
1535
                    samples = sc->samples_per_frame;
1536
                    size = sc->bytes_per_frame;
1537
                } else {
1538
                    if (sc->samples_per_frame > 1) {
1539
                        samples = FFMIN((1024 / sc->samples_per_frame)*
1540
                                        sc->samples_per_frame, chunk_samples);
1541
                        size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
1542
                    } else {
1543
                        samples = FFMIN(1024, chunk_samples);
1544
                        size = samples * sc->sample_size;
1545
                    }
1546
                }
1547

    
1548
                av_add_index_entry(st, current_offset, current_dts, size, 0, AVINDEX_KEYFRAME);
1549
                dprintf(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
1550
                        "size %d, duration %d\n", st->index, i, current_offset, current_dts,
1551
                        size, samples);
1552

    
1553
                current_offset += size;
1554
                current_dts += samples;
1555
                chunk_samples -= samples;
1556
            }
1557
        }
1558
    }
1559
}
1560

    
1561
static int mov_open_dref(ByteIOContext **pb, char *src, MOVDref *ref)
1562
{
1563
    /* try absolute path */
1564
    if (!url_fopen(pb, ref->path, URL_RDONLY))
1565
        return 0;
1566

    
1567
    /* try relative path */
1568
    if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
1569
        char filename[1024];
1570
        char *src_path;
1571
        int i, l;
1572

    
1573
        /* find a source dir */
1574
        src_path = strrchr(src, '/');
1575
        if (src_path)
1576
            src_path++;
1577
        else
1578
            src_path = src;
1579

    
1580
        /* find a next level down to target */
1581
        for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
1582
            if (ref->path[l] == '/') {
1583
                if (i == ref->nlvl_to - 1)
1584
                    break;
1585
                else
1586
                    i++;
1587
            }
1588

    
1589
        /* compose filename if next level down to target was found */
1590
        if (i == ref->nlvl_to - 1) {
1591
            memcpy(filename, src, src_path - src);
1592
            filename[src_path - src] = 0;
1593

    
1594
            for (i = 1; i < ref->nlvl_from; i++)
1595
                av_strlcat(filename, "../", 1024);
1596

    
1597
            av_strlcat(filename, ref->path + l + 1, 1024);
1598

    
1599
            if (!url_fopen(pb, filename, URL_RDONLY))
1600
                return 0;
1601
        }
1602
    }
1603

    
1604
    return AVERROR(ENOENT);
1605
};
1606

    
1607
static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1608
{
1609
    AVStream *st;
1610
    MOVStreamContext *sc;
1611
    int ret;
1612

    
1613
    st = av_new_stream(c->fc, c->fc->nb_streams);
1614
    if (!st) return AVERROR(ENOMEM);
1615
    sc = av_mallocz(sizeof(MOVStreamContext));
1616
    if (!sc) return AVERROR(ENOMEM);
1617

    
1618
    st->priv_data = sc;
1619
    st->codec->codec_type = CODEC_TYPE_DATA;
1620
    sc->ffindex = st->index;
1621

    
1622
    if ((ret = mov_read_default(c, pb, atom)) < 0)
1623
        return ret;
1624

    
1625
    /* sanity checks */
1626
    if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
1627
                            (!sc->sample_size && !sc->sample_count))) {
1628
        av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
1629
               st->index);
1630
        return 0;
1631
    }
1632

    
1633
    if (!sc->time_scale) {
1634
        av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", st->index);
1635
        sc->time_scale = c->time_scale;
1636
        if (!sc->time_scale)
1637
            sc->time_scale = 1;
1638
    }
1639

    
1640
    av_set_pts_info(st, 64, 1, sc->time_scale);
1641

    
1642
    if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1643
        !st->codec->frame_size && sc->stts_count == 1) {
1644
        st->codec->frame_size = av_rescale(sc->stts_data[0].duration,
1645
                                           st->codec->sample_rate, sc->time_scale);
1646
        dprintf(c->fc, "frame size %d\n", st->codec->frame_size);
1647
    }
1648

    
1649
    mov_build_index(c, st);
1650

    
1651
    if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
1652
        MOVDref *dref = &sc->drefs[sc->dref_id - 1];
1653
        if (mov_open_dref(&sc->pb, c->fc->filename, dref) < 0)
1654
            av_log(c->fc, AV_LOG_ERROR,
1655
                   "stream %d, error opening alias: path='%s', dir='%s', "
1656
                   "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
1657
                   st->index, dref->path, dref->dir, dref->filename,
1658
                   dref->volume, dref->nlvl_from, dref->nlvl_to);
1659
    } else
1660
        sc->pb = c->fc->pb;
1661

    
1662
    switch (st->codec->codec_id) {
1663
#if CONFIG_H261_DECODER
1664
    case CODEC_ID_H261:
1665
#endif
1666
#if CONFIG_H263_DECODER
1667
    case CODEC_ID_H263:
1668
#endif
1669
#if CONFIG_H264_DECODER
1670
    case CODEC_ID_H264:
1671
#endif
1672
#if CONFIG_MPEG4_DECODER
1673
    case CODEC_ID_MPEG4:
1674
#endif
1675
        st->codec->width = 0; /* let decoder init width/height */
1676
        st->codec->height= 0;
1677
        break;
1678
    }
1679

    
1680
    /* Do not need those anymore. */
1681
    av_freep(&sc->chunk_offsets);
1682
    av_freep(&sc->stsc_data);
1683
    av_freep(&sc->sample_sizes);
1684
    av_freep(&sc->keyframes);
1685
    av_freep(&sc->stts_data);
1686
    av_freep(&sc->stps_data);
1687

    
1688
    return 0;
1689
}
1690

    
1691
static int mov_read_ilst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1692
{
1693
    int ret;
1694
    c->itunes_metadata = 1;
1695
    ret = mov_read_default(c, pb, atom);
1696
    c->itunes_metadata = 0;
1697
    return ret;
1698
}
1699

    
1700
static int mov_read_meta(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1701
{
1702
    while (atom.size > 8) {
1703
        uint32_t tag = get_le32(pb);
1704
        atom.size -= 4;
1705
        if (tag == MKTAG('h','d','l','r')) {
1706
            url_fseek(pb, -8, SEEK_CUR);
1707
            atom.size += 8;
1708
            return mov_read_default(c, pb, atom);
1709
        }
1710
    }
1711
    return 0;
1712
}
1713

    
1714
static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1715
{
1716
    int i;
1717
    int width;
1718
    int height;
1719
    int64_t disp_transform[2];
1720
    int display_matrix[3][2];
1721
    AVStream *st;
1722
    MOVStreamContext *sc;
1723
    int version;
1724

    
1725
    if (c->fc->nb_streams < 1)
1726
        return 0;
1727
    st = c->fc->streams[c->fc->nb_streams-1];
1728
    sc = st->priv_data;
1729

    
1730
    version = get_byte(pb);
1731
    get_be24(pb); /* flags */
1732
    /*
1733
    MOV_TRACK_ENABLED 0x0001
1734
    MOV_TRACK_IN_MOVIE 0x0002
1735
    MOV_TRACK_IN_PREVIEW 0x0004
1736
    MOV_TRACK_IN_POSTER 0x0008
1737
    */
1738

    
1739
    if (version == 1) {
1740
        get_be64(pb);
1741
        get_be64(pb);
1742
    } else {
1743
        get_be32(pb); /* creation time */
1744
        get_be32(pb); /* modification time */
1745
    }
1746
    st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/
1747
    get_be32(pb); /* reserved */
1748

    
1749
    /* highlevel (considering edits) duration in movie timebase */
1750
    (version == 1) ? get_be64(pb) : get_be32(pb);
1751
    get_be32(pb); /* reserved */
1752
    get_be32(pb); /* reserved */
1753

    
1754
    get_be16(pb); /* layer */
1755
    get_be16(pb); /* alternate group */
1756
    get_be16(pb); /* volume */
1757
    get_be16(pb); /* reserved */
1758

    
1759
    //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
1760
    // they're kept in fixed point format through all calculations
1761
    // ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
1762
    for (i = 0; i < 3; i++) {
1763
        display_matrix[i][0] = get_be32(pb);   // 16.16 fixed point
1764
        display_matrix[i][1] = get_be32(pb);   // 16.16 fixed point
1765
        get_be32(pb);           // 2.30 fixed point (not used)
1766
    }
1767

    
1768
    width = get_be32(pb);       // 16.16 fixed point track width
1769
    height = get_be32(pb);      // 16.16 fixed point track height
1770
    sc->width = width >> 16;
1771
    sc->height = height >> 16;
1772

    
1773
    // transform the display width/height according to the matrix
1774
    // skip this if the display matrix is the default identity matrix
1775
    // or if it is rotating the picture, ex iPhone 3GS
1776
    // to keep the same scale, use [width height 1<<16]
1777
    if (width && height &&
1778
        ((display_matrix[0][0] != 65536  ||
1779
          display_matrix[1][1] != 65536) &&
1780
         !display_matrix[0][1] &&
1781
         !display_matrix[1][0] &&
1782
         !display_matrix[2][0] && !display_matrix[2][1])) {
1783
        for (i = 0; i < 2; i++)
1784
            disp_transform[i] =
1785
                (int64_t)  width  * display_matrix[0][i] +
1786
                (int64_t)  height * display_matrix[1][i] +
1787
                ((int64_t) display_matrix[2][i] << 16);
1788

    
1789
        //sample aspect ratio is new width/height divided by old width/height
1790
        st->sample_aspect_ratio = av_d2q(
1791
            ((double) disp_transform[0] * height) /
1792
            ((double) disp_transform[1] * width), INT_MAX);
1793
    }
1794
    return 0;
1795
}
1796

    
1797
static int mov_read_tfhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1798
{
1799
    MOVFragment *frag = &c->fragment;
1800
    MOVTrackExt *trex = NULL;
1801
    int flags, track_id, i;
1802

    
1803
    get_byte(pb); /* version */
1804
    flags = get_be24(pb);
1805

    
1806
    track_id = get_be32(pb);
1807
    if (!track_id)
1808
        return -1;
1809
    frag->track_id = track_id;
1810
    for (i = 0; i < c->trex_count; i++)
1811
        if (c->trex_data[i].track_id == frag->track_id) {
1812
            trex = &c->trex_data[i];
1813
            break;
1814
        }
1815
    if (!trex) {
1816
        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
1817
        return -1;
1818
    }
1819

    
1820
    if (flags & 0x01) frag->base_data_offset = get_be64(pb);
1821
    else              frag->base_data_offset = frag->moof_offset;
1822
    if (flags & 0x02) frag->stsd_id          = get_be32(pb);
1823
    else              frag->stsd_id          = trex->stsd_id;
1824

    
1825
    frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration;
1826
    frag->size     = flags & 0x10 ? get_be32(pb) : trex->size;
1827
    frag->flags    = flags & 0x20 ? get_be32(pb) : trex->flags;
1828
    dprintf(c->fc, "frag flags 0x%x\n", frag->flags);
1829
    return 0;
1830
}
1831

    
1832
static int mov_read_trex(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1833
{
1834
    MOVTrackExt *trex;
1835

    
1836
    if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
1837
        return -1;
1838
    trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
1839
    if (!trex)
1840
        return AVERROR(ENOMEM);
1841
    c->trex_data = trex;
1842
    trex = &c->trex_data[c->trex_count++];
1843
    get_byte(pb); /* version */
1844
    get_be24(pb); /* flags */
1845
    trex->track_id = get_be32(pb);
1846
    trex->stsd_id  = get_be32(pb);
1847
    trex->duration = get_be32(pb);
1848
    trex->size     = get_be32(pb);
1849
    trex->flags    = get_be32(pb);
1850
    return 0;
1851
}
1852

    
1853
static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1854
{
1855
    MOVFragment *frag = &c->fragment;
1856
    AVStream *st = NULL;
1857
    MOVStreamContext *sc;
1858
    uint64_t offset;
1859
    int64_t dts;
1860
    int data_offset = 0;
1861
    unsigned entries, first_sample_flags = frag->flags;
1862
    int flags, distance, i;
1863

    
1864
    for (i = 0; i < c->fc->nb_streams; i++) {
1865
        if (c->fc->streams[i]->id == frag->track_id) {
1866
            st = c->fc->streams[i];
1867
            break;
1868
        }
1869
    }
1870
    if (!st) {
1871
        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
1872
        return -1;
1873
    }
1874
    sc = st->priv_data;
1875
    if (sc->pseudo_stream_id+1 != frag->stsd_id)
1876
        return 0;
1877
    get_byte(pb); /* version */
1878
    flags = get_be24(pb);
1879
    entries = get_be32(pb);
1880
    dprintf(c->fc, "flags 0x%x entries %d\n", flags, entries);
1881
    if (flags & 0x001) data_offset        = get_be32(pb);
1882
    if (flags & 0x004) first_sample_flags = get_be32(pb);
1883
    if (flags & 0x800) {
1884
        MOVStts *ctts_data;
1885
        if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
1886
            return -1;
1887
        ctts_data = av_realloc(sc->ctts_data,
1888
                               (entries+sc->ctts_count)*sizeof(*sc->ctts_data));
1889
        if (!ctts_data)
1890
            return AVERROR(ENOMEM);
1891
        sc->ctts_data = ctts_data;
1892
    }
1893
    dts = st->duration;
1894
    offset = frag->base_data_offset + data_offset;
1895
    distance = 0;
1896
    dprintf(c->fc, "first sample flags 0x%x\n", first_sample_flags);
1897
    for (i = 0; i < entries; i++) {
1898
        unsigned sample_size = frag->size;
1899
        int sample_flags = i ? frag->flags : first_sample_flags;
1900
        unsigned sample_duration = frag->duration;
1901
        int keyframe;
1902

    
1903
        if (flags & 0x100) sample_duration = get_be32(pb);
1904
        if (flags & 0x200) sample_size     = get_be32(pb);
1905
        if (flags & 0x400) sample_flags    = get_be32(pb);
1906
        if (flags & 0x800) {
1907
            sc->ctts_data[sc->ctts_count].count = 1;
1908
            sc->ctts_data[sc->ctts_count].duration = get_be32(pb);
1909
            sc->ctts_count++;
1910
        }
1911
        if ((keyframe = st->codec->codec_type == CODEC_TYPE_AUDIO ||
1912
             (flags & 0x004 && !i && !sample_flags) || sample_flags & 0x2000000))
1913
            distance = 0;
1914
        av_add_index_entry(st, offset, dts, sample_size, distance,
1915
                           keyframe ? AVINDEX_KEYFRAME : 0);
1916
        dprintf(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
1917
                "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
1918
                offset, dts, sample_size, distance, keyframe);
1919
        distance++;
1920
        dts += sample_duration;
1921
        offset += sample_size;
1922
    }
1923
    frag->moof_offset = offset;
1924
    st->duration = dts;
1925
    return 0;
1926
}
1927

    
1928
/* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
1929
/* like the files created with Adobe Premiere 5.0, for samples see */
1930
/* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
1931
static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1932
{
1933
    int err;
1934

    
1935
    if (atom.size < 8)
1936
        return 0; /* continue */
1937
    if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
1938
        url_fskip(pb, atom.size - 4);
1939
        return 0;
1940
    }
1941
    atom.type = get_le32(pb);
1942
    atom.offset += 8;
1943
    atom.size -= 8;
1944
    if (atom.type != MKTAG('m','d','a','t')) {
1945
        url_fskip(pb, atom.size);
1946
        return 0;
1947
    }
1948
    err = mov_read_mdat(c, pb, atom);
1949
    return err;
1950
}
1951

    
1952
static int mov_read_cmov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
1953
{
1954
#if CONFIG_ZLIB
1955
    ByteIOContext ctx;
1956
    uint8_t *cmov_data;
1957
    uint8_t *moov_data; /* uncompressed data */
1958
    long cmov_len, moov_len;
1959
    int ret = -1;
1960

    
1961
    get_be32(pb); /* dcom atom */
1962
    if (get_le32(pb) != MKTAG('d','c','o','m'))
1963
        return -1;
1964
    if (get_le32(pb) != MKTAG('z','l','i','b')) {
1965
        av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
1966
        return -1;
1967
    }
1968
    get_be32(pb); /* cmvd atom */
1969
    if (get_le32(pb) != MKTAG('c','m','v','d'))
1970
        return -1;
1971
    moov_len = get_be32(pb); /* uncompressed size */
1972
    cmov_len = atom.size - 6 * 4;
1973

    
1974
    cmov_data = av_malloc(cmov_len);
1975
    if (!cmov_data)
1976
        return AVERROR(ENOMEM);
1977
    moov_data = av_malloc(moov_len);
1978
    if (!moov_data) {
1979
        av_free(cmov_data);
1980
        return AVERROR(ENOMEM);
1981
    }
1982
    get_buffer(pb, cmov_data, cmov_len);
1983
    if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
1984
        goto free_and_return;
1985
    if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
1986
        goto free_and_return;
1987
    atom.type = MKTAG('m','o','o','v');
1988
    atom.offset = 0;
1989
    atom.size = moov_len;
1990
#ifdef DEBUG
1991
//    { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
1992
#endif
1993
    ret = mov_read_default(c, &ctx, atom);
1994
free_and_return:
1995
    av_free(moov_data);
1996
    av_free(cmov_data);
1997
    return ret;
1998
#else
1999
    av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
2000
    return -1;
2001
#endif
2002
}
2003

    
2004
/* edit list atom */
2005
static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
2006
{
2007
    MOVStreamContext *sc;
2008
    int i, edit_count;
2009

    
2010
    if (c->fc->nb_streams < 1)
2011
        return 0;
2012
    sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
2013

    
2014
    get_byte(pb); /* version */
2015
    get_be24(pb); /* flags */
2016
    edit_count = get_be32(pb); /* entries */
2017

    
2018
    if((uint64_t)edit_count*12+8 > atom.size)
2019
        return -1;
2020

    
2021
    for(i=0; i<edit_count; i++){
2022
        int time;
2023
        int duration = get_be32(pb); /* Track duration */
2024
        time = get_be32(pb); /* Media time */
2025
        get_be32(pb); /* Media rate */
2026
        if (i == 0 && time >= -1) {
2027
            sc->time_offset = time != -1 ? time : -duration;
2028
        }
2029
    }
2030

    
2031
    if(edit_count > 1)
2032
        av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
2033
               "a/v desync might occur, patch welcome\n");
2034

    
2035
    dprintf(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
2036
    return 0;
2037
}
2038

    
2039
static const MOVParseTableEntry mov_default_parse_table[] = {
2040
{ MKTAG('a','v','s','s'), mov_read_extradata },
2041
{ MKTAG('c','o','6','4'), mov_read_stco },
2042
{ MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
2043
{ MKTAG('d','i','n','f'), mov_read_default },
2044
{ MKTAG('d','r','e','f'), mov_read_dref },
2045
{ MKTAG('e','d','t','s'), mov_read_default },
2046
{ MKTAG('e','l','s','t'), mov_read_elst },
2047
{ MKTAG('e','n','d','a'), mov_read_enda },
2048
{ MKTAG('f','i','e','l'), mov_read_extradata },
2049
{ MKTAG('f','t','y','p'), mov_read_ftyp },
2050
{ MKTAG('g','l','b','l'), mov_read_glbl },
2051
{ MKTAG('h','d','l','r'), mov_read_hdlr },
2052
{ MKTAG('i','l','s','t'), mov_read_ilst },
2053
{ MKTAG('j','p','2','h'), mov_read_extradata },
2054
{ MKTAG('m','d','a','t'), mov_read_mdat },
2055
{ MKTAG('m','d','h','d'), mov_read_mdhd },
2056
{ MKTAG('m','d','i','a'), mov_read_default },
2057
{ MKTAG('m','e','t','a'), mov_read_meta },
2058
{ MKTAG('m','i','n','f'), mov_read_default },
2059
{ MKTAG('m','o','o','f'), mov_read_moof },
2060
{ MKTAG('m','o','o','v'), mov_read_moov },
2061
{ MKTAG('m','v','e','x'), mov_read_default },
2062
{ MKTAG('m','v','h','d'), mov_read_mvhd },
2063
{ MKTAG('S','M','I',' '), mov_read_smi }, /* Sorenson extension ??? */
2064
{ MKTAG('a','l','a','c'), mov_read_extradata }, /* alac specific atom */
2065
{ MKTAG('a','v','c','C'), mov_read_glbl },
2066
{ MKTAG('p','a','s','p'), mov_read_pasp },
2067
{ MKTAG('s','t','b','l'), mov_read_default },
2068
{ MKTAG('s','t','c','o'), mov_read_stco },
2069
{ MKTAG('s','t','p','s'), mov_read_stps },
2070
{ MKTAG('s','t','s','c'), mov_read_stsc },
2071
{ MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
2072
{ MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
2073
{ MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
2074
{ MKTAG('s','t','t','s'), mov_read_stts },
2075
{ MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
2076
{ MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
2077
{ MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
2078
{ MKTAG('t','r','a','k'), mov_read_trak },
2079
{ MKTAG('t','r','a','f'), mov_read_default },
2080
{ MKTAG('t','r','e','x'), mov_read_trex },
2081
{ MKTAG('t','r','u','n'), mov_read_trun },
2082
{ MKTAG('u','d','t','a'), mov_read_default },
2083
{ MKTAG('w','a','v','e'), mov_read_wave },
2084
{ MKTAG('e','s','d','s'), mov_read_esds },
2085
{ MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
2086
{ MKTAG('c','m','o','v'), mov_read_cmov },
2087
{ 0, NULL }
2088
};
2089

    
2090
static int mov_probe(AVProbeData *p)
2091
{
2092
    unsigned int offset;
2093
    uint32_t tag;
2094
    int score = 0;
2095

    
2096
    /* check file header */
2097
    offset = 0;
2098
    for(;;) {
2099
        /* ignore invalid offset */
2100
        if ((offset + 8) > (unsigned int)p->buf_size)
2101
            return score;
2102
        tag = AV_RL32(p->buf + offset + 4);
2103
        switch(tag) {
2104
        /* check for obvious tags */
2105
        case MKTAG('j','P',' ',' '): /* jpeg 2000 signature */
2106
        case MKTAG('m','o','o','v'):
2107
        case MKTAG('m','d','a','t'):
2108
        case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
2109
        case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
2110
        case MKTAG('f','t','y','p'):
2111
            return AVPROBE_SCORE_MAX;
2112
        /* those are more common words, so rate then a bit less */
2113
        case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
2114
        case MKTAG('w','i','d','e'):
2115
        case MKTAG('f','r','e','e'):
2116
        case MKTAG('j','u','n','k'):
2117
        case MKTAG('p','i','c','t'):
2118
            return AVPROBE_SCORE_MAX - 5;
2119
        case MKTAG(0x82,0x82,0x7f,0x7d):
2120
        case MKTAG('s','k','i','p'):
2121
        case MKTAG('u','u','i','d'):
2122
        case MKTAG('p','r','f','l'):
2123
            offset = AV_RB32(p->buf+offset) + offset;
2124
            /* if we only find those cause probedata is too small at least rate them */
2125
            score = AVPROBE_SCORE_MAX - 50;
2126
            break;
2127
        default:
2128
            /* unrecognized tag */
2129
            return score;
2130
        }
2131
    }
2132
    return score;
2133
}
2134

    
2135
static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
2136
{
2137
    MOVContext *mov = s->priv_data;
2138
    ByteIOContext *pb = s->pb;
2139
    int err;
2140
    MOVAtom atom = { 0, 0, 0 };
2141

    
2142
    mov->fc = s;
2143
    /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
2144
    if(!url_is_streamed(pb))
2145
        atom.size = url_fsize(pb);
2146
    else
2147
        atom.size = INT64_MAX;
2148

    
2149
    /* check MOV header */
2150
    if ((err = mov_read_default(mov, pb, atom)) < 0) {
2151
        av_log(s, AV_LOG_ERROR, "error reading header: %d\n", err);
2152
        return err;
2153
    }
2154
    if (!mov->found_moov) {
2155
        av_log(s, AV_LOG_ERROR, "moov atom not found\n");
2156
        return -1;
2157
    }
2158
    dprintf(mov->fc, "on_parse_exit_offset=%lld\n", url_ftell(pb));
2159

    
2160
    return 0;
2161
}
2162

    
2163
static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
2164
{
2165
    AVIndexEntry *sample = NULL;
2166
    int64_t best_dts = INT64_MAX;
2167
    int i;
2168
    for (i = 0; i < s->nb_streams; i++) {
2169
        AVStream *avst = s->streams[i];
2170
        MOVStreamContext *msc = avst->priv_data;
2171
        if (msc->pb && msc->current_sample < avst->nb_index_entries) {
2172
            AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
2173
            int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
2174
            dprintf(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
2175
            if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) ||
2176
                (!url_is_streamed(s->pb) &&
2177
                 ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
2178
                 ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
2179
                  (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
2180
                sample = current_sample;
2181
                best_dts = dts;
2182
                *st = avst;
2183
            }
2184
        }
2185
    }
2186
    return sample;
2187
}
2188

    
2189
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
2190
{
2191
    MOVContext *mov = s->priv_data;
2192
    MOVStreamContext *sc;
2193
    AVIndexEntry *sample;
2194
    AVStream *st = NULL;
2195
    int ret;
2196
 retry:
2197
    sample = mov_find_next_sample(s, &st);
2198
    if (!sample) {
2199
        mov->found_mdat = 0;
2200
        if (!url_is_streamed(s->pb) ||
2201
            mov_read_default(mov, s->pb, (MOVAtom){ 0, 0, INT64_MAX }) < 0 ||
2202
            url_feof(s->pb))
2203
            return AVERROR_EOF;
2204
        dprintf(s, "read fragments, offset 0x%llx\n", url_ftell(s->pb));
2205
        goto retry;
2206
    }
2207
    sc = st->priv_data;
2208
    /* must be done just before reading, to avoid infinite loop on sample */
2209
    sc->current_sample++;
2210

    
2211
    if (st->discard != AVDISCARD_ALL) {
2212
        if (url_fseek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
2213
            av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
2214
                   sc->ffindex, sample->pos);
2215
            return -1;
2216
        }
2217
        ret = av_get_packet(sc->pb, pkt, sample->size);
2218
        if (ret < 0)
2219
            return ret;
2220
#if CONFIG_DV_DEMUXER
2221
        if (mov->dv_demux && sc->dv_audio_container) {
2222
            dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);
2223
            av_free(pkt->data);
2224
            pkt->size = 0;
2225
            ret = dv_get_packet(mov->dv_demux, pkt);
2226
            if (ret < 0)
2227
                return ret;
2228
        }
2229
#endif
2230
    }
2231

    
2232
    pkt->stream_index = sc->ffindex;
2233
    pkt->dts = sample->timestamp;
2234
    if (sc->ctts_data) {
2235
        pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
2236
        /* update ctts context */
2237
        sc->ctts_sample++;
2238
        if (sc->ctts_index < sc->ctts_count &&
2239
            sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
2240
            sc->ctts_index++;
2241
            sc->ctts_sample = 0;
2242
        }
2243
        if (sc->wrong_dts)
2244
            pkt->dts = AV_NOPTS_VALUE;
2245
    } else {
2246
        int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
2247
            st->index_entries[sc->current_sample].timestamp : st->duration;
2248
        pkt->duration = next_dts - pkt->dts;
2249
        pkt->pts = pkt->dts;
2250
    }
2251
    if (st->discard == AVDISCARD_ALL)
2252
        goto retry;
2253
    pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0;
2254
    pkt->pos = sample->pos;
2255
    dprintf(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
2256
            pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
2257
    return 0;
2258
}
2259

    
2260
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
2261
{
2262
    MOVStreamContext *sc = st->priv_data;
2263
    int sample, time_sample;
2264
    int i;
2265

    
2266
    sample = av_index_search_timestamp(st, timestamp, flags);
2267
    dprintf(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
2268
    if (sample < 0) /* not sure what to do */
2269
        return -1;
2270
    sc->current_sample = sample;
2271
    dprintf(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
2272
    /* adjust ctts index */
2273
    if (sc->ctts_data) {
2274
        time_sample = 0;
2275
        for (i = 0; i < sc->ctts_count; i++) {
2276
            int next = time_sample + sc->ctts_data[i].count;
2277
            if (next > sc->current_sample) {
2278
                sc->ctts_index = i;
2279
                sc->ctts_sample = sc->current_sample - time_sample;
2280
                break;
2281
            }
2282
            time_sample = next;
2283
        }
2284
    }
2285
    return sample;
2286
}
2287

    
2288
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2289
{
2290
    AVStream *st;
2291
    int64_t seek_timestamp, timestamp;
2292
    int sample;
2293
    int i;
2294

    
2295
    if (stream_index >= s->nb_streams)
2296
        return -1;
2297
    if (sample_time < 0)
2298
        sample_time = 0;
2299

    
2300
    st = s->streams[stream_index];
2301
    sample = mov_seek_stream(s, st, sample_time, flags);
2302
    if (sample < 0)
2303
        return -1;
2304

    
2305
    /* adjust seek timestamp to found sample timestamp */
2306
    seek_timestamp = st->index_entries[sample].timestamp;
2307

    
2308
    for (i = 0; i < s->nb_streams; i++) {
2309
        st = s->streams[i];
2310
        if (stream_index == i)
2311
            continue;
2312

    
2313
        timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
2314
        mov_seek_stream(s, st, timestamp, flags);
2315
    }
2316
    return 0;
2317
}
2318

    
2319
static int mov_read_close(AVFormatContext *s)
2320
{
2321
    MOVContext *mov = s->priv_data;
2322
    int i, j;
2323

    
2324
    for (i = 0; i < s->nb_streams; i++) {
2325
        AVStream *st = s->streams[i];
2326
        MOVStreamContext *sc = st->priv_data;
2327

    
2328
        av_freep(&sc->ctts_data);
2329
        for (j = 0; j < sc->drefs_count; j++) {
2330
            av_freep(&sc->drefs[j].path);
2331
            av_freep(&sc->drefs[j].dir);
2332
        }
2333
        av_freep(&sc->drefs);
2334
        if (sc->pb && sc->pb != s->pb)
2335
            url_fclose(sc->pb);
2336

    
2337
        av_freep(&st->codec->palctrl);
2338
    }
2339

    
2340
    if (mov->dv_demux) {
2341
        for(i = 0; i < mov->dv_fctx->nb_streams; i++) {
2342
            av_freep(&mov->dv_fctx->streams[i]->codec);
2343
            av_freep(&mov->dv_fctx->streams[i]);
2344
        }
2345
        av_freep(&mov->dv_fctx);
2346
        av_freep(&mov->dv_demux);
2347
    }
2348

    
2349
    av_freep(&mov->trex_data);
2350

    
2351
    return 0;
2352
}
2353

    
2354
AVInputFormat mov_demuxer = {
2355
    "mov,mp4,m4a,3gp,3g2,mj2",
2356
    NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
2357
    sizeof(MOVContext),
2358
    mov_probe,
2359
    mov_read_header,
2360
    mov_read_packet,
2361
    mov_read_close,
2362
    mov_read_seek,
2363
};