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

827 lines
24KB
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 "avio.h"

  21. #include <time.h>

  22. 

  23. #undef NDEBUG

  24. #include <assert.h>

  25. 

  26. /*

  27.  * Limitations

  28.  * - Currently supports h.263, MPEG4 video codecs, and AMR audio codec.

  29.  */

  30. 

  31. #define MOV_INDEX_CLUSTER_SIZE 16384

  32. #define globalTimescale 1000

  33. 

  34. typedef struct MOVIentry {

  35.     unsigned int flags, pos, len;

  36.     unsigned int entries;

  37. } MOVIentry;

  38. 

  39. typedef struct MOVIndex {

  40.     int         entry;

  41.     int         samples;

  42.     int         mdat_size;

  43.     offset_t    mdat_pos;

  44.     int         ents_allocated;

  45.     long        timescale;

  46.     long        time;

  47.     long        frameDuration;

  48.     long        sampleDelta;

  49.     int         trackID;

  50.     AVCodecContext *enc;

  51. 

  52.     int         vosLen;

  53.     uint8_t     *vosData;

  54.     MOVIentry** cluster;

  55. } MOVTrack;

  56. 

  57. typedef struct {

  58.     long    time;

  59.     int     nb_streams;

  60.     offset_t movi_list;

  61.     long    timescale;

  62.     MOVTrack tracks[MAX_STREAMS];

  63. } MOVContext;

  64. 

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

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

  67. {

  68.     long curpos = url_ftell(pb);

  69.     url_fseek(pb, pos, SEEK_SET);

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

  71.     url_fseek(pb, curpos, SEEK_SET);

  72. 

  73.     return curpos - pos;

  74. }

  75. 

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

  77. {

  78.     int i;

  79.     put_be32(pb, 16+track->entry*4); /* size */

  80.     put_tag(pb, "stco");

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

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

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

  84.         int cl = i / MOV_INDEX_CLUSTER_SIZE;

  85.         int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  87.     }

  88.     return 16+track->entry*4;

  89. }

  90. 

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

  92. {

  93.     int i, size;

  94. 

  95.     if(track->cluster[0][0].entries != 0) 

  96.         size = 20;

  97.     else

  98.         size = 20+track->samples*4;

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

  100.     put_tag(pb, "stsz");

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

  102. 

  103.     /* TODO: Ugly (and false) assumption: if we have a chunk of samples, assume

  104.      * all sizes are same */

  105.     if(track->cluster[0][0].entries != 0)   {

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

  107.         put_be32(pb, sSize); /* sample size */

  108.         put_be32(pb, track->samples); /* sample count */

  109.     }

  110.     else 

  111.     {

  112.         put_be32(pb, 0); /* sample size */

  113.         put_be32(pb, track->samples); /* sample count */

  114.         for (i=0; i<track->samples; i++) {

  115.             int cl = i / MOV_INDEX_CLUSTER_SIZE;

  116.             int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  118.         }

  119.     }

  120.     return size;

  121. }

  122. 

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

  124. {

  125.     int size;

  126.     if(track->cluster[0][0].entries != 0)

  127.         size = 16+track->entry*4*3;

  128.     else

  129.         size = 0x1c;

  130.     put_be32(pb, size); // size 

  131.     put_tag(pb, "stsc");

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

  133.     if(track->cluster[0][0].entries != 0) {

  134.         int i;

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

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

  137.             int cl = i / MOV_INDEX_CLUSTER_SIZE;

  138.             int id = i % MOV_INDEX_CLUSTER_SIZE;

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

  140.             put_be32(pb, track->cluster[cl][id].entries);

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

  142.         }

  143.     }

  144.     else {

  145.         put_be32(pb, 1); // entry count 

  146.         put_be32(pb, 0x1); // first chunk 

  147.         put_be32(pb, 0x1); // samples per chunk 

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

  149.     }

  150. 

  151.     return size;

  152. }

  153. 

  154. //FIXME keyframes?

  155. static int mov_write_stss_tag(ByteIOContext *pb) //TRA OK

  156. {

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

  158.     put_tag(pb, "stss");

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

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

  161.     put_be32(pb, 0x1); /* sample number */

  162.     return 0x14;

  163. }

  164. 

  165. static int mov_write_damr_tag(ByteIOContext *pb)

  166. {

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

  168.     put_tag(pb, "damr");

  169.     put_tag(pb, "FFMP");

  170.     put_byte(pb, 0);

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

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

  173.     return 0x11;

  174. }

  175. 

  176. static int mov_write_samr_tag(ByteIOContext *pb, MOVTrack* track)

  177. {

  178.     int pos = url_ftell(pb);

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

  180.     /* "samr" for AMR NB, "sawb" for AMR WB */

  181.     put_tag(pb, "samr");

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

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

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

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

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

  187. 

  188.     put_be16(pb, 2); /* Reserved */

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

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

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

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

  193. 

  194.     mov_write_damr_tag(pb);

  195.     return updateSize (pb, pos);

  196. }

  197. 

  198. static int mov_write_d263_tag(ByteIOContext *pb)

  199. {

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

  201.     put_tag(pb, "d263");

  202.     put_tag(pb, "FFMP");

  203.     put_be16(pb, 0x0a);

  204.     put_byte(pb, 0);

  205.     return 0xf;

  206. }

  207. 

  208. static int mov_write_s263_tag(ByteIOContext *pb, MOVTrack* track)

  209. {

  210.     int pos = url_ftell(pb);

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

  212.     put_tag(pb, "s263");

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

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

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

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

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

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

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

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

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

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

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

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

  225.     put_be16(pb, 1); /* Reserved */

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

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

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

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

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

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

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

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

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

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

  236.     mov_write_d263_tag(pb);

  237.     return updateSize (pb, pos);

  238. }

  239. 

  240. static unsigned int esdsLength(unsigned int len)

  241. {

  242.     unsigned int result = 0;

  243.     unsigned char b = len & 0x7f;

  244.     result += b;

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

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

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

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

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

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

  251.     return result;

  252. }

  253. 

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

  255. {

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

  257.     put_tag(pb, "esds");

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

  259. 

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

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

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

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

  264. 

  265. // Decoderconfigdescriptor = 4

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

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

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

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

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

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

  272. 

  273.     // TODO: find real values for these

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

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

  276. 

  277. // Decoderspecific info Tag = 5

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

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

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

  281.     

  282.     put_byte(pb, 0x06);

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

  284.     put_byte(pb, 0x02);

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

  286. }

  287. 

  288. static int mov_write_mp4v_tag(ByteIOContext *pb, MOVTrack* track) // Basic

  289. {

  290.     int pos = url_ftell(pb);

  291. 

  292.     put_be32(pb, 0);

  293.     put_tag(pb, "mp4v");

  294.     put_be32(pb, 0);  // Reserved

  295.     put_be16(pb, 0);  // Reserved

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

  297.     put_be32(pb, 0);  // Reserved

  298.     put_be32(pb, 0);  // Reserved

  299.     put_be32(pb, 0);  // Reserved

  300.     put_be32(pb, 0);  // Reserved

  301.     put_be16(pb, track->enc->width);  // Width

  302.     put_be16(pb, track->enc->height);  // Height

  303.     put_be32(pb, 0x00480000);  // Reserved

  304.     put_be32(pb, 0x00480000);  // Reserved

  305.     put_be32(pb, 0);  // Reserved

  306.     put_be16(pb, 1);  // Reserved

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

  308.     put_be32(pb, 0);  // Reserved

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

  310.     put_be32(pb, 0);  // Reserved

  311.     put_be32(pb, 0);  // Reserved

  312.     put_be32(pb, 0);  // Reserved

  313.     put_be32(pb, 0);  // Reserved

  314.     put_be32(pb, 0);  // Reserved

  315.     put_be16(pb, 24); // Reserved

  316.     put_be16(pb, 0xFFFF); // Reserved

  317.     mov_write_esds_tag(pb, track);

  318.     return updateSize(pb, pos);

  319. }

  320. 

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

  322. {

  323.     int pos = url_ftell(pb);

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

  325.     put_tag(pb, "stsd");

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

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

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

  329.         if (track->enc->codec_id == CODEC_ID_H263) 

  330.             mov_write_s263_tag(pb, track);

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

  332.             mov_write_mp4v_tag(pb, track);

  333.     }

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

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

  336.             mov_write_samr_tag(pb, track);

  337.     }

  338.     return updateSize(pb, pos);

  339. }

  340. 

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

  342. {

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

  344.     put_tag(pb, "stts");

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

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

  347. 

  348.     put_be32(pb, track->samples); /* sample count */

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

  350.     return 0x18;

  351. }

  352. 

  353. static int mov_write_dref_tag(ByteIOContext *pb)

  354. {

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

  356.     put_tag(pb, "dref");

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

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

  359. 

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

  361.     put_tag(pb, "url ");

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

  363. 

  364.     return 28;

  365. }

  366. 

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

  368. {

  369.     int pos = url_ftell(pb);

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

  371.     put_tag(pb, "stbl");

  372.     mov_write_stsd_tag(pb, track);

  373.     mov_write_stts_tag(pb, track);

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

  375.         mov_write_stss_tag(pb);

  376.     mov_write_stsc_tag(pb, track);

  377.     mov_write_stsz_tag(pb, track);

  378.     mov_write_stco_tag(pb, track);

  379.     return updateSize(pb, pos);

  380. }

  381. 

  382. static int mov_write_dinf_tag(ByteIOContext *pb)

  383. {

  384.     int pos = url_ftell(pb);

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

  386.     put_tag(pb, "dinf");

  387.     mov_write_dref_tag(pb);

  388.     return updateSize(pb, pos);

  389. }

  390. 

  391. static int mov_write_smhd_tag(ByteIOContext *pb)

  392. {

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

  394.     put_tag(pb, "smhd");

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

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

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

  398.     return 16;

  399. }

  400. 

  401. static int mov_write_vmhd_tag(ByteIOContext *pb)

  402. {

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

  404.     put_tag(pb, "vmhd");

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

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

  407.     return 0x14;

  408. }

  409. 

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

  411. {

  412.     int pos = url_ftell(pb);

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

  414.     put_tag(pb, "minf");

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

  416.         mov_write_vmhd_tag(pb);

  417.     else

  418.         mov_write_smhd_tag(pb);

  419.     mov_write_dinf_tag(pb);

  420.     mov_write_stbl_tag(pb, track);

  421.     return updateSize(pb, pos);

  422. }

  423. 

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

  425. {

  426.     int size = 0;

  427.     size = 45;

  428.     put_be32(pb, size); /* size */

  429.     put_tag(pb, "hdlr");

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

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

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

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

  434.     else

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

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

  437.     put_byte(pb, 0); /* reserved */

  438.     put_byte(pb, 0); /* reserved */

  439.     put_byte(pb, 0); /* reserved */

  440.     put_byte(pb, 0); /* reserved */

  441.     put_byte(pb, 0); /* reserved */

  442.     put_byte(pb, 0); /* reserved */

  443.     put_byte(pb, 0); /* reserved */

  444.     put_byte(pb, 0); /* reserved */

  445.     put_byte(pb, 0); /* reserved */

  446.     put_byte(pb, 0); /* reserved */

  447.     put_byte(pb, 0); /* reserved */

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

  449.         put_buffer(pb, "VideoHandler", 13);

  450.     else

  451.         put_buffer(pb, "SoundHandler", 13);

  452.     return size;

  453. }

  454. 

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

  456. {

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

  458.     put_tag(pb, "mdhd");

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

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

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

  462.     put_be32(pb, track->timescale); /* time scale */

  463. 

  464.     put_be32(pb, track->timescale*track->entry*track->frameDuration/globalTimescale); /* duration */

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

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

  467.     return 32;

  468. }

  469. 

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

  471. {

  472.     int pos = url_ftell(pb);

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

  474.     put_tag(pb, "mdia");

  475.     mov_write_mdhd_tag(pb, track);

  476.     mov_write_hdlr_tag(pb, track);

  477.     mov_write_minf_tag(pb, track);

  478.     return updateSize(pb, pos);

  479. }

  480. 

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

  482. {

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

  484.     put_tag(pb, "tkhd");

  485.     put_be32(pb, 1); /* version & flags (track enabled) */

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

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

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

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

  490.     put_be32(pb, track->entry*track->frameDuration); /* duration */

  491. 

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

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

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

  495.     /* Volume, only for audio */

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

  497.         put_be16(pb, 0x0100);

  498.     else

  499.         put_be16(pb, 0);

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

  501. 

  502.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  512. 

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

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

  515.         put_be32(pb, 0x01400000);

  516.         put_be32(pb, 0x00f00000);

  517.     }

  518.     else {

  519.         put_be32(pb, 0);

  520.         put_be32(pb, 0);

  521.     }

  522.     return 0x5c;

  523. }

  524. 

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

  526. {

  527.     int pos = url_ftell(pb);

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

  529.     put_tag(pb, "trak");

  530.     mov_write_tkhd_tag(pb, track);

  531.     mov_write_mdia_tag(pb, track);

  532.     return updateSize(pb, pos);

  533. }

  534. 

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

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

  537. {

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

  539.     put_tag(pb, "iods");

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

  541.     put_be16(pb, 0x1007);

  542.     put_byte(pb, 0);

  543.     put_be16(pb, 0x4fff);

  544.     put_be16(pb, 0xfffe);

  545.     put_be16(pb, 0x01ff);

  546.     return 0x15;

  547. }

  548. 

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

  550. {

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

  552. 

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

  554.     put_tag(pb, "mvhd");

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

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

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

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

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

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

  561.             if(maxTrackLen < mov->tracks[i].entry*mov->tracks[i].frameDuration)

  562.                 maxTrackLen = mov->tracks[i].entry*mov->tracks[i].frameDuration;

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

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

  565.         }

  566.     }

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

  568. 

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

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

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

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

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

  574. 

  575.     /* Matrix structure */

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

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

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

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

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

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

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

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

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

  585. 

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

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

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

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

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

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

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

  593.     return 0x6c;

  594. }

  595. 

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

  597. {

  598.     int pos, i;

  599.     pos = url_ftell(pb);

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

  601.     put_tag(pb, "moov");

  602.     mov->timescale = globalTimescale;

  603. 

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

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

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

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

  608.                 mov->tracks[i].sampleDelta = mov->tracks[i].frameDuration =

  609.                     globalTimescale*mov->tracks[i].enc->frame_rate_base/mov->tracks[i].enc->frame_rate;

  610.             }

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

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

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

  614.                     mov->tracks[i].frameDuration = 20;

  615.                     mov->tracks[i].sampleDelta = 160;

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

  617.                 }

  618.                 else {

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

  620.                     mov->tracks[i].frameDuration =

  621.                     globalTimescale*mov->tracks[i].enc->frame_rate_base/mov->tracks[i].enc->frame_rate;

  622.                 }

  623.             }

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

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

  626.         }

  627.     }

  628. 

  629.     mov_write_mvhd_tag(pb, mov);

  630.     //mov_write_iods_tag(pb, mov);

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

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

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

  634.         }

  635.     }

  636. 

  637.     return updateSize(pb, pos);

  638. }

  639. 

  640. int mov_write_mdat_tag(ByteIOContext *pb, MOVTrack* track)

  641. {

  642.     track->mdat_pos = url_ftell(pb); 

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

  644.     put_tag(pb, "mdat");

  645.     return 0;

  646. }

  647. 

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

  649. int mov_write_ftyp_tag(ByteIOContext *pb)

  650. {

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

  652.     put_tag(pb, "ftyp");

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

  654.     put_be32(pb, 0x200 );

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

  656.     return 0x14;

  657. }

  658. 

  659. static int mov_write_header(AVFormatContext *s)

  660. {

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

  662. 

  663.     /* write ftyp */

  664.     mov_write_ftyp_tag(pb);

  665.     

  666.     put_flush_packet(pb);

  667. 

  668.     return 0;

  669. }

  670. 

  671. static int Timestamp() {

  672.     time_t ltime;

  673.     time ( &ltime );

  674.     return ltime+(24107*86400);

  675. }

  676. 

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

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

  679. {

  680.     MOVContext *mov = s->priv_data;

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

  682.     AVCodecContext *enc;

  683.     int cl, id;

  684. 

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

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

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

  688.         int sampleCount = 0;

  689. 

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

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

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

  693.             int len = 0;

  694. 

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

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

  697.                 sampleCount++;

  698.             }

  699.         }

  700.         

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

  702.            trk->vosLen == 0)

  703.         {

  704.             assert(enc->extradata_size);

  705. 

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

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

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

  709.         }

  710. 

  711.         cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;

  712.         id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

  713. 

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

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

  716.             if (!trk->cluster)

  717.                 return -1;

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

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

  720.                 return -1;

  721.             trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;

  722.         }

  723.         if(stream_index == 0 && trk->entry == 0) {

  724.             mov_write_mdat_tag(pb, trk);

  725.             mov->time = Timestamp();

  726.         }

  727.         

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

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

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

  731.         trk->enc = enc;

  732.         trk->entry++;

  733.         if(sampleCount == 0)

  734.             trk->samples++;

  735.         else

  736.             trk->samples += sampleCount;

  737.         trk->mdat_size += size;

  738.     }

  739.     put_buffer(pb, buf, size);

  740. 

  741.     put_flush_packet(pb);

  742.     return 0;

  743. }

  744. 

  745. static int mov_write_trailer(AVFormatContext *s)

  746. {

  747.     MOVContext *mov = s->priv_data;

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

  749.     int res = 0;

  750.     int i, j;

  751.     offset_t file_size;

  752. 

  753.     file_size = url_ftell(pb);

  754.     j = 0;

  755. 

  756.     /* Write size of mdat tag */

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

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

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

  760.         }

  761.     }

  762.     url_fseek(pb, mov->tracks[0].mdat_pos, SEEK_SET);

  763.     put_be32(pb, j+8);

  764.     url_fseek(pb, file_size, SEEK_SET);

  765. 

  766.     mov_write_moov_tag(pb, mov);

  767. 

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

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

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

  771.         }

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

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

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

  775.     }

  776.     put_flush_packet(pb);

  777. 

  778.     return res;

  779. }

  780. 

  781. static AVOutputFormat mov_oformat = {

  782.     "mov",

  783.     "mov format",

  784.     NULL,

  785.     "mov",

  786.     sizeof(MOVContext),

  787.     CODEC_ID_MP2,

  788.     CODEC_ID_MPEG4,

  789.     mov_write_header,

  790.     mov_write_packet,

  791.     mov_write_trailer,

  792. };

  793. 

  794. static AVOutputFormat _3gp_oformat = {

  795.     "3gp",

  796.     "3gp format",

  797.     NULL,

  798.     "3gp",

  799.     sizeof(MOVContext),

  800.     CODEC_ID_AMR_NB,

  801.     CODEC_ID_H263,

  802.     mov_write_header,

  803.     mov_write_packet,

  804.     mov_write_trailer,

  805. };

  806. 

  807. static AVOutputFormat mp4_oformat = {

  808.     "mp4",

  809.     "mp4 format",

  810.     NULL,

  811.     "mp4",

  812.     sizeof(MOVContext),

  813.     CODEC_ID_AAC,

  814.     CODEC_ID_MPEG4,

  815.     mov_write_header,

  816.     mov_write_packet,

  817.     mov_write_trailer,

  818. };

  819. 

  820. int movenc_init(void)

  821. {

  822.     av_register_output_format(&mov_oformat);

  823.     av_register_output_format(&_3gp_oformat);

  824.     av_register_output_format(&mp4_oformat);

  825.     return 0;

  826. }