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

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

多媒体编程

开发平台：

Visual C++

MatroskaSplitter.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 <mmreg.h>
  24. #include "MatroskaSplitter.h"
  25. #include "......DSUtilDSUtil.h"
  27. #include <initguid.h>
  28. #include "........includematroskamatroska.h"
  29. #include "........includeoggOggDS.h"
  30. #include "........includemoreuuids.h"
  32. using namespace MatroskaReader;
  34. #ifdef REGISTER_FILTER
  36. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  37. {
  38. {&MEDIATYPE_Stream, &MEDIASUBTYPE_Matroska},
  39. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL}
  40. };
  42. const AMOVIESETUP_PIN sudpPins[] =
  43. {
  44.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  45.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, 0, NULL}
  46. };
  48. const AMOVIESETUP_FILTER sudFilter[] =
  49. {
  50. {&__uuidof(CMatroskaSplitterFilter), L"Matroska Splitter", MERIT_NORMAL, countof(sudpPins), sudpPins},
  51. {&__uuidof(CMatroskaSourceFilter), L"Matroska Source", MERIT_NORMAL, 0, NULL},
  52. };
  54. CFactoryTemplate g_Templates[] =
  55. {
  56. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CMatroskaSplitterFilter>, NULL, &sudFilter[0]},
  57. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CMatroskaSourceFilter>, NULL, &sudFilter[1]},
  58. };
  60. int g_cTemplates = countof(g_Templates);
  62. STDAPI DllRegisterServer()
  63. {
  64. RegisterSourceFilter(
  65. CLSID_AsyncReader, 
  66. MEDIASUBTYPE_Matroska, 
  67. _T("0,4,,1A45DFA3"), 
  68. _T(".mkv"), _T(".mka"), _T(".mks"), NULL);
  70. return AMovieDllRegisterServer2(TRUE);
  71. }
  73. STDAPI DllUnregisterServer()
  74. {
  75. UnRegisterSourceFilter(MEDIASUBTYPE_Matroska);
  77. return AMovieDllRegisterServer2(FALSE);
  78. }
  80. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  82. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  83. {
  84.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  85. }
  87. #endif
  89. //
  90. // CMatroskaSplitterFilter
  91. //
  93. CMatroskaSplitterFilter::CMatroskaSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  94. : CBaseSplitterFilter(NAME("CMatroskaSplitterFilter"), pUnk, phr, __uuidof(this))
  95. {
  96. }
  98. CMatroskaSplitterFilter::~CMatroskaSplitterFilter()
  99. {
  100. }
  102. STDMETHODIMP CMatroskaSplitterFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  103. {
  104. CheckPointer(ppv, E_POINTER);
  106. return 
  107. QI(ITrackInfo)
  108. __super::NonDelegatingQueryInterface(riid, ppv);
  109. }
  111. #include <vector>
  113. HRESULT CMatroskaSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  114. {
  115. CheckPointer(pAsyncReader, E_POINTER);
  117. HRESULT hr = E_FAIL;
  119. m_pFile.Free();
  120. m_pTrackEntryMap.RemoveAll();
  121. m_pOrderedTrackArray.RemoveAll();
  123. m_pFile.Attach(new CMatroskaFile(pAsyncReader, hr));
  124. if(!m_pFile) return E_OUTOFMEMORY;
  125. if(FAILED(hr)) {m_pFile.Free(); return hr;}
  127. m_rtNewStart = m_rtCurrent = 0;
  128. m_rtNewStop = m_rtStop = 0;
  130. int iVideo = 1, iAudio = 1, iSubtitle = 1;
  132. POSITION pos = m_pFile->m_segment.Tracks.GetHeadPosition();
  133. while(pos)
  134. {
  135. Track* pT = m_pFile->m_segment.Tracks.GetNext(pos);
  137. POSITION pos2 = pT->TrackEntries.GetHeadPosition();
  138. while(pos2)
  139. {
  140. TrackEntry* pTE = pT->TrackEntries.GetNext(pos2);
  142. if(!pTE->Expand(pTE->CodecPrivate, ContentEncoding::TracksPrivateData))
  143. continue;
  145. CStringA CodecID = pTE->CodecID.ToString();
  147. CStringW Name;
  148. Name.Format(L"Output %I64d", (UINT64)pTE->TrackNumber);
  150. CMediaType mt;
  151. CArray<CMediaType> mts;
  153. mt.SetSampleSize(1);
  155. if(pTE->TrackType == TrackEntry::TypeVideo)
  156. {
  157. Name.Format(L"Video %d", iVideo++);
  159. mt.majortype = MEDIATYPE_Video;
  161. if(CodecID == "V_MS/VFW/FOURCC")
  162. {
  163. mt.formattype = FORMAT_VideoInfo;
  164. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pTE->CodecPrivate.GetCount() - sizeof(BITMAPINFOHEADER));
  165. memset(mt.Format(), 0, mt.FormatLength());
  166. memcpy(&pvih->bmiHeader, (BYTE*)pTE->CodecPrivate, pTE->CodecPrivate.GetCount());
  167. mt.subtype = FOURCCMap(pvih->bmiHeader.biCompression);
  168. switch(pvih->bmiHeader.biCompression)
  169. {
  170. case BI_RGB: case BI_BITFIELDS: mt.subtype = 
  171. pvih->bmiHeader.biBitCount == 1 ? MEDIASUBTYPE_RGB1 :
  172. pvih->bmiHeader.biBitCount == 4 ? MEDIASUBTYPE_RGB4 :
  173. pvih->bmiHeader.biBitCount == 8 ? MEDIASUBTYPE_RGB8 :
  174. pvih->bmiHeader.biBitCount == 16 ? MEDIASUBTYPE_RGB565 :
  175. pvih->bmiHeader.biBitCount == 24 ? MEDIASUBTYPE_RGB24 :
  176. pvih->bmiHeader.biBitCount == 32 ? MEDIASUBTYPE_ARGB32 :
  177. MEDIASUBTYPE_NULL;
  178. break;
  179. // case BI_RLE8: mt.subtype = MEDIASUBTYPE_RGB8; break;
  180. // case BI_RLE4: mt.subtype = MEDIASUBTYPE_RGB4; break;
  181. }
  182. mts.Add(mt);
  183. }
  184. else if(CodecID == "V_UNCOMPRESSED")
  185. {
  186. }
  187. else if(CodecID.Find("V_MPEG4/ISO/AVC") == 0)
  188. {
  189. if(pTE->CodecPrivate.GetSize() >= 6)
  190. {
  191. BYTE sps = pTE->CodecPrivate[5] & 0x1f;
  194. std::vector<BYTE> avcC;
  195. for(int i = 0, j = pTE->CodecPrivate.GetSize(); i < j; i++)
  196. avcC.push_back(pTE->CodecPrivate[i]);
  198. std::vector<BYTE> sh;
  200. unsigned jj = 6;
  202. while (sps--) {
  203.   if (jj + 2 > avcC.size())
  204.     goto avcfail;
  205.   unsigned spslen = ((unsigned)avcC[jj] << 8) | avcC[jj+1];
  206.   if (jj + 2 + spslen > avcC.size())
  207.     goto avcfail;
  208.   unsigned cur = sh.size();
  209.   sh.resize(cur + spslen + 2, 0);
  210.   std::copy(avcC.begin() + jj, avcC.begin() + jj + 2 + spslen,sh.begin() + cur);
  211.   jj += 2 + spslen;
  212. }
  214. if (jj + 1 > avcC.size())
  215.   continue;
  217. unsigned pps = avcC[jj++];
  219. while (pps--) {
  220.   if (jj + 2 > avcC.size())
  221.     goto avcfail;
  222.   unsigned ppslen = ((unsigned)avcC[jj] << 8) | avcC[jj+1];
  223.   if (jj + 2 + ppslen > avcC.size())
  224.     goto avcfail;
  225.   unsigned cur = sh.size();
  226.   sh.resize(cur + ppslen + 2, 0);
  227.   std::copy(avcC.begin() + jj, avcC.begin() + jj + 2 + ppslen, sh.begin() + cur);
  228.   jj += 2 + ppslen;
  229. }
  231. goto avcsuccess;
  232. avcfail:
  233. continue;
  234. avcsuccess:
  236. CArray<BYTE> data;
  237. data.SetSize(sh.size());
  238. std::copy(sh.begin(), sh.end(), (BYTE*)data.GetData());
  240. mt.subtype = FOURCCMap('1CVA');
  241. mt.formattype = FORMAT_MPEG2Video;
  242. MPEG2VIDEOINFO* pm2vi = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + data.GetSize());
  243. memset(mt.Format(), 0, mt.FormatLength());
  244. pm2vi->hdr.bmiHeader.biSize = sizeof(pm2vi->hdr.bmiHeader);
  245. pm2vi->hdr.bmiHeader.biWidth = (LONG)pTE->v.PixelWidth;
  246. pm2vi->hdr.bmiHeader.biHeight = (LONG)pTE->v.PixelHeight;
  247. pm2vi->hdr.bmiHeader.biCompression = '1cva';
  248. pm2vi->hdr.bmiHeader.biPlanes = 1;
  249. pm2vi->hdr.bmiHeader.biBitCount = 24;
  251. pm2vi->dwProfile = pTE->CodecPrivate[1];
  252. pm2vi->dwLevel = pTE->CodecPrivate[3];
  253. pm2vi->dwFlags = (pTE->CodecPrivate[4] & 3) + 1;
  255. BYTE* pSequenceHeader = (BYTE*)pm2vi->dwSequenceHeader;
  256. memcpy(pSequenceHeader, data.GetData(), data.GetSize());
  257. pm2vi->cbSequenceHeader = data.GetSize();
  259. mts.Add(mt);
  261. }
  262. }
  263. else if(CodecID.Find("V_MPEG4/") == 0) // TODO: find out which V_MPEG4/*/* ids can be mapped to 'mp4v'
  264. {
  265. mt.subtype = FOURCCMap('v4pm');
  266. mt.formattype = FORMAT_VideoInfo;
  267. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  268. memset(pvih, 0, mt.FormatLength());
  269. pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader);
  270. pvih->bmiHeader.biWidth = (LONG)pTE->v.PixelWidth;
  271. pvih->bmiHeader.biHeight = (LONG)pTE->v.PixelHeight;
  272. pvih->bmiHeader.biCompression = 'v4pm';
  273. mts.Add(mt);
  275. // TODO: add (-1,0) dummy frame to timeoverride when it is /asp (that is having b-frames almost certainly)
  276. }
  277. else if(CodecID.Find("V_REAL/RV") == 0)
  278. {
  279. mt.subtype = FOURCCMap('00VR' + ((CodecID[9]-0x30)<<16));
  280. mt.formattype = FORMAT_VideoInfo;
  281. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pTE->CodecPrivate.GetCount());
  282. memset(mt.Format(), 0, mt.FormatLength());
  283. memcpy(mt.Format() + sizeof(VIDEOINFOHEADER), pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount());
  284. pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader);
  285. pvih->bmiHeader.biWidth = (LONG)pTE->v.PixelWidth;
  286. pvih->bmiHeader.biHeight = (LONG)pTE->v.PixelHeight;
  287. pvih->bmiHeader.biCompression = mt.subtype.Data1;
  288. mts.Add(mt);
  289. }
  290. else if(CodecID == "V_DIRAC")
  291. {
  292. mt.subtype = MEDIASUBTYPE_DiracVideo;
  293. mt.formattype = FORMAT_DiracVideoInfo;
  294. DIRACINFOHEADER* dvih = (DIRACINFOHEADER*)mt.AllocFormatBuffer(FIELD_OFFSET(DIRACINFOHEADER, dwSequenceHeader) + pTE->CodecPrivate.GetSize());
  295. memset(mt.Format(), 0, mt.FormatLength());
  296. dvih->hdr.bmiHeader.biSize = sizeof(dvih->hdr.bmiHeader);
  297. dvih->hdr.bmiHeader.biWidth = (LONG)pTE->v.PixelWidth;
  298. dvih->hdr.bmiHeader.biHeight = (LONG)pTE->v.PixelHeight;
  299. dvih->hdr.dwPictAspectRatioX = dvih->hdr.bmiHeader.biWidth;
  300. dvih->hdr.dwPictAspectRatioY = dvih->hdr.bmiHeader.biHeight;
  302. BYTE* pSequenceHeader = (BYTE*)dvih->dwSequenceHeader;
  303. memcpy(pSequenceHeader, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetSize());
  304. dvih->cbSequenceHeader = pTE->CodecPrivate.GetSize();
  306. mts.Add(mt);
  307. }
  308. else if(CodecID == "V_MPEG2")
  309. {
  310. BYTE* seqhdr = pTE->CodecPrivate.GetData();
  311. DWORD len = pTE->CodecPrivate.GetSize();
  312. int w = pTE->v.PixelWidth;
  313. int h = pTE->v.PixelHeight;
  315. if(MakeMPEG2MediaType(mt, seqhdr, len, w, h))
  316. mts.Add(mt);
  317. }
  318. /*
  319. else if(CodecID == "V_DSHOW/MPEG1VIDEO") // V_MPEG1
  320. {
  321. mt.majortype = MEDIATYPE_Video;
  322. mt.subtype = MEDIASUBTYPE_MPEG1Payload;
  323. mt.formattype = FORMAT_MPEGVideo;
  324. MPEG1VIDEOINFO* pm1vi = (MPEG1VIDEOINFO*)mt.AllocFormatBuffer(pTE->CodecPrivate.GetSize());
  325. memcpy(pm1vi, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetSize());
  326. mt.SetSampleSize(pm1vi->hdr.bmiHeader.biWidth*pm1vi->hdr.bmiHeader.biHeight*4);
  327. mts.Add(mt);
  328. }
  329. */
  330. REFERENCE_TIME AvgTimePerFrame = 0;
  332.                 if(pTE->v.FramePerSec > 0)
  333. AvgTimePerFrame = (REFERENCE_TIME)(10000000i64 / pTE->v.FramePerSec);
  334. else if(pTE->DefaultDuration > 0)
  335. AvgTimePerFrame = (REFERENCE_TIME)pTE->DefaultDuration / 100;
  337. if(AvgTimePerFrame)
  338. {
  339. for(int i = 0; i < mts.GetCount(); i++)
  340. {
  341. if(mts[i].formattype == FORMAT_VideoInfo
  342. || mts[i].formattype == FORMAT_VideoInfo2
  343. || mts[i].formattype == FORMAT_MPEG2Video)
  344. {
  345. ((VIDEOINFOHEADER*)mts[i].Format())->AvgTimePerFrame = AvgTimePerFrame;
  346. }
  347. }
  348. }
  350. if(pTE->v.DisplayWidth != 0 && pTE->v.DisplayHeight != 0)
  351. {
  352. for(int i = 0; i < mts.GetCount(); i++)
  353. {
  354. if(mts[i].formattype == FORMAT_VideoInfo)
  355. {
  356. DWORD vih1 = FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader);
  357. DWORD vih2 = FIELD_OFFSET(VIDEOINFOHEADER2, bmiHeader);
  358. DWORD bmi = mts[i].FormatLength() - FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader);
  359. mt.formattype = FORMAT_VideoInfo2;
  360. mt.AllocFormatBuffer(vih2 + bmi);
  361. memcpy(mt.Format(), mts[i].Format(), vih1);
  362. memset(mt.Format() + vih1, 0, vih2 - vih1);
  363. memcpy(mt.Format() + vih2, mts[i].Format() + vih1, bmi);
  364. ((VIDEOINFOHEADER2*)mt.Format())->dwPictAspectRatioX = (DWORD)pTE->v.DisplayWidth;
  365. ((VIDEOINFOHEADER2*)mt.Format())->dwPictAspectRatioY = (DWORD)pTE->v.DisplayHeight;
  366. mts.InsertAt(i++, mt);
  367. }
  368. else if(mts[i].formattype == FORMAT_MPEG2Video)
  369. {
  370. ((MPEG2VIDEOINFO*)mts[i].Format())->hdr.dwPictAspectRatioX = (DWORD)pTE->v.DisplayWidth;
  371. ((MPEG2VIDEOINFO*)mts[i].Format())->hdr.dwPictAspectRatioY = (DWORD)pTE->v.DisplayHeight;
  372. }
  373. }
  374. }
  375. }
  376. else if(pTE->TrackType == TrackEntry::TypeAudio)
  377. {
  378. Name.Format(L"Audio %d", iAudio++);
  380. mt.majortype = MEDIATYPE_Audio;
  381. mt.formattype = FORMAT_WaveFormatEx;
  382. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)mt.AllocFormatBuffer(sizeof(WAVEFORMATEX));
  383. memset(pwfe, 0, mt.FormatLength());
  384. pwfe->nChannels = (WORD)pTE->a.Channels;
  385. pwfe->nSamplesPerSec = (DWORD)pTE->a.SamplingFrequency;
  386. pwfe->wBitsPerSample = (WORD)pTE->a.BitDepth;
  387. pwfe->nBlockAlign = (WORD)((pwfe->nChannels * pwfe->wBitsPerSample) / 8);
  388. pwfe->nAvgBytesPerSec = pwfe->nSamplesPerSec * pwfe->nBlockAlign;
  389. mt.SetSampleSize(256000);
  391. if(CodecID == "A_VORBIS")
  392. {
  393. BYTE* p = (BYTE*)pTE->CodecPrivate;
  394. CArray<long> sizes;
  395. for(BYTE n = *p++; n > 0; n--)
  396. {
  397. long size = 0;
  398. do {size += *p;} while(*p++ == 0xff);
  399. sizes.Add(size);
  400. }
  402. long totalsize = 0;
  403. for(int i = 0; i < sizes.GetCount(); i++)
  404. totalsize += sizes[i];
  406. sizes.Add(pTE->CodecPrivate.GetSize() - (p - (BYTE*)pTE->CodecPrivate) - totalsize);
  407. totalsize += sizes[sizes.GetCount()-1];
  409. if(sizes.GetCount() == 3)
  410. {
  411. mt.subtype = MEDIASUBTYPE_Vorbis2;
  412. mt.formattype = FORMAT_VorbisFormat2;
  413. VORBISFORMAT2* pvf2 = (VORBISFORMAT2*)mt.AllocFormatBuffer(sizeof(VORBISFORMAT2) + totalsize);
  414. memset(pvf2, 0, mt.FormatLength());
  415. pvf2->Channels = (WORD)pTE->a.Channels;
  416. pvf2->SamplesPerSec = (DWORD)pTE->a.SamplingFrequency;
  417. pvf2->BitsPerSample = (DWORD)pTE->a.BitDepth;
  418. BYTE* p2 = mt.Format() + sizeof(VORBISFORMAT2);
  419. for(int i = 0; i < sizes.GetCount(); p += sizes[i], p2 += sizes[i], i++)
  420. memcpy(p2, p, pvf2->HeaderSize[i] = sizes[i]);
  422. mts.Add(mt);
  423. }
  425. mt.subtype = MEDIASUBTYPE_Vorbis;
  426. mt.formattype = FORMAT_VorbisFormat;
  427. VORBISFORMAT* pvf = (VORBISFORMAT*)mt.AllocFormatBuffer(sizeof(VORBISFORMAT));
  428. memset(pvf, 0, mt.FormatLength());
  429. pvf->nChannels = (WORD)pTE->a.Channels;
  430. pvf->nSamplesPerSec = (DWORD)pTE->a.SamplingFrequency;
  431. pvf->nMinBitsPerSec = pvf->nMaxBitsPerSec = pvf->nAvgBitsPerSec = -1;
  432. mts.Add(mt);
  433. }
  434. else if(CodecID == "A_MPEG/L3")
  435. {
  436. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_MP3);
  437. mts.Add(mt);
  438. }
  439. else if(CodecID == "A_MPEG/L2")
  440. {
  441. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_MPEG);
  442. mts.Add(mt);
  443. // TODO : add MPEG1WAVEFORMAT
  444. }
  445. else if(CodecID == "A_AC3")
  446. {
  447. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_DOLBY_AC3);
  448. mts.Add(mt);
  449. }
  450. else if(CodecID == "A_DTS")
  451. {
  452. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_DVD_DTS);
  453. mts.Add(mt);
  454. }
  455. else if(CodecID == "A_FLAC")
  456. {
  457. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_FLAC);
  458. pwfe->cbSize = pTE->CodecPrivate.GetCount();
  459. BYTE* pExtra = mt.ReallocFormatBuffer(sizeof(WAVEFORMATEX) + pTE->CodecPrivate.GetCount()) + sizeof(WAVEFORMATEX);
  460. memcpy(pExtra, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount());
  461. mts.Add(mt);
  463. mt.subtype = MEDIASUBTYPE_FLAC_FRAMED;
  464. mts.InsertAt(0, mt);
  465. }
  466. else if(CodecID == "A_TTA1")
  467. {
  468. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_TTA1);
  469. mts.Add(mt);
  470. }
  471. else if(CodecID == "A_MS/ACM")
  472. {
  473. pwfe = (WAVEFORMATEX*)mt.AllocFormatBuffer(pTE->CodecPrivate.GetCount());
  474. memcpy(pwfe, (WAVEFORMATEX*)(BYTE*)pTE->CodecPrivate, pTE->CodecPrivate.GetCount());
  475. mt.subtype = FOURCCMap(pwfe->wFormatTag);
  476. mts.Add(mt);
  477. }
  478. else if(CodecID == "A_PCM/INT/LIT")
  479. {
  480. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_PCM);
  481. mts.Add(mt);
  482. }
  483. else if(CodecID == "A_PCM/FLOAT/IEEE")
  484. {
  485. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_IEEE_FLOAT);
  486. mts.Add(mt);
  487. }
  488. else if(CodecID.Find("A_AAC/") == 0)
  489. {
  490. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_AAC);
  491. BYTE* pExtra = mt.ReallocFormatBuffer(sizeof(WAVEFORMATEX)+5) + sizeof(WAVEFORMATEX);
  492. (pwfe = (WAVEFORMATEX*)mt.pbFormat)->cbSize = 2;
  494. int profile;
  496. if(CodecID.Find("/MAIN") > 0) profile = 0;
  497. else if(CodecID.Find("/SBR") > 0) profile = -1;
  498. else if(CodecID.Find("/LC") > 0) profile = 1;
  499. else if(CodecID.Find("/SSR") > 0) profile = 2;
  500. else if(CodecID.Find("/LTP") > 0) profile = 3;
  501. else continue;
  503. WORD cbSize = MakeAACInitData(pExtra, profile, pwfe->nSamplesPerSec, pTE->a.Channels);
  505. mts.Add(mt);
  507. if(profile < 0)
  508. {
  509. pwfe->cbSize = cbSize;
  510. pwfe->nSamplesPerSec *= 2;
  511. pwfe->nAvgBytesPerSec *= 2;
  513. mts.InsertAt(0, mt);
  514. }
  515. }
  516. else if(CodecID.Find("A_REAL/") == 0 && CodecID.GetLength() >= 11)
  517. {
  518. mt.bTemporalCompression = TRUE;
  519. mt.subtype = FOURCCMap((DWORD)CodecID[7]|((DWORD)CodecID[8]<<8)|((DWORD)CodecID[9]<<16)|((DWORD)CodecID[10]<<24));
  520. BYTE* p = mt.ReallocFormatBuffer(sizeof(WAVEFORMATEX) + pTE->CodecPrivate.GetCount());
  521. memcpy(p + sizeof(WAVEFORMATEX), pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount());
  523. mts.Add(mt);
  524. }
  525. }
  526. else if(pTE->TrackType == TrackEntry::TypeSubtitle)
  527. {
  528. if(iSubtitle == 1) InstallFonts();
  530. Name.Format(L"Subtitle %d", iSubtitle++);
  532. mt.SetSampleSize(1);
  534. if(CodecID == "S_TEXT/ASCII")
  535. {
  536. mt.majortype = MEDIATYPE_Text;
  537. mt.subtype = MEDIASUBTYPE_NULL;
  538. mt.formattype = FORMAT_None;
  539. mts.Add(mt);
  540. }
  541. else
  542. {
  543. mt.majortype = MEDIATYPE_Subtitle;
  544. mt.formattype = FORMAT_SubtitleInfo;
  545. SUBTITLEINFO* psi = (SUBTITLEINFO*)mt.AllocFormatBuffer(sizeof(SUBTITLEINFO) + pTE->CodecPrivate.GetSize());
  546. memset(psi, 0, mt.FormatLength());
  547. strncpy(psi->IsoLang, pTE->Language, countof(psi->IsoLang)-1);
  548. wcsncpy(psi->TrackName, pTE->Name, countof(psi->TrackName)-1);
  549. memcpy(mt.pbFormat + (psi->dwOffset = sizeof(SUBTITLEINFO)), pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetSize());
  551. mt.subtype = 
  552. CodecID == "S_TEXT/UTF8" ? MEDIASUBTYPE_UTF8 :
  553. CodecID == "S_TEXT/SSA" || CodecID == "S_SSA" ? MEDIASUBTYPE_SSA :
  554. CodecID == "S_TEXT/ASS" || CodecID == "S_ASS" ? MEDIASUBTYPE_ASS :
  555. CodecID == "S_TEXT/USF" || CodecID == "S_USF" ? MEDIASUBTYPE_USF :
  556. CodecID == "S_VOBSUB" ? MEDIASUBTYPE_VOBSUB :
  557. MEDIASUBTYPE_NULL;
  559. if(mt.subtype != MEDIASUBTYPE_NULL)
  560. mts.Add(mt);
  561. }
  562. }
  564. if(mts.IsEmpty())
  565. {
  566. TRACE(_T("CMatroskaSourceFilter: Unsupported TrackType %s (%I64d)n"), CString(CodecID), (UINT64)pTE->TrackType);
  567. continue;
  568. }
  570. Name = CStringW(pTE->Language.IsEmpty() ? L"English" : CStringW(ISO6392ToLanguage(pTE->Language)))
  571. + (pTE->Name.IsEmpty() ? L"" : L", " + pTE->Name)
  572. + (L" (" + Name + L")");
  574. HRESULT hr;
  576. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CMatroskaSplitterOutputPin((int)pTE->MinCache, pTE->DefaultDuration/100, mts, Name, this, this, &hr));
  577. if(!pTE->Name.IsEmpty()) pPinOut->SetProperty(L"NAME", pTE->Name);
  578. if(pTE->Language.GetLength() == 3) pPinOut->SetProperty(L"LANG", CStringW(CString(pTE->Language)));
  579. AddOutputPin((DWORD)pTE->TrackNumber, pPinOut);
  581. m_pTrackEntryMap[(DWORD)pTE->TrackNumber] = pTE;
  582. m_pOrderedTrackArray.Add(pTE);
  583. }
  584. }
  586. Info& info = m_pFile->m_segment.SegmentInfo;
  587. m_rtNewStart = m_rtCurrent = 0;
  588. m_rtNewStop = m_rtStop = (REFERENCE_TIME)(info.Duration*info.TimeCodeScale/100);
  590. #ifdef DEBUG
  591. /*
  592. for(int i = 1, j = GetChapterCount(CHAPTER_ROOT_ID); i <= j; i++)
  593. {
  594. UINT id = GetChapterId(CHAPTER_ROOT_ID, i);
  595. struct ChapterElement ce;
  596. BOOL b = GetChapterInfo(id, &ce);
  597. BSTR bstr = GetChapterStringInfo(id, "eng", "");
  598. if(bstr) ::SysFreeString(bstr);
  599. }
  600. */
  601. #endif
  603. SetProperty(L"TITL", info.Title);
  604. // TODO
  606. // resources
  608. {
  609. POSITION pos = m_pFile->m_segment.Attachments.GetHeadPosition();
  610. while(pos)
  611. {
  612. Attachment* pA = m_pFile->m_segment.Attachments.GetNext(pos);
  614. POSITION pos = pA->AttachedFiles.GetHeadPosition();
  615. while(pos)
  616. {
  617. AttachedFile* pF = pA->AttachedFiles.GetNext(pos);
  619. CArray<BYTE> pData;
  620. pData.SetSize(pF->FileDataLen);
  621. m_pFile->Seek(pF->FileDataPos);
  622. if(SUCCEEDED(m_pFile->Read(pData.GetData(), pData.GetSize())))
  623. ResAppend(pF->FileName, pF->FileDescription, CStringW(pF->FileMimeType), pData.GetData(), pData.GetSize());
  624. }
  625. }
  626. }
  628. // chapters
  630. if(ChapterAtom* caroot = m_pFile->m_segment.FindChapterAtom(0))
  631. {
  632. CStringA str;
  633. str.ReleaseBufferSetLength(GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, str.GetBuffer(3), 3));
  634. CStringA ChapLanguage = CStringA(ISO6391To6392(str));
  635. if(ChapLanguage.GetLength() < 3) ChapLanguage = "eng";
  637. POSITION pos = caroot->ChapterAtoms.GetHeadPosition();
  638. while(pos)
  639. {
  640. // ca == caroot->ChapterAtoms.GetNext(pos) ?
  641. if(ChapterAtom* ca = m_pFile->m_segment.FindChapterAtom(caroot->ChapterAtoms.GetNext(pos)->ChapterUID))
  642. {
  643. CStringW name, first;
  645. POSITION pos = ca->ChapterDisplays.GetHeadPosition();
  646. while(pos)
  647. {
  648. ChapterDisplay* cd = ca->ChapterDisplays.GetNext(pos);
  649. if(first.IsEmpty()) first = cd->ChapString;
  650. if(cd->ChapLanguage == ChapLanguage) name = cd->ChapString;
  651. }
  653. ChapAppend(ca->ChapterTimeStart / 100 - m_pFile->m_rtOffset, !name.IsEmpty() ? name : first);
  654. }
  655. }
  656. }
  658. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  659. }
  661. void CMatroskaSplitterFilter::InstallFonts()
  662. {
  663. POSITION pos = m_pFile->m_segment.Attachments.GetHeadPosition();
  664. while(pos)
  665. {
  666. Attachment* pA = m_pFile->m_segment.Attachments.GetNext(pos);
  668. POSITION p2 = pA->AttachedFiles.GetHeadPosition();
  669. while(p2)
  670. {
  671. AttachedFile* pF = pA->AttachedFiles.GetNext(p2);
  673. if(pF->FileMimeType == "application/x-truetype-font")
  674. {
  675. // assume this is a font resource
  677. if(BYTE* pData = new BYTE[(UINT)pF->FileDataLen])
  678. {
  679. m_pFile->Seek(pF->FileDataPos);
  681. if(SUCCEEDED(m_pFile->Read(pData, pF->FileDataLen)))
  682. m_fontinst.InstallFont(pData, (UINT)pF->FileDataLen);
  684. delete [] pData;
  685. }
  686. }
  687. }
  688. }
  689. }
  691. void CMatroskaSplitterFilter::SendVorbisHeaderSample()
  692. {
  693. HRESULT hr;
  695. POSITION pos = m_pTrackEntryMap.GetStartPosition();
  696. while(pos)
  697. {
  698. DWORD TrackNumber = 0;
  699. TrackEntry* pTE = NULL;
  700. m_pTrackEntryMap.GetNextAssoc(pos, TrackNumber, pTE);
  702. CBaseSplitterOutputPin* pPin = GetOutputPin(TrackNumber);
  704. if(!(pTE && pPin && pPin->IsConnected()))
  705. continue;
  707. if(pTE->CodecID.ToString() == "A_VORBIS" && pPin->CurrentMediaType().subtype == MEDIASUBTYPE_Vorbis
  708. && pTE->CodecPrivate.GetSize() > 0)
  709. {
  710. BYTE* ptr = (BYTE*)pTE->CodecPrivate;
  712. CList<long> sizes;
  713. long last = 0;
  714. for(BYTE n = *ptr++; n > 0; n--)
  715. {
  716. long size = 0;
  717. do {size += *ptr;} while(*ptr++ == 0xff);
  718. sizes.AddTail(size);
  719. last += size;
  720. }
  721. sizes.AddTail(pTE->CodecPrivate.GetSize() - (ptr - (BYTE*)pTE->CodecPrivate) - last);
  723. hr = S_OK;
  725. POSITION pos = sizes.GetHeadPosition();
  726. while(pos && SUCCEEDED(hr))
  727. {
  728. long len = sizes.GetNext(pos);
  730. CAutoPtr<Packet> p(new Packet());
  731. p->TrackNumber = (DWORD)pTE->TrackNumber;
  732. p->rtStart = 0; p->rtStop = 1;
  733. p->bSyncPoint = FALSE;
  734. p->pData.SetSize(len);
  735. memcpy(p->pData.GetData(), ptr, len);
  736. ptr += len;
  738. hr = DeliverPacket(p);
  739. }
  741. if(FAILED(hr))
  742. TRACE(_T("ERROR: Vorbis initialization failed for stream %I64dn"), TrackNumber);
  743. }
  744. }
  745. }
  747. bool CMatroskaSplitterFilter::DemuxInit()
  748. {
  749. CMatroskaNode Root(m_pFile);
  750. if(!m_pFile
  751. || !(m_pSegment = Root.Child(0x18538067))
  752. || !(m_pCluster = m_pSegment->Child(0x1F43B675)))
  753. return(false);
  755. // reindex if needed
  757. if(m_pFile->m_segment.Cues.GetCount() == 0)
  758. {
  759. m_nOpenProgress = 0;
  760. m_pFile->m_segment.SegmentInfo.Duration.Set(0);
  762. UINT64 TrackNumber = m_pFile->m_segment.GetMasterTrack();
  764. CAutoPtr<Cue> pCue(new Cue());
  766. do
  767. {
  768. Cluster c;
  769. c.ParseTimeCode(m_pCluster);
  771. m_pFile->m_segment.SegmentInfo.Duration.Set((float)c.TimeCode - m_pFile->m_rtOffset/10000);
  773. CAutoPtr<CuePoint> pCuePoint(new CuePoint());
  774. CAutoPtr<CueTrackPosition> pCueTrackPosition(new CueTrackPosition());
  775. pCuePoint->CueTime.Set(c.TimeCode);
  776. pCueTrackPosition->CueTrack.Set(TrackNumber);
  777. pCueTrackPosition->CueClusterPosition.Set(m_pCluster->m_filepos - m_pSegment->m_start);
  778. pCuePoint->CueTrackPositions.AddTail(pCueTrackPosition);
  779. pCue->CuePoints.AddTail(pCuePoint);
  781. m_nOpenProgress = m_pFile->GetPos()*100/m_pFile->GetLength();
  783. DWORD cmd;
  784. if(CheckRequest(&cmd))
  785. {
  786. if(cmd == CMD_EXIT) m_fAbort = true;
  787. else Reply(S_OK);
  788. }
  789. }
  790. while(!m_fAbort && m_pCluster->Next(true));
  792. m_nOpenProgress = 100;
  794. if(!m_fAbort) m_pFile->m_segment.Cues.AddTail(pCue);
  796. m_fAbort = false;
  797. }
  799. m_pCluster.Free();
  800. m_pBlock.Free();
  802. return(true);
  803. }
  805. void CMatroskaSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  806. {
  807. m_pCluster = m_pSegment->Child(0x1F43B675);
  808. m_pBlock.Free();
  810. if(rt > 0)
  811. {
  812. rt += m_pFile->m_rtOffset;
  814. QWORD lastCueClusterPosition = -1;
  816. Segment& s = m_pFile->m_segment;
  818. UINT64 TrackNumber = s.GetMasterTrack();
  820. POSITION pos1 = s.Cues.GetHeadPosition();
  821. while(pos1)
  822. {
  823. Cue* pCue = s.Cues.GetNext(pos1);
  825. POSITION pos2 = pCue->CuePoints.GetTailPosition();
  826. while(pos2)
  827. {
  828. CuePoint* pCuePoint = pCue->CuePoints.GetPrev(pos2);
  830. if(rt < s.GetRefTime(pCuePoint->CueTime))
  831. continue;
  833. POSITION pos3 = pCuePoint->CueTrackPositions.GetHeadPosition();
  834. while(pos3)
  835. {
  836. CueTrackPosition* pCueTrackPositions = pCuePoint->CueTrackPositions.GetNext(pos3);
  838. if(TrackNumber != pCueTrackPositions->CueTrack)
  839. continue;
  841. if(lastCueClusterPosition == pCueTrackPositions->CueClusterPosition)
  842. continue;
  844. lastCueClusterPosition = pCueTrackPositions->CueClusterPosition;
  846. m_pCluster->SeekTo(m_pSegment->m_start + pCueTrackPositions->CueClusterPosition);
  847. m_pCluster->Parse();
  849. bool fFoundKeyFrame = false;
  850. /*
  851. if(pCueTrackPositions->CueBlockNumber > 0)
  852. {
  853. // TODO: CueBlockNumber only tells the block num of the track and not for all mixed in the cluster
  854. m_nLastBlock = (int)pCueTrackPositions->CueBlockNumber;
  855. fFoundKeyFrame = true;
  856. }
  857. else
  858. */
  859. {
  860. Cluster c;
  861. c.ParseTimeCode(m_pCluster);
  863. if(CAutoPtr<CMatroskaNode> pBlock = m_pCluster->GetFirstBlock())
  864. {
  865. bool fPassedCueTime = false;
  867. do
  868. {
  869. CBlockGroupNode bgn;
  871. if(pBlock->m_id == 0xA0)
  872. {
  873. bgn.Parse(pBlock, true);
  874. }
  875. else if(pBlock->m_id == 0xA3)
  876. {
  877. CAutoPtr<BlockGroup> bg(new BlockGroup());
  878. bg->Block.Parse(pBlock, true);
  879. if(!(bg->Block.Lacing & 0x80)) bg->ReferenceBlock.Set(0); // not a kf
  880. bgn.AddTail(bg);
  881. }
  883. POSITION pos4 = bgn.GetHeadPosition();
  884. while(!fPassedCueTime && pos4)
  885. {
  886. BlockGroup* bg = bgn.GetNext(pos4);
  888. if(bg->Block.TrackNumber == pCueTrackPositions->CueTrack && rt < s.GetRefTime(c.TimeCode + bg->Block.TimeCode)
  889. || rt + 5000000i64 < s.GetRefTime(c.TimeCode + bg->Block.TimeCode)) // allow 500ms difference between tracks, just in case intreleaving wasn't that much precise
  890. {
  891. fPassedCueTime = true;
  892. }
  893. else if(bg->Block.TrackNumber == pCueTrackPositions->CueTrack && !bg->ReferenceBlock.IsValid())
  894. {
  895. fFoundKeyFrame = true;
  896. m_pBlock = pBlock->Copy();
  897. }
  898. }
  899. }
  900. while(!fPassedCueTime && pBlock->NextBlock());
  901. }
  902. }
  904. if(fFoundKeyFrame)
  905. pos1 = pos2 = pos3 = NULL;
  906. }
  907. }
  908. }
  910. if(!m_pBlock)
  911. {
  912. m_pCluster = m_pSegment->Child(0x1F43B675);
  913. }
  914. }
  915. }
  917. bool CMatroskaSplitterFilter::DemuxLoop()
  918. {
  919. HRESULT hr = S_OK;
  921. SendVorbisHeaderSample(); // HACK: init vorbis decoder with the headers
  923. do
  924. {
  925. Cluster c;
  926. c.ParseTimeCode(m_pCluster);
  928. if(!m_pBlock) m_pBlock = m_pCluster->GetFirstBlock();
  929. if(!m_pBlock) continue;
  931. do
  932. {
  933. CBlockGroupNode bgn;
  935. if(m_pBlock->m_id == 0xA0)
  936. {
  937. bgn.Parse(m_pBlock, true);
  938. }
  939. else if(m_pBlock->m_id == 0xA3)
  940. {
  941. CAutoPtr<BlockGroup> bg(new BlockGroup());
  942. bg->Block.Parse(m_pBlock, true);
  943. if(!(bg->Block.Lacing & 0x80)) bg->ReferenceBlock.Set(0); // not a kf
  944. bgn.AddTail(bg);
  945. }
  947. while(bgn.GetCount())
  948. {
  949. CAutoPtr<MatroskaPacket> p(new MatroskaPacket());
  950. p->bg = bgn.RemoveHead();
  952. p->bSyncPoint = !p->bg->ReferenceBlock.IsValid();
  953. p->TrackNumber = (DWORD)p->bg->Block.TrackNumber;
  955. TrackEntry *pTE = m_pTrackEntryMap[p->TrackNumber];
  956. p->rtStart = m_pFile->m_segment.GetRefTime((REFERENCE_TIME)c.TimeCode + p->bg->Block.TimeCode);
  957. p->rtStop = p->rtStart + (p->bg->BlockDuration.IsValid() ? m_pFile->m_segment.GetRefTime(p->bg->BlockDuration) : 1);
  959. // Fix subtitle with duration = 0
  960. if(pTE && (pTE->TrackType == TrackEntry::TypeSubtitle) && (!p->bg->BlockDuration.IsValid()))
  961. {
  962. p->bg->BlockDuration.Set(1); // just setting it to be valid
  963. p->rtStop = p->rtStart;
  964. }
  966. POSITION pos = p->bg->Block.BlockData.GetHeadPosition();
  967. while(pos)
  968. {
  969. CBinary* pb = p->bg->Block.BlockData.GetNext(pos);
  970. m_pTrackEntryMap[p->TrackNumber]->Expand(*pb, ContentEncoding::AllFrameContents);
  971. }
  973. // HACK
  974. p->rtStart -= m_pFile->m_rtOffset;
  975. p->rtStop -= m_pFile->m_rtOffset;
  977. hr = DeliverPacket(p);
  978. }
  979. }
  980. while(m_pBlock->NextBlock() && SUCCEEDED(hr) && !CheckRequest(NULL));
  982. m_pBlock.Free();
  983. }
  984. while(m_pFile->GetPos() < m_pFile->m_segment.pos + m_pFile->m_segment.len 
  985. && m_pCluster->Next(true) && SUCCEEDED(hr) && !CheckRequest(NULL));
  987. m_pCluster.Free();
  989. return(true);
  990. }
  992. // IMediaSeeking
  994. STDMETHODIMP CMatroskaSplitterFilter::GetDuration(LONGLONG* pDuration)
  995. {
  996. CheckPointer(pDuration, E_POINTER);
  997. CheckPointer(m_pFile, VFW_E_NOT_CONNECTED);
  999. Segment& s = m_pFile->m_segment;
  1000. *pDuration = s.GetRefTime((INT64)s.SegmentInfo.Duration);
  1002. return S_OK;
  1003. }
  1005. // IKeyFrameInfo
  1007. STDMETHODIMP CMatroskaSplitterFilter::GetKeyFrameCount(UINT& nKFs)
  1008. {
  1009. if(!m_pFile) return E_UNEXPECTED;
  1011. HRESULT hr = S_OK;
  1013. nKFs = 0;
  1015. POSITION pos = m_pFile->m_segment.Cues.GetHeadPosition();
  1016. while(pos) nKFs += m_pFile->m_segment.Cues.GetNext(pos)->CuePoints.GetCount();
  1018. return hr;
  1019. }
  1021. STDMETHODIMP CMatroskaSplitterFilter::GetKeyFrames(const GUID* pFormat, REFERENCE_TIME* pKFs, UINT& nKFs)
  1022. {
  1023. CheckPointer(pFormat, E_POINTER);
  1024. CheckPointer(pKFs, E_POINTER);
  1026. if(!m_pFile) return E_UNEXPECTED;
  1027. if(*pFormat != TIME_FORMAT_MEDIA_TIME) return E_INVALIDARG;
  1029. UINT nKFsTmp = 0;
  1031. POSITION pos1 = m_pFile->m_segment.Cues.GetHeadPosition();
  1032. while(pos1 && nKFsTmp < nKFs)
  1033. {
  1034. Cue* pCue = m_pFile->m_segment.Cues.GetNext(pos1);
  1036. POSITION pos2 = pCue->CuePoints.GetHeadPosition();
  1037. while(pos2 && nKFsTmp < nKFs)
  1038. pKFs[nKFsTmp++] = m_pFile->m_segment.GetRefTime(pCue->CuePoints.GetNext(pos2)->CueTime);
  1039. }
  1041. nKFs = nKFsTmp;
  1043. return S_OK;
  1044. }
  1046. //
  1047. // CMatroskaSourceFilter
  1048. //
  1050. CMatroskaSourceFilter::CMatroskaSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  1051. : CMatroskaSplitterFilter(pUnk, phr)
  1052. {
  1053. m_clsid = __uuidof(this);
  1054. m_pInput.Free();
  1055. }
  1057. //
  1058. // CMatroskaSplitterOutputPin
  1059. //
  1061. CMatroskaSplitterOutputPin::CMatroskaSplitterOutputPin(
  1062. int nMinCache, REFERENCE_TIME rtDefaultDuration,
  1063. CArray<CMediaType>& mts, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  1064. : CBaseSplitterOutputPin(mts, pName, pFilter, pLock, phr)
  1065. , m_nMinCache(nMinCache), m_rtDefaultDuration(rtDefaultDuration)
  1066. {
  1067. m_nMinCache = max(m_nMinCache, 1);
  1068. }
  1070. CMatroskaSplitterOutputPin::~CMatroskaSplitterOutputPin()
  1071. {
  1072. }
  1074. HRESULT CMatroskaSplitterOutputPin::DeliverEndFlush()
  1075. {
  1076. {
  1077. CAutoLock cAutoLock(&m_csQueue);
  1078. m_packets.RemoveAll();
  1079. m_rob.RemoveAll();
  1080. m_tos.RemoveAll();
  1081. }
  1083. return __super::DeliverEndFlush();
  1084. }
  1086. HRESULT CMatroskaSplitterOutputPin::DeliverEndOfStream()
  1087. {
  1088. CAutoLock cAutoLock(&m_csQueue);
  1090. // send out the last remaining packets from the queue
  1092. while(m_rob.GetCount())
  1093. {
  1094. MatroskaPacket* mp = m_rob.RemoveHead();
  1095. if(m_rob.GetCount() && !mp->bg->BlockDuration.IsValid()) 
  1096. mp->rtStop = m_rob.GetHead()->rtStart;
  1097. else if(m_rob.GetCount() == 0 && m_rtDefaultDuration > 0)
  1098. mp->rtStop = mp->rtStart + m_rtDefaultDuration;
  1100. timeoverride to = {mp->rtStart, mp->rtStop};
  1101. m_tos.AddTail(to);
  1102. }
  1104. while(m_packets.GetCount())
  1105. {
  1106. HRESULT hr = DeliverBlock(m_packets.RemoveHead());
  1107. if(hr != S_OK) return hr;
  1108. }
  1110. return __super::DeliverEndOfStream();
  1111. }
  1113. HRESULT CMatroskaSplitterOutputPin::DeliverPacket(CAutoPtr<Packet> p)
  1114. {
  1115. MatroskaPacket* mp = dynamic_cast<MatroskaPacket*>(p.m_p);
  1116. if(!mp) return __super::DeliverPacket(p);
  1118. // don't try to understand what's happening here, it's magic
  1120. CAutoLock cAutoLock(&m_csQueue);
  1122. CAutoPtr<MatroskaPacket> p2;
  1123. p.Detach();
  1124. p2.Attach(mp);
  1125. m_packets.AddTail(p2);
  1127. POSITION pos = m_rob.GetTailPosition();
  1128. for(int i = m_nMinCache-1; i > 0 && pos && mp->bg->ReferencePriority < m_rob.GetAt(pos)->bg->ReferencePriority; i--)
  1129. m_rob.GetPrev(pos);
  1131. if(!pos) m_rob.AddHead(mp);
  1132. else m_rob.InsertAfter(pos, mp);
  1134. mp = NULL;
  1136. if(m_rob.GetCount() == m_nMinCache+1)
  1137. {
  1138. ASSERT(m_nMinCache > 0);
  1139. pos = m_rob.GetHeadPosition();
  1140. MatroskaPacket* mp1 = m_rob.GetNext(pos);
  1141. MatroskaPacket* mp2 = m_rob.GetNext(pos);
  1142. if(!mp1->bg->BlockDuration.IsValid())
  1143. {
  1144. mp1->bg->BlockDuration.Set(1); // just to set it valid
  1146. if(mp1->rtStart >= mp2->rtStart)
  1147. {
  1148. /* CString str;
  1149. str.Format(_T("mp1->rtStart (%I64d) >= mp2->rtStart (%I64d)!!!n"), mp1->rtStart, mp2->rtStart);
  1150. AfxMessageBox(str);
  1151. */
  1152. // TRACE(_T("mp1->rtStart (%I64d) >= mp2->rtStart (%I64d)!!!n"), mp1->rtStart, mp2->rtStart);
  1153. }
  1154. else
  1155. {
  1156. mp1->rtStop = mp2->rtStart;
  1157. }
  1158. }
  1159. }
  1161. while(m_packets.GetCount())
  1162. {
  1163. mp = m_packets.GetHead();
  1164. if(!mp->bg->BlockDuration.IsValid()) break;
  1165.         
  1166. mp = m_rob.RemoveHead();
  1167. timeoverride to = {mp->rtStart, mp->rtStop};
  1168. m_tos.AddTail(to);
  1170. HRESULT hr = DeliverBlock(m_packets.RemoveHead());
  1171. if(hr != S_OK) return hr;
  1172. }
  1174. return S_OK;
  1175. }
  1177. HRESULT CMatroskaSplitterOutputPin::DeliverBlock(MatroskaPacket* p)
  1178. {
  1179. HRESULT hr = S_FALSE;
  1181. if(m_tos.GetCount())
  1182. {
  1183. timeoverride to = m_tos.RemoveHead();
  1184. // if(p->TrackNumber == 2)
  1185. TRACE(_T("(track=%d) %I64d, %I64d -> %I64d, %I64d (buffcnt=%d)n"), 
  1186. p->TrackNumber, p->rtStart, p->rtStop, to.rtStart, to.rtStop,
  1187. QueueCount());
  1188. /**/
  1189. p->rtStart = to.rtStart;
  1190. p->rtStop = to.rtStop;
  1191. }
  1193. REFERENCE_TIME 
  1194. rtStart = p->rtStart,
  1195. rtDelta = (p->rtStop - p->rtStart) / p->bg->Block.BlockData.GetCount(),
  1196. rtStop = p->rtStart + rtDelta;
  1198. POSITION pos = p->bg->Block.BlockData.GetHeadPosition();
  1199. while(pos)
  1200. {
  1201. CAutoPtr<Packet> tmp(new Packet());
  1202. tmp->TrackNumber = p->TrackNumber;
  1203. tmp->bDiscontinuity = p->bDiscontinuity;
  1204. tmp->bSyncPoint = p->bSyncPoint;
  1205. tmp->rtStart = rtStart;
  1206. tmp->rtStop = rtStop;
  1207. tmp->pData.Copy(*p->bg->Block.BlockData.GetNext(pos));
  1208. if(S_OK != (hr = DeliverPacket(tmp))) break;
  1210. rtStart += rtDelta;
  1211. rtStop += rtDelta;
  1213. p->bSyncPoint = false;
  1214. p->bDiscontinuity = false;
  1215. }
  1217. return hr;
  1218. }
  1220. // ITrackInfo
  1222. TrackEntry* CMatroskaSplitterFilter::GetTrackEntryAt(UINT aTrackIdx)
  1223. {
  1224. if(aTrackIdx < 0 || aTrackIdx >= m_pOrderedTrackArray.GetCount())
  1225. return NULL;
  1226. return m_pOrderedTrackArray[aTrackIdx];
  1227. }
  1229. STDMETHODIMP_(UINT) CMatroskaSplitterFilter::GetTrackCount()
  1230. {
  1231. return m_pTrackEntryMap.GetCount();
  1232. }
  1234. STDMETHODIMP_(BOOL) CMatroskaSplitterFilter::GetTrackInfo(UINT aTrackIdx, struct TrackElement* pStructureToFill)
  1235. {
  1236. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1237. if(pTE == NULL)
  1238. return FALSE;
  1240. pStructureToFill->FlagDefault = !!pTE->FlagDefault;
  1241. pStructureToFill->FlagLacing = !!pTE->FlagLacing;
  1242. strncpy(pStructureToFill->Language, pTE->Language, 3);
  1243. if(pStructureToFill->Language[0] == '')
  1244. strncpy(pStructureToFill->Language, "eng", 3);
  1245. pStructureToFill->Language[3] = '';
  1246. pStructureToFill->MaxCache = (UINT)pTE->MaxCache;
  1247. pStructureToFill->MinCache = (UINT)pTE->MinCache;
  1248. pStructureToFill->Type = (BYTE)pTE->TrackType;
  1249. return TRUE;
  1250. }
  1252. STDMETHODIMP_(BOOL) CMatroskaSplitterFilter::GetTrackExtendedInfo(UINT aTrackIdx, void* pStructureToFill)
  1253. {
  1254. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1255. if(pTE == NULL)
  1256. return FALSE;
  1258. if(pTE->TrackType == TrackEntry::TypeVideo)
  1259. {
  1260. TrackExtendedInfoVideo* pTEIV = (TrackExtendedInfoVideo*)pStructureToFill;
  1261. pTEIV->AspectRatioType = (BYTE)pTE->v.AspectRatioType;
  1262. pTEIV->DisplayUnit = (BYTE)pTE->v.DisplayUnit;
  1263. pTEIV->DisplayWidth = (UINT)pTE->v.DisplayWidth;
  1264. pTEIV->DisplayHeight = (UINT)pTE->v.DisplayHeight;
  1265. pTEIV->Interlaced = !!pTE->v.FlagInterlaced;
  1266. pTEIV->PixelWidth = (UINT)pTE->v.PixelWidth;
  1267. pTEIV->PixelHeight = (UINT)pTE->v.PixelHeight;
  1268. } else if(pTE->TrackType == TrackEntry::TypeAudio) {
  1269. TrackExtendedInfoAudio* pTEIA = (TrackExtendedInfoAudio*)pStructureToFill;
  1270. pTEIA->BitDepth = (UINT)pTE->a.BitDepth;
  1271. pTEIA->Channels = (UINT)pTE->a.Channels;
  1272. pTEIA->OutputSamplingFrequency = pTE->a.OutputSamplingFrequency;
  1273. pTEIA->SamplingFreq = pTE->a.SamplingFrequency;
  1274. } else {
  1275. return FALSE;
  1276. }
  1278. return TRUE;
  1279. }
  1281. STDMETHODIMP_(BSTR) CMatroskaSplitterFilter::GetTrackName(UINT aTrackIdx)
  1282. {
  1283. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1284. if(pTE == NULL)
  1285. return NULL;
  1286. return pTE->Name.AllocSysString();
  1287. }
  1289. STDMETHODIMP_(BSTR) CMatroskaSplitterFilter::GetTrackCodecID(UINT aTrackIdx)
  1290. {
  1291. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1292. if(pTE == NULL)
  1293. return NULL;
  1294. return pTE->CodecID.ToString().AllocSysString();
  1295. }
  1297. STDMETHODIMP_(BSTR) CMatroskaSplitterFilter::GetTrackCodecName(UINT aTrackIdx)
  1298. {
  1299. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1300. if(pTE == NULL)
  1301. return NULL;
  1302. return pTE->CodecName.AllocSysString();
  1303. }
  1305. STDMETHODIMP_(BSTR) CMatroskaSplitterFilter::GetTrackCodecInfoURL(UINT aTrackIdx)
  1306. {
  1307. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1308. if(pTE == NULL)
  1309. return NULL;
  1310. return pTE->CodecInfoURL.AllocSysString();
  1311. }
  1313. STDMETHODIMP_(BSTR) CMatroskaSplitterFilter::GetTrackCodecDownloadURL(UINT aTrackIdx)
  1314. {
  1315. TrackEntry* pTE = GetTrackEntryAt(aTrackIdx);
  1316. if(pTE == NULL)
  1317. return NULL;
  1318. return pTE->CodecDownloadURL.AllocSysString();
  1319. }