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.

1564 lines
46KB

  1. /*
  2. * MOV, 3GP, MP4 encoder.
  3. * Copyright (c) 2003 Thomas Raivio.
  4. * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>.
  5. *
  6. * This library is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2 of the License, or (at your option) any later version.
  10. *
  11. * This library is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with this library; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. #include "avformat.h"
  21. #include "avi.h"
  22. #include "avio.h"
  23. #undef NDEBUG
  24. #include <assert.h>
  25. #define MOV_INDEX_CLUSTER_SIZE 16384
  26. #define globalTimescale 1000
  27. #define MODE_MP4 0
  28. #define MODE_MOV 1
  29. #define MODE_3GP 2
  30. #define MODE_PSP 3 // example working PSP command line:
  31. // ffmpeg -i testinput.avi -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4
  32. #define MODE_3G2 4
  33. typedef struct MOVIentry {
  34. unsigned int flags, pos, size;
  35. unsigned int samplesInChunk;
  36. char key_frame;
  37. unsigned int entries;
  38. } MOVIentry;
  39. typedef struct MOVIndex {
  40. int mode;
  41. int entry;
  42. int mdat_size;
  43. int ents_allocated;
  44. long timescale;
  45. long time;
  46. long trackDuration;
  47. long sampleCount;
  48. long sampleDuration;
  49. int hasKeyframes;
  50. int trackID;
  51. AVCodecContext *enc;
  52. int vosLen;
  53. uint8_t *vosData;
  54. MOVIentry** cluster;
  55. } MOVTrack;
  56. typedef struct MOVContext {
  57. int mode;
  58. long time;
  59. int nb_streams;
  60. int mdat_written;
  61. offset_t mdat_pos;
  62. long timescale;
  63. MOVTrack tracks[MAX_STREAMS];
  64. } MOVContext;
  65. static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track);
  66. const CodecTag ff_mov_obj_type[] = {
  67. { CODEC_ID_MPEG4 , 32 },
  68. { CODEC_ID_AAC , 64 },
  69. { CODEC_ID_MPEG1VIDEO, 106 },
  70. { CODEC_ID_MPEG2VIDEO, 96 },//mpeg2 profiles
  71. { CODEC_ID_MP2 , 107 },//FIXME mpeg2 mpeg audio -> 105
  72. { CODEC_ID_MP3 , 107 },//FIXME mpeg2 mpeg audio -> 105
  73. { CODEC_ID_H264 , 241 },
  74. { CODEC_ID_H263 , 242 },
  75. { CODEC_ID_H261 , 243 },
  76. { CODEC_ID_MJPEG , 108 },
  77. { CODEC_ID_PCM_S16LE , 224 },
  78. { CODEC_ID_VORBIS , 225 },
  79. { CODEC_ID_AC3 , 226 },
  80. { CODEC_ID_PCM_ALAW , 227 },
  81. { CODEC_ID_PCM_MULAW , 228 },
  82. { CODEC_ID_PCM_S16BE , 230 },
  83. { 0,0 },
  84. };
  85. //FIXME supprt 64bit varaint with wide placeholders
  86. static int updateSize (ByteIOContext *pb, int pos)
  87. {
  88. long curpos = url_ftell(pb);
  89. url_fseek(pb, pos, SEEK_SET);
  90. put_be32(pb, curpos - pos); /* rewrite size */
  91. url_fseek(pb, curpos, SEEK_SET);
  92. return curpos - pos;
  93. }
  94. /* Chunk offset atom */
  95. static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack* track)
  96. {
  97. int i;
  98. int pos = url_ftell(pb);
  99. put_be32(pb, 0); /* size */
  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. put_be32(pb, track->cluster[cl][id].pos);
  107. }
  108. return updateSize (pb, pos);
  109. }
  110. /* Sample size atom */
  111. static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack* track)
  112. {
  113. int equalChunks = 1;
  114. int i, j, entries = 0, tst = -1, oldtst = -1;
  115. int pos = url_ftell(pb);
  116. put_be32(pb, 0); /* size */
  117. put_tag(pb, "stsz");
  118. put_be32(pb, 0); /* version & flags */
  119. for (i=0; i<track->entry; i++) {
  120. int cl = i / MOV_INDEX_CLUSTER_SIZE;
  121. int id = i % MOV_INDEX_CLUSTER_SIZE;
  122. tst = track->cluster[cl][id].size/track->cluster[cl][id].entries;
  123. if(oldtst != -1 && tst != oldtst) {
  124. equalChunks = 0;
  125. }
  126. oldtst = tst;
  127. entries += track->cluster[cl][id].entries;
  128. }
  129. if (equalChunks) {
  130. int sSize = track->cluster[0][0].size/track->cluster[0][0].entries;
  131. put_be32(pb, sSize); // sample size
  132. put_be32(pb, entries); // sample count
  133. }
  134. else {
  135. put_be32(pb, 0); // sample size
  136. put_be32(pb, entries); // sample count
  137. for (i=0; i<track->entry; i++) {
  138. int cl = i / MOV_INDEX_CLUSTER_SIZE;
  139. int id = i % MOV_INDEX_CLUSTER_SIZE;
  140. for ( j=0; j<track->cluster[cl][id].entries; j++) {
  141. put_be32(pb, track->cluster[cl][id].size /
  142. track->cluster[cl][id].entries);
  143. }
  144. }
  145. }
  146. return updateSize (pb, pos);
  147. }
  148. /* Sample to chunk atom */
  149. static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack* track)
  150. {
  151. int index = 0, oldval = -1, i, entryPos, curpos;
  152. int pos = url_ftell(pb);
  153. put_be32(pb, 0); /* size */
  154. put_tag(pb, "stsc");
  155. put_be32(pb, 0); // version & flags
  156. entryPos = url_ftell(pb);
  157. put_be32(pb, track->entry); // entry count
  158. for (i=0; i<track->entry; i++) {
  159. int cl = i / MOV_INDEX_CLUSTER_SIZE;
  160. int id = i % MOV_INDEX_CLUSTER_SIZE;
  161. if(oldval != track->cluster[cl][id].samplesInChunk)
  162. {
  163. put_be32(pb, i+1); // first chunk
  164. put_be32(pb, track->cluster[cl][id].samplesInChunk); // samples per chunk
  165. put_be32(pb, 0x1); // sample description index
  166. oldval = track->cluster[cl][id].samplesInChunk;
  167. index++;
  168. }
  169. }
  170. curpos = url_ftell(pb);
  171. url_fseek(pb, entryPos, SEEK_SET);
  172. put_be32(pb, index); // rewrite size
  173. url_fseek(pb, curpos, SEEK_SET);
  174. return updateSize (pb, pos);
  175. }
  176. /* Sync sample atom */
  177. static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack* track)
  178. {
  179. long curpos;
  180. int i, index = 0, entryPos;
  181. int pos = url_ftell(pb);
  182. put_be32(pb, 0); // size
  183. put_tag(pb, "stss");
  184. put_be32(pb, 0); // version & flags
  185. entryPos = url_ftell(pb);
  186. put_be32(pb, track->entry); // entry count
  187. for (i=0; i<track->entry; i++) {
  188. int cl = i / MOV_INDEX_CLUSTER_SIZE;
  189. int id = i % MOV_INDEX_CLUSTER_SIZE;
  190. if(track->cluster[cl][id].key_frame == 1) {
  191. put_be32(pb, i+1);
  192. index++;
  193. }
  194. }
  195. curpos = url_ftell(pb);
  196. url_fseek(pb, entryPos, SEEK_SET);
  197. put_be32(pb, index); // rewrite size
  198. url_fseek(pb, curpos, SEEK_SET);
  199. return updateSize (pb, pos);
  200. }
  201. static int mov_write_damr_tag(ByteIOContext *pb)
  202. {
  203. put_be32(pb, 0x11); /* size */
  204. put_tag(pb, "damr");
  205. put_tag(pb, "FFMP");
  206. put_byte(pb, 0);
  207. put_be16(pb, 0x80); /* Mode set (all modes for AMR_NB) */
  208. put_be16(pb, 0xa); /* Mode change period (no restriction) */
  209. //put_be16(pb, 0x81ff); /* Mode set (all modes for AMR_NB) */
  210. //put_be16(pb, 1); /* Mode change period (no restriction) */
  211. return 0x11;
  212. }
  213. static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack* track)
  214. {
  215. int pos = url_ftell(pb);
  216. put_be32(pb, 0); /* size */
  217. put_tag(pb, "wave");
  218. put_be32(pb, 12); /* size */
  219. put_tag(pb, "frma");
  220. put_tag(pb, "mp4a");
  221. put_be32(pb, 12); /* size */
  222. put_tag(pb, "mp4a");
  223. put_be32(pb, 0);
  224. mov_write_esds_tag(pb, track);
  225. put_be32(pb, 12); /* size */
  226. put_tag(pb, "srcq");
  227. put_be32(pb, 0x40);
  228. put_be32(pb, 8); /* size */
  229. put_be32(pb, 0); /* null tag */
  230. return updateSize (pb, pos);
  231. }
  232. const CodecTag codec_movaudio_tags[] = {
  233. { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') },
  234. { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') },
  235. { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') },
  236. { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') },
  237. { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') },
  238. { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') },
  239. { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') },
  240. { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') },
  241. { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') },
  242. { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') },
  243. { 0, 0 },
  244. };
  245. static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack* track)
  246. {
  247. int pos = url_ftell(pb);
  248. int tag;
  249. put_be32(pb, 0); /* size */
  250. tag = track->enc->codec_tag;
  251. if (!tag)
  252. tag = codec_get_tag(codec_movaudio_tags, track->enc->codec_id);
  253. // if no mac fcc found, try with Microsoft tags
  254. if (!tag)
  255. {
  256. int tmp = codec_get_tag(codec_wav_tags, track->enc->codec_id);
  257. tag = MKTAG('m', 's', ((tmp >> 8) & 0xff), (tmp & 0xff));
  258. }
  259. put_le32(pb, tag); // store it byteswapped
  260. put_be32(pb, 0); /* Reserved */
  261. put_be16(pb, 0); /* Reserved */
  262. put_be16(pb, 1); /* Data-reference index, XXX == 1 */
  263. /* SoundDescription */
  264. if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)
  265. put_be16(pb, 1); /* Version 1 */
  266. else
  267. put_be16(pb, 0); /* Version 0 */
  268. put_be16(pb, 0); /* Revision level */
  269. put_be32(pb, 0); /* Reserved */
  270. put_be16(pb, track->enc->channels); /* Number of channels */
  271. /* TODO: Currently hard-coded to 16-bit, there doesn't seem
  272. to be a good way to get number of bits of audio */
  273. put_be16(pb, 0x10); /* Reserved */
  274. if(track->enc->codec_id == CODEC_ID_AAC ||
  275. track->enc->codec_id == CODEC_ID_MP3)
  276. {
  277. put_be16(pb, 0xfffe); /* compression ID (vbr)*/
  278. }
  279. else
  280. {
  281. put_be16(pb, 0); /* compression ID (= 0) */
  282. }
  283. put_be16(pb, 0); /* packet size (= 0) */
  284. put_be16(pb, track->timescale); /* Time scale */
  285. put_be16(pb, 0); /* Reserved */
  286. if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)
  287. {
  288. /* SoundDescription V1 extended info */
  289. put_be32(pb, track->enc->frame_size); /* Samples per packet */
  290. put_be32(pb, 1536); /* Bytes per packet */
  291. put_be32(pb, 2); /* Bytes per frame */
  292. put_be32(pb, 2); /* Bytes per sample */
  293. }
  294. if(track->enc->codec_id == CODEC_ID_AAC) {
  295. if( track->mode == MODE_MOV ) mov_write_wave_tag(pb, track);
  296. else mov_write_esds_tag(pb, track);
  297. }
  298. if(track->enc->codec_id == CODEC_ID_AMR_NB)
  299. mov_write_damr_tag(pb);
  300. return updateSize (pb, pos);
  301. }
  302. static int mov_write_d263_tag(ByteIOContext *pb)
  303. {
  304. put_be32(pb, 0xf); /* size */
  305. put_tag(pb, "d263");
  306. put_tag(pb, "FFMP");
  307. put_be16(pb, 0x0a);
  308. put_byte(pb, 0);
  309. return 0xf;
  310. }
  311. /* TODO: No idea about these values */
  312. static int mov_write_svq3_tag(ByteIOContext *pb)
  313. {
  314. put_be32(pb, 0x15);
  315. put_tag(pb, "SMI ");
  316. put_tag(pb, "SEQH");
  317. put_be32(pb, 0x5);
  318. put_be32(pb, 0xe2c0211d);
  319. put_be32(pb, 0xc0000000);
  320. put_byte(pb, 0);
  321. return 0x15;
  322. }
  323. static unsigned int descrLength(unsigned int len)
  324. {
  325. if (len < 0x00000080)
  326. return 2 + len;
  327. else if (len < 0x00004000)
  328. return 3 + len;
  329. else if(len < 0x00200000)
  330. return 4 + len;
  331. else
  332. return 5 + len;
  333. }
  334. static void putDescr(ByteIOContext *pb, int tag, int size)
  335. {
  336. uint32_t len;
  337. uint8_t vals[4];
  338. len = size;
  339. vals[3] = (uint8_t)(len & 0x7f);
  340. len >>= 7;
  341. vals[2] = (uint8_t)((len & 0x7f) | 0x80);
  342. len >>= 7;
  343. vals[1] = (uint8_t)((len & 0x7f) | 0x80);
  344. len >>= 7;
  345. vals[0] = (uint8_t)((len & 0x7f) | 0x80);
  346. put_byte(pb, tag); // DescriptorTag
  347. if (size < 0x00000080)
  348. {
  349. put_byte(pb, vals[3]);
  350. }
  351. else if (size < 0x00004000)
  352. {
  353. put_byte(pb, vals[2]);
  354. put_byte(pb, vals[3]);
  355. }
  356. else if (size < 0x00200000)
  357. {
  358. put_byte(pb, vals[1]);
  359. put_byte(pb, vals[2]);
  360. put_byte(pb, vals[3]);
  361. }
  362. else if (size < 0x10000000)
  363. {
  364. put_byte(pb, vals[0]);
  365. put_byte(pb, vals[1]);
  366. put_byte(pb, vals[2]);
  367. put_byte(pb, vals[3]);
  368. }
  369. }
  370. static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track) // Basic
  371. {
  372. int decoderSpecificInfoLen;
  373. int pos = url_ftell(pb);
  374. void *vosDataBackup=track->vosData;
  375. int vosLenBackup=track->vosLen;
  376. // we should be able to have these passed in, via vosData, then we wouldn't need to attack this routine at all
  377. static const char PSPAACData[]={0x13,0x10};
  378. static const char PSPMP4Data[]={0x00,0x00,0x01,0xB0,0x03,0x00,0x00,0x01,0xB5,0x09,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x20,0x00,0x84,0x5D,0x4C,0x28,0x50,0x20,0xF0,0xA3,0x1F };
  379. if (track->mode == MODE_PSP) // fails on psp if this is not here
  380. {
  381. if (track->enc->codec_id == CODEC_ID_AAC)
  382. {
  383. track->vosLen = 2;
  384. track->vosData = PSPAACData;
  385. }
  386. if (track->enc->codec_id == CODEC_ID_MPEG4)
  387. {
  388. track->vosLen = 28;
  389. track->vosData = PSPMP4Data;
  390. }
  391. }
  392. decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;
  393. put_be32(pb, 0); // size
  394. put_tag(pb, "esds");
  395. put_be32(pb, 0); // Version
  396. // ES descriptor
  397. putDescr(pb, 0x03, 3 + descrLength(13 + decoderSpecificInfoLen) +
  398. descrLength(1));
  399. put_be16(pb, track->trackID);
  400. put_byte(pb, 0x00); // flags (= no flags)
  401. // DecoderConfig descriptor
  402. putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);
  403. // Object type indication
  404. put_byte(pb, codec_get_tag(ff_mov_obj_type, track->enc->codec_id));
  405. if(track->enc->codec_type == CODEC_TYPE_AUDIO)
  406. put_byte(pb, 0x15); // flags (= Audiostream)
  407. else
  408. put_byte(pb, 0x11); // flags (= Visualstream)
  409. put_byte(pb, track->enc->rc_buffer_size>>(3+16)); // Buffersize DB (24 bits)
  410. put_be16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF); // Buffersize DB
  411. put_be32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window)
  412. if(track->enc->rc_max_rate != track->enc->rc_min_rate || track->enc->rc_min_rate==0)
  413. put_be32(pb, 0); // vbr
  414. else
  415. put_be32(pb, track->enc->rc_max_rate); // avg bitrate
  416. if (track->vosLen)
  417. {
  418. // DecoderSpecific info descriptor
  419. putDescr(pb, 0x05, track->vosLen);
  420. put_buffer(pb, track->vosData, track->vosLen);
  421. }
  422. track->vosData = vosDataBackup;
  423. track->vosLen = vosLenBackup;
  424. // SL descriptor
  425. putDescr(pb, 0x06, 1);
  426. put_byte(pb, 0x02);
  427. return updateSize (pb, pos);
  428. }
  429. const CodecTag codec_movvideo_tags[] = {
  430. { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') },
  431. { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') },
  432. { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
  433. { CODEC_ID_H263, MKTAG('s', '2', '6', '3') },
  434. { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') },
  435. { 0, 0 },
  436. };
  437. static int mov_write_video_tag(ByteIOContext *pb, MOVTrack* track)
  438. {
  439. int pos = url_ftell(pb);
  440. char compressor_name[32];
  441. int tag;
  442. put_be32(pb, 0); /* size */
  443. tag = track->enc->codec_tag;
  444. if (!tag)
  445. tag = codec_get_tag(codec_movvideo_tags, track->enc->codec_id);
  446. // if no mac fcc found, try with Microsoft tags
  447. if (!tag)
  448. tag = codec_get_tag(codec_bmp_tags, track->enc->codec_id);
  449. put_le32(pb, tag); // store it byteswapped
  450. put_be32(pb, 0); /* Reserved */
  451. put_be16(pb, 0); /* Reserved */
  452. put_be16(pb, 1); /* Data-reference index */
  453. put_be16(pb, 0); /* Codec stream version */
  454. put_be16(pb, 0); /* Codec stream revision (=0) */
  455. put_tag(pb, "FFMP"); /* Vendor */
  456. if(track->enc->codec_id == CODEC_ID_RAWVIDEO) {
  457. put_be32(pb, 0); /* Temporal Quality */
  458. put_be32(pb, 0x400); /* Spatial Quality = lossless*/
  459. } else {
  460. put_be32(pb, 0x200); /* Temporal Quality = normal */
  461. put_be32(pb, 0x200); /* Spatial Quality = normal */
  462. }
  463. put_be16(pb, track->enc->width); /* Video width */
  464. put_be16(pb, track->enc->height); /* Video height */
  465. put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */
  466. put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */
  467. put_be32(pb, 0); /* Data size (= 0) */
  468. put_be16(pb, 1); /* Frame count (= 1) */
  469. memset(compressor_name,0,32);
  470. if (track->enc->codec && track->enc->codec->name)
  471. strncpy(compressor_name,track->enc->codec->name,31);
  472. put_byte(pb, strlen(compressor_name));
  473. put_buffer(pb, compressor_name, 31);
  474. put_be16(pb, 0x18); /* Reserved */
  475. put_be16(pb, 0xffff); /* Reserved */
  476. if(track->enc->codec_id == CODEC_ID_MPEG4)
  477. mov_write_esds_tag(pb, track);
  478. else if(track->enc->codec_id == CODEC_ID_H263)
  479. mov_write_d263_tag(pb);
  480. else if(track->enc->codec_id == CODEC_ID_SVQ3)
  481. mov_write_svq3_tag(pb);
  482. return updateSize (pb, pos);
  483. }
  484. static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack* track)
  485. {
  486. int pos = url_ftell(pb);
  487. put_be32(pb, 0); /* size */
  488. put_tag(pb, "stsd");
  489. put_be32(pb, 0); /* version & flags */
  490. put_be32(pb, 1); /* entry count */
  491. if (track->enc->codec_type == CODEC_TYPE_VIDEO)
  492. mov_write_video_tag(pb, track);
  493. else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
  494. mov_write_audio_tag(pb, track);
  495. return updateSize(pb, pos);
  496. }
  497. /* TODO: */
  498. /* Time to sample atom */
  499. static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack* track)
  500. {
  501. put_be32(pb, 0x18); /* size */
  502. put_tag(pb, "stts");
  503. put_be32(pb, 0); /* version & flags */
  504. put_be32(pb, 1); /* entry count */
  505. put_be32(pb, track->sampleCount); /* sample count */
  506. put_be32(pb, track->sampleDuration); /* sample duration */
  507. return 0x18;
  508. }
  509. static int mov_write_dref_tag(ByteIOContext *pb)
  510. {
  511. put_be32(pb, 28); /* size */
  512. put_tag(pb, "dref");
  513. put_be32(pb, 0); /* version & flags */
  514. put_be32(pb, 1); /* entry count */
  515. put_be32(pb, 0xc); /* size */
  516. put_tag(pb, "url ");
  517. put_be32(pb, 1); /* version & flags */
  518. return 28;
  519. }
  520. static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack* track)
  521. {
  522. int pos = url_ftell(pb);
  523. put_be32(pb, 0); /* size */
  524. put_tag(pb, "stbl");
  525. mov_write_stsd_tag(pb, track);
  526. mov_write_stts_tag(pb, track);
  527. if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
  528. track->hasKeyframes)
  529. mov_write_stss_tag(pb, track);
  530. mov_write_stsc_tag(pb, track);
  531. mov_write_stsz_tag(pb, track);
  532. mov_write_stco_tag(pb, track);
  533. return updateSize(pb, pos);
  534. }
  535. static int mov_write_dinf_tag(ByteIOContext *pb)
  536. {
  537. int pos = url_ftell(pb);
  538. put_be32(pb, 0); /* size */
  539. put_tag(pb, "dinf");
  540. mov_write_dref_tag(pb);
  541. return updateSize(pb, pos);
  542. }
  543. static int mov_write_smhd_tag(ByteIOContext *pb)
  544. {
  545. put_be32(pb, 16); /* size */
  546. put_tag(pb, "smhd");
  547. put_be32(pb, 0); /* version & flags */
  548. put_be16(pb, 0); /* reserved (balance, normally = 0) */
  549. put_be16(pb, 0); /* reserved */
  550. return 16;
  551. }
  552. static int mov_write_vmhd_tag(ByteIOContext *pb)
  553. {
  554. put_be32(pb, 0x14); /* size (always 0x14) */
  555. put_tag(pb, "vmhd");
  556. put_be32(pb, 0x01); /* version & flags */
  557. put_be64(pb, 0); /* reserved (graphics mode = copy) */
  558. return 0x14;
  559. }
  560. static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack* track)
  561. {
  562. char *descr, *hdlr, *hdlr_type;
  563. int pos = url_ftell(pb);
  564. if (!track) { /* no media --> data handler */
  565. hdlr = "dhlr";
  566. hdlr_type = "url ";
  567. descr = "DataHandler";
  568. } else {
  569. hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
  570. if (track->enc->codec_type == CODEC_TYPE_VIDEO) {
  571. hdlr_type = "vide";
  572. descr = "VideoHandler";
  573. } else {
  574. hdlr_type = "soun";
  575. descr = "SoundHandler";
  576. }
  577. }
  578. put_be32(pb, 0); /* size */
  579. put_tag(pb, "hdlr");
  580. put_be32(pb, 0); /* Version & flags */
  581. put_buffer(pb, hdlr, 4); /* handler */
  582. put_tag(pb, hdlr_type); /* handler type */
  583. put_be32(pb ,0); /* reserved */
  584. put_be32(pb ,0); /* reserved */
  585. put_be32(pb ,0); /* reserved */
  586. put_byte(pb, strlen(descr)); /* string counter */
  587. put_buffer(pb, descr, strlen(descr)); /* handler description */
  588. return updateSize(pb, pos);
  589. }
  590. static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack* track)
  591. {
  592. int pos = url_ftell(pb);
  593. put_be32(pb, 0); /* size */
  594. put_tag(pb, "minf");
  595. if(track->enc->codec_type == CODEC_TYPE_VIDEO)
  596. mov_write_vmhd_tag(pb);
  597. else
  598. mov_write_smhd_tag(pb);
  599. if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
  600. mov_write_hdlr_tag(pb, NULL);
  601. mov_write_dinf_tag(pb);
  602. mov_write_stbl_tag(pb, track);
  603. return updateSize(pb, pos);
  604. }
  605. static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack* track)
  606. {
  607. put_be32(pb, 32); /* size */
  608. put_tag(pb, "mdhd");
  609. put_be32(pb, 0); /* Version & flags */
  610. put_be32(pb, track->time); /* creation time */
  611. put_be32(pb, track->time); /* modification time */
  612. put_be32(pb, track->timescale); /* time scale (sample rate for audio) */
  613. put_be32(pb, track->trackDuration); /* duration */
  614. put_be16(pb, 0); /* language, 0 = english */
  615. put_be16(pb, 0); /* reserved (quality) */
  616. return 32;
  617. }
  618. static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack* track)
  619. {
  620. int pos = url_ftell(pb);
  621. put_be32(pb, 0); /* size */
  622. put_tag(pb, "mdia");
  623. mov_write_mdhd_tag(pb, track);
  624. mov_write_hdlr_tag(pb, track);
  625. mov_write_minf_tag(pb, track);
  626. return updateSize(pb, pos);
  627. }
  628. static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack* track)
  629. {
  630. put_be32(pb, 0x5c); /* size (always 0x5c) */
  631. put_tag(pb, "tkhd");
  632. put_be32(pb, 0xf); /* version & flags (track enabled) */
  633. put_be32(pb, track->time); /* creation time */
  634. put_be32(pb, track->time); /* modification time */
  635. put_be32(pb, track->trackID); /* track-id */
  636. put_be32(pb, 0); /* reserved */
  637. put_be32(pb, av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP)); /* duration */
  638. put_be32(pb, 0); /* reserved */
  639. put_be32(pb, 0); /* reserved */
  640. put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
  641. /* Volume, only for audio */
  642. if(track->enc->codec_type == CODEC_TYPE_AUDIO)
  643. put_be16(pb, 0x0100);
  644. else
  645. put_be16(pb, 0);
  646. put_be16(pb, 0); /* reserved */
  647. /* Matrix structure */
  648. put_be32(pb, 0x00010000); /* reserved */
  649. put_be32(pb, 0x0); /* reserved */
  650. put_be32(pb, 0x0); /* reserved */
  651. put_be32(pb, 0x0); /* reserved */
  652. put_be32(pb, 0x00010000); /* reserved */
  653. put_be32(pb, 0x0); /* reserved */
  654. put_be32(pb, 0x0); /* reserved */
  655. put_be32(pb, 0x0); /* reserved */
  656. put_be32(pb, 0x40000000); /* reserved */
  657. /* Track width and height, for visual only */
  658. if(track->enc->codec_type == CODEC_TYPE_VIDEO) {
  659. double sample_aspect_ratio = av_q2d(track->enc->sample_aspect_ratio);
  660. if( !sample_aspect_ratio ) sample_aspect_ratio = 1;
  661. put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
  662. put_be32(pb, track->enc->height*0x10000);
  663. }
  664. else {
  665. put_be32(pb, 0);
  666. put_be32(pb, 0);
  667. }
  668. return 0x5c;
  669. }
  670. // This box seems important for the psp playback ... without it the movie seems to hang
  671. static int mov_write_edts_tag(ByteIOContext *pb, MOVTrack *track)
  672. {
  673. put_be32(pb, 0x24); /* size */
  674. put_tag(pb, "edts");
  675. put_be32(pb, 0x1c); /* size */
  676. put_tag(pb, "elst");
  677. put_be32(pb, 0x0);
  678. put_be32(pb, 0x1);
  679. put_be32(pb, av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP)); /* duration ... doesn't seem to effect psp */
  680. put_be32(pb, 0x0);
  681. put_be32(pb, 0x00010000);
  682. return 0x24;
  683. }
  684. // goes at the end of each track! ... Critical for PSP playback ("Incompatible data" without it)
  685. static int mov_write_uuid_tag_psp(ByteIOContext *pb, MOVTrack *mov)
  686. {
  687. put_be32(pb, 0x34); /* size ... reports as 28 in mp4box! */
  688. put_tag(pb, "uuid");
  689. put_tag(pb, "USMT");
  690. put_be32(pb, 0x21d24fce);
  691. put_be32(pb, 0xbb88695c);
  692. put_be32(pb, 0xfac9c740);
  693. put_be32(pb, 0x1c); // another size here!
  694. put_tag(pb, "MTDT");
  695. put_be32(pb, 0x00010012);
  696. put_be32(pb, 0x0a);
  697. put_be32(pb, 0x55c40000);
  698. put_be32(pb, 0x1);
  699. put_be32(pb, 0x0);
  700. return 0x34;
  701. }
  702. static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack* track)
  703. {
  704. int pos = url_ftell(pb);
  705. put_be32(pb, 0); /* size */
  706. put_tag(pb, "trak");
  707. mov_write_tkhd_tag(pb, track);
  708. if (track->mode == MODE_PSP)
  709. mov_write_edts_tag(pb, track); // PSP Movies require edts box
  710. mov_write_mdia_tag(pb, track);
  711. if (track->mode == MODE_PSP)
  712. mov_write_uuid_tag_psp(pb,track); // PSP Movies require this uuid box
  713. return updateSize(pb, pos);
  714. }
  715. #if 0
  716. /* TODO: Not sorted out, but not necessary either */
  717. static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
  718. {
  719. put_be32(pb, 0x15); /* size */
  720. put_tag(pb, "iods");
  721. put_be32(pb, 0); /* version & flags */
  722. put_be16(pb, 0x1007);
  723. put_byte(pb, 0);
  724. put_be16(pb, 0x4fff);
  725. put_be16(pb, 0xfffe);
  726. put_be16(pb, 0x01ff);
  727. return 0x15;
  728. }
  729. #endif
  730. static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
  731. {
  732. int maxTrackID = 1, maxTrackLen = 0, i;
  733. int64_t maxTrackLenTemp;
  734. put_be32(pb, 0x6c); /* size (always 0x6c) */
  735. put_tag(pb, "mvhd");
  736. put_be32(pb, 0); /* version & flags */
  737. put_be32(pb, mov->time); /* creation time */
  738. put_be32(pb, mov->time); /* modification time */
  739. put_be32(pb, mov->timescale); /* timescale */
  740. for (i=0; i<MAX_STREAMS; i++) {
  741. if(mov->tracks[i].entry > 0) {
  742. maxTrackLenTemp = av_rescale_rnd(mov->tracks[i].trackDuration, globalTimescale, mov->tracks[i].timescale, AV_ROUND_UP);
  743. if(maxTrackLen < maxTrackLenTemp)
  744. maxTrackLen = maxTrackLenTemp;
  745. if(maxTrackID < mov->tracks[i].trackID)
  746. maxTrackID = mov->tracks[i].trackID;
  747. }
  748. }
  749. put_be32(pb, maxTrackLen); /* duration of longest track */
  750. put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
  751. put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
  752. put_be16(pb, 0); /* reserved */
  753. put_be32(pb, 0); /* reserved */
  754. put_be32(pb, 0); /* reserved */
  755. /* Matrix structure */
  756. put_be32(pb, 0x00010000); /* reserved */
  757. put_be32(pb, 0x0); /* reserved */
  758. put_be32(pb, 0x0); /* reserved */
  759. put_be32(pb, 0x0); /* reserved */
  760. put_be32(pb, 0x00010000); /* reserved */
  761. put_be32(pb, 0x0); /* reserved */
  762. put_be32(pb, 0x0); /* reserved */
  763. put_be32(pb, 0x0); /* reserved */
  764. put_be32(pb, 0x40000000); /* reserved */
  765. put_be32(pb, 0); /* reserved (preview time) */
  766. put_be32(pb, 0); /* reserved (preview duration) */
  767. put_be32(pb, 0); /* reserved (poster time) */
  768. put_be32(pb, 0); /* reserved (selection time) */
  769. put_be32(pb, 0); /* reserved (selection duration) */
  770. put_be32(pb, 0); /* reserved (current time) */
  771. put_be32(pb, maxTrackID+1); /* Next track id */
  772. return 0x6c;
  773. }
  774. static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext* mov,
  775. AVFormatContext *s)
  776. {
  777. int pos = url_ftell(pb);
  778. put_be32(pb, 0); /* size */
  779. put_tag(pb, "hdlr");
  780. put_be32(pb, 0);
  781. put_be32(pb, 0);
  782. put_tag(pb, "mdir");
  783. put_tag(pb, "appl");
  784. put_be32(pb, 0);
  785. put_be32(pb, 0);
  786. put_be16(pb, 0);
  787. return updateSize(pb, pos);
  788. }
  789. /* helper function to write a data tag with the specified string as data */
  790. static int mov_write_string_data_tag(ByteIOContext *pb, MOVContext* mov,
  791. AVFormatContext *s, const char *data)
  792. {
  793. int pos = url_ftell(pb);
  794. put_be32(pb, 0); /* size */
  795. put_tag(pb, "data");
  796. put_be32(pb, 1);
  797. put_be32(pb, 0);
  798. put_buffer(pb, data, strlen(data));
  799. return updateSize(pb, pos);
  800. }
  801. /* iTunes name of the song/movie */
  802. static int mov_write_nam_tag(ByteIOContext *pb, MOVContext* mov,
  803. AVFormatContext *s)
  804. {
  805. int size = 0;
  806. if ( s->title[0] ) {
  807. int pos = url_ftell(pb);
  808. put_be32(pb, 0); /* size */
  809. put_tag(pb, "\251nam");
  810. mov_write_string_data_tag(pb, mov, s, s->title);
  811. size = updateSize(pb, pos);
  812. }
  813. return size;
  814. }
  815. /* iTunes name of the artist/performer */
  816. static int mov_write_ART_tag(ByteIOContext *pb, MOVContext* mov,
  817. AVFormatContext *s)
  818. {
  819. int size = 0;
  820. if ( s->author[0] ) {
  821. int pos = url_ftell(pb);
  822. put_be32(pb, 0); /* size */
  823. put_tag(pb, "\251ART");
  824. // we use the author here as this is the only thing that we have...
  825. mov_write_string_data_tag(pb, mov, s, s->author);
  826. size = updateSize(pb, pos);
  827. }
  828. return size;
  829. }
  830. /* iTunes name of the writer */
  831. static int mov_write_wrt_tag(ByteIOContext *pb, MOVContext* mov,
  832. AVFormatContext *s)
  833. {
  834. int size = 0;
  835. if ( s->author[0] ) {
  836. int pos = url_ftell(pb);
  837. put_be32(pb, 0); /* size */
  838. put_tag(pb, "\251wrt");
  839. mov_write_string_data_tag(pb, mov, s, s->author);
  840. size = updateSize(pb, pos);
  841. }
  842. return size;
  843. }
  844. /* iTunes name of the album */
  845. static int mov_write_alb_tag(ByteIOContext *pb, MOVContext* mov,
  846. AVFormatContext *s)
  847. {
  848. int size = 0;
  849. if ( s->album[0] ) {
  850. int pos = url_ftell(pb);
  851. put_be32(pb, 0); /* size */
  852. put_tag(pb, "\251alb");
  853. mov_write_string_data_tag(pb, mov, s, s->album);
  854. size = updateSize(pb, pos);
  855. }
  856. return size;
  857. }
  858. /* iTunes year */
  859. static int mov_write_day_tag(ByteIOContext *pb, MOVContext* mov,
  860. AVFormatContext *s)
  861. {
  862. char year[5];
  863. int size = 0;
  864. if ( s->year ) {
  865. int pos = url_ftell(pb);
  866. put_be32(pb, 0); /* size */
  867. put_tag(pb, "\251day");
  868. snprintf(year, 5, "%04d", s->year);
  869. mov_write_string_data_tag(pb, mov, s, year);
  870. size = updateSize(pb, pos);
  871. }
  872. return size;
  873. }
  874. /* iTunes tool used to create the file */
  875. static int mov_write_too_tag(ByteIOContext *pb, MOVContext* mov,
  876. AVFormatContext *s)
  877. {
  878. int pos = url_ftell(pb);
  879. put_be32(pb, 0); /* size */
  880. put_tag(pb, "\251too");
  881. mov_write_string_data_tag(pb, mov, s, LIBAVFORMAT_IDENT);
  882. return updateSize(pb, pos);
  883. }
  884. /* iTunes comment */
  885. static int mov_write_cmt_tag(ByteIOContext *pb, MOVContext* mov,
  886. AVFormatContext *s)
  887. {
  888. int size = 0;
  889. if ( s->comment[0] ) {
  890. int pos = url_ftell(pb);
  891. put_be32(pb, 0); /* size */
  892. put_tag(pb, "\251cmt");
  893. mov_write_string_data_tag(pb, mov, s, s->comment);
  894. size = updateSize(pb, pos);
  895. }
  896. return size;
  897. }
  898. /* iTunes custom genre */
  899. static int mov_write_gen_tag(ByteIOContext *pb, MOVContext* mov,
  900. AVFormatContext *s)
  901. {
  902. int size = 0;
  903. if ( s->genre[0] ) {
  904. int pos = url_ftell(pb);
  905. put_be32(pb, 0); /* size */
  906. put_tag(pb, "\251gen");
  907. mov_write_string_data_tag(pb, mov, s, s->genre);
  908. size = updateSize(pb, pos);
  909. }
  910. return size;
  911. }
  912. /* iTunes track number */
  913. static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext* mov,
  914. AVFormatContext *s)
  915. {
  916. int size = 0;
  917. if ( s->track ) {
  918. int pos = url_ftell(pb);
  919. put_be32(pb, 0); /* size */
  920. put_tag(pb, "trkn");
  921. {
  922. int pos = url_ftell(pb);
  923. put_be32(pb, 0); /* size */
  924. put_tag(pb, "data");
  925. put_be32(pb, 0); // 8 bytes empty
  926. put_be32(pb, 0);
  927. put_be16(pb, 0); // empty
  928. put_be16(pb, s->track); // track number
  929. put_be16(pb, 0); // total track number
  930. put_be16(pb, 0); // empty
  931. updateSize(pb, pos);
  932. }
  933. size = updateSize(pb, pos);
  934. }
  935. return size;
  936. }
  937. /* iTunes meta data list */
  938. static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext* mov,
  939. AVFormatContext *s)
  940. {
  941. int pos = url_ftell(pb);
  942. put_be32(pb, 0); /* size */
  943. put_tag(pb, "ilst");
  944. mov_write_nam_tag(pb, mov, s);
  945. mov_write_ART_tag(pb, mov, s);
  946. mov_write_wrt_tag(pb, mov, s);
  947. mov_write_alb_tag(pb, mov, s);
  948. mov_write_day_tag(pb, mov, s);
  949. mov_write_too_tag(pb, mov, s);
  950. mov_write_cmt_tag(pb, mov, s);
  951. mov_write_gen_tag(pb, mov, s);
  952. mov_write_trkn_tag(pb, mov, s);
  953. return updateSize(pb, pos);
  954. }
  955. /* iTunes meta data tag */
  956. static int mov_write_meta_tag(ByteIOContext *pb, MOVContext* mov,
  957. AVFormatContext *s)
  958. {
  959. int size = 0;
  960. // only save meta tag if required
  961. if ( s->title[0] || s->author[0] || s->album[0] || s->year ||
  962. s->comment[0] || s->genre[0] || s->track ) {
  963. int pos = url_ftell(pb);
  964. put_be32(pb, 0); /* size */
  965. put_tag(pb, "meta");
  966. put_be32(pb, 0);
  967. mov_write_itunes_hdlr_tag(pb, mov, s);
  968. mov_write_ilst_tag(pb, mov, s);
  969. size = updateSize(pb, pos);
  970. }
  971. return size;
  972. }
  973. static int mov_write_udta_tag(ByteIOContext *pb, MOVContext* mov,
  974. AVFormatContext *s)
  975. {
  976. int pos = url_ftell(pb);
  977. int i;
  978. put_be32(pb, 0); /* size */
  979. put_tag(pb, "udta");
  980. /* iTunes meta data */
  981. mov_write_meta_tag(pb, mov, s);
  982. /* Requirements */
  983. for (i=0; i<MAX_STREAMS; i++) {
  984. if(mov->tracks[i].entry <= 0) continue;
  985. if (mov->tracks[i].enc->codec_id == CODEC_ID_AAC ||
  986. mov->tracks[i].enc->codec_id == CODEC_ID_MPEG4) {
  987. int pos = url_ftell(pb);
  988. put_be32(pb, 0); /* size */
  989. put_tag(pb, "\251req");
  990. put_be16(pb, sizeof("QuickTime 6.0 or greater") - 1);
  991. put_be16(pb, 0);
  992. put_buffer(pb, "QuickTime 6.0 or greater",
  993. sizeof("QuickTime 6.0 or greater") - 1);
  994. updateSize(pb, pos);
  995. break;
  996. }
  997. }
  998. /* Encoder */
  999. if(mov->tracks[0].enc && !(mov->tracks[0].enc->flags & CODEC_FLAG_BITEXACT))
  1000. {
  1001. int pos = url_ftell(pb);
  1002. put_be32(pb, 0); /* size */
  1003. put_tag(pb, "\251enc");
  1004. put_be16(pb, sizeof(LIBAVFORMAT_IDENT) - 1); /* string length */
  1005. put_be16(pb, 0);
  1006. put_buffer(pb, LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);
  1007. updateSize(pb, pos);
  1008. }
  1009. if( s->title[0] )
  1010. {
  1011. int pos = url_ftell(pb);
  1012. put_be32(pb, 0); /* size */
  1013. put_tag(pb, "\251nam");
  1014. put_be16(pb, strlen(s->title)); /* string length */
  1015. put_be16(pb, 0);
  1016. put_buffer(pb, s->title, strlen(s->title));
  1017. updateSize(pb, pos);
  1018. }
  1019. if( s->author[0] )
  1020. {
  1021. int pos = url_ftell(pb);
  1022. put_be32(pb, 0); /* size */
  1023. put_tag(pb, /*"\251aut"*/ "\251day" );
  1024. put_be16(pb, strlen(s->author)); /* string length */
  1025. put_be16(pb, 0);
  1026. put_buffer(pb, s->author, strlen(s->author));
  1027. updateSize(pb, pos);
  1028. }
  1029. if( s->comment[0] )
  1030. {
  1031. int pos = url_ftell(pb);
  1032. put_be32(pb, 0); /* size */
  1033. put_tag(pb, "\251des");
  1034. put_be16(pb, strlen(s->comment)); /* string length */
  1035. put_be16(pb, 0);
  1036. put_buffer(pb, s->comment, strlen(s->comment));
  1037. updateSize(pb, pos);
  1038. }
  1039. return updateSize(pb, pos);
  1040. }
  1041. static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
  1042. AVFormatContext *s)
  1043. {
  1044. int pos, i;
  1045. pos = url_ftell(pb);
  1046. put_be32(pb, 0); /* size placeholder*/
  1047. put_tag(pb, "moov");
  1048. mov->timescale = globalTimescale;
  1049. for (i=0; i<MAX_STREAMS; i++) {
  1050. if(mov->tracks[i].entry <= 0) continue;
  1051. if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO) {
  1052. mov->tracks[i].timescale = mov->tracks[i].enc->time_base.den;
  1053. mov->tracks[i].sampleDuration = mov->tracks[i].enc->time_base.num;
  1054. }
  1055. else if(mov->tracks[i].enc->codec_type == CODEC_TYPE_AUDIO) {
  1056. /* If AMR, track timescale = 8000, AMR_WB = 16000 */
  1057. if(mov->tracks[i].enc->codec_id == CODEC_ID_AMR_NB) {
  1058. mov->tracks[i].sampleDuration = 160; // Bytes per chunk
  1059. mov->tracks[i].timescale = 8000;
  1060. }
  1061. else {
  1062. mov->tracks[i].timescale = mov->tracks[i].enc->sample_rate;
  1063. mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_size;
  1064. }
  1065. }
  1066. mov->tracks[i].trackDuration =
  1067. mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;
  1068. mov->tracks[i].time = mov->time;
  1069. mov->tracks[i].trackID = i+1;
  1070. }
  1071. mov_write_mvhd_tag(pb, mov);
  1072. //mov_write_iods_tag(pb, mov);
  1073. for (i=0; i<MAX_STREAMS; i++) {
  1074. if(mov->tracks[i].entry > 0) {
  1075. mov_write_trak_tag(pb, &(mov->tracks[i]));
  1076. }
  1077. }
  1078. mov_write_udta_tag(pb, mov, s);
  1079. return updateSize(pb, pos);
  1080. }
  1081. int mov_write_mdat_tag(ByteIOContext *pb, MOVContext* mov)
  1082. {
  1083. mov->mdat_pos = url_ftell(pb);
  1084. put_be32(pb, 0); /* size placeholder*/
  1085. put_tag(pb, "mdat");
  1086. return 0;
  1087. }
  1088. /* TODO: This needs to be more general */
  1089. int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
  1090. {
  1091. MOVContext *mov = s->priv_data;
  1092. put_be32(pb, 0x14 ); /* size */
  1093. put_tag(pb, "ftyp");
  1094. if ( mov->mode == MODE_3GP )
  1095. put_tag(pb, "3gp4");
  1096. else if ( mov->mode == MODE_3G2 )
  1097. put_tag(pb, "3g2a");
  1098. else if ( mov->mode == MODE_PSP )
  1099. put_tag(pb, "MSNV");
  1100. else
  1101. put_tag(pb, "isom");
  1102. put_be32(pb, 0x200 );
  1103. if ( mov->mode == MODE_3GP )
  1104. put_tag(pb, "3gp4");
  1105. else if ( mov->mode == MODE_3G2 )
  1106. put_tag(pb, "3g2a");
  1107. else if ( mov->mode == MODE_PSP )
  1108. put_tag(pb, "MSNV");
  1109. else
  1110. put_tag(pb, "mp41");
  1111. return 0x14;
  1112. }
  1113. static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
  1114. {
  1115. int AudioRate = s->streams[1]->codec.sample_rate;
  1116. int FrameRate = ((s->streams[0]->codec.time_base.den) * (0x10000))/ (s->streams[0]->codec.time_base.num);
  1117. //printf("audiorate = %d\n",AudioRate);
  1118. //printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec.time_base.den,s->streams[0]->codec.time_base.num,FrameRate);
  1119. put_be32(pb, 0x94 ); /* size */
  1120. put_tag(pb, "uuid");
  1121. put_tag(pb, "PROF");
  1122. put_be32(pb, 0x21d24fce ); /* 96 bit UUID */
  1123. put_be32(pb, 0xbb88695c );
  1124. put_be32(pb, 0xfac9c740 );
  1125. put_be32(pb, 0x0 ); /* ? */
  1126. put_be32(pb, 0x3 ); /* 3 sections ? */
  1127. put_be32(pb, 0x14 ); /* size */
  1128. put_tag(pb, "FPRF");
  1129. put_be32(pb, 0x0 ); /* ? */
  1130. put_be32(pb, 0x0 ); /* ? */
  1131. put_be32(pb, 0x0 ); /* ? */
  1132. put_be32(pb, 0x2c ); /* size */
  1133. put_tag(pb, "APRF"); /* audio */
  1134. put_be32(pb, 0x0 );
  1135. put_be32(pb, 0x2 );
  1136. put_tag(pb, "mp4a");
  1137. put_be32(pb, 0x20f );
  1138. put_be32(pb, 0x0 );
  1139. put_be32(pb, 0x40 );
  1140. put_be32(pb, 0x40 );
  1141. put_be32(pb, AudioRate ); //24000 ... audio rate?
  1142. put_be32(pb, 0x2 );
  1143. put_be32(pb, 0x34 ); /* size */
  1144. put_tag(pb, "VPRF"); /* video */
  1145. put_be32(pb, 0x0 );
  1146. put_be32(pb, 0x1 );
  1147. put_tag(pb, "mp4v");
  1148. put_be32(pb, 0x103 );
  1149. put_be32(pb, 0x0 );
  1150. put_be32(pb, 0xc0 );
  1151. put_be32(pb, 0xc0 );
  1152. put_be32(pb, FrameRate); // was 0xefc29
  1153. put_be32(pb, FrameRate ); // was 0xefc29
  1154. put_be16(pb, s->streams[0]->codec.width);
  1155. put_be16(pb, s->streams[0]->codec.height);
  1156. put_be32(pb, 0x010001 );
  1157. }
  1158. static int mov_write_header(AVFormatContext *s)
  1159. {
  1160. ByteIOContext *pb = &s->pb;
  1161. MOVContext *mov = s->priv_data;
  1162. int i;
  1163. for(i=0; i<s->nb_streams; i++){
  1164. AVCodecContext *c= &s->streams[i]->codec;
  1165. if (c->codec_type == CODEC_TYPE_VIDEO){
  1166. if (!codec_get_tag(codec_movvideo_tags, c->codec_id)){
  1167. if(!codec_get_tag(codec_bmp_tags, c->codec_id))
  1168. return -1;
  1169. else
  1170. av_log(s, AV_LOG_INFO, "Warning, using MS style video codec tag, the file may be unplayable!\n");
  1171. }
  1172. }else if(c->codec_type == CODEC_TYPE_AUDIO){
  1173. if (!codec_get_tag(codec_movaudio_tags, c->codec_id)){
  1174. if(!codec_get_tag(codec_wav_tags, c->codec_id))
  1175. return -1;
  1176. else
  1177. av_log(s, AV_LOG_INFO, "Warning, using MS style audio codec tag, the file may be unplayable!\n");
  1178. }
  1179. }
  1180. }
  1181. /* Default mode == MP4 */
  1182. mov->mode = MODE_MP4;
  1183. if (s->oformat != NULL) {
  1184. if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP;
  1185. else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3G2;
  1186. else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;
  1187. else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;
  1188. if ( mov->mode == MODE_3GP || mov->mode == MODE_3G2 ||
  1189. mov->mode == MODE_MP4 || mov->mode == MODE_PSP )
  1190. mov_write_ftyp_tag(pb,s);
  1191. if ( mov->mode == MODE_PSP ) {
  1192. if ( s->nb_streams != 2 ) {
  1193. av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");
  1194. return -1;
  1195. }
  1196. mov_write_uuidprof_tag(pb,s);
  1197. }
  1198. }
  1199. for (i=0; i<MAX_STREAMS; i++) {
  1200. mov->tracks[i].mode = mov->mode;
  1201. }
  1202. put_flush_packet(pb);
  1203. return 0;
  1204. }
  1205. static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
  1206. {
  1207. MOVContext *mov = s->priv_data;
  1208. ByteIOContext *pb = &s->pb;
  1209. AVCodecContext *enc = &s->streams[pkt->stream_index]->codec;
  1210. MOVTrack* trk = &mov->tracks[pkt->stream_index];
  1211. int cl, id;
  1212. unsigned int samplesInChunk = 0;
  1213. int size= pkt->size;
  1214. if (url_is_streamed(&s->pb)) return 0; /* Can't handle that */
  1215. if (!size) return 0; /* Discard 0 sized packets */
  1216. if (enc->codec_type == CODEC_TYPE_VIDEO ) {
  1217. samplesInChunk = 1;
  1218. }
  1219. else if (enc->codec_type == CODEC_TYPE_AUDIO ) {
  1220. if( enc->codec_id == CODEC_ID_AMR_NB) {
  1221. /* We must find out how many AMR blocks there are in one packet */
  1222. static uint16_t packed_size[16] =
  1223. {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 0};
  1224. int len = 0;
  1225. while (len < size && samplesInChunk < 100) {
  1226. len += packed_size[(pkt->data[len] >> 3) & 0x0F];
  1227. samplesInChunk++;
  1228. }
  1229. }
  1230. else if(enc->codec_id == CODEC_ID_PCM_ALAW) {
  1231. samplesInChunk = size/enc->channels;
  1232. }
  1233. else if(enc->codec_id == CODEC_ID_PCM_S16BE || enc->codec_id == CODEC_ID_PCM_S16LE) {
  1234. samplesInChunk = size/(2*enc->channels);
  1235. }
  1236. else {
  1237. samplesInChunk = 1;
  1238. }
  1239. }
  1240. if ((enc->codec_id == CODEC_ID_MPEG4 || enc->codec_id == CODEC_ID_AAC)
  1241. && trk->vosLen == 0) {
  1242. // assert(enc->extradata_size);
  1243. trk->vosLen = enc->extradata_size;
  1244. trk->vosData = av_malloc(trk->vosLen);
  1245. memcpy(trk->vosData, enc->extradata, trk->vosLen);
  1246. }
  1247. cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;
  1248. id = trk->entry % MOV_INDEX_CLUSTER_SIZE;
  1249. if (trk->ents_allocated <= trk->entry) {
  1250. trk->cluster = av_realloc(trk->cluster, (cl+1)*sizeof(void*));
  1251. if (!trk->cluster)
  1252. return -1;
  1253. trk->cluster[cl] = av_malloc(MOV_INDEX_CLUSTER_SIZE*sizeof(MOVIentry));
  1254. if (!trk->cluster[cl])
  1255. return -1;
  1256. trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;
  1257. }
  1258. if (mov->mdat_written == 0) {
  1259. mov_write_mdat_tag(pb, mov);
  1260. mov->mdat_written = 1;
  1261. mov->time = s->timestamp + 0x7C25B080; //1970 based -> 1904 based
  1262. }
  1263. trk->cluster[cl][id].pos = url_ftell(pb);
  1264. trk->cluster[cl][id].samplesInChunk = samplesInChunk;
  1265. trk->cluster[cl][id].size = size;
  1266. trk->cluster[cl][id].entries = samplesInChunk;
  1267. if(enc->codec_type == CODEC_TYPE_VIDEO) {
  1268. trk->cluster[cl][id].key_frame = !!(pkt->flags & PKT_FLAG_KEY);
  1269. if(trk->cluster[cl][id].key_frame)
  1270. trk->hasKeyframes = 1;
  1271. }
  1272. trk->enc = enc;
  1273. trk->entry++;
  1274. trk->sampleCount += samplesInChunk;
  1275. trk->mdat_size += size;
  1276. put_buffer(pb, pkt->data, size);
  1277. put_flush_packet(pb);
  1278. return 0;
  1279. }
  1280. static int mov_write_trailer(AVFormatContext *s)
  1281. {
  1282. MOVContext *mov = s->priv_data;
  1283. ByteIOContext *pb = &s->pb;
  1284. int res = 0;
  1285. int i, j;
  1286. offset_t moov_pos = url_ftell(pb);
  1287. /* Write size of mdat tag */
  1288. for (i=0, j=0; i<MAX_STREAMS; i++) {
  1289. if(mov->tracks[i].ents_allocated > 0) {
  1290. j += mov->tracks[i].mdat_size;
  1291. }
  1292. }
  1293. url_fseek(pb, mov->mdat_pos, SEEK_SET);
  1294. put_be32(pb, j+8);
  1295. url_fseek(pb, moov_pos, SEEK_SET);
  1296. mov_write_moov_tag(pb, mov, s);
  1297. for (i=0; i<MAX_STREAMS; i++) {
  1298. for (j=0; j<mov->tracks[i].ents_allocated/MOV_INDEX_CLUSTER_SIZE; j++) {
  1299. av_free(mov->tracks[i].cluster[j]);
  1300. }
  1301. av_free(mov->tracks[i].cluster);
  1302. if( mov->tracks[i].vosLen ) av_free( mov->tracks[i].vosData );
  1303. mov->tracks[i].cluster = NULL;
  1304. mov->tracks[i].ents_allocated = mov->tracks[i].entry = 0;
  1305. }
  1306. put_flush_packet(pb);
  1307. return res;
  1308. }
  1309. static AVOutputFormat mov_oformat = {
  1310. "mov",
  1311. "mov format",
  1312. NULL,
  1313. "mov",
  1314. sizeof(MOVContext),
  1315. CODEC_ID_AAC,
  1316. CODEC_ID_MPEG4,
  1317. mov_write_header,
  1318. mov_write_packet,
  1319. mov_write_trailer,
  1320. .flags = AVFMT_GLOBALHEADER,
  1321. };
  1322. static AVOutputFormat _3gp_oformat = {
  1323. "3gp",
  1324. "3gp format",
  1325. NULL,
  1326. "3gp",
  1327. sizeof(MOVContext),
  1328. CODEC_ID_AMR_NB,
  1329. CODEC_ID_H263,
  1330. mov_write_header,
  1331. mov_write_packet,
  1332. mov_write_trailer,
  1333. .flags = AVFMT_GLOBALHEADER,
  1334. };
  1335. static AVOutputFormat mp4_oformat = {
  1336. "mp4",
  1337. "mp4 format",
  1338. "application/mp4",
  1339. "mp4,m4a",
  1340. sizeof(MOVContext),
  1341. CODEC_ID_AAC,
  1342. CODEC_ID_MPEG4,
  1343. mov_write_header,
  1344. mov_write_packet,
  1345. mov_write_trailer,
  1346. .flags = AVFMT_GLOBALHEADER,
  1347. };
  1348. static AVOutputFormat psp_oformat = {
  1349. "psp",
  1350. "psp mp4 format",
  1351. NULL,
  1352. "mp4,psp",
  1353. sizeof(MOVContext),
  1354. CODEC_ID_AAC,
  1355. CODEC_ID_MPEG4,
  1356. mov_write_header,
  1357. mov_write_packet,
  1358. mov_write_trailer,
  1359. // .flags = AVFMT_GLOBALHEADER,
  1360. };
  1361. static AVOutputFormat _3g2_oformat = {
  1362. "3g2",
  1363. "3gp2 format",
  1364. NULL,
  1365. "3g2",
  1366. sizeof(MOVContext),
  1367. CODEC_ID_AMR_NB,
  1368. CODEC_ID_H263,
  1369. mov_write_header,
  1370. mov_write_packet,
  1371. mov_write_trailer,
  1372. .flags = AVFMT_GLOBALHEADER,
  1373. };
  1374. int movenc_init(void)
  1375. {
  1376. av_register_output_format(&mov_oformat);
  1377. av_register_output_format(&_3gp_oformat);
  1378. av_register_output_format(&mp4_oformat);
  1379. av_register_output_format(&psp_oformat);
  1380. av_register_output_format(&_3g2_oformat);
  1381. return 0;
  1382. }