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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mp4creator.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2001-2002.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  */
  22. #define MP4CREATOR_GLOBALS
  23. #include "mp4creator.h"
  24. #include "mpeg4ip_getopt.h"
  26. // forward declarations
  28. MP4TrackId* CreateMediaTracks(
  29. MP4FileHandle mp4File, 
  30. const char* inputFileName);
  32. void CreateHintTrack(
  33. MP4FileHandle mp4File, 
  34. MP4TrackId mediaTrackId,
  35. const char* payloadName, 
  36. bool interleave, 
  37. u_int16_t maxPayloadSize);
  39. void ExtractTrack(
  40. MP4FileHandle mp4File, 
  41. MP4TrackId trackId, 
  42. const char* outputFileName);
  44. // external declarations
  46. // track creators
  47. MP4TrackId* AviCreator(
  48. MP4FileHandle mp4File, const char* aviFileName);
  50. MP4TrackId AacCreator(
  51. MP4FileHandle mp4File, FILE* inFile);
  53. MP4TrackId Mp3Creator(
  54. MP4FileHandle mp4File, FILE* inFile);
  56. MP4TrackId Mp4vCreator(
  57. MP4FileHandle mp4File, FILE* inFile);
  60. // main routine
  61. int main(int argc, char** argv)
  62. {
  63. char* usageString = 
  64. "usage: %s <options> <mp4-file>n"
  65. "  Options:n"
  66. "  -create=<input-file>    Create track from <input-file>n"
  67. "    input files can be of type: .aac .mp3 .divx .mp4v .m4v .cmp .xvidn"
  68. "  -extract=<track-id>     Extract a trackn"
  69. "  -delete=<track-id>      Delete a trackn"
  70. "  -hint[=<track-id>]      Create hint track, also -Hn"
  71. "  -interleave             Use interleaved audio payload format, also -In"
  72. "  -list                   List tracks in mp4 filen"
  73. "  -mtu=<size>             MTU for hint trackn"
  74. "  -optimize               Optimize mp4 file layoutn"
  75.         "  -payload=<payload>      Rtp payload type n"
  76.                 "                          (use 3119 or mpa-robust for mp3 rfc 3119 support)n"
  77. "  -rate=<fps>             Video frame rate, e.g. 30 or 29.97n"
  78. "  -timescale=<ticks>      Time scale (ticks per second)n"
  79. "  -verbose[=[1-5]]        Enable debug messagesn"
  80.         "  -version                Display version informationn"
  81. ;
  83. bool doCreate = false;
  84. bool doExtract = false;
  85. bool doDelete = false;
  86. bool doHint = false;
  87. bool doList = false;
  88. bool doOptimize = false;
  89. bool doInterleave = false;
  90. char* mp4FileName = NULL;
  91. char* inputFileName = NULL;
  92. char* outputFileName = NULL;
  93. char* payloadName = NULL;
  94. MP4TrackId hintTrackId = MP4_INVALID_TRACK_ID;
  95. MP4TrackId extractTrackId = MP4_INVALID_TRACK_ID;
  96. MP4TrackId deleteTrackId = MP4_INVALID_TRACK_ID;
  97. u_int16_t maxPayloadSize = 1460;
  99. Verbosity = MP4_DETAILS_ERROR;
  100. VideoFrameRate = 0; // determine from input file
  101. Mp4TimeScale = 90000;
  103. // begin processing command line
  104. ProgName = argv[0];
  106. while (true) {
  107. int c = -1;
  108. int option_index = 0;
  109. static struct option long_options[] = {
  110. { "create", 1, 0, 'c' },
  111. { "delete", 1, 0, 'd' },
  112. { "extract", 1, 0, 'e' },
  113. { "help", 0, 0, '?' },
  114. { "hint", 2, 0, 'H' },
  115. { "interleave", 0, 0, 'I' },
  116. { "list", 0, 0, 'l' },
  117. { "mtu", 1, 0, 'm' },
  118. { "optimize", 0, 0, 'O' },
  119. { "payload", 1, 0, 'p' },
  120. { "rate", 1, 0, 'r' },
  121. { "timescale", 1, 0, 't' },
  122. { "verbose", 2, 0, 'v' },
  123. { "version", 0, 0, 'V' },
  124. { NULL, 0, 0, 0 }
  125. };
  127. c = getopt_long_only(argc, argv, "c:d:e:H::Ilm:Op:r:t:v::V",
  128. long_options, &option_index);
  130. if (c == -1)
  131. break;
  133. switch (c) {
  134. case 'c':
  135. doCreate = true;
  136. inputFileName = optarg;
  137. break;
  138. case 'd':
  139. if (sscanf(optarg, "%u", &deleteTrackId) != 1) {
  140. fprintf(stderr, 
  141. "%s: bad track-id specified: %sn",
  142.  ProgName, optarg);
  143. exit(EXIT_COMMAND_LINE);
  144. }
  145. doDelete = true;
  146. break;
  147. case 'e':
  148. if (sscanf(optarg, "%u", &extractTrackId) != 1) {
  149. fprintf(stderr, 
  150. "%s: bad track-id specified: %sn",
  151.  ProgName, optarg);
  152. exit(EXIT_COMMAND_LINE);
  153. }
  154. doExtract = true;
  155. break;
  156. case 'H':
  157. doHint = true;
  158. if (optarg) {
  159. if (sscanf(optarg, "%u", &hintTrackId) != 1) {
  160. fprintf(stderr, 
  161. "%s: bad track-id specified: %sn",
  162.  ProgName, optarg);
  163. exit(EXIT_COMMAND_LINE);
  164. }
  165. }
  166. break;
  167. case 'I':
  168. doInterleave = true;
  169. break;
  170. case 'l':
  171. doList = true;
  172. break;
  173. case 'm':
  174. u_int32_t mtu;
  175. if (sscanf(optarg, "%u", &mtu) != 1 || mtu < 64) {
  176. fprintf(stderr, 
  177. "%s: bad mtu specified: %sn",
  178.  ProgName, optarg);
  179. exit(EXIT_COMMAND_LINE);
  180. }
  181. maxPayloadSize = mtu - 40; // subtract IP, UDP, and RTP hdrs
  182. break;
  183. case 'O':
  184. doOptimize = true;
  185. break;
  186. case 'p':
  187. payloadName = optarg;
  188. break;
  189. case 'r':
  190. if (sscanf(optarg, "%f", &VideoFrameRate) != 1) {
  191. fprintf(stderr, 
  192. "%s: bad rate specified: %sn",
  193.  ProgName, optarg);
  194. exit(EXIT_COMMAND_LINE);
  195. }
  196. break;
  197. case 't':
  198. if (sscanf(optarg, "%u", &Mp4TimeScale) != 1) {
  199. fprintf(stderr, 
  200. "%s: bad timescale specified: %sn",
  201.  ProgName, optarg);
  202. exit(EXIT_COMMAND_LINE);
  203. }
  204. break;
  205. case 'v':
  206. Verbosity |= (MP4_DETAILS_READ | MP4_DETAILS_WRITE);
  207. if (optarg) {
  208. u_int32_t level;
  209. if (sscanf(optarg, "%u", &level) == 1) {
  210. if (level >= 2) {
  211. Verbosity |= MP4_DETAILS_TABLE;
  212. } 
  213. if (level >= 3) {
  214. Verbosity |= MP4_DETAILS_SAMPLE;
  215. } 
  216. if (level >= 4) {
  217. Verbosity |= MP4_DETAILS_HINT;
  218. } 
  219. if (level >= 5) {
  220. Verbosity = MP4_DETAILS_ALL;
  221. } 
  222. }
  223. }
  224. break;
  225. case '?':
  226. fprintf(stderr, usageString, ProgName);
  227. exit(EXIT_SUCCESS);
  228. case 'V':
  229.   fprintf(stderr, "%s - %s version %sn", 
  230.   ProgName, PACKAGE, VERSION);
  231.   exit(EXIT_SUCCESS);
  232. default:
  233. fprintf(stderr, "%s: unknown option specified, ignoring: %cn", 
  234. ProgName, c);
  235. }
  236. }
  238. // check that we have at least one non-option argument
  239. if ((argc - optind) < 1) {
  240. fprintf(stderr, usageString, ProgName);
  241. exit(EXIT_COMMAND_LINE);
  242. }
  244. if ((argc - optind) == 1) {
  245. mp4FileName = argv[optind++];
  246. } else {
  247. // it appears we have two file names
  248. if (doExtract) {
  249. mp4FileName = argv[optind++];
  250. outputFileName = argv[optind++];
  251. } else {
  252. if (inputFileName == NULL) {
  253. // then assume -c for the first file name
  254. doCreate = true;
  255. inputFileName = argv[optind++];
  256. }
  257. mp4FileName = argv[optind++];
  258. }
  259. }
  261. // warn about extraneous non-option arguments
  262. if (optind < argc) {
  263. fprintf(stderr, "%s: unknown options specified, ignoring: ", ProgName);
  264. while (optind < argc) {
  265. fprintf(stderr, "%s ", argv[optind++]);
  266. }
  267. fprintf(stderr, "n");
  268. }
  270. // operations consistency checks
  272. if (!doList && !doCreate && !doHint 
  273.   && !doOptimize && !doExtract && !doDelete) {
  274. fprintf(stderr, 
  275. "%s: no operation specifiedn",
  276.  ProgName);
  277. exit(EXIT_COMMAND_LINE);
  278. }
  279. if ((doCreate || doHint) && doExtract) {
  280. fprintf(stderr, 
  281. "%s: extract operation must be done separatelyn",
  282.  ProgName);
  283. exit(EXIT_COMMAND_LINE);
  284. }
  285. if ((doCreate || doHint) && doDelete) {
  286. fprintf(stderr, 
  287. "%s: delete operation must be done separatelyn",
  288.  ProgName);
  289. exit(EXIT_COMMAND_LINE);
  290. }
  291. if (doExtract && doDelete) {
  292. fprintf(stderr, 
  293. "%s: extract and delete operations must be done separatelyn",
  294.  ProgName);
  295. exit(EXIT_COMMAND_LINE);
  296. }
  298. // end processing of command line
  300. if (doList) {
  301. // just want the track listing
  302. char* info = MP4FileInfo(mp4FileName);
  304. if (!info) {
  305. fprintf(stderr, 
  306. "%s: can't open %sn", 
  307. ProgName, mp4FileName);
  308. exit(EXIT_INFO);
  309. }
  311. fputs(info, stdout);
  312. free(info);
  313. exit(EXIT_SUCCESS);
  314. }
  316. // test if mp4 file exists
  317. bool mp4FileExists = (access(mp4FileName, F_OK) == 0);
  319. MP4FileHandle mp4File;
  321. if (doCreate || doHint) {
  322. if (!mp4FileExists) {
  323. if (doCreate) {
  324. mp4File = MP4Create(mp4FileName, Verbosity);
  325. if (mp4File) {
  326. MP4SetTimeScale(mp4File, Mp4TimeScale);
  327. }
  328. } else {
  329. fprintf(stderr,
  330. "%s: can't hint track in file that doesn't existn", 
  331. ProgName);
  332. exit(EXIT_CREATE_FILE);
  333. }
  334. } else {
  335. mp4File = MP4Modify(mp4FileName, Verbosity);
  336. }
  338. if (!mp4File) {
  339. // mp4 library should have printed a message
  340. exit(EXIT_CREATE_FILE);
  341. }
  343. bool allMpeg4Streams = true;
  345. if (doCreate) {
  346. MP4TrackId* pCreatedTrackIds = 
  347. CreateMediaTracks(mp4File, inputFileName);
  349. if (pCreatedTrackIds) {
  350. // decide if we can raise the ISMA compliance tag in SDP
  351. // we do this if audio and/or video are MPEG-4
  352. MP4TrackId* pTrackId = pCreatedTrackIds;
  354. while (*pTrackId != MP4_INVALID_TRACK_ID) {
  355. const char *type =
  356. MP4GetTrackType(mp4File, *pTrackId);
  358. if (!strcmp(type, MP4_AUDIO_TRACK_TYPE)) { 
  359. allMpeg4Streams &=
  360. (MP4GetTrackAudioType(mp4File, *pTrackId) 
  361. == MP4_MPEG4_AUDIO_TYPE);
  363. } else if (!strcmp(type, MP4_VIDEO_TRACK_TYPE)) { 
  364. allMpeg4Streams &=
  365. (MP4GetTrackVideoType(mp4File, *pTrackId)
  366. == MP4_MPEG4_VIDEO_TYPE);
  367. }
  368. pTrackId++;
  369. }
  370. }
  372. if (pCreatedTrackIds && doHint) {
  373. MP4TrackId* pTrackId = pCreatedTrackIds;
  375. while (*pTrackId != MP4_INVALID_TRACK_ID) {
  376. CreateHintTrack(mp4File, *pTrackId, 
  377. payloadName, doInterleave, maxPayloadSize);
  378. pTrackId++;
  379. }
  380. }
  381. } else {
  382. CreateHintTrack(mp4File, hintTrackId, 
  383. payloadName, doInterleave, maxPayloadSize);
  384. } 
  386. MP4Close(mp4File);
  388. if (doCreate) {
  389. // this creates simple MPEG-4 OD and BIFS streams
  390. MP4MakeIsmaCompliant(mp4FileName, Verbosity, allMpeg4Streams);
  391. }
  394. } else if (doExtract) {
  395. if (!mp4FileExists) {
  396. fprintf(stderr,
  397. "%s: can't extract track in file that doesn't existn", 
  398. ProgName);
  399. exit(EXIT_CREATE_FILE);
  400. }
  402. mp4File = MP4Read(mp4FileName, Verbosity);
  403. if (!mp4File) {
  404. // mp4 library should have printed a message
  405. exit(EXIT_CREATE_FILE);
  406. }
  408. char tempName[PATH_MAX];
  409. if (outputFileName == NULL) {
  410. snprintf(tempName, sizeof(tempName), 
  411. "%s.t%u", mp4FileName, extractTrackId);
  412. outputFileName = tempName;
  413. }
  415. ExtractTrack(mp4File, extractTrackId, outputFileName);
  417. MP4Close(mp4File);
  419. } else if (doDelete) {
  420. if (!mp4FileExists) {
  421. fprintf(stderr,
  422. "%s: can't delete track in file that doesn't existn", 
  423. ProgName);
  424. exit(EXIT_CREATE_FILE);
  425. }
  427. mp4File = MP4Modify(mp4FileName, Verbosity);
  428. if (!mp4File) {
  429. // mp4 library should have printed a message
  430. exit(EXIT_CREATE_FILE);
  431. }
  433. MP4DeleteTrack(mp4File, deleteTrackId);
  435. MP4Close(mp4File);
  437. doOptimize = true; // to purge unreferenced track data
  438. }
  440. if (doOptimize) {
  441. if (!MP4Optimize(mp4FileName, NULL, Verbosity)) {
  442. // mp4 library should have printed a message
  443. exit(EXIT_OPTIMIZE_FILE);
  444. }
  445. }
  447. return(EXIT_SUCCESS);
  448. }
  450. MP4TrackId* CreateMediaTracks(MP4FileHandle mp4File, const char* inputFileName)
  451. {
  452. FILE* inFile = fopen(inputFileName, "rb");
  454. if (inFile == NULL) {
  455. fprintf(stderr, 
  456. "%s: can't open file %s: %sn",
  457. ProgName, inputFileName, strerror(errno));
  458. exit(EXIT_CREATE_MEDIA);
  459. }
  461. struct stat s;
  462. if (fstat(fileno(inFile), &s) < 0) {
  463. fprintf(stderr, 
  464. "%s: can't stat file %s: %sn",
  465. ProgName, inputFileName, strerror(errno));
  466. exit(EXIT_CREATE_MEDIA);
  467. }
  469. if (s.st_size == 0) {
  470. fprintf(stderr, 
  471. "%s: file %s is emptyn",
  472. ProgName, inputFileName);
  473. exit(EXIT_CREATE_MEDIA);
  474. }
  476. const char* extension = strrchr(inputFileName, '.');
  477. if (extension == NULL) {
  478. fprintf(stderr, 
  479. "%s: no file type extensionn", ProgName);
  480. exit(EXIT_CREATE_MEDIA);
  481. }
  483. static MP4TrackId trackIds[2] = {
  484. MP4_INVALID_TRACK_ID, MP4_INVALID_TRACK_ID
  485. };
  486. MP4TrackId* pTrackIds = trackIds;
  488. if (!strcasecmp(extension, ".avi")) {
  489. fclose(inFile);
  490. inFile = NULL;
  492. pTrackIds = AviCreator(mp4File, inputFileName);
  494. } else if (!strcasecmp(extension, ".aac")) {
  495. trackIds[0] = AacCreator(mp4File, inFile);
  497. } else if (!strcasecmp(extension, ".mp3")
  498.   || !strcasecmp(extension, ".mp1")
  499.   || !strcasecmp(extension, ".mp2")) {
  500. trackIds[0] = Mp3Creator(mp4File, inFile);
  502. } else if (!strcasecmp(extension, ".divx")
  503.   || !strcasecmp(extension, ".mp4v")
  504.   || !strcasecmp(extension, ".m4v")
  505.   || !strcasecmp(extension, ".xvid")
  506.   || !strcasecmp(extension, ".cmp")) {
  507. trackIds[0] = Mp4vCreator(mp4File, inFile);
  509. } else {
  510. fprintf(stderr, 
  511. "%s: unknown file typen", ProgName);
  512. exit(EXIT_CREATE_MEDIA);
  513. }
  515. if (inFile) {
  516. fclose(inFile);
  517. }
  519. return pTrackIds;
  520. }
  522. void CreateHintTrack(MP4FileHandle mp4File, MP4TrackId mediaTrackId,
  523. const char* payloadName, bool interleave, u_int16_t maxPayloadSize)
  524. {
  525. bool rc;
  527. if (MP4GetTrackNumberOfSamples(mp4File, mediaTrackId) == 0) {
  528. fprintf(stderr, 
  529. "%s: couldn't create hint track, no media samplesn", ProgName);
  530. exit(EXIT_CREATE_HINT);
  531. }
  533. // vector out to specific hinters
  534. const char* trackType = MP4GetTrackType(mp4File, mediaTrackId);
  536. if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE)) {
  537. u_int8_t audioType = MP4GetTrackAudioType(mp4File, mediaTrackId);
  539. switch (audioType) {
  540. case MP4_MPEG4_AUDIO_TYPE:
  541. case MP4_MPEG2_AAC_MAIN_AUDIO_TYPE:
  542. case MP4_MPEG2_AAC_LC_AUDIO_TYPE:
  543. case MP4_MPEG2_AAC_SSR_AUDIO_TYPE:
  544. rc = MP4AV_RfcIsmaHinter(mp4File, mediaTrackId, 
  545. interleave, maxPayloadSize);
  546. break;
  547. case MP4_MPEG1_AUDIO_TYPE:
  548. case MP4_MPEG2_AUDIO_TYPE:
  549. if (payloadName && 
  550.   (!strcasecmp(payloadName, "3119") 
  551.   || !strcasecmp(payloadName, "mpa-robust"))) {
  552. rc = MP4AV_Rfc3119Hinter(mp4File, mediaTrackId, 
  553. interleave, maxPayloadSize);
  554. } else {
  555. rc = MP4AV_Rfc2250Hinter(mp4File, mediaTrackId, 
  556. false, maxPayloadSize);
  557. }
  558. break;
  559. default:
  560. fprintf(stderr, 
  561. "%s: can't hint non-MPEG4/non-MP3 audio typen", ProgName);
  562. exit(EXIT_CREATE_HINT);
  563. }
  564. } else if (!strcmp(trackType, MP4_VIDEO_TRACK_TYPE)) {
  565. u_int8_t videoType = MP4GetTrackVideoType(mp4File, mediaTrackId);
  567. if (videoType == MP4_MPEG4_VIDEO_TYPE) {
  568. rc = MP4AV_Rfc3016Hinter(mp4File, mediaTrackId, maxPayloadSize);
  569. } else {
  570. fprintf(stderr, 
  571. "%s: can't hint non-MPEG4 video typen", ProgName);
  572. exit(EXIT_CREATE_HINT);
  573. }
  574. } else {
  575. fprintf(stderr, 
  576. "%s: can't hint track type %sn", ProgName, trackType);
  577. exit(EXIT_CREATE_HINT);
  578. }
  580. if (!rc) {
  581. fprintf(stderr, 
  582. "%s: error hinting track %un", ProgName, mediaTrackId);
  583. exit(EXIT_CREATE_HINT);
  584. }
  585. }
  587. void ExtractTrack(
  588. MP4FileHandle mp4File, 
  589. MP4TrackId trackId, 
  590. const char* outputFileName)
  591. {
  592. int outFd = open(outputFileName, 
  593. O_WRONLY | O_CREAT | O_TRUNC, 0644);
  595. if (outFd == -1) {
  596. fprintf(stderr, "%s: can't open %s: %sn",
  597. ProgName, outputFileName, strerror(errno));
  598. exit(EXIT_EXTRACT_TRACK);
  599. }
  601. // some track types have special needs
  602. // to properly recreate their raw ES file
  604. bool prependES = false;
  605. bool prependADTS = false;
  607. const char* trackType =
  608. MP4GetTrackType(mp4File, trackId);
  610. if (!strcmp(trackType, MP4_VIDEO_TRACK_TYPE)) {
  611. if (MP4_IS_MPEG4_VIDEO_TYPE(MP4GetTrackVideoType(mp4File, trackId))) {
  612. prependES = true;
  613. }
  614. } else if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE)) {
  615. if (MP4_IS_AAC_AUDIO_TYPE(MP4GetTrackAudioType(mp4File, trackId))) {
  616. prependADTS = true;
  617. }
  618. }
  620. MP4SampleId numSamples = 
  621. MP4GetTrackNumberOfSamples(mp4File, trackId);
  622. u_int8_t* pSample;
  623. u_int32_t sampleSize;
  625. // extraction loop
  626. for (MP4SampleId sampleId = 1 ; sampleId <= numSamples; sampleId++) {
  627. int rc;
  629. // signal to ReadSample() 
  630. // that it should malloc a buffer for us
  631. pSample = NULL;
  632. sampleSize = 0;
  634. if (prependADTS) {
  635. // need some very specialized work for these
  636. MP4AV_AdtsMakeFrameFromMp4Sample(
  637. mp4File,
  638. trackId,
  639. sampleId,
  640. &pSample,
  641. &sampleSize);
  642. } else {
  643. // read the sample
  644. rc = MP4ReadSample(
  645. mp4File, 
  646. trackId, 
  647. sampleId, 
  648. &pSample, 
  649. &sampleSize);
  651. if (rc == 0) {
  652. fprintf(stderr, "%s: read sample %u for %s failedn",
  653. ProgName, sampleId, outputFileName);
  654. exit(EXIT_EXTRACT_TRACK);
  655. }
  657. if (prependES && sampleId == 1) {
  658. u_int8_t* pConfig = NULL;
  659. u_int32_t configSize = 0;
  661. MP4GetTrackESConfiguration(mp4File, trackId, 
  662. &pConfig, &configSize);
  664. write(outFd, pConfig, configSize);
  666. free(pConfig);
  667. }
  668. }
  670. rc = write(outFd, pSample, sampleSize);
  672. if (rc == -1 || (u_int32_t)rc != sampleSize) {
  673. fprintf(stderr, "%s: write to %s failed: %sn",
  674. ProgName, outputFileName, strerror(errno));
  675. exit(EXIT_EXTRACT_TRACK);
  676. }
  678. free(pSample);
  679. }
  681. // close ES file
  682. close(outFd);
  683. }