falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
18662 Commits
32 Branches
552MB
Tree: 7943a90a0d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7943a90a0d'
${ noResults }
FFmpeg/libavformat/movenc.c

1952 lines
63KB
Raw Blame History 

  1. /*

  2.  * MOV, 3GP, MP4 muxer

  3.  * Copyright (c) 2003 Thomas Raivio

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

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

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

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

  10.  * License as published by the Free Software Foundation; either

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

  12.  *

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

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

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

  16.  * Lesser General Public License for more details.

  17.  *

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

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

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

  21.  */

  22. #include "avformat.h"

  23. #include "riff.h"

  24. #include "avio.h"

  25. #include "isom.h"

  26. #include "avc.h"

  27. #include "libavcodec/bitstream.h"

  28. 

  29. #undef NDEBUG

  30. #include <assert.h>

  31. 

  32. #define MOV_INDEX_CLUSTER_SIZE 16384

  33. #define globalTimescale 1000

  34. 

  35. #define MODE_MP4  0x01

  36. #define MODE_MOV  0x02

  37. #define MODE_3GP  0x04

  38. #define MODE_PSP  0x08 // example working PSP command line:

  39. // ffmpeg -i testinput.avi  -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4

  40. #define MODE_3G2  0x10

  41. #define MODE_IPOD 0x20

  42. 

  43. typedef struct MOVIentry {

  44.     unsigned int flags, size;

  45.     uint64_t     pos;

  46.     unsigned int samplesInChunk;

  47.     char         key_frame;

  48.     unsigned int entries;

  49.     int64_t      cts;

  50.     int64_t      dts;

  51. } MOVIentry;

  52. 

  53. typedef struct MOVIndex {

  54.     int         mode;

  55.     int         entry;

  56.     long        timescale;

  57.     long        time;

  58.     int64_t     trackDuration;

  59.     long        sampleCount;

  60.     long        sampleSize;

  61.     int         hasKeyframes;

  62.     int         hasBframes;

  63.     int         language;

  64.     int         trackID;

  65.     int         tag; ///< stsd fourcc

  66.     AVCodecContext *enc;

  67. 

  68.     int         vosLen;

  69.     uint8_t     *vosData;

  70.     MOVIentry   *cluster;

  71.     int         audio_vbr;

  72.     int         height; ///< active picture (w/o VBI) height for D-10/IMX

  73. } MOVTrack;

  74. 

  75. typedef struct MOVMuxContext {

  76.     int     mode;

  77.     int64_t time;

  78.     int     nb_streams;

  79.     int64_t mdat_pos;

  80.     uint64_t mdat_size;

  81.     long    timescale;

  82.     MOVTrack tracks[MAX_STREAMS];

  83. } MOVMuxContext;

  84. 

  85. //FIXME support 64 bit variant with wide placeholders

  86. static int64_t updateSize(ByteIOContext *pb, int64_t pos)

  87. {

  88.     int64_t curpos = url_ftell(pb);

  89.     url_fseek(pb, pos, SEEK_SET);

  90.     put_be32(pb, curpos - pos); /* rewrite size */

  91.     url_fseek(pb, curpos, SEEK_SET);

  92. 

  93.     return curpos - pos;

  94. }

  95. 

  96. /* Chunk offset atom */

  97. static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack *track)

  98. {

  99.     int i;

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

  101.     int64_t pos = url_ftell(pb);

  102.     put_be32(pb, 0); /* size */

  103.     if (pos > UINT32_MAX) {

  104.         mode64 = 1;

  105.         put_tag(pb, "co64");

  106.     } else

  107.         put_tag(pb, "stco");

  108.     put_be32(pb, 0); /* version & flags */

  109.     put_be32(pb, track->entry); /* entry count */

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

  111.         if(mode64 == 1)

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

  113.         else

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

  115.     }

  116.     return updateSize(pb, pos);

  117. }

  118. 

  119. /* Sample size atom */

  120. static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack *track)

  121. {

  122.     int equalChunks = 1;

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

  124. 

  125.     int64_t pos = url_ftell(pb);

  126.     put_be32(pb, 0); /* size */

  127.     put_tag(pb, "stsz");

  128.     put_be32(pb, 0); /* version & flags */

  129. 

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

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

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

  133.             equalChunks = 0;

  134.         }

  135.         oldtst = tst;

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

  137.     }

  138.     if (equalChunks) {

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

  140.         put_be32(pb, sSize); // sample size

  141.         put_be32(pb, entries); // sample count

  142.     }

  143.     else {

  144.         put_be32(pb, 0); // sample size

  145.         put_be32(pb, entries); // sample count

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

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

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

  149.                          track->cluster[i].entries);

  150.             }

  151.         }

  152.     }

  153.     return updateSize(pb, pos);

  154. }

  155. 

  156. /* Sample to chunk atom */

  157. static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack *track)

  158. {

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

  160.     int64_t entryPos, curpos;

  161. 

  162.     int64_t pos = url_ftell(pb);

  163.     put_be32(pb, 0); /* size */

  164.     put_tag(pb, "stsc");

  165.     put_be32(pb, 0); // version & flags

  166.     entryPos = url_ftell(pb);

  167.     put_be32(pb, track->entry); // entry count

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

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

  170.         {

  171.             put_be32(pb, i+1); // first chunk

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

  173.             put_be32(pb, 0x1); // sample description index

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

  175.             index++;

  176.         }

  177.     }

  178.     curpos = url_ftell(pb);

  179.     url_fseek(pb, entryPos, SEEK_SET);

  180.     put_be32(pb, index); // rewrite size

  181.     url_fseek(pb, curpos, SEEK_SET);

  182. 

  183.     return updateSize(pb, pos);

  184. }

  185. 

  186. /* Sync sample atom */

  187. static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack *track)

  188. {

  189.     int64_t curpos, entryPos;

  190.     int i, index = 0;

  191.     int64_t pos = url_ftell(pb);

  192.     put_be32(pb, 0); // size

  193.     put_tag(pb, "stss");

  194.     put_be32(pb, 0); // version & flags

  195.     entryPos = url_ftell(pb);

  196.     put_be32(pb, track->entry); // entry count

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

  198.         if(track->cluster[i].key_frame == 1) {

  199.             put_be32(pb, i+1);

  200.             index++;

  201.         }

  202.     }

  203.     curpos = url_ftell(pb);

  204.     url_fseek(pb, entryPos, SEEK_SET);

  205.     put_be32(pb, index); // rewrite size

  206.     url_fseek(pb, curpos, SEEK_SET);

  207.     return updateSize(pb, pos);

  208. }

  209. 

  210. static int mov_write_amr_tag(ByteIOContext *pb, MOVTrack *track)

  211. {

  212.     put_be32(pb, 0x11); /* size */

  213.     if (track->mode == MODE_MOV) put_tag(pb, "samr");

  214.     else                         put_tag(pb, "damr");

  215.     put_tag(pb, "FFMP");

  216.     put_byte(pb, 0); /* decoder version */

  217. 

  218.     put_be16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */

  219.     put_byte(pb, 0x00); /* Mode change period (no restriction) */

  220.     put_byte(pb, 0x01); /* Frames per sample */

  221.     return 0x11;

  222. }

  223. 

  224. static int mov_write_ac3_tag(ByteIOContext *pb, MOVTrack *track)

  225. {

  226.     GetBitContext gbc;

  227.     PutBitContext pbc;

  228.     uint8_t buf[3];

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

  230. 

  231.     if (track->vosLen < 7)

  232.         return -1;

  233. 

  234.     put_be32(pb, 11);

  235.     put_tag(pb, "dac3");

  236. 

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

  238.     fscod      = get_bits(&gbc, 2);

  239.     frmsizecod = get_bits(&gbc, 6);

  240.     bsid       = get_bits(&gbc, 5);

  241.     bsmod      = get_bits(&gbc, 3);

  242.     acmod      = get_bits(&gbc, 3);

  243.     if (acmod == 2) {

  244.         skip_bits(&gbc, 2); // dsurmod

  245.     } else {

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

  247.             skip_bits(&gbc, 2); // cmixlev

  248.         if (acmod & 4)

  249.             skip_bits(&gbc, 2); // surmixlev

  250.     }

  251.     lfeon = get_bits1(&gbc);

  252. 

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

  254.     put_bits(&pbc, 2, fscod);

  255.     put_bits(&pbc, 5, bsid);

  256.     put_bits(&pbc, 3, bsmod);

  257.     put_bits(&pbc, 3, acmod);

  258.     put_bits(&pbc, 1, lfeon);

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

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

  261. 

  262.     flush_put_bits(&pbc);

  263.     put_buffer(pb, buf, sizeof(buf));

  264. 

  265.     return 11;

  266. }

  267. 

  268. /**

  269.  * This function writes extradata "as is".

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

  271.  */

  272. static int mov_write_extradata_tag(ByteIOContext *pb, MOVTrack *track)

  273. {

  274.     put_buffer(pb, track->enc->extradata, track->enc->extradata_size);

  275.     return track->enc->extradata_size;

  276. }

  277. 

  278. static int mov_write_enda_tag(ByteIOContext *pb)

  279. {

  280.     put_be32(pb, 10);

  281.     put_tag(pb, "enda");

  282.     put_be16(pb, 1); /* little endian */

  283.     return 10;

  284. }

  285. 

  286. static unsigned int descrLength(unsigned int len)

  287. {

  288.     int i;

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

  290.     return len + 1 + i;

  291. }

  292. 

  293. static void putDescr(ByteIOContext *pb, int tag, unsigned int size)

  294. {

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

  296.     put_byte(pb, tag);

  297.     for(; i>0; i--)

  298.         put_byte(pb, (size>>(7*i)) | 0x80);

  299.     put_byte(pb, size & 0x7F);

  300. }

  301. 

  302. static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack *track) // Basic

  303. {

  304.     int64_t pos = url_ftell(pb);

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

  306. 

  307.     put_be32(pb, 0); // size

  308.     put_tag(pb, "esds");

  309.     put_be32(pb, 0); // Version

  310. 

  311.     // ES descriptor

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

  313.              descrLength(1));

  314.     put_be16(pb, track->trackID);

  315.     put_byte(pb, 0x00); // flags (= no flags)

  316. 

  317.     // DecoderConfig descriptor

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

  319. 

  320.     // Object type indication

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

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

  323.         track->enc->sample_rate > 24000)

  324.         put_byte(pb, 0x6B); // 11172-3

  325.     else

  326.         put_byte(pb, codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));

  327. 

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

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

  330.     if(track->enc->codec_type == CODEC_TYPE_AUDIO)

  331.         put_byte(pb, 0x15); // flags (= Audiostream)

  332.     else

  333.         put_byte(pb, 0x11); // flags (= Visualstream)

  334. 

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

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

  337. 

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

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

  340.         put_be32(pb, 0); // vbr

  341.     else

  342.         put_be32(pb, track->enc->rc_max_rate); // avg bitrate

  343. 

  344.     if (track->vosLen) {

  345.         // DecoderSpecific info descriptor

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

  347.         put_buffer(pb, track->vosData, track->vosLen);

  348.     }

  349. 

  350.     // SL descriptor

  351.     putDescr(pb, 0x06, 1);

  352.     put_byte(pb, 0x02);

  353.     return updateSize(pb, pos);

  354. }

  355. 

  356. static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack *track)

  357. {

  358.     int64_t pos = url_ftell(pb);

  359. 

  360.     put_be32(pb, 0);     /* size */

  361.     put_tag(pb, "wave");

  362. 

  363.     put_be32(pb, 12);    /* size */

  364.     put_tag(pb, "frma");

  365.     put_le32(pb, track->tag);

  366. 

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

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

  369.         put_be32(pb, 12); /* size */

  370.         put_tag(pb, "mp4a");

  371.         put_be32(pb, 0);

  372.         mov_write_esds_tag(pb, track);

  373.     } else if (track->enc->codec_id == CODEC_ID_PCM_S24LE ||

  374.                track->enc->codec_id == CODEC_ID_PCM_S32LE) {

  375.         mov_write_enda_tag(pb);

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

  377.         mov_write_amr_tag(pb, track);

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

  379.         mov_write_ac3_tag(pb, track);

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

  381.         mov_write_extradata_tag(pb, track);

  382.     }

  383. 

  384.     put_be32(pb, 8);     /* size */

  385.     put_be32(pb, 0);     /* null tag */

  386. 

  387.     return updateSize(pb, pos);

  388. }

  389. 

  390. static int mov_write_glbl_tag(ByteIOContext *pb, MOVTrack *track)

  391. {

  392.     put_be32(pb, track->vosLen+8);

  393.     put_tag(pb, "glbl");

  394.     put_buffer(pb, track->vosData, track->vosLen);

  395.     return 8+track->vosLen;

  396. }

  397. 

  398. static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack *track)

  399. {

  400.     int64_t pos = url_ftell(pb);

  401.     int version = track->mode == MODE_MOV &&

  402.         (track->audio_vbr ||

  403.          track->enc->codec_id == CODEC_ID_PCM_S32LE ||

  404.          track->enc->codec_id == CODEC_ID_PCM_S24LE);

  405. 

  406.     put_be32(pb, 0); /* size */

  407.     put_le32(pb, track->tag); // store it byteswapped

  408.     put_be32(pb, 0); /* Reserved */

  409.     put_be16(pb, 0); /* Reserved */

  410.     put_be16(pb, 1); /* Data-reference index, XXX  == 1 */

  411. 

  412.     /* SoundDescription */

  413.     put_be16(pb, version); /* Version */

  414.     put_be16(pb, 0); /* Revision level */

  415.     put_be32(pb, 0); /* Reserved */

  416. 

  417.     if (track->mode == MODE_MOV) {

  418.         put_be16(pb, track->enc->channels);

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

  420.             track->enc->codec_id == CODEC_ID_PCM_S8)

  421.             put_be16(pb, 8); /* bits per sample */

  422.         else

  423.             put_be16(pb, 16);

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

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

  426.         put_be16(pb, 2);

  427.         put_be16(pb, 16);

  428.         put_be16(pb, 0);

  429.     }

  430. 

  431.     put_be16(pb, 0); /* packet size (= 0) */

  432.     put_be16(pb, track->timescale); /* Time scale */

  433.     put_be16(pb, 0); /* Reserved */

  434. 

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

  436.         put_be32(pb, track->enc->frame_size); /* Samples per packet */

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

  438.         put_be32(pb, track->sampleSize); /* Bytes per frame */

  439.         put_be32(pb, 2); /* Bytes per sample */

  440.     }

  441. 

  442.     if(track->mode == MODE_MOV &&

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

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

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

  446.         track->enc->codec_id == CODEC_ID_PCM_S24LE ||

  447.         track->enc->codec_id == CODEC_ID_PCM_S32LE ||

  448.         track->enc->codec_id == CODEC_ID_ALAC))

  449.         mov_write_wave_tag(pb, track);

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

  451.         mov_write_esds_tag(pb, track);

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

  453.         mov_write_amr_tag(pb, track);

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

  455.         mov_write_ac3_tag(pb, track);

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

  457.         mov_write_extradata_tag(pb, track);

  458.     else if(track->vosLen > 0)

  459.         mov_write_glbl_tag(pb, track);

  460. 

  461.     return updateSize(pb, pos);

  462. }

  463. 

  464. static int mov_write_d263_tag(ByteIOContext *pb)

  465. {

  466.     put_be32(pb, 0xf); /* size */

  467.     put_tag(pb, "d263");

  468.     put_tag(pb, "FFMP");

  469.     put_byte(pb, 0); /* decoder version */

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

  471.     put_byte(pb, 0xa); /* level */

  472.     put_byte(pb, 0); /* profile */

  473.     return 0xf;

  474. }

  475. 

  476. /* TODO: No idea about these values */

  477. static int mov_write_svq3_tag(ByteIOContext *pb)

  478. {

  479.     put_be32(pb, 0x15);

  480.     put_tag(pb, "SMI ");

  481.     put_tag(pb, "SEQH");

  482.     put_be32(pb, 0x5);

  483.     put_be32(pb, 0xe2c0211d);

  484.     put_be32(pb, 0xc0000000);

  485.     put_byte(pb, 0);

  486.     return 0x15;

  487. }

  488. 

  489. static int mov_write_avcc_tag(ByteIOContext *pb, MOVTrack *track)

  490. {

  491.     int64_t pos = url_ftell(pb);

  492. 

  493.     put_be32(pb, 0);

  494.     put_tag(pb, "avcC");

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

  496.     return updateSize(pb, pos);

  497. }

  498. 

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

  500. static int mov_write_avid_tag(ByteIOContext *pb, MOVTrack *track)

  501. {

  502.     int i;

  503.     put_be32(pb, 24); /* size */

  504.     put_tag(pb, "ACLR");

  505.     put_tag(pb, "ACLR");

  506.     put_tag(pb, "0001");

  507.     put_be32(pb, 1); /* yuv 1 / rgb 2 ? */

  508.     put_be32(pb, 0); /* unknown */

  509. 

  510.     put_be32(pb, 24); /* size */

  511.     put_tag(pb, "APRG");

  512.     put_tag(pb, "APRG");

  513.     put_tag(pb, "0001");

  514.     put_be32(pb, 1); /* unknown */

  515.     put_be32(pb, 0); /* unknown */

  516. 

  517.     put_be32(pb, 120); /* size */

  518.     put_tag(pb, "ARES");

  519.     put_tag(pb, "ARES");

  520.     put_tag(pb, "0001");

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

  522.     put_be32(pb, track->enc->width);

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

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

  525.         put_be32(pb, track->enc->height/2);

  526.         put_be32(pb, 2); /* unknown */

  527.         put_be32(pb, 0); /* unknown */

  528.         put_be32(pb, 4); /* unknown */

  529.     } else {

  530.         put_be32(pb, track->enc->height);

  531.         put_be32(pb, 1); /* unknown */

  532.         put_be32(pb, 0); /* unknown */

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

  534.             put_be32(pb, 5); /* unknown */

  535.         else

  536.             put_be32(pb, 6); /* unknown */

  537.     }

  538.     /* padding */

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

  540.         put_be64(pb, 0);

  541. 

  542.     /* extra padding for stsd needed */

  543.     put_be32(pb, 0);

  544.     return 0;

  545. }

  546. 

  547. static const AVCodecTag codec_3gp_tags[] = {

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

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

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

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

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

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

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

  555.     { CODEC_ID_NONE, 0 },

  556. };

  557. 

  558. static const AVCodecTag mov_pix_fmt_tags[] = {

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

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

  561.     { PIX_FMT_BGR555,  MKTAG('r','a','w',' ') },

  562.     { PIX_FMT_RGB24,   MKTAG('r','a','w',' ') },

  563.     { PIX_FMT_BGR32_1, MKTAG('r','a','w',' ') },

  564. };

  565. 

  566. static const AVCodecTag codec_ipod_tags[] = {

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

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

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

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

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

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

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

  574.     { CODEC_ID_NONE, 0 },

  575. };

  576. 

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

  578. {

  579.     int tag = track->enc->codec_tag;

  580.     if (track->mode == MODE_MP4 || track->mode == MODE_PSP) {

  581.         if (!codec_get_tag(ff_mp4_obj_type, track->enc->codec_id))

  582.             return 0;

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

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

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

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

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

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

  589.     } else if (track->mode == MODE_IPOD) {

  590.         if (track->enc->codec_type == CODEC_TYPE_SUBTITLE &&

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

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

  593.             track->tag = tag; // keep original tag

  594.         else

  595.         tag = codec_get_tag(codec_ipod_tags, track->enc->codec_id);

  596.         if (!match_ext(s->filename, "m4a") && !match_ext(s->filename, "m4v"))

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

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

  599.     } else if (track->mode & MODE_3GP) {

  600.         tag = codec_get_tag(codec_3gp_tags, track->enc->codec_id);

  601.     } else if (!tag || (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&

  602.                         (tag == MKTAG('d','v','c','p') ||

  603.                          track->enc->codec_id == CODEC_ID_RAWVIDEO))) {

  604.         if (track->enc->codec_id == CODEC_ID_DVVIDEO) {

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

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

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

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

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

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

  611.         } else if (track->enc->codec_id == CODEC_ID_RAWVIDEO) {

  612.             tag = codec_get_tag(mov_pix_fmt_tags, track->enc->pix_fmt);

  613.             if (!tag) // restore tag

  614.                 tag = track->enc->codec_tag;

  615.         } else {

  616.             if (track->enc->codec_type == CODEC_TYPE_VIDEO) {

  617.                 tag = codec_get_tag(codec_movvideo_tags, track->enc->codec_id);

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

  619.                     tag = codec_get_tag(codec_bmp_tags, track->enc->codec_id);

  620.                     if (tag)

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

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

  623.                 }

  624.             } else if (track->enc->codec_type == CODEC_TYPE_AUDIO) {

  625.                 tag = codec_get_tag(codec_movaudio_tags, track->enc->codec_id);

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

  627.                     int ms_tag = codec_get_tag(codec_wav_tags, track->enc->codec_id);

  628.                     if (ms_tag) {

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

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

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

  632.                     }

  633.                 }

  634.             } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {

  635.                 tag = codec_get_tag(ff_codec_movsubtitle_tags, track->enc->codec_id);

  636.             }

  637.         }

  638.     }

  639.     return tag;

  640. }

  641. 

  642. /** Write uuid atom.

  643.  * Needed to make file play in iPods running newest firmware

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

  645.  */

  646. static int mov_write_uuid_tag_ipod(ByteIOContext *pb)

  647. {

  648.     put_be32(pb, 28);

  649.     put_tag(pb, "uuid");

  650.     put_be32(pb, 0x6b6840f2);

  651.     put_be32(pb, 0x5f244fc5);

  652.     put_be32(pb, 0xba39a51b);

  653.     put_be32(pb, 0xcf0323f3);

  654.     put_be32(pb, 0x0);

  655.     return 28;

  656. }

  657. 

  658. static int mov_write_subtitle_tag(ByteIOContext *pb, MOVTrack *track)

  659. {

  660.     int64_t pos = url_ftell(pb);

  661.     put_be32(pb, 0);    /* size */

  662.     put_le32(pb, track->tag); // store it byteswapped

  663.     put_be32(pb, 0);    /* Reserved */

  664.     put_be16(pb, 0);    /* Reserved */

  665.     put_be16(pb, 1);    /* Data-reference index */

  666. 

  667.     if (track->enc->extradata_size)

  668.         put_buffer(pb, track->enc->extradata, track->enc->extradata_size);

  669. 

  670.     return updateSize(pb, pos);

  671. }

  672. 

  673. static int mov_write_video_tag(ByteIOContext *pb, MOVTrack *track)

  674. {

  675.     int64_t pos = url_ftell(pb);

  676.     char compressor_name[32];

  677. 

  678.     put_be32(pb, 0); /* size */

  679.     put_le32(pb, track->tag); // store it byteswapped

  680.     put_be32(pb, 0); /* Reserved */

  681.     put_be16(pb, 0); /* Reserved */

  682.     put_be16(pb, 1); /* Data-reference index */

  683. 

  684.     put_be16(pb, 0); /* Codec stream version */

  685.     put_be16(pb, 0); /* Codec stream revision (=0) */

  686.     if (track->mode == MODE_MOV) {

  687.         put_tag(pb, "FFMP"); /* Vendor */

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

  689.             put_be32(pb, 0); /* Temporal Quality */

  690.             put_be32(pb, 0x400); /* Spatial Quality = lossless*/

  691.         } else {

  692.             put_be32(pb, 0x200); /* Temporal Quality = normal */

  693.             put_be32(pb, 0x200); /* Spatial Quality = normal */

  694.         }

  695.     } else {

  696.         put_be32(pb, 0); /* Reserved */

  697.         put_be32(pb, 0); /* Reserved */

  698.         put_be32(pb, 0); /* Reserved */

  699.     }

  700.     put_be16(pb, track->enc->width); /* Video width */

  701.     put_be16(pb, track->height); /* Video height */

  702.     put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */

  703.     put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */

  704.     put_be32(pb, 0); /* Data size (= 0) */

  705.     put_be16(pb, 1); /* Frame count (= 1) */

  706. 

  707.     memset(compressor_name,0,32);

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

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

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

  711.     put_byte(pb, strlen(compressor_name));

  712.     put_buffer(pb, compressor_name, 31);

  713. 

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

  715.         put_be16(pb, track->enc->bits_per_coded_sample);

  716.     else

  717.         put_be16(pb, 0x18); /* Reserved */

  718.     put_be16(pb, 0xffff); /* Reserved */

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

  720.         mov_write_esds_tag(pb, track);

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

  722.         mov_write_d263_tag(pb);

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

  724.         mov_write_svq3_tag(pb);

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

  726.         mov_write_avid_tag(pb, track);

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

  728.         mov_write_avcc_tag(pb, track);

  729.         if(track->mode == MODE_IPOD)

  730.             mov_write_uuid_tag_ipod(pb);

  731.     } else if(track->vosLen > 0)

  732.         mov_write_glbl_tag(pb, track);

  733. 

  734.     return updateSize(pb, pos);

  735. }

  736. 

  737. static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)

  738. {

  739.     int64_t pos = url_ftell(pb);

  740.     put_be32(pb, 0); /* size */

  741.     put_tag(pb, "stsd");

  742.     put_be32(pb, 0); /* version & flags */

  743.     put_be32(pb, 1); /* entry count */

  744.     if (track->enc->codec_type == CODEC_TYPE_VIDEO)

  745.         mov_write_video_tag(pb, track);

  746.     else if (track->enc->codec_type == CODEC_TYPE_AUDIO)

  747.         mov_write_audio_tag(pb, track);

  748.     else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE)

  749.         mov_write_subtitle_tag(pb, track);

  750.     return updateSize(pb, pos);

  751. }

  752. 

  753. static int mov_write_ctts_tag(ByteIOContext *pb, MOVTrack *track)

  754. {

  755.     MOVStts *ctts_entries;

  756.     uint32_t entries = 0;

  757.     uint32_t atom_size;

  758.     int i;

  759. 

  760.     ctts_entries = av_malloc((track->entry + 1) * sizeof(*ctts_entries)); /* worst case */

  761.     ctts_entries[0].count = 1;

  762.     ctts_entries[0].duration = track->cluster[0].cts;

  763.     for (i=1; i<track->entry; i++) {

  764.         if (track->cluster[i].cts == ctts_entries[entries].duration) {

  765.             ctts_entries[entries].count++; /* compress */

  766.         } else {

  767.             entries++;

  768.             ctts_entries[entries].duration = track->cluster[i].cts;

  769.             ctts_entries[entries].count = 1;

  770.         }

  771.     }

  772.     entries++; /* last one */

  773.     atom_size = 16 + (entries * 8);

  774.     put_be32(pb, atom_size); /* size */

  775.     put_tag(pb, "ctts");

  776.     put_be32(pb, 0); /* version & flags */

  777.     put_be32(pb, entries); /* entry count */

  778.     for (i=0; i<entries; i++) {

  779.         put_be32(pb, ctts_entries[i].count);

  780.         put_be32(pb, ctts_entries[i].duration);

  781.     }

  782.     av_free(ctts_entries);

  783.     return atom_size;

  784. }

  785. 

  786. /* Time to sample atom */

  787. static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack *track)

  788. {

  789.     MOVStts *stts_entries;

  790.     uint32_t entries = -1;

  791.     uint32_t atom_size;

  792.     int i;

  793. 

  794.     if (track->enc->codec_type == CODEC_TYPE_AUDIO && !track->audio_vbr) {

  795.         stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */

  796.         stts_entries[0].count = track->sampleCount;

  797.         stts_entries[0].duration = 1;

  798.         entries = 1;

  799.     } else {

  800.         stts_entries = av_malloc(track->entry * sizeof(*stts_entries)); /* worst case */

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

  802.             int64_t duration = i + 1 == track->entry ?

  803.                 track->trackDuration - track->cluster[i].dts + track->cluster[0].dts : /* readjusting */

  804.                 track->cluster[i+1].dts - track->cluster[i].dts;

  805.             if (i && duration == stts_entries[entries].duration) {

  806.                 stts_entries[entries].count++; /* compress */

  807.             } else {

  808.                 entries++;

  809.                 stts_entries[entries].duration = duration;

  810.                 stts_entries[entries].count = 1;

  811.             }

  812.         }

  813.         entries++; /* last one */

  814.     }

  815.     atom_size = 16 + (entries * 8);

  816.     put_be32(pb, atom_size); /* size */

  817.     put_tag(pb, "stts");

  818.     put_be32(pb, 0); /* version & flags */

  819.     put_be32(pb, entries); /* entry count */

  820.     for (i=0; i<entries; i++) {

  821.         put_be32(pb, stts_entries[i].count);

  822.         put_be32(pb, stts_entries[i].duration);

  823.     }

  824.     av_free(stts_entries);

  825.     return atom_size;

  826. }

  827. 

  828. static int mov_write_dref_tag(ByteIOContext *pb)

  829. {

  830.     put_be32(pb, 28); /* size */

  831.     put_tag(pb, "dref");

  832.     put_be32(pb, 0); /* version & flags */

  833.     put_be32(pb, 1); /* entry count */

  834. 

  835.     put_be32(pb, 0xc); /* size */

  836.     put_tag(pb, "url ");

  837.     put_be32(pb, 1); /* version & flags */

  838. 

  839.     return 28;

  840. }

  841. 

  842. static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack *track)

  843. {

  844.     int64_t pos = url_ftell(pb);

  845.     put_be32(pb, 0); /* size */

  846.     put_tag(pb, "stbl");

  847.     mov_write_stsd_tag(pb, track);

  848.     mov_write_stts_tag(pb, track);

  849.     if (track->enc->codec_type == CODEC_TYPE_VIDEO &&

  850.         track->hasKeyframes && track->hasKeyframes < track->entry)

  851.         mov_write_stss_tag(pb, track);

  852.     if (track->enc->codec_type == CODEC_TYPE_VIDEO &&

  853.         track->hasBframes)

  854.         mov_write_ctts_tag(pb, track);

  855.     mov_write_stsc_tag(pb, track);

  856.     mov_write_stsz_tag(pb, track);

  857.     mov_write_stco_tag(pb, track);

  858.     return updateSize(pb, pos);

  859. }

  860. 

  861. static int mov_write_dinf_tag(ByteIOContext *pb)

  862. {

  863.     int64_t pos = url_ftell(pb);

  864.     put_be32(pb, 0); /* size */

  865.     put_tag(pb, "dinf");

  866.     mov_write_dref_tag(pb);

  867.     return updateSize(pb, pos);

  868. }

  869. 

  870. static int mov_write_nmhd_tag(ByteIOContext *pb)

  871. {

  872.     put_be32(pb, 12);

  873.     put_tag(pb, "nmhd");

  874.     put_be32(pb, 0);

  875.     return 12;

  876. }

  877. 

  878. static int mov_write_gmhd_tag(ByteIOContext *pb)

  879. {

  880.     put_be32(pb, 0x20);   /* size */

  881.     put_tag(pb, "gmhd");

  882.     put_be32(pb, 0x18);   /* gmin size */

  883.     put_tag(pb, "gmin");  /* generic media info */

  884.     put_be32(pb, 0);      /* version & flags */

  885.     put_be16(pb, 0x40);   /* graphics mode = */

  886.     put_be16(pb, 0x8000); /* opColor (r?) */

  887.     put_be16(pb, 0x8000); /* opColor (g?) */

  888.     put_be16(pb, 0x8000); /* opColor (b?) */

  889.     put_be16(pb, 0);      /* balance */

  890.     put_be16(pb, 0);      /* reserved */

  891.     return 0x20;

  892. }

  893. 

  894. static int mov_write_smhd_tag(ByteIOContext *pb)

  895. {

  896.     put_be32(pb, 16); /* size */

  897.     put_tag(pb, "smhd");

  898.     put_be32(pb, 0); /* version & flags */

  899.     put_be16(pb, 0); /* reserved (balance, normally = 0) */

  900.     put_be16(pb, 0); /* reserved */

  901.     return 16;

  902. }

  903. 

  904. static int mov_write_vmhd_tag(ByteIOContext *pb)

  905. {

  906.     put_be32(pb, 0x14); /* size (always 0x14) */

  907.     put_tag(pb, "vmhd");

  908.     put_be32(pb, 0x01); /* version & flags */

  909.     put_be64(pb, 0); /* reserved (graphics mode = copy) */

  910.     return 0x14;

  911. }

  912. 

  913. static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)

  914. {

  915.     const char *hdlr, *descr = NULL, *hdlr_type = NULL;

  916.     int64_t pos = url_ftell(pb);

  917. 

  918.     if (!track) { /* no media --> data handler */

  919.         hdlr = "dhlr";

  920.         hdlr_type = "url ";

  921.         descr = "DataHandler";

  922.     } else {

  923.         hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";

  924.         if (track->enc->codec_type == CODEC_TYPE_VIDEO) {

  925.             hdlr_type = "vide";

  926.             descr = "VideoHandler";

  927.         } else if (track->enc->codec_type == CODEC_TYPE_AUDIO) {

  928.             hdlr_type = "soun";

  929.             descr = "SoundHandler";

  930.         } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {

  931.             if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";

  932.             else                                      hdlr_type = "text";

  933.             descr = "SubtitleHandler";

  934.         }

  935.     }

  936. 

  937.     put_be32(pb, 0); /* size */

  938.     put_tag(pb, "hdlr");

  939.     put_be32(pb, 0); /* Version & flags */

  940.     put_buffer(pb, hdlr, 4); /* handler */

  941.     put_tag(pb, hdlr_type); /* handler type */

  942.     put_be32(pb ,0); /* reserved */

  943.     put_be32(pb ,0); /* reserved */

  944.     put_be32(pb ,0); /* reserved */

  945.     put_byte(pb, strlen(descr)); /* string counter */

  946.     put_buffer(pb, descr, strlen(descr)); /* handler description */

  947.     return updateSize(pb, pos);

  948. }

  949. 

  950. static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)

  951. {

  952.     int64_t pos = url_ftell(pb);

  953.     put_be32(pb, 0); /* size */

  954.     put_tag(pb, "minf");

  955.     if(track->enc->codec_type == CODEC_TYPE_VIDEO)

  956.         mov_write_vmhd_tag(pb);

  957.     else if (track->enc->codec_type == CODEC_TYPE_AUDIO)

  958.         mov_write_smhd_tag(pb);

  959.     else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {

  960.         if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb);

  961.         else                                      mov_write_nmhd_tag(pb);

  962.     }

  963.     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */

  964.         mov_write_hdlr_tag(pb, NULL);

  965.     mov_write_dinf_tag(pb);

  966.     mov_write_stbl_tag(pb, track);

  967.     return updateSize(pb, pos);

  968. }

  969. 

  970. static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack *track)

  971. {

  972.     int version = track->trackDuration < INT32_MAX ? 0 : 1;

  973. 

  974.     (version == 1) ? put_be32(pb, 44) : put_be32(pb, 32); /* size */

  975.     put_tag(pb, "mdhd");

  976.     put_byte(pb, version);

  977.     put_be24(pb, 0); /* flags */

  978.     if (version == 1) {

  979.         put_be64(pb, track->time);

  980.         put_be64(pb, track->time);

  981.     } else {

  982.         put_be32(pb, track->time); /* creation time */

  983.         put_be32(pb, track->time); /* modification time */

  984.     }

  985.     put_be32(pb, track->timescale); /* time scale (sample rate for audio) */

  986.     (version == 1) ? put_be64(pb, track->trackDuration) : put_be32(pb, track->trackDuration); /* duration */

  987.     put_be16(pb, track->language); /* language */

  988.     put_be16(pb, 0); /* reserved (quality) */

  989. 

  990.     if(version!=0 && track->mode == MODE_MOV){

  991.         av_log(NULL, AV_LOG_ERROR,

  992.             "FATAL error, file duration too long for timebase, this file will not be\n"

  993.             "playable with quicktime. Choose a different timebase or a different\n"

  994.             "container format\n");

  995.     }

  996. 

  997.     return 32;

  998. }

  999. 

  1000. static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack *track)

  1001. {

  1002.     int64_t pos = url_ftell(pb);

  1003.     put_be32(pb, 0); /* size */

  1004.     put_tag(pb, "mdia");

  1005.     mov_write_mdhd_tag(pb, track);

  1006.     mov_write_hdlr_tag(pb, track);

  1007.     mov_write_minf_tag(pb, track);

  1008.     return updateSize(pb, pos);

  1009. }

  1010. 

  1011. static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)

  1012. {

  1013.     int64_t duration = av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP);

  1014.     int version = duration < INT32_MAX ? 0 : 1;

  1015. 

  1016.     (version == 1) ? put_be32(pb, 104) : put_be32(pb, 92); /* size */

  1017.     put_tag(pb, "tkhd");

  1018.     put_byte(pb, version);

  1019.     put_be24(pb, 0xf); /* flags (track enabled) */

  1020.     if (version == 1) {

  1021.         put_be64(pb, track->time);

  1022.         put_be64(pb, track->time);

  1023.     } else {

  1024.         put_be32(pb, track->time); /* creation time */

  1025.         put_be32(pb, track->time); /* modification time */

  1026.     }

  1027.     put_be32(pb, track->trackID); /* track-id */

  1028.     put_be32(pb, 0); /* reserved */

  1029.     (version == 1) ? put_be64(pb, duration) : put_be32(pb, duration);

  1030. 

  1031.     put_be32(pb, 0); /* reserved */

  1032.     put_be32(pb, 0); /* reserved */

  1033.     put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */

  1034.     /* Volume, only for audio */

  1035.     if(track->enc->codec_type == CODEC_TYPE_AUDIO)

  1036.         put_be16(pb, 0x0100);

  1037.     else

  1038.         put_be16(pb, 0);

  1039.     put_be16(pb, 0); /* reserved */

  1040. 

  1041.     /* Matrix structure */

  1042.     put_be32(pb, 0x00010000); /* reserved */

  1043.     put_be32(pb, 0x0); /* reserved */

  1044.     put_be32(pb, 0x0); /* reserved */

  1045.     put_be32(pb, 0x0); /* reserved */

  1046.     put_be32(pb, 0x00010000); /* reserved */

  1047.     put_be32(pb, 0x0); /* reserved */

  1048.     put_be32(pb, 0x0); /* reserved */

  1049.     put_be32(pb, 0x0); /* reserved */

  1050.     put_be32(pb, 0x40000000); /* reserved */

  1051. 

  1052.     /* Track width and height, for visual only */

  1053.     if(track->enc->codec_type == CODEC_TYPE_VIDEO ||

  1054.        track->enc->codec_type == CODEC_TYPE_SUBTITLE) {

  1055.         double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);

  1056.         if(!sample_aspect_ratio || track->height != track->enc->height)

  1057.             sample_aspect_ratio = 1;

  1058.         put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);

  1059.         put_be32(pb, track->height*0x10000);

  1060.     }

  1061.     else {

  1062.         put_be32(pb, 0);

  1063.         put_be32(pb, 0);

  1064.     }

  1065.     return 0x5c;

  1066. }

  1067. 

  1068. // This box seems important for the psp playback ... without it the movie seems to hang

  1069. static int mov_write_edts_tag(ByteIOContext *pb, MOVTrack *track)

  1070. {

  1071.     put_be32(pb, 0x24); /* size  */

  1072.     put_tag(pb, "edts");

  1073.     put_be32(pb, 0x1c); /* size  */

  1074.     put_tag(pb, "elst");

  1075.     put_be32(pb, 0x0);

  1076.     put_be32(pb, 0x1);

  1077. 

  1078.     put_be32(pb, av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP)); /* duration   ... doesn't seem to effect psp */

  1079. 

  1080.     put_be32(pb, track->cluster[0].cts); /* first pts is cts since dts is 0 */

  1081.     put_be32(pb, 0x00010000);

  1082.     return 0x24;

  1083. }

  1084. 

  1085. // goes at the end of each track!  ... Critical for PSP playback ("Incompatible data" without it)

  1086. static int mov_write_uuid_tag_psp(ByteIOContext *pb, MOVTrack *mov)

  1087. {

  1088.     put_be32(pb, 0x34); /* size ... reports as 28 in mp4box! */

  1089.     put_tag(pb, "uuid");

  1090.     put_tag(pb, "USMT");

  1091.     put_be32(pb, 0x21d24fce);

  1092.     put_be32(pb, 0xbb88695c);

  1093.     put_be32(pb, 0xfac9c740);

  1094.     put_be32(pb, 0x1c);     // another size here!

  1095.     put_tag(pb, "MTDT");

  1096.     put_be32(pb, 0x00010012);

  1097.     put_be32(pb, 0x0a);

  1098.     put_be32(pb, 0x55c40000);

  1099.     put_be32(pb, 0x1);

  1100.     put_be32(pb, 0x0);

  1101.     return 0x34;

  1102. }

  1103. 

  1104. static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)

  1105. {

  1106.     int64_t pos = url_ftell(pb);

  1107.     put_be32(pb, 0); /* size */

  1108.     put_tag(pb, "trak");

  1109.     mov_write_tkhd_tag(pb, track, st);

  1110.     if (track->mode == MODE_PSP || track->hasBframes)

  1111.         mov_write_edts_tag(pb, track);  // PSP Movies require edts box

  1112.     mov_write_mdia_tag(pb, track);

  1113.     if (track->mode == MODE_PSP)

  1114.         mov_write_uuid_tag_psp(pb,track);  // PSP Movies require this uuid box

  1115.     return updateSize(pb, pos);

  1116. }

  1117. 

  1118. #if 0

  1119. /* TODO: Not sorted out, but not necessary either */

  1120. static int mov_write_iods_tag(ByteIOContext *pb, MOVMuxContext *mov)

  1121. {

  1122.     put_be32(pb, 0x15); /* size */

  1123.     put_tag(pb, "iods");

  1124.     put_be32(pb, 0);    /* version & flags */

  1125.     put_be16(pb, 0x1007);

  1126.     put_byte(pb, 0);

  1127.     put_be16(pb, 0x4fff);

  1128.     put_be16(pb, 0xfffe);

  1129.     put_be16(pb, 0x01ff);

  1130.     return 0x15;

  1131. }

  1132. #endif

  1133. 

  1134. static int mov_write_mvhd_tag(ByteIOContext *pb, MOVMuxContext *mov)

  1135. {

  1136.     int maxTrackID = 1, i;

  1137.     int64_t maxTrackLenTemp, maxTrackLen = 0;

  1138.     int version;

  1139. 

  1140.     for (i=0; i<mov->nb_streams; i++) {

  1141.         if(mov->tracks[i].entry > 0) {

  1142.             maxTrackLenTemp = av_rescale_rnd(mov->tracks[i].trackDuration, globalTimescale, mov->tracks[i].timescale, AV_ROUND_UP);

  1143.             if(maxTrackLen < maxTrackLenTemp)

  1144.                 maxTrackLen = maxTrackLenTemp;

  1145.             if(maxTrackID < mov->tracks[i].trackID)

  1146.                 maxTrackID = mov->tracks[i].trackID;

  1147.         }

  1148.     }

  1149. 

  1150.     version = maxTrackLen < UINT32_MAX ? 0 : 1;

  1151.     (version == 1) ? put_be32(pb, 120) : put_be32(pb, 108); /* size */

  1152.     put_tag(pb, "mvhd");

  1153.     put_byte(pb, version);

  1154.     put_be24(pb, 0); /* flags */

  1155.     if (version == 1) {

  1156.         put_be64(pb, mov->time);

  1157.         put_be64(pb, mov->time);

  1158.     } else {

  1159.         put_be32(pb, mov->time); /* creation time */

  1160.         put_be32(pb, mov->time); /* modification time */

  1161.     }

  1162.     put_be32(pb, mov->timescale); /* timescale */

  1163.     (version == 1) ? put_be64(pb, maxTrackLen) : put_be32(pb, maxTrackLen); /* duration of longest track */

  1164. 

  1165.     put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */

  1166.     put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */

  1167.     put_be16(pb, 0); /* reserved */

  1168.     put_be32(pb, 0); /* reserved */

  1169.     put_be32(pb, 0); /* reserved */

  1170. 

  1171.     /* Matrix structure */

  1172.     put_be32(pb, 0x00010000); /* reserved */

  1173.     put_be32(pb, 0x0); /* reserved */

  1174.     put_be32(pb, 0x0); /* reserved */

  1175.     put_be32(pb, 0x0); /* reserved */

  1176.     put_be32(pb, 0x00010000); /* reserved */

  1177.     put_be32(pb, 0x0); /* reserved */

  1178.     put_be32(pb, 0x0); /* reserved */

  1179.     put_be32(pb, 0x0); /* reserved */

  1180.     put_be32(pb, 0x40000000); /* reserved */

  1181. 

  1182.     put_be32(pb, 0); /* reserved (preview time) */

  1183.     put_be32(pb, 0); /* reserved (preview duration) */

  1184.     put_be32(pb, 0); /* reserved (poster time) */

  1185.     put_be32(pb, 0); /* reserved (selection time) */

  1186.     put_be32(pb, 0); /* reserved (selection duration) */

  1187.     put_be32(pb, 0); /* reserved (current time) */

  1188.     put_be32(pb, maxTrackID+1); /* Next track id */

  1189.     return 0x6c;

  1190. }

  1191. 

  1192. static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1193.                                      AVFormatContext *s)

  1194. {

  1195.     int64_t pos = url_ftell(pb);

  1196.     put_be32(pb, 0); /* size */

  1197.     put_tag(pb, "hdlr");

  1198.     put_be32(pb, 0);

  1199.     put_be32(pb, 0);

  1200.     put_tag(pb, "mdir");

  1201.     put_tag(pb, "appl");

  1202.     put_be32(pb, 0);

  1203.     put_be32(pb, 0);

  1204.     put_be16(pb, 0);

  1205.     return updateSize(pb, pos);

  1206. }

  1207. 

  1208. /* helper function to write a data tag with the specified string as data */

  1209. static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int lang, int long_style)

  1210. {

  1211.     if(long_style){

  1212.         int64_t pos = url_ftell(pb);

  1213.         put_be32(pb, 0); /* size */

  1214.         put_tag(pb, "data");

  1215.         put_be32(pb, 1);

  1216.         put_be32(pb, 0);

  1217.         put_buffer(pb, data, strlen(data));

  1218.         return updateSize(pb, pos);

  1219.     }else{

  1220.         put_be16(pb, strlen(data)); /* string length */

  1221.         put_be16(pb, lang);

  1222.         put_buffer(pb, data, strlen(data));

  1223.         return strlen(data) + 4;

  1224.     }

  1225. }

  1226. 

  1227. static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char *value, int lang, int long_style){

  1228.     int size = 0;

  1229.     if (value && value[0]) {

  1230.         int64_t pos = url_ftell(pb);

  1231.         put_be32(pb, 0); /* size */

  1232.         put_tag(pb, name);

  1233.         mov_write_string_data_tag(pb, value, lang, long_style);

  1234.         size= updateSize(pb, pos);

  1235.     }

  1236.     return size;

  1237. }

  1238. 

  1239. static int mov_write_string_metadata(AVFormatContext *s, ByteIOContext *pb,

  1240.                                      const char *name, const char *tag,

  1241.                                      int long_style)

  1242. {

  1243.     int l, lang = 0, len, len2;

  1244.     AVMetadataTag *t, *t2 = NULL;

  1245.     char tag2[16];

  1246. 

  1247.     if (!(t = av_metadata_get(s->metadata, tag, NULL, 0)))

  1248.         return 0;

  1249. 

  1250.     len = strlen(t->key);

  1251.     snprintf(tag2, sizeof(tag2), "%s-", tag);

  1252.     while ((t2 = av_metadata_get(s->metadata, tag2, t2, AV_METADATA_IGNORE_SUFFIX))) {

  1253.         len2 = strlen(t2->key);

  1254.         if (len2 == len+4 && !strcmp(t->value, t2->value)

  1255.             && (l=ff_mov_iso639_to_lang(&t2->key[len2-3], 0)) >= 0) {

  1256.             lang = l;

  1257.             break;

  1258.         }

  1259.     }

  1260.     return mov_write_string_tag(pb, name, t->value, lang, long_style);

  1261. }

  1262. 

  1263. /* iTunes track number */

  1264. static int mov_write_trkn_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1265.                               AVFormatContext *s)

  1266. {

  1267.     AVMetadataTag *t = av_metadata_get(s->metadata, "track", NULL, 0);

  1268.     int size = 0, track = t ? atoi(t->value) : 0;

  1269.     if (track) {

  1270.         int64_t pos = url_ftell(pb);

  1271.         put_be32(pb, 0); /* size */

  1272.         put_tag(pb, "trkn");

  1273.         {

  1274.             int64_t pos = url_ftell(pb);

  1275.             put_be32(pb, 0); /* size */

  1276.             put_tag(pb, "data");

  1277.             put_be32(pb, 0);        // 8 bytes empty

  1278.             put_be32(pb, 0);

  1279.             put_be16(pb, 0);        // empty

  1280.             put_be16(pb, track);    // track number

  1281.             put_be16(pb, 0);        // total track number

  1282.             put_be16(pb, 0);        // empty

  1283.             updateSize(pb, pos);

  1284.         }

  1285.         size = updateSize(pb, pos);

  1286.     }

  1287.     return size;

  1288. }

  1289. 

  1290. /* iTunes meta data list */

  1291. static int mov_write_ilst_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1292.                               AVFormatContext *s)

  1293. {

  1294.     int64_t pos = url_ftell(pb);

  1295.     put_be32(pb, 0); /* size */

  1296.     put_tag(pb, "ilst");

  1297.     mov_write_string_metadata(s, pb, "\251nam", "title"    , 1);

  1298.     mov_write_string_metadata(s, pb, "\251ART", "author"   , 1);

  1299.     mov_write_string_metadata(s, pb, "\251wrt", "author"   , 1);

  1300.     mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);

  1301.     mov_write_string_metadata(s, pb, "\251day", "year"     , 1);

  1302.     mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);

  1303.     mov_write_string_metadata(s, pb, "\251cmt", "comment"  , 1);

  1304.     mov_write_string_metadata(s, pb, "\251gen", "genre"    , 1);

  1305.     mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1);

  1306.     mov_write_trkn_tag(pb, mov, s);

  1307.     return updateSize(pb, pos);

  1308. }

  1309. 

  1310. /* iTunes meta data tag */

  1311. static int mov_write_meta_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1312.                               AVFormatContext *s)

  1313. {

  1314.     int size = 0;

  1315.     int64_t pos = url_ftell(pb);

  1316.     put_be32(pb, 0); /* size */

  1317.     put_tag(pb, "meta");

  1318.     put_be32(pb, 0);

  1319.     mov_write_itunes_hdlr_tag(pb, mov, s);

  1320.     mov_write_ilst_tag(pb, mov, s);

  1321.     size = updateSize(pb, pos);

  1322.     return size;

  1323. }

  1324. 

  1325. static int utf8len(const uint8_t *b)

  1326. {

  1327.     int len=0;

  1328.     int val;

  1329.     while(*b){

  1330.         GET_UTF8(val, *b++, return -1;)

  1331.         len++;

  1332.     }

  1333.     return len;

  1334. }

  1335. 

  1336. static int ascii_to_wc(ByteIOContext *pb, const uint8_t *b)

  1337. {

  1338.     int val;

  1339.     while(*b){

  1340.         GET_UTF8(val, *b++, return -1;)

  1341.         put_be16(pb, val);

  1342.     }

  1343.     put_be16(pb, 0x00);

  1344.     return 0;

  1345. }

  1346. 

  1347. static uint16_t language_code(const char *str)

  1348. {

  1349.     return (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);

  1350. }

  1351. 

  1352. static int mov_write_3gp_udta_tag(ByteIOContext *pb, AVFormatContext *s,

  1353.                                   const char *tag, const char *str)

  1354. {

  1355.     int64_t pos = url_ftell(pb);

  1356.     AVMetadataTag *t = av_metadata_get(s->metadata, str, NULL, 0);

  1357.     if (!t || !utf8len(t->value))

  1358.         return 0;

  1359.     put_be32(pb, 0);   /* size */

  1360.     put_tag (pb, tag); /* type */

  1361.     put_be32(pb, 0);   /* version + flags */

  1362.     if (!strcmp(tag, "yrrc"))

  1363.         put_be16(pb, atoi(t->value));

  1364.     else {

  1365.         put_be16(pb, language_code("eng")); /* language */

  1366.         ascii_to_wc(pb, t->value);

  1367.         if (!strcmp(tag, "albm") &&

  1368.             (t = av_metadata_get(s->metadata, "year", NULL, 0)))

  1369.             put_byte(pb, atoi(t->value));

  1370.     }

  1371.     return updateSize(pb, pos);

  1372. }

  1373. 

  1374. static int mov_write_udta_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1375.                               AVFormatContext *s)

  1376. {

  1377.     ByteIOContext *pb_buf;

  1378.     int i, ret, size;

  1379.     uint8_t *buf;

  1380. 

  1381.     for (i = 0; i < s->nb_streams; i++)

  1382.         if (mov->tracks[i].enc->flags & CODEC_FLAG_BITEXACT) {

  1383.             return 0;

  1384.         }

  1385. 

  1386.     ret = url_open_dyn_buf(&pb_buf);

  1387.     if(ret < 0)

  1388.         return ret;

  1389. 

  1390.         if (mov->mode & MODE_3GP) {

  1391.             mov_write_3gp_udta_tag(pb_buf, s, "titl", "title");

  1392.             mov_write_3gp_udta_tag(pb_buf, s, "auth", "author");

  1393.             mov_write_3gp_udta_tag(pb_buf, s, "gnre", "genre");

  1394.             mov_write_3gp_udta_tag(pb_buf, s, "dscp", "comment");

  1395.             mov_write_3gp_udta_tag(pb_buf, s, "albm", "album");

  1396.             mov_write_3gp_udta_tag(pb_buf, s, "cprt", "copyright");

  1397.             mov_write_3gp_udta_tag(pb_buf, s, "yrrc", "year");

  1398.         } else if (mov->mode == MODE_MOV) { // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4

  1399.             mov_write_string_metadata(s, pb_buf, "\251nam", "title"      , 0);

  1400.             mov_write_string_metadata(s, pb_buf, "\251aut", "author"     , 0);

  1401.             mov_write_string_metadata(s, pb_buf, "\251alb", "album"      , 0);

  1402.             mov_write_string_metadata(s, pb_buf, "\251day", "year"       , 0);

  1403.             mov_write_string_tag(pb_buf, "\251enc", LIBAVFORMAT_IDENT, 0, 0);

  1404.             mov_write_string_metadata(s, pb_buf, "\251des", "comment"    , 0);

  1405.             mov_write_string_metadata(s, pb_buf, "\251gen", "genre"      , 0);

  1406.             mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright"  , 0);

  1407.         } else {

  1408.             /* iTunes meta data */

  1409.             mov_write_meta_tag(pb_buf, mov, s);

  1410.         }

  1411. 

  1412.     if ((size = url_close_dyn_buf(pb_buf, &buf)) > 0) {

  1413.         put_be32(pb, size+8);

  1414.         put_tag(pb, "udta");

  1415.         put_buffer(pb, buf, size);

  1416.         av_free(buf);

  1417.     }

  1418. 

  1419.     return 0;

  1420. }

  1421. 

  1422. static void mov_write_psp_udta_tag(ByteIOContext *pb,

  1423.                                   const char *str, const char *lang, int type)

  1424. {

  1425.     int len = utf8len(str)+1;

  1426.     if(len<=0)

  1427.         return;

  1428.     put_be16(pb, len*2+10);            /* size */

  1429.     put_be32(pb, type);                /* type */

  1430.     put_be16(pb, language_code(lang)); /* language */

  1431.     put_be16(pb, 0x01);                /* ? */

  1432.     ascii_to_wc(pb, str);

  1433. }

  1434. 

  1435. static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)

  1436. {

  1437.     AVMetadataTag *title = av_metadata_get(s->metadata, "title", NULL, 0);

  1438.     int64_t pos, pos2;

  1439. 

  1440.     if (title) {

  1441.         pos = url_ftell(pb);

  1442.         put_be32(pb, 0); /* size placeholder*/

  1443.         put_tag(pb, "uuid");

  1444.         put_tag(pb, "USMT");

  1445.         put_be32(pb, 0x21d24fce); /* 96 bit UUID */

  1446.         put_be32(pb, 0xbb88695c);

  1447.         put_be32(pb, 0xfac9c740);

  1448. 

  1449.         pos2 = url_ftell(pb);

  1450.         put_be32(pb, 0); /* size placeholder*/

  1451.         put_tag(pb, "MTDT");

  1452.         put_be16(pb, 4);

  1453. 

  1454.         // ?

  1455.         put_be16(pb, 0x0C);                 /* size */

  1456.         put_be32(pb, 0x0B);                 /* type */

  1457.         put_be16(pb, language_code("und")); /* language */

  1458.         put_be16(pb, 0x0);                  /* ? */

  1459.         put_be16(pb, 0x021C);               /* data */

  1460. 

  1461.         mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);

  1462.         mov_write_psp_udta_tag(pb, title->value,          "eng", 0x01);

  1463. //        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);

  1464.         mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);

  1465. 

  1466.         updateSize(pb, pos2);

  1467.         return updateSize(pb, pos);

  1468.     }

  1469. 

  1470.     return 0;

  1471. }

  1472. 

  1473. static int mov_write_moov_tag(ByteIOContext *pb, MOVMuxContext *mov,

  1474.                               AVFormatContext *s)

  1475. {

  1476.     int i;

  1477.     int64_t pos = url_ftell(pb);

  1478.     put_be32(pb, 0); /* size placeholder*/

  1479.     put_tag(pb, "moov");

  1480.     mov->timescale = globalTimescale;

  1481. 

  1482.     for (i=0; i<mov->nb_streams; i++) {

  1483.         if(mov->tracks[i].entry <= 0) continue;

  1484. 

  1485.         mov->tracks[i].time = mov->time;

  1486.         mov->tracks[i].trackID = i+1;

  1487.     }

  1488. 

  1489.     mov_write_mvhd_tag(pb, mov);

  1490.     //mov_write_iods_tag(pb, mov);

  1491.     for (i=0; i<mov->nb_streams; i++) {

  1492.         if(mov->tracks[i].entry > 0) {

  1493.             mov_write_trak_tag(pb, &(mov->tracks[i]), s->streams[i]);

  1494.         }

  1495.     }

  1496. 

  1497.     if (mov->mode == MODE_PSP)

  1498.         mov_write_uuidusmt_tag(pb, s);

  1499.     else

  1500.         mov_write_udta_tag(pb, mov, s);

  1501. 

  1502.     return updateSize(pb, pos);

  1503. }

  1504. 

  1505. static int mov_write_mdat_tag(ByteIOContext *pb, MOVMuxContext *mov)

  1506. {

  1507.     put_be32(pb, 8);    // placeholder for extended size field (64 bit)

  1508.     put_tag(pb, mov->mode == MODE_MOV ? "wide" : "free");

  1509. 

  1510.     mov->mdat_pos = url_ftell(pb);

  1511.     put_be32(pb, 0); /* size placeholder*/

  1512.     put_tag(pb, "mdat");

  1513.     return 0;

  1514. }

  1515. 

  1516. /* TODO: This needs to be more general */

  1517. static int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)

  1518. {

  1519.     MOVMuxContext *mov = s->priv_data;

  1520.     int64_t pos = url_ftell(pb);

  1521.     int has_h264 = 0, has_video = 0;

  1522.     int minor = 0x200;

  1523.     int i;

  1524. 

  1525.     for (i = 0; i < s->nb_streams; i++) {

  1526.         AVStream *st = s->streams[i];

  1527.         if (st->codec->codec_type == CODEC_TYPE_VIDEO)

  1528.             has_video = 1;

  1529.         if (st->codec->codec_id == CODEC_ID_H264)

  1530.             has_h264 = 1;

  1531.     }

  1532. 

  1533.     put_be32(pb, 0); /* size */

  1534.     put_tag(pb, "ftyp");

  1535. 

  1536.     if (mov->mode == MODE_3GP) {

  1537.         put_tag(pb, has_h264 ? "3gp6"  : "3gp4");

  1538.         minor =     has_h264 ?   0x100 :   0x200;

  1539.     } else if (mov->mode & MODE_3G2) {

  1540.         put_tag(pb, has_h264 ? "3g2b"  : "3g2a");

  1541.         minor =     has_h264 ? 0x20000 : 0x10000;

  1542.     }else if (mov->mode == MODE_PSP)

  1543.         put_tag(pb, "MSNV");

  1544.     else if (mov->mode == MODE_MP4)

  1545.         put_tag(pb, "isom");

  1546.     else if (mov->mode == MODE_IPOD)

  1547.         put_tag(pb, has_video ? "M4V ":"M4A ");

  1548.     else

  1549.         put_tag(pb, "qt  ");

  1550. 

  1551.     put_be32(pb, minor);

  1552. 

  1553.     if(mov->mode == MODE_MOV)

  1554.         put_tag(pb, "qt  ");

  1555.     else{

  1556.         put_tag(pb, "isom");

  1557.         put_tag(pb, "iso2");

  1558.         if(has_h264)

  1559.             put_tag(pb, "avc1");

  1560.     }

  1561. 

  1562.     if (mov->mode == MODE_3GP)

  1563.         put_tag(pb, has_h264 ? "3gp6":"3gp4");

  1564.     else if (mov->mode & MODE_3G2)

  1565.         put_tag(pb, has_h264 ? "3g2b":"3g2a");

  1566.     else if (mov->mode == MODE_PSP)

  1567.         put_tag(pb, "MSNV");

  1568.     else if (mov->mode == MODE_MP4)

  1569.         put_tag(pb, "mp41");

  1570.     return updateSize(pb, pos);

  1571. }

  1572. 

  1573. static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)

  1574. {

  1575.     AVCodecContext *VideoCodec = s->streams[0]->codec;

  1576.     AVCodecContext *AudioCodec = s->streams[1]->codec;

  1577.     int AudioRate = AudioCodec->sample_rate;

  1578.     int FrameRate = ((VideoCodec->time_base.den) * (0x10000))/ (VideoCodec->time_base.num);

  1579.     int audio_kbitrate= AudioCodec->bit_rate / 1000;

  1580.     int video_kbitrate= FFMIN(VideoCodec->bit_rate / 1000, 800 - audio_kbitrate);

  1581. 

  1582.     put_be32(pb, 0x94); /* size */

  1583.     put_tag(pb, "uuid");

  1584.     put_tag(pb, "PROF");

  1585. 

  1586.     put_be32(pb, 0x21d24fce); /* 96 bit UUID */

  1587.     put_be32(pb, 0xbb88695c);

  1588.     put_be32(pb, 0xfac9c740);

  1589. 

  1590.     put_be32(pb, 0x0);  /* ? */

  1591.     put_be32(pb, 0x3);  /* 3 sections ? */

  1592. 

  1593.     put_be32(pb, 0x14); /* size */

  1594.     put_tag(pb, "FPRF");

  1595.     put_be32(pb, 0x0);  /* ? */

  1596.     put_be32(pb, 0x0);  /* ? */

  1597.     put_be32(pb, 0x0);  /* ? */

  1598. 

  1599.     put_be32(pb, 0x2c);  /* size */

  1600.     put_tag(pb, "APRF");   /* audio */

  1601.     put_be32(pb, 0x0);

  1602.     put_be32(pb, 0x2);   /* TrackID */

  1603.     put_tag(pb, "mp4a");

  1604.     put_be32(pb, 0x20f);

  1605.     put_be32(pb, 0x0);

  1606.     put_be32(pb, audio_kbitrate);

  1607.     put_be32(pb, audio_kbitrate);

  1608.     put_be32(pb, AudioRate);

  1609.     put_be32(pb, AudioCodec->channels);

  1610. 

  1611.     put_be32(pb, 0x34);  /* size */

  1612.     put_tag(pb, "VPRF");   /* video */

  1613.     put_be32(pb, 0x0);

  1614.     put_be32(pb, 0x1);    /* TrackID */

  1615.     if (VideoCodec->codec_id == CODEC_ID_H264) {

  1616.         put_tag(pb, "avc1");

  1617.         put_be16(pb, 0x014D);

  1618.         put_be16(pb, 0x0015);

  1619.     } else {

  1620.         put_tag(pb, "mp4v");

  1621.         put_be16(pb, 0x0000);

  1622.         put_be16(pb, 0x0103);

  1623.     }

  1624.     put_be32(pb, 0x0);

  1625.     put_be32(pb, video_kbitrate);

  1626.     put_be32(pb, video_kbitrate);

  1627.     put_be32(pb, FrameRate);

  1628.     put_be32(pb, FrameRate);

  1629.     put_be16(pb, VideoCodec->width);

  1630.     put_be16(pb, VideoCodec->height);

  1631.     put_be32(pb, 0x010001); /* ? */

  1632. }

  1633. 

  1634. static int mov_write_header(AVFormatContext *s)

  1635. {

  1636.     ByteIOContext *pb = s->pb;

  1637.     MOVMuxContext *mov = s->priv_data;

  1638.     int i;

  1639. 

  1640.     if (url_is_streamed(s->pb)) {

  1641.         av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");

  1642.         return -1;

  1643.     }

  1644. 

  1645.     /* Default mode == MP4 */

  1646.     mov->mode = MODE_MP4;

  1647. 

  1648.     if (s->oformat != NULL) {

  1649.         if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP;

  1650.         else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3GP|MODE_3G2;

  1651.         else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;

  1652.         else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;

  1653.         else if (!strcmp("ipod",s->oformat->name)) mov->mode = MODE_IPOD;

  1654. 

  1655.         mov_write_ftyp_tag(pb,s);

  1656.         if (mov->mode == MODE_PSP) {

  1657.             if (s->nb_streams != 2) {

  1658.                 av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");

  1659.                 return -1;

  1660.             }

  1661.             mov_write_uuidprof_tag(pb,s);

  1662.         }

  1663.     }

  1664. 

  1665.     for(i=0; i<s->nb_streams; i++){

  1666.         AVStream *st= s->streams[i];

  1667.         MOVTrack *track= &mov->tracks[i];

  1668.         AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);

  1669. 

  1670.         track->enc = st->codec;

  1671.         track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);

  1672.         if (track->language < 0)

  1673.             track->language = 0;

  1674.         track->mode = mov->mode;

  1675.         track->tag = mov_find_codec_tag(s, track);

  1676.         if (!track->tag) {

  1677.             av_log(s, AV_LOG_ERROR, "track %d: could not find tag, "

  1678.                    "codec not currently supported in container\n", i);

  1679.             return -1;

  1680.         }

  1681.         if(st->codec->codec_type == CODEC_TYPE_VIDEO){

  1682.             if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||

  1683.                 track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||

  1684.                 track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {

  1685.                 if (st->codec->width != 720 || (st->codec->height != 608 && st->codec->height != 512)) {

  1686.                     av_log(s, AV_LOG_ERROR, "D-10/IMX must use 720x608 or 720x512 video resolution\n");

  1687.                     return -1;

  1688.                 }

  1689.                 track->height = track->tag>>24 == 'n' ? 486 : 576;

  1690.             }

  1691.             track->timescale = st->codec->time_base.den;

  1692.             av_set_pts_info(st, 64, 1, st->codec->time_base.den);

  1693.             if (track->mode == MODE_MOV && track->timescale > 100000)

  1694.                 av_log(s, AV_LOG_WARNING,

  1695.                        "WARNING codec timebase is very high. If duration is too long,\n"

  1696.                        "file may not be playable by quicktime. Specify a shorter timebase\n"

  1697.                        "or choose different container.\n");

  1698.         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO){

  1699.             track->timescale = st->codec->sample_rate;

  1700.             av_set_pts_info(st, 64, 1, st->codec->sample_rate);

  1701.             if(!st->codec->frame_size && !av_get_bits_per_sample(st->codec->codec_id)) {

  1702.                 av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);

  1703.                 return -1;

  1704.             }else if(st->codec->frame_size > 1){ /* assume compressed audio */

  1705.                 track->audio_vbr = 1;

  1706.             }else{

  1707.                 st->codec->frame_size = 1;

  1708.                 track->sampleSize = (av_get_bits_per_sample(st->codec->codec_id) >> 3) * st->codec->channels;

  1709.             }

  1710.             if(track->mode != MODE_MOV &&

  1711.                track->enc->codec_id == CODEC_ID_MP3 && track->enc->sample_rate < 16000){

  1712.                 av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not supported\n",

  1713.                        i, track->enc->sample_rate);

  1714.                 return -1;

  1715.             }

  1716.         }else if(st->codec->codec_type == CODEC_TYPE_SUBTITLE){

  1717.             track->timescale = st->codec->time_base.den;

  1718.             av_set_pts_info(st, 64, 1, st->codec->time_base.den);

  1719.         }

  1720.         if (!track->height)

  1721.             track->height = st->codec->height;

  1722.     }

  1723. 

  1724.     mov_write_mdat_tag(pb, mov);

  1725.     mov->time = s->timestamp + 0x7C25B080; //1970 based -> 1904 based

  1726.     mov->nb_streams = s->nb_streams;

  1727. 

  1728.     put_flush_packet(pb);

  1729. 

  1730.     return 0;

  1731. }

  1732. 

  1733. static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)

  1734. {

  1735.     MOVMuxContext *mov = s->priv_data;

  1736.     ByteIOContext *pb = s->pb;

  1737.     MOVTrack *trk = &mov->tracks[pkt->stream_index];

  1738.     AVCodecContext *enc = trk->enc;

  1739.     unsigned int samplesInChunk = 0;

  1740.     int size= pkt->size;

  1741. 

  1742.     if (url_is_streamed(s->pb)) return 0; /* Can't handle that */

  1743.     if (!size) return 0; /* Discard 0 sized packets */

  1744. 

  1745.     if (enc->codec_id == CODEC_ID_AMR_NB) {

  1746.         /* We must find out how many AMR blocks there are in one packet */

  1747.         static uint16_t packed_size[16] =

  1748.             {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 0};

  1749.         int len = 0;

  1750. 

  1751.         while (len < size && samplesInChunk < 100) {

  1752.             len += packed_size[(pkt->data[len] >> 3) & 0x0F];

  1753.             samplesInChunk++;

  1754.         }

  1755.         if(samplesInChunk > 1){

  1756.             av_log(s, AV_LOG_ERROR, "fatal error, input is not a single packet, implement a AVParser for it\n");

  1757.             return -1;

  1758.         }

  1759.     } else if (trk->sampleSize)

  1760.         samplesInChunk = size/trk->sampleSize;

  1761.     else

  1762.         samplesInChunk = 1;

  1763. 

  1764.     /* copy extradata if it exists */

  1765.     if (trk->vosLen == 0 && enc->extradata_size > 0) {

  1766.         trk->vosLen = enc->extradata_size;

  1767.         trk->vosData = av_malloc(trk->vosLen);

  1768.         memcpy(trk->vosData, enc->extradata, trk->vosLen);

  1769.     }

  1770. 

  1771.     if (enc->codec_id == CODEC_ID_H264 && trk->vosLen > 0 && *(uint8_t *)trk->vosData != 1) {

  1772.         /* from x264 or from bytestream h264 */

  1773.         /* nal reformating needed */

  1774.         size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);

  1775.     } else {

  1776.         put_buffer(pb, pkt->data, size);

  1777.     }

  1778. 

  1779.     if ((enc->codec_id == CODEC_ID_DNXHD ||

  1780.                 enc->codec_id == CODEC_ID_AC3) && !trk->vosLen) {

  1781.         /* copy frame to create needed atoms */

  1782.         trk->vosLen = size;

  1783.         trk->vosData = av_malloc(size);

  1784.         if (!trk->vosData)

  1785.             return AVERROR(ENOMEM);

  1786.         memcpy(trk->vosData, pkt->data, size);

  1787.     }

  1788. 

  1789.     if (!(trk->entry % MOV_INDEX_CLUSTER_SIZE)) {

  1790.         trk->cluster = av_realloc(trk->cluster, (trk->entry + MOV_INDEX_CLUSTER_SIZE) * sizeof(*trk->cluster));

  1791.         if (!trk->cluster)

  1792.             return -1;

  1793.     }

  1794. 

  1795.     trk->cluster[trk->entry].pos = url_ftell(pb) - size;

  1796.     trk->cluster[trk->entry].samplesInChunk = samplesInChunk;

  1797.     trk->cluster[trk->entry].size = size;

  1798.     trk->cluster[trk->entry].entries = samplesInChunk;

  1799.     trk->cluster[trk->entry].dts = pkt->dts;

  1800.     trk->trackDuration = pkt->dts - trk->cluster[0].dts + pkt->duration;

  1801. 

  1802.     if (pkt->pts == AV_NOPTS_VALUE) {

  1803.         av_log(s, AV_LOG_WARNING, "pts has no value\n");

  1804.         pkt->pts = pkt->dts;

  1805.     }

  1806.     if (pkt->dts != pkt->pts)

  1807.         trk->hasBframes = 1;

  1808.     trk->cluster[trk->entry].cts = pkt->pts - pkt->dts;

  1809.     trk->cluster[trk->entry].key_frame = !!(pkt->flags & PKT_FLAG_KEY);

  1810.     if(trk->cluster[trk->entry].key_frame)

  1811.         trk->hasKeyframes++;

  1812.     trk->entry++;

  1813.     trk->sampleCount += samplesInChunk;

  1814.     mov->mdat_size += size;

  1815. 

  1816.     put_flush_packet(pb);

  1817.     return 0;

  1818. }

  1819. 

  1820. static int mov_write_trailer(AVFormatContext *s)

  1821. {

  1822.     MOVMuxContext *mov = s->priv_data;

  1823.     ByteIOContext *pb = s->pb;

  1824.     int res = 0;

  1825.     int i;

  1826. 

  1827.     int64_t moov_pos = url_ftell(pb);

  1828. 

  1829.     /* Write size of mdat tag */

  1830.     if (mov->mdat_size+8 <= UINT32_MAX) {

  1831.         url_fseek(pb, mov->mdat_pos, SEEK_SET);

  1832.         put_be32(pb, mov->mdat_size+8);

  1833.     } else {

  1834.         /* overwrite 'wide' placeholder atom */

  1835.         url_fseek(pb, mov->mdat_pos - 8, SEEK_SET);

  1836.         put_be32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */

  1837.         put_tag(pb, "mdat");

  1838.         put_be64(pb, mov->mdat_size+16);

  1839.     }

  1840.     url_fseek(pb, moov_pos, SEEK_SET);

  1841. 

  1842.     mov_write_moov_tag(pb, mov, s);

  1843. 

  1844.     for (i=0; i<mov->nb_streams; i++) {

  1845.         av_freep(&mov->tracks[i].cluster);

  1846. 

  1847.         if(mov->tracks[i].vosLen) av_free(mov->tracks[i].vosData);

  1848. 

  1849.     }

  1850. 

  1851.     put_flush_packet(pb);

  1852. 

  1853.     return res;

  1854. }

  1855. 

  1856. #if CONFIG_MOV_MUXER

  1857. AVOutputFormat mov_muxer = {

  1858.     "mov",

  1859.     NULL_IF_CONFIG_SMALL("MOV format"),

  1860.     NULL,

  1861.     "mov",

  1862.     sizeof(MOVMuxContext),

  1863.     CODEC_ID_AAC,

  1864.     CODEC_ID_MPEG4,

  1865.     mov_write_header,

  1866.     mov_write_packet,

  1867.     mov_write_trailer,

  1868.     .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,

  1869.     .codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},

  1870. };

  1871. #endif

  1872. #if CONFIG_TGP_MUXER

  1873. AVOutputFormat tgp_muxer = {

  1874.     "3gp",

  1875.     NULL_IF_CONFIG_SMALL("3GP format"),

  1876.     NULL,

  1877.     "3gp",

  1878.     sizeof(MOVMuxContext),

  1879.     CODEC_ID_AMR_NB,

  1880.     CODEC_ID_H263,

  1881.     mov_write_header,

  1882.     mov_write_packet,

  1883.     mov_write_trailer,

  1884.     .flags = AVFMT_GLOBALHEADER,

  1885.     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},

  1886. };

  1887. #endif

  1888. #if CONFIG_MP4_MUXER

  1889. AVOutputFormat mp4_muxer = {

  1890.     "mp4",

  1891.     NULL_IF_CONFIG_SMALL("MP4 format"),

  1892.     "application/mp4",

  1893.     "mp4",

  1894.     sizeof(MOVMuxContext),

  1895.     CODEC_ID_AAC,

  1896.     CODEC_ID_MPEG4,

  1897.     mov_write_header,

  1898.     mov_write_packet,

  1899.     mov_write_trailer,

  1900.     .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,

  1901.     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},

  1902. };

  1903. #endif

  1904. #if CONFIG_PSP_MUXER

  1905. AVOutputFormat psp_muxer = {

  1906.     "psp",

  1907.     NULL_IF_CONFIG_SMALL("PSP MP4 format"),

  1908.     NULL,

  1909.     "mp4,psp",

  1910.     sizeof(MOVMuxContext),

  1911.     CODEC_ID_AAC,

  1912.     CODEC_ID_MPEG4,

  1913.     mov_write_header,

  1914.     mov_write_packet,

  1915.     mov_write_trailer,

  1916.     .flags = AVFMT_GLOBALHEADER,

  1917.     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},

  1918. };

  1919. #endif

  1920. #if CONFIG_TG2_MUXER

  1921. AVOutputFormat tg2_muxer = {

  1922.     "3g2",

  1923.     NULL_IF_CONFIG_SMALL("3GP2 format"),

  1924.     NULL,

  1925.     "3g2",

  1926.     sizeof(MOVMuxContext),

  1927.     CODEC_ID_AMR_NB,

  1928.     CODEC_ID_H263,

  1929.     mov_write_header,

  1930.     mov_write_packet,

  1931.     mov_write_trailer,

  1932.     .flags = AVFMT_GLOBALHEADER,

  1933.     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},

  1934. };

  1935. #endif

  1936. #if CONFIG_IPOD_MUXER

  1937. AVOutputFormat ipod_muxer = {

  1938.     "ipod",

  1939.     NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),

  1940.     "application/mp4",

  1941.     "m4v,m4a",

  1942.     sizeof(MOVMuxContext),

  1943.     CODEC_ID_AAC,

  1944.     CODEC_ID_H264,

  1945.     mov_write_header,

  1946.     mov_write_packet,

  1947.     mov_write_trailer,

  1948.     .flags = AVFMT_GLOBALHEADER,

  1949.     .codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},

  1950. };

  1951. #endif