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

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

多媒体编程

开发平台：

Visual C++

StreamSwitcher.cpp：源码内容
  1. // Copyright 2003 Gabest.
  2. // http://www.gabest.org
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
  17. // http://www.gnu.org/copyleft/gpl.html
  19. #include "StdAfx.h"
  20. #include "StreamSwitcher.h"
  22. #include "Shlwapi.h"
  23. #include <atlpath.h>
  24. #include <mmreg.h>
  25. #include <ks.h>
  26. #include <ksmedia.h>
  27. #include "AudioSwitcher.h"
  28. #include "Audio.h"
  29. #include "......DSUtilDSUtil.h"
  31. #include <initguid.h>
  32. #include "........includeOggOggDS.h"
  34. #define BLOCKSTREAM
  36. //
  37. // CStreamSwitcherPassThru
  38. //
  40. CStreamSwitcherPassThru::CStreamSwitcherPassThru(LPUNKNOWN pUnk, HRESULT* phr, CStreamSwitcherFilter* pFilter)
  41. : CMediaPosition(NAME("CStreamSwitcherPassThru"), pUnk)
  42. , m_pFilter(pFilter)
  43. {
  44. }
  46. STDMETHODIMP CStreamSwitcherPassThru::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  47. {
  48.     CheckPointer(ppv, E_POINTER);
  49.     *ppv = NULL;
  51.     return 
  52. QI(IMediaSeeking)
  53. CMediaPosition::NonDelegatingQueryInterface(riid, ppv);
  54. }
  56. template<class T>
  57. HRESULT GetPeer(CStreamSwitcherFilter* pFilter, T** ppT)
  58. {
  59.     *ppT = NULL;
  61. CBasePin* pPin = pFilter->GetInputPin();
  62. if(!pPin) return E_NOTIMPL;
  64.     CComPtr<IPin> pConnected;
  65.     if(FAILED(pPin->ConnectedTo(&pConnected))) 
  66. return E_NOTIMPL;
  68. if(CComQIPtr<T> pT = pConnected)
  69. {
  70. *ppT = pT.Detach();
  71. return S_OK;
  72. }
  74. return E_NOTIMPL;
  75. }
  77. #define CallPeerSeeking(call) 
  78. CComPtr<IMediaSeeking> pMS; 
  79. if(FAILED(GetPeer(m_pFilter, &pMS))) return E_NOTIMPL; 
  80. return pMS->##call; 
  82. #define CallPeer(call) 
  83. CComPtr<IMediaPosition> pMP; 
  84. if(FAILED(GetPeer(m_pFilter, &pMP))) return E_NOTIMPL; 
  85. return pMP->##call; 
  87. #define CallPeerSeekingAll(call) 
  88. HRESULT hr = E_NOTIMPL; 
  89. POSITION pos = m_pFilter->m_pInputs.GetHeadPosition(); 
  90. while(pos) 
  91. { 
  92. CBasePin* pPin = m_pFilter->m_pInputs.GetNext(pos); 
  93. CComPtr<IPin> pConnected; 
  94.     if(FAILED(pPin->ConnectedTo(&pConnected))) 
  95. continue; 
  96. if(CComQIPtr<IMediaSeeking> pMS = pConnected) 
  97. { 
  98. HRESULT hr2 = pMS->call; 
  99. if(pPin == m_pFilter->GetInputPin()) 
  100. hr = hr2; 
  101. } 
  102. } 
  103. return hr; 
  105. #define CallPeerAll(call) 
  106. HRESULT hr = E_NOTIMPL; 
  107. POSITION pos = m_pFilter->m_pInputs.GetHeadPosition(); 
  108. while(pos) 
  109. { 
  110. CBasePin* pPin = m_pFilter->m_pInputs.GetNext(pos); 
  111. CComPtr<IPin> pConnected; 
  112.     if(FAILED(pPin->ConnectedTo(&pConnected))) 
  113. continue; 
  114. if(CComQIPtr<IMediaPosition> pMP = pConnected) 
  115. { 
  116. HRESULT hr2 = pMP->call; 
  117. if(pPin == m_pFilter->GetInputPin()) 
  118. hr = hr2; 
  119. } 
  120. } 
  121. return hr; 
  124. // IMediaSeeking
  126. STDMETHODIMP CStreamSwitcherPassThru::GetCapabilities(DWORD* pCaps)
  127. {CallPeerSeeking(GetCapabilities(pCaps));}
  128. STDMETHODIMP CStreamSwitcherPassThru::CheckCapabilities(DWORD* pCaps)
  129. {CallPeerSeeking(CheckCapabilities(pCaps));}
  130. STDMETHODIMP CStreamSwitcherPassThru::IsFormatSupported(const GUID* pFormat)
  131. {CallPeerSeeking(IsFormatSupported(pFormat));}
  132. STDMETHODIMP CStreamSwitcherPassThru::QueryPreferredFormat(GUID* pFormat)
  133. {CallPeerSeeking(QueryPreferredFormat(pFormat));}
  134. STDMETHODIMP CStreamSwitcherPassThru::SetTimeFormat(const GUID* pFormat)
  135. {CallPeerSeeking(SetTimeFormat(pFormat));}
  136. STDMETHODIMP CStreamSwitcherPassThru::GetTimeFormat(GUID* pFormat)
  137. {CallPeerSeeking(GetTimeFormat(pFormat));}
  138. STDMETHODIMP CStreamSwitcherPassThru::IsUsingTimeFormat(const GUID* pFormat)
  139. {CallPeerSeeking(IsUsingTimeFormat(pFormat));}
  140. STDMETHODIMP CStreamSwitcherPassThru::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat)
  141. {CallPeerSeeking(ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat));}
  142. STDMETHODIMP CStreamSwitcherPassThru::SetPositions(LONGLONG* pCurrent, DWORD CurrentFlags, LONGLONG* pStop, DWORD StopFlags)
  143. {CallPeerSeekingAll(SetPositions(pCurrent, CurrentFlags, pStop, StopFlags));}
  144. STDMETHODIMP CStreamSwitcherPassThru::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop)
  145. {CallPeerSeeking(GetPositions(pCurrent, pStop));}
  146. STDMETHODIMP CStreamSwitcherPassThru::GetCurrentPosition(LONGLONG* pCurrent)
  147. {CallPeerSeeking(GetCurrentPosition(pCurrent));}
  148. STDMETHODIMP CStreamSwitcherPassThru::GetStopPosition(LONGLONG* pStop)
  149. {CallPeerSeeking(GetStopPosition(pStop));}
  150. STDMETHODIMP CStreamSwitcherPassThru::GetDuration(LONGLONG* pDuration)
  151. {CallPeerSeeking(GetDuration(pDuration));}
  152. STDMETHODIMP CStreamSwitcherPassThru::GetPreroll(LONGLONG* pllPreroll)
  153. {CallPeerSeeking(GetPreroll(pllPreroll));}
  154. STDMETHODIMP CStreamSwitcherPassThru::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest)
  155. {CallPeerSeeking(GetAvailable(pEarliest, pLatest));}
  156. STDMETHODIMP CStreamSwitcherPassThru::GetRate(double* pdRate)
  157. {CallPeerSeeking(GetRate(pdRate));}
  158. STDMETHODIMP CStreamSwitcherPassThru::SetRate(double dRate)
  159. {if(0.0 == dRate) return E_INVALIDARG;
  160. CallPeerSeekingAll(SetRate(dRate));}
  162. // IMediaPosition
  164. STDMETHODIMP CStreamSwitcherPassThru::get_Duration(REFTIME* plength)
  165. {CallPeer(get_Duration(plength));}
  166. STDMETHODIMP CStreamSwitcherPassThru::get_CurrentPosition(REFTIME* pllTime)
  167. {CallPeer(get_CurrentPosition(pllTime));}
  168. STDMETHODIMP CStreamSwitcherPassThru::put_CurrentPosition(REFTIME llTime)
  169. {CallPeerAll(put_CurrentPosition(llTime));}
  170. STDMETHODIMP CStreamSwitcherPassThru::get_StopTime(REFTIME* pllTime)
  171. {CallPeer(get_StopTime(pllTime));}
  172. STDMETHODIMP CStreamSwitcherPassThru::put_StopTime(REFTIME llTime)
  173. {CallPeerAll(put_StopTime(llTime));}
  174. STDMETHODIMP CStreamSwitcherPassThru::get_PrerollTime(REFTIME * pllTime)
  175. {CallPeer(get_PrerollTime(pllTime));}
  176. STDMETHODIMP CStreamSwitcherPassThru::put_PrerollTime(REFTIME llTime)
  177. {CallPeerAll(put_PrerollTime(llTime));}
  178. STDMETHODIMP CStreamSwitcherPassThru::get_Rate(double* pdRate)
  179. {CallPeer(get_Rate(pdRate));}
  180. STDMETHODIMP CStreamSwitcherPassThru::put_Rate(double dRate)
  181. {if(0.0 == dRate) return E_INVALIDARG;
  182. CallPeerAll(put_Rate(dRate));}
  183. STDMETHODIMP CStreamSwitcherPassThru::CanSeekForward(LONG* pCanSeekForward)
  184. {CallPeer(CanSeekForward(pCanSeekForward));}
  185. STDMETHODIMP CStreamSwitcherPassThru::CanSeekBackward(LONG* pCanSeekBackward) 
  186. {CallPeer(CanSeekBackward(pCanSeekBackward));}
  188. //
  189. // CStreamSwitcherAllocator
  190. //
  192. CStreamSwitcherAllocator::CStreamSwitcherAllocator(CStreamSwitcherInputPin* pPin, HRESULT* phr)
  193. : CMemAllocator(NAME("CStreamSwitcherAllocator"), NULL, phr)
  194. , m_pPin(pPin)
  195. , m_fMediaTypeChanged(false)
  196. {
  197. ASSERT(phr);
  198. ASSERT(pPin);
  199. }
  201. #ifdef DEBUG
  202. CStreamSwitcherAllocator::~CStreamSwitcherAllocator()
  203. {
  204.     ASSERT(m_bCommitted == FALSE);
  205. }
  206. #endif
  208. STDMETHODIMP_(ULONG) CStreamSwitcherAllocator::NonDelegatingAddRef()
  209. {
  210. return m_pPin->m_pFilter->AddRef();
  211. }
  213. STDMETHODIMP_(ULONG) CStreamSwitcherAllocator::NonDelegatingRelease()
  214. {
  215. return m_pPin->m_pFilter->Release();
  216. }
  218. STDMETHODIMP CStreamSwitcherAllocator::GetBuffer(
  219. IMediaSample** ppBuffer, 
  220. REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, 
  221. DWORD dwFlags)
  222. {
  223. HRESULT hr = VFW_E_NOT_COMMITTED;
  225. if(!m_bCommitted)
  226.         return hr;
  227. /*
  228. TRACE(_T("CStreamSwitcherAllocator::GetBuffer m_pPin->m_evBlock.Wait() + %xn"), this);
  229. m_pPin->m_evBlock.Wait();
  230. TRACE(_T("CStreamSwitcherAllocator::GetBuffer m_pPin->m_evBlock.Wait() - %xn"), this);
  231. */
  232. if(m_fMediaTypeChanged)
  233. {
  234. if(!m_pPin || !m_pPin->m_pFilter)
  235. return hr;
  237. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pPin->m_pFilter)->GetOutputPin();
  238. if(!pOut || !pOut->CurrentAllocator())
  239. return hr;
  241. ALLOCATOR_PROPERTIES Properties, Actual;
  242. if(FAILED(pOut->CurrentAllocator()->GetProperties(&Actual))) 
  243. return hr;
  244. if(FAILED(GetProperties(&Properties))) 
  245. return hr;
  247. if(!m_bCommitted || Properties.cbBuffer < Actual.cbBuffer)
  248. {
  249. Properties.cbBuffer = Actual.cbBuffer;
  250. if(FAILED(Decommit())) return hr;
  251. if(FAILED(SetProperties(&Properties, &Actual))) return hr;
  252. if(FAILED(Commit())) return hr;
  253. ASSERT(Actual.cbBuffer >= Properties.cbBuffer);
  254. if(Actual.cbBuffer < Properties.cbBuffer) return hr;
  255. }
  256. }
  258. hr = CMemAllocator::GetBuffer(ppBuffer, pStartTime, pEndTime, dwFlags);
  260. if(m_fMediaTypeChanged && SUCCEEDED(hr))
  261. {
  262. (*ppBuffer)->SetMediaType(&m_mt);
  263. m_fMediaTypeChanged = false;
  264. }
  266. return hr;
  267. }
  269. void CStreamSwitcherAllocator::NotifyMediaType(const CMediaType& mt)
  270. {
  271. CopyMediaType(&m_mt, &mt);
  272. m_fMediaTypeChanged = true;
  273. }
  276. //
  277. // CStreamSwitcherInputPin
  278. //
  280. CStreamSwitcherInputPin::CStreamSwitcherInputPin(CStreamSwitcherFilter* pFilter, HRESULT* phr, LPCWSTR pName)
  281.     : CBaseInputPin(NAME("CStreamSwitcherInputPin"), pFilter, &pFilter->m_csState, phr, pName)
  282. , m_Allocator(this, phr)
  283. , m_bSampleSkipped(FALSE)
  284. , m_bQualityChanged(FALSE)
  285. , m_bUsingOwnAllocator(FALSE)
  286. , m_evBlock(TRUE)
  287. , m_fCanBlock(false)
  288. , m_hNotifyEvent(NULL)
  289. {
  290. m_bCanReconnectWhenActive = TRUE;
  291. }
  293. [uuid("138130AF-A79B-45D5-B4AA-87697457BA87")]
  294. class NeroAudioDecoder {};
  296. STDMETHODIMP CStreamSwitcherInputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  297. {
  298. return
  299. QI(IStreamSwitcherInputPin)
  300. IsConnected() && GetCLSID(GetFilterFromPin(GetConnected())) == __uuidof(NeroAudioDecoder) && QI(IPinConnection)
  301. __super::NonDelegatingQueryInterface(riid, ppv);
  302. }
  304. // IPinConnection
  306. STDMETHODIMP CStreamSwitcherInputPin::DynamicQueryAccept(const AM_MEDIA_TYPE* pmt)
  307. {
  308. return QueryAccept(pmt);
  309. }
  311. STDMETHODIMP CStreamSwitcherInputPin::NotifyEndOfStream(HANDLE hNotifyEvent)
  312. {
  313. if(m_hNotifyEvent) SetEvent(m_hNotifyEvent);
  314. m_hNotifyEvent = hNotifyEvent;
  315. return S_OK;
  316. }
  318. STDMETHODIMP CStreamSwitcherInputPin::IsEndPin()
  319. {
  320. return S_OK;
  321. }
  323. STDMETHODIMP CStreamSwitcherInputPin::DynamicDisconnect()
  324. {
  325. CAutoLock cAutoLock(&m_csReceive);
  326. Disconnect();
  327. return S_OK;
  328. }
  330. // IStreamSwitcherInputPin
  332. STDMETHODIMP_(bool) CStreamSwitcherInputPin::IsActive()
  333. {
  334. // TODO: lock onto something here
  335. return(this == ((CStreamSwitcherFilter*)m_pFilter)->GetInputPin());
  336. }
  338. // 
  340. HRESULT CStreamSwitcherInputPin::QueryAcceptDownstream(const AM_MEDIA_TYPE* pmt)
  341. {
  342. HRESULT hr = S_OK;
  344. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  346. if(pOut && pOut->IsConnected())
  347. {
  348. if(CComPtr<IPinConnection> pPC = pOut->CurrentPinConnection())
  349. {
  350. hr = pPC->DynamicQueryAccept(pmt);
  351. if(hr == S_OK) return S_OK;
  352. }
  354. hr = pOut->GetConnected()->QueryAccept(pmt);
  355. }
  357. return hr;
  358. }
  360. void CStreamSwitcherInputPin::Block(bool fBlock)
  361. {
  362. if(fBlock) m_evBlock.Reset();
  363. else m_evBlock.Set();
  364. }
  366. HRESULT CStreamSwitcherInputPin::InitializeOutputSample(IMediaSample* pInSample, IMediaSample** ppOutSample)
  367. {
  368. if(!pInSample || !ppOutSample) 
  369. return E_POINTER;
  371. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  372. ASSERT(pOut->GetConnected());
  374.     CComPtr<IMediaSample> pOutSample;
  376. DWORD dwFlags = m_bSampleSkipped ? AM_GBF_PREVFRAMESKIPPED : 0;
  378.     if(!(m_SampleProps.dwSampleFlags & AM_SAMPLE_SPLICEPOINT))
  379. dwFlags |= AM_GBF_NOTASYNCPOINT;
  381. HRESULT hr = pOut->GetDeliveryBuffer(&pOutSample
  382.         , m_SampleProps.dwSampleFlags & AM_SAMPLE_TIMEVALID ? &m_SampleProps.tStart : NULL
  383.         , m_SampleProps.dwSampleFlags & AM_SAMPLE_STOPVALID ? &m_SampleProps.tStop : NULL
  384.         , dwFlags);
  386.     if(FAILED(hr))
  387. return hr;
  389. if(!pOutSample) 
  390. return E_FAIL;
  392.     if(CComQIPtr<IMediaSample2> pOutSample2 = pOutSample)
  393. {
  394.         AM_SAMPLE2_PROPERTIES OutProps;
  395. EXECUTE_ASSERT(SUCCEEDED(pOutSample2->GetProperties(FIELD_OFFSET(AM_SAMPLE2_PROPERTIES, tStart), (PBYTE)&OutProps)));
  396.         OutProps.dwTypeSpecificFlags = m_SampleProps.dwTypeSpecificFlags;
  397.         OutProps.dwSampleFlags =
  398.             (OutProps.dwSampleFlags & AM_SAMPLE_TYPECHANGED) |
  399.             (m_SampleProps.dwSampleFlags & ~AM_SAMPLE_TYPECHANGED);
  401.         OutProps.tStart = m_SampleProps.tStart;
  402.         OutProps.tStop  = m_SampleProps.tStop;
  403.         OutProps.cbData = FIELD_OFFSET(AM_SAMPLE2_PROPERTIES, dwStreamId);
  405.         hr = pOutSample2->SetProperties(FIELD_OFFSET(AM_SAMPLE2_PROPERTIES, dwStreamId), (PBYTE)&OutProps);
  406.         if(m_SampleProps.dwSampleFlags & AM_SAMPLE_DATADISCONTINUITY)
  407. m_bSampleSkipped = FALSE;
  408.     }
  409.     else
  410. {
  411.         if(m_SampleProps.dwSampleFlags & AM_SAMPLE_TIMEVALID)
  412. pOutSample->SetTime(&m_SampleProps.tStart, &m_SampleProps.tStop);
  414. if(m_SampleProps.dwSampleFlags & AM_SAMPLE_SPLICEPOINT)
  415. pOutSample->SetSyncPoint(TRUE);
  417. if(m_SampleProps.dwSampleFlags & AM_SAMPLE_DATADISCONTINUITY)
  418. {
  419. pOutSample->SetDiscontinuity(TRUE);
  420.             m_bSampleSkipped = FALSE;
  421.         }
  423. LONGLONG MediaStart, MediaEnd;
  424.         if(pInSample->GetMediaTime(&MediaStart, &MediaEnd) == NOERROR)
  425. pOutSample->SetMediaTime(&MediaStart, &MediaEnd);
  426.     }
  428. *ppOutSample = pOutSample.Detach();
  430. return S_OK;
  431. }
  433. // pure virtual
  435. HRESULT CStreamSwitcherInputPin::CheckMediaType(const CMediaType* pmt)
  436. {
  437. return ((CStreamSwitcherFilter*)m_pFilter)->CheckMediaType(pmt);
  438. }
  440. // virtual 
  442. HRESULT CStreamSwitcherInputPin::CheckConnect(IPin* pPin)
  443. {
  444. return (IPin*)((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin() == pPin 
  445. ? E_FAIL
  446. : __super::CheckConnect(pPin);
  447. }
  449. HRESULT CStreamSwitcherInputPin::CompleteConnect(IPin* pReceivePin)
  450. {
  451. HRESULT hr = __super::CompleteConnect(pReceivePin);
  452. if(FAILED(hr)) return hr;
  454.     ((CStreamSwitcherFilter*)m_pFilter)->CompleteConnect(PINDIR_INPUT, this, pReceivePin);
  456. m_fCanBlock = false;
  457. bool fForkedSomewhere = false;
  459. CStringW fileName;
  460. CStringW pinName;
  462.     IPin* pPin = (IPin*)this;
  463. IBaseFilter* pBF = (IBaseFilter*)m_pFilter;
  465. while((pPin = GetUpStreamPin(pBF, pPin)) && (pBF = GetFilterFromPin(pPin)))
  466. {
  467. if(IsSplitter(pBF))
  468. {
  469. pinName = GetPinName(pPin);
  470. }
  472. CLSID clsid = GetCLSID(pBF);
  473. if(clsid == CLSID_AviSplitter || clsid == CLSID_OggSplitter)
  474. m_fCanBlock = true;
  476. int nIn, nOut, nInC, nOutC;
  477. CountPins(pBF, nIn, nOut, nInC, nOutC);
  478. fForkedSomewhere = fForkedSomewhere || nIn > 1 || nOut > 1;
  480. if(CComQIPtr<IFileSourceFilter> pFSF = pBF)
  481. {
  482. WCHAR* pszName = NULL;
  483. AM_MEDIA_TYPE mt;
  484. if(SUCCEEDED(pFSF->GetCurFile(&pszName, &mt)) && pszName)
  485. {
  486. fileName = pszName;
  487. CoTaskMemFree(pszName);
  489. fileName.Replace('\', '/');
  490. CStringW fn = fileName.Mid(fileName.ReverseFind('/')+1);
  491. if(!fn.IsEmpty()) fileName = fn;
  493. if(!pinName.IsEmpty()) fileName += L" / " + pinName;
  495. WCHAR* pName = new WCHAR[fileName.GetLength()+1];
  496. if(pName)
  497. {
  498. wcscpy(pName, fileName);
  499. if(m_pName) delete [] m_pName;
  500. m_pName = pName;
  501. }
  502. }
  504. break;
  505. }
  507. pPin = GetFirstPin(pBF);
  508. }
  510. if(!fForkedSomewhere)
  511. m_fCanBlock = true;
  513. m_hNotifyEvent = NULL;
  515. return S_OK;
  516. }
  518. HRESULT CStreamSwitcherInputPin::Active()
  519. {
  520. Block(!IsActive());
  522. return __super::Active();
  523. }
  525. HRESULT CStreamSwitcherInputPin::Inactive()
  526. {
  527. Block(false);
  529. return __super::Inactive();
  530. }
  532. // IPin
  534. STDMETHODIMP CStreamSwitcherInputPin::QueryAccept(const AM_MEDIA_TYPE* pmt)
  535. {
  536. HRESULT hr = __super::QueryAccept(pmt);
  537. if(S_OK != hr) return hr;
  539. return QueryAcceptDownstream(pmt);
  540. }
  542. STDMETHODIMP CStreamSwitcherInputPin::ReceiveConnection(IPin* pConnector, const AM_MEDIA_TYPE* pmt)
  543. {
  544. // FIXME: this locked up once
  545. //    CAutoLock cAutoLock(&((CStreamSwitcherFilter*)m_pFilter)->m_csReceive);
  547. HRESULT hr;
  548. if(S_OK != (hr = QueryAcceptDownstream(pmt)))
  549. return VFW_E_TYPE_NOT_ACCEPTED;
  551. if(m_Connected) 
  552. m_Connected->Release(), m_Connected = NULL;
  554. return SUCCEEDED(__super::ReceiveConnection(pConnector, pmt)) ? S_OK : E_FAIL;
  555. }
  557. STDMETHODIMP CStreamSwitcherInputPin::GetAllocator(IMemAllocator** ppAllocator)
  558. {
  559.     CheckPointer(ppAllocator, E_POINTER);
  561.     if(m_pAllocator == NULL)
  562. {
  563.         (m_pAllocator = &m_Allocator)->AddRef();
  564.     }
  566.     (*ppAllocator = m_pAllocator)->AddRef();
  568.     return NOERROR;
  569. }
  571. STDMETHODIMP CStreamSwitcherInputPin::NotifyAllocator(IMemAllocator* pAllocator, BOOL bReadOnly)
  572. {
  573. HRESULT hr = __super::NotifyAllocator(pAllocator, bReadOnly);
  574. if(FAILED(hr)) return hr;
  576. m_bUsingOwnAllocator = (pAllocator == (IMemAllocator*)&m_Allocator);
  578. return S_OK;
  579. }
  581. STDMETHODIMP CStreamSwitcherInputPin::BeginFlush()
  582. {
  583.     CAutoLock cAutoLock(&((CStreamSwitcherFilter*)m_pFilter)->m_csState);
  585. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  586.     if(!IsConnected() || !pOut || !pOut->IsConnected())
  587. return VFW_E_NOT_CONNECTED;
  589. HRESULT hr = __super::BeginFlush();
  590.     if(FAILED(hr)) 
  591. return hr;
  593. return IsActive() ? pOut->DeliverBeginFlush() : Block(false), S_OK;
  594. }
  596. STDMETHODIMP CStreamSwitcherInputPin::EndFlush()
  597. {
  598. CAutoLock cAutoLock(&((CStreamSwitcherFilter*)m_pFilter)->m_csState);
  600. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  601.     if(!IsConnected() || !pOut || !pOut->IsConnected())
  602. return VFW_E_NOT_CONNECTED;
  604. HRESULT hr = __super::EndFlush();
  605.     if(FAILED(hr)) 
  606. return hr;
  608. return IsActive() ? pOut->DeliverEndFlush() : Block(true), S_OK;
  609. }
  611. STDMETHODIMP CStreamSwitcherInputPin::EndOfStream()
  612. {
  613.     CAutoLock cAutoLock(&m_csReceive);
  615. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  616. if(!IsConnected() || !pOut || !pOut->IsConnected())
  617. return VFW_E_NOT_CONNECTED;
  619. if(m_hNotifyEvent)
  620. {
  621. SetEvent(m_hNotifyEvent), m_hNotifyEvent = NULL;
  622. return S_OK;
  623. }
  625. return IsActive() ? pOut->DeliverEndOfStream() : S_OK;
  626. }
  628. // IMemInputPin
  630. STDMETHODIMP CStreamSwitcherInputPin::Receive(IMediaSample* pSample)
  631. {
  632. AM_MEDIA_TYPE* pmt = NULL;
  633. if(SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)
  634. {
  635. const CMediaType mt(*pmt);
  636. DeleteMediaType(pmt), pmt = NULL;
  637. SetMediaType(&mt);
  638. }
  640. // DAMN!!!!!! this doesn't work if the stream we are blocking 
  641. // shares the same thread with another stream, mpeg splitters 
  642. // are usually like that. Our nicely built up multithreaded 
  643. // strategy is useless because of this, ARRRRRRGHHHHHH.
  645. #ifdef BLOCKSTREAM
  646. if(m_fCanBlock)
  647. m_evBlock.Wait();
  648. #endif
  650. if(!IsActive())
  651. {
  652. #ifdef BLOCKSTREAM
  653. if(m_fCanBlock)
  654. return S_FALSE;
  655. #endif
  657. TRACE(_T("&^%$#@n"));
  658. //Sleep(32);
  659. return E_FAIL; // a stupid fix for this stupid problem
  660. }
  662.     CAutoLock cAutoLock(&m_csReceive);
  664. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  665. ASSERT(pOut->GetConnected());
  667. HRESULT hr = __super::Receive(pSample);
  668. if(S_OK != hr) return hr;
  670. if(m_SampleProps.dwStreamId != AM_STREAM_MEDIA)
  671. {
  672. return pOut->Deliver(pSample);
  673. }
  675. //
  677. ALLOCATOR_PROPERTIES props, actual;
  678. hr = m_pAllocator->GetProperties(&props);
  679. hr = pOut->CurrentAllocator()->GetProperties(&actual);
  681. REFERENCE_TIME rtStart = 0, rtStop = 0;
  682. if(S_OK == pSample->GetTime(&rtStart, &rtStop))
  683. {
  684. //
  685. }
  687. long cbBuffer = pSample->GetActualDataLength();
  689. CMediaType mtOut = m_mt;
  690. mtOut = ((CStreamSwitcherFilter*)m_pFilter)->CreateNewOutputMediaType(mtOut, cbBuffer);
  692. bool fTypeChanged = false;
  694. if(mtOut != pOut->CurrentMediaType() || cbBuffer > actual.cbBuffer)
  695. {
  696. fTypeChanged = true;
  698. m_SampleProps.dwSampleFlags |= AM_SAMPLE_TYPECHANGED/*|AM_SAMPLE_DATADISCONTINUITY|AM_SAMPLE_TIMEDISCONTINUITY*/;
  700. /*
  701. if(CComQIPtr<IPinConnection> pPC = pOut->CurrentPinConnection())
  702. {
  703. HANDLE hEOS = CreateEvent(NULL, FALSE, FALSE, NULL);
  704. hr = pPC->NotifyEndOfStream(hEOS);
  705. hr = pOut->DeliverEndOfStream();
  706. WaitForSingleObject(hEOS, 3000);
  707. CloseHandle(hEOS);
  708. hr = pOut->DeliverBeginFlush();
  709. hr = pOut->DeliverEndFlush();
  710. }
  711. */
  713. if(props.cBuffers < 8 && mtOut.majortype == MEDIATYPE_Audio)
  714. props.cBuffers = 8;
  716. props.cbBuffer = cbBuffer;
  718. if(actual.cbAlign != props.cbAlign
  719. || actual.cbPrefix != props.cbPrefix
  720. || actual.cBuffers < props.cBuffers
  721. || actual.cbBuffer < props.cbBuffer)
  722. {
  723. hr = pOut->DeliverBeginFlush();
  724. hr = pOut->DeliverEndFlush();
  725. hr = pOut->CurrentAllocator()->Decommit();
  726. hr = pOut->CurrentAllocator()->SetProperties(&props, &actual);
  727. hr = pOut->CurrentAllocator()->Commit();
  728. }
  729. }
  731. CComPtr<IMediaSample> pOutSample;
  732. if(FAILED(InitializeOutputSample(pSample, &pOutSample)))
  733. return E_FAIL;
  735. pmt = NULL;
  736. if(SUCCEEDED(pOutSample->GetMediaType(&pmt)) && pmt)
  737. {
  738. const CMediaType mt(*pmt);
  739. DeleteMediaType(pmt), pmt = NULL;
  740. // TODO
  741. ASSERT(0);
  742. }
  744. if(fTypeChanged)
  745. {
  746. pOut->SetMediaType(&mtOut);
  747. ((CStreamSwitcherFilter*)m_pFilter)->OnNewOutputMediaType(m_mt, mtOut);
  748. pOutSample->SetMediaType(&mtOut);
  749. }
  751. // Transform
  753. hr = ((CStreamSwitcherFilter*)m_pFilter)->Transform(pSample, pOutSample);
  755. //
  757.     if(S_OK == hr)
  758. {
  759. hr = pOut->Deliver(pOutSample);
  760.         m_bSampleSkipped = FALSE;
  761. /*
  762. if(FAILED(hr))
  763. {
  764. ASSERT(0);
  765. }
  766. */
  767. }
  768.     else if(S_FALSE == hr)
  769. {
  770. hr = S_OK;
  771. pOutSample = NULL;
  772. m_bSampleSkipped = TRUE;
  774. if(!m_bQualityChanged)
  775. {
  776. m_pFilter->NotifyEvent(EC_QUALITY_CHANGE, 0, 0);
  777. m_bQualityChanged = TRUE;
  778. }
  779. }
  781. return hr;
  782. }
  784. STDMETHODIMP CStreamSwitcherInputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  785. {
  786. if(!IsConnected())
  787. return S_OK;
  789. CAutoLock cAutoLock(&m_csReceive);
  791. CStreamSwitcherOutputPin* pOut = ((CStreamSwitcherFilter*)m_pFilter)->GetOutputPin();
  792.     if(!pOut || !pOut->IsConnected())
  793. return VFW_E_NOT_CONNECTED;
  795. HRESULT hr = pOut->DeliverNewSegment(tStart, tStop, dRate);
  797. return hr;
  798. }
  801. //
  802. // CStreamSwitcherOutputPin
  803. //
  805. CStreamSwitcherOutputPin::CStreamSwitcherOutputPin(CStreamSwitcherFilter* pFilter, HRESULT* phr)
  806. : CBaseOutputPin(NAME("CStreamSwitcherOutputPin"), pFilter, &pFilter->m_csState, phr, L"Out")
  807. {
  808. // m_bCanReconnectWhenActive = TRUE;
  809. }
  811. STDMETHODIMP CStreamSwitcherOutputPin::NonDelegatingQueryInterface(REFIID riid, void **ppv)
  812. {
  813.     CheckPointer(ppv,E_POINTER);
  814.     ValidateReadWritePtr(ppv, sizeof(PVOID));
  815.     *ppv = NULL;
  817.     if(riid == IID_IMediaPosition || riid == IID_IMediaSeeking)
  818. {
  819.         if(m_pStreamSwitcherPassThru == NULL)
  820. {
  821. HRESULT hr = S_OK;
  822. m_pStreamSwitcherPassThru = (IUnknown*)(INonDelegatingUnknown*)
  823. new CStreamSwitcherPassThru(GetOwner(), &hr, (CStreamSwitcherFilter*)m_pFilter);
  825. if(!m_pStreamSwitcherPassThru) return E_OUTOFMEMORY;
  826.             if(FAILED(hr)) return hr;
  827.         }
  829.         return m_pStreamSwitcherPassThru->QueryInterface(riid, ppv);
  830.     }
  831. /*
  832. else if(riid == IID_IStreamBuilder)
  833. {
  834. return GetInterface((IStreamBuilder*)this, ppv);
  835. }
  836. */
  837. return CBaseOutputPin::NonDelegatingQueryInterface(riid, ppv);
  838. }
  840. HRESULT CStreamSwitcherOutputPin::QueryAcceptUpstream(const AM_MEDIA_TYPE* pmt)
  841. {
  842. HRESULT hr = S_FALSE;
  844. CStreamSwitcherInputPin* pIn = ((CStreamSwitcherFilter*)m_pFilter)->GetInputPin();
  846. if(pIn && pIn->IsConnected() && (pIn->IsUsingOwnAllocator() || pIn->CurrentMediaType() == *pmt))
  847. {
  848. if(CComQIPtr<IPin> pPinTo = pIn->GetConnected())
  849. {
  850. if(S_OK != (hr = pPinTo->QueryAccept(pmt)))
  851. return VFW_E_TYPE_NOT_ACCEPTED;
  852. }
  853. else
  854. {
  855. return E_FAIL;
  856. }
  857. }
  859. return hr;
  860. }
  862. // pure virtual
  864. HRESULT CStreamSwitcherOutputPin::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  865. {
  866. CStreamSwitcherInputPin* pIn = ((CStreamSwitcherFilter*)m_pFilter)->GetInputPin();
  867. if(!pIn || !pIn->IsConnected()) return E_UNEXPECTED;
  869. CComPtr<IMemAllocator> pAllocatorIn;
  870. pIn->GetAllocator(&pAllocatorIn);
  871. if(!pAllocatorIn) return E_UNEXPECTED;
  873. HRESULT hr;
  874.     if(FAILED(hr = pAllocatorIn->GetProperties(pProperties))) 
  875. return hr;
  877. if(pProperties->cBuffers < 8 && pIn->CurrentMediaType().majortype == MEDIATYPE_Audio)
  878. pProperties->cBuffers = 8;
  880. ALLOCATOR_PROPERTIES Actual;
  881.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  882. return hr;
  884. return(pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  885. ? E_FAIL
  886. : NOERROR);
  887. }
  889. // virtual
  891. [uuid("AEFA5024-215A-4FC7-97A4-1043C86FD0B8")]
  892. class MatrixMixer {};
  894. HRESULT CStreamSwitcherOutputPin::CheckConnect(IPin* pPin)
  895. {
  896. CComPtr<IBaseFilter> pBF = GetFilterFromPin(pPin);
  898. return 
  899. IsAudioWaveRenderer(pBF) || GetCLSID(pBF) == __uuidof(MatrixMixer)
  900. ? __super::CheckConnect(pPin) 
  901. : E_FAIL;
  903. // return CComQIPtr<IPinConnection>(pPin) ? CBaseOutputPin::CheckConnect(pPin) : E_NOINTERFACE;
  904. // return CBaseOutputPin::CheckConnect(pPin);
  905. }
  907. HRESULT CStreamSwitcherOutputPin::BreakConnect()
  908. {
  909. m_pPinConnection = NULL;
  910. return __super::BreakConnect();
  911. }
  913. HRESULT CStreamSwitcherOutputPin::CompleteConnect(IPin* pReceivePin)
  914. {
  915. m_pPinConnection = CComQIPtr<IPinConnection>(pReceivePin);
  916. return __super::CompleteConnect(pReceivePin);
  917. }
  919. HRESULT CStreamSwitcherOutputPin::CheckMediaType(const CMediaType* pmt)
  920. {
  921. return ((CStreamSwitcherFilter*)m_pFilter)->CheckMediaType(pmt);
  922. }
  924. HRESULT CStreamSwitcherOutputPin::GetMediaType(int iPosition, CMediaType* pmt)
  925. {
  926. CStreamSwitcherInputPin* pIn = ((CStreamSwitcherFilter*)m_pFilter)->GetInputPin();
  927. if(!pIn || !pIn->IsConnected()) return E_UNEXPECTED;
  929. CComPtr<IEnumMediaTypes> pEM;
  930. if(FAILED(pIn->GetConnected()->EnumMediaTypes(&pEM)))
  931. return VFW_S_NO_MORE_ITEMS;
  933. if(iPosition > 0 && FAILED(pEM->Skip(iPosition)))
  934. return VFW_S_NO_MORE_ITEMS;
  936. AM_MEDIA_TYPE* tmp = NULL;
  937. if(S_OK != pEM->Next(1, &tmp, NULL) || !tmp)
  938. return VFW_S_NO_MORE_ITEMS;
  940. CopyMediaType(pmt, tmp);
  941. DeleteMediaType(tmp);
  942. /*
  943. if(iPosition < 0) return E_INVALIDARG;
  944.     if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  946. CopyMediaType(pmt, &pIn->CurrentMediaType());
  947. */
  948. return S_OK;
  949. }
  951. // IPin
  953. STDMETHODIMP CStreamSwitcherOutputPin::QueryAccept(const AM_MEDIA_TYPE* pmt)
  954. {
  955. HRESULT hr = __super::QueryAccept(pmt);
  956. if(S_OK != hr) return hr;
  958. return QueryAcceptUpstream(pmt);
  959. }
  961. // IQualityControl
  963. STDMETHODIMP CStreamSwitcherOutputPin::Notify(IBaseFilter* pSender, Quality q)
  964. {
  965. CStreamSwitcherInputPin* pIn = ((CStreamSwitcherFilter*)m_pFilter)->GetInputPin();
  966. if(!pIn || !pIn->IsConnected()) return VFW_E_NOT_CONNECTED;
  967.     return pIn->PassNotify(q);
  968. }
  970. // IStreamBuilder
  972. STDMETHODIMP CStreamSwitcherOutputPin::Render(IPin* ppinOut, IGraphBuilder* pGraph)
  973. {
  974. CComPtr<IBaseFilter> pBF;
  975. pBF.CoCreateInstance(CLSID_DSoundRender);
  976. if(!pBF || FAILED(pGraph->AddFilter(pBF, L"Default DirectSound Device")))
  977. {
  978. return E_FAIL;
  979. }
  981. if(FAILED(pGraph->ConnectDirect(ppinOut, GetFirstDisconnectedPin(pBF, PINDIR_INPUT), NULL)))
  982. {
  983. pGraph->RemoveFilter(pBF);
  984. return E_FAIL;
  985. }
  987. return S_OK;
  988. }
  990. STDMETHODIMP CStreamSwitcherOutputPin::Backout(IPin* ppinOut, IGraphBuilder* pGraph)
  991. {
  992. return S_OK;
  993. }
  995. //
  996. // CStreamSwitcherFilter
  997. //
  999. CStreamSwitcherFilter::CStreamSwitcherFilter(LPUNKNOWN lpunk, HRESULT* phr, const CLSID& clsid) 
  1000. : CBaseFilter(NAME("CStreamSwitcherFilter"), lpunk, &m_csState, clsid)
  1001. {
  1002. if(phr) *phr = S_OK;
  1004. HRESULT hr = S_OK;
  1006. do
  1007. {
  1008. CAutoPtr<CStreamSwitcherInputPin> pInput;
  1009. CAutoPtr<CStreamSwitcherOutputPin> pOutput;
  1011. hr = S_OK;
  1012.         pInput.Attach(new CStreamSwitcherInputPin(this, &hr, L"Channel 1"));
  1013. if(!pInput || FAILED(hr)) break;
  1015. hr = S_OK;
  1016. pOutput.Attach(new CStreamSwitcherOutputPin(this, &hr));
  1017.         if(!pOutput || FAILED(hr)) break;
  1019. CAutoLock cAutoLock(&m_csPins);
  1020.         
  1021. m_pInputs.AddHead(m_pInput = pInput.Detach());
  1022. m_pOutput = pOutput.Detach();
  1024. return;
  1025. }
  1026. while(false);
  1028. if(phr) *phr = E_FAIL;
  1029. }
  1031. CStreamSwitcherFilter::~CStreamSwitcherFilter()
  1032. {
  1033. CAutoLock cAutoLock(&m_csPins);
  1035. POSITION pos = m_pInputs.GetHeadPosition();
  1036. while(pos) delete m_pInputs.GetNext(pos);
  1037. m_pInputs.RemoveAll();
  1038. m_pInput = NULL;
  1040. delete m_pOutput;
  1041. m_pOutput = NULL;
  1042. }
  1044. STDMETHODIMP CStreamSwitcherFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1045. {
  1046. return
  1047. QI(IAMStreamSelect)
  1048. __super::NonDelegatingQueryInterface(riid, ppv);
  1049. }
  1051. //
  1053. int CStreamSwitcherFilter::GetPinCount()
  1054. {
  1055. CAutoLock cAutoLock(&m_csPins);
  1057. return(1 + (int)m_pInputs.GetCount());
  1058. }
  1060. CBasePin* CStreamSwitcherFilter::GetPin(int n)
  1061. {
  1062. CAutoLock cAutoLock(&m_csPins);
  1064. if(n < 0 || n >= GetPinCount()) return NULL;
  1065. else if(n == 0) return m_pOutput;
  1066. else return m_pInputs.GetAt(m_pInputs.FindIndex(n-1));
  1067. }
  1069. int CStreamSwitcherFilter::GetConnectedInputPinCount()
  1070. {
  1071. CAutoLock cAutoLock(&m_csPins);
  1073. int nConnected = 0;
  1075. POSITION pos = m_pInputs.GetHeadPosition();
  1076. while(pos)
  1077. {
  1078. if(m_pInputs.GetNext(pos)->IsConnected()) 
  1079. nConnected++;
  1080. }
  1082. return(nConnected);
  1083. }
  1085. CStreamSwitcherInputPin* CStreamSwitcherFilter::GetConnectedInputPin(int n)
  1086. {
  1087. if(n >= 0)
  1088. {
  1089. POSITION pos = m_pInputs.GetHeadPosition();
  1090. while(pos)
  1091. {
  1092. CStreamSwitcherInputPin* pPin = m_pInputs.GetNext(pos);
  1093. if(pPin->IsConnected())
  1094. {
  1095. if(n == 0) return(pPin);
  1096. n--;
  1097. }
  1098. }
  1099. }
  1101. return NULL;
  1102. }
  1104. CStreamSwitcherInputPin* CStreamSwitcherFilter::GetInputPin()
  1105. {
  1106. return m_pInput;
  1107. }
  1109. CStreamSwitcherOutputPin* CStreamSwitcherFilter::GetOutputPin()
  1110. {
  1111. return m_pOutput;
  1112. }
  1114. //
  1116. HRESULT CStreamSwitcherFilter::CompleteConnect(PIN_DIRECTION dir, CBasePin* pPin, IPin* pReceivePin)
  1117. {
  1118. if(dir == PINDIR_INPUT)
  1119. {
  1120. CAutoLock cAutoLock(&m_csPins);
  1122. int nConnected = GetConnectedInputPinCount();
  1124. if(nConnected == 1)
  1125. {
  1126. m_pInput = (CStreamSwitcherInputPin*)pPin;
  1127. }
  1129. if(nConnected == m_pInputs.GetCount())
  1130. {
  1131. CStringW name;
  1132. name.Format(L"Channel %d", ++m_PinVersion);
  1134. HRESULT hr = S_OK;
  1135. CStreamSwitcherInputPin* pPin = new CStreamSwitcherInputPin(this, &hr, name);
  1136. if(!pPin || FAILED(hr)) return E_FAIL;
  1137. m_pInputs.AddTail(pPin);
  1138. }
  1139. }
  1141. return S_OK;
  1142. }
  1144. // this should be very thread safe, I hope it is, it must be... :)
  1146. void CStreamSwitcherFilter::SelectInput(CStreamSwitcherInputPin* pInput)
  1147. {
  1148. // make sure no input thinks it is active
  1149. m_pInput = NULL;
  1151. // release blocked GetBuffer in our own allocator & block all Receive
  1152. POSITION pos = m_pInputs.GetHeadPosition();
  1153. while(pos)
  1154. {
  1155. CStreamSwitcherInputPin* pPin = m_pInputs.GetNext(pos);
  1156. pPin->Block(false);
  1157. // a few Receive calls can arrive here, but since m_pInput == NULL neighter of them gets delivered
  1158. pPin->Block(true);
  1159. }
  1161. // this will let waiting GetBuffer() calls go on inside our Receive()
  1162. if(m_pOutput)
  1163. {
  1164. m_pOutput->DeliverBeginFlush();
  1165. m_pOutput->DeliverEndFlush();
  1166. }
  1168. if(!pInput) return;
  1170. // set new input
  1171. m_pInput = pInput;
  1173. // let it go
  1174. m_pInput->Block(false);
  1175. }
  1177. //
  1179. HRESULT CStreamSwitcherFilter::Transform(IMediaSample* pIn, IMediaSample* pOut)
  1180. {
  1181. BYTE* pDataIn = NULL;
  1182. BYTE* pDataOut = NULL;
  1184. HRESULT hr;
  1185. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  1186. if(FAILED(hr = pOut->GetPointer(&pDataOut))) return hr;
  1188. long len = pIn->GetActualDataLength();
  1189. long size = pOut->GetSize();
  1191. if(!pDataIn || !pDataOut /*|| len > size || len <= 0*/) return S_FALSE; // FIXME
  1193. memcpy(pDataOut, pDataIn, min(len, size));
  1194. pOut->SetActualDataLength(min(len, size));
  1196. return S_OK;
  1197. }
  1199. CMediaType CStreamSwitcherFilter::CreateNewOutputMediaType(CMediaType mt, long& cbBuffer)
  1200. {
  1201. return(mt);
  1202. }
  1204. // IAMStreamSelect
  1206. STDMETHODIMP CStreamSwitcherFilter::Count(DWORD* pcStreams)
  1207. {
  1208. if(!pcStreams) return E_POINTER;
  1210. CAutoLock cAutoLock(&m_csPins);
  1212. *pcStreams = GetConnectedInputPinCount();
  1214. return S_OK;
  1215. }
  1217. STDMETHODIMP CStreamSwitcherFilter::Info(long lIndex, AM_MEDIA_TYPE** ppmt, DWORD* pdwFlags, LCID* plcid, DWORD* pdwGroup, WCHAR** ppszName, IUnknown** ppObject, IUnknown** ppUnk)
  1218. {
  1219. CAutoLock cAutoLock(&m_csPins);
  1221. CBasePin* pPin = GetConnectedInputPin(lIndex);
  1222. if(!pPin) return E_INVALIDARG;
  1224. if(ppmt)
  1225. *ppmt = CreateMediaType(&m_pOutput->CurrentMediaType());
  1227. if(pdwFlags)
  1228. *pdwFlags = (m_pInput == pPin) ? AMSTREAMSELECTINFO_EXCLUSIVE : 0;
  1230. if(plcid)
  1231. *plcid = 0;
  1233. if(pdwGroup)
  1234. *pdwGroup = 0;
  1236. if(ppszName && (*ppszName = (WCHAR*)CoTaskMemAlloc((wcslen(pPin->Name())+1)*sizeof(WCHAR))))
  1237. wcscpy(*ppszName, pPin->Name());
  1239. if(ppObject)
  1240. *ppObject = NULL;
  1242. if(ppUnk)
  1243. *ppUnk = NULL;
  1245. return S_OK;
  1246. }
  1248. STDMETHODIMP CStreamSwitcherFilter::Enable(long lIndex, DWORD dwFlags)
  1249. {
  1250. if(dwFlags != AMSTREAMSELECTENABLE_ENABLE)
  1251. return E_NOTIMPL;
  1253. PauseGraph;
  1255. CStreamSwitcherInputPin* pNewInput = GetConnectedInputPin(lIndex);
  1256. if(!pNewInput) return E_INVALIDARG;
  1258. SelectInput(pNewInput);
  1260. ResumeGraph;
  1262. return S_OK;
  1263. }
  1265. //////////