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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mp4.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.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  */
  22. /* 
  23.  * MP4 library API functions
  24.  * 
  25.  * These are wrapper functions that provide C linkage conventions
  26.  * to the library, and catch any internal errors, ensuring that
  27.  * a proper return value is given.
  28.  */
  30. #include "mp4common.h"
  32. #define PRINT_ERROR(e) 
  33. VERBOSE_ERROR(((MP4File*)hFile)->GetVerbosity(), e->Print());
  35. /* file operations */
  37. extern "C" MP4FileHandle MP4Read(const char* fileName, u_int32_t verbosity)
  38. {
  39. MP4File* pFile = NULL;
  40. try {
  41. pFile = new MP4File(verbosity);
  42. pFile->Read(fileName);
  43. return (MP4FileHandle)pFile;
  44. }
  45. catch (MP4Error* e) {
  46. VERBOSE_ERROR(verbosity, e->Print());
  47. delete e;
  48. delete pFile;
  49. return MP4_INVALID_FILE_HANDLE;
  50. }
  51. }
  53. extern "C" MP4FileHandle MP4Create(const char* fileName, 
  54. u_int32_t verbosity, bool use64bits, bool useExtensibleFormat)
  55. {
  56. MP4File* pFile = NULL;
  57. try {
  58. pFile = new MP4File(verbosity);
  59. // LATER useExtensibleFormat, moov first, then mvex's
  60. pFile->Create(fileName, use64bits);
  61. return (MP4FileHandle)pFile;
  62. }
  63. catch (MP4Error* e) {
  64. VERBOSE_ERROR(verbosity, e->Print());
  65. delete e;
  66. delete pFile;
  67. return MP4_INVALID_FILE_HANDLE;
  68. }
  69. }
  71. extern "C" MP4FileHandle MP4Modify(const char* fileName, 
  72. u_int32_t verbosity, bool useExtensibleFormat)
  73. {
  74. MP4File* pFile = NULL;
  75. try {
  76. pFile = new MP4File(verbosity);
  77. // LATER useExtensibleFormat, moov first, then mvex's
  78. pFile->Modify(fileName);
  79. return (MP4FileHandle)pFile;
  80. }
  81. catch (MP4Error* e) {
  82. VERBOSE_ERROR(verbosity, e->Print());
  83. delete e;
  84. delete pFile;
  85. return MP4_INVALID_FILE_HANDLE;
  86. }
  87. }
  89. extern "C" bool MP4Optimize(const char* existingFileName, 
  90. const char* newFileName, 
  91. u_int32_t verbosity)
  92. {
  93. try {
  94. MP4File* pFile = new MP4File(verbosity);
  95. pFile->Optimize(existingFileName, newFileName);
  96. delete pFile;
  97. return true;
  98. }
  99. catch (MP4Error* e) {
  100. VERBOSE_ERROR(verbosity, e->Print());
  101. delete e;
  102. }
  103. return false;
  104. }
  106. extern "C" bool MP4Close(MP4FileHandle hFile)
  107. {
  108. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  109. try {
  110. ((MP4File*)hFile)->Close();
  111. delete (MP4File*)hFile;
  112. return true;
  113. }
  114. catch (MP4Error* e) {
  115. PRINT_ERROR(e);
  116. delete e;
  117. }
  118. }
  119. return false;
  120. }
  122. extern "C" bool MP4Dump(
  123. MP4FileHandle hFile, 
  124. FILE* pDumpFile, 
  125. bool dumpImplicits)
  126. {
  127. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  128. try {
  129. ((MP4File*)hFile)->Dump(pDumpFile, dumpImplicits);
  130. return true;
  131. }
  132. catch (MP4Error* e) {
  133. PRINT_ERROR(e);
  134. delete e;
  135. }
  136. }
  137. return false;
  138. }
  141. /* specific file properties */
  143. extern "C" u_int32_t MP4GetVerbosity(MP4FileHandle hFile)
  144. {
  145. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  146. try {
  147. return ((MP4File*)hFile)->GetVerbosity();
  148. }
  149. catch (MP4Error* e) {
  150. PRINT_ERROR(e);
  151. delete e;
  152. }
  153. }
  154. return 0;
  155. }
  157. extern "C" bool MP4SetVerbosity(MP4FileHandle hFile, u_int32_t verbosity)
  158. {
  159. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  160. try {
  161. ((MP4File*)hFile)->SetVerbosity(verbosity);
  162. return true;
  163. }
  164. catch (MP4Error* e) {
  165. PRINT_ERROR(e);
  166. delete e;
  167. }
  168. }
  169. return false;
  170. }
  172. extern "C" MP4Duration MP4GetDuration(MP4FileHandle hFile)
  173. {
  174. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  175. try {
  176. return ((MP4File*)hFile)->GetDuration();
  177. }
  178. catch (MP4Error* e) {
  179. PRINT_ERROR(e);
  180. delete e;
  181. }
  182. }
  183. return MP4_INVALID_DURATION;
  184. }
  186. extern "C" u_int32_t MP4GetTimeScale(MP4FileHandle hFile)
  187. {
  188. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  189. try {
  190. return ((MP4File*)hFile)->GetTimeScale();
  191. }
  192. catch (MP4Error* e) {
  193. PRINT_ERROR(e);
  194. delete e;
  195. }
  196. }
  197. return 0;
  198. }
  200. extern "C" bool MP4SetTimeScale(MP4FileHandle hFile, u_int32_t value)
  201. {
  202. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  203. try {
  204. ((MP4File*)hFile)->SetTimeScale(value);
  205. return true;
  206. }
  207. catch (MP4Error* e) {
  208. PRINT_ERROR(e);
  209. delete e;
  210. }
  211. }
  212. return false;
  213. }
  215. extern "C" u_int8_t MP4GetODProfileLevel(MP4FileHandle hFile)
  216. {
  217. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  218. try {
  219. return ((MP4File*)hFile)->GetODProfileLevel();
  220. }
  221. catch (MP4Error* e) {
  222. PRINT_ERROR(e);
  223. delete e;
  224. }
  225. }
  226. return 0;
  227. }
  229. extern "C" bool MP4SetODProfileLevel(MP4FileHandle hFile, u_int8_t value)
  230. {
  231. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  232. try {
  233. ((MP4File*)hFile)->SetODProfileLevel(value);
  234. return true;
  235. }
  236. catch (MP4Error* e) {
  237. PRINT_ERROR(e);
  238. delete e;
  239. }
  240. }
  241. return false;
  242. }
  244. extern "C" u_int8_t MP4GetSceneProfileLevel(MP4FileHandle hFile)
  245. {
  246. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  247. try {
  248. return ((MP4File*)hFile)->GetSceneProfileLevel();
  249. }
  250. catch (MP4Error* e) {
  251. PRINT_ERROR(e);
  252. delete e;
  253. }
  254. }
  255. return 0;
  256. }
  258. extern "C" bool MP4SetSceneProfileLevel(MP4FileHandle hFile, u_int8_t value)
  259. {
  260. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  261. try {
  262. ((MP4File*)hFile)->SetSceneProfileLevel(value);
  263. return true;
  264. }
  265. catch (MP4Error* e) {
  266. PRINT_ERROR(e);
  267. delete e;
  268. }
  269. }
  270. return false;
  271. }
  273. extern "C" u_int8_t MP4GetVideoProfileLevel(MP4FileHandle hFile)
  274. {
  275. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  276. try {
  277. return ((MP4File*)hFile)->GetVideoProfileLevel();
  278. }
  279. catch (MP4Error* e) {
  280. PRINT_ERROR(e);
  281. delete e;
  282. }
  283. }
  284. return 0;
  285. }
  287. extern "C" bool MP4SetVideoProfileLevel(MP4FileHandle hFile, u_int8_t value)
  288. {
  289. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  290. try {
  291. ((MP4File*)hFile)->SetVideoProfileLevel(value);
  292. return true;
  293. }
  294. catch (MP4Error* e) {
  295. PRINT_ERROR(e);
  296. delete e;
  297. }
  298. }
  299. return false;
  300. }
  302. extern "C" u_int8_t MP4GetAudioProfileLevel(MP4FileHandle hFile)
  303. {
  304. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  305. try {
  306. return ((MP4File*)hFile)->GetAudioProfileLevel();
  307. }
  308. catch (MP4Error* e) {
  309. PRINT_ERROR(e);
  310. delete e;
  311. }
  312. }
  313. return 0;
  314. }
  316. extern "C" bool MP4SetAudioProfileLevel(MP4FileHandle hFile, u_int8_t value)
  317. {
  318. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  319. try {
  320. ((MP4File*)hFile)->SetAudioProfileLevel(value);
  321. return true;
  322. }
  323. catch (MP4Error* e) {
  324. PRINT_ERROR(e);
  325. delete e;
  326. }
  327. }
  328. return false;
  329. }
  331. extern "C" u_int8_t MP4GetGraphicsProfileLevel(MP4FileHandle hFile)
  332. {
  333. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  334. try {
  335. return ((MP4File*)hFile)->GetGraphicsProfileLevel();
  336. }
  337. catch (MP4Error* e) {
  338. PRINT_ERROR(e);
  339. delete e;
  340. }
  341. }
  342. return 0;
  343. }
  345. extern "C" bool MP4SetGraphicsProfileLevel(MP4FileHandle hFile, u_int8_t value)
  346. {
  347. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  348. try {
  349. ((MP4File*)hFile)->SetGraphicsProfileLevel(value);
  350. return true;
  351. }
  352. catch (MP4Error* e) {
  353. PRINT_ERROR(e);
  354. delete e;
  355. }
  356. }
  357. return false;
  358. }
  360. /* generic file properties */
  362. extern "C" u_int64_t MP4GetIntegerProperty(
  363. MP4FileHandle hFile, const char* propName)
  364. {
  365. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  366. try {
  367. return ((MP4File*)hFile)->GetIntegerProperty(propName);
  368. }
  369. catch (MP4Error* e) {
  370. PRINT_ERROR(e);
  371. delete e;
  372. }
  373. }
  374. return (u_int64_t)-1;
  375. }
  377. extern "C" float MP4GetFloatProperty(
  378. MP4FileHandle hFile, const char* propName)
  379. {
  380. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  381. try {
  382. return ((MP4File*)hFile)->GetFloatProperty(propName);
  383. }
  384. catch (MP4Error* e) {
  385. PRINT_ERROR(e);
  386. delete e;
  387. }
  388. }
  389. return NAN;
  390. }
  392. extern "C" const char* MP4GetStringProperty(
  393. MP4FileHandle hFile, const char* propName)
  394. {
  395. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  396. try {
  397. return ((MP4File*)hFile)->GetStringProperty(propName);
  398. }
  399. catch (MP4Error* e) {
  400. PRINT_ERROR(e);
  401. delete e;
  402. }
  403. }
  404. return NULL;
  405. }
  407. extern "C" void MP4GetBytesProperty(
  408. MP4FileHandle hFile, const char* propName, 
  409. u_int8_t** ppValue, u_int32_t* pValueSize)
  410. {
  411. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  412. try {
  413. ((MP4File*)hFile)->GetBytesProperty(propName, ppValue, pValueSize);
  414. return;
  415. }
  416. catch (MP4Error* e) {
  417. PRINT_ERROR(e);
  418. delete e;
  419. }
  420. }
  421. *ppValue = NULL;
  422. *pValueSize = 0;
  423. return;
  424. }
  426. extern "C" bool MP4SetIntegerProperty(
  427. MP4FileHandle hFile, const char* propName, int64_t value)
  428. {
  429. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  430. try {
  431. ((MP4File*)hFile)->SetIntegerProperty(propName, value);
  432. return true;
  433. }
  434. catch (MP4Error* e) {
  435. PRINT_ERROR(e);
  436. delete e;
  437. }
  438. }
  439. return false;
  440. }
  442. extern "C" bool MP4SetFloatProperty(
  443. MP4FileHandle hFile, const char* propName, float value)
  444. {
  445. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  446. try {
  447. ((MP4File*)hFile)->SetFloatProperty(propName, value);
  448. return true;
  449. }
  450. catch (MP4Error* e) {
  451. PRINT_ERROR(e);
  452. delete e;
  453. }
  454. }
  455. return false;
  456. }
  458. extern "C" bool MP4SetStringProperty(
  459. MP4FileHandle hFile, const char* propName, const char* value)
  460. {
  461. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  462. try {
  463. ((MP4File*)hFile)->SetStringProperty(propName, value);
  464. return true;
  465. }
  466. catch (MP4Error* e) {
  467. PRINT_ERROR(e);
  468. delete e;
  469. }
  470. }
  471. return false;
  472. }
  474. extern "C" bool MP4SetBytesProperty(
  475. MP4FileHandle hFile, const char* propName, 
  476. const u_int8_t* pValue, u_int32_t valueSize)
  477. {
  478. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  479. try {
  480. ((MP4File*)hFile)->SetBytesProperty(propName, pValue, valueSize);
  481. return true;
  482. }
  483. catch (MP4Error* e) {
  484. PRINT_ERROR(e);
  485. delete e;
  486. }
  487. }
  488. return false;
  489. }
  491. /* track operations */
  493. extern "C" MP4TrackId MP4AddTrack(
  494. MP4FileHandle hFile, const char* type)
  495. {
  496. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  497. try {
  498. return ((MP4File*)hFile)->AddSystemsTrack(type);
  499. }
  500. catch (MP4Error* e) {
  501. PRINT_ERROR(e);
  502. delete e;
  503. }
  504. }
  505. return MP4_INVALID_TRACK_ID;
  506. }
  508. extern "C" MP4TrackId MP4AddSystemsTrack(
  509. MP4FileHandle hFile, const char* type)
  510. {
  511. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  512. try {
  513. return ((MP4File*)hFile)->AddSystemsTrack(type);
  514. }
  515. catch (MP4Error* e) {
  516. PRINT_ERROR(e);
  517. delete e;
  518. }
  519. }
  520. return MP4_INVALID_TRACK_ID;
  521. }
  523. extern "C" MP4TrackId MP4AddODTrack(MP4FileHandle hFile)
  524. {
  525. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  526. try {
  527. return ((MP4File*)hFile)->AddODTrack();
  528. }
  529. catch (MP4Error* e) {
  530. PRINT_ERROR(e);
  531. delete e;
  532. }
  533. }
  534. return MP4_INVALID_TRACK_ID;
  535. }
  537. extern "C" MP4TrackId MP4AddSceneTrack(MP4FileHandle hFile)
  538. {
  539. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  540. try {
  541. return ((MP4File*)hFile)->AddSceneTrack();
  542. }
  543. catch (MP4Error* e) {
  544. PRINT_ERROR(e);
  545. delete e;
  546. }
  547. }
  548. return MP4_INVALID_TRACK_ID;
  549. }
  551. extern "C" MP4TrackId MP4AddAudioTrack(
  552. MP4FileHandle hFile, 
  553. u_int32_t timeScale, 
  554. MP4Duration sampleDuration, 
  555. u_int8_t audioType)
  556. {
  557. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  558. try {
  559. return ((MP4File*)hFile)->
  560. AddAudioTrack(timeScale, sampleDuration, audioType);
  561. }
  562. catch (MP4Error* e) {
  563. PRINT_ERROR(e);
  564. delete e;
  565. }
  566. }
  567. return MP4_INVALID_TRACK_ID;
  568. }
  570. extern "C" MP4TrackId MP4AddVideoTrack(
  571. MP4FileHandle hFile, 
  572. u_int32_t timeScale, 
  573. MP4Duration sampleDuration,
  574. u_int16_t width, 
  575. u_int16_t height, 
  576. u_int8_t videoType)
  577. {
  578. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  579. try {
  580. return ((MP4File*)hFile)->AddVideoTrack(
  581. timeScale, sampleDuration, width, height, videoType);
  582. }
  583. catch (MP4Error* e) {
  584. PRINT_ERROR(e);
  585. delete e;
  586. }
  587. }
  588. return MP4_INVALID_TRACK_ID;
  589. }
  591. extern "C" MP4TrackId MP4AddHintTrack(
  592. MP4FileHandle hFile, MP4TrackId refTrackId)
  593. {
  594. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  595. try {
  596. return ((MP4File*)hFile)->AddHintTrack(refTrackId);
  597. }
  598. catch (MP4Error* e) {
  599. PRINT_ERROR(e);
  600. delete e;
  601. }
  602. }
  603. return MP4_INVALID_TRACK_ID;
  604. }
  606. extern "C" MP4TrackId MP4CloneTrack(
  607. MP4FileHandle srcFile, 
  608. MP4TrackId srcTrackId,
  609. MP4FileHandle dstFile)
  610. {
  611. MP4TrackId dstTrackId = MP4_INVALID_TRACK_ID;
  613. if (dstFile == NULL) {
  614. dstFile = srcFile;
  615. }
  617. const char* trackType = 
  618. MP4GetTrackType(srcFile, srcTrackId);
  620. if (!trackType) {
  621. return dstTrackId;
  622. }
  624. if (MP4_IS_VIDEO_TRACK_TYPE(trackType)) {
  625. dstTrackId = MP4AddVideoTrack(
  626. dstFile,
  627. MP4GetTrackTimeScale(srcFile, srcTrackId),
  628. MP4GetTrackFixedSampleDuration(srcFile, srcTrackId),
  629. MP4GetTrackVideoWidth(srcFile, srcTrackId),
  630. MP4GetTrackVideoHeight(srcFile, srcTrackId),
  631. MP4GetTrackVideoType(srcFile, srcTrackId));
  633. } else if (MP4_IS_AUDIO_TRACK_TYPE(trackType)) {
  634. dstTrackId = MP4AddAudioTrack(
  635. dstFile,
  636. MP4GetTrackTimeScale(srcFile, srcTrackId),
  637. MP4GetTrackFixedSampleDuration(srcFile, srcTrackId),
  638. MP4GetTrackAudioType(srcFile, srcTrackId));
  640. } else if (MP4_IS_OD_TRACK_TYPE(trackType)) {
  641. dstTrackId = MP4AddODTrack(dstFile);
  643. } else if (MP4_IS_SCENE_TRACK_TYPE(trackType)) {
  644. dstTrackId = MP4AddSceneTrack(dstFile);
  646. } else if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
  647. dstTrackId = MP4AddHintTrack(
  648. dstFile,
  649. MP4GetHintTrackReferenceTrackId(srcFile, srcTrackId));
  651. } else if (MP4_IS_SYSTEMS_TRACK_TYPE(trackType)) {
  652. dstTrackId = MP4AddSystemsTrack(dstFile, trackType);
  654. } else {
  655. dstTrackId = MP4AddTrack(dstFile, trackType);
  656. }
  658. if (dstTrackId == MP4_INVALID_TRACK_ID) {
  659. return dstTrackId;
  660. }
  662. MP4SetTrackTimeScale(
  663. dstFile, 
  664. dstTrackId,
  665. MP4GetTrackTimeScale(srcFile, srcTrackId));
  667. // copy track ES configuration
  668. u_int8_t* pConfig = NULL;
  669. u_int32_t configSize = 0;
  671. MP4GetTrackESConfiguration(
  672. srcFile, 
  673. srcTrackId,
  674. &pConfig,
  675. &configSize);
  677. MP4SetTrackESConfiguration(
  678. dstFile, 
  679. dstTrackId,
  680. pConfig,
  681. configSize);
  683. free(pConfig);
  685. if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
  686. // probably not exactly what is wanted
  687. // but caller can adjust later to fit their desires
  689. char* payloadName = NULL;
  690. u_int8_t payloadNumber;
  691. u_int16_t maxPayloadSize;
  693. MP4GetHintTrackRtpPayload(
  694. srcFile,
  695. srcTrackId,
  696. &payloadName,
  697. &payloadNumber,
  698. &maxPayloadSize);
  700. MP4SetHintTrackRtpPayload(
  701. dstFile,
  702. dstTrackId,
  703. payloadName,
  704. &payloadNumber,
  705. maxPayloadSize);
  707. MP4SetHintTrackSdp(
  708. dstFile,
  709. dstTrackId,
  710. MP4GetHintTrackSdp(srcFile, srcTrackId));
  711. }
  713. return dstTrackId;
  714. }
  716. extern "C" MP4TrackId MP4CopyTrack(
  717. MP4FileHandle srcFile, 
  718. MP4TrackId srcTrackId,
  719. MP4FileHandle dstFile, 
  720. bool applyEdits)
  721. {
  722. bool copySamples = true; // LATER allow false => reference samples
  724. MP4TrackId dstTrackId =
  725. MP4CloneTrack(srcFile, srcTrackId, dstFile);
  727. if (dstTrackId == MP4_INVALID_TRACK_ID) {
  728. return dstTrackId;
  729. }
  731. bool viaEdits =
  732. applyEdits && MP4GetTrackNumberOfEdits(srcFile, srcTrackId);
  734. MP4SampleId sampleId = 0;
  735. MP4SampleId numSamples = 
  736. MP4GetTrackNumberOfSamples(srcFile, srcTrackId);
  738. MP4Timestamp when = 0;
  739. MP4Duration editsDuration = 
  740. MP4GetTrackEditTotalDuration(srcFile, srcTrackId);
  742. while (true) {
  743. MP4Duration sampleDuration = MP4_INVALID_DURATION;
  745. if (viaEdits) {
  746. sampleId = MP4GetSampleIdFromEditTime(
  747. srcFile,
  748. srcTrackId,
  749. when,
  750. NULL,
  751. &sampleDuration);
  753. // in theory, this shouldn't happen
  754. if (sampleId == MP4_INVALID_SAMPLE_ID) {
  755. MP4DeleteTrack(dstFile, dstTrackId);
  756. return MP4_INVALID_TRACK_ID;
  757. }
  759. when += sampleDuration;
  761. if (when >= editsDuration) {
  762. break;
  763. }
  764. } else {
  765. sampleId++;
  766. if (sampleId > numSamples) {
  767. break;
  768. }
  769. }
  771. bool rc = false;
  773. if (copySamples) {
  774. rc = MP4CopySample(
  775. srcFile,
  776. srcTrackId,
  777. sampleId,
  778. dstFile,
  779. dstTrackId,
  780. sampleDuration);
  782. } else {
  783. rc = MP4ReferenceSample(
  784. srcFile,
  785. srcTrackId,
  786. sampleId,
  787. dstFile,
  788. dstTrackId,
  789. sampleDuration);
  790. }
  792. if (!rc) {
  793. MP4DeleteTrack(dstFile, dstTrackId);
  794. return MP4_INVALID_TRACK_ID;
  795. }
  796. }
  798. return dstTrackId;
  799. }
  801. extern "C" bool MP4DeleteTrack(
  802. MP4FileHandle hFile, 
  803. MP4TrackId trackId)
  804. {
  805. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  806. try {
  807. ((MP4File*)hFile)->DeleteTrack(trackId);
  808. return true;
  809. }
  810. catch (MP4Error* e) {
  811. PRINT_ERROR(e);
  812. delete e;
  813. }
  814. }
  815. return false;
  816. }
  818. extern "C" u_int32_t MP4GetNumberOfTracks(
  819. MP4FileHandle hFile, 
  820. const char* type,
  821. u_int8_t subType)
  822. {
  823. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  824. try {
  825. return ((MP4File*)hFile)->GetNumberOfTracks(type, subType);
  826. }
  827. catch (MP4Error* e) {
  828. PRINT_ERROR(e);
  829. delete e;
  830. }
  831. }
  832. return 0;
  833. }
  835. extern "C" MP4TrackId MP4FindTrackId(
  836. MP4FileHandle hFile, 
  837. u_int16_t index, 
  838. const char* type,
  839. u_int8_t subType)
  840. {
  841. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  842. try {
  843. return ((MP4File*)hFile)->FindTrackId(index, type, subType);
  844. }
  845. catch (MP4Error* e) {
  846. PRINT_ERROR(e);
  847. delete e;
  848. }
  849. }
  850. return MP4_INVALID_TRACK_ID;
  851. }
  853. extern "C" u_int16_t MP4FindTrackIndex(
  854. MP4FileHandle hFile, MP4TrackId trackId)
  855. {
  856. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  857. try {
  858. return ((MP4File*)hFile)->FindTrackIndex(trackId);
  859. }
  860. catch (MP4Error* e) {
  861. PRINT_ERROR(e);
  862. delete e;
  863. }
  864. }
  865. return (u_int16_t)-1;
  866. }
  868. /* specific track properties */
  870. extern "C" const char* MP4GetTrackType(
  871. MP4FileHandle hFile, MP4TrackId trackId)
  872. {
  873. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  874. try {
  875. return ((MP4File*)hFile)->GetTrackType(trackId);
  876. }
  877. catch (MP4Error* e) {
  878. PRINT_ERROR(e);
  879. delete e;
  880. }
  881. }
  882. return NULL;
  883. }
  885. extern "C" MP4Duration MP4GetTrackDuration(
  886. MP4FileHandle hFile, MP4TrackId trackId)
  887. {
  888. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  889. try {
  890. return ((MP4File*)hFile)->GetTrackDuration(trackId);
  891. }
  892. catch (MP4Error* e) {
  893. PRINT_ERROR(e);
  894. delete e;
  895. }
  896. }
  897. return MP4_INVALID_DURATION;
  898. }
  900. extern "C" u_int32_t MP4GetTrackTimeScale(
  901. MP4FileHandle hFile, MP4TrackId trackId)
  902. {
  903. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  904. try {
  905. return ((MP4File*)hFile)->GetTrackTimeScale(trackId);
  906. }
  907. catch (MP4Error* e) {
  908. PRINT_ERROR(e);
  909. delete e;
  910. }
  911. }
  912. return 0;
  913. }
  915. extern "C" bool MP4SetTrackTimeScale(
  916. MP4FileHandle hFile, MP4TrackId trackId, u_int32_t value)
  917. {
  918. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  919. try {
  920. ((MP4File*)hFile)->SetTrackTimeScale(trackId, value);
  921. return true;
  922. }
  923. catch (MP4Error* e) {
  924. PRINT_ERROR(e);
  925. delete e;
  926. }
  927. }
  928. return false;
  929. }
  931. extern "C" u_int8_t MP4GetTrackAudioType(
  932. MP4FileHandle hFile, MP4TrackId trackId)
  933. {
  934. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  935. try {
  936. return ((MP4File*)hFile)->GetTrackAudioType(trackId);
  937. }
  938. catch (MP4Error* e) {
  939. PRINT_ERROR(e);
  940. delete e;
  941. }
  942. }
  943. return MP4_INVALID_AUDIO_TYPE;
  944. }
  946. extern "C" u_int8_t MP4GetTrackAudioMpeg4Type(
  947. MP4FileHandle hFile, MP4TrackId trackId)
  948. {
  949. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  950. try {
  951. return ((MP4File*)hFile)->GetTrackAudioMpeg4Type(trackId);
  952. }
  953. catch (MP4Error* e) {
  954. PRINT_ERROR(e);
  955. delete e;
  956. }
  957. }
  958. return MP4_MPEG4_INVALID_AUDIO_TYPE;
  959. }
  962. extern "C" u_int8_t MP4GetTrackVideoType(
  963. MP4FileHandle hFile, MP4TrackId trackId)
  964. {
  965. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  966. try {
  967. return ((MP4File*)hFile)->GetTrackVideoType(trackId);
  968. }
  969. catch (MP4Error* e) {
  970. PRINT_ERROR(e);
  971. delete e;
  972. }
  973. }
  974. return MP4_INVALID_VIDEO_TYPE;
  975. }
  977. extern "C" MP4Duration MP4GetTrackFixedSampleDuration(
  978. MP4FileHandle hFile, MP4TrackId trackId)
  979. {
  980. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  981. try {
  982. return ((MP4File*)hFile)->GetTrackFixedSampleDuration(trackId);
  983. }
  984. catch (MP4Error* e) {
  985. PRINT_ERROR(e);
  986. delete e;
  987. }
  988. }
  989. return MP4_INVALID_DURATION;
  990. }
  992. extern "C" u_int32_t MP4GetTrackBitRate(
  993. MP4FileHandle hFile, MP4TrackId trackId)
  994. {
  995. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  996. try {
  997. return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId,
  998. "mdia.minf.stbl.stsd.*.esds.decConfigDescr.avgBitrate");
  999. }
  1000. catch (MP4Error* e) {
  1001. PRINT_ERROR(e);
  1002. delete e;
  1003. }
  1004. }
  1005. return 0;
  1006. }
  1008. extern "C" void MP4GetTrackESConfiguration(
  1009. MP4FileHandle hFile, MP4TrackId trackId, 
  1010. u_int8_t** ppConfig, u_int32_t* pConfigSize)
  1011. {
  1012. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1013. try {
  1014. ((MP4File*)hFile)->GetTrackESConfiguration(
  1015. trackId, ppConfig, pConfigSize);
  1016. return;
  1017. }
  1018. catch (MP4Error* e) {
  1019. PRINT_ERROR(e);
  1020. delete e;
  1021. }
  1022. }
  1023. *ppConfig = NULL;
  1024. *pConfigSize = 0;
  1025. return;
  1026. }
  1028. extern "C" bool MP4SetTrackESConfiguration(
  1029. MP4FileHandle hFile, MP4TrackId trackId, 
  1030. const u_int8_t* pConfig, u_int32_t configSize)
  1031. {
  1032. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1033. try {
  1034. ((MP4File*)hFile)->SetTrackESConfiguration(
  1035. trackId, pConfig, configSize);
  1036. return true;
  1037. }
  1038. catch (MP4Error* e) {
  1039. PRINT_ERROR(e);
  1040. delete e;
  1041. }
  1042. }
  1043. return false;
  1044. }
  1046. extern "C" MP4SampleId MP4GetTrackNumberOfSamples(
  1047. MP4FileHandle hFile, MP4TrackId trackId)
  1048. {
  1049. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1050. try {
  1051. return ((MP4File*)hFile)->GetTrackNumberOfSamples(trackId);
  1052. }
  1053. catch (MP4Error* e) {
  1054. PRINT_ERROR(e);
  1055. delete e;
  1056. }
  1057. }
  1058. return 0;
  1059. }
  1061. extern "C" u_int16_t MP4GetTrackVideoWidth(
  1062. MP4FileHandle hFile, MP4TrackId trackId)
  1063. {
  1064. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1065. try {
  1066. return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId,
  1067. "mdia.minf.stbl.stsd.mp4v.width");
  1068. }
  1069. catch (MP4Error* e) {
  1070. PRINT_ERROR(e);
  1071. delete e;
  1072. }
  1073. }
  1074. return 0;
  1075. }
  1077. extern "C" u_int16_t MP4GetTrackVideoHeight(
  1078. MP4FileHandle hFile, MP4TrackId trackId)
  1079. {
  1080. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1081. try {
  1082. return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId,
  1083. "mdia.minf.stbl.stsd.mp4v.height");
  1084. }
  1085. catch (MP4Error* e) {
  1086. PRINT_ERROR(e);
  1087. delete e;
  1088. }
  1089. }
  1090. return 0;
  1091. }
  1093. extern "C" float MP4GetTrackVideoFrameRate(
  1094. MP4FileHandle hFile, MP4TrackId trackId)
  1095. {
  1096. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1097. try {
  1098. return ((MP4File*)hFile)->GetTrackVideoFrameRate(trackId);
  1099. }
  1100. catch (MP4Error* e) {
  1101. PRINT_ERROR(e);
  1102. delete e;
  1103. }
  1104. }
  1105. return 0.0;
  1106. }
  1108. /* generic track properties */
  1110. extern "C" u_int64_t MP4GetTrackIntegerProperty(
  1111. MP4FileHandle hFile, MP4TrackId trackId, 
  1112. const char* propName)
  1113. {
  1114. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1115. try {
  1116. return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId, 
  1117. propName);
  1118. }
  1119. catch (MP4Error* e) {
  1120. PRINT_ERROR(e);
  1121. delete e;
  1122. }
  1123. }
  1124. return (u_int64_t)-1;
  1125. }
  1127. extern "C" float MP4GetTrackFloatProperty(
  1128. MP4FileHandle hFile, MP4TrackId trackId, 
  1129. const char* propName)
  1130. {
  1131. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1132. try {
  1133. return ((MP4File*)hFile)->GetTrackFloatProperty(trackId, propName);
  1134. }
  1135. catch (MP4Error* e) {
  1136. PRINT_ERROR(e);
  1137. delete e;
  1138. }
  1139. }
  1140. return NAN;
  1141. }
  1143. extern "C" const char* MP4GetTrackStringProperty(
  1144. MP4FileHandle hFile, MP4TrackId trackId, 
  1145. const char* propName)
  1146. {
  1147. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1148. try {
  1149. return ((MP4File*)hFile)->GetTrackStringProperty(trackId, propName);
  1150. }
  1151. catch (MP4Error* e) {
  1152. PRINT_ERROR(e);
  1153. delete e;
  1154. }
  1155. }
  1156. return NULL;
  1157. }
  1159. extern "C" void MP4GetTrackBytesProperty(
  1160. MP4FileHandle hFile, MP4TrackId trackId, const char* propName, 
  1161. u_int8_t** ppValue, u_int32_t* pValueSize)
  1162. {
  1163. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1164. try {
  1165. ((MP4File*)hFile)->GetTrackBytesProperty(
  1166. trackId, propName, ppValue, pValueSize);
  1167. return;
  1168. }
  1169. catch (MP4Error* e) {
  1170. PRINT_ERROR(e);
  1171. delete e;
  1172. }
  1173. }
  1174. *ppValue = NULL;
  1175. *pValueSize = 0;
  1176. return;
  1177. }
  1179. extern "C" bool MP4SetTrackIntegerProperty(
  1180. MP4FileHandle hFile, MP4TrackId trackId, 
  1181. const char* propName, int64_t value)
  1182. {
  1183. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1184. try {
  1185. ((MP4File*)hFile)->SetTrackIntegerProperty(trackId, 
  1186. propName, value);
  1187. return true;
  1188. }
  1189. catch (MP4Error* e) {
  1190. PRINT_ERROR(e);
  1191. delete e;
  1192. }
  1193. }
  1194. return false;
  1195. }
  1197. extern "C" bool MP4SetTrackFloatProperty(
  1198. MP4FileHandle hFile, MP4TrackId trackId, 
  1199. const char* propName, float value)
  1200. {
  1201. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1202. try {
  1203. ((MP4File*)hFile)->SetTrackFloatProperty(trackId, propName, value);
  1204. return true;
  1205. }
  1206. catch (MP4Error* e) {
  1207. PRINT_ERROR(e);
  1208. delete e;
  1209. }
  1210. }
  1211. return false;
  1212. }
  1214. extern "C" bool MP4SetTrackStringProperty(
  1215. MP4FileHandle hFile, MP4TrackId trackId, 
  1216. const char* propName, const char* value)
  1217. {
  1218. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1219. try {
  1220. ((MP4File*)hFile)->SetTrackStringProperty(trackId, propName, value);
  1221. return true;
  1222. }
  1223. catch (MP4Error* e) {
  1224. PRINT_ERROR(e);
  1225. delete e;
  1226. }
  1227. }
  1228. return false;
  1229. }
  1231. extern "C" bool MP4SetTrackBytesProperty(
  1232. MP4FileHandle hFile, MP4TrackId trackId, 
  1233. const char* propName, const u_int8_t* pValue, u_int32_t valueSize)
  1234. {
  1235. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1236. try {
  1237. ((MP4File*)hFile)->SetTrackBytesProperty(
  1238. trackId, propName, pValue, valueSize);
  1239. return true;
  1240. }
  1241. catch (MP4Error* e) {
  1242. PRINT_ERROR(e);
  1243. delete e;
  1244. }
  1245. }
  1246. return false;
  1247. }
  1249. /* sample operations */
  1251. extern "C" bool MP4ReadSample(
  1252. /* input parameters */
  1253. MP4FileHandle hFile,
  1254. MP4TrackId trackId, 
  1255. MP4SampleId sampleId,
  1256. /* output parameters */
  1257. u_int8_t** ppBytes, 
  1258. u_int32_t* pNumBytes, 
  1259. MP4Timestamp* pStartTime, 
  1260. MP4Duration* pDuration,
  1261. MP4Duration* pRenderingOffset, 
  1262. bool* pIsSyncSample)
  1263. {
  1264. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1265. try {
  1266. ((MP4File*)hFile)->ReadSample(
  1267. trackId, 
  1268. sampleId, 
  1269. ppBytes, 
  1270. pNumBytes, 
  1271. pStartTime, 
  1272. pDuration, 
  1273. pRenderingOffset, 
  1274. pIsSyncSample);
  1275. return true;
  1276. }
  1277. catch (MP4Error* e) {
  1278. PRINT_ERROR(e);
  1279. delete e;
  1280. }
  1281. }
  1282. *pNumBytes = 0;
  1283. return false;
  1284. }
  1286. extern "C" bool MP4ReadSampleFromTime(
  1287. /* input parameters */
  1288. MP4FileHandle hFile,
  1289. MP4TrackId trackId, 
  1290. MP4Timestamp when,
  1291. /* output parameters */
  1292. u_int8_t** ppBytes, 
  1293. u_int32_t* pNumBytes, 
  1294. MP4Timestamp* pStartTime, 
  1295. MP4Duration* pDuration,
  1296. MP4Duration* pRenderingOffset, 
  1297. bool* pIsSyncSample)
  1298. {
  1299. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1300. try {
  1301. MP4SampleId sampleId = 
  1302. ((MP4File*)hFile)->GetSampleIdFromTime(
  1303. trackId, when, false);
  1305. ((MP4File*)hFile)->ReadSample(
  1306. trackId, 
  1307. sampleId, 
  1308. ppBytes, 
  1309. pNumBytes, 
  1310. pStartTime, 
  1311. pDuration, 
  1312. pRenderingOffset, 
  1313. pIsSyncSample);
  1315. return true;
  1316. }
  1317. catch (MP4Error* e) {
  1318. PRINT_ERROR(e);
  1319. delete e;
  1320. }
  1321. }
  1322. *pNumBytes = 0;
  1323. return false;
  1324. }
  1326. extern "C" bool MP4WriteSample(
  1327. MP4FileHandle hFile,
  1328. MP4TrackId trackId,
  1329. u_int8_t* pBytes, 
  1330. u_int32_t numBytes,
  1331. MP4Duration duration,
  1332. MP4Duration renderingOffset, 
  1333. bool isSyncSample)
  1334. {
  1335. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1336. try {
  1337. ((MP4File*)hFile)->WriteSample(
  1338. trackId, 
  1339. pBytes, 
  1340. numBytes, 
  1341. duration, 
  1342. renderingOffset, 
  1343. isSyncSample);
  1344. return true;
  1345. }
  1346. catch (MP4Error* e) {
  1347. PRINT_ERROR(e);
  1348. delete e;
  1349. }
  1350. }
  1351. return false;
  1352. }
  1354. extern "C" bool MP4CopySample(
  1355. MP4FileHandle srcFile,
  1356. MP4TrackId srcTrackId, 
  1357. MP4SampleId srcSampleId,
  1358. MP4FileHandle dstFile,
  1359. MP4TrackId dstTrackId,
  1360. MP4Duration dstSampleDuration)
  1361. {
  1362. bool rc;
  1363. u_int8_t* pBytes = NULL; 
  1364. u_int32_t numBytes = 0;
  1365. MP4Duration sampleDuration;
  1366. MP4Duration renderingOffset;
  1367. bool isSyncSample;
  1369. // Note: we leave it up to the caller to ensure that the
  1370. // source and destination tracks are compatible.
  1371. // i.e. copying audio samples into a video track 
  1372. // is unlikely to do anything useful
  1374. rc = MP4ReadSample(
  1375. srcFile,
  1376. srcTrackId,
  1377. srcSampleId,
  1378. &pBytes,
  1379. &numBytes,
  1380. NULL,
  1381. &sampleDuration,
  1382. &renderingOffset,
  1383. &isSyncSample);
  1385. if (!rc) {
  1386. return false;
  1387. }
  1389. if (dstFile == MP4_INVALID_FILE_HANDLE) {
  1390. dstFile = srcFile;
  1391. }
  1392. if (dstTrackId == MP4_INVALID_TRACK_ID) {
  1393. dstTrackId = srcTrackId;
  1394. }
  1395. if (dstSampleDuration != MP4_INVALID_DURATION) {
  1396. sampleDuration = dstSampleDuration;
  1397. }
  1399. rc = MP4WriteSample(
  1400. dstFile,
  1401. dstTrackId,
  1402. pBytes,
  1403. numBytes,
  1404. sampleDuration,
  1405. renderingOffset,
  1406. isSyncSample);
  1408. free(pBytes);
  1410. return rc;
  1411. }
  1413. extern "C" bool MP4ReferenceSample(
  1414. MP4FileHandle srcFile,
  1415. MP4TrackId srcTrackId, 
  1416. MP4SampleId srcSampleId,
  1417. MP4FileHandle dstFile,
  1418. MP4TrackId dstTrackId,
  1419. MP4Duration dstSampleDuration)
  1420. {
  1421. // LATER Not yet implemented
  1422. return false;
  1423. }
  1425. extern "C" u_int32_t MP4GetSampleSize(
  1426. MP4FileHandle hFile,
  1427. MP4TrackId trackId, 
  1428. MP4SampleId sampleId)
  1429. {
  1430. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1431. try {
  1432. return ((MP4File*)hFile)->GetSampleSize(
  1433. trackId, sampleId);
  1434. }
  1435. catch (MP4Error* e) {
  1436. PRINT_ERROR(e);
  1437. delete e;
  1438. }
  1439. }
  1440. return 0;
  1441. }
  1443. extern "C" u_int32_t MP4GetTrackMaxSampleSize(
  1444. MP4FileHandle hFile,
  1445. MP4TrackId trackId)
  1446. {
  1447. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1448. try {
  1449. return ((MP4File*)hFile)->GetTrackMaxSampleSize(trackId);
  1450. }
  1451. catch (MP4Error* e) {
  1452. PRINT_ERROR(e);
  1453. delete e;
  1454. }
  1455. }
  1456. return 0;
  1457. }
  1459. extern "C" MP4SampleId MP4GetSampleIdFromTime(
  1460. MP4FileHandle hFile,
  1461. MP4TrackId trackId, 
  1462. MP4Timestamp when, 
  1463. bool wantSyncSample)
  1464. {
  1465. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1466. try {
  1467. return ((MP4File*)hFile)->GetSampleIdFromTime(
  1468. trackId, when, wantSyncSample);
  1469. }
  1470. catch (MP4Error* e) {
  1471. PRINT_ERROR(e);
  1472. delete e;
  1473. }
  1474. }
  1475. return MP4_INVALID_SAMPLE_ID;
  1476. }
  1478. extern "C" MP4Timestamp MP4GetSampleTime(
  1479. MP4FileHandle hFile,
  1480. MP4TrackId trackId, 
  1481. MP4SampleId sampleId)
  1482. {
  1483. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1484. try {
  1485. return ((MP4File*)hFile)->GetSampleTime(
  1486. trackId, sampleId);
  1487. }
  1488. catch (MP4Error* e) {
  1489. PRINT_ERROR(e);
  1490. delete e;
  1491. }
  1492. }
  1493. return MP4_INVALID_TIMESTAMP;
  1494. }
  1496. extern "C" MP4Duration MP4GetSampleDuration(
  1497. MP4FileHandle hFile,
  1498. MP4TrackId trackId, 
  1499. MP4SampleId sampleId)
  1500. {
  1501. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1502. try {
  1503. return ((MP4File*)hFile)->GetSampleDuration(
  1504. trackId, sampleId);
  1505. }
  1506. catch (MP4Error* e) {
  1507. PRINT_ERROR(e);
  1508. delete e;
  1509. }
  1510. }
  1511. return MP4_INVALID_DURATION;
  1512. }
  1514. extern "C" MP4Duration MP4GetSampleRenderingOffset(
  1515. MP4FileHandle hFile,
  1516. MP4TrackId trackId, 
  1517. MP4SampleId sampleId)
  1518. {
  1519. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1520. try {
  1521. return ((MP4File*)hFile)->GetSampleRenderingOffset(
  1522. trackId, sampleId);
  1523. }
  1524. catch (MP4Error* e) {
  1525. PRINT_ERROR(e);
  1526. delete e;
  1527. }
  1528. }
  1529. return MP4_INVALID_DURATION;
  1530. }
  1532. extern "C" bool MP4SetSampleRenderingOffset(
  1533. MP4FileHandle hFile,
  1534. MP4TrackId trackId, 
  1535. MP4SampleId sampleId,
  1536. MP4Duration renderingOffset)
  1537. {
  1538. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1539. try {
  1540. ((MP4File*)hFile)->SetSampleRenderingOffset(
  1541. trackId, sampleId, renderingOffset);
  1542. return true;
  1543. }
  1544. catch (MP4Error* e) {
  1545. PRINT_ERROR(e);
  1546. delete e;
  1547. }
  1548. }
  1549. return false;
  1550. }
  1552. extern "C" int8_t MP4GetSampleSync(
  1553. MP4FileHandle hFile,
  1554. MP4TrackId trackId, 
  1555. MP4SampleId sampleId)
  1556. {
  1557. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1558. try {
  1559. return ((MP4File*)hFile)->GetSampleSync(
  1560. trackId, sampleId);
  1561. }
  1562. catch (MP4Error* e) {
  1563. PRINT_ERROR(e);
  1564. delete e;
  1565. }
  1566. }
  1567. return -1;
  1568. }
  1571. extern "C" u_int64_t MP4ConvertFromMovieDuration(
  1572. MP4FileHandle hFile,
  1573. MP4Duration duration,
  1574. u_int32_t timeScale)
  1575. {
  1576. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1577. try {
  1578. return ((MP4File*)hFile)->ConvertFromMovieDuration(
  1579. duration, timeScale);
  1580. }
  1581. catch (MP4Error* e) {
  1582. PRINT_ERROR(e);
  1583. delete e;
  1584. }
  1585. }
  1586. return (u_int64_t)MP4_INVALID_DURATION;
  1587. }
  1589. extern "C" u_int64_t MP4ConvertFromTrackTimestamp(
  1590. MP4FileHandle hFile,
  1591. MP4TrackId trackId, 
  1592. MP4Timestamp timeStamp,
  1593. u_int32_t timeScale)
  1594. {
  1595. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1596. try {
  1597. return ((MP4File*)hFile)->ConvertFromTrackTimestamp(
  1598. trackId, timeStamp, timeScale);
  1599. }
  1600. catch (MP4Error* e) {
  1601. PRINT_ERROR(e);
  1602. delete e;
  1603. }
  1604. }
  1605. return (u_int64_t)MP4_INVALID_TIMESTAMP;
  1606. }
  1608. extern "C" MP4Timestamp MP4ConvertToTrackTimestamp(
  1609. MP4FileHandle hFile,
  1610. MP4TrackId trackId, 
  1611. u_int64_t timeStamp,
  1612. u_int32_t timeScale)
  1613. {
  1614. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1615. try {
  1616. return ((MP4File*)hFile)->ConvertToTrackTimestamp(
  1617. trackId, timeStamp, timeScale);
  1618. }
  1619. catch (MP4Error* e) {
  1620. PRINT_ERROR(e);
  1621. delete e;
  1622. }
  1623. }
  1624. return MP4_INVALID_TIMESTAMP;
  1625. }
  1627. extern "C" u_int64_t MP4ConvertFromTrackDuration(
  1628. MP4FileHandle hFile,
  1629. MP4TrackId trackId, 
  1630. MP4Duration duration,
  1631. u_int32_t timeScale)
  1632. {
  1633. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1634. try {
  1635. return ((MP4File*)hFile)->ConvertFromTrackDuration(
  1636. trackId, duration, timeScale);
  1637. }
  1638. catch (MP4Error* e) {
  1639. PRINT_ERROR(e);
  1640. delete e;
  1641. }
  1642. }
  1643. return (u_int64_t)MP4_INVALID_DURATION;
  1644. }
  1646. extern "C" MP4Duration MP4ConvertToTrackDuration(
  1647. MP4FileHandle hFile,
  1648. MP4TrackId trackId, 
  1649. u_int64_t duration,
  1650. u_int32_t timeScale)
  1651. {
  1652. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1653. try {
  1654. return ((MP4File*)hFile)->ConvertToTrackDuration(
  1655. trackId, duration, timeScale);
  1656. }
  1657. catch (MP4Error* e) {
  1658. PRINT_ERROR(e);
  1659. delete e;
  1660. }
  1661. }
  1662. return MP4_INVALID_DURATION;
  1663. }
  1665. extern "C" bool MP4GetHintTrackRtpPayload(
  1666. MP4FileHandle hFile,
  1667. MP4TrackId hintTrackId,
  1668. char** ppPayloadName,
  1669. u_int8_t* pPayloadNumber,
  1670. u_int16_t* pMaxPayloadSize)
  1671. {
  1672. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1673. try {
  1674. ((MP4File*)hFile)->GetHintTrackRtpPayload(
  1675. hintTrackId, ppPayloadName, pPayloadNumber, pMaxPayloadSize);
  1676. return true;
  1677. }
  1678. catch (MP4Error* e) {
  1679. PRINT_ERROR(e);
  1680. delete e;
  1681. }
  1682. }
  1683. return false;
  1684. }
  1686. extern "C" bool MP4SetHintTrackRtpPayload(
  1687. MP4FileHandle hFile,
  1688. MP4TrackId hintTrackId,
  1689. const char* pPayloadName,
  1690. u_int8_t* pPayloadNumber,
  1691. u_int16_t maxPayloadSize)
  1692. {
  1693. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1694. try {
  1695. ((MP4File*)hFile)->SetHintTrackRtpPayload(
  1696. hintTrackId, pPayloadName, pPayloadNumber, maxPayloadSize);
  1697. return true;
  1698. }
  1699. catch (MP4Error* e) {
  1700. PRINT_ERROR(e);
  1701. delete e;
  1702. }
  1703. }
  1704. return false;
  1705. }
  1707. extern "C" const char* MP4GetSessionSdp(
  1708. MP4FileHandle hFile)
  1709. {
  1710. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1711. try {
  1712. return ((MP4File*)hFile)->GetSessionSdp();
  1713. }
  1714. catch (MP4Error* e) {
  1715. PRINT_ERROR(e);
  1716. delete e;
  1717. }
  1718. }
  1719. return NULL;
  1720. }
  1722. extern "C" bool MP4SetSessionSdp(
  1723. MP4FileHandle hFile,
  1724. const char* sdpString)
  1725. {
  1726. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1727. try {
  1728. ((MP4File*)hFile)->SetSessionSdp(sdpString);
  1729. return true;
  1730. }
  1731. catch (MP4Error* e) {
  1732. PRINT_ERROR(e);
  1733. delete e;
  1734. }
  1735. }
  1736. return false;
  1737. }
  1739. extern "C" bool MP4AppendSessionSdp(
  1740. MP4FileHandle hFile,
  1741. const char* sdpString)
  1742. {
  1743. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1744. try {
  1745. ((MP4File*)hFile)->AppendSessionSdp(sdpString);
  1746. return true;
  1747. }
  1748. catch (MP4Error* e) {
  1749. PRINT_ERROR(e);
  1750. delete e;
  1751. }
  1752. }
  1753. return false;
  1754. }
  1756. extern "C" const char* MP4GetHintTrackSdp(
  1757. MP4FileHandle hFile,
  1758. MP4TrackId hintTrackId)
  1759. {
  1760. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1761. try {
  1762. return ((MP4File*)hFile)->GetHintTrackSdp(hintTrackId);
  1763. }
  1764. catch (MP4Error* e) {
  1765. PRINT_ERROR(e);
  1766. delete e;
  1767. }
  1768. }
  1769. return NULL;
  1770. }
  1772. extern "C" bool MP4SetHintTrackSdp(
  1773. MP4FileHandle hFile,
  1774. MP4TrackId hintTrackId,
  1775. const char* sdpString)
  1776. {
  1777. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1778. try {
  1779. ((MP4File*)hFile)->SetHintTrackSdp(hintTrackId, sdpString);
  1780. return true;
  1781. }
  1782. catch (MP4Error* e) {
  1783. PRINT_ERROR(e);
  1784. delete e;
  1785. }
  1786. }
  1787. return false;
  1788. }
  1790. extern "C" bool MP4AppendHintTrackSdp(
  1791. MP4FileHandle hFile,
  1792. MP4TrackId hintTrackId,
  1793. const char* sdpString)
  1794. {
  1795. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1796. try {
  1797. ((MP4File*)hFile)->AppendHintTrackSdp(hintTrackId, sdpString);
  1798. return true;
  1799. }
  1800. catch (MP4Error* e) {
  1801. PRINT_ERROR(e);
  1802. delete e;
  1803. }
  1804. }
  1805. return false;
  1806. }
  1808. extern "C" MP4TrackId MP4GetHintTrackReferenceTrackId(
  1809. MP4FileHandle hFile,
  1810. MP4TrackId hintTrackId)
  1811. {
  1812. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1813. try {
  1814. return ((MP4File*)hFile)->
  1815. GetHintTrackReferenceTrackId(hintTrackId);
  1816. }
  1817. catch (MP4Error* e) {
  1818. PRINT_ERROR(e);
  1819. delete e;
  1820. }
  1821. }
  1822. return MP4_INVALID_TRACK_ID;
  1823. }
  1825. extern "C" bool MP4ReadRtpHint(
  1826. MP4FileHandle hFile,
  1827. MP4TrackId hintTrackId,
  1828. MP4SampleId hintSampleId,
  1829. u_int16_t* pNumPackets)
  1830. {
  1831. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1832. try {
  1833. ((MP4File*)hFile)->ReadRtpHint(
  1834. hintTrackId, hintSampleId, pNumPackets);
  1835. return true;
  1836. }
  1837. catch (MP4Error* e) {
  1838. PRINT_ERROR(e);
  1839. delete e;
  1840. }
  1841. }
  1842. return false;
  1843. }
  1845. extern "C" u_int16_t MP4GetRtpHintNumberOfPackets(
  1846. MP4FileHandle hFile,
  1847. MP4TrackId hintTrackId)
  1848. {
  1849. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1850. try {
  1851. return ((MP4File*)hFile)->GetRtpHintNumberOfPackets(hintTrackId);
  1852. }
  1853. catch (MP4Error* e) {
  1854. PRINT_ERROR(e);
  1855. delete e;
  1856. }
  1857. }
  1858. return 0;
  1859. }
  1861. extern "C" int8_t MP4GetRtpPacketBFrame(
  1862. MP4FileHandle hFile,
  1863. MP4TrackId hintTrackId,
  1864. u_int16_t packetIndex)
  1865. {
  1866. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1867. try {
  1868. return ((MP4File*)hFile)->
  1869. GetRtpPacketBFrame(hintTrackId, packetIndex);
  1870. }
  1871. catch (MP4Error* e) {
  1872. PRINT_ERROR(e);
  1873. delete e;
  1874. }
  1875. }
  1876. return -1;
  1877. }
  1879. extern "C" int32_t MP4GetRtpPacketTransmitOffset(
  1880. MP4FileHandle hFile,
  1881. MP4TrackId hintTrackId,
  1882. u_int16_t packetIndex)
  1883. {
  1884. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1885. try {
  1886. return ((MP4File*)hFile)->
  1887. GetRtpPacketTransmitOffset(hintTrackId, packetIndex);
  1888. }
  1889. catch (MP4Error* e) {
  1890. PRINT_ERROR(e);
  1891. delete e;
  1892. }
  1893. }
  1894. return 0;
  1895. }
  1897. extern "C" bool MP4ReadRtpPacket(
  1898. MP4FileHandle hFile,
  1899. MP4TrackId hintTrackId,
  1900. u_int16_t packetIndex,
  1901. u_int8_t** ppBytes, 
  1902. u_int32_t* pNumBytes,
  1903. u_int32_t ssrc,
  1904. bool includeHeader,
  1905. bool includePayload)
  1906. {
  1907. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1908. try {
  1909. ((MP4File*)hFile)->ReadRtpPacket(
  1910. hintTrackId, packetIndex, 
  1911. ppBytes, pNumBytes, 
  1912. ssrc, includeHeader, includePayload);
  1913. return true;
  1914. }
  1915. catch (MP4Error* e) {
  1916. PRINT_ERROR(e);
  1917. delete e;
  1918. }
  1919. }
  1920. return false;
  1921. }
  1923. extern "C" MP4Timestamp MP4GetRtpTimestampStart(
  1924. MP4FileHandle hFile,
  1925. MP4TrackId hintTrackId)
  1926. {
  1927. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1928. try {
  1929. return ((MP4File*)hFile)->GetRtpTimestampStart(hintTrackId);
  1930. }
  1931. catch (MP4Error* e) {
  1932. PRINT_ERROR(e);
  1933. delete e;
  1934. }
  1935. }
  1936. return MP4_INVALID_TIMESTAMP;
  1937. }
  1939. extern "C" bool MP4SetRtpTimestampStart(
  1940. MP4FileHandle hFile,
  1941. MP4TrackId hintTrackId,
  1942. MP4Timestamp rtpStart)
  1943. {
  1944. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1945. try {
  1946. ((MP4File*)hFile)->SetRtpTimestampStart(
  1947. hintTrackId, rtpStart);
  1948. return true;
  1949. }
  1950. catch (MP4Error* e) {
  1951. PRINT_ERROR(e);
  1952. delete e;
  1953. }
  1954. }
  1955. return false;
  1956. }
  1958. extern "C" bool MP4AddRtpHint(
  1959. MP4FileHandle hFile,
  1960. MP4TrackId hintTrackId)
  1961. {
  1962. return MP4AddRtpVideoHint(hFile, hintTrackId, false, 0);
  1963. }
  1965. extern "C" bool MP4AddRtpVideoHint(
  1966. MP4FileHandle hFile,
  1967. MP4TrackId hintTrackId,
  1968. bool isBframe, 
  1969. u_int32_t timestampOffset)
  1970. {
  1971. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1972. try {
  1973. ((MP4File*)hFile)->AddRtpHint(hintTrackId, 
  1974. isBframe, timestampOffset);
  1975. return true;
  1976. }
  1977. catch (MP4Error* e) {
  1978. PRINT_ERROR(e);
  1979. delete e;
  1980. }
  1981. }
  1982. return false;
  1983. }
  1985. extern "C" bool MP4AddRtpPacket(
  1986. MP4FileHandle hFile,
  1987. MP4TrackId hintTrackId,
  1988. bool setMbit,
  1989. int32_t transmitOffset)
  1990. {
  1991. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  1992. try {
  1993. ((MP4File*)hFile)->AddRtpPacket(
  1994. hintTrackId, setMbit, transmitOffset);
  1995. return true;
  1996. }
  1997. catch (MP4Error* e) {
  1998. PRINT_ERROR(e);
  1999. delete e;
  2000. }
  2001. }
  2002. return false;
  2003. }
  2005. extern "C" bool MP4AddRtpImmediateData(
  2006. MP4FileHandle hFile,
  2007. MP4TrackId hintTrackId,
  2008. const u_int8_t* pBytes,
  2009. u_int32_t numBytes)
  2010. {
  2011. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2012. try {
  2013. ((MP4File*)hFile)->AddRtpImmediateData(hintTrackId, 
  2014. pBytes, numBytes);
  2015. return true;
  2016. }
  2017. catch (MP4Error* e) {
  2018. PRINT_ERROR(e);
  2019. delete e;
  2020. }
  2021. }
  2022. return false;
  2023. }
  2025. extern "C" bool MP4AddRtpSampleData(
  2026. MP4FileHandle hFile,
  2027. MP4TrackId hintTrackId,
  2028. MP4SampleId sampleId,
  2029. u_int32_t dataOffset,
  2030. u_int32_t dataLength)
  2031. {
  2032. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2033. try {
  2034. ((MP4File*)hFile)->AddRtpSampleData(
  2035. hintTrackId, sampleId, dataOffset, dataLength);
  2036. return true;
  2037. }
  2038. catch (MP4Error* e) {
  2039. PRINT_ERROR(e);
  2040. delete e;
  2041. }
  2042. }
  2043. return false;
  2044. }
  2046. extern "C" bool MP4AddRtpESConfigurationPacket(
  2047. MP4FileHandle hFile,
  2048. MP4TrackId hintTrackId)
  2049. {
  2050. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2051. try {
  2052. ((MP4File*)hFile)->AddRtpESConfigurationPacket(hintTrackId);
  2053. return true;
  2054. }
  2055. catch (MP4Error* e) {
  2056. PRINT_ERROR(e);
  2057. delete e;
  2058. }
  2059. }
  2060. return false;
  2061. }
  2063. extern "C" bool MP4WriteRtpHint(
  2064. MP4FileHandle hFile,
  2065. MP4TrackId hintTrackId,
  2066. MP4Duration duration,
  2067. bool isSyncSample)
  2068. {
  2069. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2070. try {
  2071. ((MP4File*)hFile)->WriteRtpHint(
  2072. hintTrackId, duration, isSyncSample);
  2073. return true;
  2074. }
  2075. catch (MP4Error* e) {
  2076. PRINT_ERROR(e);
  2077. delete e;
  2078. }
  2079. }
  2080. return false;
  2081. }
  2083. /* ISMA specific operations */
  2085. extern "C" bool MP4MakeIsmaCompliant(
  2086. const char* fileName, 
  2087. u_int32_t verbosity,
  2088. bool addIsmaComplianceSdp)
  2089. {
  2090. MP4File* pFile = NULL;
  2092. try {
  2093. pFile = new MP4File(verbosity);
  2094. pFile->Modify(fileName);
  2095. pFile->MakeIsmaCompliant(addIsmaComplianceSdp);
  2096. pFile->Close();
  2097. delete pFile;
  2098. return true;
  2099. }
  2100. catch (MP4Error* e) {
  2101. VERBOSE_ERROR(verbosity, e->Print());
  2102. delete e;
  2103. }
  2104. delete pFile;
  2105. return false;
  2106. }
  2108. extern "C" char* MP4MakeIsmaSdpIod(
  2109. u_int8_t videoProfile,
  2110. u_int32_t videoBitrate,
  2111. u_int8_t* videoConfig,
  2112. u_int32_t videoConfigLength,
  2113. u_int8_t audioProfile,
  2114. u_int32_t audioBitrate,
  2115. u_int8_t* audioConfig,
  2116. u_int32_t audioConfigLength,
  2117. u_int32_t verbosity)
  2118. {
  2119. MP4File* pFile = NULL;
  2121. try {
  2122. pFile = new MP4File(verbosity);
  2124. u_int8_t* pBytes = NULL;
  2125. u_int64_t numBytes = 0;
  2127. pFile->CreateIsmaIodFromParams(
  2128. videoProfile,
  2129. videoBitrate,
  2130. videoConfig,
  2131. videoConfigLength,
  2132. audioProfile,
  2133. audioBitrate,
  2134. audioConfig,
  2135. audioConfigLength,
  2136. &pBytes,
  2137. &numBytes);
  2139. char* iodBase64 = 
  2140. MP4ToBase64(pBytes, numBytes);
  2141. MP4Free(pBytes);
  2143. char* sdpIod = 
  2144. (char*)MP4Malloc(strlen(iodBase64) + 64);
  2145. sprintf(sdpIod,
  2146. "a=mpeg4-iod: 42data:application/mpeg4-iod;base64,%s42",
  2147. iodBase64);
  2148. MP4Free(iodBase64);
  2150. delete pFile;
  2152. return sdpIod;
  2153. }
  2154. catch (MP4Error* e) {
  2155. VERBOSE_ERROR(verbosity, e->Print());
  2156. delete e;
  2157. }
  2158. delete pFile;
  2159. return NULL;
  2160. }
  2162. /* Edit list */
  2164. extern "C" MP4EditId MP4AddTrackEdit(
  2165. MP4FileHandle hFile,
  2166. MP4TrackId trackId,
  2167. MP4EditId editId,
  2168. MP4Timestamp startTime,
  2169. MP4Duration duration,
  2170. bool dwell)
  2171. {
  2172. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2173. try {
  2174. MP4EditId editId =
  2175. ((MP4File*)hFile)->AddTrackEdit(trackId, editId);
  2177. if (editId != MP4_INVALID_EDIT_ID) {
  2178. ((MP4File*)hFile)->SetTrackEditMediaStart(
  2179. trackId, editId, startTime);
  2180. ((MP4File*)hFile)->SetTrackEditDuration(
  2181. trackId, editId, duration);
  2182. ((MP4File*)hFile)->SetTrackEditDwell(
  2183. trackId, editId, dwell);
  2184. }
  2186. return editId;
  2187. }
  2188. catch (MP4Error* e) {
  2189. PRINT_ERROR(e);
  2190. delete e;
  2191. }
  2192. }
  2193. return MP4_INVALID_EDIT_ID;
  2194. }
  2196. extern "C" bool MP4DeleteTrackEdit(
  2197. MP4FileHandle hFile,
  2198. MP4TrackId trackId,
  2199. MP4EditId editId)
  2200. {
  2201. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2202. try {
  2203. ((MP4File*)hFile)->DeleteTrackEdit(trackId, editId);
  2204. return true;
  2205. }
  2206. catch (MP4Error* e) {
  2207. PRINT_ERROR(e);
  2208. delete e;
  2209. }
  2210. }
  2211. return false;
  2212. }
  2214. extern "C" u_int32_t MP4GetTrackNumberOfEdits(
  2215. MP4FileHandle hFile,
  2216. MP4TrackId trackId)
  2217. {
  2218. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2219. try {
  2220. return ((MP4File*)hFile)->GetTrackNumberOfEdits(trackId);
  2221. }
  2222. catch (MP4Error* e) {
  2223. PRINT_ERROR(e);
  2224. delete e;
  2225. }
  2226. }
  2227. return 0;
  2228. }
  2230. extern "C" MP4Timestamp MP4GetTrackEditMediaStart(
  2231. MP4FileHandle hFile,
  2232. MP4TrackId trackId,
  2233. MP4EditId editId)
  2234. {
  2235. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2236. try {
  2237. return ((MP4File*)hFile)->GetTrackEditMediaStart(
  2238. trackId, editId);
  2239. }
  2240. catch (MP4Error* e) {
  2241. PRINT_ERROR(e);
  2242. delete e;
  2243. }
  2244. }
  2245. return MP4_INVALID_TIMESTAMP;
  2246. }
  2248. extern "C" MP4Duration MP4GetTrackEditTotalDuration(
  2249. MP4FileHandle hFile,
  2250. MP4TrackId trackId,
  2251. MP4EditId editId)
  2252. {
  2253. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2254. try {
  2255. return ((MP4File*)hFile)->GetTrackEditTotalDuration(
  2256. trackId, editId);
  2257. }
  2258. catch (MP4Error* e) {
  2259. PRINT_ERROR(e);
  2260. delete e;
  2261. }
  2262. }
  2263. return MP4_INVALID_DURATION;
  2264. }
  2266. extern "C" bool MP4SetTrackEditMediaStart(
  2267. MP4FileHandle hFile,
  2268. MP4TrackId trackId,
  2269. MP4EditId editId,
  2270. MP4Timestamp startTime)
  2271. {
  2272. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2273. try {
  2274. ((MP4File*)hFile)->SetTrackEditMediaStart(
  2275. trackId, editId, startTime);
  2276. return true;
  2277. }
  2278. catch (MP4Error* e) {
  2279. PRINT_ERROR(e);
  2280. delete e;
  2281. }
  2282. }
  2283. return false;
  2284. }
  2286. extern "C" MP4Duration MP4GetTrackEditDuration(
  2287. MP4FileHandle hFile,
  2288. MP4TrackId trackId,
  2289. MP4EditId editId)
  2290. {
  2291. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2292. try {
  2293. return ((MP4File*)hFile)->GetTrackEditDuration(trackId, editId);
  2294. }
  2295. catch (MP4Error* e) {
  2296. PRINT_ERROR(e);
  2297. delete e;
  2298. }
  2299. }
  2300. return MP4_INVALID_DURATION;
  2301. }
  2303. extern "C" bool MP4SetTrackEditDuration(
  2304. MP4FileHandle hFile,
  2305. MP4TrackId trackId,
  2306. MP4EditId editId,
  2307. MP4Duration duration)
  2308. {
  2309. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2310. try {
  2311. ((MP4File*)hFile)->SetTrackEditDuration(trackId, editId, duration);
  2312. return true;
  2313. }
  2314. catch (MP4Error* e) {
  2315. PRINT_ERROR(e);
  2316. delete e;
  2317. }
  2318. }
  2319. return false;
  2320. }
  2322. extern "C" int8_t MP4GetTrackEditDwell(
  2323. MP4FileHandle hFile,
  2324. MP4TrackId trackId,
  2325. MP4EditId editId)
  2326. {
  2327. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2328. try {
  2329. return ((MP4File*)hFile)->GetTrackEditDwell(trackId, editId);
  2330. }
  2331. catch (MP4Error* e) {
  2332. PRINT_ERROR(e);
  2333. delete e;
  2334. }
  2335. }
  2336. return -1;
  2337. }
  2339. extern "C" bool MP4SetTrackEditDwell(
  2340. MP4FileHandle hFile,
  2341. MP4TrackId trackId,
  2342. MP4EditId editId,
  2343. bool dwell)
  2344. {
  2345. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2346. try {
  2347. ((MP4File*)hFile)->SetTrackEditDwell(trackId, editId, dwell);
  2348. return true;
  2349. }
  2350. catch (MP4Error* e) {
  2351. PRINT_ERROR(e);
  2352. delete e;
  2353. }
  2354. }
  2355. return false;
  2356. }
  2358. extern "C" bool MP4ReadSampleFromEditTime(
  2359. /* input parameters */
  2360. MP4FileHandle hFile,
  2361. MP4TrackId trackId, 
  2362. MP4Timestamp when,
  2363. /* output parameters */
  2364. u_int8_t** ppBytes, 
  2365. u_int32_t* pNumBytes, 
  2366. MP4Timestamp* pStartTime, 
  2367. MP4Duration* pDuration,
  2368. MP4Duration* pRenderingOffset, 
  2369. bool* pIsSyncSample)
  2370. {
  2371. MP4SampleId sampleId = 
  2372. MP4GetSampleIdFromEditTime(
  2373. hFile,
  2374. trackId, 
  2375. when, 
  2376. pStartTime,
  2377. pDuration);
  2379. return MP4ReadSample(
  2380. hFile,
  2381. trackId, 
  2382. sampleId, 
  2383. ppBytes, 
  2384. pNumBytes, 
  2385. NULL,
  2386. NULL, 
  2387. pRenderingOffset, 
  2388. pIsSyncSample);
  2389. }
  2391. extern "C" MP4SampleId MP4GetSampleIdFromEditTime(
  2392. MP4FileHandle hFile,
  2393. MP4TrackId trackId, 
  2394. MP4Timestamp when,
  2395. MP4Timestamp* pStartTime,
  2396. MP4Duration* pDuration)
  2397. {
  2398. if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
  2399. try {
  2400. return ((MP4File*)hFile)->GetSampleIdFromEditTime(
  2401. trackId, when, pStartTime, pDuration);
  2402. }
  2403. catch (MP4Error* e) {
  2404. PRINT_ERROR(e);
  2405. delete e;
  2406. }
  2407. }
  2408. return MP4_INVALID_SAMPLE_ID;
  2409. }
  2411. /* Utlities */
  2413. extern "C" char* MP4BinaryToBase16(
  2414. const u_int8_t* pData, 
  2415. u_int32_t dataSize)
  2416. {
  2417. if (pData || dataSize == 0) {
  2418. try {
  2419. return MP4ToBase16(pData, dataSize);
  2420. }
  2421. catch (MP4Error* e) {
  2422. delete e;
  2423. }
  2424. }
  2425. return NULL;
  2426. }
  2428. extern "C" char* MP4BinaryToBase64(
  2429. const u_int8_t* pData, 
  2430. u_int32_t dataSize)
  2431. {
  2432. if (pData || dataSize == 0) {
  2433. try {
  2434. return MP4ToBase64(pData, dataSize);
  2435. }
  2436. catch (MP4Error* e) {
  2437. delete e;
  2438. }
  2439. }
  2440. return NULL;
  2441. }