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

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

多媒体编程

开发平台：

Visual C++

BaseSplitter.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 "......DSUtilDSUtil.h"
  24. #include <initguid.h>
  25. #include "........includemoreuuids.h"
  26. #include "........includematroskamatroska.h"
  27. #include "....switcherAudioSwitcherAudioSwitcher.h"
  28. #include "BaseSplitter.h"
  30. #pragma warning(disable: 4355)
  32. #define MINPACKETS 10
  33. #define MINPACKETSIZE 100*1024
  34. #define MAXPACKETS 10000
  35. #define MAXPACKETSIZE 1024*1024*5
  37. //
  38. // CPacketQueue
  39. //
  41. CPacketQueue::CPacketQueue() : m_size(0)
  42. {
  43. }
  45. void CPacketQueue::Add(CAutoPtr<Packet> p)
  46. {
  47. CAutoLock cAutoLock(this);
  49. if(p)
  50. {
  51. m_size += p->GetSize();
  53. if(p->bAppendable && !p->bDiscontinuity && !p->pmt && GetCount() > 0
  54. && p->rtStart == Packet::INVALID_TIME
  55. && GetTail()->rtStart != Packet::INVALID_TIME)
  56. {
  57. Packet* tail = GetTail();
  58. int oldsize = tail->pData.GetSize();
  59. int newsize = tail->pData.GetSize() + p->pData.GetSize();
  60. tail->pData.SetSize(newsize, max(1024, newsize)); // doubles the reserved buffer size
  61. memcpy(tail->pData.GetData() + oldsize, p->pData.GetData(), p->pData.GetSize());
  62. return;
  63. }
  64. }
  66. AddTail(p);
  67. }
  69. CAutoPtr<Packet> CPacketQueue::Remove()
  70. {
  71. CAutoLock cAutoLock(this);
  72. ASSERT(__super::GetCount() > 0);
  73. CAutoPtr<Packet> p = RemoveHead();
  74. if(p) m_size -= p->GetSize();
  75. return p;
  76. }
  78. void CPacketQueue::RemoveAll()
  79. {
  80. CAutoLock cAutoLock(this);
  81. m_size = 0;
  82. __super::RemoveAll();
  83. }
  85. int CPacketQueue::GetCount()
  86. {
  87. CAutoLock cAutoLock(this); 
  88. return __super::GetCount();
  89. }
  91. int CPacketQueue::GetSize()
  92. {
  93. CAutoLock cAutoLock(this); 
  94. return m_size;
  95. }
  97. //
  98. // CBaseSplitterInputPin
  99. //
  101. CBaseSplitterInputPin::CBaseSplitterInputPin(TCHAR* pName, CBaseSplitterFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  102. : CBasePin(pName, pFilter, pLock, phr, L"Input", PINDIR_INPUT)
  103. {
  104. }
  106. CBaseSplitterInputPin::~CBaseSplitterInputPin()
  107. {
  108. }
  110. HRESULT CBaseSplitterInputPin::GetAsyncReader(IAsyncReader** ppAsyncReader)
  111. {
  112. CheckPointer(ppAsyncReader, E_POINTER);
  113. *ppAsyncReader = NULL;
  114. CheckPointer(m_pAsyncReader, VFW_E_NOT_CONNECTED);
  115. (*ppAsyncReader = m_pAsyncReader)->AddRef();
  116. return S_OK;
  117. }
  119. STDMETHODIMP CBaseSplitterInputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  120. {
  121. CheckPointer(ppv, E_POINTER);
  123. return 
  124. __super::NonDelegatingQueryInterface(riid, ppv);
  125. }
  127. HRESULT CBaseSplitterInputPin::CheckMediaType(const CMediaType* pmt)
  128. {
  129. return S_OK;
  130. /*
  131. return pmt->majortype == MEDIATYPE_Stream
  132. ? S_OK
  133. : E_INVALIDARG;
  134. */
  135. }
  137. HRESULT CBaseSplitterInputPin::CheckConnect(IPin* pPin)
  138. {
  139. HRESULT hr;
  140. if(FAILED(hr = __super::CheckConnect(pPin)))
  141. return hr;
  143. return CComQIPtr<IAsyncReader>(pPin) ? S_OK : E_NOINTERFACE;
  144. }
  146. HRESULT CBaseSplitterInputPin::BreakConnect()
  147. {
  148. HRESULT hr;
  150. if(FAILED(hr = __super::BreakConnect()))
  151. return hr;
  153. if(FAILED(hr = ((CBaseSplitterFilter*)m_pFilter)->BreakConnect(PINDIR_INPUT, this)))
  154. return hr;
  156. m_pAsyncReader.Release();
  158. return S_OK;
  159. }
  161. HRESULT CBaseSplitterInputPin::CompleteConnect(IPin* pPin)
  162. {
  163. HRESULT hr;
  165. if(FAILED(hr = __super::CompleteConnect(pPin)))
  166. return hr;
  168. CheckPointer(pPin, E_POINTER);
  169. m_pAsyncReader = pPin;
  170. CheckPointer(m_pAsyncReader, E_NOINTERFACE);
  172. if(FAILED(hr = ((CBaseSplitterFilter*)m_pFilter)->CompleteConnect(PINDIR_INPUT, this)))
  173. return hr;
  175. return S_OK;
  176. }
  178. STDMETHODIMP CBaseSplitterInputPin::BeginFlush()
  179. {
  180. return E_UNEXPECTED;
  181. }
  183. STDMETHODIMP CBaseSplitterInputPin::EndFlush()
  184. {
  185. return E_UNEXPECTED;
  186. }
  188. //
  189. // CBaseSplitterOutputPin
  190. //
  192. CBaseSplitterOutputPin::CBaseSplitterOutputPin(CArray<CMediaType>& mts, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr, int nBuffers)
  193. : CBaseOutputPin(NAME("CBaseSplitterOutputPin"), pFilter, pLock, phr, pName)
  194. , m_hrDeliver(S_OK) // just in case it were asked before the worker thread could be created and reset it
  195. , m_fFlushing(false)
  196. , m_eEndFlush(TRUE)
  197. {
  198. m_mts.Copy(mts);
  199. m_nBuffers = max(nBuffers, 1);
  200. memset(&m_brs, 0, sizeof(m_brs));
  201. m_brs.rtLastDeliverTime = Packet::INVALID_TIME;
  202. }
  204. CBaseSplitterOutputPin::CBaseSplitterOutputPin(LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr, int nBuffers)
  205. : CBaseOutputPin(NAME("CBaseSplitterOutputPin"), pFilter, pLock, phr, pName)
  206. , m_hrDeliver(S_OK) // just in case it were asked before the worker thread could be created and reset it
  207. , m_fFlushing(false)
  208. , m_eEndFlush(TRUE)
  209. {
  210. m_nBuffers = max(nBuffers, 1);
  211. memset(&m_brs, 0, sizeof(m_brs));
  212. m_brs.rtLastDeliverTime = Packet::INVALID_TIME;
  213. }
  215. CBaseSplitterOutputPin::~CBaseSplitterOutputPin()
  216. {
  217. }
  219. STDMETHODIMP CBaseSplitterOutputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  220. {
  221. CheckPointer(ppv, E_POINTER);
  223. return 
  224. // riid == __uuidof(IMediaSeeking) ? m_pFilter->QueryInterface(riid, ppv) : 
  225. QI(IMediaSeeking)
  226. QI(IPropertyBag)
  227. QI(IPropertyBag2)
  228. QI(IDSMPropertyBag)
  229. QI(IBitRateInfo)
  230. __super::NonDelegatingQueryInterface(riid, ppv);
  231. }
  233. HRESULT CBaseSplitterOutputPin::SetName(LPCWSTR pName)
  234. {
  235. CheckPointer(pName, E_POINTER);
  236. if(m_pName) delete [] m_pName;
  237. m_pName = new WCHAR[wcslen(pName)+1];
  238. CheckPointer(m_pName, E_OUTOFMEMORY);
  239. wcscpy(m_pName, pName);
  240. return S_OK;
  241. }
  243. HRESULT CBaseSplitterOutputPin::DecideBufferSize(IMemAllocator* pAlloc, ALLOCATOR_PROPERTIES* pProperties)
  244. {
  245.     ASSERT(pAlloc);
  246.     ASSERT(pProperties);
  248.     HRESULT hr = NOERROR;
  250. pProperties->cBuffers = m_nBuffers;
  251. pProperties->cbBuffer = max(m_mt.lSampleSize, 1);
  253.     ALLOCATOR_PROPERTIES Actual;
  254.     if(FAILED(hr = pAlloc->SetProperties(pProperties, &Actual))) return hr;
  256.     if(Actual.cbBuffer < pProperties->cbBuffer) return E_FAIL;
  257.     ASSERT(Actual.cBuffers == pProperties->cBuffers);
  259.     return NOERROR;
  260. }
  262. HRESULT CBaseSplitterOutputPin::CheckMediaType(const CMediaType* pmt)
  263. {
  264. for(int i = 0; i < m_mts.GetCount(); i++)
  265. {
  266. if(*pmt == m_mts[i])
  267. return S_OK;
  268. }
  270. return E_INVALIDARG;
  271. }
  273. HRESULT CBaseSplitterOutputPin::GetMediaType(int iPosition, CMediaType* pmt)
  274. {
  275.     CAutoLock cAutoLock(m_pLock);
  277. if(iPosition < 0) return E_INVALIDARG;
  278. if(iPosition >= m_mts.GetCount()) return VFW_S_NO_MORE_ITEMS;
  280. *pmt = m_mts[iPosition];
  282. return S_OK;
  283. }
  285. STDMETHODIMP CBaseSplitterOutputPin::Notify(IBaseFilter* pSender, Quality q)
  286. {
  287. return E_NOTIMPL;
  288. }
  290. //
  292. HRESULT CBaseSplitterOutputPin::Active()
  293. {
  294.     CAutoLock cAutoLock(m_pLock);
  296. if(m_Connected) 
  297. Create();
  299. return __super::Active();
  300. }
  302. HRESULT CBaseSplitterOutputPin::Inactive()
  303. {
  304.     CAutoLock cAutoLock(m_pLock);
  306. if(ThreadExists())
  307. CallWorker(CMD_EXIT);
  309. return __super::Inactive();
  310. }
  312. HRESULT CBaseSplitterOutputPin::DeliverBeginFlush()
  313. {
  314. m_eEndFlush.Reset();
  315. m_fFlushed = false;
  316. m_fFlushing = true;
  317. m_hrDeliver = S_FALSE;
  318. m_queue.RemoveAll();
  319. HRESULT hr = IsConnected() ? GetConnected()->BeginFlush() : S_OK;
  320. if(S_OK != hr) m_eEndFlush.Set();
  321. return(hr);
  322. }
  324. HRESULT CBaseSplitterOutputPin::DeliverEndFlush()
  325. {
  326. if(!ThreadExists()) return S_FALSE;
  327. HRESULT hr = IsConnected() ? GetConnected()->EndFlush() : S_OK;
  328. m_hrDeliver = S_OK;
  329. m_fFlushing = false;
  330. m_fFlushed = true;
  331. m_eEndFlush.Set();
  332. return hr;
  333. }
  335. HRESULT CBaseSplitterOutputPin::DeliverNewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  336. {
  337. m_brs.rtLastDeliverTime = Packet::INVALID_TIME;
  338. if(m_fFlushing) return S_FALSE;
  339. m_rtStart = tStart;
  340. if(!ThreadExists()) return S_FALSE;
  341. HRESULT hr = __super::DeliverNewSegment(tStart, tStop, dRate);
  342. if(S_OK != hr) return hr;
  343. MakeISCRHappy();
  344. return hr;
  345. }
  347. int CBaseSplitterOutputPin::QueueCount()
  348. {
  349. return m_queue.GetCount();
  350. }
  352. int CBaseSplitterOutputPin::QueueSize()
  353. {
  354. return m_queue.GetSize();
  355. }
  357. HRESULT CBaseSplitterOutputPin::QueueEndOfStream()
  358. {
  359. return QueuePacket(CAutoPtr<Packet>()); // NULL means EndOfStream
  360. }
  362. HRESULT CBaseSplitterOutputPin::QueuePacket(CAutoPtr<Packet> p)
  363. {
  364. if(!ThreadExists()) return S_FALSE;
  366. while(S_OK == m_hrDeliver 
  367. && (!((CBaseSplitterFilter*)m_pFilter)->IsAnyPinDrying()
  368. || m_queue.GetSize() > MAXPACKETSIZE*100))
  369. Sleep(1);
  371. if(S_OK != m_hrDeliver)
  372. return m_hrDeliver;
  374. m_queue.Add(p);
  376. return m_hrDeliver;
  377. }
  379. bool CBaseSplitterOutputPin::IsDiscontinuous()
  380. {
  381. return m_mt.majortype == MEDIATYPE_Text
  382. || m_mt.majortype == MEDIATYPE_ScriptCommand
  383. || m_mt.majortype == MEDIATYPE_Subtitle 
  384. || m_mt.subtype == MEDIASUBTYPE_DVD_SUBPICTURE 
  385. || m_mt.subtype == MEDIASUBTYPE_CVD_SUBPICTURE 
  386. || m_mt.subtype == MEDIASUBTYPE_SVCD_SUBPICTURE;
  387. }
  389. bool CBaseSplitterOutputPin::IsActive()
  390. {
  391. CComPtr<IPin> pPin = this;
  392. do
  393. {
  394. CComPtr<IPin> pPinTo;
  395. CComQIPtr<IStreamSwitcherInputPin> pSSIP;
  396. if(S_OK == pPin->ConnectedTo(&pPinTo) && (pSSIP = pPinTo) && !pSSIP->IsActive())
  397. return(false);
  398. pPin = GetFirstPin(GetFilterFromPin(pPinTo), PINDIR_OUTPUT);
  399. }
  400. while(pPin);
  402. return(true);
  403. }
  405. DWORD CBaseSplitterOutputPin::ThreadProc()
  406. {
  407. m_hrDeliver = S_OK;
  408. m_fFlushing = m_fFlushed = false;
  409. m_eEndFlush.Set();
  411. while(1)
  412. {
  413. Sleep(1);
  415. DWORD cmd;
  416. if(CheckRequest(&cmd))
  417. {
  418. m_hThread = NULL;
  419. cmd = GetRequest();
  420. Reply(S_OK);
  421. ASSERT(cmd == CMD_EXIT);
  422. return 0;
  423. }
  425. int cnt = 0;
  426. do
  427. {
  428. CAutoPtr<Packet> p;
  430. {
  431. CAutoLock cAutoLock(&m_queue);
  432. if((cnt = m_queue.GetCount()) > 0)
  433. p = m_queue.Remove();
  434. }
  436. if(S_OK == m_hrDeliver && cnt > 0)
  437. {
  438. ASSERT(!m_fFlushing);
  440. m_fFlushed = false;
  442. // flushing can still start here, to release a blocked deliver call
  444. HRESULT hr = p 
  445. ? DeliverPacket(p) 
  446. : DeliverEndOfStream();
  448. m_eEndFlush.Wait(); // .. so we have to wait until it is done
  450. if(hr != S_OK && !m_fFlushed) // and only report the error in m_hrDeliver if we didn't flush the stream
  451. {
  452. // CAutoLock cAutoLock(&m_csQueueLock);
  453. m_hrDeliver = hr;
  454. break;
  455. }
  456. }
  457. }
  458. while(--cnt > 0);
  459. }
  460. }
  462. HRESULT CBaseSplitterOutputPin::DeliverPacket(CAutoPtr<Packet> p)
  463. {
  464. HRESULT hr;
  466. INT_PTR nBytes = p->pData.GetCount();
  468. if(nBytes == 0)
  469. {
  470. return S_OK;
  471. }
  473. m_brs.nBytesSinceLastDeliverTime += nBytes;
  475. if(p->rtStart != Packet::INVALID_TIME)
  476. {
  477. if(m_brs.rtLastDeliverTime == Packet::INVALID_TIME)
  478. {
  479. m_brs.rtLastDeliverTime = p->rtStart;
  480. m_brs.nBytesSinceLastDeliverTime = 0;
  481. }
  483. if(m_brs.rtLastDeliverTime + 10000000 < p->rtStart)
  484. {
  485. REFERENCE_TIME rtDiff = p->rtStart - m_brs.rtLastDeliverTime;
  487. double secs, bits;
  489. secs = (double)rtDiff / 10000000;
  490. bits = 8.0 * m_brs.nBytesSinceLastDeliverTime;
  491. m_brs.nCurrentBitRate = (DWORD)(bits / secs);
  493. m_brs.rtTotalTimeDelivered += rtDiff;
  494. m_brs.nTotalBytesDelivered += m_brs.nBytesSinceLastDeliverTime;
  496. secs = (double)m_brs.rtTotalTimeDelivered / 10000000;
  497. bits = 8.0 * m_brs.nTotalBytesDelivered;
  498. m_brs.nAverageBitRate = (DWORD)(bits / secs);
  500. m_brs.rtLastDeliverTime = p->rtStart;
  501. m_brs.nBytesSinceLastDeliverTime = 0;
  502. /*
  503. TRACE(_T("[%d] c: %d kbps, a: %d kbpsn"), 
  504. p->TrackNumber,
  505. (m_brs.nCurrentBitRate+500)/1000, 
  506. (m_brs.nAverageBitRate+500)/1000);
  507. */
  508. }
  510. double dRate = 1.0;
  511. if(SUCCEEDED(((CBaseSplitterFilter*)m_pFilter)->GetRate(&dRate)))
  512. {
  513. p->rtStart = (REFERENCE_TIME)((double)p->rtStart / dRate);
  514. p->rtStop = (REFERENCE_TIME)((double)p->rtStop / dRate);
  515. }
  516. }
  518. do
  519. {
  520. CComPtr<IMediaSample> pSample;
  521. if(S_OK != (hr = GetDeliveryBuffer(&pSample, NULL, NULL, 0))) break;
  523. if(nBytes > pSample->GetSize())
  524. {
  525. pSample.Release();
  527. ALLOCATOR_PROPERTIES props, actual;
  528. if(S_OK != (hr = m_pAllocator->GetProperties(&props))) break;
  529. props.cbBuffer = nBytes*3/2;
  531. if(props.cBuffers > 1)
  532. {
  533. if(S_OK != (hr = __super::DeliverBeginFlush())) break;
  534. if(S_OK != (hr = __super::DeliverEndFlush())) break;
  535. }
  537. if(S_OK != (hr = m_pAllocator->Decommit())) break;
  538. if(S_OK != (hr = m_pAllocator->SetProperties(&props, &actual))) break;
  539. if(S_OK != (hr = m_pAllocator->Commit())) break;
  540. if(S_OK != (hr = GetDeliveryBuffer(&pSample, NULL, NULL, 0))) break;
  541. }
  543. if(p->pmt)
  544. {
  545. pSample->SetMediaType(p->pmt);
  546. p->bDiscontinuity = true;
  548.     CAutoLock cAutoLock(m_pLock);
  549. m_mts.RemoveAll();
  550. m_mts.Add(*p->pmt);
  551. }
  553. bool fTimeValid = p->rtStart != Packet::INVALID_TIME;
  554. /*
  555. //if(p->TrackNumber == 1)
  556. //if(p->rtStart != Packet::INVALID_TIME)
  557. TRACE(_T("[%d]: d%d s%d p%d, b=%d, %I64d-%I64d n"), 
  558.   p->TrackNumber,
  559.   p->bDiscontinuity, p->bSyncPoint, fTimeValid && p->rtStart < 0,
  560.   nBytes, p->rtStart, p->rtStop);
  561. */
  562. ASSERT(!p->bSyncPoint || fTimeValid);
  564. BYTE* pData = NULL;
  565. if(S_OK != (hr = pSample->GetPointer(&pData)) || !pData) break;
  566. memcpy(pData, p->pData.GetData(), nBytes);
  567. if(S_OK != (hr = pSample->SetActualDataLength(nBytes))) break;
  568. if(S_OK != (hr = pSample->SetTime(fTimeValid ? &p->rtStart : NULL, fTimeValid ? &p->rtStop : NULL))) break;
  569. if(S_OK != (hr = pSample->SetMediaTime(NULL, NULL))) break;
  570. if(S_OK != (hr = pSample->SetDiscontinuity(p->bDiscontinuity))) break;
  571. if(S_OK != (hr = pSample->SetSyncPoint(p->bSyncPoint))) break;
  572. if(S_OK != (hr = pSample->SetPreroll(fTimeValid && p->rtStart < 0))) break;
  573. if(S_OK != (hr = Deliver(pSample))) break;
  574. }
  575. while(false);
  577. return hr;
  578. }
  580. void CBaseSplitterOutputPin::MakeISCRHappy()
  581. {
  582. CComPtr<IPin> pPinTo = this, pTmp;
  583. while(pPinTo && SUCCEEDED(pPinTo->ConnectedTo(&pTmp)) && (pPinTo = pTmp))
  584. {
  585. pTmp = NULL;
  587. CComPtr<IBaseFilter> pBF = GetFilterFromPin(pPinTo);
  589. if(GetCLSID(pBF) == GUIDFromCString(_T("{48025243-2D39-11CE-875D-00608CB78066}"))) // ISCR
  590. {
  591. CAutoPtr<Packet> p(new Packet());
  592. p->TrackNumber = (DWORD)-1;
  593. p->rtStart = -1; p->rtStop = 0;
  594. p->bSyncPoint = FALSE;
  595. p->pData.SetSize(2);
  596. strcpy((char*)p->pData.GetData(), " ");
  597. QueuePacket(p);
  598. break;
  599. }
  601. pPinTo = GetFirstPin(pBF, PINDIR_OUTPUT);
  602. }
  603. }
  605. HRESULT CBaseSplitterOutputPin::GetDeliveryBuffer(IMediaSample** ppSample, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags)
  606. {
  607. return __super::GetDeliveryBuffer(ppSample, pStartTime, pEndTime, dwFlags);
  608. }
  610. HRESULT CBaseSplitterOutputPin::Deliver(IMediaSample* pSample)
  611. {
  612. return __super::Deliver(pSample);
  613. }
  615. // IMediaSeeking
  617. STDMETHODIMP CBaseSplitterOutputPin::GetCapabilities(DWORD* pCapabilities)
  618. {
  619. return ((CBaseSplitterFilter*)m_pFilter)->GetCapabilities(pCapabilities);
  620. }
  621. STDMETHODIMP CBaseSplitterOutputPin::CheckCapabilities(DWORD* pCapabilities)
  622. {
  623. return ((CBaseSplitterFilter*)m_pFilter)->CheckCapabilities(pCapabilities);
  624. }
  625. STDMETHODIMP CBaseSplitterOutputPin::IsFormatSupported(const GUID* pFormat)
  626. {
  627. return ((CBaseSplitterFilter*)m_pFilter)->IsFormatSupported(pFormat);
  628. }
  629. STDMETHODIMP CBaseSplitterOutputPin::QueryPreferredFormat(GUID* pFormat)
  630. {
  631. return ((CBaseSplitterFilter*)m_pFilter)->QueryPreferredFormat(pFormat);
  632. }
  633. STDMETHODIMP CBaseSplitterOutputPin::GetTimeFormat(GUID* pFormat)
  634. {
  635. return ((CBaseSplitterFilter*)m_pFilter)->GetTimeFormat(pFormat);
  636. }
  637. STDMETHODIMP CBaseSplitterOutputPin::IsUsingTimeFormat(const GUID* pFormat)
  638. {
  639. return ((CBaseSplitterFilter*)m_pFilter)->IsUsingTimeFormat(pFormat);
  640. }
  641. STDMETHODIMP CBaseSplitterOutputPin::SetTimeFormat(const GUID* pFormat)
  642. {
  643. return ((CBaseSplitterFilter*)m_pFilter)->SetTimeFormat(pFormat);
  644. }
  645. STDMETHODIMP CBaseSplitterOutputPin::GetDuration(LONGLONG* pDuration)
  646. {
  647. return ((CBaseSplitterFilter*)m_pFilter)->GetDuration(pDuration);
  648. }
  649. STDMETHODIMP CBaseSplitterOutputPin::GetStopPosition(LONGLONG* pStop)
  650. {
  651. return ((CBaseSplitterFilter*)m_pFilter)->GetStopPosition(pStop);
  652. }
  653. STDMETHODIMP CBaseSplitterOutputPin::GetCurrentPosition(LONGLONG* pCurrent)
  654. {
  655. return ((CBaseSplitterFilter*)m_pFilter)->GetCurrentPosition(pCurrent);
  656. }
  657. STDMETHODIMP CBaseSplitterOutputPin::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat)
  658. {
  659. return ((CBaseSplitterFilter*)m_pFilter)->ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat);
  660. }
  661. STDMETHODIMP CBaseSplitterOutputPin::SetPositions(LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags)
  662. {
  663. return ((CBaseSplitterFilter*)m_pFilter)->SetPositionsInternal(this, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
  664. }
  665. STDMETHODIMP CBaseSplitterOutputPin::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop)
  666. {
  667. return ((CBaseSplitterFilter*)m_pFilter)->GetPositions(pCurrent, pStop);
  668. }
  669. STDMETHODIMP CBaseSplitterOutputPin::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest)
  670. {
  671. return ((CBaseSplitterFilter*)m_pFilter)->GetAvailable(pEarliest, pLatest);
  672. }
  673. STDMETHODIMP CBaseSplitterOutputPin::SetRate(double dRate)
  674. {
  675. return ((CBaseSplitterFilter*)m_pFilter)->SetRate(dRate);
  676. }
  677. STDMETHODIMP CBaseSplitterOutputPin::GetRate(double* pdRate)
  678. {
  679. return ((CBaseSplitterFilter*)m_pFilter)->GetRate(pdRate);
  680. }
  681. STDMETHODIMP CBaseSplitterOutputPin::GetPreroll(LONGLONG* pllPreroll)
  682. {
  683. return ((CBaseSplitterFilter*)m_pFilter)->GetPreroll(pllPreroll);
  684. }
  686. //
  687. // CBaseSplitterFilter
  688. //
  690. CBaseSplitterFilter::CBaseSplitterFilter(LPCTSTR pName, LPUNKNOWN pUnk, HRESULT* phr, const CLSID& clsid)
  691. : CBaseFilter(pName, pUnk, this, clsid)
  692. , m_rtDuration(0), m_rtStart(0), m_rtStop(0), m_rtCurrent(0)
  693. , m_dRate(1.0)
  694. , m_nOpenProgress(100)
  695. , m_fAbort(false)
  696. , m_rtLastStart(_I64_MIN)
  697. , m_rtLastStop(_I64_MIN)
  698. , m_priority(THREAD_PRIORITY_NORMAL)
  699. {
  700. if(phr) *phr = S_OK;
  702. m_pInput.Attach(new CBaseSplitterInputPin(NAME("CBaseSplitterInputPin"), this, this, phr));
  703. }
  705. CBaseSplitterFilter::~CBaseSplitterFilter()
  706. {
  707. CAutoLock cAutoLock(this);
  709. CAMThread::CallWorker(CMD_EXIT);
  710. CAMThread::Close();
  711. }
  713. STDMETHODIMP CBaseSplitterFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  714. {
  715. CheckPointer(ppv, E_POINTER);
  717. *ppv = NULL;
  719. if(m_pInput && riid == __uuidof(IFileSourceFilter)) 
  720. return E_NOINTERFACE;
  722. return 
  723. QI(IFileSourceFilter)
  724. QI(IMediaSeeking)
  725. QI(IAMOpenProgress)
  726. QI2(IAMMediaContent)
  727. QI2(IAMExtendedSeeking)
  728. QI(IKeyFrameInfo)
  729. QI(IBufferInfo)
  730. QI(IPropertyBag)
  731. QI(IPropertyBag2)
  732. QI(IDSMPropertyBag)
  733. QI(IDSMResourceBag)
  734. QI(IDSMChapterBag)
  735. __super::NonDelegatingQueryInterface(riid, ppv);
  736. }
  738. CBaseSplitterOutputPin* CBaseSplitterFilter::GetOutputPin(DWORD TrackNum)
  739. {
  740. CAutoLock cAutoLock(&m_csPinMap);
  742.     CBaseSplitterOutputPin* pPin = NULL;
  743. m_pPinMap.Lookup(TrackNum, pPin);
  744. return pPin;
  745. }
  747. DWORD CBaseSplitterFilter::GetOutputTrackNum(CBaseSplitterOutputPin* pPin)
  748. {
  749. CAutoLock cAutoLock(&m_csPinMap);
  751. POSITION pos = m_pPinMap.GetStartPosition();
  752. while(pos)
  753. {
  754. DWORD TrackNum;
  755. CBaseSplitterOutputPin* pPinTmp;
  756. m_pPinMap.GetNextAssoc(pos, TrackNum, pPinTmp);
  757. if(pPinTmp == pPin) return TrackNum;
  758. }
  760. return (DWORD)-1;
  761. }
  763. HRESULT CBaseSplitterFilter::RenameOutputPin(DWORD TrackNumSrc, DWORD TrackNumDst, const AM_MEDIA_TYPE* pmt)
  764. {
  765. CAutoLock cAutoLock(&m_csPinMap);
  767. CBaseSplitterOutputPin* pPin;
  768. if(m_pPinMap.Lookup(TrackNumSrc, pPin))
  769. {
  770. if(CComQIPtr<IPin> pPinTo = pPin->GetConnected())
  771. {
  772. if(pmt && S_OK != pPinTo->QueryAccept(pmt))
  773. return VFW_E_TYPE_NOT_ACCEPTED;
  774. }
  776. m_pPinMap.RemoveKey(TrackNumSrc);
  777. m_pPinMap[TrackNumDst] = pPin;
  779. if(pmt)
  780. {
  781. CAutoLock cAutoLock(&m_csmtnew);
  782. m_mtnew[TrackNumDst] = *pmt;
  783. }
  785. return S_OK;
  786. }
  788. return E_FAIL;
  789. }
  791. HRESULT CBaseSplitterFilter::AddOutputPin(DWORD TrackNum, CAutoPtr<CBaseSplitterOutputPin> pPin)
  792. {
  793. CAutoLock cAutoLock(&m_csPinMap);
  795. if(!pPin) return E_INVALIDARG;
  796. m_pPinMap[TrackNum] = pPin;
  797. m_pOutputs.AddTail(pPin);
  798. return S_OK;
  799. }
  801. HRESULT CBaseSplitterFilter::DeleteOutputs()
  802. {
  803. m_rtDuration = 0;
  805. m_pRetiredOutputs.RemoveAll();
  807. CAutoLock cAutoLockF(this);
  808. if(m_State != State_Stopped) return VFW_E_NOT_STOPPED;
  810. while(m_pOutputs.GetCount())
  811. {
  812. CAutoPtr<CBaseSplitterOutputPin> pPin = m_pOutputs.RemoveHead();
  813. if(IPin* pPinTo = pPin->GetConnected()) pPinTo->Disconnect();
  814. pPin->Disconnect();
  815. // we can't just let it be deleted now, something might have AddRefed on it (graphedit...)
  816. m_pRetiredOutputs.AddTail(pPin);
  817. }
  819. CAutoLock cAutoLockPM(&m_csPinMap);
  820. m_pPinMap.RemoveAll();
  822. CAutoLock cAutoLockMT(&m_csmtnew);
  823. m_mtnew.RemoveAll();
  825. RemoveAll();
  826. ResRemoveAll();
  827. ChapRemoveAll();
  829. m_fontinst.UninstallFonts();
  831. m_pSyncReader.Release();
  833. return S_OK;
  834. }
  836. void CBaseSplitterFilter::DeliverBeginFlush()
  837. {
  838. m_fFlushing = true;
  839. POSITION pos = m_pOutputs.GetHeadPosition();
  840. while(pos) m_pOutputs.GetNext(pos)->DeliverBeginFlush();
  841. }
  843. void CBaseSplitterFilter::DeliverEndFlush()
  844. {
  845. POSITION pos = m_pOutputs.GetHeadPosition();
  846. while(pos) m_pOutputs.GetNext(pos)->DeliverEndFlush();
  847. m_fFlushing = false;
  848. m_eEndFlush.Set();
  849. }
  851. DWORD CBaseSplitterFilter::ThreadProc()
  852. {
  853. if(m_pSyncReader) 
  854. m_pSyncReader->SetBreakEvent(GetRequestHandle());
  856. if(!DemuxInit())
  857. {
  858. while(1)
  859. {
  860. DWORD cmd = GetRequest();
  861. if(cmd == CMD_EXIT) CAMThread::m_hThread = NULL;
  862. Reply(S_OK);
  863. if(cmd == CMD_EXIT) return 0;
  864. }
  865. }
  867. m_eEndFlush.Set();
  868. m_fFlushing = false;
  870. for(DWORD cmd = -1; ; cmd = GetRequest())
  871. {
  872. if(cmd == CMD_EXIT)
  873. {
  874. m_hThread = NULL;
  875. Reply(S_OK);
  876. return 0;
  877. }
  879. SetThreadPriority(m_hThread, m_priority = THREAD_PRIORITY_NORMAL);
  881. m_rtStart = m_rtNewStart;
  882. m_rtStop = m_rtNewStop;
  884. DemuxSeek(m_rtStart);
  886. if(cmd != -1)
  887. Reply(S_OK);
  889. m_eEndFlush.Wait();
  891. m_pActivePins.RemoveAll();
  893. POSITION pos = m_pOutputs.GetHeadPosition();
  894. while(pos && !m_fFlushing)
  895. {
  896. CBaseSplitterOutputPin* pPin = m_pOutputs.GetNext(pos);
  897. if(pPin->IsConnected() && pPin->IsActive())
  898. {
  899. m_pActivePins.AddTail(pPin);
  900. pPin->DeliverNewSegment(m_rtStart, m_rtStop, m_dRate);
  901. }
  902. }
  904. do {m_bDiscontinuitySent.RemoveAll();}
  905. while(!DemuxLoop());
  907. pos = m_pActivePins.GetHeadPosition();
  908. while(pos && !CheckRequest(&cmd))
  909. m_pActivePins.GetNext(pos)->QueueEndOfStream();
  910. }
  912. ASSERT(0); // we should only exit via CMD_EXIT
  914. m_hThread = NULL;
  915. return 0;
  916. }
  918. HRESULT CBaseSplitterFilter::DeliverPacket(CAutoPtr<Packet> p)
  919. {
  920. HRESULT hr = S_FALSE;
  922. CBaseSplitterOutputPin* pPin = GetOutputPin(p->TrackNumber);
  923. if(!pPin || !pPin->IsConnected() || !m_pActivePins.Find(pPin))
  924. return S_FALSE;
  926. if(p->rtStart != Packet::INVALID_TIME)
  927. {
  928. m_rtCurrent = p->rtStart;
  930. p->rtStart -= m_rtStart;
  931. p->rtStop -= m_rtStart;
  933. ASSERT(p->rtStart <= p->rtStop);
  934. }
  936. {
  937. CAutoLock cAutoLock(&m_csmtnew);
  939. CMediaType mt;
  940. if(m_mtnew.Lookup(p->TrackNumber, mt))
  941. {
  942. p->pmt = CreateMediaType(&mt);
  943. m_mtnew.RemoveKey(p->TrackNumber);
  944. }
  945. }
  947. if(!m_bDiscontinuitySent.Find(p->TrackNumber))
  948. p->bDiscontinuity = TRUE;
  950. DWORD TrackNumber = p->TrackNumber;
  951. BOOL bDiscontinuity = p->bDiscontinuity;
  952. /*
  953. //if(p->TrackNumber == 1)
  954. //if(p->rtStart != Packet::INVALID_TIME)
  955. TRACE(_T("[%d]: d%d s%d p%d, b=%d, %I64d-%I64d n"), 
  956.   p->TrackNumber,
  957.   p->bDiscontinuity, p->bSyncPoint, p->rtStart != Packet::INVALID_TIME && p->rtStart < 0,
  958.   p->pData.GetCount(), p->rtStart, p->rtStop);
  959. */
  961. hr = pPin->QueuePacket(p);
  963. if(S_OK != hr)
  964. {
  965. if(POSITION pos = m_pActivePins.Find(pPin))
  966. m_pActivePins.RemoveAt(pos);
  968. if(!m_pActivePins.IsEmpty()) // only die when all pins are down
  969. hr = S_OK;
  971. return hr;
  972. }
  974. if(bDiscontinuity)
  975. m_bDiscontinuitySent.AddTail(TrackNumber);
  977. return hr;
  978. }
  980. bool CBaseSplitterFilter::IsAnyPinDrying()
  981. {
  982. int totalcount = 0, totalsize = 0;
  984. POSITION pos = m_pActivePins.GetHeadPosition();
  985. while(pos)
  986. {
  987. CBaseSplitterOutputPin* pPin = m_pActivePins.GetNext(pos);
  988. int count = pPin->QueueCount();
  989. int size = pPin->QueueSize();
  990. if(!pPin->IsDiscontinuous() && (count < MINPACKETS || size < MINPACKETSIZE))
  991. {
  992. // if(m_priority != THREAD_PRIORITY_ABOVE_NORMAL && (count < MINPACKETS/3 || size < MINPACKETSIZE/3))
  993. if(m_priority != THREAD_PRIORITY_BELOW_NORMAL && (count < MINPACKETS/3 || size < MINPACKETSIZE/3))
  994. {
  995. // SetThreadPriority(m_hThread, m_priority = THREAD_PRIORITY_ABOVE_NORMAL);
  996. POSITION pos = m_pOutputs.GetHeadPosition();
  997. while(pos) m_pOutputs.GetNext(pos)->SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
  998. m_priority = THREAD_PRIORITY_BELOW_NORMAL;
  999. }
  1000. return(true);
  1001. }
  1002. totalcount += count;
  1003. totalsize += size;
  1004. }
  1006. if(m_priority != THREAD_PRIORITY_NORMAL && (totalcount > MAXPACKETS*2/3 || totalsize > MAXPACKETSIZE*2/3))
  1007. {
  1008. // SetThreadPriority(m_hThread, m_priority = THREAD_PRIORITY_NORMAL);
  1009. POSITION pos = m_pOutputs.GetHeadPosition();
  1010. while(pos) m_pOutputs.GetNext(pos)->SetThreadPriority(THREAD_PRIORITY_NORMAL);
  1011. m_priority = THREAD_PRIORITY_NORMAL;
  1012. }
  1014. if(totalcount < MAXPACKETS && totalsize < MAXPACKETSIZE) 
  1015. return(true);
  1017. return(false);
  1018. }
  1020. HRESULT CBaseSplitterFilter::BreakConnect(PIN_DIRECTION dir, CBasePin* pPin)
  1021. {
  1022. CheckPointer(pPin, E_POINTER);
  1024. if(dir == PINDIR_INPUT)
  1025. {
  1026. DeleteOutputs();
  1027. }
  1028. else if(dir == PINDIR_OUTPUT)
  1029. {
  1030. }
  1031. else
  1032. {
  1033. return E_UNEXPECTED;
  1034. }
  1036. return S_OK;
  1037. }
  1039. HRESULT CBaseSplitterFilter::CompleteConnect(PIN_DIRECTION dir, CBasePin* pPin)
  1040. {
  1041. CheckPointer(pPin, E_POINTER);
  1043. if(dir == PINDIR_INPUT)
  1044. {
  1045. CBaseSplitterInputPin* pIn = (CBaseSplitterInputPin*)pPin;
  1047. HRESULT hr;
  1049. CComPtr<IAsyncReader> pAsyncReader;
  1050. if(FAILED(hr = pIn->GetAsyncReader(&pAsyncReader))
  1051. || FAILED(hr = DeleteOutputs())
  1052. || FAILED(hr = CreateOutputs(pAsyncReader)))
  1053. return hr;
  1055. ChapSort();
  1057. m_pSyncReader = pAsyncReader;
  1058. }
  1059. else if(dir == PINDIR_OUTPUT)
  1060. {
  1061. m_pRetiredOutputs.RemoveAll();
  1062. }
  1063. else
  1064. {
  1065. return E_UNEXPECTED;
  1066. }
  1068. return S_OK;
  1069. }
  1071. int CBaseSplitterFilter::GetPinCount()
  1072. {
  1073. return (m_pInput ? 1 : 0) + m_pOutputs.GetCount();
  1074. }
  1076. CBasePin* CBaseSplitterFilter::GetPin(int n)
  1077. {
  1078.     CAutoLock cAutoLock(this);
  1080. if(n >= 0 && n < (int)m_pOutputs.GetCount())
  1081. {
  1082. if(POSITION pos = m_pOutputs.FindIndex(n))
  1083. return m_pOutputs.GetAt(pos);
  1084. }
  1086. if(n == m_pOutputs.GetCount() && m_pInput)
  1087. {
  1088. return m_pInput;
  1089. }
  1091. return NULL;
  1092. }
  1094. STDMETHODIMP CBaseSplitterFilter::Stop()
  1095. {
  1096. CAutoLock cAutoLock(this);
  1098. DeliverBeginFlush();
  1099. CallWorker(CMD_EXIT);
  1100. DeliverEndFlush();
  1102. HRESULT hr;
  1103. if(FAILED(hr = __super::Stop()))
  1104. return hr;
  1106. return S_OK;
  1107. }
  1109. STDMETHODIMP CBaseSplitterFilter::Pause()
  1110. {
  1111. CAutoLock cAutoLock(this);
  1113. FILTER_STATE fs = m_State;
  1115. HRESULT hr;
  1116. if(FAILED(hr = __super::Pause()))
  1117. return hr;
  1119. if(fs == State_Stopped)
  1120. {
  1121. Create();
  1122. }
  1124. return S_OK;
  1125. }
  1127. STDMETHODIMP CBaseSplitterFilter::Run(REFERENCE_TIME tStart)
  1128. {
  1129. CAutoLock cAutoLock(this);
  1131. HRESULT hr;
  1132. if(FAILED(hr = __super::Run(tStart)))
  1133. return hr;
  1135. return S_OK;
  1136. }
  1138. // IFileSourceFilter
  1140. STDMETHODIMP CBaseSplitterFilter::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt)
  1141. {
  1142. CheckPointer(pszFileName, E_POINTER);
  1144. HRESULT hr = E_FAIL;
  1145. CComPtr<IAsyncReader> pAsyncReader = (IAsyncReader*)new CAsyncFileReader(CString(pszFileName), hr);
  1146. if(FAILED(hr)
  1147. || FAILED(hr = DeleteOutputs())
  1148. || FAILED(hr = CreateOutputs(pAsyncReader)))
  1149. return hr;
  1151. ChapSort();
  1153. m_fn = pszFileName;
  1154. m_pSyncReader = pAsyncReader;
  1156. return S_OK;
  1157. }
  1159. STDMETHODIMP CBaseSplitterFilter::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)
  1160. {
  1161. CheckPointer(ppszFileName, E_POINTER);
  1162. if(!(*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR))))
  1163. return E_OUTOFMEMORY;
  1164. wcscpy(*ppszFileName, m_fn);
  1165. return S_OK;
  1166. }
  1168. // IMediaSeeking
  1170. STDMETHODIMP CBaseSplitterFilter::GetCapabilities(DWORD* pCapabilities)
  1171. {
  1172. return pCapabilities ? *pCapabilities = 
  1173. AM_SEEKING_CanGetStopPos|
  1174. AM_SEEKING_CanGetDuration|
  1175. AM_SEEKING_CanSeekAbsolute|
  1176. AM_SEEKING_CanSeekForwards|
  1177. AM_SEEKING_CanSeekBackwards, S_OK : E_POINTER;
  1178. }
  1179. STDMETHODIMP CBaseSplitterFilter::CheckCapabilities(DWORD* pCapabilities)
  1180. {
  1181. CheckPointer(pCapabilities, E_POINTER);
  1182. if(*pCapabilities == 0) return S_OK;
  1183. DWORD caps;
  1184. GetCapabilities(&caps);
  1185. if((caps&*pCapabilities) == 0) return E_FAIL;
  1186. if(caps == *pCapabilities) return S_OK;
  1187. return S_FALSE;
  1188. }
  1189. STDMETHODIMP CBaseSplitterFilter::IsFormatSupported(const GUID* pFormat) {return !pFormat ? E_POINTER : *pFormat == TIME_FORMAT_MEDIA_TIME ? S_OK : S_FALSE;}
  1190. STDMETHODIMP CBaseSplitterFilter::QueryPreferredFormat(GUID* pFormat) {return GetTimeFormat(pFormat);}
  1191. STDMETHODIMP CBaseSplitterFilter::GetTimeFormat(GUID* pFormat) {return pFormat ? *pFormat = TIME_FORMAT_MEDIA_TIME, S_OK : E_POINTER;}
  1192. STDMETHODIMP CBaseSplitterFilter::IsUsingTimeFormat(const GUID* pFormat) {return IsFormatSupported(pFormat);}
  1193. STDMETHODIMP CBaseSplitterFilter::SetTimeFormat(const GUID* pFormat) {return S_OK == IsFormatSupported(pFormat) ? S_OK : E_INVALIDARG;}
  1194. STDMETHODIMP CBaseSplitterFilter::GetDuration(LONGLONG* pDuration) {CheckPointer(pDuration, E_POINTER); *pDuration = m_rtDuration; return S_OK;}
  1195. STDMETHODIMP CBaseSplitterFilter::GetStopPosition(LONGLONG* pStop) {return GetDuration(pStop);}
  1196. STDMETHODIMP CBaseSplitterFilter::GetCurrentPosition(LONGLONG* pCurrent) {return E_NOTIMPL;}
  1197. STDMETHODIMP CBaseSplitterFilter::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat) {return E_NOTIMPL;}
  1198. STDMETHODIMP CBaseSplitterFilter::SetPositions(LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags)
  1199. {
  1200. return SetPositionsInternal(this, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
  1201. }
  1202. STDMETHODIMP CBaseSplitterFilter::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop)
  1203. {
  1204. if(pCurrent) *pCurrent = m_rtCurrent;
  1205. if(pStop) *pStop = m_rtStop;
  1206. return S_OK;
  1207. }
  1208. STDMETHODIMP CBaseSplitterFilter::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest)
  1209. {
  1210. if(pEarliest) *pEarliest = 0;
  1211. return GetDuration(pLatest);
  1212. }
  1213. STDMETHODIMP CBaseSplitterFilter::SetRate(double dRate) {return dRate > 0 ? m_dRate = dRate, S_OK : E_INVALIDARG;}
  1214. STDMETHODIMP CBaseSplitterFilter::GetRate(double* pdRate) {return pdRate ? *pdRate = m_dRate, S_OK : E_POINTER;}
  1215. STDMETHODIMP CBaseSplitterFilter::GetPreroll(LONGLONG* pllPreroll) {return pllPreroll ? *pllPreroll = 0, S_OK : E_POINTER;}
  1217. HRESULT CBaseSplitterFilter::SetPositionsInternal(void* id, LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags)
  1218. {
  1219. CAutoLock cAutoLock(this);
  1221. if(!pCurrent && !pStop
  1222. || (dwCurrentFlags&AM_SEEKING_PositioningBitsMask) == AM_SEEKING_NoPositioning 
  1223. && (dwStopFlags&AM_SEEKING_PositioningBitsMask) == AM_SEEKING_NoPositioning)
  1224. return S_OK;
  1226. REFERENCE_TIME 
  1227. rtCurrent = m_rtCurrent,
  1228. rtStop = m_rtStop;
  1230. if(pCurrent)
  1231. switch(dwCurrentFlags&AM_SEEKING_PositioningBitsMask)
  1232. {
  1233. case AM_SEEKING_NoPositioning: break;
  1234. case AM_SEEKING_AbsolutePositioning: rtCurrent = *pCurrent; break;
  1235. case AM_SEEKING_RelativePositioning: rtCurrent = rtCurrent + *pCurrent; break;
  1236. case AM_SEEKING_IncrementalPositioning: rtCurrent = rtCurrent + *pCurrent; break;
  1237. }
  1239. if(pStop)
  1240. switch(dwStopFlags&AM_SEEKING_PositioningBitsMask)
  1241. {
  1242. case AM_SEEKING_NoPositioning: break;
  1243. case AM_SEEKING_AbsolutePositioning: rtStop = *pStop; break;
  1244. case AM_SEEKING_RelativePositioning: rtStop += *pStop; break;
  1245. case AM_SEEKING_IncrementalPositioning: rtStop = rtCurrent + *pStop; break;
  1246. }
  1248. if(m_rtCurrent == rtCurrent && m_rtStop == rtStop)
  1249. return S_OK;
  1251. if(m_rtLastStart == rtCurrent && m_rtLastStop == rtStop && !m_LastSeekers.Find(id))
  1252. {
  1253. m_LastSeekers.AddTail(id);
  1254. return S_OK;
  1255. }
  1257. m_rtLastStart = rtCurrent;
  1258. m_rtLastStop = rtStop;
  1259. m_LastSeekers.RemoveAll();
  1260. m_LastSeekers.AddTail(id);
  1262. DbgLog((LOG_TRACE, 0, _T("Seek Started %I64d"), rtCurrent));
  1264. m_rtNewStart = m_rtCurrent = rtCurrent;
  1265. m_rtNewStop = rtStop;
  1267. if(ThreadExists())
  1268. {
  1269. DeliverBeginFlush();
  1270. CallWorker(CMD_SEEK);
  1271. DeliverEndFlush();
  1272. }
  1274. DbgLog((LOG_TRACE, 0, _T("Seek Ended")));
  1276. return S_OK;
  1277. }
  1279. // IAMOpenProgress
  1281. STDMETHODIMP CBaseSplitterFilter::QueryProgress(LONGLONG* pllTotal, LONGLONG* pllCurrent)
  1282. {
  1283. CheckPointer(pllTotal, E_POINTER);
  1284. CheckPointer(pllCurrent, E_POINTER);
  1286. *pllTotal = 100;
  1287. *pllCurrent = m_nOpenProgress;
  1289. return S_OK;
  1290. }
  1292. STDMETHODIMP CBaseSplitterFilter::AbortOperation()
  1293. {
  1294. m_fAbort = true;
  1295. return S_OK;
  1296. }
  1298. // IAMMediaContent
  1300. STDMETHODIMP CBaseSplitterFilter::get_AuthorName(BSTR* pbstrAuthorName)
  1301. {
  1302. return GetProperty(L"AUTH", pbstrAuthorName);
  1303. }
  1305. STDMETHODIMP CBaseSplitterFilter::get_Title(BSTR* pbstrTitle)
  1306. {
  1307. return GetProperty(L"TITL", pbstrTitle);
  1308. }
  1310. STDMETHODIMP CBaseSplitterFilter::get_Rating(BSTR* pbstrRating)
  1311. {
  1312. return GetProperty(L"RTNG", pbstrRating);
  1313. }
  1315. STDMETHODIMP CBaseSplitterFilter::get_Description(BSTR* pbstrDescription)
  1316. {
  1317. return GetProperty(L"DESC", pbstrDescription);
  1318. }
  1320. STDMETHODIMP CBaseSplitterFilter::get_Copyright(BSTR* pbstrCopyright)
  1321. {
  1322. return GetProperty(L"CPYR", pbstrCopyright);
  1323. }
  1325. // IAMExtendedSeeking
  1327. STDMETHODIMP CBaseSplitterFilter::get_ExSeekCapabilities(long* pExCapabilities)
  1328. {
  1329. CheckPointer(pExCapabilities, E_POINTER);
  1330. *pExCapabilities = AM_EXSEEK_CANSEEK;
  1331. if(ChapGetCount()) *pExCapabilities |= AM_EXSEEK_MARKERSEEK;
  1332. return S_OK;
  1333. }
  1335. STDMETHODIMP CBaseSplitterFilter::get_MarkerCount(long* pMarkerCount)
  1336. {
  1337. CheckPointer(pMarkerCount, E_POINTER);
  1338. *pMarkerCount = (long)ChapGetCount();
  1339. return S_OK;
  1340. }
  1342. STDMETHODIMP CBaseSplitterFilter::get_CurrentMarker(long* pCurrentMarker)
  1343. {
  1344. CheckPointer(pCurrentMarker, E_POINTER);
  1345. REFERENCE_TIME rt = m_rtCurrent;
  1346. long i = ChapLookup(&rt);
  1347. if(i < 0) return E_FAIL;
  1348. *pCurrentMarker = i+1;
  1349. return S_OK;
  1350. }
  1352. STDMETHODIMP CBaseSplitterFilter::GetMarkerTime(long MarkerNum, double* pMarkerTime)
  1353. {
  1354. CheckPointer(pMarkerTime, E_POINTER);
  1355. REFERENCE_TIME rt;
  1356. if(FAILED(ChapGet((int)MarkerNum-1, &rt))) return E_FAIL;
  1357. *pMarkerTime = (double)rt / 10000000;
  1358. return S_OK;
  1359. }
  1361. STDMETHODIMP CBaseSplitterFilter::GetMarkerName(long MarkerNum, BSTR* pbstrMarkerName)
  1362. {
  1363. return ChapGet((int)MarkerNum-1, NULL, pbstrMarkerName);
  1364. }
  1366. // IKeyFrameInfo
  1368. STDMETHODIMP CBaseSplitterFilter::GetKeyFrameCount(UINT& nKFs)
  1369. {
  1370. return E_NOTIMPL;
  1371. }
  1373. STDMETHODIMP CBaseSplitterFilter::GetKeyFrames(const GUID* pFormat, REFERENCE_TIME* pKFs, UINT& nKFs)
  1374. {
  1375. return E_NOTIMPL;
  1376. }
  1378. // IBufferInfo
  1380. STDMETHODIMP_(int) CBaseSplitterFilter::GetCount()
  1381. {
  1382. CAutoLock cAutoLock(m_pLock);
  1384. return m_pOutputs.GetCount();
  1385. }
  1387. STDMETHODIMP CBaseSplitterFilter::GetStatus(int i, int& samples, int& size)
  1388. {
  1389. CAutoLock cAutoLock(m_pLock);
  1391. if(POSITION pos = m_pOutputs.FindIndex(i))
  1392. {
  1393. CBaseSplitterOutputPin* pPin = m_pOutputs.GetAt(pos);
  1394. samples = pPin->QueueCount();
  1395. size = pPin->QueueSize();
  1396. return pPin->IsConnected() ? S_OK : S_FALSE;
  1397. }
  1399. return E_INVALIDARG;
  1400. }
  1402. STDMETHODIMP_(DWORD) CBaseSplitterFilter::GetPriority()
  1403. {
  1404.     return m_priority;
  1405. }