开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
quicktime.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：42k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

quicktime.c：源码内容
  1. #include "quicktime.h"
  4. int quicktime_make_streamable(char *in_path, char *out_path)
  5. {
  6. quicktime_t file, *old_file, new_file;
  7. int moov_exists = 0, mdat_exists = 0, result, atoms = 1;
  8. long mdat_start, mdat_size;
  9. quicktime_atom_t leaf_atom;
  10. long moov_length;
  12. quicktime_init(&file);
  14. /* find the moov atom in the old file */
  16. if(!(file.stream = fopen(in_path, "rb")))
  17. {
  18. perror("quicktime_make_streamable");
  19. return 1;
  20. }
  22. fseek(file.stream, 0, SEEK_END);
  23. file.total_length = ftell(file.stream);
  24. fseek(file.stream, 0, SEEK_SET);
  26. /* get the locations of moov and mdat atoms */
  27. do
  28. {
  29. /*printf("%xn", quicktime_position(&file)); */
  30. result = quicktime_atom_read_header(&file, &leaf_atom);
  32. if(!result)
  33. {
  34. if(quicktime_atom_is(&leaf_atom, "moov"))
  35. {
  36. moov_exists = atoms;
  37. moov_length = leaf_atom.size;
  38. }
  39. else
  40. if(quicktime_atom_is(&leaf_atom, "mdat"))
  41. {
  42. mdat_start = quicktime_position(&file) - HEADER_LENGTH;
  43. mdat_size = leaf_atom.size;
  44. mdat_exists = atoms;
  45. }
  47. quicktime_atom_skip(&file, &leaf_atom);
  49. atoms++;
  50. }
  51. }while(!result && quicktime_position(&file) < file.total_length);
  53. fclose(file.stream);
  55. if(!moov_exists)
  56. {
  57. printf("quicktime_make_streamable: no moov atomn");
  58. return 1;
  59. }
  61. if(!mdat_exists)
  62. {
  63. printf("quicktime_make_streamable: no mdat atomn");
  64. return 1;
  65. }
  67. /* copy the old file to the new file */
  68. if(moov_exists && mdat_exists)
  69. {
  70. /* moov wasn't the first atom */
  71. if(moov_exists > 1)
  72. {
  73. char *buffer;
  74. long buf_size = 1000000;
  76. result = 0;
  78. /* read the header proper */
  79. if(!(old_file = quicktime_open(in_path, 1, 0, 0)))
  80. {
  81. return 1;
  82. }
  84. quicktime_shift_offsets(&(old_file->moov), moov_length);
  86. /* open the output file */
  87. if(!(new_file.stream = fopen(out_path, "wb")))
  88. {
  89. perror("quicktime_make_streamable");
  90. result =  1;
  91. }
  92. else
  93. {
  94. /* set up some flags */
  95. new_file.wr = 1;
  96. new_file.rd = 0;
  97. quicktime_write_moov(&new_file, &(old_file->moov));
  99. quicktime_set_position(old_file, mdat_start);
  101. if(!(buffer = calloc(1, buf_size)))
  102. {
  103. result = 1;
  104. printf("quicktime_make_streamable: out of memoryn");
  105. }
  106. else
  107. {
  108. while(quicktime_position(old_file) < mdat_start + mdat_size && !result)
  109. {
  110. if(quicktime_position(old_file) + buf_size > mdat_start + mdat_size)
  111. buf_size = mdat_start + mdat_size - quicktime_position(old_file);
  113. if(!quicktime_read_data(old_file, buffer, buf_size)) result = 1;
  114. if(!result)
  115. {
  116. if(!quicktime_write_data(&new_file, buffer, buf_size)) result = 1;
  117. }
  118. }
  119. free(buffer);
  120. }
  121. fclose(new_file.stream);
  122. }
  123. quicktime_close(old_file);
  124. }
  125. else
  126. {
  127. printf("quicktime_make_streamable: header already at 0 offsetn");
  128. return 0;
  129. }
  130. }
  132. return 0;
  133. }
  135. int quicktime_set_time_scale(quicktime_t *file, int time_scale)
  136. {
  137. file->moov.mvhd.time_scale = time_scale;
  138. }
  140. int quicktime_set_copyright(quicktime_t *file, char *string)
  141. {
  142. quicktime_set_udta_string(&(file->moov.udta.copyright), &(file->moov.udta.copyright_len), string);
  143. }
  145. int quicktime_set_name(quicktime_t *file, char *string)
  146. {
  147. quicktime_set_udta_string(&(file->moov.udta.name), &(file->moov.udta.name_len), string);
  148. }
  150. int quicktime_set_info(quicktime_t *file, char *string)
  151. {
  152. quicktime_set_udta_string(&(file->moov.udta.info), &(file->moov.udta.info_len), string);
  153. }
  155. int quicktime_get_time_scale(quicktime_t *file)
  156. {
  157. return file->moov.mvhd.time_scale;
  158. }
  160. char* quicktime_get_copyright(quicktime_t *file)
  161. {
  162. return file->moov.udta.copyright;
  163. }
  165. char* quicktime_get_name(quicktime_t *file)
  166. {
  167. return file->moov.udta.name;
  168. }
  170. char* quicktime_get_info(quicktime_t *file)
  171. {
  172. return file->moov.udta.info;
  173. }
  175. int quicktime_get_iod_audio_profile_level(quicktime_t *file)
  176. {
  177. return file->moov.iods.audioProfileId;
  178. }
  180. int quicktime_set_iod_audio_profile_level(quicktime_t *file, int id)
  181. {
  182. quicktime_iods_set_audio_profile(&file->moov.iods, id);
  183. }
  185. int quicktime_get_iod_video_profile_level(quicktime_t *file)
  186. {
  187. return file->moov.iods.videoProfileId;
  188. }
  190. int quicktime_set_iod_video_profile_level(quicktime_t *file, int id)
  191. {
  192. quicktime_iods_set_video_profile(&file->moov.iods, id);
  193. }
  195. int quicktime_video_tracks(quicktime_t *file)
  196. {
  197. int i, result = 0;
  198. for(i = 0; i < file->moov.total_tracks; i++)
  199. {
  200. if(file->moov.trak[i]->mdia.minf.is_video) result++;
  201. }
  202. return result;
  203. }
  205. int quicktime_audio_tracks(quicktime_t *file)
  206. {
  207. int i, result = 0;
  208. quicktime_minf_t *minf;
  209. for(i = 0; i < file->moov.total_tracks; i++)
  210. {
  211. minf = &(file->moov.trak[i]->mdia.minf);
  212. if(minf->is_audio)
  213. result++;
  214. }
  215. return result;
  216. }
  218. int quicktime_set_audio(quicktime_t *file, 
  219. int channels,
  220. long sample_rate,
  221. int bits,
  222. int sample_size,
  223. int time_scale,
  224. int sample_duration,
  225. char *compressor)
  226. {
  227. int i, j;
  228. quicktime_trak_t *trak;
  230. /* delete any existing tracks */
  231. for(i = 0; i < file->total_atracks; i++) {
  232. for (j = 0; j < file->atracks[i].totalHintTracks; j++) {
  233. quicktime_delete_trak(&(file->moov), 
  234. file->atracks[i].hintTracks[j]);
  235. free(file->atracks[i].hintTracks[j]);
  236. file->atracks[i].hintTracks[j] = NULL;
  237. file->total_hint_tracks--;
  238. }
  239. quicktime_delete_audio_map(&(file->atracks[i]));
  240. quicktime_delete_trak(&(file->moov), file->atracks[i].track);
  241. }
  242. free(file->atracks);
  243. file->atracks = NULL;
  244. file->total_atracks = 0;
  246. if(channels) {
  247. /* Fake the bits parameter for some formats. */
  248. if(quicktime_match_32(compressor, QUICKTIME_ULAW) ||
  249. quicktime_match_32(compressor, QUICKTIME_IMA4)) bits = 16;
  251. file->atracks = (quicktime_audio_map_t*)
  252. calloc(1, sizeof(quicktime_audio_map_t));
  253. trak = quicktime_add_track(&(file->moov));
  254. quicktime_trak_init_audio(file, trak, channels, sample_rate, bits, 
  255. sample_size, time_scale, sample_duration, compressor);
  256. quicktime_init_audio_map(&(file->atracks[0]), trak);
  257. file->atracks[file->total_atracks].track = trak;
  258. file->atracks[file->total_atracks].channels = channels;
  259. file->atracks[file->total_atracks].current_position = 0;
  260. file->atracks[file->total_atracks].current_chunk = 1;
  261. file->total_atracks++;
  262. }
  263. return 1;   /* Return the number of tracks created */
  264. }
  266. int quicktime_set_video(quicktime_t *file, 
  267. int tracks, 
  268. int frame_w, 
  269. int frame_h,
  270. float frame_rate,
  271. int time_scale,
  272. char *compressor)
  273. {
  274. int i, j;
  275. quicktime_trak_t *trak;
  277. /* delete any existing tracks */
  278. for(i = 0; i < file->total_vtracks; i++) {
  279. for (j = 0; j < file->vtracks[i].totalHintTracks; j++) {
  280. quicktime_delete_trak(&(file->moov), 
  281. file->vtracks[i].hintTracks[j]);
  282. file->vtracks[i].hintTracks[j] = NULL;
  283. file->total_hint_tracks--;
  284. }
  285. quicktime_delete_video_map(&(file->vtracks[i]));
  286. quicktime_delete_trak(&(file->moov), file->vtracks[i].track);
  287. }
  288. free(file->vtracks);
  289. file->vtracks = NULL;
  290. file->total_vtracks = 0;
  292. if (tracks > 0) {
  293. file->total_vtracks = tracks;
  294. file->vtracks = (quicktime_video_map_t*)calloc(1, sizeof(quicktime_video_map_t) * file->total_vtracks);
  295. for(i = 0; i < tracks; i++)
  296. {
  297. trak = quicktime_add_track(&(file->moov));
  298. quicktime_trak_init_video(file, trak, frame_w, frame_h, frame_rate,
  299. time_scale, compressor);
  300. quicktime_init_video_map(&(file->vtracks[i]), trak);
  301. }
  302. }
  303. return 0;
  304. }
  306. int quicktime_set_audio_hint(quicktime_t *file, int audioTrack,
  307. char *payloadName, u_int* pPayloadNumber, 
  308. int maxPktSize)
  309. {
  310. quicktime_audio_map_t* pMap = NULL;
  311. quicktime_trak_t* hintTrak = NULL;
  312. int timeScale;
  313. float frameRate;
  314. int sampleDuration;
  315. char rtpMapBuf[128];
  316. char sdpBuf[256];
  318. /* check our arguments */
  319. if (file == NULL) {
  320. return -1;
  321. }
  322. if (audioTrack < 0 || audioTrack > file->total_atracks) {
  323. return -1;
  324. }
  325. if (payloadName == NULL) {
  326. return -1;
  327. }
  329. pMap = &file->atracks[audioTrack];
  331. timeScale = quicktime_audio_time_scale(file, audioTrack);
  332. if (timeScale == 0) {
  333. return -1;
  334. }
  335. sampleDuration = file->atracks[audioTrack].track->mdia.minf.stbl.stts.table[0].sample_duration;
  337. /* add the hint track */
  338. hintTrak = quicktime_add_track(&(file->moov));
  339. if (*pPayloadNumber == 0) {
  340. (*pPayloadNumber) = 96 + file->total_hint_tracks++;
  341. }
  343. /* initialize it to reference the audio track */
  344. quicktime_trak_init_hint(file, hintTrak, pMap->track, 
  345. maxPktSize, timeScale, sampleDuration);
  347. /* set the payload info */
  348. hintTrak->hint_udta.hinf.payt.payloadNumber = *pPayloadNumber;
  349. sprintf(rtpMapBuf, "%s/%u", payloadName, timeScale);
  350. strcpy(hintTrak->hint_udta.hinf.payt.rtpMapString, rtpMapBuf);
  352. /* set the SDP media section */
  353. sprintf(sdpBuf, 
  354. "m=audio 0 RTP/AVP %u1512a=rtpmap:%u %s1512a=control:trackID=%u1512", 
  355. *pPayloadNumber, *pPayloadNumber, rtpMapBuf, hintTrak->tkhd.track_id);
  356. quicktime_sdp_set(&(hintTrak->hint_udta.hnti.sdp), sdpBuf);
  358. pMap->hintTracks[pMap->totalHintTracks] = hintTrak;
  359. pMap->hintPositions[pMap->totalHintTracks] = 0;
  360. pMap->totalHintTracks++;
  361. return (pMap->totalHintTracks - 1);
  362. }
  364. int quicktime_set_video_hint(quicktime_t *file, int videoTrack, 
  365. char *payloadName, u_int* pPayloadNumber, 
  366. int maxPktSize)
  367. {
  368. quicktime_video_map_t* pMap = NULL;
  369. quicktime_trak_t* hintTrak = NULL;
  370. float frameRate;
  371. int timeScale;
  372. int sampleDuration;
  373. char rtpMapBuf[128];
  374. char sdpBuf[1024];
  376. /* check our arguments */
  377. if (file == NULL) {
  378. return -1;
  379. }
  380. if (videoTrack < 0 || videoTrack > file->total_vtracks) {
  381. return -1;
  382. }
  383. if (payloadName == NULL) {
  384. return -1;
  385. }
  387. frameRate = quicktime_video_frame_rate(file, videoTrack);
  388. if (frameRate == 0.0) {
  389. return -1;
  390. }
  391. timeScale = quicktime_video_time_scale(file, videoTrack);
  392. if (timeScale == 0) {
  393. return -1;
  394. }
  395. sampleDuration = timeScale / frameRate;
  396. if (sampleDuration == 0) {
  397. return -1;
  398. }
  400. /* add the hint track */
  401. hintTrak = quicktime_add_track(&(file->moov));
  402. if (*pPayloadNumber == 0) {
  403. (*pPayloadNumber) = 96 + file->total_hint_tracks++;
  404. }
  406. pMap = &file->vtracks[videoTrack];
  408. /* initialize it to reference the video track */
  409. quicktime_trak_init_hint(file, hintTrak, pMap->track, 
  410. maxPktSize, timeScale, sampleDuration);
  412. /* set the payload info */
  413. hintTrak->hint_udta.hinf.payt.payloadNumber = *pPayloadNumber;
  414. sprintf(rtpMapBuf, "%s/90000", payloadName);
  415. strcpy(hintTrak->hint_udta.hinf.payt.rtpMapString, rtpMapBuf);
  417. /* set the SDP media section */
  418. sprintf(sdpBuf, 
  419. "m=video 0 RTP/AVP %u1512a=rtpmap:%u %s1512a=control:trackID=%u1512", 
  420. *pPayloadNumber, *pPayloadNumber, rtpMapBuf, hintTrak->tkhd.track_id);
  421. quicktime_sdp_set(&(hintTrak->hint_udta.hnti.sdp), sdpBuf);
  423. pMap->hintTracks[pMap->totalHintTracks] = hintTrak;
  424. pMap->hintPositions[pMap->totalHintTracks] = 0;
  425. pMap->totalHintTracks++;
  426. return (pMap->totalHintTracks - 1);
  427. }
  429. char* quicktime_get_session_sdp(quicktime_t *file)
  430. {
  431. return file->moov.udta.hnti.rtp.string;
  432. }
  434. int quicktime_set_session_sdp(quicktime_t *file, char* sdpString)
  435. {
  436. return quicktime_rtp_set(&(file->moov.udta.hnti.rtp), sdpString);
  437. }
  439. int quicktime_add_audio_sdp(quicktime_t *file, char* sdpString, int track, int hintTrack)
  440. {
  441. quicktime_trak_t* hintTrak = 
  442. file->atracks[track].hintTracks[hintTrack];
  444. quicktime_sdp_append(&(hintTrak->hint_udta.hnti.sdp), sdpString);
  445. }
  447. int quicktime_add_video_sdp(quicktime_t *file, char* sdpString, int track, int hintTrack)
  448. {
  449. quicktime_trak_t* hintTrak = 
  450. file->vtracks[track].hintTracks[hintTrack];
  452. quicktime_sdp_append(&(hintTrak->hint_udta.hnti.sdp), sdpString);
  453. }
  455. static int quicktime_set_media_hint_max_rate(quicktime_t *file, 
  456. int granularity, int maxBitRate, quicktime_trak_t* hintTrak)
  457. {
  458. hintTrak->hint_udta.hinf.maxr.granularity = granularity;
  459. hintTrak->hint_udta.hinf.maxr.maxBitRate = maxBitRate;
  461. hintTrak->mdia.minf.hmhd.maxbitrate = maxBitRate;
  462. /* Give upper bound on MP4 max bitrate for 1 minute window */
  463. hintTrak->mdia.minf.hmhd.slidingavgbitrate = 
  464. maxBitRate * (60000 / granularity);
  466. return 0;
  467. }
  469. int quicktime_set_audio_hint_max_rate(quicktime_t *file, 
  470. int granularity, int maxBitRate, int audioTrack, int hintTrack)
  471. {
  472. quicktime_trak_t* hintTrak = 
  473. file->atracks[audioTrack].hintTracks[hintTrack];
  475. return quicktime_set_media_hint_max_rate(file,
  476. granularity, maxBitRate, hintTrak);
  477. }
  479. int quicktime_set_video_hint_max_rate(quicktime_t *file, 
  480. int granularity, int maxBitRate, int videoTrack, int hintTrack)
  481. {
  482. quicktime_trak_t* hintTrak = 
  483. file->vtracks[videoTrack].hintTracks[hintTrack];
  485. return quicktime_set_media_hint_max_rate(file,
  486. granularity, maxBitRate, hintTrak);
  487. }
  489. int quicktime_set_framerate(quicktime_t *file, float framerate)
  490. {
  491. int i;
  492. int new_time_scale, new_sample_duration;
  493. new_time_scale = quicktime_get_timescale(framerate);
  494. new_sample_duration = (int)((float)new_time_scale / framerate + 0.5);
  496. for(i = 0; i < file->total_vtracks; i++)
  497. {
  498. file->vtracks[i].track->mdia.mdhd.time_scale = new_time_scale;
  499. file->vtracks[i].track->mdia.minf.stbl.stts.table[0].sample_duration = new_sample_duration;
  500. }
  501. }
  503. quicktime_trak_t* quicktime_add_track(quicktime_moov_t *moov)
  504. {
  505. quicktime_trak_t *trak;
  506. trak = moov->trak[moov->total_tracks] = calloc(1, sizeof(quicktime_trak_t));
  507. quicktime_trak_init(trak);
  508. trak->tkhd.track_id = moov->mvhd.next_track_id;
  509. moov->mvhd.next_track_id++;
  510. moov->total_tracks++;
  511. return trak;
  512. }
  514. /* ============================= Initialization functions */
  516. int quicktime_init(quicktime_t *file)
  517. {
  518. memset(file, 0, sizeof(quicktime_t));
  519. quicktime_mdat_init(&(file->mdat));
  520. quicktime_moov_init(&(file->moov));
  521. file->cpus = 1;
  522. return 0;
  523. }
  525. int quicktime_delete(quicktime_t *file)
  526. {
  527. int i;
  528. if(file->total_atracks) 
  529. {
  530. for(i = 0; i < file->total_atracks; i++)
  531. quicktime_delete_audio_map(&(file->atracks[i]));
  532. free(file->atracks);
  533. }
  534. if(file->total_vtracks)
  535. {
  536. for(i = 0; i < file->total_vtracks; i++)
  537. quicktime_delete_video_map(&(file->vtracks[i]));
  538. free(file->vtracks);
  539. }
  540. file->total_atracks = 0;
  541. file->total_vtracks = 0;
  542. if(file->preload_size)
  543. {
  544. free(file->preload_buffer);
  545. file->preload_size = 0;
  546. }
  547. quicktime_moov_delete(&(file->moov));
  548. quicktime_mdat_delete(&(file->mdat));
  549. return 0;
  550. }
  552. /* =============================== Optimization functions */
  554. int quicktime_set_cpus(quicktime_t *file, int cpus)
  555. {
  556. if(cpus > 0) file->cpus = cpus;
  557. return 0;
  558. }
  560. int quicktime_set_preload(quicktime_t *file, long preload)
  561. {
  562. if(!file->preload_size)
  563. {
  564. file->preload_size = preload;
  565. file->preload_buffer = calloc(1, preload);
  566. file->preload_start = 0;
  567. file->preload_end = 0;
  568. file->preload_ptr = 0;
  569. }
  570. }
  573. int quicktime_get_timescale(float frame_rate)
  574. {
  575. int timescale = 600;
  576. /* Encode the 29.97, 23.976, 59.94 framerates as per DV freaks */
  577. if(frame_rate - (int)frame_rate != 0) timescale = (int)(frame_rate * 1001 + 0.5);
  578. else
  579. if((600 / frame_rate) - (int)(600 / frame_rate) != 0) timescale = (int)(frame_rate * 100 + 0.5);
  580. return timescale;
  581. }
  583. int quicktime_seek_end(quicktime_t *file)
  584. {
  585. quicktime_set_position(file, file->mdat.size + file->mdat.start);
  586. /*printf("quicktime_seek_end %ldn", file->mdat.size + file->mdat.start); */
  587. quicktime_update_positions(file);
  588. return 0;
  589. }
  591. int quicktime_seek_start(quicktime_t *file)
  592. {
  593. quicktime_set_position(file, file->mdat.start + HEADER_LENGTH);
  594. quicktime_update_positions(file);
  595. return 0;
  596. }
  598. long quicktime_audio_length(quicktime_t *file, int track)
  599. {
  600. if(file->total_atracks > 0) 
  601. return quicktime_track_samples(file, file->atracks[track].track);
  603. return 0;
  604. }
  606. long quicktime_video_length(quicktime_t *file, int track)
  607. {
  608. /*printf("quicktime_video_length %d %dn", quicktime_track_samples(file, file->vtracks[track].track), track); */
  609. if(file->total_vtracks > 0)
  610. return quicktime_track_samples(file, file->vtracks[track].track);
  611. return 0;
  612. }
  614. long quicktime_audio_position(quicktime_t *file, int track)
  615. {
  616. return file->atracks[track].current_position;
  617. }
  619. long quicktime_video_position(quicktime_t *file, int track)
  620. {
  621. return file->vtracks[track].current_position;
  622. }
  624. int quicktime_update_positions(quicktime_t *file)
  625. {
  626. /* Used for routines that change the positions of all tracks, like */
  627. /* seek_end and seek_start but not for routines that reposition one track, like */
  628. /* set_audio_position. */
  630. long mdat_offset = quicktime_position(file) - file->mdat.start;
  631. long sample, chunk, chunk_offset;
  632. int i;
  634. if(file->total_atracks)
  635. {
  636. sample = quicktime_offset_to_sample(file->atracks[0].track, mdat_offset);
  637. chunk = quicktime_offset_to_chunk(&chunk_offset, file->atracks[0].track, mdat_offset);
  638. for(i = 0; i < file->total_atracks; i++)
  639. {
  640. file->atracks[i].current_position = sample;
  641. file->atracks[i].current_chunk = chunk;
  642. }
  643. }
  645. if(file->total_vtracks)
  646. {
  647. sample = quicktime_offset_to_sample(file->vtracks[0].track, mdat_offset);
  648. chunk = quicktime_offset_to_chunk(&chunk_offset, file->vtracks[0].track, mdat_offset);
  649. for(i = 0; i < file->total_vtracks; i++)
  650. {
  651. file->vtracks[i].current_position = sample;
  652. file->vtracks[i].current_chunk = chunk;
  653. }
  654. }
  655. return 0;
  656. }
  658. int quicktime_set_audio_position(quicktime_t *file, long sample, int track)
  659. {
  660. long offset, chunk_sample, chunk;
  661. quicktime_trak_t *trak;
  663. if(file->total_atracks)
  664. {
  665. trak = file->atracks[track].track;
  666. file->atracks[track].current_position = sample;
  667. quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, sample);
  668. file->atracks[track].current_chunk = chunk;
  669. offset = quicktime_sample_to_offset(trak, sample);
  670. quicktime_set_position(file, offset);
  671. /*quicktime_update_positions(file); */
  672. }
  674. return 0;
  675. }
  677. int quicktime_set_video_position(quicktime_t *file, long frame, int track)
  678. {
  679. long offset, chunk_sample, chunk;
  680. quicktime_trak_t *trak;
  682. if(file->total_vtracks)
  683. {
  684. trak = file->vtracks[track].track;
  685. file->vtracks[track].current_position = frame;
  686. quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, frame);
  687. file->vtracks[track].current_chunk = chunk;
  688. offset = quicktime_sample_to_offset(trak, frame);
  689. quicktime_set_position(file, offset);
  690. /*quicktime_update_positions(file); */
  691. }
  692. return 0;
  693. }
  695. int quicktime_has_audio(quicktime_t *file)
  696. {
  697. if(quicktime_audio_tracks(file)) return 1;
  698. return 0;
  699. }
  701. long quicktime_audio_sample_rate(quicktime_t *file, int track)
  702. {
  703. if(file->total_atracks)
  704. return file->atracks[track].track->mdia.minf.stbl.stsd.table[0].sample_rate;
  705. return 0;
  706. }
  708. int quicktime_audio_bits(quicktime_t *file, int track)
  709. {
  710. if(file->total_atracks)
  711. return file->atracks[track].track->mdia.minf.stbl.stsd.table[0].sample_size;
  713. return 0;
  714. }
  716. int quicktime_audio_time_scale(quicktime_t *file, int track)
  717. {
  718. if(file->total_atracks) {
  719. return file->atracks[track].track->mdia.mdhd.time_scale;
  720. }
  721. return 0;
  722. }
  724. int quicktime_audio_sample_duration(quicktime_t *file, int track)
  725. {
  726. if(file->total_atracks) {
  727. return file->atracks[track].track->mdia.minf.stbl.stts.table[0].sample_duration;
  728. }
  729. return 0;
  730. }
  732. char* quicktime_audio_compressor(quicktime_t *file, int track)
  733. {
  734.   if (file->atracks[track].track == NULL)
  735.     return (NULL);
  736. return file->atracks[track].track->mdia.minf.stbl.stsd.table[0].format;
  737. }
  739. int quicktime_track_channels(quicktime_t *file, int track)
  740. {
  741. if(track < file->total_atracks)
  742. return file->atracks[track].channels;
  744. return 0;
  745. }
  747. int quicktime_channel_location(quicktime_t *file, int *quicktime_track, int *quicktime_channel, int channel)
  748. {
  749. int current_channel = 0, current_track = 0;
  750. *quicktime_channel = 0;
  751. *quicktime_track = 0;
  752. for(current_channel = 0, current_track = 0; current_track < file->total_atracks; )
  753. {
  754. if(channel >= current_channel)
  755. {
  756. *quicktime_channel = channel - current_channel;
  757. *quicktime_track = current_track;
  758. }
  760. current_channel += file->atracks[current_track].channels;
  761. current_track++;
  762. }
  763. return 0;
  764. }
  766. int quicktime_has_video(quicktime_t *file)
  767. {
  768. if(quicktime_video_tracks(file)) return 1;
  769. return 0;
  770. }
  772. int quicktime_video_width(quicktime_t *file, int track)
  773. {
  774. if(file->total_vtracks) {
  775. int width = 
  776. file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].width;
  777. if (width) {
  778. return width;
  779. }
  780. return file->vtracks[track].track->tkhd.track_width;
  781. }
  782. return 0;
  783. }
  785. int quicktime_video_height(quicktime_t *file, int track)
  786. {
  787. if(file->total_vtracks) {
  788. int height = file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].height;
  789. if (height) {
  790. return height;
  791. }
  792. return file->vtracks[track].track->tkhd.track_height;
  793. }
  794. return 0;
  795. }
  797. int quicktime_video_depth(quicktime_t *file, int track)
  798. {
  799. if(file->total_vtracks)
  800. return file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].depth;
  801. return 0;
  802. }
  804. int quicktime_set_depth(quicktime_t *file, int depth, int track)
  805. {
  806. int i;
  808. for(i = 0; i < file->total_vtracks; i++)
  809. {
  810. file->vtracks[i].track->mdia.minf.stbl.stsd.table[0].depth = depth;
  811. }
  812. }
  814. float quicktime_video_frame_rate(quicktime_t *file, int track)
  815. {
  816.   float ret = 0;
  817.   int num = 0;
  818.   
  819.   if(file->total_vtracks) {
  820.     ret = file->vtracks[track].track->mdia.mdhd.time_scale;
  821.     if (file->vtracks[track].track->mdia.minf.stbl.stts.table[0].sample_duration == 0)
  822.       num = 1;
  823.     ret /= 
  824. file->vtracks[track].track->mdia.minf.stbl.stts.table[num].sample_duration;
  825.   }
  826.   return ret;
  827. }
  829. char* quicktime_video_compressor(quicktime_t *file, int track)
  830. {
  831.   if (file->vtracks[track].track == NULL)
  832.     return (NULL);
  833.   
  834. return file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].format;
  835. }
  837. int quicktime_video_time_scale(quicktime_t *file, int track)
  838. {
  839. if(file->total_vtracks) {
  840. return file->vtracks[track].track->mdia.mdhd.time_scale;
  841. }
  842. return 0;
  843. }
  845. int quicktime_video_frame_time(quicktime_t *file, int track, long frame,
  846. long *start, int *duration)
  847. {
  848. quicktime_stts_t *stts;
  849. int i;
  850. long f;
  852. if (file->total_vtracks == 0) {
  853. return 0;
  854. }
  855. stts = &(file->vtracks[track].track->mdia.minf.stbl.stts);
  857. if (frame < file->last_frame) {
  858. /* we need to reset our cached values */
  859. file->last_frame = 0;
  860. file->last_start = 0;
  861. file->last_stts_index = 0;
  862. }
  864. i = file->last_stts_index;
  865. f = file->last_frame;
  866. *start = file->last_start;
  868. while (i < stts->total_entries) {
  869. if (f + stts->table[i].sample_count <= frame) {
  870. *start += stts->table[i].sample_duration 
  871. * stts->table[i].sample_count;
  872. f += stts->table[i].sample_count;
  873. i++;
  875. } else {
  876. /* cache the results for future use */
  877. file->last_stts_index = i;
  878. file->last_frame = f;
  879. file->last_start = *start;
  881. *start += stts->table[i].sample_duration * (frame - f);
  882. *duration = stts->table[i].sample_duration;
  884. return 1;
  885. }
  886. }
  888. /* error */
  889. return 0;
  890. }
  892. int quicktime_get_mp4_video_decoder_config(quicktime_t *file, int track, u_char** ppBuf, int* pBufSize)
  893. {
  894. quicktime_esds_t* esds;
  896. if (!file->total_vtracks) {
  897. return 0;
  898. }
  899. esds = &file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].esds;
  900. return quicktime_esds_get_decoder_config(esds, ppBuf, pBufSize);
  901. }
  903. int quicktime_set_mp4_video_decoder_config(quicktime_t *file, int track, u_char* pBuf, int bufSize)
  904. {
  905. quicktime_esds_t* esds;
  907. if (!file->total_vtracks) {
  908. return 0;
  909. }
  910. esds = &file->vtracks[track].track->mdia.minf.stbl.stsd.table[0].esds;
  911. return quicktime_esds_set_decoder_config(esds, pBuf, bufSize);
  912. }
  914. int quicktime_get_mp4_audio_decoder_config(quicktime_t *file, int track, u_char** ppBuf, int* pBufSize)
  915. {
  916. quicktime_esds_t* esds;
  918. if (!file->total_atracks) {
  919. return 0;
  920. }
  921. esds = &file->atracks[track].track->mdia.minf.stbl.stsd.table[0].esds;
  922. return quicktime_esds_get_decoder_config(esds, ppBuf, pBufSize);
  923. }
  925. int quicktime_set_mp4_audio_decoder_config(quicktime_t *file, int track, u_char* pBuf, int bufSize)
  926. {
  927. quicktime_esds_t* esds;
  929. if (!file->total_atracks) {
  930. return 0;
  931. }
  932. esds = &file->atracks[track].track->mdia.minf.stbl.stsd.table[0].esds;
  933. return quicktime_esds_set_decoder_config(esds, pBuf, bufSize);
  934. }
  936. long quicktime_samples_to_bytes(quicktime_trak_t *track, long samples)
  937. {
  938. return samples
  939. * track->mdia.minf.stbl.stsd.table[0].channels
  940. * track->mdia.minf.stbl.stsd.table[0].sample_size / 8;
  941. }
  943. int quicktime_write_audio(quicktime_t *file, char *audio_buffer, long samples, int track)
  944. {
  945. long offset;
  946. int result;
  947. long bytes;
  949. /* Defeat 32 bit file size limit. */
  950. if(quicktime_test_position(file)) return 1;
  952. /* write chunk for 1 track */
  953. bytes = samples * quicktime_audio_bits(file, track) / 8 * file->atracks[track].channels;
  954. offset = quicktime_position(file);
  955. result = quicktime_write_data(file, audio_buffer, bytes);
  957. if(result) result = 0; else result = 1; /* defeat fwrite's return */
  958. quicktime_update_tables(file, 
  959. file->atracks[track].track, 
  960. offset, 
  961. file->atracks[track].current_chunk, 
  962. file->atracks[track].current_position, 
  963. samples, 
  964. 0,
  965. 0,
  966. 0,
  967. 0);
  968. file->atracks[track].current_position += samples;
  969. file->atracks[track].current_chunk++;
  970. return result;
  971. }
  973. int quicktime_write_audio_frame(quicktime_t *file, unsigned char *audio_buffer, long bytes, int track)
  974. {
  975. long offset = quicktime_position(file);
  976. int result = 0;
  978. /* Defeat 32 bit file size limit. */
  979. if(quicktime_test_position(file)) return 1;
  981. result = quicktime_write_data(file, audio_buffer, bytes);
  982. if(result) result = 0; else result = 1;
  984. quicktime_update_tables(file,
  985. file->atracks[track].track,
  986. offset,
  987. file->atracks[track].current_chunk,
  988. file->atracks[track].current_position,
  989. 1, 
  990. bytes,
  991. 0,
  992. 0,
  993. 0);
  994. file->atracks[track].current_position += 1;
  995. file->atracks[track].current_chunk++;
  996. return result;
  997. }
  999. int quicktime_write_video_frame(quicktime_t *file, 
  1000. unsigned char *video_buffer, 
  1001. long bytes, 
  1002. int track, 
  1003. u_char isKeyFrame,
  1004. long duration,
  1005. long renderingOffset)
  1006. {
  1007. long offset = quicktime_position(file);
  1008. int result = 0;
  1010. /* Defeat 32 bit file size limit. */
  1011. if(quicktime_test_position(file)) return 1;
  1013. result = quicktime_write_data(file, video_buffer, bytes);
  1014. if(result) result = 0; else result = 1;
  1016. quicktime_update_tables(file,
  1017. file->vtracks[track].track,
  1018. offset,
  1019. file->vtracks[track].current_chunk,
  1020. file->vtracks[track].current_position,
  1021. 1,
  1022. bytes,
  1023. duration,
  1024. isKeyFrame,
  1025. renderingOffset);
  1026. file->vtracks[track].current_position += 1;
  1027. file->vtracks[track].current_chunk++;
  1028. return result;
  1029. }
  1031. static int quicktime_write_media_hint(quicktime_t* file,
  1032. u_char* hintBuffer,
  1033. long hintBufferSize,
  1034. quicktime_trak_t* hintTrak,
  1035. long* pSampleNumber,
  1036. long hintSampleDuration,
  1037. u_char isSyncSample)
  1038. {
  1040. long offset = quicktime_position(file);
  1041. quicktime_hint_info_t hintInfo;
  1042. int result = 0;
  1044. /* handle 32 bit file size limit */
  1045. if (quicktime_test_position(file)) {
  1046. return 1;
  1047. }
  1049. /* get info about this hint */
  1050. quicktime_get_hint_info(hintBuffer, hintBufferSize, &hintInfo);
  1052. /* update overall info */
  1053. hintTrak->hint_udta.hinf.trpy.numBytes += hintInfo.trpy; 
  1054. hintTrak->hint_udta.hinf.nump.numPackets += hintInfo.nump;
  1055. hintTrak->hint_udta.hinf.tpyl.numBytes += hintInfo.tpyl;
  1056. hintTrak->hint_udta.hinf.dmed.numBytes += hintInfo.dmed;
  1057. hintTrak->hint_udta.hinf.drep.numBytes += hintInfo.drep;
  1058. hintTrak->hint_udta.hinf.dimm.numBytes += hintInfo.dimm;
  1059. hintTrak->hint_udta.hinf.tmin.milliSecs = 
  1060. MAX(hintInfo.tmin, hintTrak->hint_udta.hinf.tmin.milliSecs);
  1061. hintTrak->hint_udta.hinf.tmax.milliSecs = 
  1062. MAX(hintInfo.tmax, hintTrak->hint_udta.hinf.tmax.milliSecs);
  1063. hintTrak->hint_udta.hinf.pmax.numBytes = 
  1064. MAX(hintInfo.pmax, hintTrak->hint_udta.hinf.pmax.numBytes);
  1066. hintTrak->mdia.minf.hmhd.maxPDUsize = 
  1067. hintTrak->hint_udta.hinf.pmax.numBytes;
  1068. hintTrak->mdia.minf.hmhd.avgPDUsize = 
  1069. hintTrak->hint_udta.hinf.trpy.numBytes
  1070. / hintTrak->hint_udta.hinf.nump.numPackets;
  1072. /* write the hint data */
  1073. result = quicktime_write_data(file, hintBuffer, hintBufferSize);
  1074. result = (result ? 0 : 1);
  1076. quicktime_update_tables(file, hintTrak, offset, *pSampleNumber + 1,
  1077. *pSampleNumber, 1, hintBufferSize, hintSampleDuration, isSyncSample, 0);
  1078. (*pSampleNumber)++;
  1079. return result;
  1080. }
  1082. int quicktime_write_audio_hint(quicktime_t *file, 
  1083. unsigned char *hintBuffer, 
  1084. long hintBufferSize, 
  1085. int audioTrack,
  1086. int hintTrack,
  1087. long hintSampleDuration)
  1088. {
  1089. quicktime_trak_t* hintTrak = 
  1090. file->atracks[audioTrack].hintTracks[hintTrack];
  1092. return quicktime_write_media_hint(file, hintBuffer, hintBufferSize,
  1093. hintTrak, &(file->atracks[audioTrack].hintPositions[hintTrack]),
  1094. hintSampleDuration, 0);
  1095. }
  1097. int quicktime_write_video_hint(quicktime_t *file, 
  1098. unsigned char *hintBuffer, 
  1099. long hintBufferSize, 
  1100. int videoTrack,
  1101. int hintTrack,
  1102. long hintSampleDuration,
  1103. u_char isKeyFrame)
  1104. {
  1105. quicktime_trak_t* hintTrak = 
  1106. file->vtracks[videoTrack].hintTracks[hintTrack];
  1108. return quicktime_write_media_hint(file, hintBuffer, hintBufferSize,
  1109. hintTrak, &(file->vtracks[videoTrack].hintPositions[hintTrack]), 
  1110. hintSampleDuration, isKeyFrame);
  1111. }
  1113. FILE* quicktime_get_fd(quicktime_t *file)
  1114. {
  1115. if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  1116. return file->stream;
  1117. }
  1119. int quicktime_write_frame_init(quicktime_t *file, int track)
  1120. {
  1121. if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  1122. file->offset = quicktime_position(file);
  1123. return 0;
  1124. }
  1126. int quicktime_write_frame_end(quicktime_t *file, int track)
  1127. {
  1128. long bytes;
  1129. file->file_position = ftell(file->stream);
  1130. bytes = quicktime_position(file) - file->offset;
  1131. quicktime_update_tables(file,
  1132. file->vtracks[track].track,
  1133. file->offset,
  1134. file->vtracks[track].current_chunk,
  1135. file->vtracks[track].current_position,
  1136. 1,
  1137. bytes,
  1138. 0,
  1139. 0,
  1140. 0);
  1141. file->vtracks[track].current_position += 1;
  1142. file->vtracks[track].current_chunk++;
  1143. return 0;
  1144. }
  1146. int quicktime_write_audio_init(quicktime_t *file, int track)
  1147. {
  1148. return quicktime_write_frame_init(file, track);
  1149. }
  1151. int quicktime_write_audio_end(quicktime_t *file, int track, long samples)
  1152. {
  1153. long bytes;
  1154. file->file_position = ftell(file->stream);
  1155. bytes = quicktime_position(file) - file->offset;
  1156. quicktime_update_tables(file, 
  1157. file->atracks[track].track,
  1158. file->offset,
  1159. file->atracks[track].current_chunk,
  1160. file->atracks[track].current_position,
  1161. samples,
  1162. bytes, 
  1163. 0,
  1164. 0,
  1165. 0);
  1166. file->atracks[track].current_position += samples;
  1167. file->atracks[track].current_chunk++;
  1168. return 0;
  1169. }
  1172. long quicktime_read_audio(quicktime_t *file, char *audio_buffer, long samples, int track)
  1173. {
  1174. long chunk_sample, chunk;
  1175. int result = 1, track_num;
  1176. quicktime_trak_t *trak = file->atracks[track].track;
  1177. long fragment_len, chunk_end;
  1178. long position = file->atracks[track].current_position;
  1179. long start = position, end = position + samples;
  1180. long bytes, total_bytes = 0;
  1181. long buffer_offset;
  1183. quicktime_chunk_of_sample(&chunk_sample, &chunk, trak, position);
  1184. buffer_offset = 0;
  1186. while(position < end && result)
  1187. {
  1188. quicktime_set_audio_position(file, position, track);
  1189. fragment_len = quicktime_chunk_samples(trak, chunk);
  1190. chunk_end = chunk_sample + fragment_len;
  1191. fragment_len -= position - chunk_sample;
  1192. if(position + fragment_len > chunk_end) fragment_len = chunk_end - position;
  1193. if(position + fragment_len > end) fragment_len = end - position;
  1195. bytes = quicktime_samples_to_bytes(trak, fragment_len);
  1196. result = quicktime_read_data(file, &audio_buffer[buffer_offset], bytes);
  1198. total_bytes += bytes;
  1199. position += fragment_len;
  1200. chunk_sample = position;
  1201. buffer_offset += bytes;
  1202. chunk++;
  1203. }
  1205. file->atracks[track].current_position = position;
  1206. if(!result) return 0;
  1207. return total_bytes;
  1208. }
  1210. int quicktime_read_chunk(quicktime_t *file, char *output, int track, long chunk, long byte_start, long byte_len)
  1211. {
  1212. quicktime_set_position(file, quicktime_chunk_to_offset(file->atracks[track].track, chunk) + byte_start);
  1213. if(quicktime_read_data(file, output, byte_len)) return 0;
  1214. else
  1215. return 1;
  1216. }
  1218. long quicktime_frame_size(quicktime_t *file, long frame, int track)
  1219. {
  1220. int bytes;
  1221. quicktime_trak_t *trak = file->vtracks[track].track;
  1223. if(trak->mdia.minf.stbl.stsz.sample_size)
  1224. {
  1225. bytes = trak->mdia.minf.stbl.stsz.sample_size;
  1226. }
  1227. else
  1228. {
  1229. bytes = trak->mdia.minf.stbl.stsz.table[frame].size;
  1230. }
  1232. return bytes;
  1233. }
  1235. long quicktime_audio_frame_size(quicktime_t *file, long frame, int track)
  1236. {
  1237. int bytes;
  1238. quicktime_trak_t *trak = file->atracks[track].track;
  1240. if(trak->mdia.minf.stbl.stsz.sample_size)
  1241. {
  1242. bytes = trak->mdia.minf.stbl.stsz.sample_size;
  1243. }
  1244. else
  1245. {
  1246. bytes = trak->mdia.minf.stbl.stsz.table[frame].size;
  1247. }
  1249. return bytes;
  1250. }
  1252. long quicktime_read_audio_frame(quicktime_t *file, unsigned char *audio_buffer,  int maxBytes, int track)
  1253. {
  1254. long bytes;
  1255. int result = 0;
  1256. quicktime_trak_t *trak = file->atracks[track].track;
  1258. bytes = quicktime_audio_frame_size(file, 
  1259. file->atracks[track].current_position, track);
  1261. if (bytes > maxBytes) {
  1262. return -bytes;
  1263. }
  1265. quicktime_set_audio_position(file, 
  1266. file->atracks[track].current_position, track);
  1268. result = quicktime_read_data(file, audio_buffer, bytes);
  1270. file->atracks[track].current_position++;
  1272. if (!result)
  1273. return 0;
  1274. return bytes;
  1275. }
  1277. long quicktime_read_frame(quicktime_t *file, unsigned char *video_buffer, int track)
  1278. {
  1279. long bytes;
  1280. int result = 0;
  1282. quicktime_trak_t *trak = file->vtracks[track].track;
  1283. bytes = quicktime_frame_size(file, file->vtracks[track].current_position, track);
  1285. if(!file->vtracks[track].frames_cached)
  1286. {
  1287. quicktime_set_video_position(file, file->vtracks[track].current_position, track);
  1288. result = quicktime_read_data(file, video_buffer, bytes);
  1289. }
  1290. else
  1291. {
  1292. int i;
  1293. unsigned char *cached_frame;
  1295. if(file->vtracks[track].current_position >= file->vtracks[track].frames_cached) result = 1;
  1296. if(!result)
  1297. {
  1298. cached_frame = file->vtracks[track].frame_cache[file->vtracks[track].current_position];
  1300. for(i = 0; i < bytes; i++)
  1301. video_buffer[i] = cached_frame[i];
  1302. }
  1303. }
  1304. file->vtracks[track].current_position++;
  1306. if(!result) return 0;
  1307. return bytes;
  1308. }
  1310. int quicktime_read_frame_init(quicktime_t *file, int track)
  1311. {
  1312. quicktime_trak_t *trak = file->vtracks[track].track;
  1313. quicktime_set_video_position(file, file->vtracks[track].current_position, track);
  1314. if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  1315. return 0;
  1316. }
  1318. int quicktime_read_frame_end(quicktime_t *file, int track)
  1319. {
  1320. file->file_position = ftell(file->stream);
  1321. file->vtracks[track].current_position++;
  1322. return 0;
  1323. }
  1325. int quicktime_init_video_map(quicktime_video_map_t *vtrack, quicktime_trak_t *trak)
  1326. {
  1327. vtrack->track = trak;
  1328. vtrack->current_position = 0;
  1329. vtrack->current_chunk = 1;
  1330. vtrack->frame_cache = 0;
  1331. vtrack->frames_cached = 0;
  1332. return 0;
  1333. }
  1335. int quicktime_delete_video_map(quicktime_video_map_t *vtrack)
  1336. {
  1337. int i;
  1338. if(vtrack->frames_cached)
  1339. {
  1340. for(i = 0; i < vtrack->frames_cached; i++)
  1341. {
  1342. free(vtrack->frame_cache[i]);
  1343. }
  1344. free(vtrack->frame_cache);
  1345. vtrack->frames_cached = 0;
  1346. }
  1347. return 0;
  1348. }
  1350. int quicktime_init_audio_map(quicktime_audio_map_t *atrack, quicktime_trak_t *trak)
  1351. {
  1352. atrack->track = trak;
  1353. atrack->channels = trak->mdia.minf.stbl.stsd.table[0].channels;
  1354. atrack->current_position = 0;
  1355. atrack->current_chunk = 1;
  1356. return 0;
  1357. }
  1359. int quicktime_delete_audio_map(quicktime_audio_map_t *atrack)
  1360. {
  1361. int i;
  1362. return 0;
  1363. }
  1365. int quicktime_read_info(quicktime_t *file)
  1366. {
  1367. int result = 0, found_moov = 0;
  1368. int i, j, k, m, channel, trak_channel, track;
  1369. long start_position = quicktime_position(file);
  1370. quicktime_atom_t leaf_atom;
  1371. quicktime_trak_t *trak;
  1372. char avi_test[4];
  1374. /* Check for Microsoft AVI */
  1375. quicktime_read_char32(file, avi_test);
  1376. if(quicktime_match_32(avi_test, "RIFF"))
  1377. {
  1378. quicktime_read_char32(file, avi_test);
  1379. quicktime_read_char32(file, avi_test);
  1380. if(quicktime_match_32(avi_test, "AVI "))
  1381. file->use_avi = 1;
  1382. }
  1384. quicktime_set_position(file, 0);
  1386. do
  1387. {
  1388. result = quicktime_atom_read_header(file, &leaf_atom);
  1389. if(!result)
  1390. {
  1391. if(quicktime_atom_is(&leaf_atom, "mdat")) {
  1392. quicktime_read_mdat(file, &(file->mdat), &leaf_atom);
  1393. } else if(quicktime_atom_is(&leaf_atom, "moov")) {
  1394. quicktime_read_moov(file, &(file->moov), &leaf_atom);
  1395. found_moov = 1;
  1396. } else {
  1397. quicktime_atom_skip(file, &leaf_atom);
  1398. }
  1399. }
  1400. }while(!result && quicktime_position(file) < file->total_length);
  1402. /* go back to the original position */
  1403. quicktime_set_position(file, start_position);
  1405. if(found_moov) {
  1407. /* get tables for all the different tracks */
  1408. file->total_atracks = quicktime_audio_tracks(file);
  1409. file->atracks = (quicktime_audio_map_t*)calloc(1, 
  1410. sizeof(quicktime_audio_map_t) * file->total_atracks);
  1412. for(i = 0, track = 0; i < file->total_atracks; i++) {
  1413. while(!file->moov.trak[track]->mdia.minf.is_audio)
  1414. track++;
  1415. quicktime_init_audio_map(&(file->atracks[i]), file->moov.trak[track]);
  1416. }
  1418. file->total_vtracks = quicktime_video_tracks(file);
  1419. file->vtracks = (quicktime_video_map_t*)calloc(1, sizeof(quicktime_video_map_t) * file->total_vtracks);
  1421. for(track = 0, i = 0; i < file->total_vtracks; i++)
  1422. {
  1423. while(!file->moov.trak[track]->mdia.minf.is_video)
  1424. track++;
  1426. quicktime_init_video_map(&(file->vtracks[i]), file->moov.trak[track]);
  1427. }
  1429. /* for all tracks */
  1430. for (track = 0; track < file->moov.total_tracks; track++) {
  1432. /* check if it's a hint track */
  1433. if (!file->moov.trak[track]->mdia.minf.is_hint) {
  1434. continue;
  1435. }
  1437. /* it is, so for each reference */
  1438. for (j = 0; j < file->moov.trak[track]->tref.hint.numTracks; j++) {
  1440. /* get the reference track id */
  1441. long refTrackId = file->moov.trak[track]->tref.hint.trackIds[j]; 
  1442. /* check each audio track */
  1443. for(k = 0; k < file->total_atracks; k++) {
  1444. if (file->atracks[k].track->tkhd.track_id == refTrackId) {
  1445. int m = file->atracks[k].totalHintTracks++;
  1446. file->atracks[k].hintTracks[m] = file->moov.trak[track];
  1447. file->atracks[k].hintPositions[m] = 0;
  1448. file->moov.trak[track]->tref.hint.traks[j] = 
  1449. file->atracks[k].track;
  1450. file->total_hint_tracks++;
  1451. break;
  1452. }
  1453. }
  1455. /* check each video track */
  1456. for(k = 0; k < file->total_vtracks; k++) {
  1457. if (file->vtracks[k].track->tkhd.track_id == refTrackId) {
  1458. int m = file->vtracks[k].totalHintTracks++;
  1459. file->vtracks[k].hintTracks[m] = file->moov.trak[track];
  1460. file->vtracks[k].hintPositions[m] = 0;
  1461. file->moov.trak[track]->tref.hint.traks[j] = 
  1462. file->vtracks[k].track;
  1463. file->total_hint_tracks++;
  1464. break;
  1465. }
  1466. }
  1467. }
  1468. }
  1469. }
  1471. if(found_moov) 
  1472. return 0; 
  1473. else 
  1474. return 1;
  1475. }
  1478. int quicktime_dump(quicktime_t *file)
  1479. {
  1480. printf("quicktime_dumpn");
  1481. printf("movie datan");
  1482. printf(" size %ldn", file->mdat.size);
  1483. printf(" start %ldn", file->mdat.start);
  1484. quicktime_moov_dump(&(file->moov));
  1485. return 0;
  1486. }
  1489. /* ================================== Entry points ========================== */
  1491. int quicktime_check_sig(const char *path)
  1492. {
  1493. quicktime_t file;
  1494. quicktime_atom_t leaf_atom;
  1495. int result1 = 0, result2 = 0;
  1497. quicktime_init(&file);
  1498. if(!(file.stream = fopen(path, "rb"))) 
  1499. {
  1500. perror("quicktime_check_sig");
  1501. return 0;
  1502. }
  1504. fseek(file.stream, 0, SEEK_END);
  1505. file.total_length = ftell(file.stream);
  1506. fseek(file.stream, 0, SEEK_SET);
  1508. do
  1509. {
  1510. result1 = quicktime_atom_read_header(&file, &leaf_atom);
  1512. if(!result1)
  1513. {
  1514. /* just want the "moov" atom */
  1515. if(quicktime_atom_is(&leaf_atom, "moov"))
  1516. {
  1517. result2 = 1;
  1518. }
  1519. else
  1520. quicktime_atom_skip(&file, &leaf_atom);
  1521. }
  1522. }while(!result1 && !result2 && quicktime_position(&file) < file.total_length);
  1524. fclose(file.stream);
  1526. quicktime_delete(&file);
  1527. return result2;
  1528. }
  1530. quicktime_t* quicktime_open(char *filename, int rd, int wr, int append)
  1531. {
  1532. quicktime_t *new_file = malloc(sizeof(quicktime_t));
  1533. char flags[10];
  1534. int exists = 0;
  1536. quicktime_init(new_file);
  1537. new_file->wr = wr;
  1538. new_file->rd = rd;
  1539. new_file->mdat.start = 0;
  1541. if (!strcmp(&filename[strlen(filename)-4], ".mp4")) {
  1542. new_file->use_mp4 = TRUE;
  1543. } else {
  1544. new_file->use_mp4 = FALSE;
  1545. }
  1547. if(rd && (new_file->stream = fopen(filename, "rb")))
  1548. {
  1549. exists = 1; 
  1550. fclose(new_file->stream); 
  1551. new_file->stream = NULL;
  1552. }
  1555. if(rd && !wr) 
  1556. sprintf(flags, "rb");
  1557. else if(!rd && wr) 
  1558. sprintf(flags, "wb");
  1559. else if(rd && wr)
  1560. {
  1561. if(exists) 
  1562. sprintf(flags, "rb+");
  1563. else
  1564. sprintf(flags, "wb+");
  1565. }
  1567. if(!(new_file->stream = fopen(filename, flags)))
  1568. {
  1569. perror("quicktime_open");
  1570. free(new_file);
  1571. return 0;
  1572. }
  1575. if(rd && exists)
  1576. {
  1577. fseek(new_file->stream, 0, SEEK_END);
  1578. new_file->total_length = ftell(new_file->stream);
  1580. fseek(new_file->stream, 0, SEEK_SET);
  1582. if(quicktime_read_info(new_file))
  1583. {
  1584. quicktime_close(new_file);
  1585. new_file = 0;
  1586. }
  1587. }
  1589. if(wr) {
  1590. if(!exists || !append) {
  1591. /* start the data atom */
  1592. quicktime_write_int32(new_file, 0);
  1593. quicktime_write_char32(new_file, "mdat");
  1594. } else {
  1595. quicktime_set_position(new_file,
  1596.  new_file->mdat.start + new_file->mdat.size);
  1597. fseek(new_file->stream, 
  1598.  new_file->mdat.start + new_file->mdat.size, SEEK_SET);
  1599. }
  1600. }
  1601. return new_file;
  1602. }
  1604. int quicktime_write(quicktime_t *file)
  1605. {
  1606. int result = -1;
  1608. if(!file->wr) {
  1609. return result;
  1610. }
  1612. quicktime_write_mdat(file, &(file->mdat));
  1613. quicktime_write_moov(file, &(file->moov));
  1615. result = fclose(file->stream);
  1616. file->stream = NULL;
  1617. return result;
  1618. }
  1620. int quicktime_destroy(quicktime_t *file)
  1621. {
  1622. quicktime_delete(file);
  1623. free(file);
  1624. return 0;
  1625. }
  1627. int quicktime_close(quicktime_t *file)
  1628. {
  1629. int result;
  1630. if(file->wr)
  1631. {
  1632. quicktime_write_mdat(file, &(file->mdat));
  1633. quicktime_write_moov(file, &(file->moov));
  1634. }
  1635. result = fclose(file->stream);
  1637. quicktime_delete(file);
  1638. free(file);
  1639. return result;
  1640. }