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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
Capture.cpp
资源名称：p2p_vod.rar　[点击查看]
上传用户：liguizhu
上传日期：2015-11-01
资源大小：2422k
文件大小：61k
源码类别：

P2P编程

开发平台：

Visual C++

Capture.cpp：源码内容
  1. /*
  2.  *  Openmysee
  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  *
  18.  */
  19. #include "stdafx.h"
  20. #include <atlbase.h>
  21. #include <dmodshow.h>
  22. #include <qedit.h>
  24. #include "capture.h"
  25. #include "utilities.h"
  26. #include "audiocompressselectordlg.h"
  27. #include "GVCaptureDlg.h"
  28. #include "audiochangeddlg.h"
  29. #include "videochanged.h"
  30. #include "SysConfig.h"
  31. #include "wmcodecconst.h"
  32. #include "VideoEncParams.h"
  33. #include "macros.h"
  34. #include "videoenc.h"
  35. #include "streams.h"
  37. #pragma comment(lib,"Dmoguids")
  38. #pragma comment(lib,"Winmm")
  40. //static const GUID CLSID_TVStreamSink = 
  41. //{ 0x1860c8d5, 0x370b, 0x4334, { 0x99, 0xf1, 0xb7, 0xc, 0x37, 0x9f, 0xac, 0x67 } };
  43. // {C2B146BB-C61D-4673-AF41-5079E6855401}
  44. static const GUID CLSID_TVStreamSink = 
  45. { 0xc2b146bb, 0xc61d, 0x4673, { 0xaf, 0x41, 0x50, 0x79, 0xe6, 0x85, 0x54, 0x1 } };
  47. static const GUID CLSID_FVideoOverlay =
  48. {0xae1c4226, 0xb8ec, 0x4204,  { 0xbf, 0x15, 0x92, 0x56, 0x63, 0xde, 0x51, 0x68} };
  50. //用于WM9的外部变量
  51. extern CVideoEncParams g_VideoEncodingParams;
  53. //////////////////////////////////////////////////////////////////////////
  54. //以下是构造和析构函数
  55. //////////////////////////////////////////////////////////////////////////
  56. CCaptureGraph::CCaptureGraph()
  57. {
  58. m_config = FALSE;
  59. state = NULL;
  60. sstate = 0;
  62. m_RefCount = 0;
  64. m_pGB = NULL;         // capture graph
  65. m_pVW = NULL;          // video window
  66. m_pMC = NULL;         // media control
  67. m_pTVConfig = NULL; // tv sink config
  69. // filters in graph 
  70. m_pVideoCapture = NULL;
  71. m_pVideoEncoder = NULL;
  72. m_pAudioEncoder = NULL;
  73. m_pAudioCapture = NULL;
  74. m_pTVStreamSink = NULL;
  75. m_pVideoSmartTee = NULL;
  76. m_pAudioSmartTee = NULL;
  77. m_pAVIMuxer = NULL;
  78. m_pFileWriter = NULL;
  79. m_pftrDVSpliter = NULL;
  80. m_pDVDecoder = NULL;
  81. //xiezhouwei 05-08-17添加
  82. m_pVideoOverlay = NULL;
  84. m_arrayOtherFilter.RemoveAll();
  86. m_bGraphBuiled = FALSE; 
  87. m_bIsPreview = TRUE;
  88. m_bIsOnlyAudio = FALSE;
  89. m_bSave = FALSE; // added by zk for saving 2004-04-16
  90. m_bNeedOverlay = TRUE;
  91. mbIsDV = FALSE; //added by xiezhouwei 2005-09-01
  92. m_bISCrossBar = FALSE; //默认不选择CrossBar
  94. m_strCurVideoEncoder.Empty();
  95. m_pCurAudioAMT = NULL;
  96. m_hWndOwner = NULL;
  97. ZeroMemory(m_szAVIFile,sizeof(m_szAVIFile));
  98. }
  100. CCaptureGraph::~CCaptureGraph()
  101. {
  102. Uninitialize();
  103. }
  105. STDMETHODIMP_(ULONG) CCaptureGraph::AddRef()
  106. {
  107. return ++m_RefCount;
  108. }
  110. STDMETHODIMP_(ULONG) CCaptureGraph::Release()
  111. {
  112. m_RefCount--;
  114. if(m_RefCount == 0)
  115. delete this;
  117. return m_RefCount;
  118. }
  120. STDMETHODIMP CCaptureGraph::QueryInterface(REFIID iid, void** ppInter)
  121. {
  122. // we need not to implement this now
  123. // it only for late_use
  124. return E_NOTIMPL;
  125. }
  127. STDMETHODIMP CCaptureGraph::Initialize()
  128. {
  129. HRESULT hr = CoInitialize(NULL);
  130. if (FAILED(hr))
  131. {
  132. TRACE0("ERROR - Could not initialize COM library");
  133. return hr;
  134. }
  136. // Create the filter graph manager and query for interfaces.
  137. hr = CoCreateInstance(CLSID_FilterGraph, 
  138. NULL, 
  139. CLSCTX_INPROC_SERVER, 
  140. IID_IGraphBuilder, 
  141. (void **)&m_pGB);
  142. if (FAILED(hr))
  143. {
  144. TRACE0("ERROR - Could not create the Filter Graph Manager.");
  145. return hr;
  146. }
  148. hr = m_pGB->QueryInterface(IID_IMediaControl, (void **)&m_pMC);
  149. if (FAILED(hr))
  150. {
  151. TRACE0("ERROR - Could not Get IMediaControl");
  152. return hr;
  153. }
  155. // for DEBUG
  156. #ifdef _DEBUG
  157. AddGraphToRot(m_pGB, &g_dwRegister);
  158. #endif //_DEBUG
  160. return S_OK;
  161. }
  163. STDMETHODIMP CCaptureGraph::Uninitialize()
  164. {
  165. // first unDEBUG
  166. #ifdef _DEBUG
  167. RemoveGraphFromRot(g_dwRegister);
  168. #endif //_DEBUG
  169. RemoveFilter(m_pVideoCapture);
  170. RemoveFilter(m_pAudioCapture);
  171. RemoveFilter(m_pVideoEncoder);
  172. RemoveFilter(m_pAudioEncoder);
  173. RemoveFilter(m_pVideoSmartTee);
  174. RemoveFilter(m_pAudioSmartTee);
  175. RemoveFilter(m_pTVStreamSink);
  176. RemoveFilter(m_pVideoOverlay);
  177. RemoveFilter(m_pAVIMuxer);
  178. RemoveFilter(m_pFileWriter);
  179. RemoveFilter(m_pDVDecoder);
  181. state = NULL;
  183. SAFE_RELEASE(m_pGB);
  184. SAFE_RELEASE(m_pVW);
  185. SAFE_RELEASE(m_pMC);
  186. // SAFE_RELEASE(m_pTVConfig);
  188. // filters in graph 
  189. SAFE_RELEASE(m_pVideoCapture);
  190. SAFE_RELEASE(m_pVideoEncoder);
  191. SAFE_RELEASE(m_pAudioEncoder);
  192. SAFE_RELEASE(m_pAudioCapture);
  193. // SAFE_RELEASE(m_pTVStreamSink);
  194. SAFE_RELEASE(m_pVideoSmartTee);
  195. SAFE_RELEASE(m_pAudioSmartTee);
  196. SAFE_RELEASE(m_pAVIMuxer);
  197. SAFE_RELEASE(m_pFileWriter);
  199. SAFE_RELEASE(m_pVideoOverlay);
  200. SAFE_RELEASE(m_pDVDecoder);
  202. m_hWndOwner = NULL;
  204. CoUninitialize();
  205. return S_OK;
  206. }
  208. // controls
  209. STDMETHODIMP CCaptureGraph::Run()
  210. {
  211. HRESULT hr;
  212. if(!m_bGraphBuiled)
  213. {
  214. if(FAILED(BuildGraph()))
  215. {
  216. DisassembleGraph();
  217. return E_FAIL;
  218. }
  219. }
  221. CComPtr <IVideoWindow> lpVideoWindow;
  222. hr = m_pGB->QueryInterface(IID_IVideoWindow, (void**)&lpVideoWindow);
  223. if (FAILED(hr))
  224. {
  225. return hr;
  226. }
  227. hr = lpVideoWindow->put_Visible(OATRUE);
  229. ASSERT(m_pMC);
  230. return m_pMC->Run();
  231. }
  233. STDMETHODIMP CCaptureGraph::Stop()
  234. {
  235. HRESULT hr;
  236. ASSERT(m_pMC);
  238. CComPtr <IVideoWindow> lpVideoWindow;
  239. hr = m_pGB->QueryInterface(IID_IVideoWindow, (void**)&lpVideoWindow);
  240. if (FAILED(hr))
  241. {
  242. return hr;
  243. }
  244. hr = lpVideoWindow->put_AutoShow(OAFALSE);
  245. hr = lpVideoWindow->put_Visible(OAFALSE);
  247. return m_pMC->Stop();
  248. }
  250. STDMETHODIMP CCaptureGraph::Pause()
  251. {
  252. ASSERT(m_pMC);
  253. return m_pMC->Pause();
  254. }
  256. // enums,it respectively call EnumSpeciFilters
  257. // with diffrent specification
  258. STDMETHODIMP CCaptureGraph::EnumVideoCapDevices(CStringArray &strArrayType)
  259. {
  260. return EnumSpeciFilters(VIDEO_CAP, strArrayType);
  261. }
  263. STDMETHODIMP CCaptureGraph::EnumAudioCapDevices(CStringArray &strArrayType)
  264. {
  265.     return EnumSpeciFilters(AUDIO_CAP, strArrayType);
  266. }
  268. STDMETHODIMP CCaptureGraph::EnumVideoEncoders(CStringArray &strArrayType)
  269. {
  270. return EnumSpeciFilters(VIDEO_COMPRESS, strArrayType);
  271. }
  273. STDMETHODIMP CCaptureGraph::EnumAudioEncoders(CStringArray &strArrayType)
  274. {
  275. return EnumSpeciFilters(AUDIO_COMPRESS, strArrayType);
  276. }
  278. // configs
  279. STDMETHODIMP CCaptureGraph::ConfigVideoCapDeviceByName(HWND hParent)
  280. {
  281. if (NULL == m_pVideoCapture)
  282. {
  283. AfxMessageBox("视频采集设备未找到");
  284. return S_OK;
  285. }
  286. // must be added in the graph this time
  287. m_pGB->AddFilter(m_pVideoCapture, NULL);
  288. /*
  289. * FIRST: prompt user to set filter configuration
  290. */
  292. // Get property page interface 
  293. HRESULT hr;
  294. IAMVfwCaptureDialogs* pDlg;
  295. hr = m_pVideoCapture->QueryInterface(IID_IAMVfwCaptureDialogs, (void**)(&pDlg));
  296. if(!FAILED(hr))
  297. {
  298. if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Format)))
  299. {
  300. hr = pDlg->ShowDialog(VfwCaptureDialog_Format, hParent);
  301. }
  302. if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Source)))
  303. {
  304. hr = pDlg->ShowDialog(VfwCaptureDialog_Source, hParent);
  305. }
  306. if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Display)))
  307. {
  308. hr = pDlg->ShowDialog(VfwCaptureDialog_Display, hParent);
  309. }
  310. return hr;
  311. }
  312. ISpecifyPropertyPages *pSpec;
  313. hr = m_pVideoCapture->QueryInterface(IID_ISpecifyPropertyPages, (void**)(&pSpec));
  314. if(FAILED(hr))
  315. {
  316. return E_FAIL;
  317. }
  319. // Popup page
  320. CString str(_T("Video Capture Configuration 1")); // dlg caption
  321. WCHAR wstrCaption[256];
  323. CAUUID cauuid;
  324. pSpec->GetPages(&cauuid);
  325. pSpec->Release();
  326. if(cauuid.cElems >= 1)
  327. {
  328. MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  329. str.GetBuffer(str.GetLength()), -1, 
  330. wstrCaption, sizeof(wstrCaption) / sizeof(WCHAR));
  332. hr = OleCreatePropertyFrame(hParent, 30, 30, wstrCaption, 1,
  333. (IUnknown **)&m_pVideoCapture, cauuid.cElems,
  334. (GUID *)cauuid.pElems, 0, 0, NULL);
  335. if(FAILED(hr))
  336. {
  337. CoTaskMemFree(cauuid.pElems);
  338. pSpec->Release();
  339. return E_FAIL;
  340. }
  341. }
  343. // Destructor
  344. CoTaskMemFree(cauuid.pElems);
  345. return S_OK;
  346. }
  348. // configs
  349. STDMETHODIMP CCaptureGraph::ConfigAudioCapDeviceByName(HWND hParent)
  350. {
  351.     if (NULL == m_pAudioCapture)
  352.     {
  353.         AfxMessageBox("视频采集设备未找到");
  354.         return S_OK;
  355.     }
  356.     // must be added in the graph this time
  357.     m_pGB->AddFilter(m_pAudioCapture, NULL);
  358.     /*
  359.     * FIRST: prompt user to set filter configuration
  360.     */
  362.     // Get property page interface 
  363.     HRESULT hr;
  364.     IAMVfwCaptureDialogs* pDlg;
  365.     hr = m_pAudioCapture->QueryInterface(IID_IAMVfwCaptureDialogs, (void**)(&pDlg));
  366.     if(!FAILED(hr))
  367.     {
  368.         if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Format)))
  369.         {
  370.             hr = pDlg->ShowDialog(VfwCaptureDialog_Format, hParent);
  371.         }
  372.         if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Source)))
  373.         {
  374.             hr = pDlg->ShowDialog(VfwCaptureDialog_Source, hParent);
  375.         }
  376.         if ( !FAILED(pDlg->HasDialog(VfwCaptureDialog_Display)))
  377.         {
  378.             hr = pDlg->ShowDialog(VfwCaptureDialog_Display, hParent);
  379.         }
  380.         return hr;
  381.     }
  382.     ISpecifyPropertyPages *pSpec;
  383.     hr = m_pAudioCapture->QueryInterface(IID_ISpecifyPropertyPages, (void**)(&pSpec));
  384.     if(FAILED(hr))
  385.     {
  386.         return E_FAIL;
  387.     }
  389.     // Popup page
  390.     CString str(_T("Audio Capture Configuration 1")); // dlg caption
  391.     WCHAR wstrCaption[256];
  393.     CAUUID cauuid;
  394.     pSpec->GetPages(&cauuid);
  395.     pSpec->Release();
  396.     if(cauuid.cElems >= 1)
  397.     {
  398.         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  399.             str.GetBuffer(str.GetLength()), -1, 
  400.             wstrCaption, sizeof(wstrCaption) / sizeof(WCHAR));
  402.         hr = OleCreatePropertyFrame(hParent, 30, 30, wstrCaption, 1,
  403.             (IUnknown **)&m_pAudioCapture, cauuid.cElems,
  404.             (GUID *)cauuid.pElems, 0, 0, NULL);
  405.         if(FAILED(hr))
  406.         {
  407.             CoTaskMemFree(cauuid.pElems);
  408.             pSpec->Release();
  409.             return E_FAIL;
  410.         }
  411.     }
  413.     // Destructor
  414.     CoTaskMemFree(cauuid.pElems);
  415.     return S_OK;
  416. }
  418. //Arthur?
  419. bool isEqualFOURCC(FOURCC fccA, FOURCC fccB) {
  420. int i;
  422. for(i=0; i<4; i++) {
  423. if (tolower((unsigned char)fccA) != tolower((unsigned char)fccB))
  424. return false;
  426. fccA>>=8;
  427. fccB>>=8;
  428. }
  430. return true;
  431. }
  433. ////////////////
  434. HIC hic=0;
  435. BYTE *pState = NULL;
  436. int size = 0;
  437. ICINFO in;
  438. STDMETHODIMP CCaptureGraph::ConfigVideoEncoderByName(HWND hParent)
  439. {
  440. HRESULT hr;
  441. if (NULL == m_pVideoEncoder)
  442. {
  443. return E_FAIL;
  444. }
  446. if (NULL == hParent)
  447. {
  448. AfxMessageBox("hParent不能为空");
  449. }
  451. hr = m_pGB->AddFilter(m_pVideoEncoder, NULL);
  452. if (FAILED(hr))
  453. {
  454. return E_FAIL;
  455. }
  456. if (TRUE == IsDMOFilter())
  457. {
  459. return S_OK;
  460. }
  462. //ASSERT(m_pVideoEncoder);
  463. if(hic)
  464. {
  465. ICClose(hic);
  466. TRACE("hic值为：%d",hic);
  467. }
  468. //Arthur:？将压缩信息中ICTYPE_VIDEO进行枚举。若能打开则取出他的信息。
  469. //判断它的描述信息是否和当前的m_strCurVideoEncoder一致。一致则显示配置
  470. //配置信息框。（若pState中有可设置的值。则将之，设入。?是否会将上次的
  471. //pState设置到这次的hic中去。）再用ICGetState得到信息。再将之设回去？？
  472. //何必呢？并将之保存在state变量中。
  473. //一切连接好后，若用户选择马上中断则会，将全部filter移出。若不是则将之
  474. //移出后再立刻接上会不会有问题，是否执行了重定位操作。
  475. ICINFO info;
  476. for(int i=0; ICInfo(ICTYPE_VIDEO, i, &info); i++)//Arthur：该函数的用法逐步取出i个ICINFO结构。
  477. {
  478. hic = ICOpen(info.fccType, info.fccHandler, ICMODE_COMPRESS);//Arthur:打开该压缩器。
  479. if(hic == NULL)
  480. continue;
  482. ICINFO ici = { sizeof(ICINFO) };
  483. CHAR* lpszDes;
  484. if (ICGetInfo(hic, &ici, sizeof(ICINFO)))//Arthur:得到该压缩器。并将描述信息放入
  485. //lpszDes中
  486. {
  487. int cch = lstrlenW(ici.szDescription) + 1;
  488. lpszDes = new char[cch * 2];
  489. if (!lpszDes)
  490. {
  491. AfxMessageBox("开辟描述名buf失败");
  492. return E_OUTOFMEMORY;
  493. }
  494. WideCharToMultiByte(GetACP(), 0, ici.szDescription, 
  495. -1,lpszDes, cch, NULL, NULL); 
  496. }
  498. if(CString(lpszDes) == m_strCurVideoEncoder)//若取出的，是自己要的
  499. {
  500. if(ICQueryConfigure(hic))
  501. {
  502. if (state)
  503. ICSetState(hic, state, sstate);
  505. if (NULL == hParent || 0 == hic)
  506. {
  507. AfxMessageBox("父窗口指针为空，无法显示");
  508. return E_FAIL;
  509. }
  510. ICConfigure(hic, hParent);//Arthur:显示该压缩码的对话框。
  511. if(pState)
  512. delete [] pState;
  514. size = ICGetStateSize(hic);
  515. pState = new BYTE[size];
  516. if (0 == hic || NULL == pState)
  517. {
  518. AfxMessageBox("pState为零");
  519. return E_FAIL;
  520. }
  521. int nt = ICGetState(hic, pState, size);//Arthur:得到hic此时的状态信息
  522. if(nt > 0)
  523. {
  524. m_config = TRUE;
  525. if (NULL == state)
  526. {
  527. state=new BYTE[size + 1];
  528. if (NULL == state)
  529. {
  530. AfxMessageBox("State为零");
  531. return E_FAIL;
  532. }
  533. }
  534. ICSetState(hic, pState, size);//为什么要重新设置一次，此时pState的信息已经是完善了的。
  535. memcpy(state,pState,size);
  536. sstate=size;
  537. }
  538. }
  539. if (lpszDes)
  540. {
  541. delete [] lpszDes;
  542. }
  543. break;
  544. }
  546. ICClose(hic);
  547. hic = 0;
  548. if (lpszDes)
  549. {
  550. delete [] lpszDes;
  551. }
  552. }
  553. OAFilterState ofs;
  554. m_pMC->GetState(1000, &ofs);
  556. if(ofs == State_Running)
  557. {
  558. CVideoChanged vc;
  559. if(vc.DoModal() == IDOK)
  560. {
  561. CWnd wd;
  562. wd.Attach(m_hWndOwner);
  563. ((CGVCaptureDlg*)wd.GetParent())->OnNotifyStop();
  564. DisassembleGraph();
  565. ((CGVCaptureDlg*)wd.GetParent())->OnNotifyPlay();
  566. wd.Detach();
  567. }
  568. }
  569. else
  570. {
  571. if(m_bGraphBuiled)
  572. {
  573. DisassembleGraph();
  574. if(FAILED(BuildGraph()))
  575. {
  576. DisassembleGraph();
  577. return E_FAIL;
  578. }
  579. }
  580. }
  582. return S_OK;
  583. }
  585. STDMETHODIMP CCaptureGraph::ConfigAudioEncoderByName(HWND hParent)
  586. {
  587. if (NULL == m_pAudioEncoder)
  588. {
  589. return E_FAIL;
  590. }
  592. if (NULL == m_hWndOwner)
  593. {
  594. AfxMessageBox("m_hWndOwner不能为空");
  595. }
  597. CWnd wnd;
  598. wnd.Attach(m_hWndOwner);
  600. CAudioCompressSelectorDlg afs(this, &wnd);
  601. if(afs.DoModal()== IDOK)
  602. {
  603. OAFilterState ofs;
  604. m_pMC->GetState(1000, &ofs);
  606. if(ofs == State_Running)
  607. {
  608. CAudioChangedDlg vc;
  609. if(vc.DoModal() == IDOK)
  610. {
  611. AfxMessageBox("不可能执行的代码");
  612. ((CGVCaptureDlg*)wnd.GetParent())->OnNotifyStop();
  613. DisassembleGraph();
  614. ((CGVCaptureDlg*)wnd.GetParent())->OnNotifyPlay();
  615. }
  616. }
  617. else
  618. {
  619. if(m_bGraphBuiled)
  620. {
  621. DisassembleGraph();
  622. if(FAILED(BuildGraph()))
  623. {
  624. wnd.Detach();
  625. DisassembleGraph();
  626. return E_FAIL;
  627. }
  628. }
  629. }
  630. }
  632. wnd.Detach();
  634. return S_OK;
  635. }
  638. //系统设置框
  639. STDMETHODIMP CCaptureGraph::ConfigSysCfg(HWND hParent)
  640. {
  641. CSysConfig afs;
  642. afs.DoModal();
  643. return S_OK;
  644. }
  646. // some filter creations must be implemented by enumulator
  647. // implemented with FindFilterByName auxily function
  648. HRESULT CCaptureGraph::CreateVideoCapDeviceFilterByName(LPTSTR strName)
  649. {
  650. // here we disassamble the graph
  651. if (m_bGraphBuiled)
  652. {
  653. DisassembleGraph();
  654. }
  657. RemoveFilter(m_pVideoCapture);
  658. SAFE_RELEASE(m_pVideoCapture);
  660. FindFilterByName(strName, &m_pVideoCapture, VIDEO_CAP);
  661. if(m_pVideoCapture == NULL)
  662. {
  663. TRACE0("no this filte in system");
  664. return S_FALSE;
  665. }
  667. return NOERROR;
  668. }
  670. // some filter creations must be implemented by enumulator
  671. // implemented with FindFilterByName auxily function
  672. HRESULT CCaptureGraph::CreateAudioCapDeviceFilterByName(LPTSTR strName)
  673. {
  674.     // here we disassamble the graph
  675.     if (m_bGraphBuiled)
  676.     {
  677.         DisassembleGraph();
  678.     }
  681.     RemoveFilter(m_pAudioCapture);
  682.     SAFE_RELEASE(m_pAudioCapture);
  684.     FindFilterByName(strName, &m_pAudioCapture, AUDIO_CAP);
  685.     if(m_pAudioCapture == NULL)
  686.     {
  687.         TRACE0("no this filte in system");
  688.         return S_FALSE;
  689.     }
  691.     return NOERROR;
  692. }
  694. BOOL CCaptureGraph::IsDMOFilter()
  695. {
  696. HRESULT hr;
  697. IDMOWrapperFilter *pDmoWrapper;
  698. hr = m_pVideoEncoder->QueryInterface(IID_IDMOWrapperFilter, (void**)&pDmoWrapper);
  699. if (SUCCEEDED(hr)) 
  700. {
  701. return TRUE;
  702. }
  703. return FALSE;
  704. }
  706. STDMETHODIMP CCaptureGraph::BuildVideoDMOEncoder()
  707. {
  708. AM_MEDIA_TYPE mtIn, mtOut;
  709. mtIn.majortype = MEDIATYPE_Video; //set this for the call to "Connect Filters"
  710. mtIn.cbFormat = 0;
  712. GetInputMediaType(m_pVideoCapture, mtIn); //S_FALSE is ok here
  714. // now connect these filters and render them
  715. if (NULL == m_pVideoOverlay)
  716. {
  717. if(FAILED(ConnectPins(m_pVideoCapture, NULL, m_pVideoEncoder, NULL, &mtIn)))
  718. {
  719. AfxMessageBox("不能进行播放，请重新选择视频编码器。");
  720. return E_FAIL;
  721. }
  722. }
  723. else
  724. {
  725. if(FAILED(ConnectPins(m_pVideoOverlay, NULL, m_pVideoEncoder, NULL, &mtIn)))
  726. {
  727. AfxMessageBox("不能进行播放，请重新选择视频编码器。");
  728. return E_FAIL;
  729. }
  730. }
  732. CComQIPtr<IMediaObject, &IID_IMediaObject> pDMO(m_pVideoEncoder);
  733. ConfigureDMO(pDMO, &mtIn, &mtOut);
  735. // Get Wrapper's output pin
  736. IPin* pOutPin = FindPinOnFilter( m_pVideoEncoder, NULL, PINDIR_OUTPUT );
  737. if(pOutPin == NULL)
  738. {
  739. TRACE("Failed to get wrapper's output pin!");
  740. return E_FAIL;
  741. }
  743. // Set the output media type
  744. CComQIPtr<IAMStreamConfig, &IID_IAMStreamConfig> pIAMStreamConfig( pOutPin );    
  745. ON_QI_FAIL("Failed to QI for IAMStreamConfig!", pIAMStreamConfig)
  747. // Set the media type
  748. HRESULT hr = pIAMStreamConfig->SetFormat( &mtOut );
  749. ON_FAIL("Failed to set wrapper's output type!", hr)
  751. FreeMediaType(mtIn);
  752. FreeMediaType(mtOut);
  754. return S_OK;
  755. }
  757. HRESULT CCaptureGraph::CreateV9EncoderFilter()
  758. {
  759. // here we disassamble the graph
  760. // DisassembleGraph();
  762. HRESULT hr = CoCreateInstance(CLSID_DMOWrapperFilter, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&m_pVideoEncoder);
  763. if (SUCCEEDED(hr)) 
  764. {
  765. // Query for IDMOWrapperFilter.
  766. IDMOWrapperFilter *pDmoWrapper;
  767. hr = m_pVideoEncoder->QueryInterface(IID_IDMOWrapperFilter, (void**)&pDmoWrapper);
  768. if (SUCCEEDED(hr)) 
  769. {     
  770. // Initialize the filter.
  771. hr = pDmoWrapper->Init(CLSID_CWMVEncMediaObject2, CLSID_VideoCompressorCategory); 
  772. pDmoWrapper->Release();
  774. if (SUCCEEDED(hr)) 
  775. {
  776. // Add the filter to the graph.
  777. hr = m_pGB->AddFilter(m_pVideoEncoder, L"My DMO");
  778. }
  779. }
  780. }
  782. return hr;
  783. }
  785. HRESULT CCaptureGraph::CreateVideoEncoderFilterByName(LPTSTR strName)
  786. {
  787. // here we disassamble the graph
  788. if (NULL == strName)
  789. {
  790. AfxMessageBox("Filter名称为空");
  791. return E_FAIL;
  792. }
  793. if (m_bGraphBuiled)
  794. {
  795. DisassembleGraph();
  796. }
  798. RemoveFilter(m_pVideoEncoder);
  799. SAFE_RELEASE(m_pVideoEncoder);
  801. if (0 == strcmp(strName, "MicroSoft Media 9 DMO"))
  802. {
  803. CreateV9EncoderFilter();
  804. }
  805. else
  806. {
  807. FindFilterByName(strName, &m_pVideoEncoder, VIDEO_COMPRESS);
  808. }
  809. if(m_pVideoEncoder == NULL)
  810. {
  811. TRACE0("no this filte in system");
  812. return S_FALSE;
  813. }
  815. m_strCurVideoEncoder = strName;
  817. return NOERROR;
  818. }
  820. HRESULT CCaptureGraph::CreateAudioEncoderFilterByName(LPTSTR strName)
  821. {
  822. // here we disassamble the graph
  823. if (NULL == strName)
  824. {
  825. AfxMessageBox("Filter名称为空");
  826. return E_FAIL;
  827. }
  828. if (m_bGraphBuiled)
  829. {
  830. DisassembleGraph();
  831. }
  833. RemoveFilter(m_pAudioEncoder);
  834. SAFE_RELEASE(m_pAudioEncoder);
  836. FindFilterByName(strName, &m_pAudioEncoder, AUDIO_COMPRESS);
  837. if (m_pAudioEncoder == NULL)
  838. {
  839. TRACE0("no this filte in system");
  840. return S_FALSE;
  841. }
  843. if(m_pCurAudioAMT)
  844. {
  845. HeapFree(GetProcessHeap(), 0, m_pCurAudioAMT);
  846. m_pCurAudioAMT = NULL;
  847. }
  849. return NOERROR;
  850. }
  851. //xiezhouwei 05-08-17 添加
  852. /*
  853. // 设置是否需要字幕的
  854. void CCaptureGraph::SetNeedOverlay(bool abNeedOverlay)
  855. {
  856. m_bNeedOverlay = abNeedOverlay;
  857. }
  858. */
  860. //初始化字幕Filter
  861. HRESULT CCaptureGraph::CreateUideoOverlay()
  862. {
  863. HRESULT hr;
  864. hr = CoCreateInstance(CLSID_FVideoOverlay, 
  865. NULL, 
  866. CLSCTX_INPROC, 
  867. IID_IBaseFilter,
  868. (void **)&m_pVideoOverlay);
  869. if(FAILED(hr))
  870. {
  871. TRACE("Could not instantiate VideoOverlay filter");
  872. }
  873. return hr;
  874. }
  876. //配置字幕property。
  877. HRESULT CCaptureGraph::ConfigVideoOverlay(HWND hParent)
  878. {
  879. ASSERT(m_pVideoOverlay);
  881. HRESULT hr;
  882. ISpecifyPropertyPages *pSpec;
  883. hr = m_pVideoOverlay->QueryInterface(IID_ISpecifyPropertyPages, (void**)(&pSpec));
  884. if(FAILED(hr))
  885. {
  886. return E_FAIL;
  887. }
  888. // Popup page
  889. CAUUID cauuid;
  890. pSpec->GetPages(&cauuid);
  891. if(cauuid.cElems >= 1)
  892. {
  893. hr = OleCreatePropertyFrame(NULL, 30, 30, /*wstrCaption*/NULL, 1,
  894. (IUnknown **)&pSpec, cauuid.cElems,
  895. (GUID *)cauuid.pElems, 0, 0, NULL);
  896. if(FAILED(hr))
  897. {
  898. CoTaskMemFree(cauuid.pElems);
  899. pSpec->Release();
  900. return hr;
  901. }
  902. }
  904. // Destructor
  905. CoTaskMemFree(cauuid.pElems);
  906. pSpec->Release();
  907. return hr;
  908. }
  910. //释放掉字幕filter
  911. void CCaptureGraph::ReleaseUideoOverlay()
  912. {
  913. //DisassembleGraph();
  914. if (TRUE == m_bGraphBuiled)
  915. {
  916. DisassembleGraph();
  917. }
  918. RemoveFilter(m_pVideoOverlay);
  919. SAFE_RELEASE(m_pVideoOverlay);
  920. }
  921. // preview
  922. VOID CCaptureGraph::SetPreview(BOOL bIsPreview)
  923. {
  924. if(m_bGraphBuiled)
  925. {
  926. if(bIsPreview)
  927. {
  928. m_pVW->put_Owner((OAHWND)m_hWndOwner);
  929. m_pVW->put_WindowStyle(WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN);
  931. CRect rc;
  932. GetClientRect(m_hWndOwner, &rc);
  933. m_pVW->put_Top(0);
  934. m_pVW->put_Left(0);
  935. m_pVW->put_Width(rc.Width());
  936. m_pVW->put_Height(rc.Height());
  938. m_pVW->put_Visible(-1);
  939. m_pVW->put_AutoShow(-1);
  940. }
  941. else
  942. {
  943. m_pVW->put_Visible(0);
  944. m_pVW->put_AutoShow(0);
  945. m_pVW->put_Owner(NULL);
  946. }
  947. }
  949. m_bIsPreview = bIsPreview;
  950. }
  952. void CCaptureGraph::SetOnlyAudio( BOOL bIsOnlyAudio )
  953. {
  954. OAFilterState ofs;
  955. m_pMC->GetState(1000, &ofs);
  957. m_bIsOnlyAudio = bIsOnlyAudio;
  959. if(ofs == State_Running)
  960. {
  961. //将对wd的操作解除。因为在DisassembleGraph中会会做的，
  962. //如果不解除，因为attach操作不允许同时做两遍，会导致断言。
  963. CWnd wd;
  964. wd.Attach(m_hWndOwner);
  965. ((CGVCaptureDlg*)wd.GetParent())->OnNotifyStop();
  966. DisassembleGraph();
  967. ((CGVCaptureDlg*)wd.GetParent())->OnNotifyPlay();
  968. wd.Detach();
  969. }
  970. else
  971. {
  972. if(m_bGraphBuiled)
  973. {
  974. DisassembleGraph();
  975. if(FAILED(BuildGraph()))
  976. DisassembleGraph();
  977. }
  978. }
  979. }
  981. STDMETHODIMP CCaptureGraph::AddFilter(CLSID clsidFilter,    
  982.   IBaseFilter** ppIFilter,
  983.   LPCTSTR pstrFilterName)
  984. {
  985. HRESULT hr;
  986. ASSERT(m_pGB);
  987. ASSERT(ppIFilter);
  988. (*ppIFilter) = NULL;
  990. // try to instantiate the filter
  991. hr = CoCreateInstance(clsidFilter, 
  992. NULL, 
  993. CLSCTX_INPROC, 
  994. IID_IBaseFilter,
  995. (LPVOID*)(ppIFilter));
  996. if(FAILED(hr))
  997. {
  998. TRACE("Could not instantiate filter");
  999. return hr;
  1000. }
  1002. // Check for unicode or not
  1003. #ifndef _UNICODE
  1004. if(pstrFilterName)
  1005. {
  1006. // not unicode, we need to unicodify the string
  1007. WCHAR wstrFilterName[256];
  1008. MultiByteToWideChar(CP_ACP, 
  1009. MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  1010. pstrFilterName,
  1011. -1, 
  1012. wstrFilterName, 
  1013. sizeof(wstrFilterName) / sizeof(WCHAR));
  1015. // try to add it to the filter graph
  1016. hr = m_pGB->AddFilter(*ppIFilter, wstrFilterName);
  1017. }
  1018. else
  1019. {
  1020. // No filter name specified, cannot convert
  1021. // try to add it to the filter graph
  1022. hr = m_pGB->AddFilter(*ppIFilter, NULL);
  1023. }
  1024. #else
  1025. // already unicode, no need to change anything
  1026. // try to add it to the filter graph
  1027. hr = m_pGB->AddFilter(*ppIFilter, pstrFilterName);
  1028. #endif
  1030. // check the result of the operation
  1031. if(FAILED(hr))
  1032. {
  1033. TRACE("Could not add filter to filter graphn");
  1034. // free the filter definitely
  1035. (*ppIFilter)->Release();
  1036. (*ppIFilter) = NULL;
  1037. return hr;
  1038. }
  1040. // that's it
  1041. return hr;
  1042. }
  1044. STDMETHODIMP CCaptureGraph::RemoveFilter(IBaseFilter* pIFilter)
  1045. {
  1046. HRESULT hr;
  1048. // Parameters...
  1049. if(!pIFilter)
  1050. // DON'T return an error, this is expected
  1051. return NOERROR;
  1053. ASSERT(m_pGB);
  1055. // Just remove it from the graph
  1056. hr = m_pGB->RemoveFilter(pIFilter);
  1058. // Check the result
  1059. if(FAILED(hr))
  1060. TRACE("Could not remove filter from filter graphn");
  1062. return hr;
  1063. }
  1065. STDMETHODIMP CCaptureGraph::ConnectPins(IBaseFilter* pIFilterOutput, 
  1066. LPCTSTR pstrPinNameOutput,
  1067. IBaseFilter* pIFilterInput, 
  1068. LPCTSTR pstrPinNameInput,
  1069. AM_MEDIA_TYPE* pmt)
  1070. {
  1071. HRESULT hr;
  1072. ASSERT(m_pGB);
  1074. // Parameters...
  1075. if((!pIFilterOutput) || (!pIFilterInput))
  1076. {
  1077. ASSERT(pIFilterOutput && pIFilterInput);
  1078. TRACE("ConnectPins called with NULL parametern");
  1079. return E_INVALIDARG;
  1080. }
  1082. // Find the first pin
  1083. IPin* pIPinOutput = FindPinOnFilter(pIFilterOutput, 
  1084. pstrPinNameOutput,
  1085. PINDIR_OUTPUT);
  1086. if(!pIPinOutput)
  1087. {
  1088. ASSERT(pIPinOutput);
  1089. return E_FAIL;
  1090. }
  1092. // Find the second pin
  1093. IPin* pIPinInput = FindPinOnFilter(pIFilterInput,
  1094. pstrPinNameInput,
  1095. PINDIR_INPUT);
  1096. if(!pIPinInput)
  1097. {
  1098. ASSERT(pIPinInput);
  1099. // release the other pin
  1100. pIPinOutput->Release();
  1101. return E_FAIL;
  1102. }
  1104. if(FAILED(pIPinOutput->Disconnect()))
  1105. {
  1106. ASSERT(FALSE);
  1107. return E_FAIL;
  1108. }
  1110. if(FAILED(pIPinInput->Disconnect()))
  1111. {
  1112. ASSERT(FALSE);
  1113. return E_FAIL;
  1114. }
  1116. // Now just connect the two pins
  1117. hr = m_pGB->ConnectDirect(pIPinOutput, pIPinInput, pmt);
  1118. ASSERT(SUCCEEDED(hr));
  1119. if(FAILED(hr))
  1120. TRACE("Could not connect pins!");
  1122. // Release the two pins and return the result
  1123. pIPinOutput->Release();
  1124. pIPinInput->Release();
  1126. return hr;
  1127. }
  1129. //自动连接Filter
  1130. STDMETHODIMP CCaptureGraph::ConnectAutoPins(IBaseFilter* pIFilterOutput, 
  1131. LPCTSTR pstrPinNameOutput,
  1132. IBaseFilter* pIFilterInput, 
  1133. LPCTSTR pstrPinNameInput)
  1134. {
  1135. HRESULT hr;
  1136. ASSERT(m_pGB);
  1138. // Parameters...
  1139. if((!pIFilterOutput) || (!pIFilterInput))
  1140. {
  1141. ASSERT(pIFilterOutput && pIFilterInput);
  1142. TRACE("ConnectPins called with NULL parametern");
  1143. return E_INVALIDARG;
  1144. }
  1146. // Find the first pin
  1147. IPin* pIPinOutput = FindPinOnFilter(pIFilterOutput, 
  1148. pstrPinNameOutput,
  1149. PINDIR_OUTPUT);
  1150. if(!pIPinOutput)
  1151. {
  1152. ASSERT(pIPinOutput);
  1153. return E_FAIL;
  1154. }
  1156. // Find the second pin
  1157. IPin* pIPinInput = FindPinOnFilter(pIFilterInput,
  1158. pstrPinNameInput,
  1159. PINDIR_INPUT);
  1160. if(!pIPinInput)
  1161. {
  1162. ASSERT(pIPinInput);
  1163. // release the other pin
  1164. pIPinOutput->Release();
  1165. return E_FAIL;
  1166. }
  1168. if(FAILED(pIPinOutput->Disconnect()))
  1169. {
  1170. ASSERT(FALSE);
  1171. return E_FAIL;
  1172. }
  1174. if(FAILED(pIPinInput->Disconnect()))
  1175. {
  1176. ASSERT(FALSE);
  1177. return E_FAIL;
  1178. }
  1180. // Now just connect the two pins
  1181. hr = m_pGB->Connect(pIPinOutput, pIPinInput);
  1182. ASSERT(SUCCEEDED(hr));
  1183. if(FAILED(hr))
  1184. TRACE("Could not connect pins!");
  1186. // Release the two pins and return the result
  1187. pIPinOutput->Release();
  1188. pIPinInput->Release();
  1190. return hr;
  1191. }
  1193. STDMETHODIMP_(BOOL) CCaptureGraph::IsConnected(IBaseFilter *pFilter,
  1194.    LPCTSTR pstrPinName, 
  1195.    PIN_DIRECTION pd)
  1196. {
  1197. ASSERT(m_pGB);
  1199. // Parameters...
  1200. if((!pFilter))
  1201. {
  1202. ASSERT(pFilter);
  1203. TRACE("ConnectPins called with NULL parametern");
  1204. return FALSE;
  1205. }
  1207. // Find the pin
  1208. IPin* pIPin = FindPinOnFilter(pFilter, 
  1209. pstrPinName,
  1210. pd);
  1211. if(!pIPin)
  1212. {
  1213. ASSERT(pIPin);
  1214. return FALSE;
  1215. }
  1217. IPin  *pNextPin = NULL;
  1219. pIPin->ConnectedTo(&pNextPin);
  1220. if(!pNextPin)
  1221. {
  1222. return FALSE;
  1223. }
  1225. pIPin->Release();
  1226. pNextPin->Release();
  1228. //That's it...
  1229. return TRUE;
  1230. }
  1232. STDMETHODIMP CCaptureGraph::DisconnectPin(IBaseFilter *pIFilter, 
  1233.   LPCTSTR pstrPinName,
  1234.   PIN_DIRECTION dir)
  1235. {
  1236. HRESULT hr;
  1237. ASSERT(m_pGB);
  1239. // Parameters...
  1240. if(!pIFilter)
  1241. // DON'T fail on this, it is expected
  1242. return NOERROR;
  1244. // Find the pin
  1245. IPin* pIPin = FindPinOnFilter(pIFilter, pstrPinName, dir);
  1246. if(!pIPin)
  1247. {
  1248. TRACE("Could not find specified filter pinn");
  1249. return E_FAIL;
  1250. }
  1252. // Find the pin it's connected to
  1253. IPin* pIPinConnected;
  1254. hr = pIPin->ConnectedTo(&pIPinConnected);
  1255. if((FAILED(hr)) || (!pIPinConnected))
  1256. {
  1257. // Function call failed, pin not connected, nothing to do!
  1258. pIPin->Release();
  1259. return NOERROR;
  1260. }
  1262. // Try to disconnect the input pin first
  1263. if (dir == PINDIR_INPUT)
  1264. {
  1265. // ok now disconnect both of them
  1266. hr = m_pGB->Disconnect(pIPin);
  1267. if(FAILED(hr))
  1268. {
  1269. // just forget everything
  1270. ASSERT(SUCCEEDED(hr));
  1271. pIPin->Release();
  1272. pIPinConnected->Release();
  1273. TRACE("Disconnect failed on input pinn");
  1274. return hr;
  1275. }
  1276. hr = m_pGB->Disconnect(pIPinConnected);
  1277. if(FAILED(hr))
  1278. {
  1279. ASSERT(SUCCEEDED(hr));
  1280. TRACE("Disconnect failed on output pinn");
  1281. }
  1282. }
  1283. else
  1284. {
  1285. // ok now disconnect both of them
  1286. hr = m_pGB->Disconnect(pIPinConnected);
  1287. if(FAILED(hr))
  1288. {
  1289. ASSERT(SUCCEEDED(hr));
  1290. // just forget everything
  1291. pIPin->Release();
  1292. pIPinConnected->Release();
  1293. TRACE("Disconnect failed on input pinn");
  1294. return hr;
  1295. }
  1296. hr = m_pGB->Disconnect(pIPin);
  1297. if(FAILED(hr))
  1298. {
  1299. ASSERT(SUCCEEDED(hr));
  1300. TRACE("Disconnect failed on output pinn");
  1301. }
  1302. }
  1304. // Just release the two pins and return last result
  1305. pIPin->Release();
  1306. pIPinConnected->Release();
  1308. return hr;
  1309. }
  1311. STDMETHODIMP_(IPin*) CCaptureGraph::FindPinOnFilter(IBaseFilter* pIFilter, 
  1312. LPCTSTR pstrPinName,
  1313. PIN_DIRECTION dir)
  1314. {
  1315. HRESULT     hr;
  1316. IEnumPins*  pIEnumPins;
  1317. IPin*       pIPin;
  1318. PIN_INFO    pi;
  1319. ASSERT(m_pGB);
  1321. // Parameters...
  1322. if(!pIFilter)
  1323. return NULL;
  1325. // Enumerate pins on the filter
  1326. hr = pIFilter->EnumPins(&pIEnumPins);
  1327. if(FAILED(hr))
  1328. // pin was not found!
  1329. return NULL;
  1331. // Loop till we find no more pins
  1332. IPin* pIPinFound = NULL;
  1333. while( (!pIPinFound) && (pIEnumPins->Next(1, &pIPin, NULL)==S_OK) )
  1334. {
  1335. // Is this the pin?
  1336. hr = pIPin->QueryPinInfo(&pi);
  1337. if(!FAILED(hr))
  1338. {
  1339. // check if it is the right direction
  1340. if(pi.dir == dir)
  1341. {
  1342. // Let the graph builder find the right filter
  1343. TCHAR strFoundPinName[256];
  1344. #ifndef _UNICODE
  1345. // not unicode, we need to de-unicodify the returned pin name
  1346. WideCharToMultiByte(CP_ACP, NULL,
  1347. pi.achName, -1,
  1348. strFoundPinName, sizeof(strFoundPinName),
  1349. NULL, NULL);
  1350. #else
  1351. // just make a copy of the string
  1352. lstrcpyn(strFoundPinName, pi.achName, sizeof(strFoundPinName));
  1353. #endif
  1355. // check if there is a pin name specified
  1356. if(!pstrPinName)
  1357. {
  1358. // no name specified, take the first pin found
  1359. pIPinFound = pIPin;
  1360. pIPinFound->AddRef();
  1361. }
  1362. // check if we have the right pin name
  1363. else if(lstrcmp(strFoundPinName, pstrPinName)==0)
  1364. {
  1365. // yes we have!
  1366. pIPinFound = pIPin;
  1367. pIPinFound->AddRef();
  1368. }
  1369. }
  1371. // release the PIN_INFO data
  1372. pi.pFilter->Release();
  1373. }
  1375. // release the IPin pointer
  1376. pIPin->Release();
  1377. }
  1379. // Finished with the enumerator, let it go (be free)
  1380. pIEnumPins->Release();
  1382. // Return whatever we have found
  1383. return pIPinFound;
  1384. }
  1386. STDMETHODIMP CCaptureGraph::BuildGraph()
  1387. {
  1388. HRESULT hr;
  1390. //添加TV Sink Filter
  1391. hr = AddFilter(CLSID_TVStreamSink, &m_pTVStreamSink);
  1392. if (FAILED(hr))
  1393. {
  1394. return hr;
  1395. }
  1397. hr = m_pTVStreamSink->Release();
  1399. //添加IID_ITVSouceConfig接口
  1400. hr = m_pTVStreamSink->QueryInterface(IID_ITVSouceConfig, (VOID**)&m_pTVConfig);
  1401. if(FAILED(hr))
  1402. {
  1403. TRACE("cant Get the ITVConfig interface!!");
  1404. return hr;
  1405. }
  1406. //判断是否为DV设备将判断结果置为mbISDV的值若是DV则走DV的流程
  1407. JudgeDV();
  1409. //若为只有音频设备，则调TV Sink接口
  1410. if(m_bIsOnlyAudio)
  1411. {
  1412. m_pTVConfig->SetAudioOrVideoOnly(m_bIsOnlyAudio);
  1413. }
  1414. m_pTVConfig->Release();
  1416. //若为DV则调用DV的Graph
  1417. if (TRUE == mbIsDV)
  1418. {
  1419. hr = DisplayDV();//DisplayDV();
  1420. if (SUCCEEDED(hr))
  1421. {
  1422. m_bGraphBuiled = TRUE;
  1423. return hr;
  1424. }
  1425. return hr;
  1426. }
  1428. //若不是DV则调用一般的Graph
  1429. hr = BuildGeneralGraph();
  1430. if (SUCCEEDED(hr))
  1431. {
  1432. m_bGraphBuiled = TRUE;
  1433. return hr;
  1434. }
  1435. return hr;
  1436. // that's ok, we can run it!
  1437. //m_bGraphBuiled = TRUE;
  1438. //return S_OK;
  1439. }
  1441. STDMETHODIMP CCaptureGraph::DisassembleGraph()
  1442. {
  1443. HRESULT hr;
  1444. /*
  1445. // first must stop
  1446. if(m_hWndOwner != NULL)
  1447. {
  1448. CWnd wd;
  1449. wd.Attach(m_hWndOwner);
  1450. //((CGVCaptureDlg*)wd.GetParent())->OnNotifyStop();
  1451. wd.Detach();
  1452. }
  1453. */
  1455. RemoveFilter(m_pVideoCapture);
  1456. RemoveFilter(m_pVideoEncoder);
  1457. RemoveFilter(m_pAudioCapture);
  1458. RemoveFilter(m_pAudioEncoder);
  1459. RemoveFilter(m_pTVStreamSink);
  1460. RemoveFilter(m_pVideoSmartTee);
  1461. RemoveFilter(m_pftrDVSpliter);
  1462. RemoveFilter(m_pDVDecoder);
  1464. for(int i = 0; i < m_arrayOtherFilter.GetSize(); i++)
  1465. {
  1466. IBaseFilter *pFilter = (IBaseFilter*)(m_arrayOtherFilter.GetAt(i));
  1467. RemoveFilter(pFilter);
  1468. }
  1469. // added by zk for saving 2004-04-16
  1470. if(m_pVideoSmartTee)
  1471. RemoveFilter(m_pVideoSmartTee);
  1472. if(m_pAudioSmartTee)
  1473. RemoveFilter(m_pAudioSmartTee);
  1474. if(m_pAVIMuxer)
  1475. RemoveFilter(m_pAVIMuxer);
  1476. if(m_pFileWriter)
  1477. RemoveFilter(m_pFileWriter);
  1478. // release All filter in the graph except for 
  1479. // videocapture and videoencoder.these two filters will be
  1480. // deleted in create CreateCapDeviceFilterByName and 
  1481. // CreateEncoderFilterByNamer
  1482. SAFE_RELEASE(m_pAudioCapture);
  1483. // SAFE_RELEASE(m_pTVStreamSink);
  1484. SAFE_RELEASE(m_pVideoSmartTee);
  1485. SAFE_RELEASE(m_pAudioSmartTee);
  1486. // SAFE_RELEASE(m_pTVConfig);
  1487. SAFE_RELEASE(m_pftrDVSpliter);
  1488. SAFE_RELEASE(m_pDVDecoder);
  1490. for(i=0; i<m_arrayOtherFilter.GetSize(); i++)
  1491. {
  1492. IBaseFilter *pFilter = (IBaseFilter*)(m_arrayOtherFilter.GetAt(i));
  1493. SAFE_RELEASE(pFilter);
  1494. }
  1495. m_arrayOtherFilter.RemoveAll();
  1497. m_bGraphBuiled = FALSE;
  1500. CComPtr <IVideoWindow> lpVideoWindow;
  1501. hr = m_pGB->QueryInterface(IID_IVideoWindow, (void**)&lpVideoWindow);
  1502. if (FAILED(hr))
  1503. {
  1504. return hr;
  1505. }
  1506. hr = lpVideoWindow->put_Visible(OAFALSE);
  1508. return S_OK;
  1509. }
  1511. //  [10/6/2005] xiezhouwei 
  1512. void CCaptureGraph::JudgeDV()
  1513. {
  1514. HRESULT hr;
  1516. CComPtr<ICaptureGraphBuilder2> lpgraphBuilder2;
  1517. //获得graphBuilder2_
  1518. hr = lpgraphBuilder2.CoCreateInstance(CLSID_CaptureGraphBuilder2); 
  1519. if (FAILED(hr))
  1520. {
  1521. return ;
  1522. }
  1524. hr = lpgraphBuilder2->SetFiltergraph(m_pGB);
  1525. if (FAILED(hr))
  1526. {
  1527. return ;
  1528. }
  1530. //判断是否为DV设备，如果不是就照正常的进行采集，否则链路将要变。
  1531. IAMStreamConfig *pSC;
  1532. mbIsDV =FALSE; //首先假设不是DV设备
  1533. hr = lpgraphBuilder2->FindInterface(&PIN_CATEGORY_CAPTURE,
  1534. &MEDIATYPE_Interleaved, m_pVideoCapture,
  1535. IID_IAMStreamConfig, (void **)&pSC);
  1537. if(hr != NOERROR)
  1538. hr = lpgraphBuilder2->FindInterface(&PIN_CATEGORY_CAPTURE,
  1539. &MEDIATYPE_Video, m_pVideoCapture,
  1540. IID_IAMStreamConfig, (void **)&pSC);
  1541. if (!FAILED(hr))
  1542. {
  1543. AM_MEDIA_TYPE *pmt;
  1544. if(pSC && pSC->GetFormat(&pmt) == S_OK)
  1545. {
  1546. if(pmt->formattype == FORMAT_DvInfo)
  1547. {
  1548. mbIsDV = TRUE;
  1549. }
  1550. }
  1551. pSC->Release();
  1552. }
  1553. }
  1555. HRESULT CCaptureGraph::BuildGeneralAudio()
  1556. {
  1557. HRESULT hr;
  1558. hr = GetAudioCaptureDevice();
  1559. if (FAILED(hr))
  1560. {
  1561. return hr;
  1562. }
  1563. hr = m_pGB->AddFilter(m_pAudioCapture, NULL);
  1564. if (FAILED(hr))
  1565. {
  1566. return hr;
  1567. }
  1568. if (NULL == m_pAudioEncoder)
  1569. {
  1570. AfxMessageBox("请选择正确的音频解码器");
  1571. return E_FAIL;
  1572. }
  1573. hr = m_pGB->AddFilter(m_pAudioEncoder, NULL);
  1574. if (FAILED(hr))
  1575. {
  1576. return hr;
  1577. }
  1578. hr = ConnectPins(m_pAudioCapture, NULL, m_pAudioEncoder, NULL);
  1579. if (FAILED(hr))
  1580. {
  1581. AfxMessageBox("请选择正确的音频解码器");
  1582. return hr;
  1583. }
  1584. hr = AddFilter(CLSID_InfTee, &m_pAudioSmartTee);
  1585. if (FAILED(hr))
  1586. {
  1587. return hr;
  1588. }
  1589. hr = ConnectPins(m_pAudioEncoder, NULL, m_pAudioSmartTee,NULL);
  1590. if (FAILED(hr))
  1591. {
  1592. AfxMessageBox("音频部分构建出错");
  1593. return hr;
  1594. }
  1595. //[AudioSmartTee] -> [TVSink]
  1596. hr = ConnectPins(m_pAudioSmartTee, __T("Output1"), m_pTVStreamSink, __T("Audio"), m_pCurAudioAMT);
  1597. if(FAILED(hr))
  1598. {
  1599. AfxMessageBox("不能进行播放，请重新选择音频编码器。");
  1600. return hr;
  1601. }
  1602. return hr;
  1603. }
  1605. //在VideoGraph中加入字幕Filter
  1606. HRESULT CCaptureGraph::AddVideoOverlayFilter()
  1607. {
  1608. HRESULT hr;
  1609. hr = m_pGB->AddFilter(m_pVideoOverlay, NULL);
  1610. if (FAILED(hr))
  1611. {
  1612. return hr;
  1613. }
  1614. hr = ConnectPins(m_pVideoCapture, NULL, m_pVideoOverlay, NULL);
  1615. if (FAILED(hr))
  1616. {
  1617. AfxMessageBox("连接字幕Filter出错");
  1618. return hr;
  1619. }
  1621. if (NULL == m_pVideoEncoder)
  1622. {
  1623. AfxMessageBox("视频编码器出错");
  1624. return E_FAIL;
  1625. }
  1626. hr = m_pGB->AddFilter(m_pVideoEncoder, NULL);
  1627. if (FAILED(hr))
  1628. {
  1629. return hr;
  1630. }
  1632. //如果是DMO组件
  1633. if (IsDMOFilter())
  1634. {
  1635. hr = BuildVideoDMOEncoder();
  1636. if (FAILED(hr))
  1637. {
  1638. return hr;
  1639. }
  1640. }
  1641. else
  1642. {
  1643. hr = ConnectPins(m_pVideoOverlay, NULL, m_pVideoEncoder, NULL);
  1644. if (FAILED(hr))
  1645. {
  1646. AfxMessageBox("视频编码器出错。请重新选择视频编码器");
  1647. return hr;
  1648. }
  1649. }
  1650. return hr;
  1651. }
  1653. //视频部分预览
  1654. HRESULT CCaptureGraph::BuildVideoPreview()
  1655. {
  1656. HRESULT hr;
  1657. CComPtr <IPin> lpPin = NULL; 
  1658. //pPreview = FindPinOnFilter(m_pVideoSmartTee, __T("Output2"))
  1659. lpPin = FindPinOnFilter(m_pVideoSmartTee, __T("Output2"));
  1660. if (lpPin == NULL)
  1661. {
  1662. AfxMessageBox("预览pin出错");
  1663. return E_FAIL;
  1664. }
  1665. hr = m_pGB->Render(lpPin);
  1667. CComPtr <IVideoWindow> lpVideoWindow;
  1668. hr = m_pGB->QueryInterface(IID_IVideoWindow, (void**)&lpVideoWindow);
  1669. if (FAILED(hr))
  1670. {
  1671. return hr;
  1672. }
  1674. hr = lpVideoWindow->put_Owner((OAHWND)m_hWndOwner);
  1675. lpVideoWindow->put_WindowStyle(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  1676. CRect rc;
  1677. GetClientRect(m_hWndOwner, &rc);
  1678. lpVideoWindow->put_Top(0);
  1679. lpVideoWindow->put_Left(0);
  1680. lpVideoWindow->put_Width(rc.Width());
  1681. lpVideoWindow->put_Height(rc.Height());
  1682. lpVideoWindow->put_Visible(-1);
  1683. lpVideoWindow->put_AutoShow(-1);
  1684. return hr;
  1685. }
  1688. HRESULT CCaptureGraph::OpenCrossBar()
  1689. {
  1690. HRESULT hr;
  1691. CComPtr<IBaseFilter> pNULL;
  1692. hr = AddFilter(CLSID_NullRenderer, &pNULL);
  1693. if(FAILED(hr))
  1694. {
  1695. TRACE("cant add smarttee filter to graph");
  1696. return hr;
  1697. }
  1699. //获得lpgraphBuilder2_
  1700. CComPtr<ICaptureGraphBuilder2> lpgraphBuilder2_;
  1701. hr = lpgraphBuilder2_.CoCreateInstance(CLSID_CaptureGraphBuilder2);
  1702. if (FAILED(hr))
  1703. {
  1704. return hr;
  1705. }
  1706. hr = lpgraphBuilder2_->SetFiltergraph(m_pGB);
  1708. hr = lpgraphBuilder2_->RenderStream( &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Audio, m_pVideoCapture, 0, pNULL );
  1710. hr = lpgraphBuilder2_->RenderStream( &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, m_pVideoCapture, 0, pNULL );
  1712. if (SUCCEEDED(hr))
  1713. {
  1714. IAMCrossbar *pX;
  1716. hr = lpgraphBuilder2_->FindInterface(&PIN_CATEGORY_CAPTURE,
  1717. &MEDIATYPE_Interleaved, m_pVideoCapture,
  1718. IID_IAMCrossbar, (void **)&pX);
  1720. if(FAILED(hr))
  1721. {
  1722. hr = lpgraphBuilder2_->FindInterface(&PIN_CATEGORY_CAPTURE,
  1723. &MEDIATYPE_Video, m_pVideoCapture,
  1724. IID_IAMCrossbar, (void **)&pX);
  1725. }
  1726. if (SUCCEEDED(hr))
  1727. {
  1728. ISpecifyPropertyPages *pSpec;
  1729. CAUUID cauuid;
  1731. hr = pX->QueryInterface(IID_ISpecifyPropertyPages,
  1732. (void **)&pSpec);
  1733. if(S_OK == hr)
  1734. {
  1735. hr = pSpec->GetPages(&cauuid);
  1737. hr = OleCreatePropertyFrame(m_hWndOwner, 30, 30, NULL, 1,
  1738. (IUnknown **)&pX, cauuid.cElems,
  1739. (GUID *)cauuid.pElems, 0, 0, NULL); 
  1740. CoTaskMemFree(cauuid.pElems);
  1741. pSpec->Release(); 
  1742. }
  1743. pX->Release();                
  1744. }
  1745. }
  1746. return hr;
  1747. }
  1749. //构建并预览一般的Graph的视频部分
  1750. HRESULT CCaptureGraph::BuildGeneralVideo()
  1751. {
  1752. HRESULT hr;
  1753. if (NULL == m_pVideoCapture)
  1754. {
  1755. AfxMessageBox("视频采集设备出错");
  1756. return E_FAIL;
  1757. }
  1758. hr = m_pGB->AddFilter(m_pVideoCapture, NULL);
  1759. if (FAILED(hr))
  1760. {
  1761. return hr;
  1762. }
  1764. if (TRUE == m_bISCrossBar)
  1765. {
  1766. hr = OpenCrossBar();
  1767. }
  1769. //如果有字幕的Filter
  1770. if (NULL != m_pVideoOverlay)
  1771. {
  1772. hr = AddVideoOverlayFilter();
  1773. if (FAILED(hr))
  1774. {
  1775. return hr;
  1776. }
  1777. }
  1778. else
  1779. {
  1780. if (NULL == m_pVideoEncoder)
  1781. {
  1782. AfxMessageBox("视频编码器出错");
  1783. return E_FAIL;
  1784. }
  1785. hr = m_pGB->AddFilter(m_pVideoEncoder, NULL);
  1786. if (FAILED(hr))
  1787. {
  1788. return hr;
  1789. }
  1791. //如果是DMO组件
  1792. if (IsDMOFilter())
  1793. {
  1794. hr = BuildVideoDMOEncoder();
  1795. if (FAILED(hr))
  1796. {
  1797. return hr;
  1798. }
  1799. }
  1800. else
  1801. {
  1802. hr = ConnectPins(m_pVideoCapture, NULL, m_pVideoEncoder, NULL);
  1803. if (FAILED(hr))
  1804. {
  1805. AfxMessageBox("视频编码器出错。请重新选择视频编码器");
  1806. return hr;
  1807. }
  1808. }
  1809. }
  1811. hr = AddFilter(CLSID_InfTee, &m_pVideoSmartTee);
  1812. if (FAILED(hr))
  1813. {
  1814. return hr;
  1815. }
  1816. hr = ConnectPins(m_pVideoEncoder, NULL, m_pVideoSmartTee, NULL);
  1817. if (FAILED(hr))
  1818. {
  1819. AfxMessageBox("视频编码器出错，请重新选择视频编码器");
  1820. return hr;
  1821. }
  1822. //[VideoSmartTee] -> [TVSink]
  1823. hr = ConnectPins(m_pVideoSmartTee, __T("Output1"), m_pTVStreamSink, __T("Video"));
  1824. if(FAILED(hr))
  1825. {
  1826. AfxMessageBox("不能进行播放，请重新选择音频编码器。");
  1827. return hr;
  1828. }
  1830. if (m_bIsPreview)
  1831. {
  1832. hr = BuildVideoPreview();
  1833. }
  1834. return hr;
  1835. }
  1837. HRESULT CCaptureGraph::BuildSaveGraph()
  1838. {
  1839. HRESULT hr;
  1840. //Add AVI Muxer and Filewriter
  1841. if(FAILED(AddFilter(CLSID_AviDest, &m_pAVIMuxer)))
  1842. {
  1843. TRACE("cant add Avi mux filter to graph");
  1844. return E_FAIL;
  1845. }
  1846. if(FAILED(AddFilter(CLSID_FileWriter, &m_pFileWriter)))
  1847. {
  1848. TRACE("cant add Filewriter filter to graph");
  1849. return E_FAIL;
  1850. }
  1852. IConfigAviMux* lpAviMux = NULL;
  1853. hr = m_pAVIMuxer->QueryInterface(IID_IConfigAviMux, (void**)&lpAviMux); 
  1855. if (FAILED(hr))
  1856. {
  1857. AfxMessageBox("AVI 设置失败");
  1858. lpAviMux->Release();
  1859. return E_FAIL;
  1860. }
  1862. hr = lpAviMux->SetOutputCompatibilityIndex(TRUE);
  1864. if (FAILED(hr))
  1865. {
  1866. AfxMessageBox("AVI 设置失败");
  1867. lpAviMux->Release();
  1868. return E_FAIL;
  1869. }
  1871. hr = lpAviMux->SetMasterStream(0);//为音频输入PIN序号 
  1873. if (FAILED(hr))
  1874. {
  1875. AfxMessageBox("AVI 设置失败");
  1876. lpAviMux->Release();
  1877. return E_FAIL;
  1878. }
  1879. lpAviMux->Release();
  1881. //[AudioSmartTee] --> [AVIMux]
  1882. if(FAILED(ConnectPins(m_pAudioSmartTee, __T("Output2"), m_pAVIMuxer, __T("Input 01"))))
  1883. {
  1884. AfxMessageBox("不能保存音频。");
  1885. return E_FAIL;
  1886. }
  1888. if (!m_bIsOnlyAudio)//如果不是只采音频的情况
  1889. {
  1890. if ( m_bIsPreview )
  1891. {
  1892. //[VideoSmartTee] --> [AVIMux]
  1893. if(FAILED(ConnectPins(m_pVideoSmartTee, __T("Output3"), m_pAVIMuxer, __T("Input 02"))))
  1894. {
  1895. AfxMessageBox("不能保存视频。");
  1896. return E_FAIL;
  1897. }
  1898. }
  1899. else
  1900. {
  1901. //[VideoSmartTee] --> [AVIMux]
  1902. if(FAILED(ConnectPins(m_pVideoSmartTee, __T("Output2"), m_pAVIMuxer, __T("Input 02"))))
  1903. {
  1904. AfxMessageBox("不能保存视频。");
  1905. return E_FAIL;
  1906. }
  1907. }
  1908. }
  1909. //Set Output FileName
  1910. IFileSinkFilter *pFileSink = NULL;
  1911. m_pFileWriter->QueryInterface(IID_IFileSinkFilter, (VOID**)(&pFileSink));
  1912. if (NULL == pFileSink)
  1913. {
  1914. return E_FAIL;
  1915. }
  1917. WCHAR wstrFilename[MAX_PATH];
  1918. MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  1919. m_szAVIFile, -1, 
  1920. wstrFilename, sizeof(wstrFilename) / sizeof(WCHAR));
  1922. pFileSink->SetFileName(wstrFilename, NULL);
  1923. pFileSink->Release();
  1925. hr = ConnectPins(m_pAVIMuxer, NULL, m_pFileWriter, NULL);
  1926. if(FAILED(hr))
  1927. {
  1928. AfxMessageBox("不能保存成文件。");
  1929. return E_FAIL;
  1930. }
  1931. return hr;
  1932. }
  1934. HRESULT CCaptureGraph::BuildGeneralGraph()
  1935. {
  1936. HRESULT hr;
  1937. hr = BuildGeneralAudio();
  1938. if (FAILED(hr))
  1939. {
  1940. return hr;
  1941. }
  1943. //构建视频部分
  1944. if (FALSE == m_bIsOnlyAudio)
  1945. {
  1946. hr = BuildGeneralVideo();
  1947. }
  1949. if (FAILED(hr))
  1950. {
  1951. return hr;
  1952. }
  1954. if (m_bSave)
  1955. {
  1956. hr = BuildSaveGraph();
  1957. }
  1958. return hr;
  1959. }
  1961. // audio compression format
  1962. HRESULT CCaptureGraph::EnumAudioWaveFormat(CListBox* pLB)// called by main dlg
  1963. {
  1964. IPin *pOutPin;
  1966. //ASSERT(m_pCurAudioAMT);
  1968. if(FAILED(pOutPin = FindPinOnFilter(m_pAudioEncoder, NULL)))
  1969. {
  1970. TRACE("cant get outpin of Audio encoder!");
  1971. return E_FAIL;
  1972. }
  1974. IEnumMediaTypes *pEmt;
  1975. if(FAILED(pOutPin->EnumMediaTypes(&pEmt)))
  1976. {
  1977. pOutPin->Release();
  1978. return E_FAIL;
  1979. }
  1981. for(int i = 0; i < pLB->GetCount(); i++)
  1982. HeapFree(GetProcessHeap(), 0, pLB->GetItemDataPtr(i));
  1984. pLB->ResetContent();
  1986. ULONG uFetch;
  1987. AM_MEDIA_TYPE *pamt;
  1988. CString strTemp;
  1989. CString strFormat;
  1990. int liResult = 0;//保存两个当前媒体类型和枚举媒题类型的比较结果
  1991. while(pEmt->Next(1, &pamt, &uFetch) == S_OK)
  1992. {
  1993. if(pamt->formattype == FORMAT_WaveFormatEx)
  1994. {
  1995. WAVEFORMATEX *pw = (WAVEFORMATEX *)(pamt->pbFormat);
  1998. strTemp.Format("%.3fKbits/s, %dHz", (pw->nAvgBytesPerSec*8)/1024.0, pw->nSamplesPerSec);
  1999. if(pw->nChannels == 1)
  2000. strFormat.Format("%s, mono", strTemp);
  2001. else
  2002. strFormat.Format("%s, stereo", strTemp);
  2004. AM_MEDIA_TYPE *pwfe = (AM_MEDIA_TYPE *)HeapAlloc(GetProcessHeap(), 
  2005. HEAP_NO_SERIALIZE|HEAP_ZERO_MEMORY, 
  2006. sizeof(AM_MEDIA_TYPE) + pamt->cbFormat);
  2007. memcpy(pwfe, pamt, sizeof(AM_MEDIA_TYPE));
  2008. pwfe->pbFormat = (LPBYTE)(pwfe+1);
  2009. memcpy(pwfe->pbFormat, pw, pamt->cbFormat);
  2010. int idx = pLB->AddString(strFormat);
  2011. pLB->SetItemDataPtr(idx, pwfe);
  2012. //Arthur:0806Add
  2013. //当前媒体类型不动，这里只是负责选择，如果当前类型在枚举的时候已经不存在，则依然不动。
  2014. //如果用户选择了新的则改变，否则继续不动。
  2015. if (!m_pCurAudioAMT)
  2016. {
  2017. continue;
  2018. }
  2019. if (m_pCurAudioAMT->cbFormat == pwfe->cbFormat)
  2020. {
  2021. liResult = memcmp(m_pCurAudioAMT, pwfe,sizeof(AM_MEDIA_TYPE) - 4);
  2022. if (!liResult)
  2023. {//如果两者一样就将这项选择
  2024. liResult = memcmp(m_pCurAudioAMT->pbFormat, pwfe->pbFormat,m_pCurAudioAMT->cbFormat);
  2025. if (!liResult)
  2026. {
  2027. pLB->SetCurSel(idx);
  2028. }
  2029. }
  2030. }
  2031. }
  2032. }
  2034. pEmt->Release();
  2035. pOutPin->Release();
  2037. return S_OK;
  2038. }
  2040. void CCaptureGraph::SetAudioWaveformat(AM_MEDIA_TYPE* pamt)// called by selector dlg
  2041. {
  2042. if(pamt)
  2043. {
  2044. //Arthur:0806Modify
  2045. WAVEFORMATEX *pwfe = (WAVEFORMATEX *)pamt;//Arthur:Bug.该指针根本就没用
  2046. //
  2048. if (!m_pCurAudioAMT)
  2049. {
  2050. m_pCurAudioAMT = (AM_MEDIA_TYPE *)HeapAlloc(GetProcessHeap(), 
  2051. HEAP_NO_SERIALIZE|HEAP_ZERO_MEMORY, 
  2052. sizeof(AM_MEDIA_TYPE) + pamt->cbFormat);
  2053. }
  2054. ZeroMemory(m_pCurAudioAMT, sizeof(AM_MEDIA_TYPE) + m_pCurAudioAMT->cbFormat);
  2056. int iii = sizeof(AM_MEDIA_TYPE);
  2057. memcpy(m_pCurAudioAMT, pamt, sizeof(AM_MEDIA_TYPE));
  2058. BYTE* ii = (LPBYTE)(m_pCurAudioAMT+1);
  2059. m_pCurAudioAMT->pbFormat = (LPBYTE)(m_pCurAudioAMT+1);//arthur:指针加1。则相当于空出一个AM_MEDIA_TYPE。在这
  2060. //赋给pbFormat
  2061. memcpy(m_pCurAudioAMT->pbFormat, pamt->pbFormat, pamt->cbFormat);
  2062. }
  2063. }
  2065. // used to enum fiters in specified catagory
  2066. HRESULT CCaptureGraph::EnumSpeciFilters(IID iidEnumType, CStringArray &strArrayType)
  2067. {
  2068. HRESULT hr;
  2069. IMoniker *pMoniker =NULL;
  2070. ULONG cFetched;
  2072. // Create the system device enumerator
  2073. ICreateDevEnum* pDevEnum = NULL;
  2075. hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
  2076. IID_ICreateDevEnum, (void **) &pDevEnum);
  2077. if (FAILED(hr))
  2078. {
  2079. TRACE1(TEXT("Couldn't create system enumerator!  hr=0x%x"), hr);
  2080. return hr;
  2081. }
  2083. IEnumMoniker *pClassEnum = NULL;
  2085. hr = pDevEnum->CreateClassEnumerator(iidEnumType, &pClassEnum, 0);
  2086. if (FAILED(hr))
  2087. {
  2088. pDevEnum->Release();
  2089. TRACE1(TEXT("Couldn't create class enumerator!  hr=0x%x"), hr);
  2090. return hr;
  2091. }
  2093. if (pClassEnum == NULL)
  2094. {
  2095. pDevEnum->Release();
  2096. return S_OK;
  2097. }
  2099. while (S_OK == (pClassEnum->Next (1, &pMoniker, &cFetched)))
  2100. {
  2101. IPropertyBag *pPropBag;
  2102. hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, 
  2103. (void **)&pPropBag);
  2104. if (SUCCEEDED(hr))
  2105. {
  2106. VARIANT varName;
  2107. VariantInit(&varName);
  2108. hr = pPropBag->Read(L"FriendlyName", &varName, 0);
  2109. if (SUCCEEDED(hr))
  2110. {
  2111. int cch = lstrlenW(varName.bstrVal) + 1;
  2112. CHAR* lpszFilterName = new char[cch * 2];
  2113. if (!lpszFilterName) 
  2114. return E_OUTOFMEMORY;
  2115. WideCharToMultiByte(GetACP(), 0, varName.bstrVal, -1,
  2116. lpszFilterName, cch, NULL, NULL);
  2118. if(iidEnumType == VIDEO_CAP)
  2119.                     strArrayType.Add(lpszFilterName);
  2120.                 else if(iidEnumType == AUDIO_CAP)
  2121.                     strArrayType.Add(lpszFilterName);
  2122. else if(iidEnumType == VIDEO_COMPRESS)
  2123. {
  2124. if(strcmp(lpszFilterName, "Microsoft H.261 Video Codec") != 0 &&
  2125. strcmp(lpszFilterName, "Microsoft H.263 Video Codec") != 0 &&
  2126. strcmp(lpszFilterName, "Microsoft RLE") != 0 && 
  2127. strcmp(lpszFilterName, "ffdshow video encoder") != 0)
  2128. strArrayType.Add(lpszFilterName);
  2129. }
  2130. else if(iidEnumType == AUDIO_COMPRESS)
  2131. {
  2132. if(strcmp(lpszFilterName, "WM Speech Encoder DMO") != 0 &&
  2133. strcmp(lpszFilterName, "ACELP.net") != 0)
  2134. strArrayType.Add(lpszFilterName);
  2135. }
  2136. else
  2137. ASSERT(FALSE);
  2139. delete [] lpszFilterName;
  2140. }
  2141. VariantClear(&varName);
  2143. pPropBag->Release();
  2144. }
  2145. pMoniker->Release();
  2146. }
  2148. pClassEnum->Release();
  2149. pDevEnum->Release();
  2151. return S_OK;
  2152. }
  2154. // used to create filter 
  2155. HRESULT CCaptureGraph::FindFilterByName(LPTSTR strName, IBaseFilter **ppFilter, IID iidEnumType)
  2156. {
  2157. if(ppFilter == NULL)
  2158. return E_INVALIDARG;
  2160. *ppFilter = NULL;
  2162. HRESULT hr;
  2163. IMoniker *pMoniker =NULL;
  2164. ULONG cFetched;
  2166. // Create the system device enumerator
  2167. ICreateDevEnum* pDevEnum = NULL;
  2169. hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
  2170. IID_ICreateDevEnum, (void **) &pDevEnum);
  2172. if (FAILED(hr))
  2173. {
  2174. TRACE1(TEXT("Couldn't create system enumerator!  hr=0x%x"), hr);
  2175. return hr;
  2176. }
  2178. IEnumMoniker *pClassEnum = NULL;
  2180. hr = pDevEnum->CreateClassEnumerator(iidEnumType, &pClassEnum, 0);
  2181. if (FAILED(hr))
  2182. {
  2183. pDevEnum->Release();
  2184. TRACE1(TEXT("Couldn't create class enumerator!  hr=0x%x"), hr);
  2185. return hr;
  2186. }
  2188. if (pClassEnum == NULL)
  2189. {
  2190. pDevEnum->Release();
  2191. return S_OK;
  2192. }
  2194. while (S_OK == (pClassEnum->Next (1, &pMoniker, &cFetched)))
  2195. {
  2196. IPropertyBag *pPropBag;
  2197. hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, 
  2198. (void **)&pPropBag);
  2199. if (SUCCEEDED(hr))
  2200. {
  2201. VARIANT varName;
  2202. VariantInit(&varName);
  2203. hr = pPropBag->Read(L"FriendlyName", &varName, 0);
  2204. if (SUCCEEDED(hr))
  2205. {
  2206. int cch = lstrlenW(varName.bstrVal) + 1;
  2207. CHAR* lpszFilterName = new char[cch * 2];
  2208. if (!lpszFilterName) 
  2209. return E_OUTOFMEMORY;
  2210. WideCharToMultiByte(GetACP(), 0, varName.bstrVal, -1,
  2211. lpszFilterName, cch, NULL, NULL);
  2212. VariantClear(&varName);
  2213. if(strcmp(lpszFilterName, strName) == 0)
  2214. {
  2215. hr = pMoniker->BindToObject(NULL, NULL, 
  2216. IID_IBaseFilter,
  2217. (VOID**)ppFilter);
  2219. delete [] lpszFilterName;
  2220. pPropBag->Release();
  2221. pMoniker->Release();
  2222. break;
  2223. }
  2225. delete [] lpszFilterName;
  2226. }
  2228. pPropBag->Release();
  2229. }
  2230. pMoniker->Release();
  2231. }
  2233. pClassEnum->Release();
  2234. pDevEnum->Release();
  2236. return S_OK;
  2237. }
  2239. // used to get audio capture device 
  2240. HRESULT CCaptureGraph::GetAudioCaptureDevice()
  2241. {
  2242. HRESULT hr;
  2243. IMoniker *pMoniker =NULL;
  2244. ULONG cFetched;
  2246. // Create the system device enumerator
  2247. ICreateDevEnum* pDevEnum = NULL;
  2249. hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
  2250. IID_ICreateDevEnum, (void **) &pDevEnum);
  2251. if (FAILED(hr))
  2252. {
  2253. TRACE1(TEXT("Couldn't create system enumerator!  hr=0x%x"), hr);
  2254. return hr;
  2255. }
  2257. IEnumMoniker *pClassEnum = NULL;
  2258. hr = pDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pClassEnum, 0);
  2259. if (FAILED(hr))
  2260. {
  2261. pDevEnum->Release();
  2262. TRACE1(TEXT("Couldn't create class enumerator!  hr=0x%x"), hr);
  2263. return hr;
  2264. }
  2265. if (pClassEnum == NULL)
  2266. {
  2267. pDevEnum->Release();
  2268. return S_OK;
  2269. }
  2270. pDevEnum->Release();
  2271. hr = pClassEnum->Reset();
  2272. if(S_OK == (pClassEnum->Next (1, &pMoniker, &cFetched)))
  2273. {
  2274. hr = pMoniker->BindToObject(NULL, NULL, 
  2275. IID_IBaseFilter,
  2276. (VOID**)&m_pAudioCapture);
  2277. if(FAILED(hr))
  2278. {
  2279. pMoniker->Release();
  2280. pClassEnum->Release();
  2281. TRACE("Cant find Audio Capture");
  2282. return hr;
  2283. }
  2284. }
  2285. pMoniker->Release();
  2286. pClassEnum->Release();
  2287. return hr;
  2288. }
  2290. // used for filling the m_arryOtherFilter, diff from our 
  2291. // refrenced filters
  2292. BOOL CCaptureGraph::IsFilterInStdFilters(IBaseFilter *pFilter)
  2293. {
  2294. if(m_pVideoCapture == pFilter ||
  2295. m_pAudioCapture == pFilter ||
  2296. m_pVideoEncoder == pFilter ||
  2297. m_pAudioEncoder == pFilter ||
  2298. m_pTVStreamSink == pFilter ||
  2299. m_pVideoSmartTee == pFilter)
  2300. return TRUE;
  2301. else
  2302. return FALSE;
  2303. }
  2305. //得到媒体类型
  2306. bool CCaptureGraph::GetCurMediaType(AM_MEDIA_TYPE** aMTMediaType)
  2307. {
  2308. //Arthur:把当前的媒体类型交出去。重新拷一下，不能直接只拷指针。只拷指针不能访问
  2309. if(m_pCurAudioAMT)
  2310. {
  2312. if (!*aMTMediaType)
  2313. {
  2314. *aMTMediaType = (AM_MEDIA_TYPE *)HeapAlloc(GetProcessHeap(), 
  2315. HEAP_NO_SERIALIZE|HEAP_ZERO_MEMORY, 
  2316. sizeof(AM_MEDIA_TYPE) + m_pCurAudioAMT->cbFormat);
  2317. if (!*aMTMediaType)
  2318. {
  2319. return false;
  2320. }
  2321. }
  2322. memcpy(*aMTMediaType, m_pCurAudioAMT, sizeof(AM_MEDIA_TYPE));
  2323. (*aMTMediaType)->pbFormat = (LPBYTE)(*aMTMediaType+ 1);//指针加1。则相当于空出一个AM_MEDIA_TYPE。在这
  2324. //赋给pbFormat
  2325. memcpy((*aMTMediaType)->pbFormat, m_pCurAudioAMT->pbFormat, m_pCurAudioAMT->cbFormat);
  2326. int ii = sizeof(AM_MEDIA_TYPE) + m_pCurAudioAMT->cbFormat;
  2327. return true;
  2328. }
  2329. return false;
  2330. }
  2332. //设置媒体类型
  2333. bool CCaptureGraph::SetCurMediaType(AM_MEDIA_TYPE *aMTMediaType)
  2334. {
  2335. //设置当前媒体类型的一个指针。
  2336. if(aMTMediaType)
  2337. {
  2338. //如果此时已经有媒体类型则将之释放掉
  2339. if (!m_pCurAudioAMT)
  2340. {
  2341. m_pCurAudioAMT = (AM_MEDIA_TYPE *)HeapAlloc(GetProcessHeap(), 
  2342. HEAP_NO_SERIALIZE|HEAP_ZERO_MEMORY, 
  2343. sizeof(AM_MEDIA_TYPE) + aMTMediaType->cbFormat);
  2344. if (!m_pCurAudioAMT)
  2345. {
  2346. return false;
  2347. }
  2348. }
  2349. ZeroMemory(m_pCurAudioAMT, sizeof(AM_MEDIA_TYPE) + m_pCurAudioAMT->cbFormat);
  2351. memcpy(m_pCurAudioAMT, aMTMediaType, sizeof(AM_MEDIA_TYPE));
  2352. BYTE* ii = (LPBYTE)(m_pCurAudioAMT+1);
  2353. int iii = sizeof(AM_MEDIA_TYPE);
  2354. m_pCurAudioAMT->pbFormat = (LPBYTE)(m_pCurAudioAMT+1);//arthur:指针加1。则相当于空出一个AM_MEDIA_TYPE。在这
  2355. //赋给pbFormat
  2356. if (m_pCurAudioAMT->pbFormat && aMTMediaType->pbFormat)
  2357. {
  2358. memcpy(m_pCurAudioAMT->pbFormat, aMTMediaType->pbFormat, aMTMediaType->cbFormat);
  2359. }
  2360. return true;
  2361. }
  2362. return false;
  2363. }
  2365. //=========================================
  2366. // Writed by zhuwei 2005-8-12 
  2367. //Show Pin Setting
  2368. void CCaptureGraph::ShowPinSetting(HWND hParent)
  2369. {
  2370. if (NULL == m_pVideoCapture)
  2371. {
  2372. AfxMessageBox("视频采集设备未找到");
  2373. return;
  2374. }
  2375. /*
  2376. * SECOND: prompt user to configure output pin configuration
  2377. */
  2378. HRESULT hr;
  2379. ISpecifyPropertyPages *pSpec;
  2380. WCHAR wstrCaption[256];
  2382. CAUUID cauuid;
  2383. // must be added in the graph this time
  2384. m_pGB->AddFilter(m_pVideoCapture, NULL);
  2386. IAMStreamConfig *pSC;
  2387. IPin *pOutPin = FindPinOnFilter(m_pVideoCapture, NULL);
  2388. hr = pOutPin->QueryInterface(IID_IAMStreamConfig, (void**)(&pSC));
  2389. pOutPin->Release();
  2390. if(FAILED(hr))
  2391. return;
  2392. hr = pSC->QueryInterface(IID_ISpecifyPropertyPages, (void**)(&pSpec));
  2393. if(FAILED(hr))
  2394. {
  2395. pSC->Release();
  2396. return;
  2397. }
  2399. // Popup page
  2400. CString str = CString(_T("Video Capture Configuration 2")); // dlg caption
  2401. pSpec->GetPages(&cauuid);
  2402. if(cauuid.cElems >= 1)
  2403. {
  2404. MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  2405. str.GetBuffer(str.GetLength()), -1, 
  2406. wstrCaption, sizeof(wstrCaption) / sizeof(WCHAR));
  2408. hr = OleCreatePropertyFrame(hParent, 30, 30, wstrCaption, 1,
  2409. (IUnknown **)&pSC, cauuid.cElems,
  2410. (GUID *)cauuid.pElems, 0, 0, NULL);
  2411. if(FAILED(hr))
  2412. {
  2413. CoTaskMemFree(cauuid.pElems);
  2414. pSpec->Release();
  2415. pSC->Release();
  2416. return;
  2417. }
  2418. }
  2420. // Destructor
  2421. CoTaskMemFree(cauuid.pElems);
  2422. pSpec->Release();
  2423. pSC->Release();
  2425. return;
  2426. }
  2427. //Set AVI Filename
  2428. void CCaptureGraph::SetAVIFile( char* szFile )
  2429. {
  2430. if ( szFile[0] )
  2431. {
  2432. this->m_bSave = true;
  2433. strncpy( this->m_szAVIFile, szFile, MAX_PATH);
  2434. }
  2435. }
  2437. HRESULT CCaptureGraph::DVSplitter()
  2438. {
  2439. HRESULT hr;
  2440. if(!m_pVideoCapture)
  2441. {
  2442. AfxMessageBox("No Video Capture Device!");
  2443. return E_FAIL;
  2444. }
  2445. hr = m_pGB->AddFilter(m_pVideoCapture, NULL);
  2446. if(FAILED(hr))
  2447. {
  2448. TRACE("cant add video capture filter to graph");
  2449. return hr;
  2450. }
  2451. hr = AddFilter(CLSID_DVSplitter, &m_pftrDVSpliter);
  2452. //Add DV Splitter Filter
  2453. if(FAILED(hr))
  2454. {
  2455. AfxMessageBox("cant add DV Splitter Filter to graph");
  2456. return hr;
  2457. }
  2458. hr = ConnectAutoPins(m_pVideoCapture, "DV A/V Out", m_pftrDVSpliter, NULL);
  2459. if (FAILED(hr))
  2460. {
  2461. AfxMessageBox("cant ConnectDirect DV Splitter Filter to graph");
  2462. return hr;
  2463. }
  2464. return hr;
  2465. }
  2467. HRESULT CCaptureGraph::BuildDVAudio()
  2468. {
  2469. //DV加音频
  2470. HRESULT hr;
  2471. //Add Audio Encoder
  2472. if(!m_pAudioEncoder)
  2473. {
  2474. AfxMessageBox("No Aduio Compressor available!");
  2475. return E_FAIL;
  2476. }
  2477. hr = m_pGB->AddFilter(m_pAudioEncoder, NULL);
  2478. if(FAILED(hr))
  2479. {
  2480. TRACE("cant add audio encoder filter to graph");
  2481. return hr;
  2482. }
  2484. //[DVSplitter] --> [AudioEncoder]
  2485. hr = ConnectAutoPins(m_pftrDVSpliter,"AudOut00", m_pAudioEncoder, NULL);
  2486. if(FAILED(hr))
  2487. {
  2488. AfxMessageBox("不能进行播放，请重新选择音频编码器。");
  2489. return hr;
  2490. }
  2492. //Add AudioSmartTee
  2493. hr = AddFilter(CLSID_InfTee, &m_pAudioSmartTee);
  2494. if(FAILED(hr))
  2495. {
  2496. TRACE("cant add smarttee filter to graph");
  2497. return hr;
  2498. }
  2499. //[AudioEncoder] --> [AudioSmartTee]
  2500. hr = ConnectPins(m_pAudioEncoder, __T("Output"), m_pAudioSmartTee, __T("Input"));
  2501. if(FAILED(hr))
  2502. {
  2503. AfxMessageBox("不能进行播放，请重新选择音频编码器。");
  2504. return E_FAIL;
  2505. }
  2506. //[AudioSmartTee] -> [TVSink]
  2507. hr = ConnectPins(m_pAudioSmartTee, __T("Output1"), m_pTVStreamSink, __T("Audio"), m_pCurAudioAMT);
  2508. if(FAILED(hr))
  2509. {
  2510. AfxMessageBox("不能进行播放，请重新选择音频编码器。");
  2511. return hr;
  2512. }
  2513. return hr;
  2514. }
  2515. HRESULT CCaptureGraph::AddDVVideoOverlay()
  2516. {
  2517. HRESULT hr;
  2518. hr = m_pGB->AddFilter(m_pVideoOverlay, NULL);
  2519. if(FAILED(hr))
  2520. {
  2521. TRACE("cant add Video Overlay to graph");
  2522. return E_FAIL;
  2523. }
  2524. //[DVEncoder] --> [VideoOverlay]
  2525. hr = ConnectPins(m_pDVDecoder, NULL, m_pVideoOverlay, NULL);
  2526. if(FAILED(hr))
  2527. {
  2528. AfxMessageBox("与字幕Filter连接失败");
  2529. return E_FAIL;
  2530. }
  2532. //将字幕Filter和视频编码filter相连
  2533. //Add Video Encoder 
  2534. if(!m_pVideoEncoder)
  2535. {
  2536. AfxMessageBox("No Video Compressor available!");
  2537. return E_FAIL;
  2538. }
  2539. hr = m_pGB->AddFilter(m_pVideoEncoder, NULL);
  2540. if(FAILED(hr))
  2541. {
  2542. TRACE("cant add video encoder filter to graph");
  2543. return E_FAIL;
  2544. }
  2546. //如果是DMO组件
  2547. if (IsDMOFilter())
  2548. {
  2549. hr = BuildVideoDMOEncoder();
  2550. if (FAILED(hr))
  2551. {
  2552. return hr;
  2553. }
  2554. }
  2555. else
  2556. {
  2557. //[VideoOverlay] --> [VideoEncoder]
  2558. hr = ConnectPins(m_pVideoOverlay, NULL, m_pVideoEncoder, NULL);
  2559. if(FAILED(hr))
  2560. {
  2561. AfxMessageBox("不能进行播放，请重新选择视频编码器。");
  2562. return hr;
  2563. }
  2564. }
  2565. return hr;
  2566. }
  2568. //DV视频预览
  2569. HRESULT CCaptureGraph::BuildDVVideoPrview()
  2570. {
  2571. //Get VideoSmartTee's Sencond Output Pin
  2572. IPin *pPreview;
  2573. if(FAILED(pPreview = FindPinOnFilter(m_pVideoSmartTee, __T("Output2"))))
  2574. {
  2575. TRACE("cant get preview outpin of smart tee!");
  2576. return E_FAIL;
  2577. }
  2578. //Render pin
  2579. HRESULT hr;
  2580. hr = m_pGB->Render(pPreview);
  2581. if(FAILED(hr))
  2582. {
  2583. AfxMessageBox("不能进行播放，请重新选择视频编码器。");
  2584. return hr;
  2585. }
  2586. pPreview->Release();
  2587. if ( NULL == m_pVW )
  2588. {
  2589. hr = m_pGB->QueryInterface(IID_IVideoWindow, (void **)&m_pVW);
  2590. if (FAILED(hr))
  2591. {
  2592. TRACE0("ERROR - Could not Get IVideoWindow.");
  2593. return hr;
  2594. }
  2595. }
  2596. m_pVW->put_Owner((OAHWND)m_hWndOwner);
  2597. m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  2598. CRect rc;
  2599. GetClientRect(m_hWndOwner, &rc);
  2600. m_pVW->put_Top(0);
  2601. m_pVW->put_Left(0);
  2602. m_pVW->put_Width(rc.Width());
  2603. m_pVW->put_Height(rc.Height());
  2604. m_pVW->put_Visible(-1);
  2605. m_pVW->put_AutoShow(-1);
  2606. return hr;
  2607. }
  2609. //构建DV视频链路
  2610. HRESULT CCaptureGraph::BuildDVVideo()
  2611. {
  2612. HRESULT hr;
  2613. hr = AddFilter(CLSID_DVVideoCodec, &m_pDVDecoder);
  2614. if (FAILED(hr))
  2615. {
  2616. TRACE("加载m_pDVDecoder失败");
  2617. return hr;
  2618. }
  2620. //为了解决CPU消耗过高，只减小输出画面
  2621. IIPDVDec* lpDVDec = NULL;
  2622. hr = m_pDVDecoder->QueryInterface(IID_IIPDVDec, (void**)&lpDVDec);
  2623. if (FAILED(hr))
  2624. {
  2625. TRACE("获取IIPDVDec接口失败");
  2626. return hr;
  2627. }
  2628. else
  2629. {
  2630. lpDVDec->put_IPDisplay(DVRESOLUTION_HALF);
  2631. lpDVDec->Release();
  2632. }
  2634. //[DVSpliter] --> [DVVideoCodec]
  2635. hr = ConnectPins(m_pftrDVSpliter, "DVVidOut0", m_pDVDecoder, NULL);
  2636. if(FAILED(hr))
  2637. {
  2638. AfxMessageBox("与m_pDVDecoderFilter连接失败");
  2639. return E_FAIL;
  2640. }
  2642. if (m_pVideoOverlay)//如果字幕filter有则需连字幕filter
  2643. {
  2644. hr = AddDVVideoOverlay();
  2645. }
  2646. else//不需要字幕的情况
  2647. {
  2648. //Add Video Encoder 
  2649. if(!m_pVideoEncoder)
  2650. {
  2651. AfxMessageBox("No Video Compressor available!");
  2652. return E_FAIL;
  2653. }
  2654. hr = m_pGB->AddFilter(m_pVideoEncoder, NULL);
  2655. if(FAILED(hr))
  2656. {
  2657. AfxMessageBox("cant add video encoder filter to graph");
  2658. return hr;
  2659. }
  2661. //如果是DMO组件
  2662. if (IsDMOFilter())
  2663. {
  2664. hr = BuildVideoDMOEncoder();
  2665. if (FAILED(hr))
  2666. {
  2667. return hr;
  2668. }
  2669. }
  2670. else
  2671. {
  2672. //[DV Splitter] --> [VideoEncoder]
  2673. hr = ConnectPins(m_pDVDecoder, NULL, m_pVideoEncoder, NULL);
  2674. if(FAILED(hr))
  2675. {
  2676. AfxMessageBox("不能进行自动连接在m_pftrDVSpliter和m_pVideoEncoder之间");
  2677. return E_FAIL;
  2678. }
  2679. }
  2680. }
  2682. //Add VideoSmartTee
  2683. hr = AddFilter(CLSID_InfTee, &m_pVideoSmartTee);
  2684. if(FAILED(hr))
  2685. {
  2686. TRACE("cant add smarttee filter to graph");
  2687. return hr;
  2688. }
  2689. //[VideoEncoder] --> [VideoSmartTee]
  2690. hr = ConnectPins(m_pVideoEncoder, NULL, m_pVideoSmartTee, __T("Input"));
  2691. if(FAILED(hr))
  2692. {
  2693. TRACE("cant connect video encoder and Smart Tee!");
  2694. return E_FAIL;
  2695. }
  2696. //[Video SmartTee] --> [TVSink]
  2697. hr = ConnectPins(m_pVideoSmartTee, __T("Output1"), m_pTVStreamSink, __T("Video"));
  2698. if(FAILED(hr))
  2699. {
  2700. AfxMessageBox("不能进行播放，请重新选择视频编码器。");
  2701. return hr;
  2702. }
  2704. //==================================================================================================
  2705. //预览
  2706. if(m_bIsPreview)
  2707. {
  2708. hr = BuildDVVideoPrview();
  2709. if (FAILED(hr))
  2710. {
  2711. return hr;
  2712. }
  2713. }
  2714. return hr;
  2715. }
  2717. //采集DV
  2718. HRESULT CCaptureGraph::DisplayDV()
  2719. {
  2720. HRESULT hr;
  2721. //分离DV的信号
  2722. hr = DVSplitter();
  2723. if (FAILED(hr))
  2724. {
  2725. return hr;
  2726. }
  2728. //构建DV音频
  2729. hr = BuildDVAudio();
  2730. if (FAILED(hr))
  2731. {
  2732. return hr;
  2733. }
  2735. if (FALSE == m_bIsOnlyAudio)
  2736. {
  2737. hr = BuildDVVideo();
  2738. if (FAILED(hr))
  2739. {
  2740. return hr;
  2741. }
  2742. }
  2744. if (m_bSave)
  2745. {
  2746. hr = BuildSaveGraph();
  2747. if (FAILED(hr))
  2748. {
  2749. return hr;
  2750. }
  2751. }
  2752. return hr;
  2753. }