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

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

多媒体编程

开发平台：

Visual C++

MatroskaMuxer.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 "MatroskaMuxer.h"
  25. #include "......DSUtilDSUtil.h"
  27. #include <initguid.h>
  28. #include "........includematroskamatroska.h"
  29. #include "........includeoggOggDS.h"
  30. #include "........includemoreuuids.h"
  32. using namespace MatroskaWriter;
  34. #ifdef REGISTER_FILTER
  36. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  37. {
  38. {&MEDIATYPE_Stream, &MEDIASUBTYPE_Matroska}
  39. };
  41. const AMOVIESETUP_PIN sudpPins[] =
  42. {
  43.     {L"Input", FALSE, FALSE, FALSE, TRUE, &CLSID_NULL, NULL, 0, NULL},
  44.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  45. };
  47. const AMOVIESETUP_FILTER sudFilter[] =
  48. {
  49. {&__uuidof(CMatroskaMuxerFilter), L"Matroska Muxer", MERIT_DO_NOT_USE, countof(sudpPins), sudpPins}
  50. };
  52. CFactoryTemplate g_Templates[] =
  53. {
  54. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CMatroskaMuxerFilter>, NULL, &sudFilter[0]}
  55. };
  57. int g_cTemplates = countof(g_Templates);
  59. STDAPI DllRegisterServer()
  60. {
  61. return AMovieDllRegisterServer2(TRUE);
  62. }
  64. STDAPI DllUnregisterServer()
  65. {
  66. return AMovieDllRegisterServer2(FALSE);
  67. }
  69. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  71. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  72. {
  73.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  74. }
  76. #endif
  78. //
  79. // CMatroskaMuxerFilter
  80. //
  82. CMatroskaMuxerFilter::CMatroskaMuxerFilter(LPUNKNOWN pUnk, HRESULT* phr)
  83. : CBaseFilter(NAME("CMatroskaMuxerFilter"), pUnk, this, __uuidof(this))
  84. , m_rtCurrent(0)
  85. , m_fNegative(true), m_fPositive(false)
  86. {
  87. if(phr) *phr = S_OK;
  89. m_pOutput.Attach(new CMatroskaMuxerOutputPin(NAME("CMatroskaMuxerOutputPin"), this, this, phr));
  91. AddInput();
  93. srand(clock());
  94. }
  96. CMatroskaMuxerFilter::~CMatroskaMuxerFilter()
  97. {
  98. CAutoLock cAutoLock(this);
  99. }
  101. STDMETHODIMP CMatroskaMuxerFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  102. {
  103. CheckPointer(ppv, E_POINTER);
  105. *ppv = NULL;
  107. return 
  108. // QI(IAMFilterMiscFlags)
  109. QI(IMediaSeeking)
  110. QI(IMatroskaMuxer)
  111. __super::NonDelegatingQueryInterface(riid, ppv);
  112. }
  114. UINT CMatroskaMuxerFilter::GetTrackNumber(CBasePin* pPin)
  115. {
  116. UINT nTrackNumber = 0;
  118. POSITION pos = m_pInputs.GetHeadPosition();
  119. while(pos)
  120. {
  121. nTrackNumber++;
  122. if(m_pInputs.GetNext(pos) == pPin)
  123. return nTrackNumber;
  124. }
  126. return 0;
  127. }
  129. void CMatroskaMuxerFilter::AddInput()
  130. {
  131. POSITION pos = m_pInputs.GetHeadPosition();
  132. while(pos)
  133. {
  134. CBasePin* pPin = m_pInputs.GetNext(pos);
  135. if(!pPin->IsConnected()) return;
  136. }
  138. CStringW name;
  139. name.Format(L"Track %d", m_pInputs.GetCount()+1);
  141. HRESULT hr;
  142. CAutoPtr<CMatroskaMuxerInputPin> pPin(new CMatroskaMuxerInputPin(name, this, this, &hr));
  143. m_pInputs.AddTail(pPin);
  144. }
  146. int CMatroskaMuxerFilter::GetPinCount()
  147. {
  148. return m_pInputs.GetCount() + (m_pOutput ? 1 : 0);
  149. }
  151. CBasePin* CMatroskaMuxerFilter::GetPin(int n)
  152. {
  153.     CAutoLock cAutoLock(this);
  155. if(n >= 0 && n < (int)m_pInputs.GetCount())
  156. {
  157. if(POSITION pos = m_pInputs.FindIndex(n))
  158. return m_pInputs.GetAt(pos);
  159. }
  161. if(n == m_pInputs.GetCount() && m_pOutput)
  162. {
  163. return m_pOutput;
  164. }
  166. return NULL;
  167. }
  169. STDMETHODIMP CMatroskaMuxerFilter::Stop()
  170. {
  171. CAutoLock cAutoLock(this);
  173. HRESULT hr;
  175. if(FAILED(hr = __super::Stop()))
  176. return hr;
  178. CallWorker(CMD_EXIT);
  180. return hr;
  181. }
  183. STDMETHODIMP CMatroskaMuxerFilter::Pause()
  184. {
  185. CAutoLock cAutoLock(this);
  187. FILTER_STATE fs = m_State;
  189. HRESULT hr;
  191. if(FAILED(hr = __super::Pause()))
  192. return hr;
  194. if(fs == State_Stopped && m_pOutput)
  195. {
  196. CAMThread::Create();
  197. CallWorker(CMD_RUN);
  198. }
  200. return hr;
  201. }
  203. STDMETHODIMP CMatroskaMuxerFilter::Run(REFERENCE_TIME tStart)
  204. {
  205. CAutoLock cAutoLock(this);
  207. HRESULT hr;
  209. if(FAILED(hr = __super::Run(tStart)))
  210. return hr;
  212. return hr;
  213. }
  215. // IAMFilterMiscFlags
  217. STDMETHODIMP_(ULONG) CMatroskaMuxerFilter::GetMiscFlags()
  218. {
  219. return AM_FILTER_MISC_FLAGS_IS_RENDERER;
  220. }
  222. // IMediaSeeking
  224. STDMETHODIMP CMatroskaMuxerFilter::GetCapabilities(DWORD* pCapabilities)
  225. {
  226. return pCapabilities ? *pCapabilities = 
  227. AM_SEEKING_CanGetDuration|
  228. AM_SEEKING_CanGetCurrentPos, S_OK : E_POINTER;
  229. }
  230. STDMETHODIMP CMatroskaMuxerFilter::CheckCapabilities(DWORD* pCapabilities)
  231. {
  232. CheckPointer(pCapabilities, E_POINTER);
  233. if(*pCapabilities == 0) return S_OK;
  234. DWORD caps;
  235. GetCapabilities(&caps);
  236. caps &= *pCapabilities;
  237. return caps == 0 ? E_FAIL : caps == *pCapabilities ? S_OK : S_FALSE;
  238. }
  239. STDMETHODIMP CMatroskaMuxerFilter::IsFormatSupported(const GUID* pFormat) {return !pFormat ? E_POINTER : *pFormat == TIME_FORMAT_MEDIA_TIME ? S_OK : S_FALSE;}
  240. STDMETHODIMP CMatroskaMuxerFilter::QueryPreferredFormat(GUID* pFormat) {return GetTimeFormat(pFormat);}
  241. STDMETHODIMP CMatroskaMuxerFilter::GetTimeFormat(GUID* pFormat) {return pFormat ? *pFormat = TIME_FORMAT_MEDIA_TIME, S_OK : E_POINTER;}
  242. STDMETHODIMP CMatroskaMuxerFilter::IsUsingTimeFormat(const GUID* pFormat) {return IsFormatSupported(pFormat);}
  243. STDMETHODIMP CMatroskaMuxerFilter::SetTimeFormat(const GUID* pFormat) {return S_OK == IsFormatSupported(pFormat) ? S_OK : E_INVALIDARG;}
  244. STDMETHODIMP CMatroskaMuxerFilter::GetDuration(LONGLONG* pDuration)
  245. {
  246. CheckPointer(pDuration, E_POINTER);
  247. *pDuration = 0;
  248. POSITION pos = m_pInputs.GetHeadPosition();
  249. while(pos) {REFERENCE_TIME rt = m_pInputs.GetNext(pos)->m_rtDur; if(rt > *pDuration) *pDuration = rt;}
  250. return S_OK;
  251. }
  252. STDMETHODIMP CMatroskaMuxerFilter::GetStopPosition(LONGLONG* pStop) {return E_NOTIMPL;}
  253. STDMETHODIMP CMatroskaMuxerFilter::GetCurrentPosition(LONGLONG* pCurrent)
  254. {
  255. CheckPointer(pCurrent, E_POINTER);
  256. *pCurrent = m_rtCurrent;
  257. return S_OK;
  258. }
  259. STDMETHODIMP CMatroskaMuxerFilter::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat) {return E_NOTIMPL;}
  260. STDMETHODIMP CMatroskaMuxerFilter::SetPositions(LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags) {return E_NOTIMPL;}
  261. STDMETHODIMP CMatroskaMuxerFilter::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop) {return E_NOTIMPL;}
  262. STDMETHODIMP CMatroskaMuxerFilter::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest) {return E_NOTIMPL;}
  263. STDMETHODIMP CMatroskaMuxerFilter::SetRate(double dRate) {return E_NOTIMPL;}
  264. STDMETHODIMP CMatroskaMuxerFilter::GetRate(double* pdRate) {return E_NOTIMPL;}
  265. STDMETHODIMP CMatroskaMuxerFilter::GetPreroll(LONGLONG* pllPreroll) {return E_NOTIMPL;}
  267. // IMatroskaMuxer 
  269. STDMETHODIMP CMatroskaMuxerFilter::CorrectTimeOffset(bool fNegative, bool fPositive)
  270. {
  271. m_fNegative = fNegative;
  272. m_fPositive = fPositive;
  273. return S_OK;
  274. }
  276. //
  278. ULONGLONG GetStreamPosition(IStream* pStream)
  279. {
  280. ULARGE_INTEGER pos = {0, 0};
  281. pStream->Seek(*(LARGE_INTEGER*)&pos, STREAM_SEEK_CUR, &pos);
  282. return pos.QuadPart;
  283. }
  285. ULONGLONG SetStreamPosition(IStream* pStream, ULONGLONG seekpos)
  286. {
  287. LARGE_INTEGER pos;
  288. pos.QuadPart = seekpos;
  289. ULARGE_INTEGER posnew;
  290. posnew.QuadPart = GetStreamPosition(pStream);
  291. pStream->Seek(pos, STREAM_SEEK_SET, &posnew);
  292. return posnew.QuadPart;
  293. }
  295. DWORD CMatroskaMuxerFilter::ThreadProc()
  296. {
  297. CComQIPtr<IStream> pStream;
  299. if(!m_pOutput || !(pStream = m_pOutput->GetConnected()))
  300. {
  301. while(1)
  302. {
  303. DWORD cmd = GetRequest();
  304. if(cmd == CMD_EXIT) CAMThread::m_hThread = NULL;
  305. Reply(S_OK);
  306. if(cmd == CMD_EXIT) return 0;
  307. }
  308. }
  310. REFERENCE_TIME rtDur = 0;
  311. GetDuration(&rtDur);
  313. SetStreamPosition(pStream, 0);
  315. ULARGE_INTEGER uli = {0};
  316. pStream->SetSize(uli);
  318. EBML hdr;
  319. hdr.DocType.Set("matroska");
  320. hdr.DocTypeVersion.Set(1);
  321. hdr.DocTypeReadVersion.Set(1);
  322. hdr.Write(pStream);
  324. Segment().Write(pStream);
  325. ULONGLONG segpos = GetStreamPosition(pStream);
  327. // TODO
  328. QWORD voidlen = 100;
  329. if(rtDur > 0) voidlen += int(1.0 * rtDur / MAXCLUSTERTIME / 10000 + 0.5) * 20;
  330. else voidlen += int(1.0 * 1000*60*60*24 / MAXCLUSTERTIME + 0.5) * 20; // when no duration is known, allocate for 24 hours (~340k)
  331. ULONGLONG voidpos = GetStreamPosition(pStream);
  332. {
  333. Void v(voidlen);
  334. voidlen = v.Size();
  335. v.Write(pStream);
  336. }
  338. // Meta Seek
  340. Seek seek;
  341. CAutoPtr<SeekHead> sh;
  343. // Segment Info
  345. sh.Attach(new SeekHead());
  346. sh->ID.Set(0x1549A966);
  347. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  348. seek.SeekHeads.AddTail(sh);
  350. ULONGLONG infopos = GetStreamPosition(pStream);
  351. Info info;
  352. info.MuxingApp.Set(L"DirectShow Matroska Muxer");
  353. info.TimeCodeScale.Set(1000000);
  354. info.Duration.Set((float)rtDur / 10000);
  355. struct tm _2001 = {0, 0, 0, 1, 0, 101, 0, 0, 1};
  356. info.DateUTC.Set((_time64(NULL) - _mktime64(&_2001)) * 1000000000);
  357. info.Write(pStream);
  359. // Tracks
  361. sh.Attach(new SeekHead());
  362. sh->ID.Set(0x1654AE6B);
  363. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  364. seek.SeekHeads.AddTail(sh);
  366. UINT64 TrackNumber = 0;
  367. /*
  368. CNode<Track> Tracks;
  369. CAutoPtr<Track> pT(new Track());
  370. POSITION pos = m_pInputs.GetHeadPosition();
  371. for(int i = 1; pos; i++)
  372. {
  373. CMatroskaMuxerInputPin* pPin = m_pInputs.GetNext(pos);
  374. if(!pPin->IsConnected()) continue;
  376. CAutoPtr<TrackEntry> pTE(new TrackEntry());
  377. *pTE = *pPin->GetTrackEntry();
  378. if(TrackNumber == 0 && pTE->TrackType == TrackEntry::TypeVideo) 
  379. TrackNumber = pTE->TrackNumber;
  380. pT->TrackEntries.AddTail(pTE);
  381. }
  382. Tracks.AddTail(pT);
  383. Tracks.Write(pStream);
  385. if(TrackNumber == 0) TrackNumber = 1;
  386. */
  387. bool fTracksWritten = false;
  389. //
  391. Cluster c;
  392. c.TimeCode.Set(0);
  394. bool fFirstBlock = true;
  395. INT64 firstTimeCode = 0;
  397. CList<CMatroskaMuxerInputPin*> pActivePins;
  399. POSITION pos = m_pInputs.GetHeadPosition();
  400. while(pos)
  401. {
  402. CMatroskaMuxerInputPin* pPin = m_pInputs.GetNext(pos);
  403. if(pPin->IsConnected()) pActivePins.AddTail(pPin);
  404. }
  406. while(1)
  407. {
  408. DWORD cmd = GetRequest();
  410. switch(cmd)
  411. {
  412. default:
  413. case CMD_EXIT:
  414. CAMThread::m_hThread = NULL;
  415. Reply(S_OK);
  416. return 0;
  418. case CMD_RUN:
  419. Reply(S_OK);
  421. Cue cue;
  422. ULONGLONG lastcueclusterpos = -1;
  423. INT64 lastcuetimecode = -1;
  424. UINT64 nBlocksInCueTrack = 0;
  426. while(!CheckRequest(NULL))
  427. {
  428. if(m_State == State_Paused)
  429. {
  430. Sleep(10);
  431. continue;
  432. }
  434. int nPinsGotSomething = 0, nPinsNeeded = 0;
  435. CMatroskaMuxerInputPin* pPin = NULL;
  436. REFERENCE_TIME rtMin = _I64_MAX;
  438. pos = pActivePins.GetHeadPosition();
  439. while(pos)
  440. {
  441. CMatroskaMuxerInputPin* pTmp = pActivePins.GetNext(pos);
  443. CAutoLock cAutoLock(&pTmp->m_csQueue);
  445. if(pTmp->m_blocks.GetCount() == 0 && pTmp->m_fEndOfStreamReceived)
  446. {
  447. pActivePins.RemoveAt(pActivePins.Find(pTmp));
  448. continue;
  449. }
  451. if(pTmp->GetTrackEntry()->TrackType != TrackEntry::TypeSubtitle)
  452. nPinsNeeded++;
  454. if(pTmp->m_blocks.GetCount() > 0)
  455. {
  456. if(pTmp->GetTrackEntry()->TrackType != TrackEntry::TypeSubtitle)
  457. nPinsGotSomething++;
  459. if(pTmp->m_blocks.GetCount() > 0)
  460. {
  461. REFERENCE_TIME rt = pTmp->m_blocks.GetHead()->Block.TimeCode;
  462. if(rt < rtMin) {rtMin = rt; pPin = pTmp;}
  463. }
  464. }
  465. }
  467. if(pActivePins.GetCount() == 0)
  468. {
  469. break;
  470. }
  472. if(!pPin || nPinsNeeded > nPinsGotSomething || !pPin && nPinsGotSomething == 0)
  473. {
  474. Sleep(1);
  475. continue;
  476. }
  478. if(!fTracksWritten)
  479. {
  480. CNode<Track> Tracks;
  481. CAutoPtr<Track> pT(new Track());
  482. POSITION pos = pActivePins.GetHeadPosition();
  483. for(int i = 1; pos; i++)
  484. {
  485. CMatroskaMuxerInputPin* pPin = pActivePins.GetNext(pos);
  487. CAutoPtr<TrackEntry> pTE(new TrackEntry());
  488. *pTE = *pPin->GetTrackEntry();
  489. if(TrackNumber == 0 && pTE->TrackType == TrackEntry::TypeVideo) 
  490. TrackNumber = pTE->TrackNumber;
  491. pT->TrackEntries.AddTail(pTE);
  492. }
  493. Tracks.AddTail(pT);
  494. Tracks.Write(pStream);
  496. if(TrackNumber == 0) TrackNumber = 1;
  498. fTracksWritten = true;
  499. }
  501. ASSERT(pPin);
  503. CAutoPtr<BlockGroup> b;
  505. {
  506. CAutoLock cAutoLock(&pPin->m_csQueue);
  507. b = pPin->m_blocks.RemoveHead();
  508. }
  510. if(b)
  511. {
  512. if(fFirstBlock)
  513. {
  514. if(b->Block.TimeCode < 0 && m_fNegative || b->Block.TimeCode > 0 && m_fPositive)
  515. firstTimeCode = b->Block.TimeCode;
  516. fFirstBlock = false;
  517. }
  519. b->Block.TimeCode -= firstTimeCode;
  520. b->Block.TimeCodeStop -= firstTimeCode;
  522. /*
  523. TRACE(_T("Muxing (%d): %I64d-%I64d dur=%I64d (c=%d, co=%dms), cnt=%d, ref=%dn"), 
  524. GetTrackNumber(pPin), 
  525. (INT64)b->Block.TimeCode, (INT64)b->Block.TimeCodeStop, (UINT64)b->BlockDuration,
  526. (int)((b->Block.TimeCode)/MAXCLUSTERTIME), (int)(b->Block.TimeCode%MAXCLUSTERTIME),
  527. b->Block.BlockData.GetCount(), (int)b->ReferenceBlock);
  528. */
  529. if(b->Block.TimeCode < SHRT_MIN /*0*/) {ASSERT(0); continue;}
  531. while((INT64)(c.TimeCode + MAXCLUSTERTIME) < b->Block.TimeCode)
  532. {
  533. if(!c.BlockGroups.IsEmpty())
  534. {
  535. sh.Attach(new SeekHead());
  536. sh->ID.Set(c.GetID()/*0x1F43B675*/);
  537. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  538. seek.SeekHeads.AddTail(sh);
  540. c.Write(pStream); // TODO: write blocks
  541. }
  543. c.TimeCode.Set(c.TimeCode + MAXCLUSTERTIME);
  544. c.BlockGroups.RemoveAll();
  545. nBlocksInCueTrack = 0;
  546. }
  548. if(b->Block.TrackNumber == TrackNumber)
  549. {
  550. nBlocksInCueTrack++;
  551. }
  553. if(b->ReferenceBlock == 0 && b->Block.TrackNumber == TrackNumber)
  554. {
  555. ULONGLONG clusterpos = GetStreamPosition(pStream) - segpos;
  556. if(lastcueclusterpos != clusterpos || lastcuetimecode + 1000 < b->Block.TimeCode)
  557. {
  558. CAutoPtr<CueTrackPosition> ctp(new CueTrackPosition());
  559. ctp->CueTrack.Set(b->Block.TrackNumber);
  560. ctp->CueClusterPosition.Set(clusterpos);
  561. if(c.BlockGroups.GetCount() > 0) ctp->CueBlockNumber.Set(nBlocksInCueTrack);
  562. CAutoPtr<CuePoint> cp(new CuePoint());
  563. cp->CueTime.Set(b->Block.TimeCode);
  564. cp->CueTrackPositions.AddTail(ctp);
  565. cue.CuePoints.AddTail(cp);
  566. lastcueclusterpos = clusterpos;
  567. lastcuetimecode = b->Block.TimeCode;
  568. }
  569. }
  571. info.Duration.Set(max(info.Duration, (float)b->Block.TimeCodeStop));
  573. m_rtCurrent = b->Block.TimeCode*10000;
  575. b->Block.TimeCode -= c.TimeCode;
  576. c.BlockGroups.AddTail(b);
  577. }
  578. }
  580. if(!c.BlockGroups.IsEmpty())
  581. {
  582. sh.Attach(new SeekHead());
  583. sh->ID.Set(c.GetID()/*0x1F43B675*/);
  584. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  585. seek.SeekHeads.AddTail(sh);
  587. c.Write(pStream);
  588. }
  590. ULONGLONG cuepos = 0;
  591. if(!cue.CuePoints.IsEmpty())
  592. {
  593. sh.Attach(new SeekHead());
  594. sh->ID.Set(cue.GetID()/*0x1C53BB6B*/);
  595. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  596. seek.SeekHeads.AddTail(sh);
  598. cue.Write(pStream);
  599. }
  601. {
  602. Tags tags;
  604. sh.Attach(new SeekHead());
  605. sh->ID.Set(tags.GetID());
  606. sh->Position.Set(GetStreamPosition(pStream) - segpos);
  607. seek.SeekHeads.AddTail(sh);
  609. tags.Write(pStream);
  610. }
  612. SetStreamPosition(pStream, voidpos);
  613. int len = (int)(voidlen - seek.Size());
  614. ASSERT(len >= 0 && len != 1);
  615. seek.Write(pStream);
  617. if(len == 0)
  618. {
  619. // nothing to do
  620. }
  621. else if(len >= 2)
  622. {
  623. for(int i = 0; i < 8; i++)
  624. {
  625. if(len >= (1<<i*7)-2 && len <= (1<<(i+1)*7)-2)
  626. {
  627. Void(len-2-i).Write(pStream);
  628. break;
  629. }
  630. }
  631. }
  633. if(abs(m_rtCurrent - (REFERENCE_TIME)info.Duration*10000) > 10000000i64)
  634. {
  635. info.Duration.Set(m_rtCurrent / 10000 + 1);
  636. }
  638. SetStreamPosition(pStream, infopos);
  639. info.Write(pStream);
  641. // TODO: write some tags
  643. m_pOutput->DeliverEndOfStream();
  645. break;
  646. }
  647. }
  649. ASSERT(0); // we should only exit via CMD_EXIT
  651. CAMThread::m_hThread = NULL;
  652. return 0;
  653. }
  655. //
  656. // CMatroskaMuxerInputPin
  657. //
  659. CMatroskaMuxerInputPin::CMatroskaMuxerInputPin(LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  660. : CBaseInputPin(NAME("CMatroskaMuxerInputPin"), pFilter, pLock, phr, pName)
  661. , m_fActive(false)
  662. , m_fEndOfStreamReceived(false)
  663. , m_rtDur(0)
  664. {
  665. }
  667. CMatroskaMuxerInputPin::~CMatroskaMuxerInputPin()
  668. {
  669. }
  671. STDMETHODIMP CMatroskaMuxerInputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  672. {
  673. CheckPointer(ppv, E_POINTER);
  675. return 
  676. __super::NonDelegatingQueryInterface(riid, ppv);
  677. }
  679. HRESULT CMatroskaMuxerInputPin::CheckMediaType(const CMediaType* pmt)
  680. {
  681. return pmt->majortype == MEDIATYPE_Video && (pmt->formattype == FORMAT_VideoInfo 
  682. || pmt->formattype == FORMAT_VideoInfo2)
  683. // || pmt->majortype == MEDIATYPE_Video && pmt->subtype == MEDIASUBTYPE_MPEG1Payload && pmt->formattype == FORMAT_MPEGVideo
  684. // || pmt->majortype == MEDIATYPE_Video && pmt->subtype == MEDIASUBTYPE_MPEG2_VIDEO && pmt->formattype == FORMAT_MPEG2_VIDEO
  685. || pmt->majortype == MEDIATYPE_Video && pmt->subtype == MEDIASUBTYPE_DiracVideo && pmt->formattype == FORMAT_DiracVideoInfo
  686. || pmt->majortype == MEDIATYPE_Audio && pmt->formattype == FORMAT_WaveFormatEx && pmt->subtype == FOURCCMap(((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag)
  687. || pmt->majortype == MEDIATYPE_Audio && pmt->subtype == MEDIASUBTYPE_Vorbis && pmt->formattype == FORMAT_VorbisFormat
  688. || pmt->majortype == MEDIATYPE_Audio && pmt->subtype == MEDIASUBTYPE_Vorbis2 && pmt->formattype == FORMAT_VorbisFormat2
  689. || pmt->majortype == MEDIATYPE_Audio && (pmt->subtype == MEDIASUBTYPE_14_4 
  690. || pmt->subtype == MEDIASUBTYPE_28_8
  691. || pmt->subtype == MEDIASUBTYPE_ATRC
  692. || pmt->subtype == MEDIASUBTYPE_COOK
  693. || pmt->subtype == MEDIASUBTYPE_DNET
  694. || pmt->subtype == MEDIASUBTYPE_SIPR) && pmt->formattype == FORMAT_WaveFormatEx
  695. || pmt->majortype == MEDIATYPE_Text && pmt->subtype == MEDIASUBTYPE_NULL && pmt->formattype == FORMAT_None
  696. || pmt->majortype == MEDIATYPE_Subtitle && pmt->formattype == FORMAT_SubtitleInfo
  697. ? S_OK
  698. : E_INVALIDARG;
  699. }
  701. HRESULT CMatroskaMuxerInputPin::BreakConnect()
  702. {
  703. HRESULT hr;
  705. if(FAILED(hr = __super::BreakConnect()))
  706. return hr;
  708. m_pTE.Free();
  710. return hr;
  711. }
  713. HRESULT CMatroskaMuxerInputPin::CompleteConnect(IPin* pPin)
  714. {
  715. HRESULT hr;
  717. if(FAILED(hr = __super::CompleteConnect(pPin)))
  718. return hr;
  720. m_rtDur = 0;
  721. CComQIPtr<IMediaSeeking> pMS;
  722. if((pMS = GetFilterFromPin(pPin)) || (pMS = pPin))
  723. pMS->GetDuration(&m_rtDur);
  725. m_pTE.Free();
  726. m_pTE.Attach(new TrackEntry());
  728. m_pTE->TrackUID.Set(rand());
  729. m_pTE->MinCache.Set(1);
  730. m_pTE->MaxCache.Set(1);
  731. m_pTE->TrackNumber.Set(((CMatroskaMuxerFilter*)m_pFilter)->GetTrackNumber(this));
  733. hr = E_FAIL;
  735. if(m_mt.majortype == MEDIATYPE_Video)
  736. {
  737. m_pTE->TrackType.Set(TrackEntry::TypeVideo);
  739. if(m_mt.formattype == FORMAT_VideoInfo 
  740. && m_mt.subtype == MEDIASUBTYPE_RV10 || m_mt.subtype == MEDIASUBTYPE_RV20
  741. || m_mt.subtype == MEDIASUBTYPE_RV30 || m_mt.subtype == MEDIASUBTYPE_RV40)
  742. {
  743. m_pTE->CodecID.Set("V_REAL/RV00");
  744. m_pTE->CodecID[9] = (CHAR)(m_mt.subtype.Data1>>16);
  746. if(m_mt.formattype == FORMAT_VideoInfo)
  747. {
  748. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)m_mt.pbFormat;
  749. if(m_mt.cbFormat > sizeof(VIDEOINFOHEADER))
  750. {
  751. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - sizeof(VIDEOINFOHEADER));
  752. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat + sizeof(VIDEOINFOHEADER), m_pTE->CodecPrivate.GetSize());
  753. }
  754. m_pTE->DefaultDuration.Set(vih->AvgTimePerFrame*100); 
  755. m_pTE->DescType = TrackEntry::DescVideo;
  756. m_pTE->v.PixelWidth.Set(vih->bmiHeader.biWidth);
  757. m_pTE->v.PixelHeight.Set(abs(vih->bmiHeader.biHeight));
  758. if(vih->AvgTimePerFrame > 0)
  759. m_pTE->v.FramePerSec.Set((float)(10000000.0 / vih->AvgTimePerFrame)); 
  760. }
  761. else if(m_mt.formattype == FORMAT_VideoInfo2)
  762. {
  763. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)m_mt.pbFormat;
  764. if(m_mt.cbFormat > sizeof(VIDEOINFOHEADER2))
  765. {
  766. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - sizeof(VIDEOINFOHEADER2));
  767. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat + sizeof(VIDEOINFOHEADER2), m_pTE->CodecPrivate.GetSize());
  768. }
  769. m_pTE->DefaultDuration.Set(vih->AvgTimePerFrame*100); 
  770. m_pTE->DescType = TrackEntry::DescVideo;
  771. m_pTE->v.PixelWidth.Set(vih->bmiHeader.biWidth);
  772. m_pTE->v.PixelHeight.Set(abs(vih->bmiHeader.biHeight));
  773. if(vih->AvgTimePerFrame > 0)
  774. m_pTE->v.FramePerSec.Set((float)(10000000.0 / vih->AvgTimePerFrame)); 
  775. m_pTE->v.DisplayWidth.Set(vih->dwPictAspectRatioX);
  776. m_pTE->v.DisplayHeight.Set(vih->dwPictAspectRatioY);
  777. }
  778. else
  779. {
  780. ASSERT(0);
  781. return hr;
  782. }
  784. hr = S_OK;
  785. }
  786. else if(m_mt.formattype == FORMAT_VideoInfo)
  787. {
  788. m_pTE->CodecID.Set("V_MS/VFW/FOURCC");
  790. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)m_mt.pbFormat;
  791. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader));
  792. memcpy(m_pTE->CodecPrivate, &vih->bmiHeader, m_pTE->CodecPrivate.GetSize());
  793. m_pTE->DefaultDuration.Set(vih->AvgTimePerFrame*100); 
  794. m_pTE->DescType = TrackEntry::DescVideo;
  795. m_pTE->v.PixelWidth.Set(vih->bmiHeader.biWidth);
  796. m_pTE->v.PixelHeight.Set(abs(vih->bmiHeader.biHeight));
  797. if(vih->AvgTimePerFrame > 0)
  798. m_pTE->v.FramePerSec.Set((float)(10000000.0 / vih->AvgTimePerFrame)); 
  800. hr = S_OK;
  801. }
  802. else if(m_mt.formattype == FORMAT_VideoInfo2)
  803. {
  804. m_pTE->CodecID.Set("V_MS/VFW/FOURCC");
  806. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)m_mt.pbFormat;
  807. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - FIELD_OFFSET(VIDEOINFOHEADER2, bmiHeader));
  808. memcpy(m_pTE->CodecPrivate, &vih->bmiHeader, m_pTE->CodecPrivate.GetSize());
  809. m_pTE->DefaultDuration.Set(vih->AvgTimePerFrame*100);
  810. m_pTE->DescType = TrackEntry::DescVideo;
  811. m_pTE->v.PixelWidth.Set(vih->bmiHeader.biWidth);
  812. m_pTE->v.PixelHeight.Set(abs(vih->bmiHeader.biHeight));
  813. m_pTE->v.DisplayWidth.Set(vih->dwPictAspectRatioX);
  814. m_pTE->v.DisplayHeight.Set(vih->dwPictAspectRatioY);
  815. if(vih->AvgTimePerFrame > 0)
  816. m_pTE->v.FramePerSec.Set((float)(10000000.0 / vih->AvgTimePerFrame)); 
  818. hr = S_OK;
  819. }
  820. else if(m_mt.formattype == FORMAT_DiracVideoInfo)
  821. {
  822. m_pTE->CodecID.Set("V_DIRAC");
  824. DIRACINFOHEADER* vih = (DIRACINFOHEADER*)m_mt.pbFormat;
  825. m_pTE->CodecPrivate.SetSize(vih->cbSequenceHeader);
  826. memcpy(m_pTE->CodecPrivate, (BYTE*)&vih->dwSequenceHeader[0], m_pTE->CodecPrivate.GetSize());
  827. m_pTE->DefaultDuration.Set(vih->hdr.AvgTimePerFrame*100);
  828. m_pTE->DescType = TrackEntry::DescVideo;
  829. m_pTE->v.PixelWidth.Set(vih->hdr.bmiHeader.biWidth);
  830. m_pTE->v.PixelHeight.Set(abs(vih->hdr.bmiHeader.biHeight));
  831. // m_pTE->v.DisplayWidth.Set(vih->dwPictAspectRatioX);
  832. // m_pTE->v.DisplayHeight.Set(vih->dwPictAspectRatioY);
  833. if(vih->hdr.AvgTimePerFrame > 0)
  834. m_pTE->v.FramePerSec.Set((float)(10000000.0 / vih->hdr.AvgTimePerFrame)); 
  836. hr = S_OK;
  837. }
  838. /*
  839. else if(m_mt.formattype == FORMAT_MPEGVideo)
  840. {
  841. m_pTE->CodecID.Set("V_DSHOW/MPEG1VIDEO"); // V_MPEG1
  843. MPEG1VIDEOINFO* pm1vi = (MPEG1VIDEOINFO*)m_mt.pbFormat;
  844. m_pTE->CodecPrivate.SetSize(m_mt.FormatLength());
  845. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat, m_pTE->CodecPrivate.GetSize());
  846. m_pTE->DefaultDuration.Set(pm1vi->hdr.AvgTimePerFrame*100);
  847. m_pTE->DescType = TrackEntry::DescVideo;
  848. m_pTE->v.PixelWidth.Set(pm1vi->hdr.bmiHeader.biWidth);
  849. m_pTE->v.PixelHeight.Set(abs(pm1vi->hdr.bmiHeader.biHeight));
  850. if(pm1vi->hdr.AvgTimePerFrame > 0)
  851. m_pTE->v.FramePerSec.Set((float)(10000000.0 / pm1vi->hdr.AvgTimePerFrame)); 
  853. hr = S_OK;
  854. }
  855. else if(m_mt.formattype == FORMAT_MPEG2_VIDEO)
  856. {
  857. m_pTE->CodecID.Set("V_DSHOW/MPEG2VIDEO"); // V_MPEG2
  859. MPEG2VIDEOINFO* pm2vi = (MPEG2VIDEOINFO*)m_mt.pbFormat;
  860. m_pTE->CodecPrivate.SetSize(m_mt.FormatLength());
  861. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat, m_pTE->CodecPrivate.GetSize());
  862. m_pTE->DefaultDuration.Set(pm2vi->hdr.AvgTimePerFrame*100);
  863. m_pTE->DescType = TrackEntry::DescVideo;
  864. m_pTE->v.PixelWidth.Set(pm2vi->hdr.bmiHeader.biWidth);
  865. m_pTE->v.PixelHeight.Set(abs(pm2vi->hdr.bmiHeader.biHeight));
  866. if(pm2vi->hdr.AvgTimePerFrame > 0)
  867. m_pTE->v.FramePerSec.Set((float)(10000000.0 / pm2vi->hdr.AvgTimePerFrame)); 
  869. hr = S_OK;
  870. }
  871. */
  872. }
  873. else if(m_mt.majortype == MEDIATYPE_Audio)
  874. {
  875. m_pTE->TrackType.Set(TrackEntry::TypeAudio);
  877. if(m_mt.formattype == FORMAT_WaveFormatEx 
  878. && ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_AAC
  879. && m_mt.cbFormat >= sizeof(WAVEFORMATEX)+2)
  880. {
  881. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  882. BYTE* p = (BYTE*)(wfe+1);
  884. DWORD nSamplesPerSec = wfe->nSamplesPerSec;
  886. int profile = (p[0]>>3)-1;
  887. int rate1 = ((p[0]&7)<<1)|(p[1]>>7);
  888. int channels = ((p[1]>>3)&15);
  889. int exttype = 0;
  890. int rate2 = rate1;
  892. if(wfe->cbSize >= 5)
  893. {
  894. profile = 4;
  896. exttype = (p[2]<<3)|(p[3]>>5);
  897. ASSERT(exttype == 0x2B7);
  898. ASSERT((p[3]&31) == 5);
  899. ASSERT((p[4]>>7) == 1);
  900. rate2 = ((p[4]>>3)&15);
  902. if(rate2 < rate1)
  903. {
  904. m_pTE->a.OutputSamplingFrequency.Set((float)nSamplesPerSec);
  905. nSamplesPerSec /= 2;
  906. }
  907. }
  909. switch(profile)
  910. {
  911. default:
  912. case 0: m_pTE->CodecID.Set("A_AAC/MPEG2/MAIN"); break;
  913. case 1: m_pTE->CodecID.Set("A_AAC/MPEG2/LC"); break;
  914. case 2: m_pTE->CodecID.Set("A_AAC/MPEG2/SSR"); break;
  915. case 3: m_pTE->CodecID.Set("A_AAC/MPEG4/LTP"); break;
  916. case 4: m_pTE->CodecID.Set("A_AAC/MPEG4/LC/SBR"); break;
  917. }
  919. ASSERT(channels == wfe->nChannels);
  921. m_pTE->DescType = TrackEntry::DescAudio;
  922. m_pTE->a.SamplingFrequency.Set((float)nSamplesPerSec);
  923. m_pTE->a.Channels.Set(channels);
  924. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  926. hr = S_OK;
  927. }
  928. else if(m_mt.formattype == FORMAT_WaveFormatEx 
  929. && ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_DOLBY_AC3)
  930. {
  931. m_pTE->CodecID.Set("A_AC3");
  933. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  934. m_pTE->DescType = TrackEntry::DescAudio;
  935. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  936. m_pTE->a.Channels.Set(wfe->nChannels);
  937. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  939. hr = S_OK;
  940. }
  941. else if(m_mt.formattype == FORMAT_WaveFormatEx 
  942. && ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_DVD_DTS)
  943. {
  944. m_pTE->CodecID.Set("A_DTS");
  946. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  947. m_pTE->DescType = TrackEntry::DescAudio;
  948. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  949. m_pTE->a.Channels.Set(wfe->nChannels);
  950. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  952. hr = S_OK;
  953. }
  954. else if(m_mt.formattype == FORMAT_WaveFormatEx
  955. && ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_FLAC)
  956. {
  957. m_pTE->CodecID.Set("A_FLAC");
  959. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  960. m_pTE->DescType = TrackEntry::DescAudio;
  961. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  962. m_pTE->a.Channels.Set(wfe->nChannels);
  963. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  965. if(wfe->cbSize)
  966. {
  967. m_pTE->CodecPrivate.SetSize(wfe->cbSize);
  968. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat + sizeof(WAVEFORMATEX), wfe->cbSize);
  969. }
  971. hr = S_OK;
  972. }
  973. else if(m_mt.formattype == FORMAT_WaveFormatEx 
  974. && (m_mt.subtype == MEDIASUBTYPE_14_4
  975. || m_mt.subtype == MEDIASUBTYPE_28_8
  976. || m_mt.subtype == MEDIASUBTYPE_ATRC
  977. || m_mt.subtype == MEDIASUBTYPE_COOK
  978. || m_mt.subtype == MEDIASUBTYPE_DNET
  979. || m_mt.subtype == MEDIASUBTYPE_SIPR))
  980. {
  981. CStringA id;
  982. id.Format("A_REAL/%c%c%c%c", 
  983. (char)((m_mt.subtype.Data1>>0)&0xff),
  984. (char)((m_mt.subtype.Data1>>8)&0xff),
  985. (char)((m_mt.subtype.Data1>>16)&0xff),
  986. (char)((m_mt.subtype.Data1>>24)&0xff));
  988. m_pTE->CodecID.Set(id);
  990. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  991. DWORD cbSize = sizeof(WAVEFORMATEX) + wfe->cbSize;
  992. if(m_mt.cbFormat > cbSize)
  993. {
  994. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - cbSize);
  995. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat + cbSize, m_pTE->CodecPrivate.GetSize());
  996. }
  997. m_pTE->DescType = TrackEntry::DescAudio;
  998. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  999. m_pTE->a.Channels.Set(wfe->nChannels);
  1000. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  1002. hr = S_OK;
  1003. }
  1004. else if(m_mt.formattype == FORMAT_WaveFormatEx
  1005. && ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_PCM)
  1006. {
  1007. m_pTE->CodecID.Set("A_PCM/INT/LIT");
  1009. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  1010. m_pTE->DescType = TrackEntry::DescAudio;
  1011. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  1012. m_pTE->a.Channels.Set(wfe->nChannels);
  1013. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  1015. hr = S_OK;
  1016. }
  1017. else if(m_mt.formattype == FORMAT_WaveFormatEx)
  1018. {
  1019. m_pTE->CodecID.Set("A_MS/ACM");
  1021. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  1022. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat);
  1023. memcpy(m_pTE->CodecPrivate, wfe, m_pTE->CodecPrivate.GetSize());
  1024. m_pTE->DescType = TrackEntry::DescAudio;
  1025. m_pTE->a.SamplingFrequency.Set((float)wfe->nSamplesPerSec);
  1026. m_pTE->a.Channels.Set(wfe->nChannels);
  1027. m_pTE->a.BitDepth.Set(wfe->wBitsPerSample);
  1029. hr = S_OK;
  1030. }
  1031. else if(m_mt.formattype == FORMAT_VorbisFormat)
  1032. {
  1033. m_pTE->CodecID.Set("A_VORBIS");
  1035. VORBISFORMAT* pvf = (VORBISFORMAT*)m_mt.pbFormat;
  1036. m_pTE->DescType = TrackEntry::DescAudio;
  1037. m_pTE->a.SamplingFrequency.Set((float)pvf->nSamplesPerSec);
  1038. m_pTE->a.Channels.Set(pvf->nChannels);
  1040. // m_pTE->CodecPrivate will be filled later
  1042. hr = S_OK;
  1043. }
  1044. else if(m_mt.formattype == FORMAT_VorbisFormat2)
  1045. {
  1046. m_pTE->CodecID.Set("A_VORBIS");
  1048. VORBISFORMAT2* pvf2 = (VORBISFORMAT2*)m_mt.pbFormat;
  1049. m_pTE->DescType = TrackEntry::DescAudio;
  1050. m_pTE->a.SamplingFrequency.Set((float)pvf2->SamplesPerSec);
  1051. m_pTE->a.Channels.Set(pvf2->Channels);
  1052. m_pTE->a.BitDepth.Set(pvf2->BitsPerSample);
  1054. int len = 1;
  1055. for(int i = 0; i < 2; i++) len += pvf2->HeaderSize[i]/255 + 1;
  1056. for(int i = 0; i < 3; i++) len += pvf2->HeaderSize[i];
  1057. m_pTE->CodecPrivate.SetSize(len);
  1059. BYTE* src = (BYTE*)m_mt.pbFormat + sizeof(VORBISFORMAT2);
  1060. BYTE* dst = m_pTE->CodecPrivate.GetData();
  1062. *dst++ = 2;
  1063. for(int i = 0; i < 2; i++)
  1064. for(int len = pvf2->HeaderSize[i]; len >= 0; len -= 255)
  1065. *dst++ = min(len, 255);
  1067. memcpy(dst, src, pvf2->HeaderSize[0]); 
  1068. dst += pvf2->HeaderSize[0]; 
  1069. src += pvf2->HeaderSize[0];
  1070. memcpy(dst, src, pvf2->HeaderSize[1]); 
  1071. dst += pvf2->HeaderSize[1]; 
  1072. src += pvf2->HeaderSize[1];
  1073. memcpy(dst, src, pvf2->HeaderSize[2]); 
  1074. dst += pvf2->HeaderSize[2]; 
  1075. src += pvf2->HeaderSize[2];
  1077. ASSERT(src <= m_mt.pbFormat + m_mt.cbFormat);
  1078. ASSERT(dst <= m_pTE->CodecPrivate.GetData() + m_pTE->CodecPrivate.GetSize());
  1080. hr = S_OK;
  1081. }
  1082. }
  1083. else if(m_mt.majortype == MEDIATYPE_Text)
  1084. {
  1085. m_pTE->TrackType.Set(TrackEntry::TypeSubtitle);
  1087. if(m_mt.formattype == FORMAT_None)
  1088. {
  1089. m_pTE->CodecID.Set("S_TEXT/ASCII");
  1090. hr = S_OK;
  1091. }
  1092. }
  1093. else if(m_mt.majortype == MEDIATYPE_Subtitle)
  1094. {
  1095. m_pTE->TrackType.Set(TrackEntry::TypeSubtitle);
  1097. m_pTE->CodecID.Set(
  1098. m_mt.subtype == MEDIASUBTYPE_UTF8 ? "S_TEXT/UTF8" :
  1099. m_mt.subtype == MEDIASUBTYPE_SSA ? "S_TEXT/SSA" :
  1100. m_mt.subtype == MEDIASUBTYPE_ASS ? "S_TEXT/ASS" :
  1101. m_mt.subtype == MEDIASUBTYPE_USF ? "S_TEXT/USF" :
  1102. m_mt.subtype == MEDIASUBTYPE_VOBSUB ? "S_VOBSUB" :
  1103. "");
  1105. if(!m_pTE->CodecID.IsEmpty())
  1106. {
  1107. hr = S_OK;
  1109. SUBTITLEINFO* psi = (SUBTITLEINFO*)m_mt.pbFormat;
  1110. if(psi->dwOffset)
  1111. {
  1112. m_pTE->CodecPrivate.SetSize(m_mt.cbFormat - psi->dwOffset);
  1113. memcpy(m_pTE->CodecPrivate, m_mt.pbFormat + psi->dwOffset, m_pTE->CodecPrivate.GetSize());
  1114. }
  1115. }
  1116. }
  1118. if(S_OK == hr)
  1119. {
  1120. ((CMatroskaMuxerFilter*)m_pFilter)->AddInput();
  1121. }
  1123. return hr;
  1124. }
  1126. HRESULT CMatroskaMuxerInputPin::Active()
  1127. {
  1128. m_fActive = true;
  1129. m_rtLastStart = m_rtLastStop = -1;
  1130. m_fEndOfStreamReceived = false;
  1131. return __super::Active();
  1132. }
  1134. HRESULT CMatroskaMuxerInputPin::Inactive()
  1135. {
  1136. m_fActive = false;
  1137. CAutoLock cAutoLock(&m_csQueue);
  1138. m_blocks.RemoveAll();
  1139. m_pVorbisHdrs.RemoveAll();
  1140. return __super::Inactive();
  1141. }
  1143. STDMETHODIMP CMatroskaMuxerInputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  1144. {
  1145. CAutoLock cAutoLock(&m_csReceive);
  1146. return __super::NewSegment(tStart, tStop, dRate);
  1147. }
  1149. STDMETHODIMP CMatroskaMuxerInputPin::BeginFlush()
  1150. {
  1151. return __super::BeginFlush();
  1152. }
  1154. STDMETHODIMP CMatroskaMuxerInputPin::EndFlush()
  1155. {
  1156. return __super::EndFlush();
  1157. }
  1159. STDMETHODIMP CMatroskaMuxerInputPin::Receive(IMediaSample* pSample)
  1160. {
  1161. if(m_fEndOfStreamReceived) {/*ASSERT(0);*/ return S_FALSE;}
  1163. CAutoLock cAutoLock(&m_csReceive);
  1165. while(m_fActive)
  1166. {
  1167. {
  1168. CAutoLock cAutoLock2(&m_csQueue);
  1169. if(m_blocks.GetCount() < MAXBLOCKS)
  1170. break;
  1171. }
  1173. Sleep(1);
  1174. }
  1176. if(!m_fActive) return S_FALSE;
  1178. HRESULT hr;
  1180. if(FAILED(hr = __super::Receive(pSample)))
  1181. return hr;
  1183. BYTE* pData = NULL;
  1184. pSample->GetPointer(&pData);
  1186. long len = pSample->GetActualDataLength();
  1188. REFERENCE_TIME rtStart = -1, rtStop = -1;
  1189. hr = pSample->GetTime(&rtStart, &rtStop);
  1191. if(FAILED(hr) || rtStart == -1 || rtStop == -1)
  1192. {
  1193. TRACE(_T("No timestamp was set on the sample!!!"));
  1194. m_pFilter->NotifyEvent(EC_ERRORABORT, VFW_E_SAMPLE_TIME_NOT_SET, 0);
  1195. return VFW_E_SAMPLE_TIME_NOT_SET;
  1196. }
  1198. // rtStart += m_tStart;
  1199. // rtStop += m_tStart;
  1201. /**/
  1202. TRACE(_T("Received (%d): %I64d-%I64d (c=%d, co=%dms), len=%d, d%d p%d s%dn"), 
  1203. ((CMatroskaMuxerFilter*)m_pFilter)->GetTrackNumber(this), 
  1204. rtStart, rtStop, (int)((rtStart/10000)/MAXCLUSTERTIME), (int)((rtStart/10000)%MAXCLUSTERTIME),
  1205. len,
  1206. pSample->IsDiscontinuity() == S_OK ? 1 : 0,
  1207. pSample->IsPreroll() == S_OK ? 1 : 0,
  1208. pSample->IsSyncPoint() == S_OK ? 1 : 0);
  1210. if(m_mt.subtype == MEDIASUBTYPE_Vorbis && m_pVorbisHdrs.GetCount() < 3)
  1211. {
  1212. CAutoPtr<CBinary> data(new CBinary(0));
  1213. data->SetSize(len);
  1214. memcpy(data->GetData(), pData, len);
  1215. m_pVorbisHdrs.Add(data);
  1217. if(m_pVorbisHdrs.GetCount() == 3)
  1218. {
  1219. int len = 1;
  1220. for(int i = 0; i < 2; i++) len += m_pVorbisHdrs[i]->GetSize()/255 + 1;
  1221. for(int i = 0; i < 3; i++) len += m_pVorbisHdrs[i]->GetSize();
  1222. m_pTE->CodecPrivate.SetSize(len);
  1224. BYTE* dst = m_pTE->CodecPrivate.GetData();
  1226. *dst++ = 2;
  1227. for(int i = 0; i < 2; i++)
  1228. for(int len = m_pVorbisHdrs[i]->GetSize(); len >= 0; len -= 255)
  1229. *dst++ = min(len, 255);
  1231. for(int i = 0; i < 3; i++)
  1232. {
  1233. memcpy(dst, m_pVorbisHdrs[i]->GetData(), m_pVorbisHdrs[i]->GetSize());
  1234. dst += m_pVorbisHdrs[i]->GetSize(); 
  1235. }
  1236. }
  1238. return S_OK;
  1239. }
  1241. if(m_mt.formattype == FORMAT_WaveFormatEx 
  1242. && (((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_PCM
  1243. || ((WAVEFORMATEX*)m_mt.pbFormat)->wFormatTag == WAVE_FORMAT_MPEGLAYER3))
  1244. pSample->SetSyncPoint(TRUE); // HACK: some capture filters don't set this
  1246. CAutoPtr<BlockGroup> b(new BlockGroup());
  1247. /*
  1248. // TODO: test this with a longer capture (pcm, mp3)
  1249. if(S_OK == pSample->IsSyncPoint() && rtStart < m_rtLastStart)
  1250. {
  1251. TRACE(_T("!!! timestamp went backwards, dropping this frame !!! rtStart (%I64) < m_rtLastStart (%I64)"), rtStart, m_rtLastStart);
  1252. return S_OK;
  1253. }
  1254. */
  1255. if((S_OK != pSample->IsSyncPoint() || m_rtLastStart == rtStart) && m_rtLastStart >= 0 /*&& m_rtLastStart < rtStart*/)
  1256. {
  1257. ASSERT(m_rtLastStart - rtStart <= 0);
  1258. REFERENCE_TIME rtDiff = m_rtLastStart - rtStart;
  1259. b->ReferenceBlock.Set((rtDiff + (rtDiff >= 0 ? 5000 : -5000)) / 10000);
  1260. }
  1262. b->Block.TrackNumber = ((CMatroskaMuxerFilter*)m_pFilter)->GetTrackNumber(this);
  1264. b->Block.TimeCode = (rtStart + 5000) / 10000;
  1265. b->Block.TimeCodeStop = (rtStop + 5000) / 10000;
  1267. if(m_pTE->TrackType == TrackEntry::TypeSubtitle)
  1268. {
  1269. b->BlockDuration.Set((rtStop - rtStart + 5000) / 10000);
  1270. }
  1272. CAutoPtr<CBinary> data(new CBinary(0));
  1273. data->SetSize(len);
  1274. memcpy(data->GetData(), pData, len);
  1275. b->Block.BlockData.AddTail(data);
  1277. CAutoLock cAutoLock2(&m_csQueue);
  1278. m_blocks.AddTail(b); // TODO: lacing for audio
  1280. m_rtLastStart = rtStart;
  1281. m_rtLastStop = rtStop;
  1283. return S_OK;
  1284. }
  1286. STDMETHODIMP CMatroskaMuxerInputPin::EndOfStream()
  1287. {
  1288. HRESULT hr;
  1290. if(FAILED(hr = __super::EndOfStream()))
  1291. return hr;
  1293. CAutoLock cAutoLock(&m_csQueue);
  1295. m_fEndOfStreamReceived = true;
  1297. return hr;
  1298. }
  1300. //
  1301. // CMatroskaMuxerOutputPin
  1302. //
  1304. CMatroskaMuxerOutputPin::CMatroskaMuxerOutputPin(TCHAR* pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  1305. : CBaseOutputPin(pName, pFilter, pLock, phr, L"Output")
  1306. {
  1307. }
  1309. CMatroskaMuxerOutputPin::~CMatroskaMuxerOutputPin()
  1310. {
  1311. }
  1313. STDMETHODIMP CMatroskaMuxerOutputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1314. {
  1315. CheckPointer(ppv, E_POINTER);
  1317. return 
  1318. __super::NonDelegatingQueryInterface(riid, ppv);
  1319. }
  1321. HRESULT CMatroskaMuxerOutputPin::DecideBufferSize(IMemAllocator* pAlloc, ALLOCATOR_PROPERTIES* pProperties)
  1322. {
  1323.     ASSERT(pAlloc);
  1324.     ASSERT(pProperties);
  1326.     HRESULT hr = NOERROR;
  1328. pProperties->cBuffers = 1;
  1329. pProperties->cbBuffer = 1;
  1331.     ALLOCATOR_PROPERTIES Actual;
  1332.     if(FAILED(hr = pAlloc->SetProperties(pProperties, &Actual))) return hr;
  1334.     if(Actual.cbBuffer < pProperties->cbBuffer) return E_FAIL;
  1335.     ASSERT(Actual.cBuffers == pProperties->cBuffers);
  1337.     return NOERROR;
  1338. }
  1340. HRESULT CMatroskaMuxerOutputPin::CheckMediaType(const CMediaType* pmt)
  1341. {
  1342. return pmt->majortype == MEDIATYPE_Stream && pmt->subtype == MEDIASUBTYPE_Matroska
  1343. ? S_OK
  1344. : E_INVALIDARG;
  1345. }
  1347. HRESULT CMatroskaMuxerOutputPin::GetMediaType(int iPosition, CMediaType* pmt)
  1348. {
  1349.     CAutoLock cAutoLock(m_pLock);
  1351. if(iPosition < 0) return E_INVALIDARG;
  1352. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  1354. pmt->ResetFormatBuffer();
  1355. pmt->InitMediaType();
  1356. pmt->majortype = MEDIATYPE_Stream;
  1357. pmt->subtype = MEDIASUBTYPE_Matroska;
  1358. pmt->formattype = FORMAT_None;
  1360. return S_OK;
  1361. }
  1363. STDMETHODIMP CMatroskaMuxerOutputPin::Notify(IBaseFilter* pSender, Quality q)
  1364. {
  1365. return E_NOTIMPL;
  1366. }