PeerStreamer

/*

 * MOV, 3GP, MP4 muxer

 * Copyright (c) 2003 Thomas Raivio

 * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>

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

 *

 * This file is part of Libav.

 *

 * Libav 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.

 *

 * Libav 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 Libav; if not, write to the Free Software

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

 */

#include "movenc.h"

#include "avformat.h"

#include "avio_internal.h"

#include "riff.h"

#include "avio.h"

#include "isom.h"

#include "avc.h"

#include "libavcodec/get_bits.h"

#include "libavcodec/put_bits.h"

#include "internal.h"

#include "libavutil/avstring.h"

#undef NDEBUG

#include <assert.h>

//FIXME support 64 bit variant with wide placeholders

static int64_t updateSize(AVIOContext *pb, int64_t pos)

{

    int64_t curpos = avio_tell(pb);

    avio_seek(pb, pos, SEEK_SET);

    avio_wb32(pb, curpos - pos); /* rewrite size */

    avio_seek(pb, curpos, SEEK_SET);

    return curpos - pos;

}

/* Chunk offset atom */

static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)

{

    int i;

    int mode64 = 0; //   use 32 bit size variant if possible

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    if (pos > UINT32_MAX) {

        mode64 = 1;

        ffio_wfourcc(pb, "co64");

    } else

        ffio_wfourcc(pb, "stco");

    avio_wb32(pb, 0); /* version & flags */

    avio_wb32(pb, track->entry); /* entry count */

    for (i=0; i<track->entry; i++) {

        if(mode64 == 1)

            avio_wb64(pb, track->cluster[i].pos);

        else

            avio_wb32(pb, track->cluster[i].pos);

    }

    return updateSize(pb, pos);

}

/* Sample size atom */

static int mov_write_stsz_tag(AVIOContext *pb, MOVTrack *track)

{

    int equalChunks = 1;

    int i, j, entries = 0, tst = -1, oldtst = -1;

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    ffio_wfourcc(pb, "stsz");

    avio_wb32(pb, 0); /* version & flags */

    for (i=0; i<track->entry; i++) {

        tst = track->cluster[i].size/track->cluster[i].entries;

        if(oldtst != -1 && tst != oldtst) {

            equalChunks = 0;

        }

        oldtst = tst;

        entries += track->cluster[i].entries;

    }

    if (equalChunks) {

        int sSize = track->cluster[0].size/track->cluster[0].entries;

        avio_wb32(pb, sSize); // sample size

        avio_wb32(pb, entries); // sample count

    }

    else {

        avio_wb32(pb, 0); // sample size

        avio_wb32(pb, entries); // sample count

        for (i=0; i<track->entry; i++) {

            for (j=0; j<track->cluster[i].entries; j++) {

                avio_wb32(pb, track->cluster[i].size /

                         track->cluster[i].entries);

            }

        }

    }

    return updateSize(pb, pos);

}

/* Sample to chunk atom */

static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)

{

    int index = 0, oldval = -1, i;

    int64_t entryPos, curpos;

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    ffio_wfourcc(pb, "stsc");

    avio_wb32(pb, 0); // version & flags

    entryPos = avio_tell(pb);

    avio_wb32(pb, track->entry); // entry count

    for (i=0; i<track->entry; i++) {

        if(oldval != track->cluster[i].samplesInChunk)

        {

            avio_wb32(pb, i+1); // first chunk

            avio_wb32(pb, track->cluster[i].samplesInChunk); // samples per chunk

            avio_wb32(pb, 0x1); // sample description index

            oldval = track->cluster[i].samplesInChunk;

            index++;

        }

    }

    curpos = avio_tell(pb);

    avio_seek(pb, entryPos, SEEK_SET);

    avio_wb32(pb, index); // rewrite size

    avio_seek(pb, curpos, SEEK_SET);

    return updateSize(pb, pos);

}

/* Sync sample atom */

static int mov_write_stss_tag(AVIOContext *pb, MOVTrack *track, uint32_t flag)

{

    int64_t curpos, entryPos;

    int i, index = 0;

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); // size

    ffio_wfourcc(pb, flag == MOV_SYNC_SAMPLE ? "stss" : "stps");

    avio_wb32(pb, 0); // version & flags

    entryPos = avio_tell(pb);

    avio_wb32(pb, track->entry); // entry count

    for (i=0; i<track->entry; i++) {

        if (track->cluster[i].flags & flag) {

            avio_wb32(pb, i+1);

            index++;

        }

    }

    curpos = avio_tell(pb);

    avio_seek(pb, entryPos, SEEK_SET);

    avio_wb32(pb, index); // rewrite size

    avio_seek(pb, curpos, SEEK_SET);

    return updateSize(pb, pos);

}

static int mov_write_amr_tag(AVIOContext *pb, MOVTrack *track)

{

    avio_wb32(pb, 0x11); /* size */

    if (track->mode == MODE_MOV) ffio_wfourcc(pb, "samr");

    else                         ffio_wfourcc(pb, "damr");

    ffio_wfourcc(pb, "FFMP");

    avio_w8(pb, 0); /* decoder version */

    avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */

    avio_w8(pb, 0x00); /* Mode change period (no restriction) */

    avio_w8(pb, 0x01); /* Frames per sample */

    return 0x11;

}

static int mov_write_ac3_tag(AVIOContext *pb, MOVTrack *track)

{

    GetBitContext gbc;

    PutBitContext pbc;

    uint8_t buf[3];

    int fscod, bsid, bsmod, acmod, lfeon, frmsizecod;

    if (track->vosLen < 7)

        return -1;

    avio_wb32(pb, 11);

    ffio_wfourcc(pb, "dac3");

    init_get_bits(&gbc, track->vosData+4, track->vosLen-4);

    fscod      = get_bits(&gbc, 2);

    frmsizecod = get_bits(&gbc, 6);

    bsid       = get_bits(&gbc, 5);

    bsmod      = get_bits(&gbc, 3);

    acmod      = get_bits(&gbc, 3);

    if (acmod == 2) {

        skip_bits(&gbc, 2); // dsurmod

    } else {

        if ((acmod & 1) && acmod != 1)

            skip_bits(&gbc, 2); // cmixlev

        if (acmod & 4)

            skip_bits(&gbc, 2); // surmixlev

    }

    lfeon = get_bits1(&gbc);

    init_put_bits(&pbc, buf, sizeof(buf));

    put_bits(&pbc, 2, fscod);

    put_bits(&pbc, 5, bsid);

    put_bits(&pbc, 3, bsmod);

    put_bits(&pbc, 3, acmod);

    put_bits(&pbc, 1, lfeon);

    put_bits(&pbc, 5, frmsizecod>>1); // bit_rate_code

    put_bits(&pbc, 5, 0); // reserved

    flush_put_bits(&pbc);

    avio_write(pb, buf, sizeof(buf));

    return 11;

}

/**

 * This function writes extradata "as is".

 * Extradata must be formated like a valid atom (with size and tag)

 */

static int mov_write_extradata_tag(AVIOContext *pb, MOVTrack *track)

{

    avio_write(pb, track->enc->extradata, track->enc->extradata_size);

    return track->enc->extradata_size;

}

static int mov_write_enda_tag(AVIOContext *pb)

{

    avio_wb32(pb, 10);

    ffio_wfourcc(pb, "enda");

    avio_wb16(pb, 1); /* little endian */

    return 10;

}

static unsigned int descrLength(unsigned int len)

{

    int i;

    for(i=1; len>>(7*i); i++);

    return len + 1 + i;

}

static void putDescr(AVIOContext *pb, int tag, unsigned int size)

{

    int i= descrLength(size) - size - 2;

    avio_w8(pb, tag);

    for(; i>0; i--)

        avio_w8(pb, (size>>(7*i)) | 0x80);

    avio_w8(pb, size & 0x7F);

}

static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic

{

    int64_t pos = avio_tell(pb);

    int decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;

    avio_wb32(pb, 0); // size

    ffio_wfourcc(pb, "esds");

    avio_wb32(pb, 0); // Version

    // ES descriptor

    putDescr(pb, 0x03, 3 + descrLength(13 + decoderSpecificInfoLen) +

             descrLength(1));

    avio_wb16(pb, track->trackID);

    avio_w8(pb, 0x00); // flags (= no flags)

    // DecoderConfig descriptor

    putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);

    // Object type indication

    if ((track->enc->codec_id == CODEC_ID_MP2 ||

         track->enc->codec_id == CODEC_ID_MP3) &&

        track->enc->sample_rate > 24000)

        avio_w8(pb, 0x6B); // 11172-3

    else

        avio_w8(pb, ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));

    // the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)

    // plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)

    if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO)

        avio_w8(pb, 0x15); // flags (= Audiostream)

    else

        avio_w8(pb, 0x11); // flags (= Visualstream)

    avio_w8(pb,  track->enc->rc_buffer_size>>(3+16));      // Buffersize DB (24 bits)

    avio_wb16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF); // Buffersize DB

    avio_wb32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window)

    if(track->enc->rc_max_rate != track->enc->rc_min_rate || track->enc->rc_min_rate==0)

        avio_wb32(pb, 0); // vbr

    else

        avio_wb32(pb, track->enc->rc_max_rate); // avg bitrate

    if (track->vosLen) {

        // DecoderSpecific info descriptor

        putDescr(pb, 0x05, track->vosLen);

        avio_write(pb, track->vosData, track->vosLen);

    }

    // SL descriptor

    putDescr(pb, 0x06, 1);

    avio_w8(pb, 0x02);

    return updateSize(pb, pos);

}

static int mov_pcm_le_gt16(enum CodecID codec_id)

{

    return codec_id == CODEC_ID_PCM_S24LE ||

           codec_id == CODEC_ID_PCM_S32LE ||

           codec_id == CODEC_ID_PCM_F32LE ||

           codec_id == CODEC_ID_PCM_F64LE;

}

static int mov_write_ms_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0);

    avio_wl32(pb, track->tag); // store it byteswapped

    track->enc->codec_tag = av_bswap16(track->tag >> 16);

    ff_put_wav_header(pb, track->enc);

    return updateSize(pb, pos);

}

static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0);     /* size */

    ffio_wfourcc(pb, "wave");

    avio_wb32(pb, 12);    /* size */

    ffio_wfourcc(pb, "frma");

    avio_wl32(pb, track->tag);

    if (track->enc->codec_id == CODEC_ID_AAC) {

        /* useless atom needed by mplayer, ipod, not needed by quicktime */

        avio_wb32(pb, 12); /* size */

        ffio_wfourcc(pb, "mp4a");

        avio_wb32(pb, 0);

        mov_write_esds_tag(pb, track);

    } else if (mov_pcm_le_gt16(track->enc->codec_id)) {

        mov_write_enda_tag(pb);

    } else if (track->enc->codec_id == CODEC_ID_AMR_NB) {

        mov_write_amr_tag(pb, track);

    } else if (track->enc->codec_id == CODEC_ID_AC3) {

        mov_write_ac3_tag(pb, track);

    } else if (track->enc->codec_id == CODEC_ID_ALAC) {

        mov_write_extradata_tag(pb, track);

    } else if (track->enc->codec_id == CODEC_ID_ADPCM_MS ||

               track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {

        mov_write_ms_tag(pb, track);

    }

    avio_wb32(pb, 8);     /* size */

    avio_wb32(pb, 0);     /* null tag */

    return updateSize(pb, pos);

}

static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)

{

    avio_wb32(pb, track->vosLen+8);

    ffio_wfourcc(pb, "glbl");

    avio_write(pb, track->vosData, track->vosLen);

    return 8+track->vosLen;

}

/**

 * Compute flags for 'lpcm' tag.

 * See CoreAudioTypes and AudioStreamBasicDescription at Apple.

 */

static int mov_get_lpcm_flags(enum CodecID codec_id)

{

    switch (codec_id) {

    case CODEC_ID_PCM_F32BE:

    case CODEC_ID_PCM_F64BE:

        return 11;

    case CODEC_ID_PCM_F32LE:

    case CODEC_ID_PCM_F64LE:

        return 9;

    case CODEC_ID_PCM_U8:

        return 10;

    case CODEC_ID_PCM_S16BE:

    case CODEC_ID_PCM_S24BE:

    case CODEC_ID_PCM_S32BE:

        return 14;

    case CODEC_ID_PCM_S8:

    case CODEC_ID_PCM_S16LE:

    case CODEC_ID_PCM_S24LE:

    case CODEC_ID_PCM_S32LE:

        return 12;

    default:

        return 0;

    }

}

static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    int version = 0;

    uint32_t tag = track->tag;

    if (track->mode == MODE_MOV) {

        if (track->timescale > UINT16_MAX) {

            if (mov_get_lpcm_flags(track->enc->codec_id))

                tag = AV_RL32("lpcm");

            version = 2;

        } else if (track->audio_vbr || mov_pcm_le_gt16(track->enc->codec_id) ||

                   track->enc->codec_id == CODEC_ID_ADPCM_MS ||

                   track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {

            version = 1;

        }

    }

    avio_wb32(pb, 0); /* size */

    avio_wl32(pb, tag); // store it byteswapped

    avio_wb32(pb, 0); /* Reserved */

    avio_wb16(pb, 0); /* Reserved */

    avio_wb16(pb, 1); /* Data-reference index, XXX  == 1 */

    /* SoundDescription */

    avio_wb16(pb, version); /* Version */

    avio_wb16(pb, 0); /* Revision level */

    avio_wb32(pb, 0); /* Reserved */

    if (version == 2) {

        avio_wb16(pb, 3);

        avio_wb16(pb, 16);

        avio_wb16(pb, 0xfffe);

        avio_wb16(pb, 0);

        avio_wb32(pb, 0x00010000);

        avio_wb32(pb, 72);

        avio_wb64(pb, av_dbl2int(track->timescale));

        avio_wb32(pb, track->enc->channels);

        avio_wb32(pb, 0x7F000000);

        avio_wb32(pb, av_get_bits_per_sample(track->enc->codec_id));

        avio_wb32(pb, mov_get_lpcm_flags(track->enc->codec_id));

        avio_wb32(pb, track->sampleSize);

        avio_wb32(pb, track->enc->frame_size);

    } else {

        if (track->mode == MODE_MOV) {

            avio_wb16(pb, track->enc->channels);

            if (track->enc->codec_id == CODEC_ID_PCM_U8 ||

                track->enc->codec_id == CODEC_ID_PCM_S8)

                avio_wb16(pb, 8); /* bits per sample */

            else

                avio_wb16(pb, 16);

            avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */

        } else { /* reserved for mp4/3gp */

            avio_wb16(pb, 2);

            avio_wb16(pb, 16);

            avio_wb16(pb, 0);

        }

        avio_wb16(pb, 0); /* packet size (= 0) */

        avio_wb16(pb, track->timescale); /* Time scale */

        avio_wb16(pb, 0); /* Reserved */

    }

    if(version == 1) { /* SoundDescription V1 extended info */

        avio_wb32(pb, track->enc->frame_size); /* Samples per packet */

        avio_wb32(pb, track->sampleSize / track->enc->channels); /* Bytes per packet */

        avio_wb32(pb, track->sampleSize); /* Bytes per frame */

        avio_wb32(pb, 2); /* Bytes per sample */

    }

    if(track->mode == MODE_MOV &&

       (track->enc->codec_id == CODEC_ID_AAC ||

        track->enc->codec_id == CODEC_ID_AC3 ||

        track->enc->codec_id == CODEC_ID_AMR_NB ||

        track->enc->codec_id == CODEC_ID_ALAC ||

        track->enc->codec_id == CODEC_ID_ADPCM_MS ||

        track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV ||

        mov_pcm_le_gt16(track->enc->codec_id)))

        mov_write_wave_tag(pb, track);

    else if(track->tag == MKTAG('m','p','4','a'))

        mov_write_esds_tag(pb, track);

    else if(track->enc->codec_id == CODEC_ID_AMR_NB)

        mov_write_amr_tag(pb, track);

    else if(track->enc->codec_id == CODEC_ID_AC3)

        mov_write_ac3_tag(pb, track);

    else if(track->enc->codec_id == CODEC_ID_ALAC)

        mov_write_extradata_tag(pb, track);

    else if(track->vosLen > 0)

        mov_write_glbl_tag(pb, track);

    return updateSize(pb, pos);

}

static int mov_write_d263_tag(AVIOContext *pb)

{

    avio_wb32(pb, 0xf); /* size */

    ffio_wfourcc(pb, "d263");

    ffio_wfourcc(pb, "FFMP");

    avio_w8(pb, 0); /* decoder version */

    /* FIXME use AVCodecContext level/profile, when encoder will set values */

    avio_w8(pb, 0xa); /* level */

    avio_w8(pb, 0); /* profile */

    return 0xf;

}

/* TODO: No idea about these values */

static int mov_write_svq3_tag(AVIOContext *pb)

{

    avio_wb32(pb, 0x15);

    ffio_wfourcc(pb, "SMI ");

    ffio_wfourcc(pb, "SEQH");

    avio_wb32(pb, 0x5);

    avio_wb32(pb, 0xe2c0211d);

    avio_wb32(pb, 0xc0000000);

    avio_w8(pb, 0);

    return 0x15;

}

static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0);

    ffio_wfourcc(pb, "avcC");

    ff_isom_write_avcc(pb, track->vosData, track->vosLen);

    return updateSize(pb, pos);

}

/* also used by all avid codecs (dv, imx, meridien) and their variants */

static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)

{

    int i;

    avio_wb32(pb, 24); /* size */

    ffio_wfourcc(pb, "ACLR");

    ffio_wfourcc(pb, "ACLR");

    ffio_wfourcc(pb, "0001");

    avio_wb32(pb, 1); /* yuv 1 / rgb 2 ? */

    avio_wb32(pb, 0); /* unknown */

    avio_wb32(pb, 24); /* size */

    ffio_wfourcc(pb, "APRG");

    ffio_wfourcc(pb, "APRG");

    ffio_wfourcc(pb, "0001");

    avio_wb32(pb, 1); /* unknown */

    avio_wb32(pb, 0); /* unknown */

    avio_wb32(pb, 120); /* size */

    ffio_wfourcc(pb, "ARES");

    ffio_wfourcc(pb, "ARES");

    ffio_wfourcc(pb, "0001");

    avio_wb32(pb, AV_RB32(track->vosData + 0x28)); /* dnxhd cid, some id ? */

    avio_wb32(pb, track->enc->width);

    /* values below are based on samples created with quicktime and avid codecs */

    if (track->vosData[5] & 2) { // interlaced

        avio_wb32(pb, track->enc->height/2);

        avio_wb32(pb, 2); /* unknown */

        avio_wb32(pb, 0); /* unknown */

        avio_wb32(pb, 4); /* unknown */

    } else {

        avio_wb32(pb, track->enc->height);

        avio_wb32(pb, 1); /* unknown */

        avio_wb32(pb, 0); /* unknown */

        if (track->enc->height == 1080)

            avio_wb32(pb, 5); /* unknown */

        else

            avio_wb32(pb, 6); /* unknown */

    }

    /* padding */

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

        avio_wb64(pb, 0);

    /* extra padding for stsd needed */

    avio_wb32(pb, 0);

    return 0;

}

static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag = track->enc->codec_tag;

    if (!ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id))

        return 0;

    if      (track->enc->codec_id == CODEC_ID_H264)      tag = MKTAG('a','v','c','1');

    else if (track->enc->codec_id == CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');

    else if (track->enc->codec_id == CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');

    else if (track->enc->codec_id == CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');

    else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v');

    else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a');

    return tag;

}

static const AVCodecTag codec_ipod_tags[] = {

    { CODEC_ID_H264,   MKTAG('a','v','c','1') },

    { CODEC_ID_MPEG4,  MKTAG('m','p','4','v') },

    { CODEC_ID_AAC,    MKTAG('m','p','4','a') },

    { CODEC_ID_ALAC,   MKTAG('a','l','a','c') },

    { CODEC_ID_AC3,    MKTAG('a','c','-','3') },

    { CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },

    { CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },

    { CODEC_ID_NONE, 0 },

};

static int ipod_get_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag = track->enc->codec_tag;

    // keep original tag for subs, ipod supports both formats

    if (!(track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE &&

        (tag == MKTAG('t','x','3','g') ||

         tag == MKTAG('t','e','x','t'))))

        tag = ff_codec_get_tag(codec_ipod_tags, track->enc->codec_id);

    if (!av_match_ext(s->filename, "m4a") && !av_match_ext(s->filename, "m4v"))

        av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a nor .m4v "

               "Quicktime/Ipod might not play the file\n");

    return tag;

}

static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag;

    if (track->enc->width == 720) /* SD */

        if (track->enc->height == 480) /* NTSC */

            if  (track->enc->pix_fmt == PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');

            else                                         tag = MKTAG('d','v','c',' ');

        else if (track->enc->pix_fmt == PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');

        else if (track->enc->pix_fmt == PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');

        else                                             tag = MKTAG('d','v','p','p');

    else if (track->enc->height == 720) /* HD 720 line */

        if  (track->enc->time_base.den == 50)            tag = MKTAG('d','v','h','q');

        else                                             tag = MKTAG('d','v','h','p');

    else if (track->enc->height == 1080) /* HD 1080 line */

        if  (track->enc->time_base.den == 25)            tag = MKTAG('d','v','h','5');

        else                                             tag = MKTAG('d','v','h','6');

    else {

        av_log(s, AV_LOG_ERROR, "unsupported height for dv codec\n");

        return 0;

    }

    return tag;

}

static const struct {

    enum PixelFormat pix_fmt;

    uint32_t tag;

    unsigned bps;

} mov_pix_fmt_tags[] = {

    { PIX_FMT_YUYV422, MKTAG('y','u','v','s'),  0 },

    { PIX_FMT_UYVY422, MKTAG('2','v','u','y'),  0 },

    { PIX_FMT_RGB555BE,MKTAG('r','a','w',' '), 16 },

    { PIX_FMT_RGB555LE,MKTAG('L','5','5','5'), 16 },

    { PIX_FMT_RGB565LE,MKTAG('L','5','6','5'), 16 },

    { PIX_FMT_RGB565BE,MKTAG('B','5','6','5'), 16 },

    { PIX_FMT_GRAY16BE,MKTAG('b','1','6','g'), 16 },

    { PIX_FMT_RGB24,   MKTAG('r','a','w',' '), 24 },

    { PIX_FMT_BGR24,   MKTAG('2','4','B','G'), 24 },

    { PIX_FMT_ARGB,    MKTAG('r','a','w',' '), 32 },

    { PIX_FMT_BGRA,    MKTAG('B','G','R','A'), 32 },

    { PIX_FMT_RGBA,    MKTAG('R','G','B','A'), 32 },

    { PIX_FMT_ABGR,    MKTAG('A','B','G','R'), 32 },

    { PIX_FMT_RGB48BE, MKTAG('b','4','8','r'), 48 },

};

static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag = track->enc->codec_tag;

    int i;

    for (i = 0; i < FF_ARRAY_ELEMS(mov_pix_fmt_tags); i++) {

        if (track->enc->pix_fmt == mov_pix_fmt_tags[i].pix_fmt) {

            tag = mov_pix_fmt_tags[i].tag;

            track->enc->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;

            break;

        }

    }

    return tag;

}

static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag = track->enc->codec_tag;

    if (!tag || (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&

                 (track->enc->codec_id == CODEC_ID_DVVIDEO ||

                  track->enc->codec_id == CODEC_ID_RAWVIDEO ||

                  track->enc->codec_id == CODEC_ID_H263 ||

                  av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio

        if (track->enc->codec_id == CODEC_ID_DVVIDEO)

            tag = mov_get_dv_codec_tag(s, track);

        else if (track->enc->codec_id == CODEC_ID_RAWVIDEO)

            tag = mov_get_rawvideo_codec_tag(s, track);

        else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {

            tag = ff_codec_get_tag(codec_movvideo_tags, track->enc->codec_id);

            if (!tag) { // if no mac fcc found, try with Microsoft tags

                tag = ff_codec_get_tag(ff_codec_bmp_tags, track->enc->codec_id);

                if (tag)

                    av_log(s, AV_LOG_INFO, "Warning, using MS style video codec tag, "

                           "the file may be unplayable!\n");

            }

        } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {

            tag = ff_codec_get_tag(codec_movaudio_tags, track->enc->codec_id);

            if (!tag) { // if no mac fcc found, try with Microsoft tags

                int ms_tag = ff_codec_get_tag(ff_codec_wav_tags, track->enc->codec_id);

                if (ms_tag) {

                    tag = MKTAG('m', 's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));

                    av_log(s, AV_LOG_INFO, "Warning, using MS style audio codec tag, "

                           "the file may be unplayable!\n");

                }

            }

        } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)

            tag = ff_codec_get_tag(ff_codec_movsubtitle_tags, track->enc->codec_id);

    }

    return tag;

}

static const AVCodecTag codec_3gp_tags[] = {

    { CODEC_ID_H263,   MKTAG('s','2','6','3') },

    { CODEC_ID_H264,   MKTAG('a','v','c','1') },

    { CODEC_ID_MPEG4,  MKTAG('m','p','4','v') },

    { CODEC_ID_AAC,    MKTAG('m','p','4','a') },

    { CODEC_ID_AMR_NB, MKTAG('s','a','m','r') },

    { CODEC_ID_AMR_WB, MKTAG('s','a','w','b') },

    { CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },

    { CODEC_ID_NONE, 0 },

};

static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)

{

    int tag = track->enc->codec_tag;

    if (track->mode == MODE_MP4 || track->mode == MODE_PSP)

        tag = mp4_get_codec_tag(s, track);

    else if (track->mode == MODE_IPOD)

        tag = ipod_get_codec_tag(s, track);

    else if (track->mode & MODE_3GP)

        tag = ff_codec_get_tag(codec_3gp_tags, track->enc->codec_id);

    else

        tag = mov_get_codec_tag(s, track);

    return tag;

}

/** Write uuid atom.

 * Needed to make file play in iPods running newest firmware

 * goes after avcC atom in moov.trak.mdia.minf.stbl.stsd.avc1

 */

static int mov_write_uuid_tag_ipod(AVIOContext *pb)

{

    avio_wb32(pb, 28);

    ffio_wfourcc(pb, "uuid");

    avio_wb32(pb, 0x6b6840f2);

    avio_wb32(pb, 0x5f244fc5);

    avio_wb32(pb, 0xba39a51b);

    avio_wb32(pb, 0xcf0323f3);

    avio_wb32(pb, 0x0);

    return 28;

}

static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0);    /* size */

    avio_wl32(pb, track->tag); // store it byteswapped

    avio_wb32(pb, 0);    /* Reserved */

    avio_wb16(pb, 0);    /* Reserved */

    avio_wb16(pb, 1);    /* Data-reference index */

    if (track->enc->extradata_size)

        avio_write(pb, track->enc->extradata, track->enc->extradata_size);

    return updateSize(pb, pos);

}

static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)

{

    AVRational sar;

    av_reduce(&sar.num, &sar.den, track->enc->sample_aspect_ratio.num,

              track->enc->sample_aspect_ratio.den, INT_MAX);

    avio_wb32(pb, 16);

    ffio_wfourcc(pb, "pasp");

    avio_wb32(pb, sar.num);

    avio_wb32(pb, sar.den);

    return 16;

}

static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    char compressor_name[32];

    avio_wb32(pb, 0); /* size */

    avio_wl32(pb, track->tag); // store it byteswapped

    avio_wb32(pb, 0); /* Reserved */

    avio_wb16(pb, 0); /* Reserved */

    avio_wb16(pb, 1); /* Data-reference index */

    avio_wb16(pb, 0); /* Codec stream version */

    avio_wb16(pb, 0); /* Codec stream revision (=0) */

    if (track->mode == MODE_MOV) {

        ffio_wfourcc(pb, "FFMP"); /* Vendor */

        if(track->enc->codec_id == CODEC_ID_RAWVIDEO) {

            avio_wb32(pb, 0); /* Temporal Quality */

            avio_wb32(pb, 0x400); /* Spatial Quality = lossless*/

        } else {

            avio_wb32(pb, 0x200); /* Temporal Quality = normal */

            avio_wb32(pb, 0x200); /* Spatial Quality = normal */

        }

    } else {

        avio_wb32(pb, 0); /* Reserved */

        avio_wb32(pb, 0); /* Reserved */

        avio_wb32(pb, 0); /* Reserved */

    }

    avio_wb16(pb, track->enc->width); /* Video width */

    avio_wb16(pb, track->height); /* Video height */

    avio_wb32(pb, 0x00480000); /* Horizontal resolution 72dpi */

    avio_wb32(pb, 0x00480000); /* Vertical resolution 72dpi */

    avio_wb32(pb, 0); /* Data size (= 0) */

    avio_wb16(pb, 1); /* Frame count (= 1) */

    memset(compressor_name,0,32);

    /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */

    if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name)

        strncpy(compressor_name,track->enc->codec->name,31);

    avio_w8(pb, strlen(compressor_name));

    avio_write(pb, compressor_name, 31);

    if (track->mode == MODE_MOV && track->enc->bits_per_coded_sample)

        avio_wb16(pb, track->enc->bits_per_coded_sample);

    else

        avio_wb16(pb, 0x18); /* Reserved */

    avio_wb16(pb, 0xffff); /* Reserved */

    if(track->tag == MKTAG('m','p','4','v'))

        mov_write_esds_tag(pb, track);

    else if(track->enc->codec_id == CODEC_ID_H263)

        mov_write_d263_tag(pb);

    else if(track->enc->codec_id == CODEC_ID_SVQ3)

        mov_write_svq3_tag(pb);

    else if(track->enc->codec_id == CODEC_ID_DNXHD)

        mov_write_avid_tag(pb, track);

    else if(track->enc->codec_id == CODEC_ID_H264) {

        mov_write_avcc_tag(pb, track);

        if(track->mode == MODE_IPOD)

            mov_write_uuid_tag_ipod(pb);

    } else if(track->vosLen > 0)

        mov_write_glbl_tag(pb, track);

    if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&

        track->enc->sample_aspect_ratio.den != track->enc->sample_aspect_ratio.num) {

        mov_write_pasp_tag(pb, track);

    }

    return updateSize(pb, pos);

}

static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    ffio_wfourcc(pb, "rtp ");

    avio_wb32(pb, 0); /* Reserved */

    avio_wb16(pb, 0); /* Reserved */

    avio_wb16(pb, 1); /* Data-reference index */

    avio_wb16(pb, 1); /* Hint track version */

    avio_wb16(pb, 1); /* Highest compatible version */

    avio_wb32(pb, track->max_packet_size); /* Max packet size */

    avio_wb32(pb, 12); /* size */

    ffio_wfourcc(pb, "tims");

    avio_wb32(pb, track->timescale);

    return updateSize(pb, pos);

}

static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track)

{

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    ffio_wfourcc(pb, "stsd");

    avio_wb32(pb, 0); /* version & flags */

    avio_wb32(pb, 1); /* entry count */

    if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)

        mov_write_video_tag(pb, track);

    else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)

        mov_write_audio_tag(pb, track);

    else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)