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.
4114 Commits
32 Branches
834MB
Tree: d06c75a830
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd06c75a830'
${ noResults }
FFmpeg/libavformat/movenc.c

1366 lines
40KB
Raw Blame History 

  1. /*

  2.  * MOV, 3GP, MP4 encoder.

  3.  * Copyright (c) 2003 Thomas Raivio.

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

  5.  *

  6.  * This library is free software; you can redistribute it and/or

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

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

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

  10.  *

  11.  * This library is distributed in the hope that it will be useful,

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

  17.  * License along with this library; if not, write to the Free Software

  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  19.  */

  20. #include "avformat.h"

  21. #include "avi.h"

  22. #include "avio.h"

  23. 

  24. #undef NDEBUG

  25. #include <assert.h>

  26. 

  27. #define MOV_INDEX_CLUSTER_SIZE 16384

  28. #define globalTimescale 1000

  29. 

  30. #define MODE_MP4 0

  31. #define MODE_MOV 1

  32. #define MODE_3GP 2

  33. 

  34. typedef struct MOVIentry {

  35.     unsigned int flags, pos, size;

  36.     unsigned int samplesInChunk;

  37.     char         key_frame;

  38.     unsigned int entries;

  39. } MOVIentry;

  40. 

  41. typedef struct MOVIndex {

  42.     int         mode;

  43.     int         entry;

  44.     int         mdat_size;

  45.     int         ents_allocated;

  46.     long        timescale;

  47.     long        time;

  48.     long        trackDuration;

  49.     long        sampleCount;

  50.     long        sampleDuration;

  51.     int         hasKeyframes;

  52.     int         trackID;

  53.     AVCodecContext *enc;

  54. 

  55.     int         vosLen;

  56.     uint8_t     *vosData;

  57.     MOVIentry** cluster;

  58. } MOVTrack;

  59. 

  60. typedef struct {

  61.     int     mode;

  62.     long    time;

  63.     int     nb_streams;

  64.     int     mdat_written;

  65.     offset_t mdat_pos;

  66.     long    timescale;

  67.     MOVTrack tracks[MAX_STREAMS];

  68. } MOVContext;

  69. 

  70. static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track);

  71. 

  72. //FIXME supprt 64bit varaint with wide placeholders

  73. static int updateSize (ByteIOContext *pb, int pos)

  74. {

  75.     long curpos = url_ftell(pb);

  76.     url_fseek(pb, pos, SEEK_SET);

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

  78.     url_fseek(pb, curpos, SEEK_SET);

  79. 

  80.     return curpos - pos;

  81. }

  82. 

  83. /* Chunk offset atom */

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

  85. {

  86.     int i;

  87.     int pos = url_ftell(pb);

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

  89.     put_tag(pb, "stco");

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

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

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

  93.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  94.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  95.         put_be32(pb, track->cluster[cl][id].pos);

  96.     }

  97.     return updateSize (pb, pos);

  98. }

  99. 

  100. /* Sample size atom */

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

  102. {

  103.     int equalChunks = 1;

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

  105. 

  106.     int pos = url_ftell(pb);

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

  108.     put_tag(pb, "stsz");

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

  110. 

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

  112.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  113.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  114.         tst = track->cluster[cl][id].size/track->cluster[cl][id].entries;

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

  116.             equalChunks = 0;

  117.         }

  118.         oldtst = tst;

  119.         entries += track->cluster[cl][id].entries;

  120.     }

  121.     if (equalChunks) {

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

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

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

  125.     }

  126.     else {

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

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

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

  130.             int cl = i / MOV_INDEX_CLUSTER_SIZE;

  131.             int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  133.                 put_be32(pb, track->cluster[cl][id].size /

  134.                          track->cluster[cl][id].entries);

  135.             }

  136.         }

  137.     }

  138.     return updateSize (pb, pos);

  139. }

  140. 

  141. /* Sample to chunk atom */

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

  143. {

  144.     int index = 0, oldval = -1, i, entryPos, curpos;

  145. 

  146.     int pos = url_ftell(pb);

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

  148.     put_tag(pb, "stsc");

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

  150.     entryPos = url_ftell(pb);

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

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

  153.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  154.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  155.         if(oldval != track->cluster[cl][id].samplesInChunk)

  156.         {

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

  158.             put_be32(pb, track->cluster[cl][id].samplesInChunk); // samples per chunk

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

  160.             oldval = track->cluster[cl][id].samplesInChunk;

  161.             index++;

  162.         }

  163.     }

  164.     curpos = url_ftell(pb);

  165.     url_fseek(pb, entryPos, SEEK_SET);

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

  167.     url_fseek(pb, curpos, SEEK_SET);

  168. 

  169.     return updateSize (pb, pos);

  170. }

  171. 

  172. /* Sync sample atom */

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

  174. {

  175.     long curpos;

  176.     int i, index = 0, entryPos;

  177.     int pos = url_ftell(pb);

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

  179.     put_tag(pb, "stss");

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

  181.     entryPos = url_ftell(pb);

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

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

  184.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  185.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  186.         if(track->cluster[cl][id].key_frame == 1) {

  187.             put_be32(pb, i+1);

  188.             index++;

  189.         }

  190.     }

  191.     curpos = url_ftell(pb);

  192.     url_fseek(pb, entryPos, SEEK_SET);

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

  194.     url_fseek(pb, curpos, SEEK_SET);

  195.     return updateSize (pb, pos);

  196. }

  197. 

  198. static int mov_write_damr_tag(ByteIOContext *pb)

  199. {

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

  201.     put_tag(pb, "damr");

  202.     put_tag(pb, "FFMP");

  203.     put_byte(pb, 0);

  204. 

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

  206.     put_be16(pb, 0xa); /* Mode change period (no restriction) */

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

  208.     //put_be16(pb, 1); /* Mode change period (no restriction) */

  209.     return 0x11;

  210. }

  211. 

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

  213. {

  214.     int pos = url_ftell(pb);

  215. 

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

  217.     put_tag(pb, "wave");

  218. 

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

  220.     put_tag(pb, "frma");

  221.     put_tag(pb, "mp4a");

  222. 

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

  224.     put_tag(pb, "mp4a");

  225.     put_be32(pb, 0);

  226. 

  227.     mov_write_esds_tag(pb, track);

  228. 

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

  230.     put_tag(pb, "srcq");

  231.     put_be32(pb, 0x40);

  232. 

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

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

  235. 

  236.     return updateSize (pb, pos);

  237. }

  238. 

  239. const CodecTag codec_movaudio_tags[] = {

  240.     { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') },

  241.     { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') },

  242.     { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') },

  243.     { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') },

  244.     { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') },

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

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

  247.     { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') },

  248.     { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') },

  249.     { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') },

  250.     { 0, 0 },

  251. };

  252. 

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

  254. {

  255.     int pos = url_ftell(pb);

  256.     int tag;

  257.     

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

  259. 

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

  261.     if (!tag)

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

  263.     // if no mac fcc found, try with Microsoft tags

  264.     if (!tag)

  265.     {

  266. 	int tmp = codec_get_tag(codec_wav_tags, track->enc->codec_id);

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

  268.     }

  269.     put_le32(pb, tag); // store it byteswapped

  270. 

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

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

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

  274. 

  275.     /* SoundDescription */

  276.     if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)

  277.         put_be16(pb, 1); /* Version 1 */

  278.     else

  279.         put_be16(pb, 0); /* Version 0 */

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

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

  282. 

  283.     put_be16(pb, track->enc->channels); /* Number of channels */

  284.     /* TODO: Currently hard-coded to 16-bit, there doesn't seem

  285.                  to be a good way to get number of bits of audio */

  286.     put_be16(pb, 0x10); /* Reserved */

  287. 

  288.     if(track->enc->codec_id == CODEC_ID_AAC ||

  289.        track->enc->codec_id == CODEC_ID_MP3)

  290.     {

  291.         put_be16(pb, 0xfffe); /* compression ID (vbr)*/

  292.     }

  293.     else

  294.     {

  295.         put_be16(pb, 0); /* compression ID (= 0) */

  296.     }

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

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

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

  300. 

  301.     if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)

  302.     {

  303.         /* SoundDescription V1 extended info */

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

  305.         put_be32(pb, 1536); /* Bytes per packet */

  306.         put_be32(pb, 2); /* Bytes per frame */

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

  308.     }

  309. 

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

  311.         if( track->mode == MODE_MOV ) mov_write_wave_tag(pb, track);

  312.         else mov_write_esds_tag(pb, track);

  313.     }

  314.     if(track->enc->codec_id == CODEC_ID_AMR_NB)

  315.         mov_write_damr_tag(pb);

  316.     return updateSize (pb, pos);

  317. }

  318. 

  319. static int mov_write_d263_tag(ByteIOContext *pb)

  320. {

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

  322.     put_tag(pb, "d263");

  323.     put_tag(pb, "FFMP");

  324.     put_be16(pb, 0x0a);

  325.     put_byte(pb, 0);

  326.     return 0xf;

  327. }

  328. 

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

  330. static int mov_write_svq3_tag(ByteIOContext *pb)

  331. {

  332.     put_be32(pb, 0x15);

  333.     put_tag(pb, "SMI ");

  334.     put_tag(pb, "SEQH");

  335.     put_be32(pb, 0x5);

  336.     put_be32(pb, 0xe2c0211d);

  337.     put_be32(pb, 0xc0000000);

  338.     put_byte(pb, 0);   

  339.     return 0x15;

  340. }

  341. 

  342. static unsigned int descrLength(unsigned int len)

  343. {

  344.     if (len < 0x00000080)

  345.         return 2 + len;

  346.     else if (len < 0x00004000)

  347.         return 3 + len;

  348.     else if(len < 0x00200000)

  349.         return 4 + len;

  350.     else

  351.         return 5 + len;

  352. }

  353. 

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

  355. {

  356.     uint32_t len;

  357.     uint8_t  vals[4];

  358. 

  359.     len = size;

  360.     vals[3] = (uint8_t)(len & 0x7f);

  361.     len >>= 7;

  362.     vals[2] = (uint8_t)((len & 0x7f) | 0x80); 

  363.     len >>= 7;

  364.     vals[1] = (uint8_t)((len & 0x7f) | 0x80); 

  365.     len >>= 7;

  366.     vals[0] = (uint8_t)((len & 0x7f) | 0x80);

  367. 

  368.     put_byte(pb, tag); // DescriptorTag

  369. 

  370.     if (size < 0x00000080)

  371.     {

  372.         put_byte(pb, vals[3]);

  373.     }

  374.     else if (size < 0x00004000)

  375.     {

  376.         put_byte(pb, vals[2]);

  377.         put_byte(pb, vals[3]);

  378.     }

  379.     else if (size < 0x00200000)

  380.     {

  381.         put_byte(pb, vals[1]);

  382.         put_byte(pb, vals[2]);

  383.         put_byte(pb, vals[3]);

  384.     }

  385.     else if (size < 0x10000000)

  386.     {

  387.         put_byte(pb, vals[0]);

  388.         put_byte(pb, vals[1]);

  389.         put_byte(pb, vals[2]);

  390.         put_byte(pb, vals[3]);

  391.     }

  392. }

  393. 

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

  395. {

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

  397.     int pos = url_ftell(pb);

  398. 

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

  400.     put_tag(pb, "esds");

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

  402. 

  403.     // ES descriptor

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

  405.              descrLength(1));

  406.     put_be16(pb, 0x0001);          // ID (= 1)

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

  408. 

  409.     // DecoderConfig descriptor

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

  411. 

  412.     if(track->enc->codec_id == CODEC_ID_AAC)

  413.         put_byte(pb, 0x40);        // Object type indication

  414.     else if(track->enc->codec_id == CODEC_ID_MPEG4)

  415.         put_byte(pb, 0x20);        // Object type indication (Visual 14496-2)

  416. 

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

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

  419.     else

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

  421. 

  422.     put_byte(pb, 0x0);             // Buffersize DB (24 bits)

  423.     put_be16(pb, 0x0dd2);          // Buffersize DB

  424. 

  425.     // TODO: find real values for these

  426.     put_be32(pb, 0x0002e918);     // maxbitrate

  427.     put_be32(pb, 0x00017e6b);     // avg bitrate

  428. 

  429.     if (track->vosLen)

  430.     {

  431.         // DecoderSpecific info descriptor

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

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

  434.     }

  435. 

  436.     // SL descriptor

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

  438.     put_byte(pb, 0x02);

  439.     return updateSize (pb, pos);

  440. }

  441. 

  442. const CodecTag codec_movvideo_tags[] = {

  443.     { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') },

  444.     { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') },

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

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

  447.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') },

  448.     { 0, 0 },

  449. };

  450. 

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

  452. {

  453.     int pos = url_ftell(pb);

  454.     int tag;

  455. 

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

  457. 

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

  459.     if (!tag)

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

  461.     // if no mac fcc found, try with Microsoft tags

  462.     if (!tag)

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

  464.     put_le32(pb, tag); // store it byteswapped

  465. 

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

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

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

  469. 

  470.     put_be32(pb, 0); /* Reserved (= 02000c) */

  471.     put_be32(pb, 0); /* Reserved ("SVis")*/

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

  473.     put_be32(pb, 0); /* Reserved (400)*/

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

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

  476.     put_be32(pb, 0x00480000); /* Reserved */

  477.     put_be32(pb, 0x00480000); /* Reserved */

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

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

  480.     

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

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

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

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

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

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

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

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

  489.     

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

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

  492.     if(track->enc->codec_id == CODEC_ID_MPEG4)

  493.         mov_write_esds_tag(pb, track);

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

  495.         mov_write_d263_tag(pb);

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

  497.         mov_write_svq3_tag(pb);    

  498. 

  499.     return updateSize (pb, pos);

  500. }

  501. 

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

  503. {

  504.     int pos = url_ftell(pb);

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

  506.     put_tag(pb, "stsd");

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

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

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

  510.         mov_write_video_tag(pb, track);

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

  512.         mov_write_audio_tag(pb, track);

  513.     return updateSize(pb, pos);

  514. }

  515. 

  516. /* TODO?: Currently all samples/frames seem to have same duration */

  517. /* Time to sample atom */

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

  519. {

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

  521.     put_tag(pb, "stts");

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

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

  524. 

  525.     put_be32(pb, track->sampleCount); /* sample count */

  526.     put_be32(pb, track->sampleDuration); /* sample duration */

  527.     return 0x18;

  528. }

  529. 

  530. static int mov_write_dref_tag(ByteIOContext *pb)

  531. {

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

  533.     put_tag(pb, "dref");

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

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

  536. 

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

  538.     put_tag(pb, "url ");

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

  540. 

  541.     return 28;

  542. }

  543. 

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

  545. {

  546.     int pos = url_ftell(pb);

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

  548.     put_tag(pb, "stbl");

  549.     mov_write_stsd_tag(pb, track);

  550.     mov_write_stts_tag(pb, track);

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

  552.         track->hasKeyframes)

  553.         mov_write_stss_tag(pb, track);

  554.     mov_write_stsc_tag(pb, track);

  555.     mov_write_stsz_tag(pb, track);

  556.     mov_write_stco_tag(pb, track);

  557.     return updateSize(pb, pos);

  558. }

  559. 

  560. static int mov_write_dinf_tag(ByteIOContext *pb)

  561. {

  562.     int pos = url_ftell(pb);

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

  564.     put_tag(pb, "dinf");

  565.     mov_write_dref_tag(pb);

  566.     return updateSize(pb, pos);

  567. }

  568. 

  569. static int mov_write_smhd_tag(ByteIOContext *pb)

  570. {

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

  572.     put_tag(pb, "smhd");

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

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

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

  576.     return 16;

  577. }

  578. 

  579. static int mov_write_vmhd_tag(ByteIOContext *pb)

  580. {

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

  582.     put_tag(pb, "vmhd");

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

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

  585.     return 0x14;

  586. }

  587. 

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

  589. {

  590.     char *descr, *hdlr, *hdlr_type;

  591.     int pos = url_ftell(pb);

  592.     

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

  594. 	hdlr = "dhlr";

  595. 	hdlr_type = "url ";

  596. 	descr = "DataHandler";

  597.     } else {

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

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

  600. 	    hdlr_type = "vide";

  601. 	    descr = "VideoHandler";

  602. 	} else {

  603. 	    hdlr_type = "soun";

  604. 	    descr = "SoundHandler";

  605. 	}

  606.     }

  607.     

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

  609.     put_tag(pb, "hdlr");

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

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

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

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

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

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

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

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

  618.     return updateSize(pb, pos);

  619. }

  620. 

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

  622. {

  623.     int pos = url_ftell(pb);

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

  625.     put_tag(pb, "minf");

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

  627.         mov_write_vmhd_tag(pb);

  628.     else

  629.         mov_write_smhd_tag(pb);

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

  631.         mov_write_hdlr_tag(pb, NULL);

  632.     mov_write_dinf_tag(pb);

  633.     mov_write_stbl_tag(pb, track);

  634.     return updateSize(pb, pos);

  635. }

  636. 

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

  638. {

  639.     put_be32(pb, 32); /* size */

  640.     put_tag(pb, "mdhd");

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

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

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

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

  645.     put_be32(pb, track->trackDuration); /* duration */

  646.     put_be16(pb, 0); /* language, 0 = english */

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

  648.     return 32;

  649. }

  650. 

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

  652. {

  653.     int pos = url_ftell(pb);

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

  655.     put_tag(pb, "mdia");

  656.     mov_write_mdhd_tag(pb, track);

  657.     mov_write_hdlr_tag(pb, track);

  658.     mov_write_minf_tag(pb, track);

  659.     return updateSize(pb, pos);

  660. }

  661. 

  662. static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack* track)

  663. {

  664.     int64_t maxTrackLenTemp;

  665.     put_be32(pb, 0x5c); /* size (always 0x5c) */

  666.     put_tag(pb, "tkhd");

  667.     put_be32(pb, 0xf); /* version & flags (track enabled) */

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

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

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

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

  672.     maxTrackLenTemp = ((int64_t)globalTimescale*(int64_t)track->trackDuration)/(int64_t)track->timescale;

  673.     put_be32(pb, (long)maxTrackLenTemp); /* duration */

  674. 

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

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

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

  678.     /* Volume, only for audio */

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

  680.         put_be16(pb, 0x0100);

  681.     else

  682.         put_be16(pb, 0);

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

  684. 

  685.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  695. 

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

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

  698.         double sample_aspect_ratio = av_q2d(track->enc->sample_aspect_ratio);

  699.         if( !sample_aspect_ratio ) sample_aspect_ratio = 1;

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

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

  702.     }

  703.     else {

  704.         put_be32(pb, 0);

  705.         put_be32(pb, 0);

  706.     }

  707.     return 0x5c;

  708. }

  709. 

  710. static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack* track)

  711. {

  712.     int pos = url_ftell(pb);

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

  714.     put_tag(pb, "trak");

  715.     mov_write_tkhd_tag(pb, track);

  716.     mov_write_mdia_tag(pb, track);

  717.     return updateSize(pb, pos);

  718. }

  719. 

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

  721. static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)

  722. {

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

  724.     put_tag(pb, "iods");

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

  726.     put_be16(pb, 0x1007);

  727.     put_byte(pb, 0);

  728.     put_be16(pb, 0x4fff);

  729.     put_be16(pb, 0xfffe);

  730.     put_be16(pb, 0x01ff);

  731.     return 0x15;

  732. }

  733. 

  734. static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)

  735. {

  736.     int maxTrackID = 1, maxTrackLen = 0, i;

  737.     int64_t maxTrackLenTemp;

  738. 

  739.     put_be32(pb, 0x6c); /* size (always 0x6c) */

  740.     put_tag(pb, "mvhd");

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

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

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

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

  745.     for (i=0; i<MAX_STREAMS; i++) {

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

  747.             maxTrackLenTemp = ((int64_t)globalTimescale*(int64_t)mov->tracks[i].trackDuration)/(int64_t)mov->tracks[i].timescale;

  748.             if(maxTrackLen < maxTrackLenTemp)

  749.                 maxTrackLen = maxTrackLenTemp;

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

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

  752.         }

  753.     }

  754.     put_be32(pb, maxTrackLen); /* duration of longest track */

  755. 

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

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

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

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

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

  761. 

  762.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  772. 

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

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

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

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

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

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

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

  780.     return 0x6c;

  781. }

  782. 

  783. static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext* mov,

  784.                                      AVFormatContext *s)

  785. {

  786.     int pos = url_ftell(pb);

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

  788.     put_tag(pb, "hdlr");

  789.     put_be32(pb, 0);

  790.     put_be32(pb, 0);

  791.     put_tag(pb, "mdir");

  792.     put_tag(pb, "appl");

  793.     put_be32(pb, 0);

  794.     put_be32(pb, 0);

  795.     put_be16(pb, 0);

  796.     return updateSize(pb, pos);

  797. }

  798. 

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

  800. static int mov_write_string_data_tag(ByteIOContext *pb, MOVContext* mov,

  801.                                      AVFormatContext *s, const char *data)

  802. {

  803.     int pos = url_ftell(pb);

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

  805.     put_tag(pb, "data");

  806.     put_be32(pb, 1);

  807.     put_be32(pb, 0);

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

  809.     return updateSize(pb, pos);

  810. }

  811. 

  812. /* iTunes name of the song/movie */

  813. static int mov_write_nam_tag(ByteIOContext *pb, MOVContext* mov,

  814.                              AVFormatContext *s)

  815. {

  816.     int size = 0;

  817.     if ( s->title[0] ) {

  818.         int pos = url_ftell(pb);

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

  820.         put_tag(pb, "\251nam");

  821.         mov_write_string_data_tag(pb, mov, s, s->title);

  822.         size = updateSize(pb, pos);

  823.     }

  824.     return size;

  825. }

  826. 

  827. /* iTunes name of the artist/performer */

  828. static int mov_write_ART_tag(ByteIOContext *pb, MOVContext* mov,

  829.                              AVFormatContext *s)

  830. {

  831.     int size = 0;

  832.     if ( s->author[0] ) {

  833.         int pos = url_ftell(pb);

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

  835.         put_tag(pb, "\251ART");

  836.         // we use the author here as this is the only thing that we have...

  837.         mov_write_string_data_tag(pb, mov, s, s->author);

  838.         size = updateSize(pb, pos);

  839.     }

  840.     return size;

  841. }

  842. 

  843. /* iTunes name of the writer */

  844. static int mov_write_wrt_tag(ByteIOContext *pb, MOVContext* mov,

  845.                              AVFormatContext *s)

  846. {

  847.     int size = 0;

  848.     if ( s->author[0] ) {

  849.         int pos = url_ftell(pb);

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

  851.         put_tag(pb, "\251wrt");

  852.         mov_write_string_data_tag(pb, mov, s, s->author);

  853.         size = updateSize(pb, pos);

  854.     }

  855.     return size;

  856. }

  857. 

  858. /* iTunes name of the album */

  859. static int mov_write_alb_tag(ByteIOContext *pb, MOVContext* mov,

  860.                              AVFormatContext *s)

  861. {

  862.     int size = 0;

  863.     if ( s->album[0] ) {

  864.         int pos = url_ftell(pb);

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

  866.         put_tag(pb, "\251alb");

  867.         mov_write_string_data_tag(pb, mov, s, s->album);

  868.         size = updateSize(pb, pos);

  869.     }

  870.     return size;

  871. }

  872. 

  873. /* iTunes year */

  874. static int mov_write_day_tag(ByteIOContext *pb, MOVContext* mov,

  875.                              AVFormatContext *s)

  876. {

  877.     char year[5];

  878.     int size = 0;

  879.     if ( s->year ) {

  880.         int pos = url_ftell(pb);

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

  882.         put_tag(pb, "\251day");

  883.         snprintf(year, 5, "%04d", s->year);

  884.         mov_write_string_data_tag(pb, mov, s, year);

  885.         size = updateSize(pb, pos);

  886.     }

  887.     return size;

  888. }

  889. 

  890. /* iTunes tool used to create the file */

  891. static int mov_write_too_tag(ByteIOContext *pb, MOVContext* mov,

  892.                              AVFormatContext *s)

  893. {

  894.     int pos = url_ftell(pb);

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

  896.     put_tag(pb, "\251too");

  897.     mov_write_string_data_tag(pb, mov, s, LIBAVFORMAT_IDENT);

  898.     return updateSize(pb, pos);

  899. }

  900. 

  901. /* iTunes comment */

  902. static int mov_write_cmt_tag(ByteIOContext *pb, MOVContext* mov,

  903.                              AVFormatContext *s)

  904. {

  905.     int size = 0;

  906.     if ( s->comment[0] ) {

  907.         int pos = url_ftell(pb);

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

  909.         put_tag(pb, "\251cmt");

  910.         mov_write_string_data_tag(pb, mov, s, s->comment);

  911.         size = updateSize(pb, pos);

  912.     }

  913.     return size;

  914. }

  915. 

  916. /* iTunes custom genre */

  917. static int mov_write_gen_tag(ByteIOContext *pb, MOVContext* mov,

  918.                              AVFormatContext *s)

  919. {

  920.     int size = 0;

  921.     if ( s->genre[0] ) {

  922.         int pos = url_ftell(pb);

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

  924.         put_tag(pb, "\251gen");

  925.         mov_write_string_data_tag(pb, mov, s, s->genre);

  926.         size = updateSize(pb, pos);

  927.     }

  928.     return size;

  929. }

  930. 

  931. /* iTunes track number */

  932. static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext* mov,

  933.                               AVFormatContext *s)

  934. {

  935.     int size = 0;

  936.     if ( s->track ) {

  937.         int pos = url_ftell(pb);

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

  939.         put_tag(pb, "trkn");

  940.         {

  941.             int pos = url_ftell(pb);

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

  943.             put_tag(pb, "data");

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

  945.             put_be32(pb, 0);

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

  947.             put_be16(pb, s->track); // track number

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

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

  950.             updateSize(pb, pos);

  951.         }

  952.         size = updateSize(pb, pos);

  953.     }

  954.     return size;

  955. }

  956. 

  957. /* iTunes meta data list */

  958. static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext* mov,

  959.                               AVFormatContext *s)

  960. {

  961.     int pos = url_ftell(pb);

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

  963.     put_tag(pb, "ilst");

  964.     mov_write_nam_tag(pb, mov, s);

  965.     mov_write_ART_tag(pb, mov, s);

  966.     mov_write_wrt_tag(pb, mov, s);

  967.     mov_write_alb_tag(pb, mov, s);

  968.     mov_write_day_tag(pb, mov, s);

  969.     mov_write_too_tag(pb, mov, s);

  970.     mov_write_cmt_tag(pb, mov, s);

  971.     mov_write_gen_tag(pb, mov, s);

  972.     mov_write_trkn_tag(pb, mov, s);

  973.     return updateSize(pb, pos);

  974. }

  975. 

  976. /* iTunes meta data tag */

  977. static int mov_write_meta_tag(ByteIOContext *pb, MOVContext* mov,

  978.                               AVFormatContext *s)

  979. {

  980.     int size = 0;

  981. 

  982.     // only save meta tag if required

  983.     if ( s->title[0] || s->author[0] || s->album[0] || s->year || 

  984.          s->comment[0] || s->genre[0] || s->track ) {

  985.         int pos = url_ftell(pb);

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

  987.         put_tag(pb, "meta");

  988.         put_be32(pb, 0);

  989.         mov_write_itunes_hdlr_tag(pb, mov, s);

  990.         mov_write_ilst_tag(pb, mov, s);

  991.         size = updateSize(pb, pos);

  992.     }

  993.     return size;

  994. }

  995.     

  996. static int mov_write_udta_tag(ByteIOContext *pb, MOVContext* mov,

  997.                               AVFormatContext *s)

  998. {

  999.     int pos = url_ftell(pb);

  1000.     int i;

  1001. 

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

  1003.     put_tag(pb, "udta");

  1004. 

  1005.     /* iTunes meta data */

  1006.     mov_write_meta_tag(pb, mov, s);

  1007. 

  1008.     /* Requirements */

  1009.     for (i=0; i<MAX_STREAMS; i++) {

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

  1011.         if (mov->tracks[i].enc->codec_id == CODEC_ID_AAC ||

  1012.             mov->tracks[i].enc->codec_id == CODEC_ID_MPEG4) {

  1013.             int pos = url_ftell(pb);

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

  1015.             put_tag(pb, "\251req");

  1016.             put_be16(pb, sizeof("QuickTime 6.0 or greater") - 1);

  1017.             put_be16(pb, 0);

  1018.             put_buffer(pb, "QuickTime 6.0 or greater",

  1019.                        sizeof("QuickTime 6.0 or greater") - 1);

  1020.             updateSize(pb, pos);

  1021.             break;

  1022.         }

  1023.     }

  1024. 

  1025.     /* Encoder */

  1026.     if(!(mov->tracks[0].enc->flags & CODEC_FLAG_BITEXACT))

  1027.     {

  1028.         int pos = url_ftell(pb);

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

  1030.         put_tag(pb, "\251enc");

  1031.         put_be16(pb, sizeof(LIBAVFORMAT_IDENT) - 1); /* string length */

  1032.         put_be16(pb, 0);

  1033.         put_buffer(pb, LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);

  1034.         updateSize(pb, pos);

  1035.     }

  1036. 

  1037.     if( s->title[0] )

  1038.     {

  1039.         int pos = url_ftell(pb);

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

  1041.         put_tag(pb, "\251nam");

  1042.         put_be16(pb, strlen(s->title)); /* string length */

  1043.         put_be16(pb, 0);

  1044.         put_buffer(pb, s->title, strlen(s->title));

  1045.         updateSize(pb, pos);

  1046.     }

  1047. 

  1048.     if( s->author[0] )

  1049.     {

  1050.         int pos = url_ftell(pb);

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

  1052.         put_tag(pb, /*"\251aut"*/ "\251day" );

  1053.         put_be16(pb, strlen(s->author)); /* string length */

  1054.         put_be16(pb, 0);

  1055.         put_buffer(pb, s->author, strlen(s->author));

  1056.         updateSize(pb, pos);

  1057.     }

  1058. 

  1059.     if( s->comment[0] )

  1060.     {

  1061.         int pos = url_ftell(pb);

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

  1063.         put_tag(pb, "\251des");

  1064.         put_be16(pb, strlen(s->comment)); /* string length */

  1065.         put_be16(pb, 0);

  1066.         put_buffer(pb, s->comment, strlen(s->comment));

  1067.         updateSize(pb, pos);

  1068.     }

  1069. 

  1070.     return updateSize(pb, pos);

  1071. }

  1072. 

  1073. static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,

  1074.                               AVFormatContext *s)

  1075. {

  1076.     int pos, i;

  1077.     pos = url_ftell(pb);

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

  1079.     put_tag(pb, "moov");

  1080.     mov->timescale = globalTimescale;

  1081. 

  1082.     for (i=0; i<MAX_STREAMS; i++) {

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

  1084. 

  1085.         if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO) {

  1086.             mov->tracks[i].timescale = mov->tracks[i].enc->frame_rate;

  1087.             mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_rate_base;

  1088.         }

  1089.         else if(mov->tracks[i].enc->codec_type == CODEC_TYPE_AUDIO) {

  1090.             /* If AMR, track timescale = 8000, AMR_WB = 16000 */

  1091.             if(mov->tracks[i].enc->codec_id == CODEC_ID_AMR_NB) {

  1092.                 mov->tracks[i].sampleDuration = 160;  // Bytes per chunk

  1093.                 mov->tracks[i].timescale = 8000;

  1094.             }

  1095.             else {

  1096.                 mov->tracks[i].timescale = mov->tracks[i].enc->sample_rate;

  1097.                 mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_size;

  1098.             }

  1099.         }

  1100. 

  1101.         mov->tracks[i].trackDuration = 

  1102.             mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;

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

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

  1105.     }

  1106. 

  1107.     mov_write_mvhd_tag(pb, mov);

  1108.     //mov_write_iods_tag(pb, mov);

  1109.     for (i=0; i<MAX_STREAMS; i++) {

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

  1111.             mov_write_trak_tag(pb, &(mov->tracks[i]));

  1112.         }

  1113.     }

  1114. 

  1115.     mov_write_udta_tag(pb, mov, s);

  1116. 

  1117.     return updateSize(pb, pos);

  1118. }

  1119. 

  1120. int mov_write_mdat_tag(ByteIOContext *pb, MOVContext* mov)

  1121. {

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

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

  1124.     put_tag(pb, "mdat");

  1125.     return 0;

  1126. }

  1127. 

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

  1129. int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)

  1130. {

  1131.     MOVContext *mov = s->priv_data;

  1132. 

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

  1134.     put_tag(pb, "ftyp");

  1135. 

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

  1137.         put_tag(pb, "3gp4");

  1138.     else

  1139.         put_tag(pb, "isom");

  1140. 

  1141.     put_be32(pb, 0x200 );

  1142. 

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

  1144.         put_tag(pb, "3gp4");

  1145.     else

  1146.         put_tag(pb, "mp41");

  1147. 

  1148.     return 0x14;

  1149. }

  1150. 

  1151. static int mov_write_header(AVFormatContext *s)

  1152. {

  1153.     ByteIOContext *pb = &s->pb;

  1154.     MOVContext *mov = s->priv_data;

  1155.     int i;

  1156. 

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

  1158.         AVCodecContext *c= &s->streams[i]->codec;

  1159. 

  1160.         if      (c->codec_type == CODEC_TYPE_VIDEO){

  1161.             if (!codec_get_tag(codec_movvideo_tags, c->codec_id)){

  1162.                 if(!codec_get_tag(codec_bmp_tags, c->codec_id))

  1163.                     return -1;

  1164.                 else

  1165.                     av_log(s, AV_LOG_INFO, "Warning, using MS style video codec tag, the file may be unplayable!\n");

  1166.             }

  1167.         }else if(c->codec_type == CODEC_TYPE_AUDIO){

  1168.             if (!codec_get_tag(codec_movaudio_tags, c->codec_id)){

  1169.                 if(!codec_get_tag(codec_wav_tags, c->codec_id))

  1170.                     return -1;

  1171.                 else

  1172.                     av_log(s, AV_LOG_INFO, "Warning, using MS style audio codec tag, the file may be unplayable!\n");

  1173.             }

  1174.         }

  1175.     }

  1176. 

  1177.     /* Default mode == MP4 */

  1178.     mov->mode = MODE_MP4;

  1179. 

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

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

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

  1183. 

  1184.         if ( mov->mode == MODE_3GP || mov->mode == MODE_MP4 )

  1185.             mov_write_ftyp_tag(pb,s);

  1186.     }

  1187. 

  1188.     for (i=0; i<MAX_STREAMS; i++) {

  1189.         mov->tracks[i].mode = mov->mode;

  1190.     }

  1191. 

  1192.     put_flush_packet(pb);

  1193. 

  1194.     return 0;

  1195. }

  1196. 

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

  1198. {

  1199.     MOVContext *mov = s->priv_data;

  1200.     ByteIOContext *pb = &s->pb;

  1201.     AVCodecContext *enc = &s->streams[pkt->stream_index]->codec;

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

  1203.     int cl, id;

  1204.     unsigned int samplesInChunk = 0;

  1205.     int size= pkt->size;

  1206. 

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

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

  1209. 

  1210.     if (enc->codec_type == CODEC_TYPE_VIDEO ) {

  1211.         samplesInChunk = 1;

  1212.     }

  1213.     else if (enc->codec_type == CODEC_TYPE_AUDIO ) {

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

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

  1216.             static uint16_t packed_size[16] =

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

  1218.             int len = 0;

  1219. 

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

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

  1222.                 samplesInChunk++;

  1223.             }

  1224.         }

  1225.         else if(enc->codec_id == CODEC_ID_PCM_ALAW) {

  1226.             samplesInChunk = size/enc->channels;

  1227.         }

  1228. 	else if(enc->codec_id == CODEC_ID_PCM_S16BE || enc->codec_id == CODEC_ID_PCM_S16LE) {

  1229. 	    samplesInChunk = size/(2*enc->channels);

  1230.         }	    

  1231.         else {

  1232.             samplesInChunk = 1;

  1233.         }

  1234.     }

  1235. 

  1236.     if ((enc->codec_id == CODEC_ID_MPEG4 || enc->codec_id == CODEC_ID_AAC)

  1237.         && trk->vosLen == 0) {

  1238. //        assert(enc->extradata_size);

  1239. 

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

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

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

  1243.     }

  1244. 

  1245.     cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;

  1246.     id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

  1247. 

  1248.     if (trk->ents_allocated <= trk->entry) {

  1249.         trk->cluster = av_realloc(trk->cluster, (cl+1)*sizeof(void*)); 

  1250.         if (!trk->cluster)

  1251.             return -1;

  1252.         trk->cluster[cl] = av_malloc(MOV_INDEX_CLUSTER_SIZE*sizeof(MOVIentry));

  1253.         if (!trk->cluster[cl])

  1254.             return -1;

  1255.         trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;

  1256.     }

  1257.     if (mov->mdat_written == 0) {

  1258.         mov_write_mdat_tag(pb, mov);

  1259.         mov->mdat_written = 1;

  1260.         mov->time = s->timestamp;

  1261.     }

  1262. 

  1263.     trk->cluster[cl][id].pos = url_ftell(pb);

  1264.     trk->cluster[cl][id].samplesInChunk = samplesInChunk;

  1265.     trk->cluster[cl][id].size = size;

  1266.     trk->cluster[cl][id].entries = samplesInChunk;

  1267.     if(enc->codec_type == CODEC_TYPE_VIDEO) {

  1268.         trk->cluster[cl][id].key_frame = !!(pkt->flags & PKT_FLAG_KEY);

  1269.         if(trk->cluster[cl][id].key_frame)

  1270.             trk->hasKeyframes = 1;

  1271.     }

  1272.     trk->enc = enc;

  1273.     trk->entry++;

  1274.     trk->sampleCount += samplesInChunk;

  1275.     trk->mdat_size += size;

  1276. 

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

  1278. 

  1279.     put_flush_packet(pb);

  1280.     return 0;

  1281. }

  1282. 

  1283. static int mov_write_trailer(AVFormatContext *s)

  1284. {

  1285.     MOVContext *mov = s->priv_data;

  1286.     ByteIOContext *pb = &s->pb;

  1287.     int res = 0;

  1288.     int i, j;

  1289. 

  1290.     offset_t moov_pos = url_ftell(pb);

  1291. 

  1292.     /* Write size of mdat tag */

  1293.     for (i=0, j=0; i<MAX_STREAMS; i++) {

  1294.         if(mov->tracks[i].ents_allocated > 0) {

  1295.             j += mov->tracks[i].mdat_size;

  1296.         }

  1297.     }

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

  1299.     put_be32(pb, j+8);

  1300.     url_fseek(pb, moov_pos, SEEK_SET);

  1301. 

  1302.     mov_write_moov_tag(pb, mov, s);

  1303. 

  1304.     for (i=0; i<MAX_STREAMS; i++) {

  1305.         for (j=0; j<mov->tracks[i].ents_allocated/MOV_INDEX_CLUSTER_SIZE; j++) {

  1306.             av_free(mov->tracks[i].cluster[j]);

  1307.         }

  1308.         av_free(mov->tracks[i].cluster);

  1309.         if( mov->tracks[i].vosLen ) av_free( mov->tracks[i].vosData );

  1310. 

  1311.         mov->tracks[i].cluster = NULL;

  1312.         mov->tracks[i].ents_allocated = mov->tracks[i].entry = 0;

  1313.     }

  1314. 

  1315.     put_flush_packet(pb);

  1316. 

  1317.     return res;

  1318. }

  1319. 

  1320. static AVOutputFormat mov_oformat = {

  1321.     "mov",

  1322.     "mov format",

  1323.     NULL,

  1324.     "mov",

  1325.     sizeof(MOVContext),

  1326.     CODEC_ID_AAC,

  1327.     CODEC_ID_MPEG4,

  1328.     mov_write_header,

  1329.     mov_write_packet,

  1330.     mov_write_trailer,

  1331. };

  1332. 

  1333. static AVOutputFormat _3gp_oformat = {

  1334.     "3gp",

  1335.     "3gp format",

  1336.     NULL,

  1337.     "3gp",

  1338.     sizeof(MOVContext),

  1339.     CODEC_ID_AMR_NB,

  1340.     CODEC_ID_H263,

  1341.     mov_write_header,

  1342.     mov_write_packet,

  1343.     mov_write_trailer,

  1344. };

  1345. 

  1346. static AVOutputFormat mp4_oformat = {

  1347.     "mp4",

  1348.     "mp4 format",

  1349.     "application/mp4",

  1350.     "mp4,m4a",

  1351.     sizeof(MOVContext),

  1352.     CODEC_ID_AAC,

  1353.     CODEC_ID_MPEG4,

  1354.     mov_write_header,

  1355.     mov_write_packet,

  1356.     mov_write_trailer,

  1357. };

  1358. 

  1359. int movenc_init(void)

  1360. {

  1361.     av_register_output_format(&mov_oformat);

  1362.     av_register_output_format(&_3gp_oformat);

  1363.     av_register_output_format(&mp4_oformat);

  1364.     return 0;

  1365. }