qt-faststart.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. /*
  2. * qt-faststart.c, v0.2
  3. * by Mike Melanson (melanson@pcisys.net)
  4. * This file is placed in the public domain. Use the program however you
  5. * see fit.
  6. *
  7. * This utility rearranges a Quicktime file such that the moov atom
  8. * is in front of the data, thus facilitating network streaming.
  9. *
  10. * To compile this program, start from the base directory from which you
  11. * are building FFmpeg and type:
  12. * make tools/qt-faststart
  13. * The qt-faststart program will be built in the tools/ directory. If you
  14. * do not build the program in this manner, correct results are not
  15. * guaranteed, particularly on 64-bit platforms.
  16. * Invoke the program with:
  17. * qt-faststart <infile.mov> <outfile.mov>
  18. *
  19. * Notes: Quicktime files can come in many configurations of top-level
  20. * atoms. This utility stipulates that the very last atom in the file needs
  21. * to be a moov atom. When given such a file, this utility will rearrange
  22. * the top-level atoms by shifting the moov atom from the back of the file
  23. * to the front, and patch the chunk offsets along the way. This utility
  24. * presently only operates on uncompressed moov atoms.
  25. */
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <inttypes.h>
  29. #include <string.h>
  30. #ifdef __MINGW32__
  31. #define fseeko(x, y, z) fseeko64(x, y, z)
  32. #define ftello(x) ftello64(x)
  33. #elif defined(_WIN32)
  34. #define fseeko(x, y, z) _fseeki64(x, y, z)
  35. #define ftello(x) _ftelli64(x)
  36. #endif
  37. #define MIN(a,b) ((a) > (b) ? (b) : (a))
  38. #define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1])
  39. #define BE_32(x) (((uint32_t)(((uint8_t*)(x))[0]) << 24) | \
  40. (((uint8_t*)(x))[1] << 16) | \
  41. (((uint8_t*)(x))[2] << 8) | \
  42. ((uint8_t*)(x))[3])
  43. #define BE_64(x) (((uint64_t)(((uint8_t*)(x))[0]) << 56) | \
  44. ((uint64_t)(((uint8_t*)(x))[1]) << 48) | \
  45. ((uint64_t)(((uint8_t*)(x))[2]) << 40) | \
  46. ((uint64_t)(((uint8_t*)(x))[3]) << 32) | \
  47. ((uint64_t)(((uint8_t*)(x))[4]) << 24) | \
  48. ((uint64_t)(((uint8_t*)(x))[5]) << 16) | \
  49. ((uint64_t)(((uint8_t*)(x))[6]) << 8) | \
  50. ((uint64_t)( (uint8_t*)(x))[7]))
  51. #define BE_FOURCC(ch0, ch1, ch2, ch3) \
  52. ( (uint32_t)(unsigned char)(ch3) | \
  53. ((uint32_t)(unsigned char)(ch2) << 8) | \
  54. ((uint32_t)(unsigned char)(ch1) << 16) | \
  55. ((uint32_t)(unsigned char)(ch0) << 24) )
  56. #define QT_ATOM BE_FOURCC
  57. /* top level atoms */
  58. #define FREE_ATOM QT_ATOM('f', 'r', 'e', 'e')
  59. #define JUNK_ATOM QT_ATOM('j', 'u', 'n', 'k')
  60. #define MDAT_ATOM QT_ATOM('m', 'd', 'a', 't')
  61. #define MOOV_ATOM QT_ATOM('m', 'o', 'o', 'v')
  62. #define PNOT_ATOM QT_ATOM('p', 'n', 'o', 't')
  63. #define SKIP_ATOM QT_ATOM('s', 'k', 'i', 'p')
  64. #define WIDE_ATOM QT_ATOM('w', 'i', 'd', 'e')
  65. #define PICT_ATOM QT_ATOM('P', 'I', 'C', 'T')
  66. #define FTYP_ATOM QT_ATOM('f', 't', 'y', 'p')
  67. #define UUID_ATOM QT_ATOM('u', 'u', 'i', 'd')
  68. #define CMOV_ATOM QT_ATOM('c', 'm', 'o', 'v')
  69. #define STCO_ATOM QT_ATOM('s', 't', 'c', 'o')
  70. #define CO64_ATOM QT_ATOM('c', 'o', '6', '4')
  71. #define ATOM_PREAMBLE_SIZE 8
  72. #define COPY_BUFFER_SIZE 33554432
  73. int main(int argc, char *argv[])
  74. {
  75. FILE *infile = NULL;
  76. FILE *outfile = NULL;
  77. unsigned char atom_bytes[ATOM_PREAMBLE_SIZE];
  78. uint32_t atom_type = 0;
  79. uint64_t atom_size = 0;
  80. uint64_t atom_offset = 0;
  81. int64_t last_offset;
  82. unsigned char *moov_atom = NULL;
  83. unsigned char *ftyp_atom = NULL;
  84. uint64_t moov_atom_size;
  85. uint64_t ftyp_atom_size = 0;
  86. uint64_t i, j;
  87. uint32_t offset_count;
  88. uint64_t current_offset;
  89. int64_t start_offset = 0;
  90. unsigned char *copy_buffer = NULL;
  91. int bytes_to_copy;
  92. if (argc != 3) {
  93. printf("Usage: qt-faststart <infile.mov> <outfile.mov>\n"
  94. "Note: alternatively you can use -movflags +faststart in ffmpeg\n");
  95. return 0;
  96. }
  97. if (!strcmp(argv[1], argv[2])) {
  98. fprintf(stderr, "input and output files need to be different\n");
  99. return 1;
  100. }
  101. infile = fopen(argv[1], "rb");
  102. if (!infile) {
  103. perror(argv[1]);
  104. goto error_out;
  105. }
  106. /* traverse through the atoms in the file to make sure that 'moov' is
  107. * at the end */
  108. while (!feof(infile)) {
  109. if (fread(atom_bytes, ATOM_PREAMBLE_SIZE, 1, infile) != 1) {
  110. break;
  111. }
  112. atom_size = BE_32(&atom_bytes[0]);
  113. atom_type = BE_32(&atom_bytes[4]);
  114. /* keep ftyp atom */
  115. if (atom_type == FTYP_ATOM) {
  116. ftyp_atom_size = atom_size;
  117. free(ftyp_atom);
  118. ftyp_atom = malloc(ftyp_atom_size);
  119. if (!ftyp_atom) {
  120. printf("could not allocate %"PRIu64" bytes for ftyp atom\n",
  121. atom_size);
  122. goto error_out;
  123. }
  124. if (fseeko(infile, -ATOM_PREAMBLE_SIZE, SEEK_CUR) ||
  125. fread(ftyp_atom, atom_size, 1, infile) != 1 ||
  126. (start_offset = ftello(infile)) < 0) {
  127. perror(argv[1]);
  128. goto error_out;
  129. }
  130. } else {
  131. int ret;
  132. /* 64-bit special case */
  133. if (atom_size == 1) {
  134. if (fread(atom_bytes, ATOM_PREAMBLE_SIZE, 1, infile) != 1) {
  135. break;
  136. }
  137. atom_size = BE_64(&atom_bytes[0]);
  138. ret = fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE * 2, SEEK_CUR);
  139. } else {
  140. ret = fseeko(infile, atom_size - ATOM_PREAMBLE_SIZE, SEEK_CUR);
  141. }
  142. if (ret) {
  143. perror(argv[1]);
  144. goto error_out;
  145. }
  146. }
  147. printf("%c%c%c%c %10"PRIu64" %"PRIu64"\n",
  148. (atom_type >> 24) & 255,
  149. (atom_type >> 16) & 255,
  150. (atom_type >> 8) & 255,
  151. (atom_type >> 0) & 255,
  152. atom_offset,
  153. atom_size);
  154. if ((atom_type != FREE_ATOM) &&
  155. (atom_type != JUNK_ATOM) &&
  156. (atom_type != MDAT_ATOM) &&
  157. (atom_type != MOOV_ATOM) &&
  158. (atom_type != PNOT_ATOM) &&
  159. (atom_type != SKIP_ATOM) &&
  160. (atom_type != WIDE_ATOM) &&
  161. (atom_type != PICT_ATOM) &&
  162. (atom_type != UUID_ATOM) &&
  163. (atom_type != FTYP_ATOM)) {
  164. printf("encountered non-QT top-level atom (is this a QuickTime file?)\n");
  165. break;
  166. }
  167. atom_offset += atom_size;
  168. /* The atom header is 8 (or 16 bytes), if the atom size (which
  169. * includes these 8 or 16 bytes) is less than that, we won't be
  170. * able to continue scanning sensibly after this atom, so break. */
  171. if (atom_size < 8)
  172. break;
  173. }
  174. if (atom_type != MOOV_ATOM) {
  175. printf("last atom in file was not a moov atom\n");
  176. free(ftyp_atom);
  177. fclose(infile);
  178. return 0;
  179. }
  180. /* moov atom was, in fact, the last atom in the chunk; load the whole
  181. * moov atom */
  182. if (fseeko(infile, -atom_size, SEEK_END)) {
  183. perror(argv[1]);
  184. goto error_out;
  185. }
  186. last_offset = ftello(infile);
  187. if (last_offset < 0) {
  188. perror(argv[1]);
  189. goto error_out;
  190. }
  191. moov_atom_size = atom_size;
  192. moov_atom = malloc(moov_atom_size);
  193. if (!moov_atom) {
  194. printf("could not allocate %"PRIu64" bytes for moov atom\n", atom_size);
  195. goto error_out;
  196. }
  197. if (fread(moov_atom, atom_size, 1, infile) != 1) {
  198. perror(argv[1]);
  199. goto error_out;
  200. }
  201. /* this utility does not support compressed atoms yet, so disqualify
  202. * files with compressed QT atoms */
  203. if (BE_32(&moov_atom[12]) == CMOV_ATOM) {
  204. printf("this utility does not support compressed moov atoms yet\n");
  205. goto error_out;
  206. }
  207. /* close; will be re-opened later */
  208. fclose(infile);
  209. infile = NULL;
  210. /* crawl through the moov chunk in search of stco or co64 atoms */
  211. for (i = 4; i < moov_atom_size - 4; i++) {
  212. atom_type = BE_32(&moov_atom[i]);
  213. if (atom_type == STCO_ATOM) {
  214. printf(" patching stco atom...\n");
  215. atom_size = BE_32(&moov_atom[i - 4]);
  216. if (i + atom_size - 4 > moov_atom_size) {
  217. printf(" bad atom size\n");
  218. goto error_out;
  219. }
  220. offset_count = BE_32(&moov_atom[i + 8]);
  221. if (i + 12 + offset_count * UINT64_C(4) > moov_atom_size) {
  222. printf(" bad atom size/element count\n");
  223. goto error_out;
  224. }
  225. for (j = 0; j < offset_count; j++) {
  226. current_offset = BE_32(&moov_atom[i + 12 + j * 4]);
  227. current_offset += moov_atom_size;
  228. moov_atom[i + 12 + j * 4 + 0] = (current_offset >> 24) & 0xFF;
  229. moov_atom[i + 12 + j * 4 + 1] = (current_offset >> 16) & 0xFF;
  230. moov_atom[i + 12 + j * 4 + 2] = (current_offset >> 8) & 0xFF;
  231. moov_atom[i + 12 + j * 4 + 3] = (current_offset >> 0) & 0xFF;
  232. }
  233. i += atom_size - 4;
  234. } else if (atom_type == CO64_ATOM) {
  235. printf(" patching co64 atom...\n");
  236. atom_size = BE_32(&moov_atom[i - 4]);
  237. if (i + atom_size - 4 > moov_atom_size) {
  238. printf(" bad atom size\n");
  239. goto error_out;
  240. }
  241. offset_count = BE_32(&moov_atom[i + 8]);
  242. if (i + 12 + offset_count * UINT64_C(8) > moov_atom_size) {
  243. printf(" bad atom size/element count\n");
  244. goto error_out;
  245. }
  246. for (j = 0; j < offset_count; j++) {
  247. current_offset = BE_64(&moov_atom[i + 12 + j * 8]);
  248. current_offset += moov_atom_size;
  249. moov_atom[i + 12 + j * 8 + 0] = (current_offset >> 56) & 0xFF;
  250. moov_atom[i + 12 + j * 8 + 1] = (current_offset >> 48) & 0xFF;
  251. moov_atom[i + 12 + j * 8 + 2] = (current_offset >> 40) & 0xFF;
  252. moov_atom[i + 12 + j * 8 + 3] = (current_offset >> 32) & 0xFF;
  253. moov_atom[i + 12 + j * 8 + 4] = (current_offset >> 24) & 0xFF;
  254. moov_atom[i + 12 + j * 8 + 5] = (current_offset >> 16) & 0xFF;
  255. moov_atom[i + 12 + j * 8 + 6] = (current_offset >> 8) & 0xFF;
  256. moov_atom[i + 12 + j * 8 + 7] = (current_offset >> 0) & 0xFF;
  257. }
  258. i += atom_size - 4;
  259. }
  260. }
  261. /* re-open the input file and open the output file */
  262. infile = fopen(argv[1], "rb");
  263. if (!infile) {
  264. perror(argv[1]);
  265. goto error_out;
  266. }
  267. if (start_offset > 0) { /* seek after ftyp atom */
  268. if (fseeko(infile, start_offset, SEEK_SET)) {
  269. perror(argv[1]);
  270. goto error_out;
  271. }
  272. last_offset -= start_offset;
  273. }
  274. outfile = fopen(argv[2], "wb");
  275. if (!outfile) {
  276. perror(argv[2]);
  277. goto error_out;
  278. }
  279. /* dump the same ftyp atom */
  280. if (ftyp_atom_size > 0) {
  281. printf(" writing ftyp atom...\n");
  282. if (fwrite(ftyp_atom, ftyp_atom_size, 1, outfile) != 1) {
  283. perror(argv[2]);
  284. goto error_out;
  285. }
  286. }
  287. /* dump the new moov atom */
  288. printf(" writing moov atom...\n");
  289. if (fwrite(moov_atom, moov_atom_size, 1, outfile) != 1) {
  290. perror(argv[2]);
  291. goto error_out;
  292. }
  293. /* copy the remainder of the infile, from offset 0 -> last_offset - 1 */
  294. bytes_to_copy = MIN(COPY_BUFFER_SIZE, last_offset);
  295. copy_buffer = malloc(bytes_to_copy);
  296. if (!copy_buffer) {
  297. printf("could not allocate %d bytes for copy_buffer\n", bytes_to_copy);
  298. goto error_out;
  299. }
  300. printf(" copying rest of file...\n");
  301. while (last_offset) {
  302. bytes_to_copy = MIN(bytes_to_copy, last_offset);
  303. if (fread(copy_buffer, bytes_to_copy, 1, infile) != 1) {
  304. perror(argv[1]);
  305. goto error_out;
  306. }
  307. if (fwrite(copy_buffer, bytes_to_copy, 1, outfile) != 1) {
  308. perror(argv[2]);
  309. goto error_out;
  310. }
  311. last_offset -= bytes_to_copy;
  312. }
  313. fclose(infile);
  314. fclose(outfile);
  315. free(moov_atom);
  316. free(ftyp_atom);
  317. free(copy_buffer);
  318. return 0;
  319. error_out:
  320. if (infile)
  321. fclose(infile);
  322. if (outfile)
  323. fclose(outfile);
  324. free(moov_atom);
  325. free(ftyp_atom);
  326. free(copy_buffer);
  327. return 1;
  328. }