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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mp4file.h：源码内容
  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. #ifndef __MP4_FILE_INCLUDED__
  23. #define __MP4_FILE_INCLUDED__
  25. // forward declarations
  26. class MP4Atom;
  27. class MP4Property;
  28. class MP4Float32Property;
  29. class MP4StringProperty;
  30. class MP4BytesProperty;
  31. class MP4Descriptor;
  32. class MP4DescriptorProperty;
  34. class MP4File {
  35. public: /* equivalent to MP4 library API */
  36. MP4File(u_int32_t verbosity = 0);
  37. ~MP4File();
  39. /* file operations */
  40. void Read(const char* fileName);
  41. void Create(const char* fileName, bool use64bits);
  42. void Modify(const char* fileName);
  43. void Optimize(const char* orgFileName, 
  44. const char* newFileName = NULL);
  45. void Dump(FILE* pDumpFile = NULL, bool dumpImplicits = false);
  46. void Close();
  48. /* library property per file */
  50. u_int32_t GetVerbosity() {
  51. return m_verbosity;
  52. }
  53. void SetVerbosity(u_int32_t verbosity) {
  54. m_verbosity = verbosity;
  55. }
  57. bool Use64Bits() {
  58. return m_use64bits;
  59. }
  61. /* file properties */
  63. u_int64_t GetIntegerProperty(const char* name);
  64. float GetFloatProperty(const char* name);
  65. const char* GetStringProperty(const char* name);
  66. void GetBytesProperty(const char* name,
  67. u_int8_t** ppValue, u_int32_t* pValueSize);
  69. void SetIntegerProperty(const char* name, u_int64_t value);
  70. void SetFloatProperty(const char* name, float value);
  71. void SetStringProperty(const char* name, const char* value);
  72. void SetBytesProperty(const char* name, 
  73. const u_int8_t* pValue, u_int32_t valueSize);
  75. // file level convenience functions
  77. MP4Duration GetDuration();
  78. void SetDuration(MP4Duration value);
  80. u_int32_t GetTimeScale();
  81. void SetTimeScale(u_int32_t value);
  83. u_int8_t GetODProfileLevel();
  84. void SetODProfileLevel(u_int8_t value);
  86. u_int8_t GetSceneProfileLevel();
  87. void SetSceneProfileLevel(u_int8_t value);
  89. u_int8_t GetVideoProfileLevel();
  90. void SetVideoProfileLevel(u_int8_t value);
  92. u_int8_t GetAudioProfileLevel();
  93. void SetAudioProfileLevel(u_int8_t value);
  95. u_int8_t GetGraphicsProfileLevel();
  96. void SetGraphicsProfileLevel(u_int8_t value);
  98. const char* GetSessionSdp();
  99. void SetSessionSdp(const char* sdpString);
  100. void AppendSessionSdp(const char* sdpString);
  102. /* track operations */
  104. MP4TrackId AddTrack(const char* type, u_int32_t timeScale = 1000);
  105. void DeleteTrack(MP4TrackId trackId);
  107. u_int32_t GetNumberOfTracks(const char* type = NULL, u_int8_t subType = 0);
  109. MP4TrackId AllocTrackId();
  110. MP4TrackId FindTrackId(u_int16_t trackIndex, 
  111. const char* type = NULL, u_int8_t subType = 0);
  112. u_int16_t FindTrackIndex(MP4TrackId trackId);
  113. u_int16_t FindTrakAtomIndex(MP4TrackId trackId);
  115. /* track properties */
  117. u_int64_t GetTrackIntegerProperty(
  118. MP4TrackId trackId, const char* name);
  119. float GetTrackFloatProperty(
  120. MP4TrackId trackId, const char* name);
  121. const char* GetTrackStringProperty(
  122. MP4TrackId trackId, const char* name);
  123. void GetTrackBytesProperty(
  124. MP4TrackId trackId, const char* name,
  125. u_int8_t** ppValue, u_int32_t* pValueSize);
  127. void SetTrackIntegerProperty(
  128. MP4TrackId trackId, const char* name, int64_t value);
  129. void SetTrackFloatProperty(
  130. MP4TrackId trackId, const char* name, float value);
  131. void SetTrackStringProperty(
  132. MP4TrackId trackId, const char* name, const char* value);
  133. void SetTrackBytesProperty(
  134. MP4TrackId trackId, const char* name, 
  135. const u_int8_t* pValue, u_int32_t valueSize);
  137. /* sample operations */
  139. u_int32_t GetSampleSize(MP4TrackId trackId, MP4SampleId sampleId);
  141. u_int32_t GetTrackMaxSampleSize(MP4TrackId trackId);
  143. MP4SampleId GetSampleIdFromTime(MP4TrackId trackId, 
  144. MP4Timestamp when, bool wantSyncSample = false);
  146. MP4Timestamp GetSampleTime(
  147. MP4TrackId trackId, MP4SampleId sampleId);
  149. MP4Duration GetSampleDuration(
  150. MP4TrackId trackId, MP4SampleId sampleId);
  152. MP4Duration GetSampleRenderingOffset(
  153. MP4TrackId trackId, MP4SampleId sampleId);
  155. bool GetSampleSync(
  156. MP4TrackId trackId, MP4SampleId sampleId);
  158. void ReadSample(
  159. // input parameters
  160. MP4TrackId trackId, 
  161. MP4SampleId sampleId,
  162. // output parameters
  163. u_int8_t** ppBytes, 
  164. u_int32_t* pNumBytes, 
  165. MP4Timestamp* pStartTime = NULL, 
  166. MP4Duration* pDuration = NULL,
  167. MP4Duration* pRenderingOffset = NULL, 
  168. bool* pIsSyncSample = NULL);
  170. void WriteSample(
  171. MP4TrackId trackId,
  172. u_int8_t* pBytes, 
  173. u_int32_t numBytes,
  174. MP4Duration duration = 0,
  175. MP4Duration renderingOffset = 0, 
  176. bool isSyncSample = true);
  178. void SetSampleRenderingOffset(
  179. MP4TrackId trackId, 
  180. MP4SampleId sampleId,
  181. MP4Duration renderingOffset);
  183. /* track level convenience functions */
  185. MP4TrackId AddSystemsTrack(const char* type);
  187. MP4TrackId AddODTrack();
  189. MP4TrackId AddSceneTrack();
  191. MP4TrackId AddAudioTrack(
  192. u_int32_t timeScale, 
  193. MP4Duration sampleDuration,
  194. u_int8_t audioType);
  196. MP4TrackId AddVideoTrack(
  197. u_int32_t timeScale, 
  198. MP4Duration sampleDuration,
  199. u_int16_t width, 
  200. u_int16_t height, 
  201. u_int8_t videoType);
  203. MP4TrackId AddHintTrack(MP4TrackId refTrackId);
  205. MP4SampleId GetTrackNumberOfSamples(MP4TrackId trackId);
  207. const char* GetTrackType(MP4TrackId trackId);
  209. MP4Duration GetTrackDuration(MP4TrackId trackId);
  211. u_int32_t GetTrackTimeScale(MP4TrackId trackId);
  212. void SetTrackTimeScale(MP4TrackId trackId, u_int32_t value);
  214. u_int8_t GetTrackAudioType(MP4TrackId trackId);
  215. u_int8_t GetTrackAudioMpeg4Type(MP4TrackId trackId);
  216. u_int8_t GetTrackVideoType(MP4TrackId trackId);
  218. MP4Duration GetTrackFixedSampleDuration(MP4TrackId trackId);
  220. float GetTrackVideoFrameRate(MP4TrackId trackId);
  222. void GetTrackESConfiguration(MP4TrackId trackId, 
  223. u_int8_t** ppConfig, u_int32_t* pConfigSize);
  224. void SetTrackESConfiguration(MP4TrackId trackId, 
  225. const u_int8_t* pConfig, u_int32_t configSize);
  227. const char* GetHintTrackSdp(MP4TrackId hintTrackId);
  228. void SetHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString);
  229. void AppendHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString);
  231. // ISMA specific functions
  233. void MakeIsmaCompliant(bool addIsmaComplianceSdp = true);
  235. void CreateIsmaIodFromParams(
  236. u_int8_t videoProfile,
  237. u_int32_t videoBitrate,
  238. u_int8_t* videoConfig,
  239. u_int32_t videoConfigLength,
  240. u_int8_t audioProfile,
  241. u_int32_t audioBitrate,
  242. u_int8_t* audioConfig,
  243. u_int32_t audioConfigLength,
  244. u_int8_t** ppBytes,
  245. u_int64_t* pNumBytes);
  247. // time convenience functions
  249. u_int64_t ConvertFromMovieDuration(
  250. MP4Duration duration,
  251. u_int32_t timeScale);
  253. u_int64_t ConvertFromTrackTimestamp(
  254. MP4TrackId trackId, 
  255. MP4Timestamp timeStamp,
  256. u_int32_t timeScale);
  258. MP4Timestamp ConvertToTrackTimestamp(
  259. MP4TrackId trackId, 
  260. u_int64_t timeStamp,
  261. u_int32_t timeScale);
  263. u_int64_t ConvertFromTrackDuration(
  264. MP4TrackId trackId, 
  265. MP4Duration duration,
  266. u_int32_t timeScale);
  268. MP4Duration ConvertToTrackDuration(
  269. MP4TrackId trackId, 
  270. u_int64_t duration,
  271. u_int32_t timeScale);
  273. // specialized operations
  275. void GetHintTrackRtpPayload(
  276. MP4TrackId hintTrackId,
  277. char** ppPayloadName = NULL,
  278. u_int8_t* pPayloadNumber = NULL,
  279. u_int16_t* pMaxPayloadSize = NULL);
  281. void SetHintTrackRtpPayload(
  282. MP4TrackId hintTrackId,
  283. const char* payloadName,
  284. u_int8_t* pPayloadNumber,
  285. u_int16_t maxPayloadSize);
  287. MP4TrackId GetHintTrackReferenceTrackId(
  288. MP4TrackId hintTrackId);
  290. void ReadRtpHint(
  291. MP4TrackId hintTrackId,
  292. MP4SampleId hintSampleId,
  293. u_int16_t* pNumPackets = NULL);
  295. u_int16_t GetRtpHintNumberOfPackets(
  296. MP4TrackId hintTrackId);
  298. int8_t GetRtpPacketBFrame(
  299. MP4TrackId hintTrackId,
  300. u_int16_t packetIndex);
  302. int32_t GetRtpPacketTransmitOffset(
  303. MP4TrackId hintTrackId,
  304. u_int16_t packetIndex);
  306. void ReadRtpPacket(
  307. MP4TrackId hintTrackId,
  308. u_int16_t packetIndex,
  309. u_int8_t** ppBytes, 
  310. u_int32_t* pNumBytes,
  311. u_int32_t ssrc = 0,
  312. bool includeHeader = true,
  313. bool includePayload = true);
  315. MP4Timestamp GetRtpTimestampStart(
  316. MP4TrackId hintTrackId);
  318. void SetRtpTimestampStart(
  319. MP4TrackId hintTrackId,
  320. MP4Timestamp rtpStart);
  322. void AddRtpHint(
  323. MP4TrackId hintTrackId,
  324. bool isBframe, 
  325. u_int32_t timestampOffset);
  327. void AddRtpPacket(
  328. MP4TrackId hintTrackId, 
  329. bool setMbit,
  330. int32_t transmitOffset);
  332. void AddRtpImmediateData(
  333. MP4TrackId hintTrackId,
  334. const u_int8_t* pBytes,
  335. u_int32_t numBytes);
  337. void AddRtpSampleData(
  338. MP4TrackId hintTrackId,
  339. MP4SampleId sampleId,
  340. u_int32_t dataOffset,
  341. u_int32_t dataLength);
  343. void AddRtpESConfigurationPacket(
  344. MP4TrackId hintTrackId);
  346. void WriteRtpHint(
  347. MP4TrackId hintTrackId,
  348. MP4Duration duration,
  349. bool isSyncSample);
  351. u_int8_t AllocRtpPayloadNumber();
  353. // edit list related
  355. char* MakeTrackEditName(
  356. MP4TrackId trackId,
  357. MP4EditId editId,
  358. const char* name);
  360. MP4EditId AddTrackEdit(
  361. MP4TrackId trackId,
  362. MP4EditId editId = MP4_INVALID_EDIT_ID);
  364. void DeleteTrackEdit(
  365. MP4TrackId trackId,
  366. MP4EditId editId);
  368. u_int32_t GetTrackNumberOfEdits(
  369. MP4TrackId trackId);
  371. MP4Timestamp GetTrackEditStart(
  372. MP4TrackId trackId,
  373. MP4EditId editId);
  375. MP4Duration GetTrackEditTotalDuration(
  376. MP4TrackId trackId,
  377. MP4EditId editId);
  379. MP4Timestamp GetTrackEditMediaStart(
  380. MP4TrackId trackId,
  381. MP4EditId editId);
  383. void SetTrackEditMediaStart(
  384. MP4TrackId trackId,
  385. MP4EditId editId,
  386. MP4Timestamp startTime);
  388. MP4Duration GetTrackEditDuration(
  389. MP4TrackId trackId,
  390. MP4EditId editId);
  392. void SetTrackEditDuration(
  393. MP4TrackId trackId,
  394. MP4EditId editId,
  395. MP4Duration duration);
  397. bool GetTrackEditDwell(
  398. MP4TrackId trackId,
  399. MP4EditId editId);
  401. void SetTrackEditDwell(
  402. MP4TrackId trackId,
  403. MP4EditId editId,
  404. bool dwell);
  406. MP4SampleId GetSampleIdFromEditTime(
  407. MP4TrackId trackId,
  408. MP4Timestamp when,
  409. MP4Timestamp* pStartTime = NULL,
  410. MP4Duration* pDuration = NULL);
  412. /* end of MP4 API */
  414. /* "protected" interface to be used only by friends in library */
  416. u_int64_t GetPosition(FILE* pFile = NULL);
  417. void SetPosition(u_int64_t pos, FILE* pFile = NULL);
  419. u_int64_t GetSize();
  421. u_int32_t ReadBytes(
  422. u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL);
  423. u_int64_t ReadUInt(u_int8_t size);
  424. u_int8_t ReadUInt8();
  425. u_int16_t ReadUInt16();
  426. u_int32_t ReadUInt24();
  427. u_int32_t ReadUInt32();
  428. u_int64_t ReadUInt64();
  429. float ReadFixed16();
  430. float ReadFixed32();
  431. float ReadFloat();
  432. char* ReadString();
  433. char* ReadCountedString(
  434. u_int8_t charSize = 1, bool allowExpandedCount = false);
  435. u_int64_t ReadBits(u_int8_t numBits);
  436. void FlushReadBits();
  437. u_int32_t ReadMpegLength();
  439. u_int32_t PeekBytes(
  440. u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL);
  442. void WriteBytes(u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL);
  443. void WriteUInt(u_int64_t value, u_int8_t size);
  444. void WriteUInt8(u_int8_t value);
  445. void WriteUInt16(u_int16_t value);
  446. void WriteUInt24(u_int32_t value);
  447. void WriteUInt32(u_int32_t value);
  448. void WriteUInt64(u_int64_t value);
  449. void WriteFixed16(float value);
  450. void WriteFixed32(float value);
  451. void WriteFloat(float value);
  452. void WriteString(char* string);
  453. void WriteCountedString(char* string, 
  454. u_int8_t charSize = 1, bool allowExpandedCount = false);
  455. void WriteBits(u_int64_t bits, u_int8_t numBits);
  456. void PadWriteBits(u_int8_t pad = 0);
  457. void FlushWriteBits();
  458. void WriteMpegLength(u_int32_t value, bool compact = false);
  460. void EnableMemoryBuffer(
  461. u_int8_t* pBytes = NULL, u_int64_t numBytes = 0);
  462. void DisableMemoryBuffer(
  463. u_int8_t** ppBytes = NULL, u_int64_t* pNumBytes = NULL);
  465. char GetMode() {
  466. return m_mode;
  467. }
  469. MP4Track* GetTrack(MP4TrackId trackId);
  471. MP4Duration UpdateDuration(MP4Duration duration);
  473. MP4Atom* FindAtom(const char* name);
  475. MP4Atom* AddChildAtom(
  476. const char* parentName, 
  477. const char* childName);
  479. MP4Atom* AddChildAtom(
  480. MP4Atom* pParentAtom, 
  481. const char* childName);
  483. MP4Atom* InsertChildAtom(
  484. const char* parentName, 
  485. const char* childName, 
  486. u_int32_t index);
  488. MP4Atom* InsertChildAtom(
  489. MP4Atom* pParentAtom, 
  490. const char* childName, 
  491. u_int32_t index);
  493. MP4Atom* AddDescendantAtoms(
  494. const char* ancestorName, 
  495. const char* childName);
  497. MP4Atom* AddDescendantAtoms(
  498. MP4Atom* pAncestorAtom,
  499. const char* childName);
  501. protected:
  502. void Open(const char* fmode);
  503. void ReadFromFile();
  504. void GenerateTracks();
  505. void BeginWrite();
  506. void FinishWrite();
  507. void CacheProperties();
  508. void RewriteMdat(FILE* pReadFile, FILE* pWriteFile);
  510. const char* TempFileName();
  511. void Rename(const char* existingFileName, const char* newFileName);
  513. void ProtectWriteOperation(char* where);
  515. void FindIntegerProperty(const char* name, 
  516. MP4Property** ppProperty, u_int32_t* pIndex = NULL);
  517. void FindFloatProperty(const char* name, 
  518. MP4Property** ppProperty, u_int32_t* pIndex = NULL);
  519. void FindStringProperty(const char* name, 
  520. MP4Property** ppProperty, u_int32_t* pIndex = NULL);
  521. void FindBytesProperty(const char* name, 
  522. MP4Property** ppProperty, u_int32_t* pIndex = NULL);
  524. bool FindProperty(const char* name,
  525. MP4Property** ppProperty, u_int32_t* pIndex = NULL);
  527. void AddTrackToIod(MP4TrackId trackId);
  529. void RemoveTrackFromIod(MP4TrackId trackId);
  531. void AddTrackToOd(MP4TrackId trackId);
  533. void RemoveTrackFromOd(MP4TrackId trackId);
  535. void GetTrackReferenceProperties(const char* trefName,
  536. MP4Property** ppCountProperty, MP4Property** ppTrackIdProperty);
  538. void AddTrackReference(const char* trefName, MP4TrackId refTrackId);
  540. u_int32_t FindTrackReference(const char* trefName, MP4TrackId refTrackId);
  542. void RemoveTrackReference(const char* trefName, MP4TrackId refTrackId);
  544. void AddDataReference(MP4TrackId trackId, const char* url);
  546. char* MakeTrackName(MP4TrackId trackId, const char* name);
  548. u_int8_t ConvertTrackTypeToStreamType(const char* trackType);
  550. void CreateIsmaIodFromFile(
  551. MP4TrackId odTrackId,
  552. MP4TrackId sceneTrackId,
  553. MP4TrackId audioTrackId, 
  554. MP4TrackId videoTrackId,
  555. u_int8_t** ppBytes,
  556. u_int64_t* pNumBytes);
  558. MP4Descriptor* CreateESD(
  559. MP4DescriptorProperty* pEsProperty,
  560. u_int32_t esid,
  561. u_int8_t objectType,
  562. u_int8_t streamType,
  563. u_int32_t bufferSize,
  564. u_int32_t bitrate,
  565. u_int8_t* pConfig,
  566. u_int32_t configLength,
  567. char* url);
  569. void CreateIsmaODUpdateCommandFromFileForFile(
  570. MP4TrackId odTrackId,
  571. MP4TrackId audioTrackId, 
  572. MP4TrackId videoTrackId,
  573. u_int8_t** ppBytes,
  574. u_int64_t* pNumBytes);
  576. void CreateIsmaODUpdateCommandFromFileForStream(
  577. MP4TrackId audioTrackId, 
  578. MP4TrackId videoTrackId,
  579. u_int8_t** ppBytes,
  580. u_int64_t* pNumBytes);
  582. void CreateIsmaODUpdateCommandForStream(
  583. MP4DescriptorProperty* pAudioEsdProperty, 
  584. MP4DescriptorProperty* pVideoEsdProperty,
  585. u_int8_t** ppBytes,
  586. u_int64_t* pNumBytes);
  588. void CreateIsmaSceneCommand(
  589. bool hasAudio,
  590. bool hasVideo,
  591. u_int8_t** ppBytes, 
  592. u_int64_t* pNumBytes);
  594. protected:
  595. char* m_fileName;
  596. FILE* m_pFile;
  597. u_int64_t m_orgFileSize;
  598. u_int64_t m_fileSize;
  599. MP4Atom* m_pRootAtom;
  600. MP4Integer32Array m_trakIds;
  601. MP4TrackArray m_pTracks;
  602. MP4TrackId m_odTrackId;
  603. u_int32_t m_verbosity;
  604. char m_mode;
  605. bool m_use64bits;
  606. bool m_useIsma;
  608. // cached properties
  609. MP4IntegerProperty* m_pModificationProperty;
  610. MP4Integer32Property* m_pTimeScaleProperty;
  611. MP4IntegerProperty* m_pDurationProperty;
  613. // read/write in memory
  614. u_int8_t* m_memoryBuffer;
  615. u_int64_t m_memoryBufferPosition;
  616. u_int64_t m_memoryBufferSize;
  618. // bit read/write buffering
  619. u_int8_t m_numReadBits;
  620. u_int8_t m_bufReadBits;
  621. u_int8_t m_numWriteBits;
  622. u_int8_t m_bufWriteBits;
  623. };
  625. #endif /* __MP4_FILE_INCLUDED__ */