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

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

多媒体编程

开发平台：

Visual C++

StreamDriveThru.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 "streamdrivethru.h"
  24. #include "......DSUtilDSUtil.h"
  26. #ifdef REGISTER_FILTER
  28. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  29. {
  30. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  31. };
  33. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  34. {
  35. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  36. };
  38. const AMOVIESETUP_PIN sudpPins[] =
  39. {
  40.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  41.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  42. };
  44. const AMOVIESETUP_FILTER sudFilter[] =
  45. {
  46. {&__uuidof(CStreamDriveThruFilter), L"StreamDriveThru", MERIT_DO_NOT_USE, countof(sudpPins), sudpPins}
  47. };
  49. CFactoryTemplate g_Templates[] =
  50. {
  51. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CStreamDriveThruFilter>, NULL, &sudFilter[0]}
  52. };
  54. int g_cTemplates = countof(g_Templates);
  56. STDAPI DllRegisterServer()
  57. {
  58. return AMovieDllRegisterServer2(TRUE);
  59. }
  61. STDAPI DllUnregisterServer()
  62. {
  63. return AMovieDllRegisterServer2(FALSE);
  64. }
  66. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  68. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  69. {
  70.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  71. }
  73. #endif
  75. //
  76. // CStreamDriveThruFilter
  77. //
  79. CStreamDriveThruFilter::CStreamDriveThruFilter(LPUNKNOWN pUnk, HRESULT* phr)
  80. : CBaseFilter(NAME("CStreamDriveThruFilter"), pUnk, &m_csLock, __uuidof(this))
  81. , m_position(0)
  82. {
  83. if(phr) *phr = S_OK;
  85. m_pInput = new CStreamDriveThruInputPin(NAME("CStreamDriveThruInputPin"), this, &m_csLock, phr);
  86. m_pOutput = new CStreamDriveThruOutputPin(NAME("CStreamDriveThruOutputPin"), this, &m_csLock, phr);
  88. CAMThread::Create();
  89. }
  91. CStreamDriveThruFilter::~CStreamDriveThruFilter()
  92. {
  93. CAutoLock csAutoLock(&m_csLock);
  95. CAMThread::CallWorker(CMD_EXIT);
  96. CAMThread::Close();
  98. delete m_pInput;
  99. delete m_pOutput;
  100. }
  102. STDMETHODIMP CStreamDriveThruFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  103. {
  104. CheckPointer(ppv, E_POINTER);
  106. return 
  107. QI(IMediaSeeking)
  108. __super::NonDelegatingQueryInterface(riid, ppv);
  109. }
  111. #define PACKETSIZE 65536
  113. DWORD CStreamDriveThruFilter::ThreadProc()
  114. {
  115. while(1)
  116. {
  117. DWORD cmd = GetRequest();
  119. switch(cmd)
  120. {
  121. default:
  122. case CMD_EXIT: 
  123. Reply(S_OK);
  124. return 0;
  125. case CMD_STOP:
  126. Reply(S_OK);
  127. break;
  128. case CMD_PAUSE:
  129. Reply(S_OK);
  130. break;
  131. case CMD_RUN:
  132. Reply(S_OK);
  134. do
  135. {
  136. CComPtr<IAsyncReader> pAsyncReader;
  137. CComPtr<IStream> pStream;
  139. if(!m_pInput || !m_pInput->IsConnected() || FAILED(m_pInput->GetAsyncReader(&pAsyncReader))
  140. || !m_pOutput || !m_pOutput->IsConnected() || FAILED(m_pOutput->GetStream(&pStream)))
  141. break;
  143. LARGE_INTEGER li = {0};
  144. ULARGE_INTEGER uli = {0};
  146. if(FAILED(pStream->Seek(li, STREAM_SEEK_SET, NULL))
  147. || FAILED(pStream->SetSize(uli)))
  148. break;
  150. if(CComQIPtr<IFileSinkFilter2> pFSF = GetFilterFromPin(m_pOutput->GetConnected()))
  151. {
  152. pFSF->SetMode(AM_FILE_OVERWRITE);
  154. LPOLESTR pfn;
  155. if(SUCCEEDED(pFSF->GetCurFile(&pfn, NULL)))
  156. {
  157. pFSF->SetFileName(pfn, NULL);
  158. CoTaskMemFree(pfn);
  159. }
  160. }
  162. m_position = 0;
  163. BYTE buff[PACKETSIZE];
  165. do
  166. {
  167. while(!CheckRequest(&cmd))
  168. {
  169. CAutoLock csAutoLock(&m_csLock);
  171. LONGLONG total = 0, available = 0;
  172. if(FAILED(pAsyncReader->Length(&total, &available)) || m_position >= total)
  173. {
  174. cmd = CMD_STOP;
  175. break;
  176. }
  178. LONG size = (LONG)min(PACKETSIZE, total - m_position);
  179. if(FAILED(pAsyncReader->SyncRead(m_position, size, buff)))
  180. {
  181. cmd = CMD_STOP;
  182. break;
  183. }
  185. ULONG written = 0;
  186. if(FAILED(pStream->Write(buff, (ULONG)size, &written)) || (ULONG)size != written)
  187. {
  188. cmd = CMD_STOP;
  189. break;
  190. }
  192. m_position += size;
  193. }
  195. if(cmd == CMD_PAUSE)
  196. {
  197. Reply(S_OK); // reply to CMD_PAUSE
  199. while(!CheckRequest(&cmd))
  200. Sleep(50);
  202. Reply(S_OK); // reply to something
  203. }
  204. }
  205. while(cmd == CMD_RUN);
  207. uli.QuadPart = m_position;
  208. pStream->SetSize(uli);
  210. if(CComPtr<IPin> pPin = m_pOutput->GetConnected())
  211. pPin->EndOfStream();
  212. }
  213. while(false);
  215. break;
  216. }
  217. }
  219. return 0;
  220. }
  222. int CStreamDriveThruFilter::GetPinCount()
  223. {
  224. return 2;
  225. }
  227. CBasePin* CStreamDriveThruFilter::GetPin(int n)
  228. {
  229.     CAutoLock csAutoLock(&m_csLock);
  231. if(n == 0) return m_pInput;
  232. else if(n == 1) return m_pOutput;
  234.     return NULL;
  235. }
  237. STDMETHODIMP CStreamDriveThruFilter::Stop()
  238. {
  239. HRESULT hr;
  241. if(FAILED(hr = __super::Stop()))
  242. return hr;
  244. CallWorker(CMD_STOP);
  246. return S_OK;
  247. }
  249. STDMETHODIMP CStreamDriveThruFilter::Pause()
  250. {
  251. HRESULT hr;
  253. if(FAILED(hr = __super::Pause()))
  254. return hr;
  256. CallWorker(CMD_PAUSE);
  258. return S_OK;
  259. }
  261. STDMETHODIMP CStreamDriveThruFilter::Run(REFERENCE_TIME tStart)
  262. {
  263. HRESULT hr;
  265. if(FAILED(hr = __super::Run(tStart)))
  266. return hr;
  268. CallWorker(CMD_RUN);
  270. return S_OK;
  271. }
  273. // IMediaSeeking
  275. STDMETHODIMP CStreamDriveThruFilter::GetCapabilities(DWORD* pCapabilities)
  276. {
  277. return pCapabilities ? *pCapabilities = AM_SEEKING_CanGetCurrentPos|AM_SEEKING_CanGetStopPos|AM_SEEKING_CanGetDuration, S_OK : E_POINTER;
  278. }
  279. STDMETHODIMP CStreamDriveThruFilter::CheckCapabilities(DWORD* pCapabilities)
  280. {
  281. CheckPointer(pCapabilities, E_POINTER);
  283. if(*pCapabilities == 0) return S_OK;
  285. DWORD caps;
  286. GetCapabilities(&caps);
  288. DWORD caps2 = caps & *pCapabilities;
  290. return caps2 == 0 ? E_FAIL : caps2 == *pCapabilities ? S_OK : S_FALSE;
  291. }
  292. STDMETHODIMP CStreamDriveThruFilter::IsFormatSupported(const GUID* pFormat)
  293. {
  294. return !pFormat ? E_POINTER : *pFormat == TIME_FORMAT_MEDIA_TIME ? S_OK : S_FALSE;
  295. }
  296. STDMETHODIMP CStreamDriveThruFilter::QueryPreferredFormat(GUID* pFormat)
  297. {
  298. return GetTimeFormat(pFormat);
  299. }
  300. STDMETHODIMP CStreamDriveThruFilter::GetTimeFormat(GUID* pFormat)
  301. {
  302. return pFormat ? *pFormat = TIME_FORMAT_MEDIA_TIME, S_OK : E_POINTER;
  303. }
  304. STDMETHODIMP CStreamDriveThruFilter::IsUsingTimeFormat(const GUID* pFormat)
  305. {
  306. return IsFormatSupported(pFormat);
  307. }
  308. STDMETHODIMP CStreamDriveThruFilter::SetTimeFormat(const GUID* pFormat)
  309. {
  310. return S_OK == IsFormatSupported(pFormat) ? S_OK : E_INVALIDARG;
  311. }
  312. STDMETHODIMP CStreamDriveThruFilter::GetDuration(LONGLONG* pDuration)
  313. {
  314. CheckPointer(pDuration, E_POINTER);
  315. CheckPointer(m_pInput, VFW_E_NOT_CONNECTED);
  317. if(CComQIPtr<IAsyncReader> pAsyncReader = m_pInput->GetConnected())
  318. {
  319. LONGLONG total, available;
  320. if(SUCCEEDED(pAsyncReader->Length(&total, &available)))
  321. {
  322. *pDuration = total;
  323. return S_OK;
  324. }
  325. }
  327. return E_NOINTERFACE;
  328. }
  329. STDMETHODIMP CStreamDriveThruFilter::GetStopPosition(LONGLONG* pStop)
  330. {
  331. return GetDuration(pStop);
  332. }
  333. STDMETHODIMP CStreamDriveThruFilter::GetCurrentPosition(LONGLONG* pCurrent)
  334. {
  335. return pCurrent ? *pCurrent = m_position, S_OK : E_POINTER;
  336. }
  337. STDMETHODIMP CStreamDriveThruFilter::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat) {return E_NOTIMPL;}
  338. STDMETHODIMP CStreamDriveThruFilter::SetPositions(LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags) {return E_NOTIMPL;}
  339. STDMETHODIMP CStreamDriveThruFilter::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop) {return E_NOTIMPL;}
  340. STDMETHODIMP CStreamDriveThruFilter::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest) {return E_NOTIMPL;}
  341. STDMETHODIMP CStreamDriveThruFilter::SetRate(double dRate) {return E_NOTIMPL;}
  342. STDMETHODIMP CStreamDriveThruFilter::GetRate(double* pdRate) {return E_NOTIMPL;}
  343. STDMETHODIMP CStreamDriveThruFilter::GetPreroll(LONGLONG* pllPreroll)
  344. {
  345. return pllPreroll ? *pllPreroll = 0, S_OK : E_POINTER;
  346. }
  348. //
  349. // CStreamDriveThruInputPin
  350. //
  352. CStreamDriveThruInputPin::CStreamDriveThruInputPin(TCHAR* pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  353. : CBasePin(pName, pFilter, pLock, phr, L"Input", PINDIR_INPUT)
  354. {
  355. }
  357. CStreamDriveThruInputPin::~CStreamDriveThruInputPin()
  358. {
  359. }
  361. HRESULT CStreamDriveThruInputPin::GetAsyncReader(IAsyncReader** ppAsyncReader)
  362. {
  363. CheckPointer(ppAsyncReader, E_POINTER);
  365. *ppAsyncReader = NULL;
  367. CheckPointer(m_pAsyncReader, VFW_E_NOT_CONNECTED);
  369. (*ppAsyncReader = m_pAsyncReader)->AddRef();
  371. return S_OK;
  372. }
  374. STDMETHODIMP CStreamDriveThruInputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  375. {
  376. CheckPointer(ppv, E_POINTER);
  378. return 
  379. __super::NonDelegatingQueryInterface(riid, ppv);
  380. }
  382. HRESULT CStreamDriveThruInputPin::CheckMediaType(const CMediaType* pmt)
  383. {
  384. return pmt->majortype == MEDIATYPE_Stream
  385. ? S_OK
  386. : E_INVALIDARG;
  387. }
  389. HRESULT CStreamDriveThruInputPin::CheckConnect(IPin* pPin)
  390. {
  391. HRESULT hr;
  393. if(FAILED(hr = __super::CheckConnect(pPin)))
  394. return hr;
  396. if(!CComQIPtr<IAsyncReader>(pPin))
  397. return E_NOINTERFACE;
  399. return S_OK;
  400. }
  402. HRESULT CStreamDriveThruInputPin::BreakConnect()
  403. {
  404. HRESULT hr;
  406. if(FAILED(hr = __super::BreakConnect()))
  407. return hr;
  409. m_pAsyncReader.Release();
  411. return S_OK;
  412. }
  414. HRESULT CStreamDriveThruInputPin::CompleteConnect(IPin* pPin)
  415. {
  416. HRESULT hr;
  418. if(FAILED(hr = __super::CompleteConnect(pPin)))
  419. return hr;
  421. CheckPointer(pPin, E_POINTER);
  422. m_pAsyncReader = pPin;
  423. CheckPointer(m_pAsyncReader, E_NOINTERFACE);
  425. return S_OK;
  426. }
  428. STDMETHODIMP CStreamDriveThruInputPin::BeginFlush()
  429. {
  430. return E_UNEXPECTED;
  431. }
  433. STDMETHODIMP CStreamDriveThruInputPin::EndFlush()
  434. {
  435. return E_UNEXPECTED;
  436. }
  438. //
  439. // CStreamDriveThruOutputPin
  440. //
  442. CStreamDriveThruOutputPin::CStreamDriveThruOutputPin(TCHAR* pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  443. : CBaseOutputPin(pName, pFilter, pLock, phr, L"Output")
  444. {
  445. }
  447. CStreamDriveThruOutputPin::~CStreamDriveThruOutputPin()
  448. {
  449. }
  451. HRESULT CStreamDriveThruOutputPin::GetStream(IStream** ppStream)
  452. {
  453. CheckPointer(ppStream, E_POINTER);
  455. *ppStream = NULL;
  457. CheckPointer(m_pStream, VFW_E_NOT_CONNECTED);
  459. (*ppStream = m_pStream)->AddRef();
  461. return S_OK;
  462. }
  464. STDMETHODIMP CStreamDriveThruOutputPin::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  465. {
  466. CheckPointer(ppv, E_POINTER);
  468. return 
  469. __super::NonDelegatingQueryInterface(riid, ppv);
  470. }
  472. HRESULT CStreamDriveThruOutputPin::DecideBufferSize(IMemAllocator* pAlloc, ALLOCATOR_PROPERTIES* pProperties)
  473. {
  474.     ASSERT(pAlloc);
  475.     ASSERT(pProperties);
  477.     HRESULT hr = NOERROR;
  479. pProperties->cBuffers = 1;
  480. pProperties->cbBuffer = PACKETSIZE;
  482.     ALLOCATOR_PROPERTIES Actual;
  483.     if(FAILED(hr = pAlloc->SetProperties(pProperties, &Actual))) return hr;
  485.     if(Actual.cbBuffer < pProperties->cbBuffer) return E_FAIL;
  486.     ASSERT(Actual.cBuffers == pProperties->cBuffers);
  488.     return NOERROR;
  489. }
  491. HRESULT CStreamDriveThruOutputPin::CheckMediaType(const CMediaType* pmt)
  492. {
  493. return pmt->majortype == MEDIATYPE_Stream
  494. ? S_OK
  495. : E_INVALIDARG;
  496. }
  498. HRESULT CStreamDriveThruOutputPin::GetMediaType(int iPosition, CMediaType* pmt)
  499. {
  500.     CAutoLock cAutoLock(m_pLock);
  502. if(iPosition < 0) return E_INVALIDARG;
  503. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  505. pmt->majortype = MEDIATYPE_Stream;
  506. pmt->subtype = GUID_NULL;
  507. pmt->formattype = GUID_NULL;
  508. pmt->SetSampleSize(PACKETSIZE);
  510. return S_OK;
  511. }
  513. HRESULT CStreamDriveThruOutputPin::CheckConnect(IPin* pPin)
  514. {
  515. HRESULT hr;
  517. if(FAILED(hr = __super::CheckConnect(pPin)))
  518. return hr;
  520. if(!CComQIPtr<IStream>(pPin))
  521. return E_NOINTERFACE;
  523. return S_OK;
  524. }
  526. HRESULT CStreamDriveThruOutputPin::BreakConnect()
  527. {
  528. HRESULT hr;
  530. if(FAILED(hr = __super::BreakConnect()))
  531. return hr;
  533. m_pStream.Release();
  535. return S_OK;
  536. }
  538. HRESULT CStreamDriveThruOutputPin::CompleteConnect(IPin* pPin)
  539. {
  540. HRESULT hr;
  542. if(FAILED(hr = __super::CompleteConnect(pPin)))
  543. return hr;
  545. CheckPointer(pPin, E_POINTER);
  546. m_pStream = pPin;
  547. CheckPointer(m_pStream, E_NOINTERFACE);
  549. return S_OK;
  550. }
  552. STDMETHODIMP CStreamDriveThruOutputPin::BeginFlush()
  553. {
  554. return E_UNEXPECTED;
  555. }
  557. STDMETHODIMP CStreamDriveThruOutputPin::EndFlush()
  558. {
  559. return E_UNEXPECTED;
  560. }
  562. STDMETHODIMP CStreamDriveThruOutputPin::Notify(IBaseFilter* pSender, Quality q)
  563. {
  564. return E_NOTIMPL;
  565. }