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

909 lines
28KB
Raw Blame History 

  1. /*

  2.  * MOV, 3GP, MP4 encoder.

  3.  * Copyright (c) 2003 Thomas Raivio.

  4.  *

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

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

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

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

  9.  *

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

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

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

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

  18.  */

  19. #include "avformat.h"

  20. #include "avi.h"

  21. #include "avio.h"

  22. #include <time.h>

  23. 

  24. #undef NDEBUG

  25. #include <assert.h>

  26. 

  27. #define MOV_INDEX_CLUSTER_SIZE 16384

  28. #define globalTimescale 1000

  29. 

  30. typedef struct MOVIentry {

  31.     unsigned int flags, pos, len;

  32.     unsigned int chunkSize;

  33.     char         key_frame;

  34.     unsigned int entries;

  35. } MOVIentry;

  36. 

  37. typedef struct MOVIndex {

  38.     int         entry;

  39.     int         samples;

  40.     int         mdat_size;

  41.     int         ents_allocated;

  42.     long        timescale;

  43.     long        time;

  44.     long        frameCount;

  45.     long        trackDuration;

  46.     long        sampleDelta;

  47.     int         hasKeyframes;

  48.     int         trackID;

  49.     AVCodecContext *enc;

  50. 

  51.     int         vosLen;

  52.     uint8_t     *vosData;

  53.     MOVIentry** cluster;

  54. } MOVTrack;

  55. 

  56. typedef struct {

  57.     long    time;

  58.     int     nb_streams;

  59.     int     mdat_written;

  60.     offset_t mdat_pos;

  61.     offset_t movi_list;

  62.     long    timescale;

  63.     MOVTrack tracks[MAX_STREAMS];

  64. } MOVContext;

  65. 

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

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

  68. {

  69.     long curpos = url_ftell(pb);

  70.     url_fseek(pb, pos, SEEK_SET);

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

  72.     url_fseek(pb, curpos, SEEK_SET);

  73. 

  74.     return curpos - pos;

  75. }

  76. 

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

  78. {

  79.     int i;

  80.     int pos = url_ftell(pb);

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

  82.     put_tag(pb, "stco");

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

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

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

  86.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  87.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  89.     }

  90.     return updateSize (pb, pos);

  91. }

  92. 

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

  94. {

  95.     int equalChunks = 1;

  96.     int i, tst = -1, oldtst = -1;

  97. 

  98.     int pos = url_ftell(pb);

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

  100.     put_tag(pb, "stsz");

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

  102. 

  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.         tst = track->cluster[cl][id].len;

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

  108.           equalChunks = 0;

  109.           break;

  110.         }

  111.         oldtst = tst;

  112.     }

  113.     if(equalChunks ||

  114.        track->enc->codec_type == CODEC_TYPE_AUDIO) {

  115.         //int sSize = track->cluster[0][0].len/track->cluster[0][0].entries;

  116.         int sSize = track->cluster[0][0].len;

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

  118.         put_be32(pb, track->samples/track->enc->channels); // sample count 

  119.     }

  120.     else {

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

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

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

  124.             int cl = i / MOV_INDEX_CLUSTER_SIZE;

  125.             int id = i % MOV_INDEX_CLUSTER_SIZE;

  126.             put_be32(pb, track->cluster[cl][id].len);

  127.         }

  128.     }

  129.     return updateSize (pb, pos);

  130. }

  131. 

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

  133. {

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

  135. 

  136.     int pos = url_ftell(pb);

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

  138.     put_tag(pb, "stsc");

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

  140.     entryPos = url_ftell(pb);

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

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

  143.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  144.         int id = i % MOV_INDEX_CLUSTER_SIZE;

  145.         if(oldval != track->cluster[cl][id].chunkSize) 

  146.         {

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

  148.             put_be32(pb, track->cluster[cl][id].chunkSize);

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

  150.             oldval = track->cluster[cl][id].chunkSize;

  151.             index++;

  152.         }

  153.     }

  154.     curpos = url_ftell(pb);

  155.     url_fseek(pb, entryPos, SEEK_SET);

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

  157.     url_fseek(pb, curpos, SEEK_SET);

  158. 

  159.     return updateSize (pb, pos);

  160. }

  161. 

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

  163. {

  164.     long curpos;

  165.     int i, index = 0, entryPos;

  166.     int pos = url_ftell(pb);

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

  168.     put_tag(pb, "stss");

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

  170.     entryPos = url_ftell(pb);

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

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

  173.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  174.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  176.             put_be32(pb, i+1);

  177.             index++;

  178.         }

  179.     }

  180.     curpos = url_ftell(pb);

  181.     url_fseek(pb, entryPos, SEEK_SET);

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

  183.     url_fseek(pb, curpos, SEEK_SET);

  184.     return updateSize (pb, pos);

  185. }

  186. 

  187. static int mov_write_damr_tag(ByteIOContext *pb)

  188. {

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

  190.     put_tag(pb, "damr");

  191.     put_tag(pb, "FFMP");

  192.     put_byte(pb, 0);

  193. 

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

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

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

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

  198.     return 0x11;

  199. }

  200. 

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

  202. {

  203.     int pos = url_ftell(pb);

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

  205. 

  206.     if(track->enc->codec_id == CODEC_ID_PCM_MULAW)

  207.       put_tag(pb, "ulaw");

  208.     else if(track->enc->codec_id == CODEC_ID_PCM_ALAW)

  209.       put_tag(pb, "alaw");

  210.     else if(track->enc->codec_id == CODEC_ID_ADPCM_IMA_QT)

  211.       put_tag(pb, "ima4");

  212.     else if(track->enc->codec_id == CODEC_ID_MACE3)

  213.       put_tag(pb, "MAC3");

  214.     else if(track->enc->codec_id == CODEC_ID_MACE6)

  215.       put_tag(pb, "MAC6");

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

  217.       put_tag(pb, "mp4a");

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

  219.       put_tag(pb, "samr");

  220.     else

  221.       put_tag(pb, "    ");

  222. 

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

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

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

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

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

  228. 

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

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

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

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

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

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

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

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

  237. 

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

  239.         mov_write_damr_tag(pb);

  240.     return updateSize (pb, pos);

  241. }

  242. 

  243. static int mov_write_d263_tag(ByteIOContext *pb)

  244. {

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

  246.     put_tag(pb, "d263");

  247.     put_tag(pb, "FFMP");

  248.     put_be16(pb, 0x0a);

  249.     put_byte(pb, 0);

  250.     return 0xf;

  251. }

  252. 

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

  254. static int mov_write_svq3_tag(ByteIOContext *pb)

  255. {

  256.     put_be32(pb, 0x15);

  257.     put_tag(pb, "SMI ");

  258.     put_tag(pb, "SEQH");

  259.     put_be32(pb, 0x5);

  260.     put_be32(pb, 0xe2c0211d);

  261.     put_be32(pb, 0xc0000000);

  262.     put_byte(pb, 0);   

  263.     return 0x15;

  264. }

  265. 

  266. static unsigned int esdsLength(unsigned int len)

  267. {

  268.     unsigned int result = 0;

  269.     unsigned char b = len & 0x7f;

  270.     result += b;

  271.     b = (len >> 8) & 0x7f;

  272.     result += (b + 0x80) << 8;

  273.     b = (len >> 16) & 0x7f;

  274.     result += (b + 0x80) << 16;

  275.     b = (len >> 24) & 0x7f;

  276.     result += (b + 0x80) << 24;

  277.     return result;

  278. }

  279. 

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

  281. {

  282.     put_be32(pb, track->vosLen+18+14+17);

  283.     put_tag(pb, "esds");

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

  285. 

  286.     put_byte(pb, 0x03);            // tag = ES_DescriptorTag

  287.     put_be32(pb, esdsLength(track->vosLen+18+14));  // Length

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

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

  290. 

  291. // Decoderconfigdescriptor = 4

  292.     put_byte(pb, 0x04);            // tag = DecoderConfigDescriptor

  293.     put_be32(pb, esdsLength(track->vosLen+18));  // Length

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

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

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

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

  298. 

  299.     // TODO: find real values for these

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

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

  302. 

  303. // Decoderspecific info Tag = 5

  304.     put_byte(pb, 0x05);           // tag = Decoderspecific info

  305.     put_be32(pb, esdsLength(track->vosLen));   // length

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

  307.     

  308.     put_byte(pb, 0x06);

  309.     put_be32(pb, esdsLength(1));  // length

  310.     put_byte(pb, 0x02);

  311.     return track->vosLen+18+14+17;

  312. }

  313. 

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

  315. {

  316.     int pos = url_ftell(pb);

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

  318.     if(track->enc->codec_id == CODEC_ID_SVQ1)

  319.       put_tag(pb, "SVQ1");

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

  321.       put_tag(pb, "SVQ3");

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

  323.       put_tag(pb, "mp4v");

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

  325.       put_tag(pb, "s263");

  326.     else

  327.       put_tag(pb, "    "); /* Unknown tag */

  328. 

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

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

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

  332. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  347. 

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

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

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

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

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

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

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

  355.         mov_write_esds_tag(pb, track);

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

  357.         mov_write_d263_tag(pb);

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

  359.         mov_write_svq3_tag(pb);    

  360. 

  361.     return updateSize (pb, pos);

  362. }

  363. 

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

  365. {

  366.     int pos = url_ftell(pb);

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

  368.     put_tag(pb, "stsd");

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

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

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

  372.         mov_write_video_tag(pb, track);

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

  374.         mov_write_audio_tag(pb, track);

  375.     return updateSize(pb, pos);

  376. }

  377. 

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

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

  380. {

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

  382.     put_tag(pb, "stts");

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

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

  385. 

  386.     put_be32(pb, track->frameCount); /* sample count */

  387.     put_be32(pb, track->sampleDelta); /* sample delta */

  388.     return 0x18;

  389. }

  390. 

  391. static int mov_write_dref_tag(ByteIOContext *pb)

  392. {

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

  394.     put_tag(pb, "dref");

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

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

  397. 

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

  399.     put_tag(pb, "url ");

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

  401. 

  402.     return 28;

  403. }

  404. 

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

  406. {

  407.     int pos = url_ftell(pb);

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

  409.     put_tag(pb, "stbl");

  410.     mov_write_stsd_tag(pb, track);

  411.     mov_write_stts_tag(pb, track);

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

  413.         track->hasKeyframes)

  414.         mov_write_stss_tag(pb, track);

  415.     mov_write_stsc_tag(pb, track);

  416.     mov_write_stsz_tag(pb, track);

  417.     mov_write_stco_tag(pb, track);

  418.     return updateSize(pb, pos);

  419. }

  420. 

  421. static int mov_write_dinf_tag(ByteIOContext *pb)

  422. {

  423.     int pos = url_ftell(pb);

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

  425.     put_tag(pb, "dinf");

  426.     mov_write_dref_tag(pb);

  427.     return updateSize(pb, pos);

  428. }

  429. 

  430. static int mov_write_smhd_tag(ByteIOContext *pb)

  431. {

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

  433.     put_tag(pb, "smhd");

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

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

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

  437.     return 16;

  438. }

  439. 

  440. static int mov_write_vmhd_tag(ByteIOContext *pb)

  441. {

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

  443.     put_tag(pb, "vmhd");

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

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

  446.     return 0x14;

  447. }

  448. 

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

  450. {

  451.     int pos = url_ftell(pb);

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

  453.     put_tag(pb, "minf");

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

  455.         mov_write_vmhd_tag(pb);

  456.     else

  457.         mov_write_smhd_tag(pb);

  458.     mov_write_dinf_tag(pb);

  459.     mov_write_stbl_tag(pb, track);

  460.     return updateSize(pb, pos);

  461. }

  462. 

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

  464. {

  465.     char *str;

  466.     int pos = url_ftell(pb);

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

  468.     put_tag(pb, "hdlr");

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

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

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

  472.         put_tag(pb, "vide"); /* handler type */

  473.     else

  474.         put_tag(pb, "soun"); /* handler type */

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

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

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

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

  479.         str = "VideoHandler";

  480.     else

  481.         str = "SoundHandler";

  482.     put_byte(pb, strlen(str)); /* string counter */

  483.     put_buffer(pb, str, strlen(str));

  484.     return updateSize(pb, pos);

  485. }

  486. 

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

  488. {

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

  490.     put_tag(pb, "mdhd");

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

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

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

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

  495.         int64_t rate = track->enc->frame_rate;

  496.         put_be32(pb, rate); 

  497.         put_be32(pb, rate*(int64_t)track->trackDuration/(int64_t)globalTimescale); // duration 

  498.     }

  499.     else {

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

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

  502.     }

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

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

  505.     return 32;

  506. }

  507. 

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

  509. {

  510.     int pos = url_ftell(pb);

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

  512.     put_tag(pb, "mdia");

  513.     mov_write_mdhd_tag(pb, track);

  514.     mov_write_hdlr_tag(pb, track);

  515.     mov_write_minf_tag(pb, track);

  516.     return updateSize(pb, pos);

  517. }

  518. 

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

  520. {

  521.     int64_t maxTrackLenTemp;

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

  523.     put_tag(pb, "tkhd");

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

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

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

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

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

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

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

  531. 

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

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

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

  535.     /* Volume, only for audio */

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

  537.         put_be16(pb, 0x0100);

  538.     else

  539.         put_be16(pb, 0);

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

  541. 

  542.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  552. 

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

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

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

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

  557.     }

  558.     else {

  559.         put_be32(pb, 0);

  560.         put_be32(pb, 0);

  561.     }

  562.     return 0x5c;

  563. }

  564. 

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

  566. {

  567.     int pos = url_ftell(pb);

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

  569.     put_tag(pb, "trak");

  570.     mov_write_tkhd_tag(pb, track);

  571.     mov_write_mdia_tag(pb, track);

  572.     return updateSize(pb, pos);

  573. }

  574. 

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

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

  577. {

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

  579.     put_tag(pb, "iods");

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

  581.     put_be16(pb, 0x1007);

  582.     put_byte(pb, 0);

  583.     put_be16(pb, 0x4fff);

  584.     put_be16(pb, 0xfffe);

  585.     put_be16(pb, 0x01ff);

  586.     return 0x15;

  587. }

  588. 

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

  590. {

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

  592.     int64_t maxTrackLenTemp;

  593. 

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

  595.     put_tag(pb, "mvhd");

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

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

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

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

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

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

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

  603.             if(maxTrackLen < maxTrackLenTemp)

  604.                 maxTrackLen = maxTrackLenTemp;

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

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

  607.         }

  608.     }

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

  610. 

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

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

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

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

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

  616. 

  617.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  627. 

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

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

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

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

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

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

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

  635.     return 0x6c;

  636. }

  637. 

  638. static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov)

  639. {

  640.     int pos, i;

  641.     pos = url_ftell(pb);

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

  643.     put_tag(pb, "moov");

  644.     mov->timescale = globalTimescale;

  645. 

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

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

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

  649.                 mov->tracks[i].timescale = globalTimescale;

  650.                 mov->tracks[i].sampleDelta = mov->tracks[i].enc->frame_rate_base;

  651.                 mov->tracks[i].frameCount = mov->tracks[i].samples;

  652.                 mov->tracks[i].trackDuration = (int64_t)((int64_t)mov->tracks[i].entry*

  653.                     (int64_t)globalTimescale*(int64_t)mov->tracks[i].enc->frame_rate_base)/(int64_t)mov->tracks[i].enc->frame_rate;

  654.             }

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

  656.                 long trackDuration = 0;

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

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

  659.                     int j;

  660.                     for (j=0; j<mov->tracks[i].samples; j++) {

  661.                         int cl = j / MOV_INDEX_CLUSTER_SIZE;

  662.                         int id = j % MOV_INDEX_CLUSTER_SIZE;

  663.                         trackDuration += mov->tracks[i].cluster[cl][id].entries;

  664.                     }

  665.                     mov->tracks[i].sampleDelta = 160;  // Bytes per chunk

  666.                     mov->tracks[i].frameCount = mov->tracks[i].samples;

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

  668.                         mov->tracks[i].samples * mov->tracks[i].sampleDelta; //trackDuration

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

  670.                 }

  671.                 else {

  672.                     int j;

  673.                     for (j=0; j<=mov->tracks[i].entry; j++) {

  674.                         int cl = j / MOV_INDEX_CLUSTER_SIZE;

  675.                         int id = j % MOV_INDEX_CLUSTER_SIZE;

  676.                         trackDuration += mov->tracks[i].cluster[cl][id].len;

  677.                     }

  678.                     mov->tracks[i].frameCount = trackDuration;

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

  680.                     mov->tracks[i].sampleDelta = 1;

  681.                     mov->tracks[i].trackDuration = trackDuration;

  682.                 }

  683.             }

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

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

  686.         }

  687.     }

  688. 

  689.     mov_write_mvhd_tag(pb, mov);

  690.     //mov_write_iods_tag(pb, mov);

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

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

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

  694.         }

  695.     }

  696. 

  697.     return updateSize(pb, pos);

  698. }

  699. 

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

  701. {

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

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

  704.     put_tag(pb, "mdat");

  705.     return 0;

  706. }

  707. 

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

  709. int mov_write_ftyp_tag(ByteIOContext *pb)

  710. {

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

  712.     put_tag(pb, "ftyp");

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

  714.     put_be32(pb, 0x200 );

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

  716.     return 0x14;

  717. }

  718. 

  719. static int mov_write_header(AVFormatContext *s)

  720. {

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

  722. 

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

  724.     if(!strcmp("3gp", s->oformat->name))

  725.         mov_write_ftyp_tag(pb);

  726.     }

  727. 

  728.     put_flush_packet(pb);

  729. 

  730.     return 0;

  731. }

  732. 

  733. static int Timestamp() {

  734.     time_t ltime;

  735.     time ( &ltime );

  736.     return ltime+(24107*86400);

  737. }

  738. 

  739. static int mov_write_packet(AVFormatContext *s, int stream_index,

  740.                             const uint8_t *buf, int size, int64_t pts)

  741. {

  742.     MOVContext *mov = s->priv_data;

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

  744.     AVCodecContext *enc;

  745.     int cl, id;

  746. 

  747.     enc = &s->streams[stream_index]->codec;

  748.     if (!url_is_streamed(&s->pb)) {

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

  750.         int sampleCount = 0;

  751.         unsigned int chunkSize = 0;

  752. 

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

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

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

  756.                 static uint16_t packed_size[16] = {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 0};             

  757.                 int len = 0;

  758. 

  759.                 while(len < size && sampleCount < 100) {

  760.                     len += packed_size[(buf[len] >> 3) & 0x0F];

  761.                     sampleCount++;

  762.                 }

  763.                 chunkSize = 1;

  764.             }

  765.             else {

  766.                 sampleCount = size;

  767.                 chunkSize = size/enc->channels;

  768.             }

  769.         }

  770.         else if(enc->codec_type == CODEC_TYPE_VIDEO) {

  771.             if(enc->codec_id == CODEC_ID_MPEG4 &&

  772.                trk->vosLen == 0)

  773.             {

  774.                 assert(enc->extradata_size);

  775. 

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

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

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

  779.             }

  780.             chunkSize = 1;

  781.         }

  782. 

  783.         cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;

  784.         id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

  785. 

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

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

  788.             if (!trk->cluster)

  789.                 return -1;

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

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

  792.                 return -1;

  793.             trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;

  794.         }

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

  796.             mov_write_mdat_tag(pb, mov);

  797.             mov->mdat_written = 1;

  798.             mov->time = Timestamp();

  799.         }

  800.         

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

  802.         trk->cluster[cl][id].chunkSize = chunkSize;

  803.         if(enc->channels > 1)

  804.           trk->cluster[cl][id].len = size/enc->channels;

  805.         else

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

  807.         trk->cluster[cl][id].entries = sampleCount;

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

  809.             trk->cluster[cl][id].key_frame = enc->coded_frame->key_frame;

  810.             if(enc->coded_frame->pict_type == FF_I_TYPE)

  811.             trk->hasKeyframes = 1;

  812.         }

  813.         trk->enc = enc;

  814.         trk->entry++;

  815.         if(sampleCount == 0)

  816.             trk->samples++;

  817.         else

  818.             trk->samples += sampleCount;

  819.         trk->mdat_size += size;

  820.     }

  821.     put_buffer(pb, buf, size);

  822. 

  823.     put_flush_packet(pb);

  824.     return 0;

  825. }

  826. 

  827. static int mov_write_trailer(AVFormatContext *s)

  828. {

  829.     MOVContext *mov = s->priv_data;

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

  831.     int res = 0;

  832.     int i, j;

  833.     offset_t file_size;

  834. 

  835.     file_size = url_ftell(pb);

  836.     j = 0;

  837. 

  838.     /* Write size of mdat tag */

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

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

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

  842.         }

  843.     }

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

  845.     put_be32(pb, j+8);

  846.     url_fseek(pb, file_size, SEEK_SET);

  847. 

  848.     mov_write_moov_tag(pb, mov);

  849. 

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

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

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

  853.         }

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

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

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

  857.     }

  858.     put_flush_packet(pb);

  859. 

  860.     return res;

  861. }

  862. 

  863. static AVOutputFormat mov_oformat = {

  864.     "mov",

  865.     "mov format",

  866.     NULL,

  867.     "mov",

  868.     sizeof(MOVContext),

  869.     CODEC_ID_PCM_ALAW,

  870.     CODEC_ID_MPEG4,

  871.     mov_write_header,

  872.     mov_write_packet,

  873.     mov_write_trailer,

  874. };

  875. 

  876. static AVOutputFormat _3gp_oformat = {

  877.     "3gp",

  878.     "3gp format",

  879.     NULL,

  880.     "3gp",

  881.     sizeof(MOVContext),

  882.     CODEC_ID_AMR_NB,

  883.     CODEC_ID_H263,

  884.     mov_write_header,

  885.     mov_write_packet,

  886.     mov_write_trailer,

  887. };

  888. 

  889. static AVOutputFormat mp4_oformat = {

  890.     "mp4",

  891.     "mp4 format",

  892.     NULL,

  893.     "mp4",

  894.     sizeof(MOVContext),

  895.     CODEC_ID_AAC,

  896.     CODEC_ID_MPEG4,

  897.     mov_write_header,

  898.     mov_write_packet,

  899.     mov_write_trailer,

  900. };

  901. 

  902. int movenc_init(void)

  903. {

  904.     av_register_output_format(&mov_oformat);

  905.     av_register_output_format(&_3gp_oformat);

  906.     av_register_output_format(&mp4_oformat);

  907.     return 0;

  908. }