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

1806 lines
55KB
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. #include "avformat.h"

  21. #include "avi.h"

  22. #include "avio.h"

  23. #include "mov.h"

  24. 

  25. #undef NDEBUG

  26. #include <assert.h>

  27. 

  28. #define MOV_INDEX_CLUSTER_SIZE 16384

  29. #define globalTimescale 1000

  30. 

  31. #define MODE_MP4 0

  32. #define MODE_MOV 1

  33. #define MODE_3GP 2

  34. #define MODE_PSP 3 // example working PSP command line:

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

  36. #define MODE_3G2 4

  37. 

  38. typedef struct MOVIentry {

  39.     unsigned int flags, size;

  40.     uint64_t     pos;

  41.     unsigned int samplesInChunk;

  42.     char         key_frame;

  43.     unsigned int entries;

  44.     int64_t      cts;

  45. } MOVIentry;

  46. 

  47. typedef struct MOVIndex {

  48.     int         mode;

  49.     int         entry;

  50.     int         ents_allocated;

  51.     long        timescale;

  52.     long        time;

  53.     int64_t     trackDuration;

  54.     long        sampleCount;

  55.     long        sampleDuration;

  56.     int         hasKeyframes;

  57.     int         hasBframes;

  58.     int         language;

  59.     int         trackID;

  60.     int         tag;

  61.     AVCodecContext *enc;

  62. 

  63.     int         vosLen;

  64.     uint8_t     *vosData;

  65.     MOVIentry** cluster;

  66. } MOVTrack;

  67. 

  68. typedef struct MOVContext {

  69.     int     mode;

  70.     int64_t time;

  71.     int     nb_streams;

  72.     offset_t mdat_pos;

  73.     uint64_t mdat_size;

  74.     long    timescale;

  75.     MOVTrack tracks[MAX_STREAMS];

  76. } MOVContext;

  77. 

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

  79. static offset_t updateSize (ByteIOContext *pb, offset_t pos)

  80. {

  81.     offset_t curpos = url_ftell(pb);

  82.     url_fseek(pb, pos, SEEK_SET);

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

  84.     url_fseek(pb, curpos, SEEK_SET);

  85. 

  86.     return curpos - pos;

  87. }

  88. 

  89. /* Chunk offset atom */

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

  91. {

  92.     int i;

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

  94.     offset_t pos = url_ftell(pb);

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

  96.     if (pos > UINT32_MAX) {

  97.         mode64 = 1;

  98.         put_tag(pb, "co64");

  99.     } else

  100.         put_tag(pb, "stco");

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

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

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

  104.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  105.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  106.         if(mode64 == 1)

  107.             put_be64(pb, track->cluster[cl][id].pos);

  108.         else

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

  110.     }

  111.     return updateSize (pb, pos);

  112. }

  113. 

  114. /* Sample size atom */

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

  116. {

  117.     int equalChunks = 1;

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

  119. 

  120.     offset_t pos = url_ftell(pb);

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

  122.     put_tag(pb, "stsz");

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

  124. 

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

  126.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  127.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

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

  130.             equalChunks = 0;

  131.         }

  132.         oldtst = tst;

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

  134.     }

  135.     if (equalChunks) {

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

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

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

  139.     }

  140.     else {

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

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

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

  144.             int cl = i / MOV_INDEX_CLUSTER_SIZE;

  145.             int id = i % MOV_INDEX_CLUSTER_SIZE;

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

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

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

  149.             }

  150.         }

  151.     }

  152.     return updateSize (pb, pos);

  153. }

  154. 

  155. /* Sample to chunk atom */

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

  157. {

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

  159.     offset_t entryPos, curpos;

  160. 

  161.     offset_t pos = url_ftell(pb);

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

  163.     put_tag(pb, "stsc");

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

  165.     entryPos = url_ftell(pb);

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

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

  168.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  169.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  171.         {

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

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

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

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

  176.             index++;

  177.         }

  178.     }

  179.     curpos = url_ftell(pb);

  180.     url_fseek(pb, entryPos, SEEK_SET);

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

  182.     url_fseek(pb, curpos, SEEK_SET);

  183. 

  184.     return updateSize (pb, pos);

  185. }

  186. 

  187. /* Sync sample atom */

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

  189. {

  190.     offset_t curpos, entryPos;

  191.     int i, index = 0;

  192.     offset_t pos = url_ftell(pb);

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

  194.     put_tag(pb, "stss");

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

  196.     entryPos = url_ftell(pb);

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

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

  199.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  200.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  202.             put_be32(pb, i+1);

  203.             index++;

  204.         }

  205.     }

  206.     curpos = url_ftell(pb);

  207.     url_fseek(pb, entryPos, SEEK_SET);

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

  209.     url_fseek(pb, curpos, SEEK_SET);

  210.     return updateSize (pb, pos);

  211. }

  212. 

  213. static int mov_write_damr_tag(ByteIOContext *pb)

  214. {

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

  216.     put_tag(pb, "damr");

  217.     put_tag(pb, "FFMP");

  218.     put_byte(pb, 0);

  219. 

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

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

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

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

  224.     return 0x11;

  225. }

  226. 

  227. static int mov_write_enda_tag(ByteIOContext *pb)

  228. {

  229.     put_be32(pb, 10);

  230.     put_tag(pb, "enda");

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

  232.     return 10;

  233. }

  234. 

  235. static unsigned int descrLength(unsigned int len)

  236. {

  237.     int i;

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

  239.     return len + 1 + i;

  240. }

  241. 

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

  243. {

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

  245.     put_byte(pb, tag);

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

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

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

  249. }

  250. 

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

  252. {

  253.     offset_t pos = url_ftell(pb);

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

  255. 

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

  257.     put_tag(pb, "esds");

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

  259. 

  260.     // ES descriptor

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

  262.              descrLength(1));

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

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

  265. 

  266.     // DecoderConfig descriptor

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

  268. 

  269.     // Object type indication

  270.     put_byte(pb, codec_get_tag(ff_mov_obj_type, track->enc->codec_id));

  271. 

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

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

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

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

  276.     else

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

  278. 

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

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

  281. 

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

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

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

  285.     else

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

  287. 

  288.     if (track->vosLen)

  289.     {

  290.         // DecoderSpecific info descriptor

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

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

  293.     }

  294. 

  295. 

  296.     // SL descriptor

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

  298.     put_byte(pb, 0x02);

  299.     return updateSize (pb, pos);

  300. }

  301. 

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

  303. {

  304.     offset_t pos = url_ftell(pb);

  305. 

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

  307.     put_tag(pb, "wave");

  308. 

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

  310.     put_tag(pb, "frma");

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

  312. 

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

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

  315.         put_tag(pb, "mp4a");

  316.         put_be32(pb, 0);

  317. 

  318.         mov_write_esds_tag(pb, track);

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

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

  321.         mov_write_enda_tag(pb);

  322.     }

  323. 

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

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

  326. 

  327.     return updateSize (pb, pos);

  328. }

  329. 

  330. static const CodecTag codec_movaudio_tags[] = {

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

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

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

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

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

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

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

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

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

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

  341.     { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') },

  342.     { CODEC_ID_PCM_S24LE, MKTAG('i', 'n', '2', '4') },

  343.     { CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') },

  344.     { CODEC_ID_PCM_S32LE, MKTAG('i', 'n', '3', '2') },

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

  346.     { CODEC_ID_NONE, 0 },

  347. };

  348. 

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

  350. {

  351.     offset_t pos = url_ftell(pb);

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

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

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

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

  356. 

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

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

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

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

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

  362. 

  363.     /* SoundDescription */

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

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

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

  367. 

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

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

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

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

  372. 

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

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

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

  376.     }

  377.     else {

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

  379.     }

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

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

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

  383. 

  384.     if(version == 1) {

  385.         /* SoundDescription V1 extended info */

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

  387.         put_be32(pb, track->sampleDuration); /* Bytes per frame */

  388.         put_be32(pb, 8); /* Bytes per sample */

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

  390.     }

  391. 

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

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

  394.         else                         mov_write_esds_tag(pb, track);

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

  396.         mov_write_damr_tag(pb);

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

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

  399.         mov_write_wave_tag(pb, track);

  400.     }

  401.     return updateSize (pb, pos);

  402. }

  403. 

  404. static int mov_write_d263_tag(ByteIOContext *pb)

  405. {

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

  407.     put_tag(pb, "d263");

  408.     put_tag(pb, "FFMP");

  409.     put_be16(pb, 0x0a);

  410.     put_byte(pb, 0);

  411.     return 0xf;

  412. }

  413. 

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

  415. static int mov_write_svq3_tag(ByteIOContext *pb)

  416. {

  417.     put_be32(pb, 0x15);

  418.     put_tag(pb, "SMI ");

  419.     put_tag(pb, "SEQH");

  420.     put_be32(pb, 0x5);

  421.     put_be32(pb, 0xe2c0211d);

  422.     put_be32(pb, 0xc0000000);

  423.     put_byte(pb, 0);

  424.     return 0x15;

  425. }

  426. 

  427. static uint8_t *avc_find_startcode( uint8_t *p, uint8_t *end )

  428. {

  429.     uint8_t *a = p + 4 - ((int)p & 3);

  430. 

  431.     for( end -= 3; p < a && p < end; p++ ) {

  432.         if( p[0] == 0 && p[1] == 0 && p[2] == 1 )

  433.             return p;

  434.     }

  435. 

  436.     for( end -= 3; p < end; p += 4 ) {

  437.         uint32_t x = *(uint32_t*)p;

  438. //      if( (x - 0x01000100) & (~x) & 0x80008000 ) // little endian

  439. //      if( (x - 0x00010001) & (~x) & 0x00800080 ) // big endian

  440.         if( (x - 0x01010101) & (~x) & 0x80808080 ) { // generic

  441.             if( p[1] == 0 ) {

  442.                 if( p[0] == 0 && p[2] == 1 )

  443.                     return p;

  444.                 if( p[2] == 0 && p[3] == 1 )

  445.                     return p+1;

  446.             }

  447.             if( p[3] == 0 ) {

  448.                 if( p[2] == 0 && p[4] == 1 )

  449.                     return p+2;

  450.                 if( p[4] == 0 && p[5] == 1 )

  451.                     return p+3;

  452.             }

  453.         }

  454.     }

  455. 

  456.     for( end += 3; p < end; p++ ) {

  457.         if( p[0] == 0 && p[1] == 0 && p[2] == 1 )

  458.             return p;

  459.     }

  460. 

  461.     return end + 3;

  462. }

  463. 

  464. static void avc_parse_nal_units(uint8_t **buf, int *size)

  465. {

  466.     ByteIOContext pb;

  467.     uint8_t *p = *buf;

  468.     uint8_t *end = p + *size;

  469.     uint8_t *nal_start, *nal_end;

  470. 

  471.     url_open_dyn_buf(&pb);

  472.     nal_start = avc_find_startcode(p, end);

  473.     while (nal_start < end) {

  474.         while(!*(nal_start++));

  475.         nal_end = avc_find_startcode(nal_start, end);

  476.         put_be32(&pb, nal_end - nal_start);

  477.         put_buffer(&pb, nal_start, nal_end - nal_start);

  478.         nal_start = nal_end;

  479.     }

  480.     av_freep(buf);

  481.     *size = url_close_dyn_buf(&pb, buf);

  482. }

  483. 

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

  485. {

  486.     offset_t pos = url_ftell(pb);

  487. 

  488.     put_be32(pb, 0);

  489.     put_tag(pb, "avcC");

  490.     if (track->vosLen > 6) {

  491.         /* check for h264 start code */

  492.         if (BE_32(track->vosData) == 0x00000001) {

  493.             uint8_t *buf, *end;

  494.             uint32_t sps_size=0, pps_size=0;

  495.             uint8_t *sps=0, *pps=0;

  496. 

  497.             avc_parse_nal_units(&track->vosData, &track->vosLen);

  498.             buf = track->vosData;

  499.             end = track->vosData + track->vosLen;

  500. 

  501.             /* look for sps and pps */

  502.             while (buf < end) {

  503.                 unsigned int size;

  504.                 uint8_t nal_type;

  505.                 size = BE_32(buf);

  506.                 nal_type = buf[4] & 0x1f;

  507.                 if (nal_type == 7) { /* SPS */

  508.                     sps = buf + 4;

  509.                     sps_size = size;

  510.                 } else if (nal_type == 8) { /* PPS */

  511.                     pps = buf + 4;

  512.                     pps_size = size;

  513.                 }

  514.                 buf += size + 4;

  515.             }

  516.             assert(sps);

  517.             assert(pps);

  518. 

  519.             put_byte(pb, 1); /* version */

  520.             put_byte(pb, sps[1]); /* profile */

  521.             put_byte(pb, sps[2]); /* profile compat */

  522.             put_byte(pb, sps[3]); /* level */

  523.             put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */

  524.             put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */

  525. 

  526.             put_be16(pb, sps_size);

  527.             put_buffer(pb, sps, sps_size);

  528.             put_byte(pb, 1); /* number of pps */

  529.             put_be16(pb, pps_size);

  530.             put_buffer(pb, pps, pps_size);

  531.         } else {

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

  533.         }

  534.     }

  535.     return updateSize(pb, pos);

  536. }

  537. 

  538. static const CodecTag codec_movvideo_tags[] = {

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

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

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

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

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

  544.     /* special handling in mov_find_video_codec_tag */

  545.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */

  546.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */

  547.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'p', 'p') }, /* DVCPRO PAL */

  548.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC */

  549.     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'p') }, /* DVCPRO50 PAL */

  550.     { CODEC_ID_NONE, 0 },

  551. };

  552. 

  553. static int mov_find_video_codec_tag(AVFormatContext *s, MOVTrack *track)

  554. {

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

  556.     if (!tag) {

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

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

  559.                 if (track->enc->pix_fmt == PIX_FMT_YUV422P)

  560.                     tag = MKTAG('d', 'v', '5', 'n');

  561.                 else

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

  563.             } else { /* assume PAL */

  564.                 if (track->enc->pix_fmt == PIX_FMT_YUV422P)

  565.                     tag = MKTAG('d', 'v', '5', 'p');

  566.                 else if (track->enc->pix_fmt == PIX_FMT_YUV420P)

  567.                     tag = MKTAG('d', 'v', 'c', 'p');

  568.                 else

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

  570.             }

  571.         } else {

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

  573.         }

  574.     }

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

  576.     if (!tag) {

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

  578.         if (tag) {

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

  580.         }

  581.     }

  582.     assert(tag);

  583.     return tag;

  584. }

  585. 

  586. static int mov_find_audio_codec_tag(AVFormatContext *s, MOVTrack *track)

  587. {

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

  589.     if (!tag) {

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

  591.     }

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

  593.     if (!tag) {

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

  595.         if (ms_tag) {

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

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

  598.         }

  599.     }

  600.     assert(tag);

  601.     return tag;

  602. }

  603. 

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

  605. {

  606.     offset_t pos = url_ftell(pb);

  607.     char compressor_name[32];

  608. 

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

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

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

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

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

  614. 

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

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

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

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

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

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

  621.     } else {

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

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

  624.     }

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

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

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

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

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

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

  631. 

  632.     memset(compressor_name,0,32);

  633.     if (track->enc->codec && track->enc->codec->name)

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

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

  636.     put_buffer(pb, compressor_name, 31);

  637. 

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

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

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

  641.         mov_write_esds_tag(pb, track);

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

  643.         mov_write_d263_tag(pb);

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

  645.         mov_write_svq3_tag(pb);

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

  647.         mov_write_avcc_tag(pb, track);

  648. 

  649.     return updateSize (pb, pos);

  650. }

  651. 

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

  653. {

  654.     offset_t pos = url_ftell(pb);

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

  656.     put_tag(pb, "stsd");

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

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

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

  660.         mov_write_video_tag(pb, track);

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

  662.         mov_write_audio_tag(pb, track);

  663.     return updateSize(pb, pos);

  664. }

  665. 

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

  667. {

  668.     Time2Sample *ctts_entries;

  669.     uint32_t entries = 0;

  670.     uint32_t atom_size;

  671.     int i;

  672. 

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

  674.     ctts_entries[0].count = 1;

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

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

  677.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  678.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  679.         if (track->cluster[cl][id].cts == ctts_entries[entries].duration) {

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

  681.         } else {

  682.             entries++;

  683.             ctts_entries[entries].duration = track->cluster[cl][id].cts;

  684.             ctts_entries[entries].count = 1;

  685.         }

  686.     }

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

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

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

  690.     put_tag(pb, "ctts");

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

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

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

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

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

  696.     }

  697.     av_free(ctts_entries);

  698.     return atom_size;

  699. }

  700. 

  701. /* TODO: */

  702. /* Time to sample atom */

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

  704. {

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

  706.     put_tag(pb, "stts");

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

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

  709. 

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

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

  712.     return 0x18;

  713. }

  714. 

  715. static int mov_write_dref_tag(ByteIOContext *pb)

  716. {

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

  718.     put_tag(pb, "dref");

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

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

  721. 

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

  723.     put_tag(pb, "url ");

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

  725. 

  726.     return 28;

  727. }

  728. 

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

  730. {

  731.     offset_t pos = url_ftell(pb);

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

  733.     put_tag(pb, "stbl");

  734.     mov_write_stsd_tag(pb, track);

  735.     mov_write_stts_tag(pb, track);

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

  737.         track->hasKeyframes < track->entry)

  738.         mov_write_stss_tag(pb, track);

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

  740.         track->hasBframes)

  741.         mov_write_ctts_tag(pb, track);

  742.     mov_write_stsc_tag(pb, track);

  743.     mov_write_stsz_tag(pb, track);

  744.     mov_write_stco_tag(pb, track);

  745.     return updateSize(pb, pos);

  746. }

  747. 

  748. static int mov_write_dinf_tag(ByteIOContext *pb)

  749. {

  750.     offset_t pos = url_ftell(pb);

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

  752.     put_tag(pb, "dinf");

  753.     mov_write_dref_tag(pb);

  754.     return updateSize(pb, pos);

  755. }

  756. 

  757. static int mov_write_smhd_tag(ByteIOContext *pb)

  758. {

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

  760.     put_tag(pb, "smhd");

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

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

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

  764.     return 16;

  765. }

  766. 

  767. static int mov_write_vmhd_tag(ByteIOContext *pb)

  768. {

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

  770.     put_tag(pb, "vmhd");

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

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

  773.     return 0x14;

  774. }

  775. 

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

  777. {

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

  779.     offset_t pos = url_ftell(pb);

  780. 

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

  782.         hdlr = "dhlr";

  783.         hdlr_type = "url ";

  784.         descr = "DataHandler";

  785.     } else {

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

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

  788.             hdlr_type = "vide";

  789.             descr = "VideoHandler";

  790.         } else {

  791.             hdlr_type = "soun";

  792.             descr = "SoundHandler";

  793.         }

  794.     }

  795. 

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

  797.     put_tag(pb, "hdlr");

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

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

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

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

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

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

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

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

  806.     return updateSize(pb, pos);

  807. }

  808. 

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

  810. {

  811.     offset_t pos = url_ftell(pb);

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

  813.     put_tag(pb, "minf");

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

  815.         mov_write_vmhd_tag(pb);

  816.     else

  817.         mov_write_smhd_tag(pb);

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

  819.         mov_write_hdlr_tag(pb, NULL);

  820.     mov_write_dinf_tag(pb);

  821.     mov_write_stbl_tag(pb, track);

  822.     return updateSize(pb, pos);

  823. }

  824. 

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

  826. {

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

  828. 

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

  830.     put_tag(pb, "mdhd");

  831.     put_byte(pb, version);

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

  833.     if (version == 1) {

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

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

  836.     } else {

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

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

  839.     }

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

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

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

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

  844.     return 32;

  845. }

  846. 

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

  848. {

  849.     offset_t pos = url_ftell(pb);

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

  851.     put_tag(pb, "mdia");

  852.     mov_write_mdhd_tag(pb, track);

  853.     mov_write_hdlr_tag(pb, track);

  854.     mov_write_minf_tag(pb, track);

  855.     return updateSize(pb, pos);

  856. }

  857. 

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

  859. {

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

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

  862. 

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

  864.     put_tag(pb, "tkhd");

  865.     put_byte(pb, version);

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

  867.     if (version == 1) {

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

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

  870.     } else {

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

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

  873.     }

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

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

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

  877. 

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

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

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

  881.     /* Volume, only for audio */

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

  883.         put_be16(pb, 0x0100);

  884.     else

  885.         put_be16(pb, 0);

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

  887. 

  888.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  898. 

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

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

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

  902.         if( !sample_aspect_ratio ) sample_aspect_ratio = 1;

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

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

  905.     }

  906.     else {

  907.         put_be32(pb, 0);

  908.         put_be32(pb, 0);

  909.     }

  910.     return 0x5c;

  911. }

  912. 

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

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

  915. {

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

  917.     put_tag(pb, "edts");

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

  919.     put_tag(pb, "elst");

  920.     put_be32(pb, 0x0);

  921.     put_be32(pb, 0x1);

  922. 

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

  924. 

  925.     if (track->hasBframes)

  926.         put_be32(pb, track->sampleDuration); /* first pts is 1 */

  927.     else

  928.         put_be32(pb, 0);

  929.     put_be32(pb, 0x00010000);

  930.     return 0x24;

  931. }

  932. 

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

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

  935. {

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

  937.     put_tag(pb, "uuid");

  938.     put_tag(pb, "USMT");

  939.     put_be32(pb, 0x21d24fce);

  940.     put_be32(pb, 0xbb88695c);

  941.     put_be32(pb, 0xfac9c740);

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

  943.     put_tag(pb, "MTDT");

  944.     put_be32(pb, 0x00010012);

  945.     put_be32(pb, 0x0a);

  946.     put_be32(pb, 0x55c40000);

  947.     put_be32(pb, 0x1);

  948.     put_be32(pb, 0x0);

  949.     return 0x34;

  950. }

  951. 

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

  953. {

  954.     offset_t pos = url_ftell(pb);

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

  956.     put_tag(pb, "trak");

  957.     mov_write_tkhd_tag(pb, track);

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

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

  960.     mov_write_mdia_tag(pb, track);

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

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

  963.     return updateSize(pb, pos);

  964. }

  965. 

  966. #if 0

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

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

  969. {

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

  971.     put_tag(pb, "iods");

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

  973.     put_be16(pb, 0x1007);

  974.     put_byte(pb, 0);

  975.     put_be16(pb, 0x4fff);

  976.     put_be16(pb, 0xfffe);

  977.     put_be16(pb, 0x01ff);

  978.     return 0x15;

  979. }

  980. #endif

  981. 

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

  983. {

  984.     int maxTrackID = 1, i;

  985.     int64_t maxTrackLenTemp, maxTrackLen = 0;

  986.     int version;

  987. 

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

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

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

  991.             if(maxTrackLen < maxTrackLenTemp)

  992.                 maxTrackLen = maxTrackLenTemp;

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

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

  995.         }

  996.     }

  997. 

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

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

  1000.     put_tag(pb, "mvhd");

  1001.     put_byte(pb, version);

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

  1003.     if (version == 1) {

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

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

  1006.     } else {

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

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

  1009.     }

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

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

  1012. 

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

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

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

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

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

  1018. 

  1019.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  1029. 

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

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

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

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

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

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

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

  1037.     return 0x6c;

  1038. }

  1039. 

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

  1041.                                      AVFormatContext *s)

  1042. {

  1043.     offset_t pos = url_ftell(pb);

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

  1045.     put_tag(pb, "hdlr");

  1046.     put_be32(pb, 0);

  1047.     put_be32(pb, 0);

  1048.     put_tag(pb, "mdir");

  1049.     put_tag(pb, "appl");

  1050.     put_be32(pb, 0);

  1051.     put_be32(pb, 0);

  1052.     put_be16(pb, 0);

  1053.     return updateSize(pb, pos);

  1054. }

  1055. 

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

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

  1058.                                      AVFormatContext *s, const char *data)

  1059. {

  1060.     offset_t pos = url_ftell(pb);

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

  1062.     put_tag(pb, "data");

  1063.     put_be32(pb, 1);

  1064.     put_be32(pb, 0);

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

  1066.     return updateSize(pb, pos);

  1067. }

  1068. 

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

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

  1071.                              AVFormatContext *s)

  1072. {

  1073.     int size = 0;

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

  1075.         offset_t pos = url_ftell(pb);

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

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

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

  1079.         size = updateSize(pb, pos);

  1080.     }

  1081.     return size;

  1082. }

  1083. 

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

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

  1086.                              AVFormatContext *s)

  1087. {

  1088.     int size = 0;

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

  1090.         offset_t pos = url_ftell(pb);

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

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

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

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

  1095.         size = updateSize(pb, pos);

  1096.     }

  1097.     return size;

  1098. }

  1099. 

  1100. /* iTunes name of the writer */

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

  1102.                              AVFormatContext *s)

  1103. {

  1104.     int size = 0;

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

  1106.         offset_t pos = url_ftell(pb);

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

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

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

  1110.         size = updateSize(pb, pos);

  1111.     }

  1112.     return size;

  1113. }

  1114. 

  1115. /* iTunes name of the album */

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

  1117.                              AVFormatContext *s)

  1118. {

  1119.     int size = 0;

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

  1121.         offset_t pos = url_ftell(pb);

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

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

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

  1125.         size = updateSize(pb, pos);

  1126.     }

  1127.     return size;

  1128. }

  1129. 

  1130. /* iTunes year */

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

  1132.                              AVFormatContext *s)

  1133. {

  1134.     char year[5];

  1135.     int size = 0;

  1136.     if ( s->year ) {

  1137.         offset_t pos = url_ftell(pb);

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

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

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

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

  1142.         size = updateSize(pb, pos);

  1143.     }

  1144.     return size;

  1145. }

  1146. 

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

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

  1149.                              AVFormatContext *s)

  1150. {

  1151.     offset_t pos = url_ftell(pb);

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

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

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

  1155.     return updateSize(pb, pos);

  1156. }

  1157. 

  1158. /* iTunes comment */

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

  1160.                              AVFormatContext *s)

  1161. {

  1162.     int size = 0;

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

  1164.         offset_t pos = url_ftell(pb);

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

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

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

  1168.         size = updateSize(pb, pos);

  1169.     }

  1170.     return size;

  1171. }

  1172. 

  1173. /* iTunes custom genre */

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

  1175.                              AVFormatContext *s)

  1176. {

  1177.     int size = 0;

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

  1179.         offset_t pos = url_ftell(pb);

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

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

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

  1183.         size = updateSize(pb, pos);

  1184.     }

  1185.     return size;

  1186. }

  1187. 

  1188. /* iTunes track number */

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

  1190.                               AVFormatContext *s)

  1191. {

  1192.     int size = 0;

  1193.     if ( s->track ) {

  1194.         offset_t pos = url_ftell(pb);

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

  1196.         put_tag(pb, "trkn");

  1197.         {

  1198.             offset_t pos = url_ftell(pb);

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

  1200.             put_tag(pb, "data");

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

  1202.             put_be32(pb, 0);

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

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

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

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

  1207.             updateSize(pb, pos);

  1208.         }

  1209.         size = updateSize(pb, pos);

  1210.     }

  1211.     return size;

  1212. }

  1213. 

  1214. /* iTunes meta data list */

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

  1216.                               AVFormatContext *s)

  1217. {

  1218.     offset_t pos = url_ftell(pb);

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

  1220.     put_tag(pb, "ilst");

  1221.     mov_write_nam_tag(pb, mov, s);

  1222.     mov_write_ART_tag(pb, mov, s);

  1223.     mov_write_wrt_tag(pb, mov, s);

  1224.     mov_write_alb_tag(pb, mov, s);

  1225.     mov_write_day_tag(pb, mov, s);

  1226.     mov_write_too_tag(pb, mov, s);

  1227.     mov_write_cmt_tag(pb, mov, s);

  1228.     mov_write_gen_tag(pb, mov, s);

  1229.     mov_write_trkn_tag(pb, mov, s);

  1230.     return updateSize(pb, pos);

  1231. }

  1232. 

  1233. /* iTunes meta data tag */

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

  1235.                               AVFormatContext *s)

  1236. {

  1237.     int size = 0;

  1238. 

  1239.     // only save meta tag if required

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

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

  1242.         offset_t pos = url_ftell(pb);

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

  1244.         put_tag(pb, "meta");

  1245.         put_be32(pb, 0);

  1246.         mov_write_itunes_hdlr_tag(pb, mov, s);

  1247.         mov_write_ilst_tag(pb, mov, s);

  1248.         size = updateSize(pb, pos);

  1249.     }

  1250.     return size;

  1251. }

  1252. 

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

  1254.                               AVFormatContext *s)

  1255. {

  1256.     offset_t pos = url_ftell(pb);

  1257.     int i;

  1258. 

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

  1260.     put_tag(pb, "udta");

  1261. 

  1262.     /* iTunes meta data */

  1263.     mov_write_meta_tag(pb, mov, s);

  1264. 

  1265.     /* Requirements */

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

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

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

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

  1270.             offset_t pos = url_ftell(pb);

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

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

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

  1274.             put_be16(pb, 0);

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

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

  1277.             updateSize(pb, pos);

  1278.             break;

  1279.         }

  1280.     }

  1281. 

  1282.     /* Encoder */

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

  1284.     {

  1285.         offset_t pos = url_ftell(pb);

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

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

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

  1289.         put_be16(pb, 0);

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

  1291.         updateSize(pb, pos);

  1292.     }

  1293. 

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

  1295.     {

  1296.         offset_t pos = url_ftell(pb);

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

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

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

  1300.         put_be16(pb, 0);

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

  1302.         updateSize(pb, pos);

  1303.     }

  1304. 

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

  1306.     {

  1307.         offset_t pos = url_ftell(pb);

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

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

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

  1311.         put_be16(pb, 0);

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

  1313.         updateSize(pb, pos);

  1314.     }

  1315. 

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

  1317.     {

  1318.         offset_t pos = url_ftell(pb);

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

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

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

  1322.         put_be16(pb, 0);

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

  1324.         updateSize(pb, pos);

  1325.     }

  1326. 

  1327.     return updateSize(pb, pos);

  1328. }

  1329. 

  1330. 

  1331. static size_t ascii_to_wc (ByteIOContext *pb, char *b, size_t n)

  1332. {

  1333.     size_t i;

  1334.     unsigned char c;

  1335.     for (i = 0; i < n - 1; i++) {

  1336.         c = b[i];

  1337.         if (! (0x20 <= c && c <= 0x7f ))

  1338.             c = 0x3f;  /* '?' */

  1339.         put_be16(pb, c);

  1340.     }

  1341.     put_be16(pb, 0x00);

  1342.     return 2*n;

  1343. }

  1344. 

  1345. static uint16_t language_code (char *str)

  1346. {

  1347.     return ((((str[0]-'a') & 0x1F)<<10) + (((str[1]-'a') & 0x1F)<<5) + ((str[2]-'a') & 0x1F));

  1348. }

  1349. 

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

  1351. {

  1352.     size_t len, size;

  1353.     offset_t pos, curpos;

  1354. 

  1355.     size = 0;

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

  1357.         pos = url_ftell(pb);

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

  1359.         put_tag(pb, "uuid");

  1360.         put_tag(pb, "USMT");

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

  1362.         put_be32(pb, 0xbb88695c );

  1363.         put_be32(pb, 0xfac9c740 );

  1364.         size += 24;

  1365. 

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

  1367.         put_tag(pb, "MTDT");

  1368.         put_be16(pb, 1);

  1369.         size += 10;

  1370. 

  1371.         // Title

  1372.         len = strlen(s->title)+1;

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

  1374.         put_be32(pb, 0x01);                 /* type */

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

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

  1377.         ascii_to_wc (pb, s->title, len);

  1378.         size += len*2+10;

  1379. 

  1380.         // size

  1381.         curpos = url_ftell(pb);

  1382.         url_fseek(pb, pos, SEEK_SET);

  1383.         put_be32(pb, size);

  1384.         url_fseek(pb, pos+24, SEEK_SET);

  1385.         put_be32(pb, size-24);

  1386.         url_fseek(pb, curpos, SEEK_SET);

  1387.     }

  1388. 

  1389.     return size;

  1390. }

  1391. 

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

  1393.                               AVFormatContext *s)

  1394. {

  1395.     int i;

  1396.     offset_t pos = url_ftell(pb);

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

  1398.     put_tag(pb, "moov");

  1399.     mov->timescale = globalTimescale;

  1400. 

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

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

  1403. 

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

  1405.             mov->tracks[i].timescale = mov->tracks[i].enc->time_base.den;

  1406.             mov->tracks[i].sampleDuration = mov->tracks[i].enc->time_base.num;

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

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

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

  1410.         }

  1411. 

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

  1413.             (int64_t)mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;

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

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

  1416.     }

  1417. 

  1418.     mov_write_mvhd_tag(pb, mov);

  1419.     //mov_write_iods_tag(pb, mov);

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

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

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

  1423.         }

  1424.     }

  1425. 

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

  1427.         mov_write_uuidusmt_tag(pb, s);

  1428.     else

  1429.     mov_write_udta_tag(pb, mov, s);

  1430. 

  1431.     return updateSize(pb, pos);

  1432. }

  1433. 

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

  1435. {

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

  1437.     put_tag(pb, "wide");

  1438. 

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

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

  1441.     put_tag(pb, "mdat");

  1442.     return 0;

  1443. }

  1444. 

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

  1446. static void mov_write_ftyp_tag (ByteIOContext *pb, AVFormatContext *s)

  1447. {

  1448.     MOVContext *mov = s->priv_data;

  1449. 

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

  1451.     put_tag(pb, "ftyp");

  1452. 

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

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

  1455.     else if ( mov->mode == MODE_3G2 )

  1456.         put_tag(pb, "3g2a");

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

  1458.         put_tag(pb, "MSNV");

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

  1460.         put_tag(pb, "isom");

  1461.     else

  1462.         put_tag(pb, "qt  ");

  1463. 

  1464.     put_be32(pb, 0x200 );

  1465. 

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

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

  1468.     else if ( mov->mode == MODE_3G2 )

  1469.         put_tag(pb, "3g2a");

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

  1471.         put_tag(pb, "MSNV");

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

  1473.         put_tag(pb, "mp41");

  1474.     else

  1475.         put_tag(pb, "qt  ");

  1476. }

  1477. 

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

  1479. {

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

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

  1482.     int AudioRate = AudioCodec->sample_rate;

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

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

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

  1486. 

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

  1488.     put_tag(pb, "uuid");

  1489.     put_tag(pb, "PROF");

  1490. 

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

  1492.     put_be32(pb, 0xbb88695c );

  1493.     put_be32(pb, 0xfac9c740 );

  1494. 

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

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

  1497. 

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

  1499.     put_tag(pb, "FPRF");

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

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

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

  1503. 

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

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

  1506.     put_be32(pb, 0x0 );

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

  1508.     put_tag(pb, "mp4a");

  1509.     put_be32(pb, 0x20f );

  1510.     put_be32(pb, 0x0 );

  1511.     put_be32(pb, audio_kbitrate);

  1512.     put_be32(pb, audio_kbitrate);

  1513.     put_be32(pb, AudioRate );

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

  1515. 

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

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

  1518.     put_be32(pb, 0x0 );

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

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

  1521.         put_tag(pb, "avc1");

  1522.         put_be16(pb, 0x014D );

  1523.         put_be16(pb, 0x0015 );

  1524.     } else {

  1525.         put_tag(pb, "mp4v");

  1526.         put_be16(pb, 0x0000 );

  1527.         put_be16(pb, 0x0103 );

  1528.     }

  1529.     put_be32(pb, 0x0 );

  1530.     put_be32(pb, video_kbitrate);

  1531.     put_be32(pb, video_kbitrate);

  1532.     put_be32(pb, FrameRate);

  1533.     put_be32(pb, FrameRate);

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

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

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

  1537. }

  1538. 

  1539. static int mov_write_header(AVFormatContext *s)

  1540. {

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

  1542.     MOVContext *mov = s->priv_data;

  1543.     int i;

  1544. 

  1545.     /* Default mode == MP4 */

  1546.     mov->mode = MODE_MP4;

  1547. 

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

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

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

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

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

  1553. 

  1554.         mov_write_ftyp_tag(pb,s);

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

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

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

  1558.                 return -1;

  1559.             }

  1560.             mov_write_uuidprof_tag(pb,s);

  1561.         }

  1562.     }

  1563. 

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

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

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

  1567. 

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

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

  1570.             track->tag = mov_find_video_codec_tag(s, track);

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

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

  1573.             track->tag = mov_find_audio_codec_tag(s, track);

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

  1575.         }

  1576.         track->language = ff_mov_iso639_to_lang(st->language, mov->mode != MODE_MOV);

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

  1578.     }

  1579. 

  1580.     mov_write_mdat_tag(pb, mov);

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

  1582. 

  1583.     put_flush_packet(pb);

  1584. 

  1585.     return 0;

  1586. }

  1587. 

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

  1589. {

  1590.     MOVContext *mov = s->priv_data;

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

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

  1593.     AVCodecContext *enc = trk->enc;

  1594.     int cl, id;

  1595.     unsigned int samplesInChunk = 0;

  1596.     int size= pkt->size;

  1597. 

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

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

  1600. 

  1601.     if (enc->codec_type == CODEC_TYPE_AUDIO) {

  1602.         switch (enc->codec_id) {

  1603.         case CODEC_ID_AMR_NB:

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

  1605.                 static uint16_t packed_size[16] =

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

  1607.                 int len = 0;

  1608. 

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

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

  1611.                     samplesInChunk++;

  1612.                 }

  1613.             }

  1614.             break;

  1615.         case CODEC_ID_PCM_ALAW:

  1616.             samplesInChunk = size/enc->channels;

  1617.             break;

  1618.         case CODEC_ID_PCM_S16BE:

  1619.         case CODEC_ID_PCM_S16LE:

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

  1621.             break;

  1622.         case CODEC_ID_PCM_S24BE:

  1623.         case CODEC_ID_PCM_S24LE:

  1624.             samplesInChunk = size/(3*enc->channels);

  1625.             break;

  1626.         case CODEC_ID_PCM_S32BE:

  1627.         case CODEC_ID_PCM_S32LE:

  1628.             samplesInChunk = size/(4*enc->channels);

  1629.             break;

  1630.         default:

  1631.             samplesInChunk = 1;

  1632.         }

  1633.     } else {

  1634.         samplesInChunk = 1;

  1635.     }

  1636. 

  1637.     /* copy extradata if it exists */

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

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

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

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

  1642.     }

  1643. 

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

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

  1646.         /* nal reformating needed */

  1647.         avc_parse_nal_units(&pkt->data, &pkt->size);

  1648.         assert(pkt->size);

  1649.         size = pkt->size;

  1650.     }

  1651. 

  1652.     cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;

  1653.     id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

  1654. 

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

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

  1657.         if (!trk->cluster)

  1658.             return -1;

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

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

  1661.             return -1;

  1662.         trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;

  1663.     }

  1664. 

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

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

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

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

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

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

  1671.             trk->hasBframes = 1;

  1672.         trk->cluster[cl][id].cts = pkt->pts - pkt->dts;

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

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

  1675.             trk->hasKeyframes++;

  1676.     }

  1677.     trk->entry++;

  1678.     trk->sampleCount += samplesInChunk;

  1679.     mov->mdat_size += size;

  1680. 

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

  1682. 

  1683.     put_flush_packet(pb);

  1684.     return 0;

  1685. }

  1686. 

  1687. static int mov_write_trailer(AVFormatContext *s)

  1688. {

  1689.     MOVContext *mov = s->priv_data;

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

  1691.     int res = 0;

  1692.     int i, j;

  1693. 

  1694.     offset_t moov_pos = url_ftell(pb);

  1695. 

  1696.     /* Write size of mdat tag */

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

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

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

  1700.     } else {

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

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

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

  1704.         put_tag(pb, "mdat");

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

  1706.     }

  1707.     url_fseek(pb, moov_pos, SEEK_SET);

  1708. 

  1709.     mov_write_moov_tag(pb, mov, s);

  1710. 

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

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

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

  1714.         }

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

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

  1717. 

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

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

  1720.     }

  1721. 

  1722.     put_flush_packet(pb);

  1723. 

  1724.     return res;

  1725. }

  1726. 

  1727. static AVOutputFormat mov_oformat = {

  1728.     "mov",

  1729.     "mov format",

  1730.     NULL,

  1731.     "mov",

  1732.     sizeof(MOVContext),

  1733.     CODEC_ID_AAC,

  1734.     CODEC_ID_MPEG4,

  1735.     mov_write_header,

  1736.     mov_write_packet,

  1737.     mov_write_trailer,

  1738.     .flags = AVFMT_GLOBALHEADER,

  1739. };

  1740. 

  1741. static AVOutputFormat _3gp_oformat = {

  1742.     "3gp",

  1743.     "3gp format",

  1744.     NULL,

  1745.     "3gp",

  1746.     sizeof(MOVContext),

  1747.     CODEC_ID_AMR_NB,

  1748.     CODEC_ID_H263,

  1749.     mov_write_header,

  1750.     mov_write_packet,

  1751.     mov_write_trailer,

  1752.     .flags = AVFMT_GLOBALHEADER,

  1753. };

  1754. 

  1755. static AVOutputFormat mp4_oformat = {

  1756.     "mp4",

  1757.     "mp4 format",

  1758.     "application/mp4",

  1759.     "mp4,m4a",

  1760.     sizeof(MOVContext),

  1761.     CODEC_ID_AAC,

  1762.     CODEC_ID_MPEG4,

  1763.     mov_write_header,

  1764.     mov_write_packet,

  1765.     mov_write_trailer,

  1766.     .flags = AVFMT_GLOBALHEADER,

  1767. };

  1768. 

  1769. static AVOutputFormat psp_oformat = {

  1770.     "psp",

  1771.     "psp mp4 format",

  1772.     NULL,

  1773.     "mp4,psp",

  1774.     sizeof(MOVContext),

  1775.     CODEC_ID_AAC,

  1776.     CODEC_ID_MPEG4,

  1777.     mov_write_header,

  1778.     mov_write_packet,

  1779.     mov_write_trailer,

  1780.     .flags = AVFMT_GLOBALHEADER,

  1781. };

  1782. 

  1783. static AVOutputFormat _3g2_oformat = {

  1784.     "3g2",

  1785.     "3gp2 format",

  1786.     NULL,

  1787.     "3g2",

  1788.     sizeof(MOVContext),

  1789.     CODEC_ID_AMR_NB,

  1790.     CODEC_ID_H263,

  1791.     mov_write_header,

  1792.     mov_write_packet,

  1793.     mov_write_trailer,

  1794.     .flags = AVFMT_GLOBALHEADER,

  1795. };

  1796. 

  1797. int movenc_init(void)

  1798. {

  1799.     av_register_output_format(&mov_oformat);

  1800.     av_register_output_format(&_3gp_oformat);

  1801.     av_register_output_format(&mp4_oformat);

  1802.     av_register_output_format(&psp_oformat);

  1803.     av_register_output_format(&_3g2_oformat);

  1804.     return 0;

  1805. }