set bits_per_coded_sample for rawvideo
[ffmpeg.git] / libavformat / movenc.c
index 3547618..bb5fbe2 100644 (file)
@@ -1,7 +1,8 @@
 /*
  * MOV, 3GP, MP4 muxer
- * Copyright (c) 2003 Thomas Raivio.
- * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>.
+ * 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 FFmpeg.
  *
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+
 #include "avformat.h"
 #include "riff.h"
 #include "avio.h"
 #include "isom.h"
 #include "avc.h"
+#include "libavcodec/bitstream.h"
 
 #undef NDEBUG
 #include <assert.h>
@@ -68,22 +71,23 @@ typedef struct MOVIndex {
     uint8_t     *vosData;
     MOVIentry   *cluster;
     int         audio_vbr;
+    int         height; ///< active picture (w/o VBI) height for D-10/IMX
 } MOVTrack;
 
-typedef struct MOVContext {
+typedef struct MOVMuxContext {
     int     mode;
     int64_t time;
     int     nb_streams;
-    offset_t mdat_pos;
+    int64_t mdat_pos;
     uint64_t mdat_size;
     long    timescale;
-    MOVTrack tracks[MAX_STREAMS];
-} MOVContext;
+    MOVTrack *tracks;
+} MOVMuxContext;
 
 //FIXME support 64 bit variant with wide placeholders
-static offset_t updateSize(ByteIOContext *pb, offset_t pos)
+static int64_t updateSize(ByteIOContext *pb, int64_t pos)
 {
-    offset_t curpos = url_ftell(pb);
+    int64_t curpos = url_ftell(pb);
     url_fseek(pb, pos, SEEK_SET);
     put_be32(pb, curpos - pos); /* rewrite size */
     url_fseek(pb, curpos, SEEK_SET);
@@ -96,7 +100,7 @@ static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack *track)
 {
     int i;
     int mode64 = 0; //   use 32 bit size variant if possible
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     if (pos > UINT32_MAX) {
         mode64 = 1;
@@ -120,7 +124,7 @@ static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack *track)
     int equalChunks = 1;
     int i, j, entries = 0, tst = -1, oldtst = -1;
 
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "stsz");
     put_be32(pb, 0); /* version & flags */
@@ -155,9 +159,9 @@ static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack *track)
 static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack *track)
 {
     int index = 0, oldval = -1, i;
-    offset_t entryPos, curpos;
+    int64_t entryPos, curpos;
 
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "stsc");
     put_be32(pb, 0); // version & flags
@@ -184,9 +188,9 @@ static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack *track)
 /* Sync sample atom */
 static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t curpos, entryPos;
+    int64_t curpos, entryPos;
     int i, index = 0;
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); // size
     put_tag(pb, "stss");
     put_be32(pb, 0); // version & flags
@@ -219,6 +223,50 @@ static int mov_write_amr_tag(ByteIOContext *pb, MOVTrack *track)
     return 0x11;
 }
 
+static int mov_write_ac3_tag(ByteIOContext *pb, MOVTrack *track)
+{
+    GetBitContext gbc;
+    PutBitContext pbc;
+    uint8_t buf[3];
+    int fscod, bsid, bsmod, acmod, lfeon, frmsizecod;
+
+    if (track->vosLen < 7)
+        return -1;
+
+    put_be32(pb, 11);
+    put_tag(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);
+    put_buffer(pb, buf, sizeof(buf));
+
+    return 11;
+}
+
 /**
  * This function writes extradata "as is".
  * Extradata must be formated like a valid atom (with size and tag)
@@ -255,7 +303,7 @@ static void putDescr(ByteIOContext *pb, int tag, unsigned int size)
 
 static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     int decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;
 
     put_be32(pb, 0); // size
@@ -274,9 +322,8 @@ static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
     // Object type indication
     if ((track->enc->codec_id == CODEC_ID_MP2 ||
          track->enc->codec_id == CODEC_ID_MP3) &&
-        track->enc->sample_rate <= 24000 &&
-        track->enc->sample_rate >= 16000)
-        put_byte(pb, 105); // 13818-3
+        track->enc->sample_rate > 24000)
+        put_byte(pb, 0x6B); // 11172-3
     else
         put_byte(pb, codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));
 
@@ -310,7 +357,7 @@ static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic
 
 static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
 
     put_be32(pb, 0);     /* size */
     put_tag(pb, "wave");
@@ -330,6 +377,8 @@ static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack *track)
         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);
     }
@@ -350,7 +399,7 @@ static int mov_write_glbl_tag(ByteIOContext *pb, MOVTrack *track)
 
 static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     int version = track->mode == MODE_MOV &&
         (track->audio_vbr ||
          track->enc->codec_id == CODEC_ID_PCM_S32LE ||
@@ -394,6 +443,7 @@ static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)
 
     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_PCM_S24LE ||
         track->enc->codec_id == CODEC_ID_PCM_S32LE ||
@@ -403,7 +453,9 @@ static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)
         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_ALAC)
+    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);
@@ -438,7 +490,7 @@ static int mov_write_svq3_tag(ByteIOContext *pb)
 
 static int mov_write_avcc_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
 
     put_be32(pb, 0);
     put_tag(pb, "avcC");
@@ -501,14 +553,20 @@ static const AVCodecTag codec_3gp_tags[] = {
     { 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 const AVCodecTag mov_pix_fmt_tags[] = {
-    { PIX_FMT_YUYV422, MKTAG('y','u','v','s') },
-    { PIX_FMT_UYVY422, MKTAG('2','v','u','y') },
-    { PIX_FMT_BGR555,  MKTAG('r','a','w',' ') },
-    { PIX_FMT_RGB24,   MKTAG('r','a','w',' ') },
-    { PIX_FMT_BGR32_1, MKTAG('r','a','w',' ') },
+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_BGR555,  MKTAG('r','a','w',' '), 16 },
+    { PIX_FMT_RGB24,   MKTAG('r','a','w',' '), 24 },
+    { PIX_FMT_BGR32_1, MKTAG('r','a','w',' '), 32 },
 };
 
 static const AVCodecTag codec_ipod_tags[] = {
@@ -516,6 +574,10 @@ static const AVCodecTag codec_ipod_tags[] = {
     { 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 mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
@@ -524,11 +586,19 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
     if (track->mode == MODE_MP4 || track->mode == MODE_PSP) {
         if (!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');
+        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 == CODEC_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
         else if (track->enc->codec_type == CODEC_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
     } else if (track->mode == MODE_IPOD) {
-        tag = codec_get_tag(codec_ipod_tags, track->enc->codec_id);
+        if (track->enc->codec_type == CODEC_TYPE_SUBTITLE &&
+            (tag == MKTAG('t','x','3','g') ||
+             tag == MKTAG('t','e','x','t')))
+            track->tag = tag; // keep original tag
+        else
+            tag = codec_get_tag(codec_ipod_tags, track->enc->codec_id);
         if (!match_ext(s->filename, "m4a") && !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");
@@ -536,7 +606,8 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
         tag = codec_get_tag(codec_3gp_tags, track->enc->codec_id);
     } else if (!tag || (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&
                         (tag == MKTAG('d','v','c','p') ||
-                         track->enc->codec_id == CODEC_ID_RAWVIDEO))) {
+                         track->enc->codec_id == CODEC_ID_RAWVIDEO ||
+                         av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio
         if (track->enc->codec_id == CODEC_ID_DVVIDEO) {
             if (track->enc->height == 480) /* NTSC */
                 if  (track->enc->pix_fmt == PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
@@ -545,7 +616,14 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
             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->codec_id == CODEC_ID_RAWVIDEO) {
-            tag = codec_get_tag(mov_pix_fmt_tags, track->enc->pix_fmt);
+            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;
+                }
+            }
             if (!tag) // restore tag
                 tag = track->enc->codec_tag;
         } else {
@@ -567,6 +645,8 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
                                "the file may be unplayable!\n");
                     }
                 }
+            } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+                tag = codec_get_tag(ff_codec_movsubtitle_tags, track->enc->codec_id);
             }
         }
     }
@@ -589,9 +669,24 @@ static int mov_write_uuid_tag_ipod(ByteIOContext *pb)
     return 28;
 }
 
+static int mov_write_subtitle_tag(ByteIOContext *pb, MOVTrack *track)
+{
+    int64_t pos = url_ftell(pb);
+    put_be32(pb, 0);    /* size */
+    put_le32(pb, track->tag); // store it byteswapped
+    put_be32(pb, 0);    /* Reserved */
+    put_be16(pb, 0);    /* Reserved */
+    put_be16(pb, 1);    /* Data-reference index */
+
+    if (track->enc->extradata_size)
+        put_buffer(pb, track->enc->extradata, track->enc->extradata_size);
+
+    return updateSize(pb, pos);
+}
+
 static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     char compressor_name[32];
 
     put_be32(pb, 0); /* size */
@@ -617,7 +712,7 @@ static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
         put_be32(pb, 0); /* Reserved */
     }
     put_be16(pb, track->enc->width); /* Video width */
-    put_be16(pb, track->enc->height); /* Video height */
+    put_be16(pb, track->height); /* Video height */
     put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */
     put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */
     put_be32(pb, 0); /* Data size (= 0) */
@@ -630,8 +725,8 @@ static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
     put_byte(pb, strlen(compressor_name));
     put_buffer(pb, compressor_name, 31);
 
-    if (track->mode == MODE_MOV && track->enc->bits_per_sample)
-        put_be16(pb, track->enc->bits_per_sample);
+    if (track->mode == MODE_MOV && track->enc->bits_per_coded_sample)
+        put_be16(pb, track->enc->bits_per_coded_sample);
     else
         put_be16(pb, 0x18); /* Reserved */
     put_be16(pb, 0xffff); /* Reserved */
@@ -655,7 +750,7 @@ static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)
 
 static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "stsd");
     put_be32(pb, 0); /* version & flags */
@@ -664,12 +759,14 @@ static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)
         mov_write_video_tag(pb, track);
     else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
         mov_write_audio_tag(pb, track);
+    else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE)
+        mov_write_subtitle_tag(pb, track);
     return updateSize(pb, pos);
 }
 
 static int mov_write_ctts_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    MOV_stts_t *ctts_entries;
+    MOVStts *ctts_entries;
     uint32_t entries = 0;
     uint32_t atom_size;
     int i;
@@ -703,7 +800,7 @@ static int mov_write_ctts_tag(ByteIOContext *pb, MOVTrack *track)
 /* Time to sample atom */
 static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    MOV_stts_t *stts_entries;
+    MOVStts *stts_entries;
     uint32_t entries = -1;
     uint32_t atom_size;
     int i;
@@ -758,7 +855,7 @@ static int mov_write_dref_tag(ByteIOContext *pb)
 
 static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "stbl");
     mov_write_stsd_tag(pb, track);
@@ -777,13 +874,37 @@ static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)
 
 static int mov_write_dinf_tag(ByteIOContext *pb)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "dinf");
     mov_write_dref_tag(pb);
     return updateSize(pb, pos);
 }
 
+static int mov_write_nmhd_tag(ByteIOContext *pb)
+{
+    put_be32(pb, 12);
+    put_tag(pb, "nmhd");
+    put_be32(pb, 0);
+    return 12;
+}
+
+static int mov_write_gmhd_tag(ByteIOContext *pb)
+{
+    put_be32(pb, 0x20);   /* size */
+    put_tag(pb, "gmhd");
+    put_be32(pb, 0x18);   /* gmin size */
+    put_tag(pb, "gmin");  /* generic media info */
+    put_be32(pb, 0);      /* version & flags */
+    put_be16(pb, 0x40);   /* graphics mode = */
+    put_be16(pb, 0x8000); /* opColor (r?) */
+    put_be16(pb, 0x8000); /* opColor (g?) */
+    put_be16(pb, 0x8000); /* opColor (b?) */
+    put_be16(pb, 0);      /* balance */
+    put_be16(pb, 0);      /* reserved */
+    return 0x20;
+}
+
 static int mov_write_smhd_tag(ByteIOContext *pb)
 {
     put_be32(pb, 16); /* size */
@@ -805,8 +926,8 @@ static int mov_write_vmhd_tag(ByteIOContext *pb)
 
 static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    const char *descr, *hdlr, *hdlr_type;
-    offset_t pos = url_ftell(pb);
+    const char *hdlr, *descr = NULL, *hdlr_type = NULL;
+    int64_t pos = url_ftell(pb);
 
     if (!track) { /* no media --> data handler */
         hdlr = "dhlr";
@@ -817,9 +938,13 @@ static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
         if (track->enc->codec_type == CODEC_TYPE_VIDEO) {
             hdlr_type = "vide";
             descr = "VideoHandler";
-        } else {
+        } else if (track->enc->codec_type == CODEC_TYPE_AUDIO) {
             hdlr_type = "soun";
             descr = "SoundHandler";
+        } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+            if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";
+            else                                      hdlr_type = "text";
+            descr = "SubtitleHandler";
         }
     }
 
@@ -838,13 +963,17 @@ static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
 
 static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "minf");
     if(track->enc->codec_type == CODEC_TYPE_VIDEO)
         mov_write_vmhd_tag(pb);
-    else
+    else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
         mov_write_smhd_tag(pb);
+    else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
+        if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb);
+        else                                      mov_write_nmhd_tag(pb);
+    }
     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
         mov_write_hdlr_tag(pb, NULL);
     mov_write_dinf_tag(pb);
@@ -884,7 +1013,7 @@ static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack *track)
 
 static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack *track)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "mdia");
     mov_write_mdhd_tag(pb, track);
@@ -935,11 +1064,13 @@ static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
     put_be32(pb, 0x40000000); /* reserved */
 
     /* Track width and height, for visual only */
-    if(track->enc->codec_type == CODEC_TYPE_VIDEO) {
+    if(track->enc->codec_type == CODEC_TYPE_VIDEO ||
+       track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
         double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
-        if(!sample_aspect_ratio) sample_aspect_ratio = 1;
+        if(!sample_aspect_ratio || track->height != track->enc->height)
+            sample_aspect_ratio = 1;
         put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
-        put_be32(pb, track->enc->height*0x10000);
+        put_be32(pb, track->height*0x10000);
     }
     else {
         put_be32(pb, 0);
@@ -986,7 +1117,7 @@ static int mov_write_uuid_tag_psp(ByteIOContext *pb, MOVTrack *mov)
 
 static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "trak");
     mov_write_tkhd_tag(pb, track, st);
@@ -1000,7 +1131,7 @@ static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
 
 #if 0
 /* TODO: Not sorted out, but not necessary either */
-static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_iods_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     put_be32(pb, 0x15); /* size */
     put_tag(pb, "iods");
@@ -1014,7 +1145,7 @@ static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
 }
 #endif
 
-static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_mvhd_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     int maxTrackID = 1, i;
     int64_t maxTrackLenTemp, maxTrackLen = 0;
@@ -1072,10 +1203,10 @@ static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
     return 0x6c;
 }
 
-static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVMuxContext *mov,
                                      AVFormatContext *s)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "hdlr");
     put_be32(pb, 0);
@@ -1089,10 +1220,10 @@ static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext *mov,
 }
 
 /* helper function to write a data tag with the specified string as data */
-static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int long_style)
+static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int lang, int long_style)
 {
     if(long_style){
-        offset_t pos = url_ftell(pb);
+        int64_t pos = url_ftell(pb);
         put_be32(pb, 0); /* size */
         put_tag(pb, "data");
         put_be32(pb, 1);
@@ -1101,52 +1232,66 @@ static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int lo
         return updateSize(pb, pos);
     }else{
         put_be16(pb, strlen(data)); /* string length */
-        put_be16(pb, 0);
+        put_be16(pb, lang);
         put_buffer(pb, data, strlen(data));
         return strlen(data) + 4;
     }
 }
 
-static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char *value, int long_style){
+static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char *value, int lang, int long_style){
     int size = 0;
     if (value && value[0]) {
-        offset_t pos = url_ftell(pb);
+        int64_t pos = url_ftell(pb);
         put_be32(pb, 0); /* size */
         put_tag(pb, name);
-        mov_write_string_data_tag(pb, value, long_style);
+        mov_write_string_data_tag(pb, value, lang, long_style);
         size= updateSize(pb, pos);
     }
     return size;
 }
 
-/* iTunes year */
-static int mov_write_day_tag(ByteIOContext *pb, int year, int long_style)
+static int mov_write_string_metadata(AVFormatContext *s, ByteIOContext *pb,
+                                     const char *name, const char *tag,
+                                     int long_style)
 {
-    if(year){
-        char year_str[5];
-        snprintf(year_str, sizeof(year_str), "%04d", year);
-        return mov_write_string_tag(pb, "\251day", year_str, long_style);
-    }else
+    int l, lang = 0, len, len2;
+    AVMetadataTag *t, *t2 = NULL;
+    char tag2[16];
+
+    if (!(t = av_metadata_get(s->metadata, tag, NULL, 0)))
         return 0;
+
+    len = strlen(t->key);
+    snprintf(tag2, sizeof(tag2), "%s-", tag);
+    while ((t2 = av_metadata_get(s->metadata, tag2, t2, AV_METADATA_IGNORE_SUFFIX))) {
+        len2 = strlen(t2->key);
+        if (len2 == len+4 && !strcmp(t->value, t2->value)
+            && (l=ff_mov_iso639_to_lang(&t2->key[len2-3], 0)) >= 0) {
+            lang = l;
+            break;
+        }
+    }
+    return mov_write_string_tag(pb, name, t->value, lang, long_style);
 }
 
 /* iTunes track number */
-static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_trkn_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
-    int size = 0;
-    if (s->track) {
-        offset_t pos = url_ftell(pb);
+    AVMetadataTag *t = av_metadata_get(s->metadata, "track", NULL, 0);
+    int size = 0, track = t ? atoi(t->value) : 0;
+    if (track) {
+        int64_t pos = url_ftell(pb);
         put_be32(pb, 0); /* size */
         put_tag(pb, "trkn");
         {
-            offset_t pos = url_ftell(pb);
+            int64_t pos = url_ftell(pb);
             put_be32(pb, 0); /* size */
             put_tag(pb, "data");
             put_be32(pb, 0);        // 8 bytes empty
             put_be32(pb, 0);
             put_be16(pb, 0);        // empty
-            put_be16(pb, s->track); // track number
+            put_be16(pb, track);    // track number
             put_be16(pb, 0);        // total track number
             put_be16(pb, 0);        // empty
             updateSize(pb, pos);
@@ -1157,41 +1302,37 @@ static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext *mov,
 }
 
 /* iTunes meta data list */
-static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_ilst_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size */
     put_tag(pb, "ilst");
-    mov_write_string_tag(pb, "\251nam", s->title         , 1);
-    mov_write_string_tag(pb, "\251ART", s->author        , 1);
-    mov_write_string_tag(pb, "\251wrt", s->author        , 1);
-    mov_write_string_tag(pb, "\251alb", s->album         , 1);
-    mov_write_day_tag(pb, s->year ,1);
-    mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 1);
-    mov_write_string_tag(pb, "\251cmt", s->comment       , 1);
-    mov_write_string_tag(pb, "\251gen", s->genre         , 1);
+    mov_write_string_metadata(s, pb, "\251nam", "title"    , 1);
+    mov_write_string_metadata(s, pb, "\251ART", "author"   , 1);
+    mov_write_string_metadata(s, pb, "\251wrt", "author"   , 1);
+    mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);
+    mov_write_string_metadata(s, pb, "\251day", "year"     , 1);
+    mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
+    mov_write_string_metadata(s, pb, "\251cmt", "comment"  , 1);
+    mov_write_string_metadata(s, pb, "\251gen", "genre"    , 1);
+    mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1);
     mov_write_trkn_tag(pb, mov, s);
     return updateSize(pb, pos);
 }
 
 /* iTunes meta data tag */
-static int mov_write_meta_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_meta_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     int size = 0;
-
-    // only save meta tag if required
-    if (s->title[0] || s->author[0] || s->album[0] || s->year ||
-        s->comment[0] || s->genre[0] || s->track) {
-        offset_t pos = url_ftell(pb);
-        put_be32(pb, 0); /* size */
-        put_tag(pb, "meta");
-        put_be32(pb, 0);
-        mov_write_itunes_hdlr_tag(pb, mov, s);
-        mov_write_ilst_tag(pb, mov, s);
-        size = updateSize(pb, pos);
-    }
+    int64_t pos = url_ftell(pb);
+    put_be32(pb, 0); /* size */
+    put_tag(pb, "meta");
+    put_be32(pb, 0);
+    mov_write_itunes_hdlr_tag(pb, mov, s);
+    mov_write_ilst_tag(pb, mov, s);
+    size = updateSize(pb, pos);
     return size;
 }
 
@@ -1225,62 +1366,68 @@ static uint16_t language_code(const char *str)
 static int mov_write_3gp_udta_tag(ByteIOContext *pb, AVFormatContext *s,
                                   const char *tag, const char *str)
 {
-    offset_t pos = url_ftell(pb);
-    if (!utf8len(str))
+    int64_t pos = url_ftell(pb);
+    AVMetadataTag *t = av_metadata_get(s->metadata, str, NULL, 0);
+    if (!t || !utf8len(t->value))
         return 0;
     put_be32(pb, 0);   /* size */
     put_tag (pb, tag); /* type */
     put_be32(pb, 0);   /* version + flags */
     if (!strcmp(tag, "yrrc"))
-        put_be16(pb, s->year);
+        put_be16(pb, atoi(t->value));
     else {
         put_be16(pb, language_code("eng")); /* language */
-        ascii_to_wc(pb, str);
-        if (!strcmp(tag, "albm") && s->year)
-            put_byte(pb, s->year);
+        ascii_to_wc(pb, t->value);
+        if (!strcmp(tag, "albm") &&
+            (t = av_metadata_get(s->metadata, "year", NULL, 0)))
+            put_byte(pb, atoi(t->value));
     }
     return updateSize(pb, pos);
 }
 
-static int mov_write_udta_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_udta_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
-    int i;
-    int bitexact = 0;
+    ByteIOContext *pb_buf;
+    int i, ret, size;
+    uint8_t *buf;
 
     for (i = 0; i < s->nb_streams; i++)
         if (mov->tracks[i].enc->flags & CODEC_FLAG_BITEXACT) {
-            bitexact = 1;
-            break;
+            return 0;
         }
 
-    if (!bitexact && (s->title[0] || s->author[0] || s->album[0] || s->year ||
-                      s->comment[0] || s->genre[0]  || s->track)) {
-        offset_t pos = url_ftell(pb);
-
-        put_be32(pb, 0); /* size */
-        put_tag(pb, "udta");
+    ret = url_open_dyn_buf(&pb_buf);
+    if(ret < 0)
+        return ret;
 
         if (mov->mode & MODE_3GP) {
-            mov_write_3gp_udta_tag(pb, s, "titl", s->title);
-            mov_write_3gp_udta_tag(pb, s, "auth", s->author);
-            mov_write_3gp_udta_tag(pb, s, "gnre", s->genre);
-            mov_write_3gp_udta_tag(pb, s, "dscp", s->comment);
-            mov_write_3gp_udta_tag(pb, s, "albm", s->album);
-            mov_write_3gp_udta_tag(pb, s, "yrrc", "nil");
+            mov_write_3gp_udta_tag(pb_buf, s, "titl", "title");
+            mov_write_3gp_udta_tag(pb_buf, s, "auth", "author");
+            mov_write_3gp_udta_tag(pb_buf, s, "gnre", "genre");
+            mov_write_3gp_udta_tag(pb_buf, s, "dscp", "comment");
+            mov_write_3gp_udta_tag(pb_buf, s, "albm", "album");
+            mov_write_3gp_udta_tag(pb_buf, s, "cprt", "copyright");
+            mov_write_3gp_udta_tag(pb_buf, s, "yrrc", "year");
         } else if (mov->mode == MODE_MOV) { // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
-            mov_write_string_tag(pb, "\251nam", s->title         , 0);
-            mov_write_string_tag(pb, "\251aut", s->author        , 0);
-            mov_write_string_tag(pb, "\251alb", s->album         , 0);
-            mov_write_day_tag(pb, s->year, 0);
-            mov_write_string_tag(pb, "\251enc", LIBAVFORMAT_IDENT, 0);
-            mov_write_string_tag(pb, "\251des", s->comment       , 0);
-            mov_write_string_tag(pb, "\251gen", s->genre         , 0);
+            mov_write_string_metadata(s, pb_buf, "\251nam", "title"      , 0);
+            mov_write_string_metadata(s, pb_buf, "\251aut", "author"     , 0);
+            mov_write_string_metadata(s, pb_buf, "\251alb", "album"      , 0);
+            mov_write_string_metadata(s, pb_buf, "\251day", "year"       , 0);
+            mov_write_string_tag(pb_buf, "\251enc", LIBAVFORMAT_IDENT, 0, 0);
+            mov_write_string_metadata(s, pb_buf, "\251des", "comment"    , 0);
+            mov_write_string_metadata(s, pb_buf, "\251gen", "genre"      , 0);
+            mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright"  , 0);
         } else {
             /* iTunes meta data */
-            mov_write_meta_tag(pb, mov, s);
+            mov_write_meta_tag(pb_buf, mov, s);
         }
-        return updateSize(pb, pos);
+
+    if ((size = url_close_dyn_buf(pb_buf, &buf)) > 0) {
+        put_be32(pb, size+8);
+        put_tag(pb, "udta");
+        put_buffer(pb, buf, size);
+        av_free(buf);
     }
 
     return 0;
@@ -1301,9 +1448,10 @@ static void mov_write_psp_udta_tag(ByteIOContext *pb,
 
 static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)
 {
-    offset_t pos, pos2;
+    AVMetadataTag *title = av_metadata_get(s->metadata, "title", NULL, 0);
+    int64_t pos, pos2;
 
-    if (s->title[0]) {
+    if (title) {
         pos = url_ftell(pb);
         put_be32(pb, 0); /* size placeholder*/
         put_tag(pb, "uuid");
@@ -1325,7 +1473,7 @@ static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)
         put_be16(pb, 0x021C);               /* data */
 
         mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
-        mov_write_psp_udta_tag(pb, s->title,              "eng", 0x01);
+        mov_write_psp_udta_tag(pb, title->value,          "eng", 0x01);
 //        snprintf(dt,32,"%04d/%02d/%02d %02d:%02d:%02d",t_st->tm_year+1900,t_st->tm_mon+1,t_st->tm_mday,t_st->tm_hour,t_st->tm_min,t_st->tm_sec);
         mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);
 
@@ -1336,11 +1484,11 @@ static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)
     return 0;
 }
 
-static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_moov_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     int i;
-    offset_t pos = url_ftell(pb);
+    int64_t pos = url_ftell(pb);
     put_be32(pb, 0); /* size placeholder*/
     put_tag(pb, "moov");
     mov->timescale = globalTimescale;
@@ -1368,7 +1516,7 @@ static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
     return updateSize(pb, pos);
 }
 
-static int mov_write_mdat_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_mdat_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     put_be32(pb, 8);    // placeholder for extended size field (64 bit)
     put_tag(pb, mov->mode == MODE_MOV ? "wide" : "free");
@@ -1382,8 +1530,8 @@ static int mov_write_mdat_tag(ByteIOContext *pb, MOVContext *mov)
 /* TODO: This needs to be more general */
 static int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
 {
-    MOVContext *mov = s->priv_data;
-    offset_t pos = url_ftell(pb);
+    MOVMuxContext *mov = s->priv_data;
+    int64_t pos = url_ftell(pb);
     int has_h264 = 0, has_video = 0;
     int minor = 0x200;
     int i;
@@ -1500,7 +1648,7 @@ static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
 static int mov_write_header(AVFormatContext *s)
 {
     ByteIOContext *pb = s->pb;
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     int i;
 
     if (url_is_streamed(s->pb)) {
@@ -1528,20 +1676,36 @@ static int mov_write_header(AVFormatContext *s)
         }
     }
 
+    mov->tracks = av_mallocz(s->nb_streams*sizeof(*mov->tracks));
+    if (!mov->tracks)
+        return AVERROR(ENOMEM);
+
     for(i=0; i<s->nb_streams; i++){
         AVStream *st= s->streams[i];
         MOVTrack *track= &mov->tracks[i];
+        AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
 
         track->enc = st->codec;
-        track->language = ff_mov_iso639_to_lang(st->language, mov->mode != MODE_MOV);
+        track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);
+        if (track->language < 0)
+            track->language = 0;
         track->mode = mov->mode;
         track->tag = mov_find_codec_tag(s, track);
         if (!track->tag) {
             av_log(s, AV_LOG_ERROR, "track %d: could not find tag, "
                    "codec not currently supported in container\n", i);
-            return -1;
+            goto error;
         }
         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+            if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
+                track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
+                track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {
+                if (st->codec->width != 720 || (st->codec->height != 608 && st->codec->height != 512)) {
+                    av_log(s, AV_LOG_ERROR, "D-10/IMX must use 720x608 or 720x512 video resolution\n");
+                    goto error;
+                }
+                track->height = track->tag>>24 == 'n' ? 486 : 576;
+            }
             track->timescale = st->codec->time_base.den;
             av_set_pts_info(st, 64, 1, st->codec->time_base.den);
             if (track->mode == MODE_MOV && track->timescale > 100000)
@@ -1552,15 +1716,27 @@ static int mov_write_header(AVFormatContext *s)
         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO){
             track->timescale = st->codec->sample_rate;
             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
-            if(!st->codec->frame_size){
+            if(!st->codec->frame_size && !av_get_bits_per_sample(st->codec->codec_id)) {
                 av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);
-                return -1;
+                goto error;
             }else if(st->codec->frame_size > 1){ /* assume compressed audio */
                 track->audio_vbr = 1;
             }else{
+                st->codec->frame_size = 1;
                 track->sampleSize = (av_get_bits_per_sample(st->codec->codec_id) >> 3) * st->codec->channels;
             }
+            if(track->mode != MODE_MOV &&
+               track->enc->codec_id == CODEC_ID_MP3 && track->enc->sample_rate < 16000){
+                av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not supported\n",
+                       i, track->enc->sample_rate);
+                goto error;
+            }
+        }else if(st->codec->codec_type == CODEC_TYPE_SUBTITLE){
+            track->timescale = st->codec->time_base.den;
+            av_set_pts_info(st, 64, 1, st->codec->time_base.den);
         }
+        if (!track->height)
+            track->height = st->codec->height;
     }
 
     mov_write_mdat_tag(pb, mov);
@@ -1570,11 +1746,14 @@ static int mov_write_header(AVFormatContext *s)
     put_flush_packet(pb);
 
     return 0;
+ error:
+    av_freep(&mov->tracks);
+    return -1;
 }
 
 static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     ByteIOContext *pb = s->pb;
     MOVTrack *trk = &mov->tracks[pkt->stream_index];
     AVCodecContext *enc = trk->enc;
@@ -1613,12 +1792,13 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
     if (enc->codec_id == CODEC_ID_H264 && trk->vosLen > 0 && *(uint8_t *)trk->vosData != 1) {
         /* from x264 or from bytestream h264 */
         /* nal reformating needed */
-        int ret = ff_avc_parse_nal_units(pkt->data, &pkt->data, &pkt->size);
-        if (ret < 0)
-            return ret;
-        assert(pkt->size);
-        size = pkt->size;
-    } else if (enc->codec_id == CODEC_ID_DNXHD && !trk->vosLen) {
+        size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
+    } else {
+        put_buffer(pb, pkt->data, size);
+    }
+
+    if ((enc->codec_id == CODEC_ID_DNXHD ||
+                enc->codec_id == CODEC_ID_AC3) && !trk->vosLen) {
         /* copy frame to create needed atoms */
         trk->vosLen = size;
         trk->vosData = av_malloc(size);
@@ -1633,7 +1813,7 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
             return -1;
     }
 
-    trk->cluster[trk->entry].pos = url_ftell(pb);
+    trk->cluster[trk->entry].pos = url_ftell(pb) - size;
     trk->cluster[trk->entry].samplesInChunk = samplesInChunk;
     trk->cluster[trk->entry].size = size;
     trk->cluster[trk->entry].entries = samplesInChunk;
@@ -1654,20 +1834,18 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
     trk->sampleCount += samplesInChunk;
     mov->mdat_size += size;
 
-    put_buffer(pb, pkt->data, size);
-
     put_flush_packet(pb);
     return 0;
 }
 
 static int mov_write_trailer(AVFormatContext *s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     ByteIOContext *pb = s->pb;
     int res = 0;
     int i;
 
-    offset_t moov_pos = url_ftell(pb);
+    int64_t moov_pos = url_ftell(pb);
 
     /* Write size of mdat tag */
     if (mov->mdat_size+8 <= UINT32_MAX) {
@@ -1693,32 +1871,34 @@ static int mov_write_trailer(AVFormatContext *s)
 
     put_flush_packet(pb);
 
+    av_freep(&mov->tracks);
+
     return res;
 }
 
-#ifdef CONFIG_MOV_MUXER
+#if CONFIG_MOV_MUXER
 AVOutputFormat mov_muxer = {
     "mov",
     NULL_IF_CONFIG_SMALL("MOV format"),
     NULL,
     "mov",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
     mov_write_packet,
     mov_write_trailer,
-    .flags = AVFMT_GLOBALHEADER,
+    .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
     .codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
 };
 #endif
-#ifdef CONFIG_TGP_MUXER
+#if CONFIG_TGP_MUXER
 AVOutputFormat tgp_muxer = {
     "3gp",
     NULL_IF_CONFIG_SMALL("3GP format"),
     NULL,
     "3gp",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AMR_NB,
     CODEC_ID_H263,
     mov_write_header,
@@ -1728,29 +1908,29 @@ AVOutputFormat tgp_muxer = {
     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
 };
 #endif
-#ifdef CONFIG_MP4_MUXER
+#if CONFIG_MP4_MUXER
 AVOutputFormat mp4_muxer = {
     "mp4",
     NULL_IF_CONFIG_SMALL("MP4 format"),
     "application/mp4",
     "mp4",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
     mov_write_packet,
     mov_write_trailer,
-    .flags = AVFMT_GLOBALHEADER,
+    .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
 };
 #endif
-#ifdef CONFIG_PSP_MUXER
+#if CONFIG_PSP_MUXER
 AVOutputFormat psp_muxer = {
     "psp",
     NULL_IF_CONFIG_SMALL("PSP MP4 format"),
     NULL,
     "mp4,psp",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
@@ -1760,13 +1940,13 @@ AVOutputFormat psp_muxer = {
     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
 };
 #endif
-#ifdef CONFIG_TG2_MUXER
+#if CONFIG_TG2_MUXER
 AVOutputFormat tg2_muxer = {
     "3g2",
     NULL_IF_CONFIG_SMALL("3GP2 format"),
     NULL,
     "3g2",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AMR_NB,
     CODEC_ID_H263,
     mov_write_header,
@@ -1776,19 +1956,19 @@ AVOutputFormat tg2_muxer = {
     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
 };
 #endif
-#ifdef CONFIG_IPOD_MUXER
+#if CONFIG_IPOD_MUXER
 AVOutputFormat ipod_muxer = {
     "ipod",
     NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
     "application/mp4",
     "m4v,m4a",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_H264,
     mov_write_header,
     mov_write_packet,
     mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
-    .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
+    .codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
 };
 #endif