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

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

P2P编程

开发平台：

Visual C++

MMSGraph.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 "mmsgraph.h"
  21. #include "configFile.h"
  22. #include "string.h"
  24. //  {6B6D0800-9ADA-11d0-A520-00A0D10129C0}
  25. DEFINE_GUID(CLSID_NetShowSource, 
  26. 0x6b6d0800, 0x9ada, 0x11d0, 0xa5, 0x20, 0x0, 0xa0, 0xd1, 0x1, 0x29, 0xc0);
  28. //////////////////////////////////////////////
  29. // Only for Debug
  30. static DWORD g_dwRegister;
  31. static HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister) 
  32. {
  33. #ifdef _DEBUG
  34.     IMoniker * pMoniker;
  35.     IRunningObjectTable *pROT;
  36.     HRESULT hr;
  38.     hr = GetRunningObjectTable(0, &pROT);
  39.     if (FAILED(hr)) return hr;
  41.     WCHAR wsz[128];
  42.     wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
  43.     hr = CreateItemMoniker(L"!", wsz, &pMoniker);
  44.     if (SUCCEEDED(hr)) 
  45. {
  46.         hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
  47.         pMoniker->Release();
  48.     }
  49.     pROT->Release(); 
  50.     return hr;
  51. #endif
  53. return S_OK;
  54. }
  56. static void RemoveGraphFromRot(DWORD pdwRegister)
  57. {
  58. #ifdef _DEBUG
  59.     IRunningObjectTable *pROT;
  60.     if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) 
  61. {
  62.         pROT->Revoke(pdwRegister);
  63.         pROT->Release();
  64.     }
  65. #endif
  66. }
  68. /////////////////////////////////////////////////////////////////
  69. // CMMSGraph
  70. CMMSGraph::CMMSGraph(string strChannel, string strMMSAddr, HRESULT *hr)
  71. {
  72. m_pGB = NULL;
  73. m_pMC = NULL;
  74. m_pMMSSource = NULL;
  75. m_pSink = NULL;
  76. m_pAsfAcmHandler = NULL;
  77. m_pAsfIcmHandler = NULL;
  78. m_pAudioSmartTee = NULL;
  79. m_pTVConfig = NULL;
  81. m_pMMSInfo = new MMSGRAPHINFO;
  82. m_pMMSInfo->fDataRate = 0.0;
  83. m_pMMSInfo->fTotalBytes=0;
  84. m_pMMSInfo->m_oldtotalbyte=0;
  85. m_pMMSInfo->mmsState = INIT;
  86. m_pMMSInfo->llTimeEscaped = 0;
  87. m_pMMSInfo->strChannelName = strChannel;
  88. m_pMMSInfo->strMMSAddr = strMMSAddr;
  89. m_pMMSInfo->llTimeEscaped = 0;
  90.     m_pMMSInfo->m_time=0;
  92.     m_bReconnecting = false;
  94. *hr = Initialize();
  95. }
  97. CMMSGraph::~CMMSGraph()
  98. {
  99.     m_bReconnecting = false;
  101. SAFE_RELEASE(m_pSink);
  102. SAFE_RELEASE(m_pTVConfig);
  104. Uninitialize();
  106. if(m_pMMSInfo)
  107. {
  108. delete m_pMMSInfo;
  109. m_pMMSInfo = NULL;
  110. }
  111. }
  113. STDMETHODIMP CMMSGraph::Run()
  114. {
  115. if(m_pMC)
  116. return m_pMC->Run();
  118. return E_FAIL;
  119. }
  121. STDMETHODIMP CMMSGraph::Stop()
  122. {
  123. if(m_pMC)
  124. return m_pMC->Stop();
  126. return E_FAIL;
  127. }
  129. STDMETHODIMP CMMSGraph::Pause()
  130. {
  131. if(m_pMC)
  132. return m_pMC->Pause();
  134. return E_FAIL;
  135. }
  138. STDMETHODIMP CMMSGraph::Uninitialize()
  139. {
  140. RemoveGraphFromRot(g_dwRegister);
  142. DisassembleGraph();
  144. // release all objects
  145. SAFE_RELEASE(m_pGB);
  146. SAFE_RELEASE(m_pMC);
  148. // release COM lib
  149. CoUninitialize();
  151. return S_OK;
  152. }
  154. STDMETHODIMP CMMSGraph::BuildGraph(bool bAssumeAudioFirst)
  155. {
  156. // add/config source filter
  157. if(FAILED(CreateAddFilter(CLSID_NetShowSource, &m_pMMSSource)))
  158. {
  159. AfxMessageBox("can not create & add mms source filter!");
  160. return E_FAIL;
  161. }
  163. IFileSourceFilter *pSF;
  164. if(FAILED(m_pMMSSource->QueryInterface(IID_IFileSourceFilter, (VOID**)&pSF)))
  165. {
  166. AfxMessageBox("can not query interface of mms source filter!");
  167. return E_FAIL;
  168. }
  170. WCHAR wstrAddr[1024];
  171. MultiByteToWideChar(CP_ACP, 
  172. MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  173. m_pMMSInfo->strMMSAddr.data(),
  174. -1, 
  175. wstrAddr, 
  176. sizeof(wstrAddr) / sizeof(WCHAR));
  177. HRESULT hr;
  178. hr =  pSF->Load(wstrAddr, NULL);  
  179. if(FAILED(hr))
  180. {
  181. string strError;
  182. char s[100];
  183. wsprintf(s, "无法读取mms流：%s，请检查这个流是否可用。", m_pMMSInfo->strMMSAddr.data());
  184.    strError.append(s);
  185.   //AfxMessageBox(strError.data());
  186.     return FALSE;
  187.  
  188. }
  189. pSF->Release();
  191.     /*
  192.     IEnumPins* enumPin = NULL;
  193.     hr = m_pMMSSource->EnumPins(&enumPin);
  194.     IPin* pins = NULL
  195.     hr = enumPin->Next(1, &pins, NULL);
  196.     AM_MEDIA_TYPE type;
  197.     hr = pins->ConnectionMediaType(&type);
  198.     if(type.formattype == FORMAT_VideoInfo) {
  199.         pins->ConnectedTo(
  200.     }
  201.     */
  203.     if(m_pSink == NULL) {
  204.     // add our sink filter
  205.       if(FAILED(CreateAddFilter(CLSID_TVStreamSink, &m_pSink)))
  206.     {
  207.     AfxMessageBox("can not create & add capture filter!");
  208.     return E_FAIL;
  209.     }
  210.      
  211.     if(FAILED(m_pSink->QueryInterface(IID_ITVSouceConfig, (VOID**)&m_pTVConfig)))
  212.     {
  213.     AfxMessageBox("can not query interface of captureserver!");
  214.     return E_FAIL;
  215.     }
  216.     }
  217.     else {
  218. // No filter name specified, cannot convert
  219. // try to add it to the filter graph
  220. hr = m_pGB->AddFilter(m_pSink, NULL);
  221.         if(hr != S_OK)
  222.     {
  223.     AfxMessageBox("can not add capture filter!");
  224.     return E_FAIL;
  225.     }
  226.     }
  228. // connect graph
  229. // audio channel
  230. BOOL bHasAudio = TRUE;
  231. BOOL bHasVideo = TRUE;
  232. if(SUCCEEDED(FindASFHandler("ASF ACM Handler")))
  233. {
  234. VERIFY(SUCCEEDED(m_pGB->AddFilter(m_pAsfAcmHandler, NULL)));
  236.         hr = ConnectPins(m_pMMSSource, bAssumeAudioFirst?__T("Stream 1"):__T("Stream 2"), m_pAsfAcmHandler,NULL);
  237.         if(hr != S_OK) {
  238.             DisassembleGraph();
  239.             hr = BuildGraph(false);
  240.             return hr;
  241.         }
  242.         hr = ConnectPins(m_pAsfAcmHandler, NULL, m_pSink, __T("Audio"));
  243.         if(hr != S_OK) {
  244.         ASSERT(0);
  245. bHasAudio = FALSE;
  246. RemoveFilter(m_pAsfAcmHandler);
  247. SAFE_RELEASE(m_pAsfAcmHandler);
  248.         }
  250.         /*
  251.         if((FAILED(ConnectPins(m_pMMSSource, __T("Stream 1"), m_pAsfAcmHandler,NULL) && 
  252.            FAILED(ConnectPins(m_pMMSSource, __T("Stream 2"), m_pAsfAcmHandler,NULL)) || 
  253.            FAILED(ConnectPins(m_pAsfAcmHandler, NULL, m_pSink, __T("Audio"))))))
  254. {
  255.         ASSERT(0);
  256. bHasAudio = FALSE;
  257. RemoveFilter(m_pAsfAcmHandler);
  258. SAFE_RELEASE(m_pAsfAcmHandler);
  259. }
  260.         */
  261. }
  262. else
  263. bHasAudio = FALSE;
  265. // video channel
  266. if(SUCCEEDED(FindASFHandler("ASF ICM Handler")))
  267. {
  268.         VERIFY(SUCCEEDED(m_pGB->AddFilter(m_pAsfIcmHandler, NULL)));
  269.         hr = ConnectPins(m_pMMSSource, bAssumeAudioFirst?__T("Stream 2"):__T("Stream 1"), m_pAsfIcmHandler,NULL);
  270.         if(hr != S_OK) {
  271.             DisassembleGraph();
  272.             hr = BuildGraph(false);
  273.             return hr;
  274.         }
  275.         hr = ConnectPins(m_pAsfIcmHandler, NULL, m_pSink, __T("Video"));
  276.         if(hr != S_OK) {
  277.             ASSERT(0);
  278.             bHasVideo = FALSE;
  279.             RemoveFilter(m_pAsfIcmHandler);
  280.             SAFE_RELEASE(m_pAsfIcmHandler);
  281.         }
  283.         /*
  284. if((FAILED(ConnectPins(m_pMMSSource, __T("Stream 2"), m_pAsfIcmHandler,NULL) &&
  285.            FAILED(ConnectPins(m_pMMSSource, __T("Stream 1"), m_pAsfIcmHandler,NULL)) ||
  286.    FAILED(ConnectPins(m_pAsfIcmHandler, NULL, m_pSink, __T("Video"))))))
  287. { 
  288.         ASSERT(0);
  289. bHasVideo = FALSE;
  290. RemoveFilter(m_pAsfIcmHandler);
  291. SAFE_RELEASE(m_pAsfIcmHandler);
  292. }
  293.         */
  295. #ifdef TIME_EXPIRE
  296.         /// 如果过了2006-03-21日，就返回错误
  297.         tm expire_tm;
  298.         memset(&expire_tm, 0, sizeof(expire_tm));
  299.         expire_tm.tm_year = 106;
  300.         expire_tm.tm_mon = 2;
  301.         expire_tm.tm_mday = 21;
  303.         time_t expire_seconds = mktime(&expire_tm);
  304.         time_t now;
  305.         time( &now );                /* Get time as long integer. */
  307.         if(now > expire_seconds)
  308.             return E_FAIL;
  309. #endif
  310. }
  311. else
  312. bHasVideo = FALSE;
  314. if(!bHasVideo && !bHasAudio)
  315. {
  316. AfxMessageBox("Sorry, MMS Server cant get media. plz check mms address is right!");
  317. return E_FAIL;
  318. }
  319. if(!bHasVideo)
  320. {
  321. // AfxMessageBox("warning:no video captured!");
  322. //return S_FALSE;
  324.   m_pTVConfig->SetAudioOrVideoOnly(TRUE); // set audio only
  325. }
  326. if(!bHasAudio)
  327. {
  328. AfxMessageBox("warning:no audio captured!");
  329. return S_FALSE;
  330. }
  332. return 1 ; 
  333. }
  335. STDMETHODIMP CMMSGraph::DisassembleGraph()
  336. {
  337. Stop();
  339. // remove all filters from graph
  340. RemoveFilter(m_pMMSSource);
  341. RemoveFilter(m_pSink);
  342. if(m_pAsfAcmHandler)
  343. RemoveFilter(m_pAsfAcmHandler);
  344. if(m_pAsfAcmHandler)
  345. RemoveFilter(m_pAsfIcmHandler);
  346. if(m_pAudioSmartTee)
  347. RemoveFilter(m_pAudioSmartTee);
  349. SAFE_RELEASE(m_pMMSSource);
  350. SAFE_RELEASE(m_pAsfIcmHandler);
  351. SAFE_RELEASE(m_pAsfAcmHandler);
  352. SAFE_RELEASE(m_pAudioSmartTee);
  354. return S_OK;
  355. }
  357. MMSGRAPHINFO *CMMSGraph::GetMMSGraphInfo()
  358. { 
  359.     ////////////Get  the  value of  the ResStartTime 
  360. CString str_path;
  361. GetModuleFileName(NULL,str_path.GetBuffer(MAX_PATH),MAX_PATH);
  362. str_path.ReleaseBuffer();
  363. int index = str_path.ReverseFind('\');
  364.     str_path=  str_path.Left(index+1);
  365.     int ResStartTime = 10;
  367.     static bool reconnecting = false;
  369. // speed
  370. m_pMMSInfo->fDataRate = m_pTVConfig->GetCompressedSpeed();
  371.     m_pMMSInfo->fTotalBytes=m_pTVConfig->GetTotalBytes(); //get current totalbytes
  372.  
  373.  if(m_pMMSInfo->fTotalBytes>m_pMMSInfo->m_oldtotalbyte) //if we got new data
  374. {
  375. if (m_pMMSInfo->mmsState==RUNNING)
  376.  m_pMMSInfo->llTimeEscaped++;
  378.      m_pMMSInfo->m_time=0;   //recount
  379.  }
  380.  else  if(m_pMMSInfo->mmsState != STOPPED )//if data stopped
  381.  {
  382.  m_pMMSInfo->m_time++;
  383.          if(m_pTVConfig->EndOfStream() || m_pMMSInfo->m_time >= ResStartTime) {
  384.             if(!m_bReconnecting) {
  385.                 m_bReconnecting = true;
  386.                 HRESULT ret = this->DisassembleGraph();
  387.                 ret = this->BuildGraph();
  388.                 ret = this->Run();
  389.                 m_bReconnecting = false;
  390.             }
  391. m_pMMSInfo->m_time=0;  //recount
  392.         }
  393.  }
  394.  
  395.  if (m_pMMSInfo->m_time==0)  
  396.  m_pMMSInfo->m_oldtotalbyte=m_pMMSInfo->fTotalBytes;
  397.  
  398.     // state
  399.  OAFilterState os;
  400.  m_pMC->GetState(100, &os);
  401.  
  402.  if(os == State_Running)
  403.  m_pMMSInfo->mmsState = RUNNING;
  404.      else if(os == State_Stopped) {
  405.  m_pMMSInfo->mmsState = STOPPED;
  406.          if(m_bReconnecting)
  407.              m_pMMSInfo->mmsState = RECONNECTING;
  408.      }
  409.  else if(os == State_Paused)
  410.  m_pMMSInfo->mmsState = PAUSED;
  411.  else
  412.  m_pMMSInfo->mmsState = INIT;
  413.  
  414.  // time escaped 
  415.  return m_pMMSInfo;
  416. }
  418. STDMETHODIMP CMMSGraph::CreateAddFilter(CLSID clsidFilter,    
  419.  IBaseFilter** ppIFilter,
  420.  LPCTSTR pstrFilterName)
  421. {
  422. HRESULT hr;
  423. ASSERT(m_pGB);
  424. ASSERT(ppIFilter);
  425. (*ppIFilter) = NULL;
  427. // try to instantiate the filter
  428. hr = CoCreateInstance(clsidFilter, 
  429.  NULL, 
  430.  CLSCTX_INPROC, 
  431.  IID_IBaseFilter,
  432.  (LPVOID*)(ppIFilter));
  433. if(FAILED(hr))
  434. {
  435. TRACE("Could not instantiate filter");
  436. return hr;
  437. }
  439. // Check for unicode or not
  440. #ifndef _UNICODE
  441. if(pstrFilterName)
  442. {
  443. // not unicode, we need to unicodify the string
  444. WCHAR wstrFilterName[256];
  445. MultiByteToWideChar(CP_ACP, 
  446. MB_PRECOMPOSED | MB_USEGLYPHCHARS,
  447.     pstrFilterName,
  448. -1, 
  449.     wstrFilterName, 
  450. sizeof(wstrFilterName) / sizeof(WCHAR));
  452. // try to add it to the filter graph
  453. hr = m_pGB->AddFilter(*ppIFilter, wstrFilterName);
  454. }
  455. else
  456. {
  457. // No filter name specified, cannot convert
  458. // try to add it to the filter graph
  459. hr = m_pGB->AddFilter(*ppIFilter, NULL);
  460. }
  461. #else
  462. // already unicode, no need to change anything
  463. // try to add it to the filter graph
  464. hr = m_pGB->AddFilter(*ppIFilter, pstrFilterName);
  465. #endif
  467. // check the result of the operation
  468. if(FAILED(hr))
  469. {
  470. TRACE("Could not add filter to filter graphn");
  471. // free the filter definitely
  472. (*ppIFilter)->Release();
  473. (*ppIFilter) = NULL;
  474. return hr;
  475. }
  477. // that's it
  478. return hr;
  479. }
  481. STDMETHODIMP CMMSGraph::RemoveFilter(IBaseFilter* pIFilter)
  482. {
  483. HRESULT hr;
  485.    // Parameters...
  486.    if(!pIFilter)
  487.       // DON'T return an error, this is expected
  488.       return NOERROR;
  490.    ASSERT(m_pGB);
  492.    // Just remove it from the graph
  493.    hr = m_pGB->RemoveFilter(pIFilter);
  495.    // Check the result
  496.    if(FAILED(hr))
  497.       TRACE("Could not remove filter from filter graphn");
  499.    return hr;
  500. }
  502. STDMETHODIMP CMMSGraph::ConnectPins(IBaseFilter* pIFilterOutput, 
  503.    LPCTSTR pstrPinNameOutput,
  504.    IBaseFilter* pIFilterInput, 
  505.    LPCTSTR pstrPinNameInput,
  506.    AM_MEDIA_TYPE* pmt)
  507. {
  508. HRESULT hr;
  509. ASSERT(m_pGB);
  511. // Parameters...
  512. if((!pIFilterOutput) || (!pIFilterInput))
  513. {
  514. //ASSERT(pIFilterOutput && pIFilterInput);
  515. TRACE("ConnectPins called with NULL parametern");
  516. return E_INVALIDARG;
  517. }
  519. // Find the first pin
  520. IPin* pIPinOutput = FindPinOnFilter(pIFilterOutput, 
  521. pstrPinNameOutput,
  522.     PINDIR_OUTPUT);
  523. if(!pIPinOutput)
  524. {
  525. // ASSERT(pIPinOutput);
  526. return E_FAIL;
  527. }
  529. // Find the second pin
  530. IPin* pIPinInput = FindPinOnFilter(pIFilterInput,
  531.    pstrPinNameInput,
  532.    PINDIR_INPUT);
  533. if(!pIPinInput)
  534. {
  535. //ASSERT(pIPinInput);
  536. // release the other pin
  537. pIPinOutput->Release();
  538. return E_FAIL;
  539. }
  541. if(FAILED(pIPinOutput->Disconnect()))
  542. {
  543. //ASSERT(FALSE);
  544. return E_FAIL;
  545. }
  547. if(FAILED(pIPinInput->Disconnect()))
  548. {
  549. //ASSERT(FALSE);
  550. return E_FAIL;
  551. }
  553. // Now just connect the two pins
  554.     if(NULL == pmt || pmt->cbFormat == 0)
  555.        hr = m_pGB->Connect(pIPinOutput, pIPinInput);
  556. else
  557. hr = m_pGB->ConnectDirect(pIPinOutput, pIPinInput, pmt);
  558. if(FAILED(hr))
  559.   TRACE("Could not connect pins!");
  561. // Release the two pins and return the result
  562. pIPinOutput->Release();
  563. pIPinInput->Release();
  565. return hr;
  566. }
  568. STDMETHODIMP CMMSGraph::DisconnectPin(IBaseFilter *pIFilter, 
  569.  LPCTSTR pstrPinName,
  570.  PIN_DIRECTION dir)
  571. {
  572. HRESULT hr;
  573. ASSERT(m_pGB);
  575. // Parameters...
  576. if(!pIFilter)
  577.   // DON'T fail on this, it is expected
  578.   return NOERROR;
  580. // Find the pin
  581. IPin* pIPin = FindPinOnFilter(pIFilter, pstrPinName, dir);
  582. if(!pIPin)
  583. {
  584. TRACE("Could not find specified filter pinn");
  585. return E_FAIL;
  586. }
  588. // Find the pin it's connected to
  589. IPin* pIPinConnected;
  590. hr = pIPin->ConnectedTo(&pIPinConnected);
  591. if((FAILED(hr)) || (!pIPinConnected))
  592. {
  593. // Function call failed, pin not connected, nothing to do!
  594. pIPin->Release();
  595. return NOERROR;
  596. }
  598. // Try to disconnect the input pin first
  599. if (dir == PINDIR_INPUT)
  600. {
  601. // ok now disconnect both of them
  602. hr = m_pGB->Disconnect(pIPin);
  603. if(FAILED(hr))
  604. {
  605. // just forget everything
  606. ASSERT(SUCCEEDED(hr));
  607. pIPin->Release();
  608. pIPinConnected->Release();
  609. TRACE("Disconnect failed on input pinn");
  610. return hr;
  611. }
  612. hr = m_pGB->Disconnect(pIPinConnected);
  613. if(FAILED(hr))
  614. {
  615. ASSERT(SUCCEEDED(hr));
  616. TRACE("Disconnect failed on output pinn");
  617. }
  618. }
  619.    else
  620.    {
  621. // ok now disconnect both of them
  622. hr = m_pGB->Disconnect(pIPinConnected);
  623. if(FAILED(hr))
  624. {
  625. ASSERT(SUCCEEDED(hr));
  626. // just forget everything
  627. pIPin->Release();
  628. pIPinConnected->Release();
  629. TRACE("Disconnect failed on input pinn");
  630. return hr;
  631. }
  632. hr = m_pGB->Disconnect(pIPin);
  633. if(FAILED(hr))
  634. {
  635. ASSERT(SUCCEEDED(hr));
  636. TRACE("Disconnect failed on output pinn");
  637. }
  638.    }
  640.    // Just release the two pins and return last result
  641.    pIPin->Release();
  642.    pIPinConnected->Release();
  644.    return hr;
  645. }
  647. STDMETHODIMP_(BOOL) CMMSGraph::IsConnected(IBaseFilter *pFilter,
  648.                         LPCTSTR pstrPinName, 
  649. PIN_DIRECTION pd)
  650. {
  651. ASSERT(m_pGB);
  653. // Parameters...
  654. if((!pFilter))
  655. {
  656. ASSERT(pFilter);
  657. TRACE("ConnectPins called with NULL parametern");
  658. return FALSE;
  659. }
  661. // Find the pin
  662. IPin* pIPin = FindPinOnFilter(pFilter, 
  663.   pstrPinName,
  664.   pd);
  665. if(!pIPin)
  666. {
  667. ASSERT(pIPin);
  668. return FALSE;
  669. }
  671. IPin  *pNextPin = NULL;
  673. pIPin->ConnectedTo(&pNextPin);
  674. if(!pNextPin)
  675. {
  676. return FALSE;
  677. }
  679. pIPin->Release();
  680. pNextPin->Release();
  682. //That's it...
  683. return TRUE;
  684. }
  686. STDMETHODIMP_(IPin*) CMMSGraph::FindPinOnFilter(IBaseFilter* pIFilter, 
  687.              LPCTSTR pstrPinName,
  688.              PIN_DIRECTION dir)
  689. {
  690. HRESULT     hr;
  691. IEnumPins*  pIEnumPins;
  692. IPin*       pIPin;
  693. PIN_INFO    pi;
  694. ASSERT(m_pGB);
  696. // Parameters...
  697. if(!pIFilter)
  698.   return NULL;
  700. // Enumerate pins on the filter
  701. hr = pIFilter->EnumPins(&pIEnumPins);
  702. if(FAILED(hr))
  703.   // pin was not found!
  704.   return NULL;
  706. // Loop till we find no more pins
  707. IPin* pIPinFound = NULL;
  708. while( (!pIPinFound) && (pIEnumPins->Next(1, &pIPin, NULL)==S_OK) )
  709. {
  710. // Is this the pin?
  711. hr = pIPin->QueryPinInfo(&pi);
  712. if(!FAILED(hr))
  713. {
  714. // check if it is the right direction
  715. if(pi.dir == dir)
  716. {
  717. // Let the graph builder find the right filter
  718. TCHAR strFoundPinName[256];
  719. #ifndef _UNICODE
  720.    // not unicode, we need to de-unicodify the returned pin name
  721.    WideCharToMultiByte(CP_ACP, NULL,
  722.    pi.achName, -1,
  723.    strFoundPinName, sizeof(strFoundPinName),
  724.    NULL, NULL);
  725. #else
  726.    // just make a copy of the string
  727.    lstrcpyn(strFoundPinName, pi.achName, sizeof(strFoundPinName));
  728. #endif
  730. // check if there is a pin name specified
  731. if(!pstrPinName)
  732. {
  733. // no name specified, take the first pin found
  734. pIPinFound = pIPin;
  735. pIPinFound->AddRef();
  736. }
  737. // check if we have the right pin name
  738. else if(lstrcmp(strFoundPinName, pstrPinName)==0)
  739. {
  740. // yes we have!
  741. pIPinFound = pIPin;
  742. pIPinFound->AddRef();
  743. }
  744. }
  746. // release the PIN_INFO data
  747. pi.pFilter->Release();
  748. }
  750. // release the IPin pointer
  751. pIPin->Release();
  752. }
  754. // Finished with the enumerator, let it go (be free)
  755. pIEnumPins->Release();
  757. // Return whatever we have found
  758. return pIPinFound;
  759. }
  761. HRESULT CMMSGraph::FindASFHandler(string strFilterName)
  762. {
  763. HRESULT hr;
  764.     IMoniker *pMoniker =NULL;
  765.     ULONG cFetched;
  767.     // Create the system device enumerator
  768.     ICreateDevEnum* pDevEnum = NULL;
  770.     hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
  771.                            IID_ICreateDevEnum, (void **) &pDevEnum);
  772.     if (FAILED(hr))
  773.     {
  774.         TRACE1(TEXT("Couldn't create system enumerator!  hr=0x%x"), hr);
  775.         return hr;
  776.     }
  778.     IEnumMoniker *pClassEnum = NULL;
  780.     hr = pDevEnum->CreateClassEnumerator(CLSID_LegacyAmFilterCategory, &pClassEnum, 0);
  781.     if (FAILED(hr))
  782.     {
  783. pDevEnum->Release();
  784.         TRACE1(TEXT("Couldn't create class enumerator!  hr=0x%x"), hr);
  785.         return hr;
  786.     }
  788.     if (pClassEnum == NULL)
  789. {
  790. pDevEnum->Release();
  791.         return E_FAIL;
  792. }
  794. BOOL bFinded = FALSE;
  795.     while (S_OK == (pClassEnum->Next (1, &pMoniker, &cFetched)))
  796.     {
  797. IPropertyBag *pPropBag;
  798.         hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, 
  799.                                      (void **)&pPropBag);
  800.         if (SUCCEEDED(hr))
  801.         {
  802.             VARIANT varName;
  803.             VariantInit(&varName);
  804.             hr = pPropBag->Read(L"FriendlyName", &varName, 0);
  805.             if (SUCCEEDED(hr))
  806.             {
  807.                 int cch = lstrlenW(varName.bstrVal) + 1;
  808. CHAR* lpszFilterName = new char[cch * 2];
  809. if (!lpszFilterName) 
  810.        return E_OUTOFMEMORY;
  811. WideCharToMultiByte(GetACP(), 0, varName.bstrVal, -1,
  812.      lpszFilterName, cch, NULL, NULL);
  814. string str;
  815. str.append(lpszFilterName);
  816. if(strFilterName == str)
  817. {
  818. if(str == "ASF ACM Handler")
  819. {
  820. pMoniker->BindToObject(NULL, NULL, 
  821. IID_IBaseFilter,
  822. (VOID**)&m_pAsfAcmHandler);
  823. bFinded = TRUE;
  824. }
  825. else if(str == "ASF ICM Handler")
  826. {
  827. pMoniker->BindToObject(NULL, NULL, 
  828. IID_IBaseFilter,
  829. (VOID**)&m_pAsfIcmHandler);
  830. bFinded = TRUE;
  831. }
  832. else
  833. ASSERT(FALSE);
  835. delete [] lpszFilterName;
  836. VariantClear(&varName);
  837. pPropBag->Release();
  838. pMoniker->Release();
  839. break;
  840. }
  842. delete [] lpszFilterName;
  843.             }
  845.             VariantClear(&varName);
  846. pPropBag->Release();
  847. }
  848. pMoniker->Release();
  849.     }
  851. pClassEnum->Release();
  852. pDevEnum->Release();
  854. if(bFinded)
  855.     return S_OK;
  857. return E_FAIL;
  858. }
  862. STDMETHODIMP CMMSGraph::Initialize()
  863. {
  864.     HRESULT hr = CoInitialize(NULL);
  865.     if (FAILED(hr))
  866.     {
  867.         TRACE0("ERROR - Could not initialize COM library");
  868.         return hr;
  869.     }
  871. // Create the filter graph manager and query for interfaces.
  872.     hr = CoCreateInstance(CLSID_FilterGraph, 
  873.                   NULL, 
  874.   CLSCTX_INPROC_SERVER, 
  875.                           IID_IGraphBuilder, 
  876.   (void **)&m_pGB);
  877.     if (FAILED(hr))
  878.     {
  879.         TRACE0("ERROR - Could not create the Filter Graph Manager.");
  880.         return hr;
  881.     }
  883. hr = m_pGB->QueryInterface(IID_IMediaControl, (void **)&m_pMC);
  884. if (FAILED(hr))
  885.     {
  886.         TRACE0("ERROR - Could not Get IMediaControl");
  887.         return hr;
  888.     }
  890. AddGraphToRot(m_pGB, &g_dwRegister);  
  891.   
  892. if(!BuildGraph())
  893. {
  894.  return -1 ;
  895. }
  897. return S_OK;
  898. }