PeerStreamer

/*

 * MOV demuxer

 * Copyright (c) 2001 Fabrice Bellard

 * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include <limits.h>

//#define DEBUG

//#define DEBUG_METADATA

//#define MOV_EXPORT_ALL_METADATA

#include "libavutil/intreadwrite.h"

#include "libavutil/avstring.h"

#include "avformat.h"

#include "riff.h"

#include "isom.h"

#include "libavcodec/get_bits.h"

#if CONFIG_ZLIB

#include <zlib.h>

#endif

/*

 * First version by Francois Revol revol@free.fr

 * Seek function by Gael Chardon gael.dev@4now.net

 *

 * Features and limitations:

 * - reads most of the QT files I have (at least the structure),

 *   Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html

 * - the code is quite ugly... maybe I won't do it recursive next time :-)

 *

 * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/

 * when coding this :) (it's a writer anyway)

 *

 * Reference documents:

 * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt

 * Apple:

 *  http://developer.apple.com/documentation/QuickTime/QTFF/

 *  http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf

 * QuickTime is a trademark of Apple (AFAIK :))

 */

#include "qtpalette.h"

#undef NDEBUG

#include <assert.h>

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

/* those functions parse an atom */

/* return code:

  0: continue to parse next atom

 <0: error occurred, exit

*/

/* links atom IDs to parse functions */

typedef struct MOVParseTableEntry {

    uint32_t type;

    int (*parse)(MOVContext *ctx, ByteIOContext *pb, MOVAtom atom);

} MOVParseTableEntry;

static const MOVParseTableEntry mov_default_parse_table[];

static int mov_metadata_trkn(MOVContext *c, ByteIOContext *pb, unsigned len)

{

    char buf[16];

    get_be16(pb); // unknown

    snprintf(buf, sizeof(buf), "%d", get_be16(pb));

    av_metadata_set2(&c->fc->metadata, "track", buf, 0);

    get_be16(pb); // total tracks

    return 0;

}

static const uint32_t mac_to_unicode[128] = {

    0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,

    0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,

    0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,

    0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,

    0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,

    0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,

    0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,

    0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,

    0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,

    0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,

    0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,

    0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,

    0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,

    0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,

    0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,

    0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,

};

static int mov_read_mac_string(MOVContext *c, ByteIOContext *pb, int len,

                               char *dst, int dstlen)

{

    char *p = dst;

    char *end = dst+dstlen-1;

    int i;

    for (i = 0; i < len; i++) {

        uint8_t t, c = get_byte(pb);

        if (c < 0x80 && p < end)

            *p++ = c;

        else

            PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);

    }

    *p = 0;

    return p - dst;

}

static int mov_read_udta_string(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

#ifdef MOV_EXPORT_ALL_METADATA

    char tmp_key[5];

#endif

    char str[1024], key2[16], language[4] = {0};

    const char *key = NULL;

    uint16_t str_size, langcode = 0;

    uint32_t data_type = 0;

    int (*parse)(MOVContext*, ByteIOContext*, unsigned) = NULL;

    switch (atom.type) {

    case MKTAG(0xa9,'n','a','m'): key = "title";     break;

    case MKTAG(0xa9,'a','u','t'):

    case MKTAG(0xa9,'A','R','T'): key = "artist";    break;

    case MKTAG(0xa9,'w','r','t'): key = "composer";  break;

    case MKTAG( 'c','p','r','t'):

    case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;

    case MKTAG(0xa9,'c','m','t'):

    case MKTAG(0xa9,'i','n','f'): key = "comment";   break;

    case MKTAG(0xa9,'a','l','b'): key = "album";     break;

    case MKTAG(0xa9,'d','a','y'): key = "date";      break;

    case MKTAG(0xa9,'g','e','n'): key = "genre";     break;

    case MKTAG(0xa9,'t','o','o'):

    case MKTAG(0xa9,'s','w','r'): key = "encoder";   break;

    case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;

    case MKTAG( 'd','e','s','c'): key = "description";break;

    case MKTAG( 'l','d','e','s'): key = "synopsis";  break;

    case MKTAG( 't','v','s','h'): key = "show";      break;

    case MKTAG( 't','v','e','n'): key = "episode_id";break;

    case MKTAG( 't','v','n','n'): key = "network";   break;

    case MKTAG( 't','r','k','n'): key = "track";

        parse = mov_metadata_trkn; break;

    }

    if (c->itunes_metadata && atom.size > 8) {

        int data_size = get_be32(pb);

        int tag = get_le32(pb);

        if (tag == MKTAG('d','a','t','a')) {

            data_type = get_be32(pb); // type

            get_be32(pb); // unknown

            str_size = data_size - 16;

            atom.size -= 16;

        } else return 0;

    } else if (atom.size > 4 && key && !c->itunes_metadata) {

        str_size = get_be16(pb); // string length

        langcode = get_be16(pb);

        ff_mov_lang_to_iso639(langcode, language);

        atom.size -= 4;

    } else

        str_size = atom.size;

#ifdef MOV_EXPORT_ALL_METADATA

    if (!key) {

        snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);

        key = tmp_key;

    }

#endif

    if (!key)

        return 0;

    if (atom.size < 0)

        return -1;

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

    if (parse)

        parse(c, pb, str_size);

    else {

        if (data_type == 3 || (data_type == 0 && langcode < 0x800)) { // MAC Encoded

            mov_read_mac_string(c, pb, str_size, str, sizeof(str));

        } else {

            get_buffer(pb, str, str_size);

            str[str_size] = 0;

        }

        av_metadata_set2(&c->fc->metadata, key, str, 0);

        if (*language && strcmp(language, "und")) {

            snprintf(key2, sizeof(key2), "%s-%s", key, language);

            av_metadata_set2(&c->fc->metadata, key2, str, 0);

        }

    }

#ifdef DEBUG_METADATA

    av_log(c->fc, AV_LOG_DEBUG, "lang \"%3s\" ", language);

    av_log(c->fc, AV_LOG_DEBUG, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %lld\n",

           key, str, (char*)&atom.type, str_size, atom.size);

#endif

    return 0;

}

static int mov_read_chpl(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    int64_t start;

    int i, nb_chapters, str_len, version;

    char str[256+1];

    if ((atom.size -= 5) < 0)

        return 0;

    version = get_byte(pb);

    get_be24(pb);

    if (version)

        get_be32(pb); // ???

    nb_chapters = get_byte(pb);

    for (i = 0; i < nb_chapters; i++) {

        if (atom.size < 9)

            return 0;

        start = get_be64(pb);

        str_len = get_byte(pb);

        if ((atom.size -= 9+str_len) < 0)

            return 0;

        get_buffer(pb, str, str_len);

        str[str_len] = 0;

        ff_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);

    }

    return 0;

}

static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    int64_t total_size = 0;

    MOVAtom a;

    int i;

    if (atom.size < 0)

        atom.size = INT64_MAX;

    while (total_size + 8 < atom.size && !url_feof(pb)) {

        int (*parse)(MOVContext*, ByteIOContext*, MOVAtom) = NULL;

        a.size = atom.size;

        a.type=0;

        if(atom.size >= 8) {

            a.size = get_be32(pb);

            a.type = get_le32(pb);

        }

        dprintf(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",

                a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);

        total_size += 8;

        if (a.size == 1) { /* 64 bit extended size */

            a.size = get_be64(pb) - 8;

            total_size += 8;

        }

        if (a.size == 0) {

            a.size = atom.size - total_size;

            if (a.size <= 8)

                break;

        }

        a.size -= 8;

        if(a.size < 0)

            break;

        a.size = FFMIN(a.size, atom.size - total_size);

        for (i = 0; mov_default_parse_table[i].type; i++)

            if (mov_default_parse_table[i].type == a.type) {

                parse = mov_default_parse_table[i].parse;

                break;

            }

        // container is user data

        if (!parse && (atom.type == MKTAG('u','d','t','a') ||

                       atom.type == MKTAG('i','l','s','t')))

            parse = mov_read_udta_string;

        if (!parse) { /* skip leaf atoms data */

            url_fskip(pb, a.size);

        } else {

            int64_t start_pos = url_ftell(pb);

            int64_t left;

            int err = parse(c, pb, a);

            if (err < 0)

                return err;

            if (c->found_moov && c->found_mdat &&

                (url_is_streamed(pb) || start_pos + a.size == url_fsize(pb)))

                return 0;

            left = a.size - url_ftell(pb) + start_pos;

            if (left > 0) /* skip garbage at atom end */

                url_fskip(pb, left);

        }

        total_size += a.size;

    }

    if (total_size < atom.size && atom.size < 0x7ffff)

        url_fskip(pb, atom.size - total_size);

    return 0;

}

static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    MOVStreamContext *sc;

    int entries, i, j;

    if (c->fc->nb_streams < 1)

        return 0;

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

    sc = st->priv_data;

    get_be32(pb); // version + flags

    entries = get_be32(pb);

    if (entries >= UINT_MAX / sizeof(*sc->drefs))

        return -1;

    sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));

    if (!sc->drefs)

        return AVERROR(ENOMEM);

    sc->drefs_count = entries;

    for (i = 0; i < sc->drefs_count; i++) {

        MOVDref *dref = &sc->drefs[i];

        uint32_t size = get_be32(pb);

        int64_t next = url_ftell(pb) + size - 4;

        if (size < 12)

            return -1;

        dref->type = get_le32(pb);

        get_be32(pb); // version + flags

        dprintf(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);

        if (dref->type == MKTAG('a','l','i','s') && size > 150) {

            /* macintosh alias record */

            uint16_t volume_len, len;

            int16_t type;

            url_fskip(pb, 10);

            volume_len = get_byte(pb);

            volume_len = FFMIN(volume_len, 27);

            get_buffer(pb, dref->volume, 27);

            dref->volume[volume_len] = 0;

            av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);

            url_fskip(pb, 12);

            len = get_byte(pb);

            len = FFMIN(len, 63);

            get_buffer(pb, dref->filename, 63);

            dref->filename[len] = 0;

            av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);

            url_fskip(pb, 16);

            /* read next level up_from_alias/down_to_target */

            dref->nlvl_from = get_be16(pb);

            dref->nlvl_to   = get_be16(pb);

            av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",

                   dref->nlvl_from, dref->nlvl_to);

            url_fskip(pb, 16);

            for (type = 0; type != -1 && url_ftell(pb) < next; ) {

                type = get_be16(pb);

                len = get_be16(pb);

                av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);

                if (len&1)

                    len += 1;

                if (type == 2) { // absolute path

                    av_free(dref->path);

                    dref->path = av_mallocz(len+1);

                    if (!dref->path)

                        return AVERROR(ENOMEM);

                    get_buffer(pb, dref->path, len);

                    if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {

                        len -= volume_len;

                        memmove(dref->path, dref->path+volume_len, len);

                        dref->path[len] = 0;

                    }

                    for (j = 0; j < len; j++)

                        if (dref->path[j] == ':')

                            dref->path[j] = '/';

                    av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);

                } else if (type == 0) { // directory name

                    av_free(dref->dir);

                    dref->dir = av_malloc(len+1);

                    if (!dref->dir)

                        return AVERROR(ENOMEM);

                    get_buffer(pb, dref->dir, len);

                    dref->dir[len] = 0;

                    for (j = 0; j < len; j++)

                        if (dref->dir[j] == ':')

                            dref->dir[j] = '/';

                    av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);

                } else

                    url_fskip(pb, len);

            }

        }

        url_fseek(pb, next, SEEK_SET);

    }

    return 0;

}

static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    uint32_t type;

    uint32_t ctype;

    if (c->fc->nb_streams < 1) // meta before first trak

        return 0;

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

    get_byte(pb); /* version */

    get_be24(pb); /* flags */

    /* component type */

    ctype = get_le32(pb);

    type = get_le32(pb); /* component subtype */

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

    dprintf(c->fc, "stype= %.4s\n", (char*)&type);

    if     (type == MKTAG('v','i','d','e'))

        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

    else if(type == MKTAG('s','o','u','n'))

        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

    else if(type == MKTAG('m','1','a',' '))

        st->codec->codec_id = CODEC_ID_MP2;

    else if(type == MKTAG('s','u','b','p'))

        st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

    get_be32(pb); /* component  manufacture */

    get_be32(pb); /* component flags */

    get_be32(pb); /* component flags mask */

    return 0;

}

int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    int tag, len;

    if (fc->nb_streams < 1)

        return 0;

    st = fc->streams[fc->nb_streams-1];

    get_be32(pb); /* version + flags */

    len = ff_mp4_read_descr(fc, pb, &tag);

    if (tag == MP4ESDescrTag) {

        get_be16(pb); /* ID */

        get_byte(pb); /* priority */

    } else

        get_be16(pb); /* ID */

    len = ff_mp4_read_descr(fc, pb, &tag);

    if (tag == MP4DecConfigDescrTag)

        ff_mp4_read_dec_config_descr(fc, st, pb);

    return 0;

}

static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    return ff_mov_read_esds(c->fc, pb, atom);

}

static int mov_read_dac3(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    int ac3info, acmod, lfeon;

    if (c->fc->nb_streams < 1)

        return 0;

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

    ac3info = get_be24(pb);

    acmod = (ac3info >> 11) & 0x7;

    lfeon = (ac3info >> 10) & 0x1;

    st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;

    return 0;

}

static int mov_read_pasp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    const int num = get_be32(pb);

    const int den = get_be32(pb);

    AVStream *st;

    if (c->fc->nb_streams < 1)

        return 0;

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

    if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default

        (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {

        av_log(c->fc, AV_LOG_WARNING,

               "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",

               st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,

               num, den);

    } else if (den != 0) {

        st->sample_aspect_ratio.num = num;

        st->sample_aspect_ratio.den = den;

    }

    return 0;

}

/* this atom contains actual media data */

static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    if(atom.size == 0) /* wrong one (MP4) */

        return 0;

    c->found_mdat=1;

    return 0; /* now go for moov */

}

/* read major brand, minor version and compatible brands and store them as metadata */

static int mov_read_ftyp(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    uint32_t minor_ver;

    int comp_brand_size;

    char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */

    char* comp_brands_str;

    uint8_t type[5] = {0};

    get_buffer(pb, type, 4);

    if (strcmp(type, "qt  "))

        c->isom = 1;

    av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);

    av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);

    minor_ver = get_be32(pb); /* minor version */

    snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);

    av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);

    comp_brand_size = atom.size - 8;

    if (comp_brand_size < 0)

        return -1;

    comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */

    if (!comp_brands_str)

        return AVERROR(ENOMEM);

    get_buffer(pb, comp_brands_str, comp_brand_size);

    comp_brands_str[comp_brand_size] = 0;

    av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);

    av_freep(&comp_brands_str);

    return 0;

}

/* this atom should contain all header atoms */

static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    if (mov_read_default(c, pb, atom) < 0)

        return -1;

    /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */

    /* so we don't parse the whole file if over a network */

    c->found_moov=1;

    return 0; /* now go for mdat */

}

static int mov_read_moof(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    c->fragment.moof_offset = url_ftell(pb) - 8;

    dprintf(c->fc, "moof offset %llx\n", c->fragment.moof_offset);

    return mov_read_default(c, pb, atom);

}

static void mov_metadata_creation_time(AVMetadata **metadata, time_t time)

{

    char buffer[32];

    if (time) {

        struct tm *ptm;

        time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */

        ptm = gmtime(&time);

        if (!ptm) return;

        strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);

        av_metadata_set2(metadata, "creation_time", buffer, 0);

    }

}

static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    MOVStreamContext *sc;

    int version;

    char language[4] = {0};

    unsigned lang;

    time_t creation_time;

    if (c->fc->nb_streams < 1)

        return 0;

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

    sc = st->priv_data;

    version = get_byte(pb);

    if (version > 1)

        return -1; /* unsupported */

    get_be24(pb); /* flags */

    if (version == 1) {

        creation_time = get_be64(pb);

        get_be64(pb);

    } else {

        creation_time = get_be32(pb);

        get_be32(pb); /* modification time */

    }

    mov_metadata_creation_time(&st->metadata, creation_time);

    sc->time_scale = get_be32(pb);

    st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */

    lang = get_be16(pb); /* language */

    if (ff_mov_lang_to_iso639(lang, language))

        av_metadata_set2(&st->metadata, "language", language, 0);

    get_be16(pb); /* quality */

    return 0;

}

static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    time_t creation_time;

    int version = get_byte(pb); /* version */

    get_be24(pb); /* flags */

    if (version == 1) {

        creation_time = get_be64(pb);

        get_be64(pb);

    } else {

        creation_time = get_be32(pb);

        get_be32(pb); /* modification time */

    }

    mov_metadata_creation_time(&c->fc->metadata, creation_time);

    c->time_scale = get_be32(pb); /* time scale */

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

    c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */

    get_be32(pb); /* preferred scale */

    get_be16(pb); /* preferred volume */

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

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

    get_be32(pb); /* preview time */

    get_be32(pb); /* preview duration */

    get_be32(pb); /* poster time */

    get_be32(pb); /* selection time */

    get_be32(pb); /* selection duration */

    get_be32(pb); /* current time */

    get_be32(pb); /* next track ID */

    return 0;

}

static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    if (c->fc->nb_streams < 1)

        return 0;

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

    if((uint64_t)atom.size > (1<<30))

        return -1;

    // currently SVQ3 decoder expect full STSD header - so let's fake it

    // this should be fixed and just SMI header should be passed

    av_free(st->codec->extradata);

    st->codec->extradata = av_mallocz(atom.size + 0x5a + FF_INPUT_BUFFER_PADDING_SIZE);

    if (!st->codec->extradata)

        return AVERROR(ENOMEM);

    st->codec->extradata_size = 0x5a + atom.size;

    memcpy(st->codec->extradata, "SVQ3", 4); // fake

    get_buffer(pb, st->codec->extradata + 0x5a, atom.size);

    dprintf(c->fc, "Reading SMI %"PRId64"  %s\n", atom.size, st->codec->extradata + 0x5a);

    return 0;

}

static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    int little_endian;

    if (c->fc->nb_streams < 1)

        return 0;

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

    little_endian = get_be16(pb);

    dprintf(c->fc, "enda %d\n", little_endian);

    if (little_endian == 1) {

        switch (st->codec->codec_id) {

        case CODEC_ID_PCM_S24BE:

            st->codec->codec_id = CODEC_ID_PCM_S24LE;

            break;

        case CODEC_ID_PCM_S32BE:

            st->codec->codec_id = CODEC_ID_PCM_S32LE;

            break;

        case CODEC_ID_PCM_F32BE:

            st->codec->codec_id = CODEC_ID_PCM_F32LE;

            break;

        case CODEC_ID_PCM_F64BE:

            st->codec->codec_id = CODEC_ID_PCM_F64LE;

            break;

        default:

            break;

        }

    }

    return 0;

}

/* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */

static int mov_read_extradata(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    uint64_t size;

    uint8_t *buf;

    if (c->fc->nb_streams < 1) // will happen with jp2 files

        return 0;

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

    size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;

    if(size > INT_MAX || (uint64_t)atom.size > INT_MAX)

        return -1;

    buf= av_realloc(st->codec->extradata, size);

    if(!buf)

        return -1;

    st->codec->extradata= buf;

    buf+= st->codec->extradata_size;

    st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;

    AV_WB32(       buf    , atom.size + 8);

    AV_WL32(       buf + 4, atom.type);

    get_buffer(pb, buf + 8, atom.size);

    return 0;

}

static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    if (c->fc->nb_streams < 1)

        return 0;

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

    if((uint64_t)atom.size > (1<<30))

        return -1;

    if (st->codec->codec_id == CODEC_ID_QDM2) {

        // pass all frma atom to codec, needed at least for QDM2

        av_free(st->codec->extradata);

        st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);

        if (!st->codec->extradata)

            return AVERROR(ENOMEM);

        st->codec->extradata_size = atom.size;

        get_buffer(pb, st->codec->extradata, atom.size);

    } else if (atom.size > 8) { /* to read frma, esds atoms */

        if (mov_read_default(c, pb, atom) < 0)

            return -1;

    } else

        url_fskip(pb, atom.size);

    return 0;

}

/**

 * This function reads atom content and puts data in extradata without tag

 * nor size unlike mov_read_extradata.

 */

static int mov_read_glbl(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    if (c->fc->nb_streams < 1)

        return 0;

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

    if((uint64_t)atom.size > (1<<30))

        return -1;

    av_free(st->codec->extradata);

    st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);

    if (!st->codec->extradata)

        return AVERROR(ENOMEM);

    st->codec->extradata_size = atom.size;

    get_buffer(pb, st->codec->extradata, atom.size);

    return 0;

}

/**

 * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,

 * but can have extradata appended at the end after the 40 bytes belonging

 * to the struct.

 */

static int mov_read_strf(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    if (c->fc->nb_streams < 1)

        return 0;

    if (atom.size <= 40)

        return 0;

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

    if((uint64_t)atom.size > (1<<30))

        return -1;

    av_free(st->codec->extradata);

    st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);

    if (!st->codec->extradata)

        return AVERROR(ENOMEM);

    st->codec->extradata_size = atom.size - 40;

    url_fskip(pb, 40);

    get_buffer(pb, st->codec->extradata, atom.size - 40);

    return 0;

}

static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOVAtom atom)

{

    AVStream *st;

    MOVStreamContext *sc;

    unsigned int i, entries;

    if (c->fc->nb_streams < 1)

        return 0;

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

    sc = st->priv_data;

    get_byte(pb); /* version */

    get_be24(pb); /* flags */

    entries = get_be32(pb);

    if(entries >= UINT_MAX/sizeof(int64_t))

        return -1;

    sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));

    if (!sc->chunk_offsets)

        return AVERROR(ENOMEM);

    sc->chunk_count = entries;

    if      (atom.type == MKTAG('s','t','c','o'))

        for(i=0; i<entries; i++)

            sc->chunk_offsets[i] = get_be32(pb);

    else if (atom.type == MKTAG('c','o','6','4'))

        for(i=0; i<entries; i++)

            sc->chunk_offsets[i] = get_be64(pb);

    else

        return -1;

    return 0;

}

/**

 * Compute codec id for 'lpcm' tag.

 * See CoreAudioTypes and AudioStreamBasicDescription at Apple.

 */

enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags)

{

    if (flags & 1) { // floating point

        if (flags & 2) { // big endian

            if      (bps == 32) return CODEC_ID_PCM_F32BE;

            else if (bps == 64) return CODEC_ID_PCM_F64BE;

        } else {

            if      (bps == 32) return CODEC_ID_PCM_F32LE;

            else if (bps == 64) return CODEC_ID_PCM_F64LE;

        }

    } else {

        if (flags & 2) {

            if      (bps == 8)

                // signed integer

                if (flags & 4)  return CODEC_ID_PCM_S8;

                else            return CODEC_ID_PCM_U8;