Directshow 中使用 IGraphBuilder

最新推荐文章于 2016-01-06 09:28:21 发布
最新推荐文章于 2016-01-06 09:28:21 发布
阅读量1.1w 收藏 3
点赞数
文章标签： null interface filter reference output graph
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yecao_kinux/article/details/1542476
版权

Directshow 中使用 IGraphBuilder

在使用directShow的过程中，常常会用到IGraphBuilder，很多人都喜欢把它封装成类的方式来使用。在网上有许多版本的封装方式，这个是我在学习过程中使用的一个封装，说不上好，贴出来是自己记录一下，当然，也可以供大家参考学习。

//以下代码仅供参考学习
//Author:古斌亮
//email: lonly_gun@hotmail.com

//GraphBuilder.h 文件
#ifndef __GRAPHBUILDER__H__
#define __GRAPHBUILDER__H__

//
// File Name : GraphBuilder.h
//
// Description : ....
//
// Creator  : James Gu
//
// Time   : 12/01/2006
//
// Modified  : ........
//     ........
//==============================================================================



//include

#define WIN32_LEAN_AND_MEAN  // 从 Windows 头中排除极少使用的资料
// Windows 头文件:
#include <windows.h>

#include <stdio.h>
#include <streams.h>

#include <atlbase.h>
extern CComModule _Module;
#include <atlcom.h>

#include <qedit.h>

#include <Mmsystem.h>
#include <initguid.h>

//#include <vector>


//devfine

#define S_RELEASE(x) {if(x){x->Release();x = NULL;}}


//Initialize COM  

//class CCOMInitialize
//{
//public:
// CCOMInitialize(){::CoInitialize(NULL);}
// ~ CCOMInitialize(){::CoUninitialize();}
//};


//CDeviceFilter -- device filter

class CDeviceFilter
{
public:
 CDeviceFilter();
 virtual ~ CDeviceFilter();

public:
 IBaseFilter*  DeviceFilter(){return m_pFilter;}

public://CLSID_SystemDeviceEnum
 bool CreateEnumor(REFCLSID riid );
 void ReleaseEnumor();

public:
 BOOL GetFirstFilter(const char * szFriendName = NULL);
 BOOL GetNextFilter(const char * szFriendName = NULL);

protected:
 BOOL GetDeviceByFriendName(const char * szFriendName);

protected:
 CComPtr<ICreateDevEnum> m_sysenum;
 IEnumMoniker *   m_pEnumMoniker;
 IBaseFilter *   m_pFilter;
};



//CGraphBuilder -- smart graphbuilder
//
// DxShow应用的基本类:   James gu -- 02/07/2007
// 改类进行对IGraphBuilder进行封装,完成部分IGraphBuilder的功能
// 还可以对改类进行近一步的扩展，使可以完成FilterGraph Objects的更多功能
//

class CGraphBuilder
{
public://Graphbuilder
 HRESULT QueryInterface(REFIID riid,void ** ppvObject);

public://filtergraph && filtergraph2 interface
 HRESULT Connect(IPin *ppinOut,IPin *ppinIn);
 HRESULT Render(IPin *ppinOut);
 HRESULT RenderFile(LPCWSTR lpwstrFile,LPCWSTR lpwstrPlayList);
 HRESULT AddSourceFilter(LPCWSTR lpwstrFileName,
  LPCWSTR lpwstrFilterName,IBaseFilter **ppFilter);

 HRESULT SetLogFile(DWORD_PTR hFile);
 HRESULT Abort(void);
 HRESULT ShouldOperationContinue(void);

 HRESULT AddFilter(IBaseFilter *pFilter,LPCWSTR pName);
 HRESULT RemoveFilter(IBaseFilter *pFilter);
 HRESULT EnumFilters(IEnumFilters **ppEnum);
 HRESULT FindFilterByName(LPCWSTR pName,IBaseFilter **ppFilter);
 HRESULT ConnectDirect(IPin *ppinOut,IPin *ppinIn,const AM_MEDIA_TYPE *pmt);
 HRESULT Reconnect(IPin *ppin);
 HRESULT Disconnect(IPin *ppin);
 HRESULT SetDefaultSyncSource(void);

public://MediaControl interface(s)
public://MediaEvent interface(s)
public://MediaEventEx interface(s)
public://MediaSeeking interface(s)
public://VideoWindow interface(s)

public://function(s)
 void HandleEvent();
 void DeviceAbort();
 BOOL DisConnectAllPin(IBaseFilter * pFilter);
 HRESULT GetPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir, IPin **ppPin);
 HRESULT ConnectFilters(IBaseFilter *pFirst, IBaseFilter *pSecond);
 void DisConnectFilterNukeDown(IBaseFilter * inFilter,BOOL bRemove = FALSE);
 void DisConnectFilterNukeUp(IBaseFilter * inFilter,BOOL bRemove = FALSE);
 void RemoveFilters();

protected:
 bool OnDeviceAbort();
 bool OnDeviceLost(IUnknown  *punk);

public://control(s)
 BOOL QueryInterface();
 void ReleaseInterface();

public://控制方法
    bool ResizeWindow(const RECT& rect);
 bool ResizeWindow(long left,long top,long width,long height);
 bool SetDisplayWindow(HWND hWnd);
 bool SetNotifyWindow(HWND hWnd, UINT message);

 bool Play();
 bool Stop();
 bool Pause();
 bool StopWhenReady();

 bool IsRunning();
 bool IsStop();
 bool IsPause();

public:
 CGraphBuilder();
 CGraphBuilder(IGraphBuilder * builder);
 virtual ~CGraphBuilder();

public:
 bool Attach(IGraphBuilder * builder);

private://
 CGraphBuilder(const CGraphBuilder& builder){}
 CGraphBuilder& operator=(const CGraphBuilder& me){return *this;}

public://interface(s)
 IGraphBuilder *  GraphBuilder(){return m_pGraph;}

private:
 IMediaControl *  MediaControl();
 IMediaEventEx *  MediaEventEx();

protected:
 CComPtr<IGraphBuilder>   m_pGraph;

protected:
 IMediaControl *  m_pMediaControl;

protected:
 HWND   m_hWnd;
};


//CCaptureGraphBuilder -- capture graphbuilder

class CCaptureGraphBuilder
{
public://FilterGraph2 Interface
 STDMETHOD(AllocCapFile)(LPCOLESTR lpwstr, DWORDLONG dwlSize);
 STDMETHOD(ControlStream)(const GUID *pCategory,
      const GUID *pType,
      IBaseFilter *pFilter,
                        REFERENCE_TIME *pstart,
                        REFERENCE_TIME *pstop,
                        WORD wStartCookie,
                        WORD wStopCookie);

 STDMETHOD(CopyCaptureFile)(LPOLESTR lpwstrOld,
      LPOLESTR lpwstrNew,
      int fAllowEscAbort,
                        IAMCopyCaptureFileProgress *pCallback);

 STDMETHOD(FindInterface)(const GUID *pCategory,
      const GUID *pType,
      IBaseFilter *pf,
      REFIID riid,
      void **ppint);

 STDMETHOD(FindPin)(IUnknown *pSource,
      PIN_DIRECTION pindir,
      const GUID *pCategory,
                        const GUID *pType,
      BOOL fUnconnected,
      int num,
      IPin **ppPin);

 STDMETHOD(GetFiltergraph)(IGraphBuilder **ppfg);

 STDMETHOD(RenderStream)(const GUID *pCategory,
      const GUID *pType,
      IUnknown *pSource,
      IBaseFilter *pIntermediate,
      IBaseFilter *pSink);

 STDMETHOD(SetOutputFileName)(const GUID *pType,
      LPCOLESTR lpwstrFile,
      IBaseFilter **ppf,
      IFileSinkFilter **pSink);

 STDMETHOD(SetFiltergraph)(IGraphBuilder *pfg);

protected://stream config
 HRESULT SetGraphBuilder();

public://IAMStreamConfig Interface
 HRESULT GetFormat(AM_MEDIA_TYPE **pmt);
 HRESULT GetNumberOfCapabilities(int *piCount,int *piSize);
 HRESULT GetStreamCaps(int iIndex,AM_MEDIA_TYPE **pmt,BYTE *pSCC);
 HRESULT SetFormat(AM_MEDIA_TYPE *pmt);
 //config(s) 

protected:
 IAMStreamConfig * AMStreamConfig();

public:
 CCaptureGraphBuilder(CGraphBuilder& gf,CDeviceFilter& dev);
 virtual ~CCaptureGraphBuilder();

protected:
 CComPtr<ICaptureGraphBuilder2> m_pGraphBuilder2;
 CGraphBuilder&     m_graphbuilder;
 CDeviceFilter&     m_device;
 IAMStreamConfig *    m_streamconfig;
};


//CDXBaseFilter -- dxbase filter

class CDXBaseFilter
{
public:
 CDXBaseFilter(const GUID& guid);
 virtual ~ CDXBaseFilter();

public:
 IBaseFilter*  BaseFilter(){return m_pFilter;}

public:
 IPin * GetPin(PIN_DIRECTION PinDir = PINDIR_OUTPUT);

protected:
 CComPtr<IBaseFilter> m_pFilter;
 GUID     m_guid;
};


#endif //__GRAPHBUILDER__H__

//GraphBuilder.cpp 文件

///
//
// File Name : GraphBuilder.cpp
//
// Description : ....
//
// Author  : James Gu
//
// Time   : 12/01/2006
//
// Modified  : ........
//     ........
//=================================================================================

/
//
/
//#include "stdafx.h"

#include <assert.h>
#include "graphbuilder.h"

/
//
/
//linker library
//#if _DEBUG
//#pragma comment(lib,"strmbasd.lib")
//#else //_DEBUG
//#pragma comment(lib,"STRMBASE.lib")
//#endif //_DEBUG
//
//#pragma comment(lib,"strmiids.lib")
//#pragma comment(lib,"winmm.lib")
//#pragma comment(lib,"quartz.lib")
//#pragma comment(lib,"uuid.lib")

/
//
/
#define WriteLog TRACE

/
//
/
//static const CCOMInitialize com_initialized = CCOMInitialize();

/
//class CDeviceFilter
//
/
CDeviceFilter::CDeviceFilter()
{
 m_pEnumMoniker = NULL;
 m_pFilter  = NULL;
}

/
//
/
CDeviceFilter::~CDeviceFilter()
{
 if(m_pFilter)
 {
  m_pFilter->Release();
  m_pFilter = NULL;
 }

 if(m_pEnumMoniker)
 {
  m_pEnumMoniker->Release();
  m_pEnumMoniker = NULL;
 }
 m_sysenum.Release();
}


/
//CLSID_SystemDeviceEnum
/
bool CDeviceFilter::CreateEnumor(REFCLSID riid )
{
 HRESULT hr = -1;

 if(m_pEnumMoniker)
 {
  m_pEnumMoniker->Release();
  m_pEnumMoniker = NULL;
 }

 m_sysenum.Release();

 hr = m_sysenum.CoCreateInstance(CLSID_SystemDeviceEnum);
 if(FAILED(hr))
 {
  return false;
 }

 hr = m_sysenum->CreateClassEnumerator(riid,&m_pEnumMoniker,0);

 if(SUCCEEDED(hr))
 {
  hr = m_pEnumMoniker->Reset();
 }

 return (SUCCEEDED(hr))?(true):(false);
}

/
//
/
void CDeviceFilter::ReleaseEnumor()
{
 if(m_pEnumMoniker)
 {
  m_pEnumMoniker->Release();
  m_pEnumMoniker = NULL;
 }

 m_sysenum.Release();
}

/
//
/
BOOL CDeviceFilter::GetFirstFilter(const char * szFriendName)
{
 return GetNextFilter(szFriendName);
}

/
//
/
BOOL CDeviceFilter::GetNextFilter(const char * szFriendName)
{
 HRESULT   hr   = -1;
 IMoniker *  pmoniker = NULL;
 
 if(m_pEnumMoniker)
 {
  S_RELEASE(m_pFilter);

  if(szFriendName)
  {
   return GetDeviceByFriendName(szFriendName);
  }
  else
  {
   hr = m_pEnumMoniker->Next(1,&pmoniker,NULL);
   if(SUCCEEDED(hr))
   {
    hr = pmoniker->BindToObject(NULL,NULL,IID_IBaseFilter,(void**)&m_pFilter);
    S_RELEASE(pmoniker);
   }
  }
 }
 return (SUCCEEDED(hr))?(TRUE):(FALSE);
}

/
//
/
BOOL CDeviceFilter::GetDeviceByFriendName(const char * szFriendName)
{
 HRESULT    hr  = -1;
 IMoniker *  pmoniker = NULL;
 IPropertyBag * pbag  = NULL;

 const CComVariant tarName = szFriendName;
 CComVariant   vname;
 
 while(SUCCEEDED(m_pEnumMoniker->Next(1,&pmoniker,NULL)))
 {
  hr = pmoniker->BindToStorage(NULL,NULL,IID_IPropertyBag,(void**)&pbag);
  if(SUCCEEDED(hr))
  {
   hr = pbag->Read(L"FriendlyName",&vname,NULL);
   if(SUCCEEDED(hr) && (vname == tarName))
   {
    hr = pmoniker->BindToObject(NULL,NULL,IID_IBaseFilter,(void**)&m_pFilter);      
    if(SUCCEEDED(hr))
    {
     S_RELEASE(pbag);
     S_RELEASE(pmoniker);
     break;
    }
   }
   S_RELEASE(pbag);
  }
  S_RELEASE(pmoniker);
 };//while()

 return (SUCCEEDED(hr))?(TRUE):(FALSE);
}

/
//class CGraphBuilder
/
CGraphBuilder::CGraphBuilder()
{
 m_pMediaControl  = NULL;

 if( FAILED(m_pGraph.CoCreateInstance(CLSID_FilterGraph)) )
 {
  throw "Cann't create graph builder object!";
 }
}

/
//
/
CGraphBuilder::CGraphBuilder(IGraphBuilder * builder)
{
 m_pMediaControl = NULL;

 if(builder)
 {
  Attach(builder);
 }
}

/
//CGraphBuilder
/
CGraphBuilder::~CGraphBuilder()
{
 if(IsRunning())
 {
  Stop();
 }

 ReleaseInterface();

 RemoveFilters();

 m_pGraph.Release();
}

/
//Attach
/
bool CGraphBuilder::Attach(IGraphBuilder * builder)
{
 return false;
}

/
//
/


/
//
/


/
//
/


/
//
/


/
//QueryInterface
/
HRESULT CGraphBuilder::QueryInterface(REFIID riid,void ** ppvObject)
{
 return m_pGraph->QueryInterface(riid,ppvObject);
}


///
//建立GraphBuilder并取得IMediaControl
///
BOOL CGraphBuilder::QueryInterface()
{
 HRESULT hr = -1;
 if(m_pGraph)
 {
  S_RELEASE(m_pMediaControl);
  hr = m_pGraph->QueryInterface(IID_IMediaControl,(void**)&m_pMediaControl);
  //hr |= m_pGraph->QueryInterface(IID_IMediaEvent,(void**)&m_pMediaEvent);
  //hr |= m_pGraph->QueryInterface(IID_IMediaEventEx,(void**)&m_pMediaEventEx);
  //hr |= m_pGraph->QueryInterface(IID_IMediaSeeking,(void**)&m_pMediaSeeking);
  //hr |= m_pGraph->QueryInterface(IID_IVideoWindow,(void**)&m_pVideoWindow);
 }
 return (SUCCEEDED(hr))?(TRUE):(FALSE);
}

///
//释放GraphBuilder
///
void CGraphBuilder::ReleaseInterface()
{
 SetDisplayWindow(NULL);
 SetNotifyWindow(NULL,0);

 S_RELEASE(m_pMediaControl);
 //S_RELEASE(m_pVideoWindow);
 //S_RELEASE(m_pMediaEvent);
 //S_RELEASE(m_pMediaEventEx);
 //S_RELEASE(m_pMediaSeeking);
}

///
//IGraphBuilder interface
///
HRESULT CGraphBuilder::Connect(IPin *ppinOut,IPin *ppinIn)
{
 return m_pGraph->Connect(ppinOut,ppinIn);
}

/
//
/
HRESULT CGraphBuilder::Render(IPin *ppinOut)
{
 return m_pGraph->Render(ppinOut);
}

/
//
/
HRESULT CGraphBuilder::RenderFile(LPCWSTR lpwstrFile,LPCWSTR lpwstrPlayList)
{
 return m_pGraph->RenderFile(lpwstrFile,lpwstrPlayList);
}

/
//
/
HRESULT CGraphBuilder::AddSourceFilter(LPCWSTR lpwstrFileName,
 LPCWSTR lpwstrFilterName,IBaseFilter **ppFilter)
{
 return m_pGraph->AddSourceFilter(lpwstrFileName,lpwstrFilterName,ppFilter);
}

/
//
/
HRESULT CGraphBuilder::SetLogFile(DWORD_PTR hFile)
{
 return m_pGraph->SetLogFile(hFile);
}

/
//
/
HRESULT CGraphBuilder::Abort()
{
 return m_pGraph->Abort();
}

/
//
/
HRESULT CGraphBuilder::ShouldOperationContinue()
{
 return m_pGraph->ShouldOperationContinue();
}

/
//
/
HRESULT CGraphBuilder::AddFilter(IBaseFilter *pFilter,LPCWSTR pName)
{
 return m_pGraph->AddFilter(pFilter,pName);
}

/
//
/
HRESULT CGraphBuilder::RemoveFilter(IBaseFilter *pFilter)
{
 return m_pGraph->RemoveFilter(pFilter);
}

/
//
/
HRESULT CGraphBuilder::EnumFilters(IEnumFilters **ppEnum)
{
 return m_pGraph->EnumFilters(ppEnum);
}

/
//
/
HRESULT CGraphBuilder::FindFilterByName(LPCWSTR pName,IBaseFilter **ppFilter)
{
 return m_pGraph->FindFilterByName(pName,ppFilter);
}

/
//
/
HRESULT CGraphBuilder::ConnectDirect(IPin *ppinOut,IPin *ppinIn,const AM_MEDIA_TYPE *pmt)
{
 return m_pGraph->ConnectDirect(ppinOut,ppinIn,pmt);
}

/
//
/
HRESULT CGraphBuilder::Reconnect(IPin *ppin)
{
 return m_pGraph->Reconnect(ppin);
}

/
//
/
HRESULT CGraphBuilder::Disconnect(IPin *ppin)
{
 return m_pGraph->Disconnect(ppin);
}

/
//
/
HRESULT CGraphBuilder::SetDefaultSyncSource()
{
 return m_pGraph->SetDefaultSyncSource();
}
///
//IGraphBuilder interface --- end!!
///

///
//
///
IMediaControl * CGraphBuilder::MediaControl()
{
 if(m_pMediaControl == NULL)
 {
  m_pGraph->QueryInterface(IID_IMediaControl,(void**)&m_pMediaControl);
 }
 return m_pMediaControl;
}

///
//
///
IMediaEventEx * CGraphBuilder::MediaEventEx()
{
 IMediaEventEx * pe = NULL;
 if(SUCCEEDED(QueryInterface(IID_IMediaEventEx,(void**)&pe)))
 {
  return pe;
 }
 return NULL;
}

///
//取得一个filter 的 pin(PINDIR_INPUT/PINDIR_OUTPUT)
///
HRESULT CGraphBuilder::GetPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir, IPin **ppPin)
{
 if(pFilter)
 {
  IEnumPins  *pEnum = NULL;
  IPin       *pPin = NULL;

  pFilter->EnumPins(&pEnum);

  while(pEnum->Next(1, &pPin, 0) == S_OK)
  {
   PIN_DIRECTION PinDirThis;
   pPin->QueryDirection(&PinDirThis);
   if (PinDir == PinDirThis)
   {
    S_RELEASE(pEnum);
    //pEnum->Release();
    *ppPin = pPin;
    return S_OK;
   }
   //pPin->Release();
   S_RELEASE(pPin);
  }
  //pEnum->Release();
  S_RELEASE(pEnum);
 }

    return E_FAIL; 
}

///
//断开一个filter上连接的所有filter
///
BOOL CGraphBuilder::DisConnectAllPin(IBaseFilter * pFilter)
{
 HRESULT  hr   = S_OK;

 if(pFilter)
 {
  IEnumPins * pEnum = NULL;
  IPin *  pin   = NULL;

  if(SUCCEEDED(pFilter->EnumPins(&pEnum)))
  {
   while(SUCCEEDED(pEnum->Next(1,&pin,0)))
   {
    hr |= m_pGraph->Disconnect(pin);
   };
   S_RELEASE(pEnum);
  }
 }

 return (SUCCEEDED(hr))?(TRUE):(FALSE);
}

///
//连接两个filter
///
HRESULT CGraphBuilder::ConnectFilters(IBaseFilter *pFirst, IBaseFilter *pSecond)
{
    IPin *pOut = NULL;
 IPin *pIn = NULL;

    HRESULT hr = -1;
 
 if(SUCCEEDED(GetPin(pFirst, PINDIR_OUTPUT, &pOut)) &&
  SUCCEEDED(GetPin(pSecond, PINDIR_INPUT, &pIn)))
 {
  hr = this->Connect(pOut,pIn);
 }

 S_RELEASE(pIn);
 S_RELEASE(pOut);

    return hr;
}

///
//给定一个Filter，断开这个Filter上面连着的所有Filter
///
void CGraphBuilder::DisConnectFilterNukeDown(IBaseFilter * inFilter,BOOL bRemove)
{
 if(inFilter)
 {
  IEnumPins * pinEnum = NULL;
  if(SUCCEEDED(inFilter->EnumPins(&pinEnum)))
  {
   pinEnum->Reset();

   IPin * pin = NULL;
   ULONG cFetched = 0;
   bool pass = true;
   
   while(pass && SUCCEEDED(pinEnum->Next(1, &pin, &cFetched)))
   {
    if(pin && cFetched)
    {
     IPin * connectedPin = NULL;
     
     pin->ConnectedTo(&connectedPin);
     
     if(connectedPin)
     {
      PIN_INFO pininfo;
      
      if(SUCCEEDED(connectedPin->QueryPinInfo(&pininfo)))
      {
       if(pininfo.dir == PINDIR_INPUT)
       {
        DisConnectFilterNukeDown(pininfo.pFilter);
        m_pGraph->Disconnect(connectedPin);
        m_pGraph->Disconnect(pin);
        
        if(bRemove)m_pGraph->RemoveFilter(pininfo.pFilter);
       }
       pininfo.pFilter->Release();
      }
      connectedPin->Release();
     }
     pin->Release();
    }
    else
    {
     pass = false;
    }
   }
   pinEnum->Release();
  }
 }
}

///
//给定一个Filter，断开这个Filter下面连着的所有Filter
///
void CGraphBuilder::DisConnectFilterNukeUp(IBaseFilter * inFilter,BOOL bRemove)
{
 if(inFilter)
 {
  IEnumPins * pinEnum = NULL;
  
  if(SUCCEEDED(inFilter->EnumPins(&pinEnum)))
  {
   pinEnum->Reset();
   
   IPin * pin = NULL;
   ULONG cFetched = 0;
   bool pass = true;
   
   while(pass && SUCCEEDED(pinEnum->Next(1, &pin, &cFetched)))
   {
    if(pin && cFetched)
    {
     IPin * connectedPin = NULL;

     pin->ConnectedTo(&connectedPin);
     
     if(connectedPin)
     {
      PIN_INFO pininfo;
      
      if(SUCCEEDED(connectedPin->QueryPinInfo(&pininfo)))
      {
       if(pininfo.dir == PINDIR_OUTPUT)
       {
        DisConnectFilterNukeUp(pininfo.pFilter);
        m_pGraph->Disconnect(connectedPin);
        m_pGraph->Disconnect(pin);
        if(bRemove)m_pGraph->RemoveFilter(pininfo.pFilter);
       }
       pininfo.pFilter->Release();
      }
      connectedPin->Release();
     }
     pin->Release();
    }
    else
    {
     pass = false;
    }
   };
   pinEnum->Release();
  }
 }
}

///
//清除图表上的所有Filters
///
void CGraphBuilder::RemoveFilters()
{
 IEnumFilters * pEnumFilters = NULL;
 HRESULT hr = m_pGraph->EnumFilters(&pEnumFilters);
 if(SUCCEEDED(hr) && (pEnumFilters))
 {
  //ULONG fet = 0;
  IBaseFilter * pf = NULL;
  while(SUCCEEDED(pEnumFilters->Next(1,&pf,0/*&fet*/)))
  {
   if(FAILED(m_pGraph->RemoveFilter(pf)))
   {
    break;
   }
   S_RELEASE(pf);
  };
  S_RELEASE(pEnumFilters);
 }
}

///
//事件处理
///
void CGraphBuilder::HandleEvent()
{
 LONG event  = 0 ;
 LONG param1 = 0 ;
 LONG param2 = 0 ;

 IMediaEventEx  *pEvent = MediaEventEx();
 if(pEvent)
 {
  while(SUCCEEDED(pEvent->GetEvent(&event, (LONG_PTR*)&param1, (LONG_PTR*)&param2, 0)))
  {
   pEvent->FreeEventParams(event, param1, param2);
   if( event == EC_ERRORABORT )
   {
    OnDeviceAbort();               
    break;
   }
   else if(event == EC_DEVICE_LOST)
   {
    //the device is remove
    if(param2 == 0)
    {
     IUnknown  *punk = (IUnknown*)(LONG_PTR)param1;
     if(OnDeviceLost(punk))
     {
      OnDeviceAbort();
      Stop();
      ReleaseInterface();
      RemoveFilters();
      m_pGraph.Release();
     }
    }
    //the device is add
    else if( param2 == 1 )
    {
     //
    }
   }
  }//while()
  S_RELEASE(pEvent);
 }//if(pEvent)
}

///
//
///
void CGraphBuilder::DeviceAbort()
{
 OnDeviceAbort();
}

///
//
///
bool CGraphBuilder::OnDeviceLost(IUnknown  *punk)
{
 HRESULT hr = S_OK;
 IBaseFilter * pf = NULL;

 if(punk)
 {
  hr = punk->QueryInterface(IID_IBaseFilter,(void**)&pf);
  if(SUCCEEDED(hr))
  {
   IBaseFilter * pb = NULL;
   hr = m_pGraph->QueryInterface(IID_IBaseFilter,(void**)&pb);
   if(SUCCEEDED(hr))
   {
    if(IsEqualObject(pb,pf))
    {
     pb->Release();
     pf->Release();
     return true;
    }
    pb->Release();
   }
   pf->Release();
  }
 }
 return false;
}

///
//
///
bool CGraphBuilder::OnDeviceAbort()
{
 return SetDisplayWindow(NULL);
}

///
//
///
bool CGraphBuilder::ResizeWindow(const RECT& rect)
{
 return ResizeWindow(rect.left,rect.top,
     rect.right - rect.left,rect.bottom - rect.top);
}

///
//
///
bool CGraphBuilder::ResizeWindow(long left,long top,long width,long height)
{
 HRESULT hr = -1;

 if(m_pGraph)
 {
  IVideoWindow * pvw = NULL;
  hr = m_pGraph->QueryInterface(IID_IVideoWindow,(void**)&pvw);
  if(SUCCEEDED(hr))
  {
   hr = pvw->SetWindowPosition(left,top,width,height);
   S_RELEASE(pvw);
  }
 }

 return (SUCCEEDED(hr))?(true):(false);
}

///
//
///
bool CGraphBuilder::SetDisplayWindow(HWND hWnd)
{
 HRESULT hr = -1;

 //if(m_pGraph)
 //{
 IVideoWindow * pvw = NULL;
 hr = m_pGraph->QueryInterface(IID_IVideoWindow,(void**)&pvw);
 
 if(SUCCEEDED(hr))
 {
  hr = pvw->put_Visible(OAFALSE);
  hr |= pvw->put_MessageDrain(OAHWND(0));
  hr |= pvw->put_Owner(OAHWND(0));

  if(hWnd && ::IsWindow(hWnd))
  {
   hr = pvw->put_Owner((OAHWND)hWnd);
   hr |= pvw->put_WindowStyle(WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
   hr |= pvw->put_MessageDrain((OAHWND)hWnd);
   hr |= pvw->put_AutoShow(OATRUE);

   hr |= pvw->put_Visible(OATRUE);
  }
  S_RELEASE(pvw);
 }
 //}//if(m_pGraph)

 return (SUCCEEDED(hr))?(true):(false);
}

///
//
///
bool CGraphBuilder::SetNotifyWindow(HWND hWnd, UINT message)
{
 HRESULT hr = -1;
 IMediaEventEx * pe = MediaEventEx();

 if(pe)
 {
  hr = pe->SetNotifyWindow((OAHWND)hWnd, message, 0);
 }
 return (SUCCEEDED(hr))?(true):(false);
}

///
//
///
bool CGraphBuilder::Play()
{
 return (m_pGraph)?((m_pMediaControl == NULL)?
    (SUCCEEDED(MediaControl()->Run())?(true):(false)):
     ((SUCCEEDED(m_pMediaControl->Run()))?(true):(false))):(false);
}

///
//
///
bool CGraphBuilder::Stop()
{
 return (m_pGraph)?((m_pMediaControl == NULL)?
    (SUCCEEDED(MediaControl()->Stop())?(true):(false)):
     ((SUCCEEDED(m_pMediaControl->Stop()))?(true):(false))):(false);
}

///
//
///
bool CGraphBuilder::StopWhenReady()
{
 return (m_pGraph)?((m_pMediaControl == NULL)?
    (SUCCEEDED(MediaControl()->StopWhenReady())?(true):(false)):
     ((SUCCEEDED(m_pMediaControl->StopWhenReady()))?(true):(false))):(false);
}

///
//
///
bool CGraphBuilder::Pause()
{
 return (m_pGraph)?((m_pMediaControl == NULL)?
    (SUCCEEDED(MediaControl()->Pause())?(true):(false)):
     ((SUCCEEDED(m_pMediaControl->Pause()))?(true):(false))):(false);
}

///
//
///
bool CGraphBuilder::IsRunning()
{
 HRESULT hr = S_OK;

 if(m_pMediaControl==NULL) m_pMediaControl = this->MediaControl();

 if(m_pMediaControl)
 {
  OAFilterState fs = 0;
  hr = m_pMediaControl->GetState(10,&fs);//INFINITE
  if(SUCCEEDED(hr))
  {
   if(fs == State_Running)return true;
  }
 }

 return false;
}

///
//
///
bool CGraphBuilder::IsStop()
{
 HRESULT hr = S_OK;

 if(m_pMediaControl==NULL) m_pMediaControl = this->MediaControl();

 if(m_pMediaControl)
 {
  OAFilterState fs = 0;
  hr = m_pMediaControl->GetState(10,&fs);//INFINITE
  if(SUCCEEDED(hr))
  {
   if(fs == State_Stopped)return true;
  }
 }

  return false;
}

///
//
///
bool CGraphBuilder::IsPause()
{
 HRESULT hr = S_OK;

 if(m_pMediaControl==NULL) m_pMediaControl = this->MediaControl();

 if(m_pMediaControl)
 {
  OAFilterState fs = 0;
  hr = m_pMediaControl->GetState(10,&fs);//INFINITE
  if(SUCCEEDED(hr))
  {
   if(fs == State_Paused)return true;
  }
 }

 return false;
}
///
//End--class CGraphBuilder
///


///
//class CCaptureGraphBuilder
///
CCaptureGraphBuilder::CCaptureGraphBuilder(CGraphBuilder& gf,CDeviceFilter& dev)
 :m_graphbuilder(gf),m_device(dev)
{
 m_streamconfig = NULL;

 if(FAILED(m_pGraphBuilder2.CoCreateInstance(CLSID_CaptureGraphBuilder2)))
 {
  throw "cann't create capture graph builder object!";
 }

 if(FAILED(m_pGraphBuilder2->SetFiltergraph(m_graphbuilder.GraphBuilder())))
 {
  m_pGraphBuilder2.Release();
  throw "cann't add object into graph builder.";
 }
}

///
//
///
CCaptureGraphBuilder::~CCaptureGraphBuilder()
{
 S_RELEASE(m_streamconfig);
 m_pGraphBuilder2.Release();
}

///
// interface
///
HRESULT CCaptureGraphBuilder::AllocCapFile(LPCOLESTR lpwstr, DWORDLONG dwlSize)
{
 return m_pGraphBuilder2->AllocCapFile(lpwstr, dwlSize);
}

///
//
///
HRESULT CCaptureGraphBuilder::ControlStream(const GUID *pCategory,
      const GUID *pType,
      IBaseFilter *pFilter,
                        REFERENCE_TIME *pstart,
                        REFERENCE_TIME *pstop,
                        WORD wStartCookie,
                        WORD wStopCookie)
{
 return m_pGraphBuilder2->ControlStream(pCategory, pType,
   pFilter, pstart, pstop, wStartCookie, wStopCookie);
}

///
//
///
HRESULT CCaptureGraphBuilder::CopyCaptureFile(LPOLESTR lpwstrOld,
      LPOLESTR lpwstrNew,
      int fAllowEscAbort,
                        IAMCopyCaptureFileProgress *pCallback)
{
 return m_pGraphBuilder2->CopyCaptureFile(lpwstrOld,
      lpwstrNew, fAllowEscAbort, pCallback);
}

///
//
///
HRESULT CCaptureGraphBuilder::FindInterface(const GUID *pCategory,
      const GUID *pType,
      IBaseFilter *pf,
      REFIID riid,
      void **ppint)
{
 return m_pGraphBuilder2->FindInterface(pCategory, pType, pf, riid, ppint);
}

///
//
///
HRESULT CCaptureGraphBuilder::FindPin(IUnknown *pSource,
      PIN_DIRECTION pindir,
      const GUID *pCategory,
                        const GUID *pType,
      BOOL fUnconnected,
      int num,
      IPin **ppPin)
{
 return m_pGraphBuilder2->FindPin(pSource,
    pindir, pCategory, pType, fUnconnected, num, ppPin);
}

///
//
///
HRESULT CCaptureGraphBuilder::GetFiltergraph(IGraphBuilder **ppfg)
{
 return m_pGraphBuilder2->GetFiltergraph(ppfg);
}

///
//
///
HRESULT CCaptureGraphBuilder::RenderStream(const GUID *pCategory,
      const GUID *pType,
      IUnknown *pSource,
      IBaseFilter *pIntermediate,
      IBaseFilter *pSink)
{
 return m_pGraphBuilder2->RenderStream(pCategory,
     pType, pSource, pIntermediate, pSink);
}

///
//
///
HRESULT CCaptureGraphBuilder::SetFiltergraph(IGraphBuilder *pfg)
{
 return m_pGraphBuilder2->SetFiltergraph(pfg);
}

///
//
///
HRESULT CCaptureGraphBuilder::SetOutputFileName(const GUID *pType,
      LPCOLESTR lpwstrFile,
      IBaseFilter **ppf,
      IFileSinkFilter **pSink)
{
 return m_pGraphBuilder2->SetOutputFileName(pType, lpwstrFile, ppf, pSink);
}

///
//
///
HRESULT CCaptureGraphBuilder::SetGraphBuilder()
{
 return m_pGraphBuilder2->SetFiltergraph(m_graphbuilder.GraphBuilder());
}

///
//IAMStreamConfig Interface
///
IAMStreamConfig * CCaptureGraphBuilder::AMStreamConfig()
{
 S_RELEASE(m_streamconfig);

 HRESULT hr = -1;

 if(m_device.DeviceFilter())
 {
  hr = m_pGraphBuilder2->FindInterface(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,
      m_device.DeviceFilter(),IID_IAMStreamConfig,(void**)&m_streamconfig);
  if(FAILED(hr))
  {
   hr = m_pGraphBuilder2->FindInterface(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Video,
      m_device.DeviceFilter(),IID_IAMStreamConfig,(void**)&m_streamconfig); 
  }
 }

 return (SUCCEEDED(hr))?(m_streamconfig):(NULL);
}

///
//
///
HRESULT CCaptureGraphBuilder::GetFormat(AM_MEDIA_TYPE **pmt)
{
 return (m_streamconfig == NULL)?
  ((AMStreamConfig())?(m_streamconfig->GetFormat(pmt)):(-1))
    :(m_streamconfig->GetFormat(pmt));
}

///
//
///
HRESULT CCaptureGraphBuilder::GetNumberOfCapabilities(int *piCount,int *piSize)
{
 return (m_streamconfig == NULL)?
  ((AMStreamConfig())?(m_streamconfig->GetNumberOfCapabilities(piCount,piSize)):(-1))
    :(m_streamconfig->GetNumberOfCapabilities(piCount,piSize));
}

///
//
///
HRESULT CCaptureGraphBuilder::GetStreamCaps(int iIndex,AM_MEDIA_TYPE **pmt,BYTE *pSCC)
{
 return (m_streamconfig == NULL)?
  ((AMStreamConfig())?(m_streamconfig->GetStreamCaps(iIndex,pmt,pSCC)):(-1))
    :(m_streamconfig->GetStreamCaps(iIndex,pmt,pSCC));
}

///
//
///
HRESULT CCaptureGraphBuilder::SetFormat(AM_MEDIA_TYPE *pmt)
{
 HRESULT hr = -1;

 if(m_streamconfig == NULL)
 {
  AMStreamConfig();
 }

 if(m_streamconfig)
 {
  hr = m_streamconfig->SetFormat(pmt);

 #if _DEBUG
  if( hr == E_OUTOFMEMORY )
  {
   ::OutputDebugString("AMStreamConfig ... E_OUTOFMEMORY!/n");
  }
  else if( hr == E_POINTER )
  {
   OutputDebugString("AMStreamConfig ... E_POINTER!/n");
  }
  else if( hr == VFW_E_INVALIDMEDIATYPE )
  {
   OutputDebugString("AMStreamConfig .....VFW_E_INVALIDMEDIATYPE!/n");
  }
  else if( hr == VFW_E_NOT_CONNECTED )
  {
   OutputDebugString("AMStreamConfig .....VFW_E_NOT_CONNECTED!/n");
  }
  else if( hr == VFW_E_NOT_STOPPED )
  {
   OutputDebugString("AMStreamConfig ....VFW_E_NOT_STOPPED!/n");
  }
  else if( hr == VFW_E_WRONG_STATE )
  {
   OutputDebugString("AMStreamConfig .....VFW_E_WRONG_STATE!/n");
  }

  if( SUCCEEDED(hr))
  {
   OutputDebugString("AMStreamConfig .....ok/n");
  }
  else
  {
   OutputDebugString("AMStreamConfig ....faild!/n");
  }
 #endif //_DEBUG

  S_RELEASE(this->m_streamconfig);
 }

 return hr;
}
///
//End----class CCaptureGraphBuilder
///


///
//class CDXBaseFilter
///
CDXBaseFilter::CDXBaseFilter(const GUID& guid):m_guid(guid)
{
 if(FAILED(m_pFilter.CoCreateInstance(m_guid)))
 {
  throw "cann't create dxobject.";
 }
}

///
//
///
CDXBaseFilter::~CDXBaseFilter()
{
 m_pFilter.Release();
}

///
//
///
IPin * CDXBaseFilter::GetPin(PIN_DIRECTION PinDir)
{
 //PIN_DIRECTION PinDir = inInput ? PINDIR_INPUT : PINDIR_OUTPUT;
    IEnumPins  *pEnum = NULL;
    IPin       *pPin = NULL;

    m_pFilter->EnumPins(&pEnum);

    while(pEnum->Next(1, &pPin, 0) == S_OK)
    {
        PIN_DIRECTION PinDirThis;
        pPin->QueryDirection(&PinDirThis);
        if(PinDir == PinDirThis)
        {
            pEnum->Release();
   return pPin;
        }
        pPin->Release();
    }
    return NULL;
}
///
//End--class CDXBaseFilter
///


///
//
///

 

///
///
//End File
///
 

yecao_kinux
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Graph 构建概述
冷月醉雪的博客
03-23 655
   要创建过滤器图形，首先创建一个过滤器图形管理器的实例： IGraphBuilder* pIGB; HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void **)&amp;pIGB);    Filter Graph Mana...
IGraphBuilder::Render() 引发的错误：0x80040154 (REGDB_E_CLASSNOTREG)
beckle_ye的专栏
04-22 1854
最近搞毕业设计，研究起了DirectShow，看了一个网络传输MPEG视频的源码，编译运行，发现客户端接收的视频没法显示出来，但是写入的文件是可以被正确播放的。最后调试跟踪到是这一句出了问题：HRESULT hr  = m_pGB->Render(m_pSourceReader->GetPin(0));返回错误： hr 0x80040154 没有注册类一开始在MSDN上搜索错误码 没有找到0x80040154的说明，于是在Google上搜索，只搜出了10几条相关内容，看了以后，说的好像是什么DLL没有注册，
IGraphBuilder
ww506772362的专栏
11-28 1931
// // CHDPlayerCore.h // // Written by Leezhm, 3rd Feb, 2010 // Contact : Leezhm@luxoom.cn // Last Modified by Leezhm, 3rd Feb, 2010 // #ifndef __CHDPlayerCore_h__ #define __CHDPlayerCore_
IGraphBuilder interface 2010-10-27 17:11
laohu6599的专栏
01-11 411
IGraphBuilder接口: 这个接口允许应用程序利用filter graph manager来构建一个完整的filter graph，或者是部分只提供了部分信息的filter graph，例如只是一个文件的名字，或是两个分开的pin的接口。Filter的映射程序用一种有效的方式，通过查找注册表来配置filter graph。 IGraphBuilder是从IFilterGraph
c#下使用Directshow进行图像采集
02-29
本篇文章将深入探讨如何在C#中使用DirectShow以及涉及到的COM（组件对象模型）知识。 首先，我们需要理解DirectShow的工作原理。DirectShow是一个基于过滤器图的框架，由一系列相互连接的过滤器组成，每个过滤器都...
directshow.rar_DirectShow_c++ DirectShow
07-14
在C++中使用DirectShow进行摄像头捕捉，首先需要了解DirectShow的架构。DirectShow由许多预先定义的过滤器组成，这些过滤器分为源过滤器、转换过滤器和渲染过滤器。源过滤器负责获取媒体数据，如摄像头；转换过滤器...
directshow摄像头视频捕捉
05-17
确保在项目设置中启用ActiveX支持，因为我们需要使用DirectShow的COM接口。 2. **引入DirectShow库** 需要在项目属性中链接DirectShow库，包括`strmiids.lib`和`quartz.lib`。同时，需要包含相应的头文件，如`...
c++ directshow 采集摄像头
04-17
描述中提到的"AMCap"是一个简单的DirectShow示例程序，它演示了如何使用DirectShow捕获和显示摄像头的视频流。AMCap的源代码可以帮助我们理解如何初始化和控制DirectShow滤波器图。它可能包含了设置摄像头参数（如...
DirectShow实务精选
11-29
在程序中，使用`IGraphBuilder`接口来连接和控制过滤器。 4. **数据流处理**：数据在过滤器之间通过样本（Sample）进行传递，每个样本包含一段连续的媒体数据。`IMediaSample`接口用于管理这些样本。 5. **事件...
用DirectShow抓取影片帧.zip
06-19
在本文中，我们将深入探讨如何使用DirectShow来抓取影片帧，这一过程对于视频处理、分析或者截图等应用至关重要。 一、DirectShow简介 DirectShow是Windows平台上的一个组件，它基于COM（Component Object Model）...
VC++通过DirectShow播放视频
12-06
本篇将详细讲解如何使用`VC++ 2015`通过`DirectShow`来播放如AVI、WMA、MP4等常见视频格式。 `DirectShow`是微软公司推出的一个多媒体框架，它构建于`DirectX`之上，主要用于处理视频和音频流。`DirectShow`提供了...
在vc6.0中配置directshow
09-02
在VC6.0这样的早期版本的Visual C++开发环境中配置DirectShow，主要是为了利用其强大的媒体处理能力，比如从摄像头捕获图像或视频流。 配置DirectShow的步骤如下： 1. **安装Windows Server 2003 Platform SDK**: ...
C# directShow 视频加水印
03-10
在C#中使用DirectShow可以实现丰富的视频处理功能，比如添加水印。本文将深入探讨如何利用C#和DirectShow来为视频添加水印，同时分析提供的"DxLogo"示例。 首先，我们要了解DirectShow的工作原理。DirectShow是一个...
DirectShow 接口.doc
09-06
DirectShow是Microsoft Windows操作系统中的一种组件，主要用于多媒体文件的捕获、编辑与播放。它由一系列的COM（Component Object Model）对象组成，这些对象被称为“筛选器”，每个筛选器负责处理数据流的一部分...
Filter Graph的创建，IFilterGraph2， IGraphBuilder， IcaptureGraphBuiler2的区别
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
01-06 1058
操作filter之前，肯定要创建filter graph。几乎所有的介绍directshow的书和例子都用了 IGraphBuilder， IcaptureGraphBuiler2 这两个接口，当然IFilterGraph也有，少用。                这三者有什么区别？             【1】IFilterGraph2，IcaptureGraphBuiler2这两个
【Directshow】Filter Graph的创建，IFilterGraph2， IGraphBuilder， IcaptureGraphBuiler2的区别
codemanrock
02-12 2598
操作filter之前，肯定要创建filter graph。几乎所有的介绍directshow的书和例子都用了 IGraphBuilder， IcaptureGraphBuiler2 这两个接口，当然IFilterGraph也有，少用。                这三者有什么区别？             【1】IFilterGraph2，IcaptureGraphBuiler2这两个
CComPtr
lnwaycool的专栏
10-24 600
CComPtr是一个类，构造函数会把内部指针初始化为NULL。
DirectShow中的视频捕捉之一
镜花水月
01-04 331
关于视频捕捉(About Video Capture in Dshow)1) 视频捕捉Graph的构建一个能够捕捉音频或者视频的graph图都称之为捕捉graph图。捕捉graph图比一般的文件回放graph图要复杂许多，dshow提供了一个Capture Graph Builder COM组件使得捕捉graph图的生成更加简单。Capture Graph Builder提供了一个ICapture...
DirectShow Filter开发基础详解
应用可以使用`IFilterGraph::ConnectDirect`或`IGraphBuilder::Connect`方法直接连接两个Filter，或者使用`IGraphBuilder::RenderFile`间接连接。Filter需先通过`IFilterGraph::AddFilter`加入到Filter Graph中。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值