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

1725 lines
53KB
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_samr_tag(ByteIOContext *pb)

  228. {

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

  230.     put_tag(pb, "samr");

  231.     put_tag(pb, "FFMP");

  232.     put_byte(pb, 1);

  233. 

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

  235.     put_be16(pb, 0x5); /* Mode change period (no restriction) */

  236.     return 0x11;

  237. }

  238. 

  239. static int mov_write_enda_tag(ByteIOContext *pb)

  240. {

  241.     put_be32(pb, 10);

  242.     put_tag(pb, "enda");

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

  244.     return 10;

  245. }

  246. 

  247. static unsigned int descrLength(unsigned int len)

  248. {

  249.     int i;

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

  251.     return len + 1 + i;

  252. }

  253. 

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

  255. {

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

  257.     put_byte(pb, tag);

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

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

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

  261. }

  262. 

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

  264. {

  265.     offset_t pos = url_ftell(pb);

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

  267. 

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

  269.     put_tag(pb, "esds");

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

  271. 

  272.     // ES descriptor

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

  274.              descrLength(1));

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

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

  277. 

  278.     // DecoderConfig descriptor

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

  280. 

  281.     // Object type indication

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

  283. 

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

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

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

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

  288.     else

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

  290. 

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

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

  293. 

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

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

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

  297.     else

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

  299. 

  300.     if (track->vosLen)

  301.     {

  302.         // DecoderSpecific info descriptor

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

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

  305.     }

  306. 

  307. 

  308.     // SL descriptor

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

  310.     put_byte(pb, 0x02);

  311.     return updateSize (pb, pos);

  312. }

  313. 

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

  315. {

  316.     offset_t pos = url_ftell(pb);

  317. 

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

  319.     put_tag(pb, "wave");

  320. 

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

  322.     put_tag(pb, "frma");

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

  324. 

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

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

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

  328.         put_tag(pb, "mp4a");

  329.         put_be32(pb, 0);

  330.         mov_write_esds_tag(pb, track);

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

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

  333.         mov_write_enda_tag(pb);

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

  335.         mov_write_samr_tag(pb);

  336.     }

  337. 

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

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

  340. 

  341.     return updateSize (pb, pos);

  342. }

  343. 

  344. static const CodecTag codec_movaudio_tags[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  360.     { CODEC_ID_NONE, 0 },

  361. };

  362. 

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

  364. {

  365.     offset_t pos = url_ftell(pb);

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

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

  368.          track->enc->codec_id == CODEC_ID_MP3 ||

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

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

  371. 

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

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

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

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

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

  377. 

  378.     /* SoundDescription */

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

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

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

  382. 

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

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

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

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

  387. 

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

  389.        track->enc->codec_id == CODEC_ID_MP3 ||

  390.        track->enc->codec_id == CODEC_ID_AMR_NB) {

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

  392.     } else {

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

  394.     }

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

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

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

  398. 

  399.     if(version == 1) {

  400.         /* SoundDescription V1 extended info */

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

  402.         /* Parameters tested on quicktime 6.5, 7 */

  403.         put_be32(pb, 1); /* Bytes per packet */

  404.         /* FIXME not correct */

  405.         /* 8 is the min value needed for in32 to work with quicktime 6.5 */

  406.         /* Value ignored by other codecs currently supported (others might need it) */

  407.         put_be32(pb, 8); /* Bytes per frame */

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

  409.     }

  410. 

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

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

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

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

  415.         track->enc->codec_id == CODEC_ID_PCM_S32LE))

  416.         mov_write_wave_tag(pb, track);

  417.     else if(track->enc->codec_id == CODEC_ID_AAC)

  418.         mov_write_esds_tag(pb, track);

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

  420.         mov_write_damr_tag(pb);

  421. 

  422.     return updateSize (pb, pos);

  423. }

  424. 

  425. static int mov_write_d263_tag(ByteIOContext *pb)

  426. {

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

  428.     put_tag(pb, "d263");

  429.     put_tag(pb, "FFMP");

  430.     put_be16(pb, 0x0a);

  431.     put_byte(pb, 0);

  432.     return 0xf;

  433. }

  434. 

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

  436. static int mov_write_svq3_tag(ByteIOContext *pb)

  437. {

  438.     put_be32(pb, 0x15);

  439.     put_tag(pb, "SMI ");

  440.     put_tag(pb, "SEQH");

  441.     put_be32(pb, 0x5);

  442.     put_be32(pb, 0xe2c0211d);

  443.     put_be32(pb, 0xc0000000);

  444.     put_byte(pb, 0);

  445.     return 0x15;

  446. }

  447. 

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

  449. {

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

  451. 

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

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

  454.             return p;

  455.     }

  456. 

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

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

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

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

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

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

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

  464.                     return p-1;

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

  466.                     return p;

  467.             }

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

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

  470.                     return p+1;

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

  472.                     return p+2;

  473.             }

  474.         }

  475.     }

  476. 

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

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

  479.             return p;

  480.     }

  481. 

  482.     return end + 3;

  483. }

  484. 

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

  486. {

  487.     ByteIOContext pb;

  488.     uint8_t *p = *buf;

  489.     uint8_t *end = p + *size;

  490.     uint8_t *nal_start, *nal_end;

  491. 

  492.     url_open_dyn_buf(&pb);

  493.     nal_start = avc_find_startcode(p, end);

  494.     while (nal_start < end) {

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

  496.         nal_end = avc_find_startcode(nal_start, end);

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

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

  499.         nal_start = nal_end;

  500.     }

  501.     av_freep(buf);

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

  503. }

  504. 

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

  506. {

  507.     offset_t pos = url_ftell(pb);

  508. 

  509.     put_be32(pb, 0);

  510.     put_tag(pb, "avcC");

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

  512.         /* check for h264 start code */

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

  514.             uint8_t *buf, *end;

  515.             uint32_t sps_size=0, pps_size=0;

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

  517. 

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

  519.             buf = track->vosData;

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

  521. 

  522.             /* look for sps and pps */

  523.             while (buf < end) {

  524.                 unsigned int size;

  525.                 uint8_t nal_type;

  526.                 size = BE_32(buf);

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

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

  529.                     sps = buf + 4;

  530.                     sps_size = size;

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

  532.                     pps = buf + 4;

  533.                     pps_size = size;

  534.                 }

  535.                 buf += size + 4;

  536.             }

  537.             assert(sps);

  538.             assert(pps);

  539. 

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

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

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

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

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

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

  546. 

  547.             put_be16(pb, sps_size);

  548.             put_buffer(pb, sps, sps_size);

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

  550.             put_be16(pb, pps_size);

  551.             put_buffer(pb, pps, pps_size);

  552.         } else {

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

  554.         }

  555.     }

  556.     return updateSize(pb, pos);

  557. }

  558. 

  559. static const CodecTag codec_movvideo_tags[] = {

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

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

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

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

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

  565.     /* special handling in mov_find_video_codec_tag */

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

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

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

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

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

  571.     { CODEC_ID_NONE, 0 },

  572. };

  573. 

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

  575. {

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

  577.     if (!tag) {

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

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

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

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

  582.                 else

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

  584.             } else { /* assume PAL */

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

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

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

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

  589.                 else

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

  591.             }

  592.         } else {

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

  594.         }

  595.     }

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

  597.     if (!tag) {

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

  599.         if (tag) {

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

  601.         }

  602.     }

  603.     assert(tag);

  604.     return tag;

  605. }

  606. 

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

  608. {

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

  610.     if (!tag) {

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

  612.     }

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

  614.     if (!tag) {

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

  616.         if (ms_tag) {

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

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

  619.         }

  620.     }

  621.     assert(tag);

  622.     return tag;

  623. }

  624. 

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

  626. {

  627.     offset_t pos = url_ftell(pb);

  628.     char compressor_name[32];

  629. 

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

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

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

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

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

  635. 

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

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

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

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

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

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

  642.     } else {

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

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

  645.     }

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

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

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

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

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

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

  652. 

  653.     memset(compressor_name,0,32);

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

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

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

  657.     put_buffer(pb, compressor_name, 31);

  658. 

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

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

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

  662.         mov_write_esds_tag(pb, track);

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

  664.         mov_write_d263_tag(pb);

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

  666.         mov_write_svq3_tag(pb);

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

  668.         mov_write_avcc_tag(pb, track);

  669. 

  670.     return updateSize (pb, pos);

  671. }

  672. 

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

  674. {

  675.     offset_t pos = url_ftell(pb);

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

  677.     put_tag(pb, "stsd");

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

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

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

  681.         mov_write_video_tag(pb, track);

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

  683.         mov_write_audio_tag(pb, track);

  684.     return updateSize(pb, pos);

  685. }

  686. 

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

  688. {

  689.     Time2Sample *ctts_entries;

  690.     uint32_t entries = 0;

  691.     uint32_t atom_size;

  692.     int i;

  693. 

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

  695.     ctts_entries[0].count = 1;

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

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

  698.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  699.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

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

  702.         } else {

  703.             entries++;

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

  705.             ctts_entries[entries].count = 1;

  706.         }

  707.     }

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

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

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

  711.     put_tag(pb, "ctts");

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

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

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

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

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

  717.     }

  718.     av_free(ctts_entries);

  719.     return atom_size;

  720. }

  721. 

  722. /* TODO: */

  723. /* Time to sample atom */

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

  725. {

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

  727.     put_tag(pb, "stts");

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

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

  730. 

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

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

  733.     return 0x18;

  734. }

  735. 

  736. static int mov_write_dref_tag(ByteIOContext *pb)

  737. {

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

  739.     put_tag(pb, "dref");

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

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

  742. 

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

  744.     put_tag(pb, "url ");

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

  746. 

  747.     return 28;

  748. }

  749. 

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

  751. {

  752.     offset_t pos = url_ftell(pb);

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

  754.     put_tag(pb, "stbl");

  755.     mov_write_stsd_tag(pb, track);

  756.     mov_write_stts_tag(pb, track);

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

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

  759.         mov_write_stss_tag(pb, track);

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

  761.         track->hasBframes)

  762.         mov_write_ctts_tag(pb, track);

  763.     mov_write_stsc_tag(pb, track);

  764.     mov_write_stsz_tag(pb, track);

  765.     mov_write_stco_tag(pb, track);

  766.     return updateSize(pb, pos);

  767. }

  768. 

  769. static int mov_write_dinf_tag(ByteIOContext *pb)

  770. {

  771.     offset_t pos = url_ftell(pb);

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

  773.     put_tag(pb, "dinf");

  774.     mov_write_dref_tag(pb);

  775.     return updateSize(pb, pos);

  776. }

  777. 

  778. static int mov_write_smhd_tag(ByteIOContext *pb)

  779. {

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

  781.     put_tag(pb, "smhd");

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

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

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

  785.     return 16;

  786. }

  787. 

  788. static int mov_write_vmhd_tag(ByteIOContext *pb)

  789. {

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

  791.     put_tag(pb, "vmhd");

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

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

  794.     return 0x14;

  795. }

  796. 

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

  798. {

  799.     const char *descr, *hdlr, *hdlr_type;

  800.     offset_t pos = url_ftell(pb);

  801. 

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

  803.         hdlr = "dhlr";

  804.         hdlr_type = "url ";

  805.         descr = "DataHandler";

  806.     } else {

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

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

  809.             hdlr_type = "vide";

  810.             descr = "VideoHandler";

  811.         } else {

  812.             hdlr_type = "soun";

  813.             descr = "SoundHandler";

  814.         }

  815.     }

  816. 

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

  818.     put_tag(pb, "hdlr");

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

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

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

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

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

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

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

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

  827.     return updateSize(pb, pos);

  828. }

  829. 

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

  831. {

  832.     offset_t pos = url_ftell(pb);

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

  834.     put_tag(pb, "minf");

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

  836.         mov_write_vmhd_tag(pb);

  837.     else

  838.         mov_write_smhd_tag(pb);

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

  840.         mov_write_hdlr_tag(pb, NULL);

  841.     mov_write_dinf_tag(pb);

  842.     mov_write_stbl_tag(pb, track);

  843.     return updateSize(pb, pos);

  844. }

  845. 

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

  847. {

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

  849. 

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

  851.     put_tag(pb, "mdhd");

  852.     put_byte(pb, version);

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

  854.     if (version == 1) {

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

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

  857.     } else {

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

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

  860.     }

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

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

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

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

  865.     return 32;

  866. }

  867. 

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

  869. {

  870.     offset_t pos = url_ftell(pb);

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

  872.     put_tag(pb, "mdia");

  873.     mov_write_mdhd_tag(pb, track);

  874.     mov_write_hdlr_tag(pb, track);

  875.     mov_write_minf_tag(pb, track);

  876.     return updateSize(pb, pos);

  877. }

  878. 

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

  880. {

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

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

  883. 

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

  885.     put_tag(pb, "tkhd");

  886.     put_byte(pb, version);

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

  888.     if (version == 1) {

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

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

  891.     } else {

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

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

  894.     }

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

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

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

  898. 

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

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

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

  902.     /* Volume, only for audio */

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

  904.         put_be16(pb, 0x0100);

  905.     else

  906.         put_be16(pb, 0);

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

  908. 

  909.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  919. 

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

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

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

  923.         if( !sample_aspect_ratio ) sample_aspect_ratio = 1;

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

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

  926.     }

  927.     else {

  928.         put_be32(pb, 0);

  929.         put_be32(pb, 0);

  930.     }

  931.     return 0x5c;

  932. }

  933. 

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

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

  936. {

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

  938.     put_tag(pb, "edts");

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

  940.     put_tag(pb, "elst");

  941.     put_be32(pb, 0x0);

  942.     put_be32(pb, 0x1);

  943. 

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

  945. 

  946.     if (track->hasBframes)

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

  948.     else

  949.         put_be32(pb, 0);

  950.     put_be32(pb, 0x00010000);

  951.     return 0x24;

  952. }

  953. 

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

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

  956. {

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

  958.     put_tag(pb, "uuid");

  959.     put_tag(pb, "USMT");

  960.     put_be32(pb, 0x21d24fce);

  961.     put_be32(pb, 0xbb88695c);

  962.     put_be32(pb, 0xfac9c740);

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

  964.     put_tag(pb, "MTDT");

  965.     put_be32(pb, 0x00010012);

  966.     put_be32(pb, 0x0a);

  967.     put_be32(pb, 0x55c40000);

  968.     put_be32(pb, 0x1);

  969.     put_be32(pb, 0x0);

  970.     return 0x34;

  971. }

  972. 

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

  974. {

  975.     offset_t pos = url_ftell(pb);

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

  977.     put_tag(pb, "trak");

  978.     mov_write_tkhd_tag(pb, track);

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

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

  981.     mov_write_mdia_tag(pb, track);

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

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

  984.     return updateSize(pb, pos);

  985. }

  986. 

  987. #if 0

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

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

  990. {

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

  992.     put_tag(pb, "iods");

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

  994.     put_be16(pb, 0x1007);

  995.     put_byte(pb, 0);

  996.     put_be16(pb, 0x4fff);

  997.     put_be16(pb, 0xfffe);

  998.     put_be16(pb, 0x01ff);

  999.     return 0x15;

  1000. }

  1001. #endif

  1002. 

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

  1004. {

  1005.     int maxTrackID = 1, i;

  1006.     int64_t maxTrackLenTemp, maxTrackLen = 0;

  1007.     int version;

  1008. 

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

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

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

  1012.             if(maxTrackLen < maxTrackLenTemp)

  1013.                 maxTrackLen = maxTrackLenTemp;

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

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

  1016.         }

  1017.     }

  1018. 

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

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

  1021.     put_tag(pb, "mvhd");

  1022.     put_byte(pb, version);

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

  1024.     if (version == 1) {

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

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

  1027.     } else {

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

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

  1030.     }

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

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

  1033. 

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

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

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

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

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

  1039. 

  1040.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  1050. 

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

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

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

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

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

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

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

  1058.     return 0x6c;

  1059. }

  1060. 

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

  1062.                                      AVFormatContext *s)

  1063. {

  1064.     offset_t pos = url_ftell(pb);

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

  1066.     put_tag(pb, "hdlr");

  1067.     put_be32(pb, 0);

  1068.     put_be32(pb, 0);

  1069.     put_tag(pb, "mdir");

  1070.     put_tag(pb, "appl");

  1071.     put_be32(pb, 0);

  1072.     put_be32(pb, 0);

  1073.     put_be16(pb, 0);

  1074.     return updateSize(pb, pos);

  1075. }

  1076. 

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

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

  1079. {

  1080.     if(long_style){

  1081.         offset_t pos = url_ftell(pb);

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

  1083.         put_tag(pb, "data");

  1084.         put_be32(pb, 1);

  1085.         put_be32(pb, 0);

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

  1087.         return updateSize(pb, pos);

  1088.     }else{

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

  1090.         put_be16(pb, 0);

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

  1092.         return strlen(data) + 4;

  1093.     }

  1094. }

  1095. 

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

  1097.     int size = 0;

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

  1099.         offset_t pos = url_ftell(pb);

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

  1101.         put_tag(pb, name);

  1102.         mov_write_string_data_tag(pb, value, long_style);

  1103.         size= updateSize(pb, pos);

  1104.     }

  1105.     return size;

  1106. }

  1107. 

  1108. /* iTunes year */

  1109. static int mov_write_day_tag(ByteIOContext *pb, int year, int long_style)

  1110. {

  1111.     if(year){

  1112.         char year_str[5];

  1113.         snprintf(year_str, sizeof(year_str), "%04d", year);

  1114.         return mov_write_string_tag(pb, "\251day", year_str, long_style);

  1115.     }else

  1116.         return 0;

  1117. }

  1118. 

  1119. /* iTunes track number */

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

  1121.                               AVFormatContext *s)

  1122. {

  1123.     int size = 0;

  1124.     if ( s->track ) {

  1125.         offset_t pos = url_ftell(pb);

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

  1127.         put_tag(pb, "trkn");

  1128.         {

  1129.             offset_t pos = url_ftell(pb);

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

  1131.             put_tag(pb, "data");

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

  1133.             put_be32(pb, 0);

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

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

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

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

  1138.             updateSize(pb, pos);

  1139.         }

  1140.         size = updateSize(pb, pos);

  1141.     }

  1142.     return size;

  1143. }

  1144. 

  1145. /* iTunes meta data list */

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

  1147.                               AVFormatContext *s)

  1148. {

  1149.     offset_t pos = url_ftell(pb);

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

  1151.     put_tag(pb, "ilst");

  1152.     mov_write_string_tag(pb, "\251nam", s->title         , 1);

  1153.     mov_write_string_tag(pb, "\251ART", s->author        , 1);

  1154.     mov_write_string_tag(pb, "\251wrt", s->author        , 1);

  1155.     mov_write_string_tag(pb, "\251alb", s->album         , 1);

  1156.     mov_write_day_tag(pb, s->year ,1);

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

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

  1159.     mov_write_string_tag(pb, "\251cmt", s->comment       , 1);

  1160.     mov_write_string_tag(pb, "\251gen", s->genre         , 1);

  1161.     mov_write_trkn_tag(pb, mov, s);

  1162.     return updateSize(pb, pos);

  1163. }

  1164. 

  1165. /* iTunes meta data tag */

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

  1167.                               AVFormatContext *s)

  1168. {

  1169.     int size = 0;

  1170. 

  1171.     // only save meta tag if required

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

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

  1174.         offset_t pos = url_ftell(pb);

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

  1176.         put_tag(pb, "meta");

  1177.         put_be32(pb, 0);

  1178.         mov_write_itunes_hdlr_tag(pb, mov, s);

  1179.         mov_write_ilst_tag(pb, mov, s);

  1180.         size = updateSize(pb, pos);

  1181.     }

  1182.     return size;

  1183. }

  1184. 

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

  1186.                               AVFormatContext *s)

  1187. {

  1188.     offset_t pos = url_ftell(pb);

  1189.     int i;

  1190. 

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

  1192.     put_tag(pb, "udta");

  1193. 

  1194.     /* iTunes meta data */

  1195.     mov_write_meta_tag(pb, mov, s);

  1196. 

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

  1198.     /* Requirements */

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

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

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

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

  1203.             mov_write_string_tag(pb, "\251req", "QuickTime 6.0 or greater", 0);

  1204.             break;

  1205.         }

  1206.     }

  1207. 

  1208.     mov_write_string_tag(pb, "\251nam", s->title         , 0);

  1209.     mov_write_string_tag(pb, "\251aut", s->author        , 0);

  1210.     mov_write_string_tag(pb, "\251alb", s->album         , 0);

  1211.     mov_write_day_tag(pb, s->year, 0);

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

  1213.         mov_write_string_tag(pb, "\251enc", LIBAVFORMAT_IDENT, 0);

  1214.     mov_write_string_tag(pb, "\251des", s->comment       , 0);

  1215.     mov_write_string_tag(pb, "\251gen", s->genre         , 0);

  1216.   }

  1217. 

  1218.     return updateSize(pb, pos);

  1219. }

  1220. 

  1221. 

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

  1223. {

  1224.     size_t i;

  1225.     unsigned char c;

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

  1227.         c = b[i];

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

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

  1230.         put_be16(pb, c);

  1231.     }

  1232.     put_be16(pb, 0x00);

  1233.     return 2*n;

  1234. }

  1235. 

  1236. static uint16_t language_code (const char *str)

  1237. {

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

  1239. }

  1240. 

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

  1242. {

  1243.     size_t len, size;

  1244.     offset_t pos, curpos;

  1245. 

  1246.     size = 0;

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

  1248.         pos = url_ftell(pb);

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

  1250.         put_tag(pb, "uuid");

  1251.         put_tag(pb, "USMT");

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

  1253.         put_be32(pb, 0xbb88695c );

  1254.         put_be32(pb, 0xfac9c740 );

  1255.         size += 24;

  1256. 

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

  1258.         put_tag(pb, "MTDT");

  1259.         put_be16(pb, 4);

  1260.         size += 10;

  1261. 

  1262.         // ?

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

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

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

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

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

  1268.         size += 12;

  1269. 

  1270.         // Encoder

  1271.         len = strlen(LIBAVCODEC_IDENT)+1;

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

  1273.         put_be32(pb, 0x04);                 /* type */

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

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

  1276.         ascii_to_wc(pb, LIBAVCODEC_IDENT, len);

  1277.         size += len*2+10;

  1278. 

  1279.         // Title

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

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

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

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

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

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

  1286.         size += len*2+10;

  1287. 

  1288.         // Date

  1289. //        snprintf(dt,32,"%04d/%02d/%02d %02d:%02d:%02d",t_st->tm_year+1900,t_st->tm_mon+1,t_st->tm_mday,t_st->tm_hour,t_st->tm_min,t_st->tm_sec);

  1290.         len = strlen("2006/04/01 11:11:11")+1;

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

  1292.         put_be32(pb, 0x03);        /* type */

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

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

  1295.         ascii_to_wc (pb, "2006/04/01 11:11:11", len);

  1296.         size += len*2+10;

  1297. 

  1298.         // size

  1299.         curpos = url_ftell(pb);

  1300.         url_fseek(pb, pos, SEEK_SET);

  1301.         put_be32(pb, size);

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

  1303.         put_be32(pb, size-24);

  1304.         url_fseek(pb, curpos, SEEK_SET);

  1305.     }

  1306. 

  1307.     return size;

  1308. }

  1309. 

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

  1311.                               AVFormatContext *s)

  1312. {

  1313.     int i;

  1314.     offset_t pos = url_ftell(pb);

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

  1316.     put_tag(pb, "moov");

  1317.     mov->timescale = globalTimescale;

  1318. 

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

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

  1321. 

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

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

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

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

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

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

  1328.         }

  1329. 

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

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

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

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

  1334.     }

  1335. 

  1336.     mov_write_mvhd_tag(pb, mov);

  1337.     //mov_write_iods_tag(pb, mov);

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

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

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

  1341.         }

  1342.     }

  1343. 

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

  1345.         mov_write_uuidusmt_tag(pb, s);

  1346.     else

  1347.     mov_write_udta_tag(pb, mov, s);

  1348. 

  1349.     return updateSize(pb, pos);

  1350. }

  1351. 

  1352. static int mov_write_mdat_tag(ByteIOContext *pb, MOVContext* mov)

  1353. {

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

  1355.     put_tag(pb, "wide");

  1356. 

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

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

  1359.     put_tag(pb, "mdat");

  1360.     return 0;

  1361. }

  1362. 

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

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

  1365. {

  1366.     MOVContext *mov = s->priv_data;

  1367. 

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

  1369.     put_tag(pb, "ftyp");

  1370. 

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

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

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

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

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

  1376.         put_tag(pb, "MSNV");

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

  1378.         put_tag(pb, "isom");

  1379.     else

  1380.         put_tag(pb, "qt  ");

  1381. 

  1382.     put_be32(pb, 0x200 );

  1383. 

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

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

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

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

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

  1389.         put_tag(pb, "MSNV");

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

  1391.         put_tag(pb, "mp41");

  1392.     else

  1393.         put_tag(pb, "qt  ");

  1394. }

  1395. 

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

  1397. {

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

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

  1400.     int AudioRate = AudioCodec->sample_rate;

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

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

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

  1404. 

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

  1406.     put_tag(pb, "uuid");

  1407.     put_tag(pb, "PROF");

  1408. 

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

  1410.     put_be32(pb, 0xbb88695c );

  1411.     put_be32(pb, 0xfac9c740 );

  1412. 

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

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

  1415. 

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

  1417.     put_tag(pb, "FPRF");

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

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

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

  1421. 

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

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

  1424.     put_be32(pb, 0x0 );

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

  1426.     put_tag(pb, "mp4a");

  1427.     put_be32(pb, 0x20f );

  1428.     put_be32(pb, 0x0 );

  1429.     put_be32(pb, audio_kbitrate);

  1430.     put_be32(pb, audio_kbitrate);

  1431.     put_be32(pb, AudioRate );

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

  1433. 

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

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

  1436.     put_be32(pb, 0x0 );

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

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

  1439.         put_tag(pb, "avc1");

  1440.         put_be16(pb, 0x014D );

  1441.         put_be16(pb, 0x0015 );

  1442.     } else {

  1443.         put_tag(pb, "mp4v");

  1444.         put_be16(pb, 0x0000 );

  1445.         put_be16(pb, 0x0103 );

  1446.     }

  1447.     put_be32(pb, 0x0 );

  1448.     put_be32(pb, video_kbitrate);

  1449.     put_be32(pb, video_kbitrate);

  1450.     put_be32(pb, FrameRate);

  1451.     put_be32(pb, FrameRate);

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

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

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

  1455. }

  1456. 

  1457. static int mov_write_header(AVFormatContext *s)

  1458. {

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

  1460.     MOVContext *mov = s->priv_data;

  1461.     int i;

  1462. 

  1463.     /* Default mode == MP4 */

  1464.     mov->mode = MODE_MP4;

  1465. 

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

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

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

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

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

  1471. 

  1472.         mov_write_ftyp_tag(pb,s);

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

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

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

  1476.                 return -1;

  1477.             }

  1478.             mov_write_uuidprof_tag(pb,s);

  1479.         }

  1480.     }

  1481. 

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

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

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

  1485. 

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

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

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

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

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

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

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

  1493.         }

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

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

  1496.     }

  1497. 

  1498.     mov_write_mdat_tag(pb, mov);

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

  1500. 

  1501.     put_flush_packet(pb);

  1502. 

  1503.     return 0;

  1504. }

  1505. 

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

  1507. {

  1508.     MOVContext *mov = s->priv_data;

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

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

  1511.     AVCodecContext *enc = trk->enc;

  1512.     int cl, id;

  1513.     unsigned int samplesInChunk = 0;

  1514.     int size= pkt->size;

  1515. 

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

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

  1518. 

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

  1520.         switch (enc->codec_id) {

  1521.         case CODEC_ID_AMR_NB:

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

  1523.                 static uint16_t packed_size[16] =

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

  1525.                 int len = 0;

  1526. 

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

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

  1529.                     samplesInChunk++;

  1530.                 }

  1531.             }

  1532.             break;

  1533.         case CODEC_ID_PCM_MULAW:

  1534.         case CODEC_ID_PCM_ALAW:

  1535.             samplesInChunk = size/enc->channels;

  1536.             break;

  1537.         case CODEC_ID_PCM_S16BE:

  1538.         case CODEC_ID_PCM_S16LE:

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

  1540.             break;

  1541.         case CODEC_ID_PCM_S24BE:

  1542.         case CODEC_ID_PCM_S24LE:

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

  1544.             break;

  1545.         case CODEC_ID_PCM_S32BE:

  1546.         case CODEC_ID_PCM_S32LE:

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

  1548.             break;

  1549.         default:

  1550.             samplesInChunk = 1;

  1551.         }

  1552.     } else {

  1553.         samplesInChunk = 1;

  1554.     }

  1555. 

  1556.     /* copy extradata if it exists */

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

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

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

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

  1561.     }

  1562. 

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

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

  1565.         /* nal reformating needed */

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

  1567.         assert(pkt->size);

  1568.         size = pkt->size;

  1569.     }

  1570. 

  1571.     cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;

  1572.     id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

  1573. 

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

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

  1576.         if (!trk->cluster)

  1577.             return -1;

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

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

  1580.             return -1;

  1581.         trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;

  1582.     }

  1583. 

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

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

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

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

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

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

  1590.             trk->hasBframes = 1;

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

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

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

  1594.             trk->hasKeyframes++;

  1595.     }

  1596.     trk->entry++;

  1597.     trk->sampleCount += samplesInChunk;

  1598.     mov->mdat_size += size;

  1599. 

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

  1601. 

  1602.     put_flush_packet(pb);

  1603.     return 0;

  1604. }

  1605. 

  1606. static int mov_write_trailer(AVFormatContext *s)

  1607. {

  1608.     MOVContext *mov = s->priv_data;

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

  1610.     int res = 0;

  1611.     int i, j;

  1612. 

  1613.     offset_t moov_pos = url_ftell(pb);

  1614. 

  1615.     /* Write size of mdat tag */

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

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

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

  1619.     } else {

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

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

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

  1623.         put_tag(pb, "mdat");

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

  1625.     }

  1626.     url_fseek(pb, moov_pos, SEEK_SET);

  1627. 

  1628.     mov_write_moov_tag(pb, mov, s);

  1629. 

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

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

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

  1633.         }

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

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

  1636. 

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

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

  1639.     }

  1640. 

  1641.     put_flush_packet(pb);

  1642. 

  1643.     return res;

  1644. }

  1645. 

  1646. static AVOutputFormat mov_oformat = {

  1647.     "mov",

  1648.     "mov format",

  1649.     NULL,

  1650.     "mov",

  1651.     sizeof(MOVContext),

  1652.     CODEC_ID_AAC,

  1653.     CODEC_ID_MPEG4,

  1654.     mov_write_header,

  1655.     mov_write_packet,

  1656.     mov_write_trailer,

  1657.     .flags = AVFMT_GLOBALHEADER,

  1658. };

  1659. 

  1660. static AVOutputFormat _3gp_oformat = {

  1661.     "3gp",

  1662.     "3gp format",

  1663.     NULL,

  1664.     "3gp",

  1665.     sizeof(MOVContext),

  1666.     CODEC_ID_AMR_NB,

  1667.     CODEC_ID_H263,

  1668.     mov_write_header,

  1669.     mov_write_packet,

  1670.     mov_write_trailer,

  1671.     .flags = AVFMT_GLOBALHEADER,

  1672. };

  1673. 

  1674. static AVOutputFormat mp4_oformat = {

  1675.     "mp4",

  1676.     "mp4 format",

  1677.     "application/mp4",

  1678.     "mp4,m4a",

  1679.     sizeof(MOVContext),

  1680.     CODEC_ID_AAC,

  1681.     CODEC_ID_MPEG4,

  1682.     mov_write_header,

  1683.     mov_write_packet,

  1684.     mov_write_trailer,

  1685.     .flags = AVFMT_GLOBALHEADER,

  1686. };

  1687. 

  1688. static AVOutputFormat psp_oformat = {

  1689.     "psp",

  1690.     "psp mp4 format",

  1691.     NULL,

  1692.     "mp4,psp",

  1693.     sizeof(MOVContext),

  1694.     CODEC_ID_AAC,

  1695.     CODEC_ID_MPEG4,

  1696.     mov_write_header,

  1697.     mov_write_packet,

  1698.     mov_write_trailer,

  1699.     .flags = AVFMT_GLOBALHEADER,

  1700. };

  1701. 

  1702. static AVOutputFormat _3g2_oformat = {

  1703.     "3g2",

  1704.     "3gp2 format",

  1705.     NULL,

  1706.     "3g2",

  1707.     sizeof(MOVContext),

  1708.     CODEC_ID_AMR_NB,

  1709.     CODEC_ID_H263,

  1710.     mov_write_header,

  1711.     mov_write_packet,

  1712.     mov_write_trailer,

  1713.     .flags = AVFMT_GLOBALHEADER,

  1714. };

  1715. 

  1716. int movenc_init(void)

  1717. {

  1718.     av_register_output_format(&mov_oformat);

  1719.     av_register_output_format(&_3gp_oformat);

  1720.     av_register_output_format(&mp4_oformat);

  1721.     av_register_output_format(&psp_oformat);

  1722.     av_register_output_format(&_3g2_oformat);

  1723.     return 0;

  1724. }