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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
MatroskaFile.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

MatroskaFile.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "stdafx.h"
  23. #include "MatroskaFile.h"
  24. #include "......DSUtilDSUtil.h"
  26. using namespace MatroskaWriter;
  28. static void bswap(BYTE* s, int len)
  29. {
  30. for(BYTE* d = s + len-1; s < d; s++, d--)
  31. *s ^= *d, *d ^= *s, *s ^= *d;
  32. }
  34. //
  36. CID::CID(DWORD id) : m_id(id)
  37. {
  38. }
  40. QWORD CID::Size(bool fWithHeader)
  41. {
  42. return CUInt(0, m_id).Size(false);
  43. }
  45. HRESULT CID::Write(IStream* pStream)
  46. {
  47. QWORD len = CID::Size();
  48. DWORD id = m_id;
  49. bswap((BYTE*)&id, (int)len);
  50. *(BYTE*)&id = ((*(BYTE*)&id)&(1<<(8-len))-1)|(1<<(8-len));
  51. return pStream->Write(&id, (ULONG)len, NULL);
  52. }
  54. QWORD CID::HeaderSize(QWORD len)
  55. {
  56. return CID::Size() + CLength(len).Size();
  57. }
  59. HRESULT CID::HeaderWrite(IStream* pStream)
  60. {
  61. CID::Write(pStream);
  62. CLength(Size(false)).Write(pStream);
  63. return S_OK;
  64. }
  66. QWORD CBinary::Size(bool fWithHeader)
  67. {
  68. if(GetSize() == 0) return 0;
  70. QWORD len = 0;
  71. len += GetSize();
  72. if(fWithHeader) len += HeaderSize(len);
  73. return len;
  74. }
  76. HRESULT CBinary::Write(IStream* pStream)
  77. {
  78. if(GetSize() == 0) return S_OK;
  80. HeaderWrite(pStream);
  81. return pStream->Write(GetData(), GetSize(), NULL);
  82. }
  84. QWORD CANSI::Size(bool fWithHeader)
  85. {
  86. if(GetLength() == 0) return 0;
  88. QWORD len = 0;
  89. len += GetLength();
  90. if(fWithHeader) len += HeaderSize(len);
  91. return len;
  92. }
  94. HRESULT CANSI::Write(IStream* pStream)
  95. {
  96. if(GetLength() == 0) return S_OK;
  98. HeaderWrite(pStream);
  99. return pStream->Write((LPCSTR)*this, GetLength(), NULL);
  100. }
  102. QWORD CUTF8::Size(bool fWithHeader)
  103. {
  104. if(GetLength() == 0) return 0;
  106. QWORD len = 0;
  107. len += UTF16To8(*this).GetLength();
  108. if(fWithHeader) len += HeaderSize(len);
  109. return len;
  110. }
  112. HRESULT CUTF8::Write(IStream* pStream)
  113. {
  114. if(GetLength() == 0) return S_OK;
  116. HeaderWrite(pStream);
  117. CStringA str = UTF16To8(*this);
  118. return pStream->Write((BYTE*)(LPCSTR)str, str.GetLength(), NULL);
  119. }
  121. template<class T, class BASE>
  122. QWORD CSimpleVar<T, BASE>::Size(bool fWithHeader)
  123. {
  124. if(!m_fSet) return 0;
  126. QWORD len = 0;
  127. len += sizeof(T);
  128. if(fWithHeader) len += HeaderSize(len);
  129. return len;
  130. }
  132. template<class T, class BASE>
  133. HRESULT CSimpleVar<T, BASE>::Write(IStream* pStream)
  134. {
  135. if(!m_fSet) return S_OK;
  137. HeaderWrite(pStream);
  138. T val = m_val;
  139. bswap((BYTE*)&val, sizeof(T));
  140. return pStream->Write(&val, sizeof(T), NULL);
  141. }
  143. QWORD CUInt::Size(bool fWithHeader)
  144. {
  145. if(!m_fSet) return 0;
  147. QWORD len = 0;
  149. if(m_val == 0)
  150. {
  151. len++;
  152. }
  153. else
  154. {
  155. for(int i = 8; i > 0; i--)
  156. {
  157. if(((0xffi64<<((i-1)*8))&m_val))
  158. {
  159. len += i; 
  160. break;
  161. }
  162. }
  163. }
  164. if(fWithHeader) len += HeaderSize(len);
  165. return len;
  166. }
  168. HRESULT CUInt::Write(IStream* pStream)
  169. {
  170. if(!m_fSet) return S_OK;
  172. CID::Write(pStream);
  173. CLength l(Size(false));
  174. l.Write(pStream);
  175. UINT64 val = m_val;
  176. bswap((BYTE*)&val, (int)l);
  177. return pStream->Write(&val, (ULONG)l, NULL);
  178. }
  180. QWORD CInt::Size(bool fWithHeader)
  181. {
  182. if(!m_fSet) return 0;
  184. QWORD len = 0;
  186. if(m_val == 0)
  187. {
  188. len++;
  189. }
  190. else
  191. {
  192. UINT64 val = m_val >= 0 ? m_val : -m_val;
  193. for(int i = 8; i > 0; i--)
  194. {
  195. if(((0xffi64<<((i-1)*8))&val))
  196. {
  197. len += i; 
  198. if(m_val < 0 && !(m_val&(0x80<<(i-1))))
  199. len++;
  200. break;
  201. }
  202. }
  203. }
  204. if(fWithHeader) len += HeaderSize(len);
  205. return len;
  206. }
  208. HRESULT CInt::Write(IStream* pStream)
  209. {
  210. if(!m_fSet) return S_OK;
  212. CID::Write(pStream);
  213. CLength l(Size(false));
  214. l.Write(pStream);
  215. UINT64 val = m_val;
  216. bswap((BYTE*)&val, (int)l);
  217. return pStream->Write(&val, (ULONG)l, NULL);
  218. }
  220. QWORD CLength::Size(bool fWithHeader)
  221. {
  222. if(m_len == 0x00FFFFFFFFFFFFFFi64)
  223. return 8;
  225. QWORD len = 0;
  226. for(int i = 1; i <= 8; i++)
  227. {
  228. if(!(m_len&(~((1i64<<(7*i))-1))) && (m_len&((1i64<<(7*i))-1)) != ((1i64<<(7*i))-1))
  229. {
  230. len += i; 
  231. break;
  232. }
  233. }
  234. return len;
  235. }
  237. HRESULT CLength::Write(IStream* pStream)
  238. {
  239. QWORD len = Size(false);
  240. UINT64 val = m_len;
  241. bswap((BYTE*)&val, (int)len);
  242. *(BYTE*)&val = ((*(BYTE*)&val)&(1<<(8-len))-1)|(1<<(8-len));
  243. return pStream->Write(&val, (ULONG)len, NULL);
  244. }
  246. //
  248. EBML::EBML(DWORD id) 
  249. : CID(id)
  250. , EBMLVersion(0x4286)
  251. , EBMLReadVersion(0x42F7)
  252. , EBMLMaxIDLength(0x42F2)
  253. , EBMLMaxSizeLength(0x42F3)
  254. , DocType(0x4282)
  255. , DocTypeVersion(0x4287)
  256. , DocTypeReadVersion(0x4285)
  257. {
  258. }
  260. QWORD EBML::Size(bool fWithHeader)
  261. {
  262. QWORD len = 0;
  263. len += EBMLVersion.Size();
  264. len += EBMLReadVersion.Size();
  265. len += EBMLMaxIDLength.Size();
  266. len += EBMLMaxSizeLength.Size();
  267. len += DocType.Size();
  268. len += DocTypeVersion.Size();
  269. len += DocTypeReadVersion.Size();
  270. if(fWithHeader) len += HeaderSize(len);
  271. return len;
  272. }
  274. HRESULT EBML::Write(IStream* pStream)
  275. {
  276. HeaderWrite(pStream);
  277. EBMLVersion.Write(pStream);
  278. EBMLReadVersion.Write(pStream);
  279. EBMLMaxIDLength.Write(pStream);
  280. EBMLMaxSizeLength.Write(pStream);
  281. DocType.Write(pStream);
  282. DocTypeVersion.Write(pStream);
  283. DocTypeReadVersion.Write(pStream);
  284. return S_OK;
  285. }
  287. Info::Info(DWORD id)
  288. : CID(id)
  289. , SegmentUID(0x73A4)
  290. , SegmentFilename(0x7384)
  291. , PrevUID(0x3CB923)
  292. , PrevFilename(0x3C83AB)
  293. , NextUID(0x3EB923)
  294. , NextFilename(0x3E83BB)
  295. , TimeCodeScale(0x2AD7B1, 1000000ui64)
  296. , Duration(0x4489)
  297. , DateUTC(0x4461)
  298. , Title(0x7BA9)
  299. , MuxingApp(0x4D80)
  300. , WritingApp(0x5741)
  301. {
  302. }
  304. QWORD Info::Size(bool fWithHeader)
  305. {
  306. QWORD len = 0;
  307. len += SegmentUID.Size();
  308. len += PrevUID.Size();
  309. len += NextUID.Size();
  310. len += SegmentFilename.Size();
  311. len += PrevFilename.Size();
  312. len += NextFilename.Size();
  313. len += TimeCodeScale.Size();
  314. len += Duration.Size();
  315. len += DateUTC.Size();
  316. len += Title.Size();
  317. len += MuxingApp.Size();
  318. len += WritingApp.Size();
  319. if(fWithHeader) len += HeaderSize(len);
  320. return len;
  321. }
  323. HRESULT Info::Write(IStream* pStream)
  324. {
  325. HeaderWrite(pStream);
  326. SegmentUID.Write(pStream);
  327. PrevUID.Write(pStream);
  328. NextUID.Write(pStream);
  329. SegmentFilename.Write(pStream);
  330. PrevFilename.Write(pStream);
  331. NextFilename.Write(pStream);
  332. TimeCodeScale.Write(pStream);
  333. Duration.Write(pStream);
  334. DateUTC.Write(pStream);
  335. Title.Write(pStream);
  336. MuxingApp.Write(pStream);
  337. WritingApp.Write(pStream);
  338. return S_OK;
  339. }
  341. Segment::Segment(DWORD id)
  342. : CID(id)
  343. {
  344. }
  346. QWORD Segment::Size(bool fWithHeader)
  347. {
  348. return 0x00FFFFFFFFFFFFFFi64;
  349. /*
  350. QWORD len = 0;
  351. if(fWithHeader) len += HeaderSize(len);
  352. return len;
  353. */
  354. }
  356. HRESULT Segment::Write(IStream* pStream)
  357. {
  358. HeaderWrite(pStream);
  359. return S_OK;
  360. }
  362. Track::Track(DWORD id)
  363. : CID(id)
  364. {
  365. }
  367. QWORD Track::Size(bool fWithHeader)
  368. {
  369. QWORD len = 0;
  370. len += TrackEntries.Size();
  371. if(fWithHeader) len += HeaderSize(len);
  372. return len;
  373. }
  375. HRESULT Track::Write(IStream* pStream)
  376. {
  377. HeaderWrite(pStream);
  378. TrackEntries.Write(pStream);
  379. return S_OK;
  380. }
  382. TrackEntry::TrackEntry(DWORD id) 
  383. : CID(id)
  384. , TrackNumber(0xD7)
  385. , TrackUID(0x73C5)
  386. , TrackType(0x83)
  387. , FlagEnabled(0xB9)
  388. , FlagDefault(0x88)
  389. , FlagLacing(0x9C)
  390. , MinCache(0x6DE7)
  391. , MaxCache(0x6DF8)
  392. , Name(0x536E)
  393. , Language(0x22B59C)
  394. , CodecID(0x86)
  395. , CodecPrivate(0x63A2)
  396. , CodecName(0x258688)
  397. , CodecSettings(0x3A9697)
  398. , CodecInfoURL(0x3B4040)
  399. , CodecDownloadURL(0x26B240)
  400. , CodecDecodeAll(0xAA)
  401. , TrackOverlay(0x6FAB)
  402. , DefaultDuration(0x23E383)
  403. , v(0xE0)
  404. , a(0xE1)
  405. {
  406. DescType = NoDesc;
  407. }
  409. QWORD TrackEntry::Size(bool fWithHeader)
  410. {
  411. QWORD len = 0;
  412. len += TrackNumber.Size();
  413. len += TrackUID.Size();
  414. len += TrackType.Size();
  415. len += FlagEnabled.Size();
  416. len += FlagDefault.Size();
  417. len += FlagLacing.Size();
  418. len += MinCache.Size();
  419. len += MaxCache.Size();
  420. len += Name.Size();
  421. len += Language.Size();
  422. len += CodecID.Size();
  423. len += CodecPrivate.Size();
  424. len += CodecName.Size();
  425. len += CodecSettings.Size();
  426. len += CodecInfoURL.Size();
  427. len += CodecDownloadURL.Size();
  428. len += CodecDecodeAll.Size();
  429. len += TrackOverlay.Size();
  430. len += DefaultDuration.Size();
  431. if(DescType == TypeVideo) len += v.Size();
  432. if(DescType == TypeAudio) len += a.Size();
  433. if(fWithHeader) len += HeaderSize(len);
  434. return len;
  435. }
  437. HRESULT TrackEntry::Write(IStream* pStream)
  438. {
  439. HeaderWrite(pStream);
  440. TrackNumber.Write(pStream);
  441. TrackUID.Write(pStream);
  442. TrackType.Write(pStream);
  443. FlagEnabled.Write(pStream);
  444. FlagDefault.Write(pStream);
  445. FlagLacing.Write(pStream);
  446. MinCache.Write(pStream);
  447. MaxCache.Write(pStream);
  448. Name.Write(pStream);
  449. Language.Write(pStream);
  450. CodecID.Write(pStream);
  451. CodecPrivate.Write(pStream);
  452. CodecName.Write(pStream);
  453. CodecSettings.Write(pStream);
  454. CodecInfoURL.Write(pStream);
  455. CodecDownloadURL.Write(pStream);
  456. CodecDecodeAll.Write(pStream);
  457. TrackOverlay.Write(pStream);
  458. DefaultDuration.Write(pStream);
  459. if(DescType == TypeVideo) v.Write(pStream);
  460. if(DescType == TypeAudio) a.Write(pStream);
  461. return S_OK;
  462. }
  464. Video::Video(DWORD id)
  465. : CID(id)
  466. , FlagInterlaced(0x9A)
  467. , StereoMode(0x53B8)
  468. , PixelWidth(0xB0)
  469. , PixelHeight(0xBA)
  470. , DisplayWidth(0x54B0)
  471. , DisplayHeight(0x54BA)
  472. , DisplayUnit(0x54B2)
  473. , AspectRatioType(0x54B3)
  474. , ColourSpace(0x2EB524)
  475. , GammaValue(0x2FB523)
  476. , FramePerSec(0x2383E3)
  477. {
  478. }
  480. QWORD Video::Size(bool fWithHeader)
  481. {
  482. QWORD len = 0;
  483. len += FlagInterlaced.Size();
  484. len += StereoMode.Size();
  485. len += PixelWidth.Size();
  486. len += PixelHeight.Size();
  487. len += DisplayWidth.Size();
  488. len += DisplayHeight.Size();
  489. len += DisplayUnit.Size();
  490. len += AspectRatioType.Size();
  491. len += ColourSpace.Size();
  492. len += GammaValue.Size();
  493. len += FramePerSec.Size();
  494. if(fWithHeader) len += HeaderSize(len);
  495. return len;
  496. }
  498. HRESULT Video::Write(IStream* pStream)
  499. {
  500. HeaderWrite(pStream);
  501. FlagInterlaced.Write(pStream);
  502. StereoMode.Write(pStream);
  503. PixelWidth.Write(pStream);
  504. PixelHeight.Write(pStream);
  505. DisplayWidth.Write(pStream);
  506. DisplayHeight.Write(pStream);
  507. DisplayUnit.Write(pStream);
  508. AspectRatioType.Write(pStream);
  509. ColourSpace.Write(pStream);
  510. GammaValue.Write(pStream);
  511. FramePerSec.Write(pStream);
  512. return S_OK;
  513. }
  515. Audio::Audio(DWORD id)
  516. : CID(id)
  517. , SamplingFrequency(0xB5)
  518. , OutputSamplingFrequency(0x78B5)
  519. , Channels(0x9F)
  520. , ChannelPositions(0x7D7B)
  521. , BitDepth(0x6264)
  522. {
  523. }
  525. QWORD Audio::Size(bool fWithHeader)
  526. {
  527. QWORD len = 0;
  528. len += SamplingFrequency.Size();
  529. len += OutputSamplingFrequency.Size();
  530. len += Channels.Size();
  531. len += ChannelPositions.Size();
  532. len += BitDepth.Size();
  533. if(fWithHeader) len += HeaderSize(len);
  534. return len;
  535. }
  537. HRESULT Audio::Write(IStream* pStream)
  538. {
  539. HeaderWrite(pStream);
  540. SamplingFrequency.Write(pStream);
  541. OutputSamplingFrequency.Write(pStream);
  542. Channels.Write(pStream);
  543. ChannelPositions.Write(pStream);
  544. BitDepth.Write(pStream);
  545. return S_OK;
  546. }
  548. Cluster::Cluster(DWORD id)
  549. : CID(id)
  550. , TimeCode(0xE7)
  551. , Position(0xA7)
  552. , PrevSize(0xAB)
  553. {
  554. }
  556. QWORD Cluster::Size(bool fWithHeader)
  557. {
  558. QWORD len = 0;
  559. len += TimeCode.Size();
  560. len += Position.Size();
  561. len += PrevSize.Size();
  562. len += BlockGroups.Size();
  563. if(fWithHeader) len += HeaderSize(len);
  564. return len;
  565. }
  567. HRESULT Cluster::Write(IStream* pStream)
  568. {
  569. HeaderWrite(pStream);
  570. TimeCode.Write(pStream);
  571. Position.Write(pStream);
  572. PrevSize.Write(pStream);
  573. BlockGroups.Write(pStream);
  574. return S_OK;
  575. }
  577. BlockGroup::BlockGroup(DWORD id)
  578. : CID(id)
  579. , BlockDuration(0x9B)
  580. , ReferencePriority(0xFA)
  581. , ReferenceBlock(0xFB)
  582. , ReferenceVirtual(0xFD)
  583. , CodecState(0xA4)
  584. {
  585. }
  587. QWORD BlockGroup::Size(bool fWithHeader)
  588. {
  589. QWORD len = 0;
  590. len += BlockDuration.Size();
  591. len += ReferencePriority.Size();
  592. len += ReferenceBlock.Size();
  593. len += ReferenceVirtual.Size();
  594. len += CodecState.Size();
  595. len += Block.Size();
  596. if(fWithHeader) len += HeaderSize(len);
  597. return len;
  598. }
  600. HRESULT BlockGroup::Write(IStream* pStream)
  601. {
  602. HeaderWrite(pStream);
  603. BlockDuration.Write(pStream);
  604. ReferencePriority.Write(pStream);
  605. ReferenceBlock.Write(pStream);
  606. ReferenceVirtual.Write(pStream);
  607. CodecState.Write(pStream);
  608. Block.Write(pStream);
  609. return S_OK;
  610. }
  612. CBlock::CBlock(DWORD id)
  613. : CID(id)
  614. , TimeCode(0)
  615. {
  616. }
  618. QWORD CBlock::Size(bool fWithHeader)
  619. {
  620. QWORD len = 0;
  621. len += TrackNumber.Size() + 2 + 1; // TrackNumber + TimeCode + Lacing
  622. if(BlockData.GetCount() > 1)
  623. {
  624. len += 1; // nBlockData
  625. POSITION pos = BlockData.GetHeadPosition();
  626. while(pos)
  627. {
  628. CBinary* b = BlockData.GetNext(pos);
  629. if(pos) len += b->GetCount()/255 + 1;
  630. }
  631. }
  632. POSITION pos = BlockData.GetHeadPosition();
  633. while(pos)
  634. {
  635. CBinary* b = BlockData.GetNext(pos);
  636. len += b->GetCount();
  637. }
  638. if(fWithHeader) len += HeaderSize(len);
  639. return len;
  640. }
  642. HRESULT CBlock::Write(IStream* pStream)
  643. {
  644. HeaderWrite(pStream);
  645. TrackNumber.Write(pStream);
  646. short t = (short)TimeCode;
  647. bswap((BYTE*)&t, 2);
  648. pStream->Write(&t, 2, NULL);
  649. BYTE Lacing = 0;
  650. BYTE n = BlockData.GetCount();
  651. if(n > 1) Lacing |= 2;
  652. pStream->Write(&Lacing, 1, NULL);
  653. if(n > 1)
  654. {
  655. pStream->Write(&n, 1, NULL);
  656. POSITION pos = BlockData.GetHeadPosition();
  657. while(pos)
  658. {
  659. CBinary* b = BlockData.GetNext(pos);
  660. if(pos)
  661. {
  662. int len = b->GetCount();
  663. while(len >= 0)
  664. {
  665. n = min(len, 255);
  666. pStream->Write(&n, 1, NULL);
  667. len -= 255;
  668. }
  669. }
  670. }
  671. }
  672. POSITION pos = BlockData.GetHeadPosition();
  673. while(pos)
  674. {
  675. CBinary* b = BlockData.GetNext(pos);
  676. pStream->Write(b->GetData(), b->GetCount(), NULL);
  677. }
  678. return S_OK;
  679. }
  681. Cue::Cue(DWORD id)
  682. : CID(id)
  683. {
  684. }
  686. QWORD Cue::Size(bool fWithHeader)
  687. {
  688. QWORD len = 0;
  689. len += CuePoints.Size();
  690. if(fWithHeader) len += HeaderSize(len);
  691. return len;
  692. }
  694. HRESULT Cue::Write(IStream* pStream)
  695. {
  696. HeaderWrite(pStream);
  697. CuePoints.Write(pStream);
  698. return S_OK;
  699. }
  701. CuePoint::CuePoint(DWORD id)
  702. : CID(id)
  703. , CueTime(0xB3)
  704. {
  705. }
  707. QWORD CuePoint::Size(bool fWithHeader)
  708. {
  709. QWORD len = 0;
  710. len += CueTime.Size();
  711. len += CueTrackPositions.Size();
  712. if(fWithHeader) len += HeaderSize(len);
  713. return len;
  714. }
  716. HRESULT CuePoint::Write(IStream* pStream)
  717. {
  718. HeaderWrite(pStream);
  719. CueTime.Write(pStream);
  720. CueTrackPositions.Write(pStream);
  721. return S_OK;
  722. }
  724. CueTrackPosition::CueTrackPosition(DWORD id)
  725. : CID(id)
  726. , CueTrack(0xF7)
  727. , CueClusterPosition(0xF1)
  728. , CueBlockNumber(0x5387)
  729. , CueCodecState(0xEA)
  730. {
  731. }
  733. QWORD CueTrackPosition::Size(bool fWithHeader)
  734. {
  735. QWORD len = 0;
  736. len += CueTrack.Size();
  737. len += CueClusterPosition.Size();
  738. len += CueBlockNumber.Size();
  739. len += CueCodecState.Size();
  740. // len += CueReferences.Size();
  741. if(fWithHeader) len += HeaderSize(len);
  742. return len;
  743. }
  745. HRESULT CueTrackPosition::Write(IStream* pStream)
  746. {
  747. HeaderWrite(pStream);
  748. CueTrack.Write(pStream);
  749. CueClusterPosition.Write(pStream);
  750. CueBlockNumber.Write(pStream);
  751. CueCodecState.Write(pStream);
  752. // CueReferences.Write(pStream);
  753. return S_OK;
  754. }
  756. Seek::Seek(DWORD id)
  757. : CID(id)
  758. {
  759. }
  761. QWORD Seek::Size(bool fWithHeader)
  762. {
  763. QWORD len = 0;
  764. len += SeekHeads.Size();
  765. if(fWithHeader) len += HeaderSize(len);
  766. return len;
  767. }
  769. HRESULT Seek::Write(IStream* pStream)
  770. {
  771. HeaderWrite(pStream);
  772. SeekHeads.Write(pStream);
  773. return S_OK;
  774. }
  776. SeekID::SeekID(DWORD id)
  777. : CID(id)
  778. , m_id(0)
  779. {
  780. }
  782. QWORD SeekID::Size(bool fWithHeader)
  783. {
  784. QWORD len = 0;
  785. len += m_id.Size();
  786. if(fWithHeader) len += HeaderSize(len);
  787. return len;
  788. }
  790. HRESULT SeekID::Write(IStream* pStream)
  791. {
  792. HeaderWrite(pStream);
  793. m_id.Write(pStream);
  794. return S_OK;
  795. }
  797. SeekHead::SeekHead(DWORD id)
  798. : CID(id)
  799. , Position(0x53AC)
  800. {
  801. }
  803. QWORD SeekHead::Size(bool fWithHeader)
  804. {
  805. QWORD len = 0;
  806. len += ID.Size();
  807. len += Position.Size();
  808. if(fWithHeader) len += HeaderSize(len);
  809. return len;
  810. }
  812. HRESULT SeekHead::Write(IStream* pStream)
  813. {
  814. HeaderWrite(pStream);
  815. ID.Write(pStream);
  816. Position.Write(pStream);
  817. return S_OK;
  818. }
  820. Tags::Tags(DWORD id)
  821. : CID(id)
  822. {
  823. }
  825. QWORD Tags::Size(bool fWithHeader)
  826. {
  827. QWORD len = 0;
  828. // len += .Size();
  829. if(fWithHeader) len += HeaderSize(len);
  830. return len;
  831. }
  833. HRESULT Tags::Write(IStream* pStream)
  834. {
  835. HeaderWrite(pStream);
  836. // .Write(pStream);
  837. return S_OK;
  838. }
  840. Void::Void(QWORD len, DWORD id)
  841. : CID(id)
  842. , m_len(len)
  843. {
  844. }
  846. QWORD Void::Size(bool fWithHeader)
  847. {
  848. QWORD len = 0;
  849. len += m_len;
  850. if(fWithHeader) len += HeaderSize(len);
  851. return len;
  852. }
  854. HRESULT Void::Write(IStream* pStream)
  855. {
  856. HeaderWrite(pStream);
  857. BYTE buff[64];
  858. memset(buff, 0x80, sizeof(buff));
  859. for(int len = (int)m_len; len > 0; len -= sizeof(buff))
  860. pStream->Write(buff, (ULONG)min(sizeof(buff), len), NULL);
  861. return S_OK;
  862. }