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

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

多媒体编程

开发平台：

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"
  25. #include "......zlibzlib.h"
  27. #define DOCTYPE _T("matroska")
  28. #define DOCTYPEVERSION 2
  30. static void LOG(LPCTSTR fmt, ...)
  31. {
  32. va_list args;
  33. va_start(args, fmt);
  34. if(FILE* f = _tfopen(_T("c:\matroskasplitterlog.txt"), _T("at")))
  35. {
  36. fseek(f, 0, 2);
  37. _vftprintf(f, fmt, args);
  38. fclose(f);
  39. }
  40. va_end(args);
  41. }
  43. using namespace MatroskaReader;
  45. #define BeginChunk
  46. CheckPointer(pMN0, E_POINTER); 
  48. CAutoPtr<CMatroskaNode> pMN = pMN0->Child(); 
  49. if(!pMN) return S_FALSE; 
  51. do 
  52. { 
  53. switch(pMN->m_id) 
  54. { 
  56. #define EndChunk 
  57. } 
  58. } 
  59. while(pMN->Next()); 
  61. return S_OK; 
  63. static void bswap(BYTE* s, int len)
  64. {
  65. for(BYTE* d = s + len-1; s < d; s++, d--)
  66. *s ^= *d, *d ^= *s, *s ^= *d;
  67. }
  69. //
  70. // CMatroskaFile
  71. //
  73. CMatroskaFile::CMatroskaFile(IAsyncReader* pAsyncReader, HRESULT& hr) 
  74. : CBaseSplitterFile(pAsyncReader, hr)
  75. , m_rtOffset(0)
  76. {
  77. if(FAILED(hr)) return;
  78. hr = Init();
  79. }
  81. HRESULT CMatroskaFile::Init()
  82. {
  83. DWORD dw;
  84. if(FAILED(Read(dw)) || dw != 0x1A45DFA3)
  85. return E_FAIL;
  87. CMatroskaNode Root(this);
  88. if(FAILED(Parse(&Root)))
  89. return E_FAIL;
  91. CAutoPtr<CMatroskaNode> pSegment, pCluster;
  92. if((pSegment = Root.Child(0x18538067))
  93. && (pCluster = pSegment->Child(0x1F43B675)))
  94. {
  95. Cluster c0;
  96. c0.ParseTimeCode(pCluster);
  97. m_rtOffset = m_segment.GetRefTime(c0.TimeCode);
  98. }
  100. return S_OK;
  101. }
  103. template <class T>
  104. HRESULT CMatroskaFile::Read(T& var)
  105. {
  106. HRESULT hr = Read((BYTE*)&var, sizeof(var));
  107. if(S_OK == hr) bswap((BYTE*)&var, sizeof(var));
  108. return hr;
  109. }
  111. HRESULT CMatroskaFile::Parse(CMatroskaNode* pMN0)
  112. {
  113. BeginChunk
  114. case 0x1A45DFA3: 
  115. m_ebml.Parse(pMN);
  116. if(m_ebml.DocType != DOCTYPE || m_ebml.DocTypeReadVersion > DOCTYPEVERSION)
  117. return E_FAIL;
  118. break;
  119. case 0x18538067: if(m_segment.SegmentInfo.SegmentUID.IsEmpty()) m_segment.ParseMinimal(pMN); break;
  120. EndChunk
  121. }
  123. //
  125. HRESULT EBML::Parse(CMatroskaNode* pMN0)
  126. {
  127. BeginChunk
  128. case 0x4286: EBMLVersion.Parse(pMN); break;
  129. case 0x42F7: EBMLReadVersion.Parse(pMN); break;
  130. case 0x42F2: EBMLMaxIDLength.Parse(pMN); break;
  131. case 0x42F3: EBMLMaxSizeLength.Parse(pMN); break;
  132. case 0x4282: DocType.Parse(pMN); break;
  133. case 0x4287: DocTypeVersion.Parse(pMN); break;
  134. case 0x4285: DocTypeReadVersion.Parse(pMN); break;
  135. EndChunk
  136. }
  138. HRESULT Segment::Parse(CMatroskaNode* pMN0)
  139. {
  140. pos = pMN0->GetPos();
  142. BeginChunk
  143. case 0x1549A966: SegmentInfo.Parse(pMN); break;
  144. case 0x114D9B74: MetaSeekInfo.Parse(pMN); break;
  145. case 0x1654AE6B: Tracks.Parse(pMN); break;
  146. case 0x1F43B675: Clusters.Parse(pMN); break;
  147. case 0x1C53BB6B: Cues.Parse(pMN); break;
  148. case 0x1941A469: Attachments.Parse(pMN); break;
  149. case 0x1043A770: Chapters.Parse(pMN); break;
  150. // case 0x1254C367: Tags.Parse(pMN); break;
  151. EndChunk
  152. }
  154. HRESULT Segment::ParseMinimal(CMatroskaNode* pMN0)
  155. {
  156. CheckPointer(pMN0, E_POINTER);
  158. pos = pMN0->GetPos();
  159. len = pMN0->m_len;
  161. CAutoPtr<CMatroskaNode> pMN = pMN0->Child();
  162. if(!pMN) return S_FALSE;
  164. int n = 0;
  166. do
  167. {
  168. switch(pMN->m_id)
  169. {
  170. case 0x1549A966: SegmentInfo.Parse(pMN); n++; break;
  171. case 0x114D9B74: MetaSeekInfo.Parse(pMN); n++; break;
  172. case 0x1654AE6B: Tracks.Parse(pMN); n++; break;
  173. case 0x1C53BB6B: Cues.Parse(pMN); break;
  174. }
  175. }
  176. while(n < 3 && pMN->Next());
  178. while(QWORD pos = pMN->FindPos(0x114D9B74, pMN->GetPos()))
  179. {
  180. pMN->SeekTo(pos);
  181. pMN->Parse();
  182. if(pMN->m_id != 0x114D9B74) {ASSERT(0); break;}
  183. MetaSeekInfo.Parse(pMN);
  184. }
  186. if(n == 3)
  187. {
  188. if(Cues.IsEmpty() && (pMN = pMN0->Child(0x1C53BB6B, false)))
  189. {
  190. do {Cues.Parse(pMN);} while(pMN->Next(true));
  191. }
  193. if(Chapters.IsEmpty() && (pMN = pMN0->Child(0x1043A770, false)))
  194. {
  195. do {Chapters.Parse(pMN); /*BIG UGLY HACK:*/ break;} while(pMN->Next(true));
  196. }
  198. if(Attachments.IsEmpty() && (pMN = pMN0->Child(0x1941A469, false)))
  199. {
  200. do {Attachments.Parse(pMN); /*BIG UGLY HACK:*/ break;} while (pMN->Next(true));
  201. }
  202. }
  204. return S_OK;
  205. }
  207. UINT64 Segment::GetMasterTrack()
  208. {
  209. UINT64 TrackNumber = 0, AltTrackNumber = 0;
  211. POSITION pos1 = Tracks.GetHeadPosition();
  212. while(pos1 && TrackNumber == 0)
  213. {
  214. Track* pT = Tracks.GetNext(pos1);
  216. POSITION pos2 = pT->TrackEntries.GetHeadPosition();
  217. while(pos2 && TrackNumber == 0)
  218. {
  219. TrackEntry* pTE = pT->TrackEntries.GetNext(pos2);
  221. if(pTE->TrackType == TrackEntry::TypeVideo)
  222. {
  223. TrackNumber = pTE->TrackNumber;
  224. break;
  225. }
  226. else if(pTE->TrackType == TrackEntry::TypeAudio && AltTrackNumber == 0)
  227. {
  228. AltTrackNumber = pTE->TrackNumber;
  229. }
  230. }
  231. }
  233. if(TrackNumber == 0) TrackNumber = AltTrackNumber;
  234. if(TrackNumber == 0) TrackNumber = 1;
  236. return TrackNumber;
  237. }
  239. ChapterAtom* ChapterAtom::FindChapterAtom(UINT64 id)
  240. {
  241. if(ChapterUID == id)
  242. return(this);
  244. POSITION pos = ChapterAtoms.GetHeadPosition();
  245. while(pos)
  246. {
  247. ChapterAtom* ca = ChapterAtoms.GetNext(pos)->FindChapterAtom(id);
  248. if(ca) return ca;
  249. }
  251. return(NULL);
  252. }
  254. ChapterAtom* Segment::FindChapterAtom(UINT64 id, int nEditionEntry)
  255. {
  256. POSITION pos1 = Chapters.GetHeadPosition();
  257. while(pos1)
  258. {
  259. Chapter* c = Chapters.GetNext(pos1);
  261. POSITION pos2 = c->EditionEntries.GetHeadPosition();
  262. while(pos2)
  263. {
  264. EditionEntry* ee = c->EditionEntries.GetNext(pos2);
  266. if(nEditionEntry-- == 0)
  267. {
  268. return id == 0 ? ee : ee->FindChapterAtom(id);
  269. }
  270. }
  271. }
  273. return(NULL);
  274. }
  276. HRESULT Info::Parse(CMatroskaNode* pMN0)
  277. {
  278. BeginChunk
  279. case 0x73A4: SegmentUID.Parse(pMN); break;
  280. case 0x7384: SegmentFilename.Parse(pMN); break;
  281. case 0x3CB923: PrevUID.Parse(pMN); break;
  282. case 0x3C83AB: PrevFilename.Parse(pMN); break;
  283. case 0x3EB923: NextUID.Parse(pMN); break;
  284. case 0x3E83BB: NextFilename.Parse(pMN); break;
  285. case 0x2AD7B1: TimeCodeScale.Parse(pMN); break;
  286. case 0x4489: Duration.Parse(pMN); break;
  287. case 0x4461: DateUTC.Parse(pMN); break;
  288. case 0x7BA9: Title.Parse(pMN); break;
  289. case 0x4D80: MuxingApp.Parse(pMN); break;
  290. case 0x5741: WritingApp.Parse(pMN); break;
  291. EndChunk
  292. }
  294. HRESULT Seek::Parse(CMatroskaNode* pMN0)
  295. {
  296. BeginChunk
  297. case 0x4DBB: SeekHeads.Parse(pMN); break;
  298. EndChunk
  299. }
  301. HRESULT SeekHead::Parse(CMatroskaNode* pMN0)
  302. {
  303. BeginChunk
  304. case 0x53AB: SeekID.Parse(pMN); break;
  305. case 0x53AC: SeekPosition.Parse(pMN); break;
  306. EndChunk
  307. }
  309. HRESULT Track::Parse(CMatroskaNode* pMN0)
  310. {
  311. BeginChunk
  312. case 0xAE: TrackEntries.Parse(pMN); break;
  313. EndChunk
  314. }
  316. HRESULT TrackEntry::Parse(CMatroskaNode* pMN0)
  317. {
  318. BeginChunk
  319. case 0xD7: TrackNumber.Parse(pMN); break;
  320. case 0x73C5: TrackUID.Parse(pMN); break;
  321. case 0x83: TrackType.Parse(pMN); break;
  322. case 0xB9: FlagEnabled.Parse(pMN); break;
  323. case 0x88: FlagDefault.Parse(pMN); break;
  324. case 0x9C: FlagLacing.Parse(pMN); break;
  325. case 0x6DE7: MinCache.Parse(pMN); break;
  326. case 0x6DF8: MaxCache.Parse(pMN); break;
  327. case 0x536E: Name.Parse(pMN); break;
  328. case 0x22B59C: Language.Parse(pMN); break;
  329. case 0x86: CodecID.Parse(pMN); break;
  330. case 0x63A2: CodecPrivate.Parse(pMN); break;
  331. case 0x258688: CodecName.Parse(pMN); break;
  332. case 0x3A9697: CodecSettings.Parse(pMN); break;
  333. case 0x3B4040: CodecInfoURL.Parse(pMN); break;
  334. case 0x26B240: CodecDownloadURL.Parse(pMN); break;
  335. case 0xAA: CodecDecodeAll.Parse(pMN); break;
  336. case 0x6FAB: TrackOverlay.Parse(pMN); break;
  337. case 0x23E383: case 0x2383E3: DefaultDuration.Parse(pMN); break;
  338. case 0x23314F: TrackTimecodeScale.Parse(pMN); break;
  339. case 0xE0: if(S_OK == v.Parse(pMN)) DescType |= DescVideo; break;
  340. case 0xE1: if(S_OK == a.Parse(pMN)) DescType |= DescAudio; break;
  341. case 0x6D80: ces.Parse(pMN); break;
  342. EndChunk
  343. }
  345. static int cesort(const void* a, const void* b) 
  346. {
  347. UINT64 ce1 = ((ContentEncoding*)a)->ContentEncodingOrder;
  348. UINT64 ce2 = ((ContentEncoding*)b)->ContentEncodingOrder;
  350. return (int)ce1 - (int)ce2; 
  351. }
  353. bool TrackEntry::Expand(CBinary& data, UINT64 Scope)
  354. {
  355. if(ces.ce.GetCount() == 0) return(true);
  357. CArray<ContentEncoding*> cearray;
  358. POSITION pos = ces.ce.GetHeadPosition();
  359. while(pos) cearray.Add(ces.ce.GetNext(pos));
  360. qsort(cearray.GetData(), cearray.GetCount(), sizeof(ContentEncoding*), cesort);
  362. for(int i = cearray.GetCount()-1; i >= 0; i--)
  363. {
  364. ContentEncoding* ce = cearray[i];
  366. if(!(ce->ContentEncodingScope & Scope))
  367. continue;
  369. if(ce->ContentEncodingType == ContentEncoding::Compression)
  370. {
  371. if(!data.Decompress(ce->cc))
  372. return(false);
  373. }
  374. else if(ce->ContentEncodingType == ContentEncoding::Encryption)
  375. {
  376. // TODO
  377. return(false);
  378. }
  379. }
  381. return(true);
  382. }
  384. HRESULT Video::Parse(CMatroskaNode* pMN0)
  385. {
  386. BeginChunk
  387. case 0x9A: FlagInterlaced.Parse(pMN); break;
  388. case 0x53B8: StereoMode.Parse(pMN); break;
  389. case 0xB0: PixelWidth.Parse(pMN); break;
  390. case 0xBA: PixelHeight.Parse(pMN); break;
  391. case 0x54B0: DisplayWidth.Parse(pMN); break;
  392. case 0x54BA: DisplayHeight.Parse(pMN); break;
  393. case 0x54B2: DisplayUnit.Parse(pMN); break;
  394. case 0x54B3: AspectRatioType.Parse(pMN); break;
  395. case 0x2EB524: ColourSpace.Parse(pMN); break;
  396. case 0x2FB523: GammaValue.Parse(pMN); break;
  397. case 0x2383E3: FramePerSec.Parse(pMN); break;
  398. EndChunk
  399. }
  401. HRESULT Audio::Parse(CMatroskaNode* pMN0)
  402. {
  403. BeginChunk
  404. case 0xB5: SamplingFrequency.Parse(pMN); break;
  405. case 0x78B5: OutputSamplingFrequency.Parse(pMN); break;
  406. case 0x9F: Channels.Parse(pMN); break;
  407. case 0x7D7B: ChannelPositions.Parse(pMN); break;
  408. case 0x6264: BitDepth.Parse(pMN); break;
  409. EndChunk
  410. }
  412. HRESULT ContentEncodings::Parse(CMatroskaNode* pMN0)
  413. {
  414. BeginChunk
  415. case 0x6240: ce.Parse(pMN); break;
  416. EndChunk
  417. }
  419. HRESULT ContentEncoding::Parse(CMatroskaNode* pMN0)
  420. {
  421. BeginChunk
  422. case 0x5031: ContentEncodingOrder.Parse(pMN); break;
  423. case 0x5032: ContentEncodingScope.Parse(pMN); break;
  424. case 0x5033: ContentEncodingType.Parse(pMN); break;
  425. case 0x5034: cc.Parse(pMN); break;
  426. case 0x5035: ce.Parse(pMN); break;
  427. EndChunk
  428. }
  430. HRESULT ContentCompression::Parse(CMatroskaNode* pMN0)
  431. {
  432. BeginChunk
  433. case 0x4254: ContentCompAlgo.Parse(pMN); break;
  434. case 0x4255: ContentCompSettings.Parse(pMN); break;
  435. EndChunk
  436. }
  438. HRESULT ContentEncryption::Parse(CMatroskaNode* pMN0)
  439. {
  440. BeginChunk
  441. case 0x47e1: ContentEncAlgo.Parse(pMN); break;
  442. case 0x47e2: ContentEncKeyID.Parse(pMN); break;
  443. case 0x47e3: ContentSignature.Parse(pMN); break;
  444. case 0x47e4: ContentSigKeyID.Parse(pMN); break;
  445. case 0x47e5: ContentSigAlgo.Parse(pMN); break;
  446. case 0x47e6: ContentSigHashAlgo.Parse(pMN); break;
  447. EndChunk
  448. }
  450. HRESULT Cluster::Parse(CMatroskaNode* pMN0)
  451. {
  452. BeginChunk
  453. case 0xE7: TimeCode.Parse(pMN); break;
  454. case 0xA7: Position.Parse(pMN); break;
  455. case 0xAB: PrevSize.Parse(pMN); break;
  456. case 0xA0: BlockGroups.Parse(pMN, true); break;
  457. case 0xA3: SimpleBlocks.Parse(pMN, true); break;
  458. EndChunk
  459. }
  461. HRESULT Cluster::ParseTimeCode(CMatroskaNode* pMN0)
  462. {
  463. BeginChunk
  464. case 0xE7: TimeCode.Parse(pMN); return S_OK;
  465. EndChunk
  466. }
  468. HRESULT BlockGroup::Parse(CMatroskaNode* pMN0, bool fFull)
  469. {
  470. BeginChunk
  471. case 0xA1: Block.Parse(pMN, fFull); break;
  472. case 0xA2: /* TODO: multiple virt blocks? */; break;
  473. case 0x9B: BlockDuration.Parse(pMN); break;
  474. case 0xFA: ReferencePriority.Parse(pMN); break;
  475. case 0xFB: ReferenceBlock.Parse(pMN); break;
  476. case 0xFD: ReferenceVirtual.Parse(pMN); break;
  477. case 0xA4: CodecState.Parse(pMN); break;
  478. case 0xE8: TimeSlices.Parse(pMN); break;
  479. EndChunk
  480. }
  482. HRESULT SimpleBlock::Parse(CMatroskaNode* pMN, bool fFull)
  483. {
  484. pMN->SeekTo(pMN->m_start);
  486. TrackNumber.Parse(pMN); 
  487. CShort s; s.Parse(pMN); TimeCode.Set(s); 
  488. Lacing.Parse(pMN);
  490. if(!fFull) return S_OK;
  492. CList<QWORD> lens;
  493. QWORD tlen = 0;
  494. QWORD FrameSize;
  495. BYTE FramesInLaceLessOne;
  497. switch((Lacing & 0x06) >> 1)
  498. {
  499. case 0:
  500. // No lacing
  501. lens.AddTail((pMN->m_start+pMN->m_len) - (pMN->GetPos()+tlen));
  502. break;
  503. case 1:
  504. // Xiph lacing
  505. BYTE n;
  506. pMN->Read(n);
  507. while(n-- > 0)
  508. {
  509. BYTE b;
  510. QWORD len = 0;
  511. do {pMN->Read(b); len += b;} while(b == 0xff);
  512. lens.AddTail(len);
  513. tlen += len;
  514. }
  515. lens.AddTail((pMN->m_start+pMN->m_len) - (pMN->GetPos()+tlen));
  516. break;
  517. case 2:
  518. // Fixed-size lacing
  519. pMN->Read(FramesInLaceLessOne);
  520. FramesInLaceLessOne++;
  521. FrameSize = ((pMN->m_start+pMN->m_len) - (pMN->GetPos()+tlen)) / FramesInLaceLessOne;
  522. while(FramesInLaceLessOne-- > 0)
  523. lens.AddTail(FrameSize);
  524. break;
  525. case 3:
  526. // EBML lacing
  527. pMN->Read(FramesInLaceLessOne);
  529. CLength FirstFrameSize;
  530. FirstFrameSize.Parse(pMN);
  531. lens.AddTail(FirstFrameSize);
  532. FramesInLaceLessOne--;
  533. tlen = FirstFrameSize;
  535. CSignedLength DiffSize;
  536. FrameSize = FirstFrameSize;
  537. while(FramesInLaceLessOne--)
  538. {
  539. DiffSize.Parse(pMN);
  540. FrameSize += DiffSize;
  541. lens.AddTail(FrameSize);
  542. tlen += FrameSize;
  543. }
  544. lens.AddTail((pMN->m_start+pMN->m_len) - (pMN->GetPos()+tlen));
  545. break;
  546. }
  548. POSITION pos = lens.GetHeadPosition();
  549. while(pos)
  550. {
  551. QWORD len = lens.GetNext(pos);
  552. CAutoPtr<CBinary> p(new CBinary());
  553. p->SetSize((INT_PTR)len);
  554. pMN->Read(p->GetData(), len);
  555. BlockData.AddTail(p);
  556. }
  558. return S_OK;
  559. }
  561. HRESULT TimeSlice::Parse(CMatroskaNode* pMN0)
  562. {
  563. BeginChunk
  564. case 0xCC: LaceNumber.Parse(pMN); break;
  565. case 0xCD: FrameNumber.Parse(pMN); break;
  566. case 0xCE: Delay.Parse(pMN); break;
  567. case 0xCF: Duration.Parse(pMN); break;
  568. EndChunk
  569. }
  571. HRESULT Cue::Parse(CMatroskaNode* pMN0)
  572. {
  573. BeginChunk
  574. case 0xBB: CuePoints.Parse(pMN); break;
  575. EndChunk
  576. }
  578. HRESULT CuePoint::Parse(CMatroskaNode* pMN0)
  579. {
  580. BeginChunk
  581. case 0xB3: CueTime.Parse(pMN); break;
  582. case 0xB7: CueTrackPositions.Parse(pMN); break;
  583. EndChunk
  584. }
  586. HRESULT CueTrackPosition::Parse(CMatroskaNode* pMN0)
  587. {
  588. BeginChunk
  589. case 0xF7: CueTrack.Parse(pMN); break;
  590. case 0xF1: CueClusterPosition.Parse(pMN); break;
  591. case 0x5387: CueBlockNumber.Parse(pMN); break;
  592. case 0xEA: CueCodecState.Parse(pMN); break;
  593. case 0xDB: CueReferences.Parse(pMN); break;
  594. EndChunk
  595. }
  597. HRESULT CueReference::Parse(CMatroskaNode* pMN0)
  598. {
  599. BeginChunk
  600. case 0x96: CueRefTime.Parse(pMN); break;
  601. case 0x97: CueRefCluster.Parse(pMN); break;
  602. case 0x535F: CueRefNumber.Parse(pMN); break;
  603. case 0xEB: CueRefCodecState.Parse(pMN); break;
  604. EndChunk
  605. }
  607. HRESULT Attachment::Parse(CMatroskaNode* pMN0)
  608. {
  609. BeginChunk
  610. case 0x61A7: AttachedFiles.Parse(pMN); break;
  611. EndChunk
  612. }
  614. HRESULT AttachedFile::Parse(CMatroskaNode* pMN0)
  615. {
  616. BeginChunk
  617. case 0x467E: FileDescription.Parse(pMN); break;
  618. case 0x466E: FileName.Parse(pMN); break;
  619. case 0x4660: FileMimeType.Parse(pMN); break;
  620. case 0x465C: // binary
  621. FileDataLen = (INT_PTR)pMN->m_len;
  622. FileDataPos = pMN->m_start;
  623. break;
  624. case 0x46AE: FileUID.Parse(pMN); break;
  625. EndChunk
  626. }
  628. HRESULT Chapter::Parse(CMatroskaNode* pMN0)
  629. {
  630. BeginChunk
  631. case 0x45B9: EditionEntries.Parse(pMN); break;
  632. EndChunk
  633. }
  635. HRESULT EditionEntry::Parse(CMatroskaNode* pMN0)
  636. {
  637. BeginChunk
  638. case 0xB6: ChapterAtoms.Parse(pMN); break;
  639. EndChunk
  640. }
  642. HRESULT ChapterAtom::Parse(CMatroskaNode* pMN0)
  643. {
  644. BeginChunk
  645. case 0x73C4: ChapterUID.Parse(pMN); break;
  646. case 0x91: ChapterTimeStart.Parse(pMN); break;
  647. case 0x92: ChapterTimeEnd.Parse(pMN); break;
  648. // case 0x8F: // TODO 
  649. case 0x80: ChapterDisplays.Parse(pMN); break;
  650. case 0xB6: ChapterAtoms.Parse(pMN); break;
  651. case 0x98: ChapterFlagHidden.Parse(pMN); break;
  652. case 0x4598: ChapterFlagEnabled.Parse(pMN); break;
  653. EndChunk
  654. }
  656. HRESULT ChapterDisplay::Parse(CMatroskaNode* pMN0)
  657. {
  658. BeginChunk
  659. case 0x85: ChapString.Parse(pMN); break;
  660. case 0x437C: ChapLanguage.Parse(pMN); break;
  661. case 0x437E: ChapCountry.Parse(pMN); break;
  662. EndChunk
  663. }
  665. //
  667. HRESULT CBinary::Parse(CMatroskaNode* pMN)
  668. {
  669. ASSERT(pMN->m_len <= INT_MAX);
  670. SetSize((INT_PTR)pMN->m_len);
  671. return pMN->Read(GetData(), pMN->m_len);
  672. }
  674. bool CBinary::Compress(ContentCompression& cc)
  675. {
  676. if(cc.ContentCompAlgo == ContentCompression::ZLIB)
  677. {
  678. int res;
  679. z_stream c_stream;
  681. c_stream.zalloc = (alloc_func)0;
  682. c_stream.zfree = (free_func)0;
  683. c_stream.opaque = (voidpf)0;
  685. if(Z_OK != (res = deflateInit(&c_stream, 9)))
  686. return(false);
  688. c_stream.next_in = GetData();
  689. c_stream.avail_in = GetSize();
  691. BYTE* dst = NULL;
  692. int n = 0;
  693. do
  694. {
  695. dst = (BYTE*)realloc(dst, ++n*10);
  696. c_stream.next_out = &dst[(n-1)*10];
  697. c_stream.avail_out = 10;
  698. if(Z_OK != (res = deflate(&c_stream, Z_FINISH)) && Z_STREAM_END != res)
  699. {
  700. free(dst);
  701. return(false);
  702. }
  703. }
  704. while(0 == c_stream.avail_out && Z_STREAM_END != res);
  706. deflateEnd(&c_stream);
  708. SetSize(c_stream.total_out);
  709. memcpy(GetData(), dst, GetSize());
  711. free(dst);
  713. return(true);
  714. }
  716. return(false);
  717. }
  719. bool CBinary::Decompress(ContentCompression& cc)
  720. {
  721. if(cc.ContentCompAlgo == ContentCompression::ZLIB)
  722. {
  723. int res;
  724. z_stream d_stream;
  726. d_stream.zalloc = (alloc_func)0;
  727. d_stream.zfree = (free_func)0;
  728. d_stream.opaque = (voidpf)0;
  730. if(Z_OK != (res = inflateInit(&d_stream)))
  731. return(false);
  733. d_stream.next_in = GetData();
  734. d_stream.avail_in = GetSize();
  736. BYTE* dst = NULL;
  737. int n = 0;
  738. do
  739. {
  740. dst = (unsigned char *)realloc(dst, ++n*1000);
  741. d_stream.next_out = &dst[(n-1)*1000];
  742. d_stream.avail_out = 1000;
  743. if(Z_OK != (res = inflate(&d_stream, Z_NO_FLUSH)) && Z_STREAM_END != res)
  744. {
  745. free(dst);
  746. return(false);
  747. }
  748. }
  749. while(0 == d_stream.avail_out && 0 != d_stream.avail_in && Z_STREAM_END != res);
  751. inflateEnd(&d_stream);
  753. SetSize(d_stream.total_out);
  754. memcpy(GetData(), dst, GetSize());
  756. free(dst);
  758. return(true);
  759. }
  760. else if(cc.ContentCompAlgo == ContentCompression::HDRSTRIP)
  761. {
  762. InsertAt(0, &cc.ContentCompSettings);
  763. }
  765. return(false);
  766. }
  768. HRESULT CANSI::Parse(CMatroskaNode* pMN)
  769. {
  770. Empty();
  772. QWORD len = pMN->m_len;
  773. CHAR c;
  774. while(len-- > 0 && SUCCEEDED(pMN->Read(c))) 
  775. *this += c;
  777. return(len == -1 ? S_OK : E_FAIL);
  778. }
  780. HRESULT CUTF8::Parse(CMatroskaNode* pMN)
  781. {
  782. Empty();
  783. CAutoVectorPtr<BYTE> buff;
  784. if(!buff.Allocate((UINT)pMN->m_len + 1) || S_OK != pMN->Read(buff, pMN->m_len))
  785. return E_FAIL;
  786. buff[pMN->m_len] = 0;
  787. CStringW::operator = (UTF8To16((LPCSTR)(BYTE*)buff));
  788. return S_OK;
  789. }
  791. HRESULT CUInt::Parse(CMatroskaNode* pMN)
  792. {
  793. m_val = 0;
  794. for(int i = 0; i < (int)pMN->m_len; i++)
  795. {
  796. m_val <<= 8;
  797. HRESULT hr = pMN->Read(*(BYTE*)&m_val);
  798. if(FAILED(hr)) return hr;
  799. }
  800. m_fValid = true;
  801. return S_OK;
  802. }
  804. HRESULT CInt::Parse(CMatroskaNode* pMN)
  805. {
  806. m_val = 0;
  807. for(int i = 0; i < (int)pMN->m_len; i++)
  808. {
  809. HRESULT hr = pMN->Read(*((BYTE*)&m_val+7-i));
  810. if(FAILED(hr)) return hr;
  811. }
  812. m_val >>= (8-pMN->m_len)*8;
  813. m_fValid = true;
  814. return S_OK;
  815. }
  817. HRESULT CFloat::Parse(CMatroskaNode* pMN)
  818. {
  819. HRESULT hr = E_FAIL;
  820. m_val = 0;
  822. if(pMN->m_len == 4)
  823. {
  824. float val = 0;
  825. hr = pMN->Read(val);
  826. m_val = val;
  827. } else if(pMN->m_len == 8) {
  828. hr = pMN->Read(m_val);
  829. }
  830. if(SUCCEEDED(hr))
  831. m_fValid = true;
  832. return hr;
  833. }
  836. template<class T, class BASE>
  837. HRESULT CSimpleVar<T, BASE>::Parse(CMatroskaNode* pMN)
  838. {
  839. m_val = 0;
  840. m_fValid = true;
  841. return pMN->Read(m_val);
  842. }
  844. HRESULT CID::Parse(CMatroskaNode* pMN)
  845. {
  846. m_val = 0;
  848. BYTE b = 0;
  849. HRESULT hr = pMN->Read(b);
  850. if(FAILED(hr)) return hr;
  852. int nMoreBytes = 0;
  854. if((b&0x80) == 0x80) {m_val = b&0xff; nMoreBytes = 0;}
  855. else if((b&0xc0) == 0x40) {m_val = b&0x7f; nMoreBytes = 1;}
  856. else if((b&0xe0) == 0x20) {m_val = b&0x3f; nMoreBytes = 2;}
  857. else if((b&0xf0) == 0x10) {m_val = b&0x1f; nMoreBytes = 3;}
  858. else return E_FAIL;
  860. while(nMoreBytes-- > 0)
  861. {
  862. m_val <<= 8;
  863. hr = pMN->Read(*(BYTE*)&m_val);
  864. if(FAILED(hr)) return hr;
  865. }
  867. m_fValid = true;
  869. return S_OK;
  870. }
  872. HRESULT CLength::Parse(CMatroskaNode* pMN)
  873. {
  874. m_val = 0;
  876. BYTE b = 0;
  877. HRESULT hr = pMN->Read(b);
  878. if(FAILED(hr)) return hr;
  880. int nMoreBytes = 0, nMoreBytesTmp = 0;
  882. if((b&0x80) == 0x80) {m_val = b&0x7f; nMoreBytes = 0;}
  883. else if((b&0xc0) == 0x40) {m_val = b&0x3f; nMoreBytes = 1;}
  884. else if((b&0xe0) == 0x20) {m_val = b&0x1f; nMoreBytes = 2;}
  885. else if((b&0xf0) == 0x10) {m_val = b&0x0f; nMoreBytes = 3;}
  886. else if((b&0xf8) == 0x08) {m_val = b&0x07; nMoreBytes = 4;}
  887. else if((b&0xfc) == 0x04) {m_val = b&0x03; nMoreBytes = 5;}
  888. else if((b&0xfe) == 0x02) {m_val = b&0x01; nMoreBytes = 6;}
  889. else if((b&0xff) == 0x01) {m_val = b&0x00; nMoreBytes = 7;}
  890. else return E_FAIL;
  892. nMoreBytesTmp = nMoreBytes;
  894. QWORD UnknownSize = (1i64<<(7*(nMoreBytes+1)))-1;
  896. while(nMoreBytes-- > 0)
  897. {
  898. m_val <<= 8;
  899. hr = pMN->Read(*(BYTE*)&m_val);
  900. if(FAILED(hr)) return hr;
  901. }
  903. if(m_val == UnknownSize)
  904. {
  905. m_val = pMN->GetLength() - pMN->GetPos();
  906. TRACE(_T("CLength: Unspecified chunk size at %I64d (corrected to %I64d)n"), pMN->GetPos(), m_val);
  907. }
  909. if(m_fSigned)
  910. m_val -= (UnknownSize >> 1);
  912. m_fValid = true;
  914. return S_OK;
  915. }
  916. /*
  917. HRESULT CSignedLength::Parse(CMatroskaNode* pMN)
  918. {
  919. // HRESULT hr = __super::Parse(pMN);
  920. // if(FAILED(hr)) return hr;
  922. m_val = 0;
  924. BYTE b = 0;
  925. HRESULT hr = pMN->Read(b);
  926. if(FAILED(hr)) return hr;
  928. int nMoreBytes = 0, nMoreBytesTmp = 0;
  930. if((b&0x80) == 0x80) {m_val = b&0x7f; nMoreBytes = 0;}
  931. else if((b&0xc0) == 0x40) {m_val = b&0x3f; nMoreBytes = 1;}
  932. else if((b&0xe0) == 0x20) {m_val = b&0x1f; nMoreBytes = 2;}
  933. else if((b&0xf0) == 0x10) {m_val = b&0x0f; nMoreBytes = 3;}
  934. else if((b&0xf8) == 0x08) {m_val = b&0x07; nMoreBytes = 4;}
  935. else if((b&0xfc) == 0x04) {m_val = b&0x03; nMoreBytes = 5;}
  936. else if((b&0xfe) == 0x02) {m_val = b&0x01; nMoreBytes = 6;}
  937. else if((b&0xff) == 0x01) {m_val = b&0x00; nMoreBytes = 7;}
  938. else return E_FAIL;
  940. nMoreBytesTmp = nMoreBytes;
  942. QWORD UnknownSize = (1i64<<(7*(nMoreBytes+1)))-1;
  944. while(nMoreBytes-- > 0)
  945. {
  946. m_val <<= 8;
  947. hr = pMN->Read(*(BYTE*)&m_val);
  948. if(FAILED(hr)) return hr;
  949. }
  951. if(m_val == UnknownSize)
  952. {
  953. m_val = pMN->GetLength() - pMN->GetPos();
  954. TRACE(_T("CLength: Unspecified chunk size at %I64d (corrected to %I64d)n"), pMN->GetPos(), m_val);
  955. }
  957. m_val -= (UnknownSize >> 1);
  959. m_fValid = true;
  961. return S_OK;
  962. }
  963. */
  964. template<class T>
  965. HRESULT CNode<T>::Parse(CMatroskaNode* pMN)
  966. {
  967. CAutoPtr<T> p(new T());
  968. HRESULT hr = E_OUTOFMEMORY;
  969. if(!p || FAILED(hr = p->Parse(pMN))) return hr;
  970. AddTail(p);
  971. return S_OK;
  972. }
  974. HRESULT CBlockGroupNode::Parse(CMatroskaNode* pMN, bool fFull)
  975. {
  976. CAutoPtr<BlockGroup> p(new BlockGroup());
  977. HRESULT hr = E_OUTOFMEMORY;
  978. if(!p || FAILED(hr = p->Parse(pMN, fFull))) return hr;
  979. AddTail(p);
  980. return S_OK;
  981. }
  983. HRESULT CSimpleBlockNode::Parse(CMatroskaNode* pMN, bool fFull)
  984. {
  985. CAutoPtr<SimpleBlock> p(new SimpleBlock());
  986. HRESULT hr = E_OUTOFMEMORY;
  987. if(!p || FAILED(hr = p->Parse(pMN, fFull))) return hr;
  988. AddTail(p);
  989. return S_OK;
  990. }
  992. ///////////////////////////////
  994. CMatroskaNode::CMatroskaNode(CMatroskaFile* pMF)
  995. : m_pMF(pMF)
  996. , m_pParent(NULL)
  997. {
  998. ASSERT(m_pMF);
  999. m_start = m_filepos = 0;
  1000. m_len.Set(m_pMF ? m_pMF->GetLength() : 0); 
  1001. }
  1003. CMatroskaNode::CMatroskaNode(CMatroskaNode* pParent)
  1004. : m_pMF(pParent->m_pMF)
  1005. , m_pParent(pParent)
  1006. {
  1007. Parse();
  1008. }
  1010. HRESULT CMatroskaNode::Parse()
  1011. {
  1012. m_filepos = GetPos();
  1013. if(FAILED(m_id.Parse(this)) || FAILED(m_len.Parse(this)))
  1014. return E_FAIL;
  1015. m_start = GetPos();
  1016. return S_OK;
  1017. }
  1019. CAutoPtr<CMatroskaNode> CMatroskaNode::Child(DWORD id, bool fSearch)
  1020. {
  1021. if(m_len == 0) return CAutoPtr<CMatroskaNode>();
  1022. SeekTo(m_start);
  1023. CAutoPtr<CMatroskaNode> pMN(new CMatroskaNode(this));
  1024. if(id && !pMN->Find(id, fSearch)) pMN.Free();
  1025. return pMN;
  1026. }
  1028. bool CMatroskaNode::Next(bool fSame)
  1029. {
  1030. if(!m_pParent)
  1031. return(false);
  1033. CID id = m_id;
  1035. while(m_start+m_len < m_pParent->m_start+m_pParent->m_len)
  1036. {
  1037. SeekTo(m_start+m_len);
  1039. if(FAILED(Parse()))
  1040. {
  1041. if(!Resync())
  1042. return(false);
  1043. }
  1045. if(!fSame || m_id == id) 
  1046. return(true);
  1047. }
  1049. return(false);
  1050. }
  1052. bool CMatroskaNode::Find(DWORD id, bool fSearch)
  1053. {
  1054. QWORD pos = m_pParent && m_pParent->m_id == 0x18538067 /*segment?*/ 
  1055. ? FindPos(id) 
  1056. : 0;
  1058. if(pos)
  1059. {
  1060. SeekTo(pos);
  1061. Parse();
  1062. }
  1063. else if(fSearch)
  1064. {
  1065. while(m_id != id && Next());
  1066. }
  1068. return(m_id == id);
  1069. }
  1071. void CMatroskaNode::SeekTo(QWORD pos) {m_pMF->Seek(pos);}
  1072. QWORD CMatroskaNode::GetPos() {return m_pMF->GetPos();}
  1073. QWORD CMatroskaNode::GetLength() {return m_pMF->GetLength();}
  1074. template <class T> 
  1075. HRESULT CMatroskaNode::Read(T& var) {return m_pMF->Read(var);}
  1076. HRESULT CMatroskaNode::Read(BYTE* pData, QWORD len) {return m_pMF->Read(pData, len);}
  1078. QWORD CMatroskaNode::FindPos(DWORD id, QWORD start)
  1079. {
  1080. Segment& sm = m_pMF->m_segment;
  1082. POSITION pos = sm.MetaSeekInfo.GetHeadPosition();
  1083. while(pos)
  1084. {
  1085. Seek* s = sm.MetaSeekInfo.GetNext(pos);
  1087. POSITION pos2 = s->SeekHeads.GetHeadPosition();
  1088. while(pos2)
  1089. {
  1090. SeekHead* sh = s->SeekHeads.GetNext(pos2);
  1091. if(sh->SeekID == id && sh->SeekPosition+sm.pos >= start)
  1092. return sh->SeekPosition+sm.pos;
  1093. }
  1094. }
  1096. return 0;
  1097. }
  1099. CAutoPtr<CMatroskaNode> CMatroskaNode::Copy()
  1100. {
  1101. CAutoPtr<CMatroskaNode> pNewNode(new CMatroskaNode(m_pMF));
  1102. pNewNode->m_pParent = m_pParent;
  1103. pNewNode->m_id.Set(m_id);
  1104. pNewNode->m_len.Set(m_len);
  1105. pNewNode->m_filepos = m_filepos;
  1106. pNewNode->m_start = m_start;
  1107. return(pNewNode);
  1108. }
  1110. CAutoPtr<CMatroskaNode> CMatroskaNode::GetFirstBlock()
  1111. {
  1112. CAutoPtr<CMatroskaNode> pNode = Child();
  1113. do {if(pNode->m_id == 0xA0 || pNode->m_id == 0xA3) return pNode;}
  1114. while(pNode->Next());
  1115. return CAutoPtr<CMatroskaNode>();
  1116. }
  1118. bool CMatroskaNode::NextBlock()
  1119. {
  1120. if(!m_pParent)
  1121. return(false);
  1123. CID id = m_id;
  1125. while(m_start+m_len < m_pParent->m_start+m_pParent->m_len)
  1126. {
  1127. SeekTo(m_start+m_len);
  1129. if(FAILED(Parse()))
  1130. {
  1131. if(!Resync())
  1132. return(false);
  1133. }
  1135. if(m_id == 0xA0 || m_id == 0xA3) 
  1136. return(true);
  1137. }
  1139. return(false);
  1140. }
  1142. bool CMatroskaNode::Resync()
  1143. {
  1144. if(m_pParent->m_id == 0x18538067) /*segment?*/ 
  1145. {
  1146. SeekTo(m_filepos);
  1148. for(BYTE b = 0; S_OK == Read(b); b = 0)
  1149. {
  1150. if((b&0xf0) != 0x10)
  1151. continue;
  1153.             DWORD dw = b;
  1154. Read((BYTE*)&dw+1, 3);
  1155. bswap((BYTE*)&dw, 4);
  1157. switch(dw)
  1158. {
  1159. case 0x1549A966: // SegmentInfo
  1160. case 0x114D9B74: // MetaSeekInfo
  1161. case 0x1654AE6B: // Tracks
  1162. case 0x1F43B675: // Clusters
  1163. case 0x1C53BB6B: // Cues
  1164. case 0x1941A469: // Attachments
  1165. case 0x1043A770: // Chapters
  1166. case 0x1254C367: // Tags
  1167. SeekTo(GetPos()-4);
  1168. return(SUCCEEDED(Parse()));
  1169. default:
  1170. SeekTo(GetPos()-3);
  1171. break;
  1172. }
  1173. }
  1174. }
  1176. return(false);
  1177. }