IBaseFilter *DirectShowPlayerService::getConnected(
IBaseFilter *filter, PIN_DIRECTION direction) const
{
IBaseFilter *connected = 0;
IEnumPins *pins = 0;
if (SUCCEEDED(filter->EnumPins(&pins))) {
for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
PIN_DIRECTION dir;
if (SUCCEEDED(pin->QueryDirection(&dir)) && dir == direction) {
IPin *peer = 0;
if (SUCCEEDED(pin->ConnectedTo(&peer))) {
PIN_INFO info;
if (SUCCEEDED(peer->QueryPinInfo(&info))) {
if (connected) {
qWarning("DirectShowPlayerService::getConnected: "
"Multiple connected filters");
connected->Release();
}
connected = info.pFilter;
}
peer->Release();
}
}
}
pins->Release();
}
return connected;
}
HRESULT GetUnconnectedPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir, IPin **ppPin)
{
*ppPin = 0;
IEnumPins *pEnum = 0;
IPin *pPin = 0;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr))
{
return hr;
}
while (pEnum->Next(1, &pPin, NULL) == S_OK)
{
PIN_DIRECTION ThisPinDir;
pPin->QueryDirection(&ThisPinDir);
if (ThisPinDir == PinDir)
{
IPin *pTmp = 0;
hr = pPin->ConnectedTo(&pTmp);
if (SUCCEEDED(hr))
{
pTmp->Release();
}
else
{
pEnum->Release();
*ppPin = pPin;
return S_OK;
}
}
pPin->Release();
}
pEnum->Release();
return E_FAIL;
}
// Function name : CVMR9Graph::GetPin
// Description : return the desired pin
// Return type : IPin*
// Argument : IBaseFilter *pFilter
// Argument : PIN_DIRECTION PinDir
IPin* CVMR9Graph::GetPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir)
{
BOOL bFound = FALSE;
IEnumPins *pEnum;
IPin *pPin;
pFilter->EnumPins(&pEnum);
while(pEnum->Next(1, &pPin, 0) == S_OK) {
PIN_DIRECTION PinDirThis;
pPin->QueryDirection(&PinDirThis);
if (PinDir == PinDirThis)
{
IPin *pTmp = 0;
if (SUCCEEDED(pPin->ConnectedTo(&pTmp))) // Already connected, not the pin we want.
{
pTmp->Release();
}
else // Unconnected, this is the pin we want.
{
bFound = true;
break;
}
}
pPin->Release();
}
pEnum->Release();
return (bFound ? pPin : 0);
}
// helper functions
HRESULT GetUnconnectedPin(IBaseFilter *pFilter,PIN_DIRECTION PinDir, IPin **ppPin)
{
*ppPin = 0;
IEnumPins *pEnum = 0;
IPin *pPin = 0;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr))
{
return hr;
}
while (pEnum->Next(1, &pPin, NULL) == S_OK)
{
PIN_DIRECTION ThisPinDir;
pPin->QueryDirection(&ThisPinDir);
if (ThisPinDir == PinDir)
{
IPin *pTmp = 0;
hr = pPin->ConnectedTo(&pTmp);
if (SUCCEEDED(hr)) // Already connected, not the pin we want.
{
pTmp->Release();
}
else // Unconnected, this is the pin we want.
{
pEnum->Release();
*ppPin = pPin;
return S_OK;
}
}
pPin->Release();
}
pEnum->Release();
// Did not find a matching pin.
return E_FAIL;
}
static HRESULT ConnectFilters(IGraphBuilder *graph,
IBaseFilter *lhs,
IBaseFilter *rhs)
{
HRESULT hr = S_OK;
IPin *out = 0;
IPin *in = 0;
hr = GetPin(lhs, PINDIR_OUTPUT, &out);
if (FAILED(hr))
return hr;
hr = GetPin(rhs, PINDIR_INPUT, &in);
if (FAILED(hr))
{
out->Release();
return hr;
}
hr = graph->Connect(out, in);
in->Release();
out->Release();
return hr;
}
HRESULT CDShowUtility::GetNextFilter(IBaseFilter *pFilter, PIN_DIRECTION Dir, IBaseFilter **ppNext)
{
if (!pFilter || !ppNext)
{
return E_POINTER;
}
IEnumPins *pEnum = NULL;
IPin *pPin = 0;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr))
{
return hr;
}
while (S_OK == pEnum->Next(1, &pPin, 0))
{
// see if this pin matches the specified direction
PIN_DIRECTION ThisPinDir;
hr = pPin->QueryDirection(&ThisPinDir);
if (FAILED(hr))
{
// something strange happened
hr = E_UNEXPECTED;
pPin->Release();
break;
}
if (ThisPinDir == Dir)
{
// check if the pin is connected to another pin
IPin *pPinNext = NULL;
if (SUCCEEDED(hr))
{
// get the filter that owns that pin
PIN_INFO PinInfo;
hr = pPinNext->QueryPinInfo(&PinInfo);
pPinNext->Release();
pEnum->Release();
if (FAILED(hr) || PinInfo.pFilter == NULL)
{
// Something strange happened
return E_UNEXPECTED;
}
// This is the filter we're looking for
*ppNext = PinInfo.pFilter;
return S_OK;
}
}
pPin->Release();
}
pEnum->Release();
return hr;
}
HRESULT movieConnectFilters(IGraphBuilder *pGraph, IBaseFilter *pFirst, IBaseFilter *pSecond)
{
IPin *pOut = NULL;
IPin *pIn = NULL;
// Find the first output pin on the first filter
HRESULT RetVal = movieGetPin(pFirst, PINDIR_OUTPUT, &pOut);
if (RetVal != S_OK)
{
return RetVal;
}
if (NULL == pOut)
{
return E_FAIL;
}
// Find the first input pin on the second filter
RetVal = movieGetPin(pSecond, PINDIR_INPUT, &pIn);
if (RetVal != S_OK)
{
return RetVal;
}
if (NULL == pIn)
{
return E_FAIL;
}
if (RetVal != S_OK)
{
pOut->Release();
return E_FAIL;
}
// Attempt to connect the two pins.
RetVal = pGraph->Connect(pOut, pIn);
// A filter having audio and video will return a VFW_S_PARTIAL_RENDER when attempting
// to connect to a filter only having video (ie. the SampleGrabber filter)
if (VFW_S_PARTIAL_RENDER == RetVal)
{
return S_OK;
}
// Release the pins
pIn->Release();
pOut->Release();
return RetVal;
}
HRESULT CDShowUtility::GetFirstUnConnectedPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir, IPin **ppPin)
{
*ppPin = NULL;
IEnumPins *pEnum = NULL;
IPin *pPin = NULL;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr))
{
return hr;
}
pEnum->Reset();
while (pEnum->Next(1, &pPin, NULL) == S_OK)
{
PIN_DIRECTION ThisPinDir;
pPin->QueryDirection(&ThisPinDir);
if (PinDir == ThisPinDir)
{
IPin *pTmp = 0;
hr = pPin->ConnectedTo(&pTmp);
if (NULL != pTmp)
{
pTmp->Release();
}
if (SUCCEEDED(hr))
{
//已经连接了
pPin->Release();
continue;
}
else
{
pEnum->Release();
*ppPin = pPin;
return S_OK;
}
}
pPin->Release();
}
pEnum->Release();
return E_FAIL;
}
HRESULT CKTVDlg::EnumPinsOnFilter( IBaseFilter *pFilter, PIN_DIRECTION PinDir , int index)
{
HRESULT r;
IEnumPins *pEnum = NULL;
IPin *pPin = NULL;
// Verify filter interface
if (!pFilter)
return E_NOINTERFACE;
// Get pin enumerator
r = pFilter->EnumPins(&pEnum);
if (FAILED(r))
return r;
pEnum->Reset();
// Enumerate all pins on this filter
while((r = pEnum->Next(1, &pPin, 0)) == S_OK)
{
PIN_DIRECTION PinDirThis;
r = pPin->QueryDirection(&PinDirThis);
if (FAILED(r))
{
pPin->Release();
continue;
}
// Does the pin's direction match the requested direction?
if (PinDir == PinDirThis)
{
PIN_INFO pininfo={0};
// Direction matches, so add pin name to listbox
r = pPin->QueryPinInfo(&pininfo);
if (SUCCEEDED(r))
{
wstring str = pininfo.achName;
m_captureFilterVec[index].PinVec.push_back(str);
}
// The pininfo structure contains a reference to an IBaseFilter,
// so you must release its reference to prevent resource a leak.
pininfo.pFilter->Release();
}
pPin->Release();
}
pEnum->Release();
return r;
}
// Get the first upstream or downstream filter
HRESULT GetNextFilter(
IBaseFilter *pFilter, // Pointer to the starting filter
PIN_DIRECTION Dir, // Direction to search (upstream or downstream)
IBaseFilter **ppNext) // Receives a pointer to the next filter.
{
if (!pFilter || !ppNext) return E_POINTER;
IEnumPins *pEnum = 0;
IPin *pPin = 0;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr)) return hr;
while (S_OK == pEnum->Next(1, &pPin, 0))
{
// See if this pin matches the specified direction.
PIN_DIRECTION ThisPinDir;
hr = pPin->QueryDirection(&ThisPinDir);
if (FAILED(hr))
{
// Something strange happened.
hr = E_UNEXPECTED;
pPin->Release();
break;
}
if (ThisPinDir == Dir)
{
// Check if the pin is connected to another pin.
IPin *pPinNext = 0;
hr = pPin->ConnectedTo(&pPinNext);
if (SUCCEEDED(hr))
{
// Get the filter that owns that pin.
PIN_INFO PinInfo;
hr = pPinNext->QueryPinInfo(&PinInfo);
pPinNext->Release();
pPin->Release();
pEnum->Release();
if (FAILED(hr) || (PinInfo.pFilter == NULL))
{
// Something strange happened.
return E_UNEXPECTED;
}
// This is the filter we're looking for.
*ppNext = PinInfo.pFilter; // Client must release.
return S_OK;
}
}
pPin->Release();
}
pEnum->Release();
// Did not find a matching filter.
return E_FAIL;
}
// Find all the immediate upstream or downstream peers of a filter.
HRESULT GetPeerFilters(
IBaseFilter *pFilter, // Pointer to the starting filter
PIN_DIRECTION Dir, // Direction to search (upstream or downstream)
CFilterList &FilterList) // Collect the results in this list.
{
if (!pFilter) return E_POINTER;
IEnumPins *pEnum = 0;
IPin *pPin = 0;
HRESULT hr = pFilter->EnumPins(&pEnum);
if (FAILED(hr)) return hr;
while (S_OK == pEnum->Next(1, &pPin, 0))
{
// See if this pin matches the specified direction.
PIN_DIRECTION ThisPinDir;
hr = pPin->QueryDirection(&ThisPinDir);
if (FAILED(hr))
{
// Something strange happened.
hr = E_UNEXPECTED;
pPin->Release();
break;
}
if (ThisPinDir == Dir)
{
// Check if the pin is connected to another pin.
IPin *pPinNext = 0;
hr = pPin->ConnectedTo(&pPinNext);
if (SUCCEEDED(hr))
{
// Get the filter that owns that pin.
PIN_INFO PinInfo;
hr = pPinNext->QueryPinInfo(&PinInfo);
pPinNext->Release();
if (FAILED(hr) || (PinInfo.pFilter == NULL))
{
// Something strange happened.
pPin->Release();
pEnum->Release();
return E_UNEXPECTED;
}
// Insert the filter into the list.
AddFilterUnique(FilterList, PinInfo.pFilter);
PinInfo.pFilter->Release();
}
}
pPin->Release();
}
pEnum->Release();
return S_OK;
}
//得到Filter上未连接Pin
BOOL GetUnconnectedPin(IBaseFilter* pFilter, PIN_DIRECTION pinDir, IPin** ppPin)
{
if(!pFilter || ppPin)
return FALSE;
ASSERT(pinDir == PINDIR_INPUT || PINDIR_INPUT == PINDIR_OUTPUT);
*ppPin = NULL;
IEnumPins* pEnumPin = NULL;
IPin* pPin = NULL;
HRESULT hr = pFilter->EnumPins(&pEnumPin);
if(FAILED(hr))
return FALSE;
while(pEnumPin->Next(1,&pPin,NULL) == S_OK)
{
PIN_DIRECTION pinDirThis;
hr = pPin->QueryDirection(&pinDirThis);
if(FAILED(hr))
{
pPin->Release();
pEnumPin->Release();
return FALSE;
}
if(pinDir == pinDirThis)
{
IPin* pPinConnected = NULL;
hr = pPin->ConnectedTo(&pPinConnected);
if(SUCCEEDED(hr))
{
pPinConnected->Release();
}
else
{
pEnumPin->Release();
*ppPin = pPin;
return TRUE;
}
}
pPin->Release();
}
pEnumPin->Release();
return FALSE;
}
// Tear down everything downstream of a given filter
void __fastcall NukeDownstream(IBaseFilter * pf, IGraphBuilder * pGB)
{
IPin *pP = 0;
IPin *pTo = 0;
ULONG u;
IEnumPins *pins = NULL;
PIN_INFO pininfo;
if (!pf)
return;
// Enumerate all filter pins
HRESULT hr = pf->EnumPins(&pins);
// Go to beginning of enumeration
pins->Reset();
while(hr == NOERROR)
{
hr = pins->Next(1, &pP, &u);
if(hr == S_OK && pP)
{
pP->ConnectedTo(&pTo);
if(pTo)
{
hr = pTo->QueryPinInfo(&pininfo);
if(hr == NOERROR)
{
if(pininfo.dir == PINDIR_INPUT)
{
NukeDownstream(pininfo.pFilter, pGB);
pGB->Disconnect(pTo);
pGB->Disconnect(pP);
pGB->RemoveFilter(pininfo.pFilter);
}
pininfo.pFilter->Release();
pininfo.pFilter = NULL;
}
pTo->Release();
pTo = NULL;
}
pP->Release();
pP = NULL;
}
}
if(pins)
{
pins->Release();
pins = NULL;
}
}
BOOL GetConnectedFilter(IBaseFilter* pFilter, PIN_DIRECTION pinDir, IBaseFilter** ppFilterConnected)
{
if(!pFilter || !ppFilterConnected)
return FALSE;
IEnumPins* pEnumPin = NULL;
if(FAILED(pFilter->EnumPins(&pEnumPin)))
return FALSE;
HRESULT hr = E_FAIL;
IPin* pPin = NULL;
while(S_OK == pEnumPin->Next(1,&pPin,NULL))
{
PIN_DIRECTION pinDirThis;
hr = pPin->QueryDirection(&pinDirThis);
if(FAILED(hr))
{
pPin->Release();
pEnumPin->Release();
return FALSE;
}
if(pinDirThis == pinDir)
{
IPin* pPinConnected;
hr = pPin->ConnectedTo(&pPinConnected);
if(SUCCEEDED(hr))
{
PIN_INFO pinInfo;
hr = pPinConnected->QueryPinInfo(&pinInfo);
pPinConnected->Release();
pPin->Release();
pEnumPin->Release();
if(FAILED(hr) || pinInfo.pFilter == NULL)
{
return FALSE;
}
*ppFilterConnected = pinInfo.pFilter;
return TRUE;
}
}
pPin->Release();
}
pEnumPin->Release();
return FALSE;
}
HRESULT FindConnectedFilter(
IBaseFilter *pSrc, // Pointer to the starting filter
PIN_DIRECTION PinDir, // Directtion to look (input = upstream, output = downstream)
IBaseFilter **ppConnected) // Returns a pointer to the filter that is connected to pSrc
{
if (!pSrc || !ppConnected) return E_FAIL;
*ppConnected = NULL;
IEnumPins *pEnum = 0;
IPin *pPin = 0;
HRESULT hr = pSrc->EnumPins(&pEnum);
if (FAILED(hr))
{
return hr;
}
while (pEnum->Next(1, &pPin, NULL) == S_OK)
{
PIN_DIRECTION ThisPinDir;
pPin->QueryDirection(&ThisPinDir);
if (ThisPinDir == PinDir)
{
IPin *pTmp = 0;
hr = pPin->ConnectedTo(&pTmp);
if (SUCCEEDED(hr) && pTmp)
{
// Return the filter that owns this pin.
PIN_INFO PinInfo;
pTmp->QueryPinInfo(&PinInfo);
pTmp->Release();
pEnum->Release();
if (PinInfo.pFilter == NULL)
{
// Inconsistent pin state. Something is wrong...
return E_UNEXPECTED;
}
else
{
*ppConnected = PinInfo.pFilter;
return S_OK;
}
}
}
pPin->Release();
}
pEnum->Release();
return E_FAIL;
}
IPin* FindPinByDirection(IBaseFilter* pFilter, PIN_DIRECTION Criteria)
{
IPin* pPin = 0;
IEnumPins* pEnum = 0;
ULONG ul = 0;
PIN_DIRECTION TempDir;
pFilter->EnumPins(&pEnum);
if(!pEnum) return 0;
while(1)
{
pEnum->Next(1, &pPin, &ul);
if(ul != 1)
{
pPin = 0;
break;
}
// Examine this pin.
pPin->QueryDirection(&TempDir);
if(TempDir == Criteria)
{
break;
}
pPin->Release();
}
SAFE_RELEASE(pEnum);
return pPin;
}
bool isRenderer(IBaseFilter* filt)
{
if (!filt) return false;
IEnumPins* pinList;
int nrOutput = 0;
int nrInput = 0;
IPin* pin = NULL;
if (FAILED(filt->EnumPins(&pinList))) return false;
pinList->Reset();
while (pinList->Next(1, &pin, NULL) == S_OK)
{
if (getPinInfo(pin).dir == PINDIR_OUTPUT) nrOutput++;
else nrInput++;
pin->Release();
}
pinList->Release();
#ifdef _DEBUG
FILTER_INFO info;
filt->QueryFilterInfo(&info);
char str[100];
WideCharToMultiByte( CP_ACP, 0, info.achName, -1, str, 100, NULL, NULL );
_RPT0(_CRT_WARN,str);
_RPT2(_CRT_WARN," %d %d\n", nrOutput, nrInput);
#endif
return nrOutput == 0 && nrInput == 1; // the only filters that have no outputs are renderers
}
BOOL ConnectFilters(IGraphBuilder* pGraphBuilder, IPin* pPinOut, IBaseFilter* pFilterDst)
{
if(!pGraphBuilder || !pPinOut || !pFilterDst)
return FALSE;
HRESULT hr = E_FAIL;
#ifdef _DEBUG
PIN_DIRECTION pinDir;
hr = pPinOut->QueryDirection(&pinDir);
if(FAILED(hr))
return FALSE;
ASSERT(pinDir == PINDIR_OUTPUT);
#endif
IPin* pPinIn = NULL;
if(!GetUnconnectedPin(pFilterDst,PINDIR_INPUT,&pPinIn))
{
return FALSE;
}
hr = pGraphBuilder->Connect(pPinOut,pPinIn);
pPinIn->Release();
return SUCCEEDED(hr);
}
//查找Pin上某一个接口，只要找到Filter上某一个Pin又该接口即返回
BOOL FindPinInterface(IBaseFilter* pFilter, REFGUID iid, void** ppUnk)
{
if(!pFilter || !ppUnk)
return FALSE;
HRESULT hr = E_FAIL;
IEnumPins* pEnumPin = NULL;
if(FAILED(pFilter->EnumPins(&pEnumPin)))
{
return FALSE;
}
IPin* pPin = NULL;
while(pEnumPin->Next(1,&pPin,NULL) == S_OK)
{
hr = pPin->QueryInterface(iid,ppUnk);
pPin->Release();
if(SUCCEEDED(hr))
{
pEnumPin->Release();
return TRUE;
}
}
pEnumPin->Release();
return FALSE;
}
HRESULT FindPinInterface(
IBaseFilter *pFilter, // Pointer to the filter to search.
REFGUID iid, // IID of the interface.
void **ppUnk) // Receives the interface pointer.
{
if (!pFilter || !ppUnk) return E_POINTER;
HRESULT hr = E_FAIL;
IEnumPins *pEnum = 0;
if (FAILED(pFilter->EnumPins(&pEnum)))
{
return E_FAIL;
}
// Query every pin for the interface.
IPin *pPin = 0;
while (S_OK == pEnum->Next(1, &pPin, 0))
{
hr = pPin->QueryInterface(iid, ppUnk);
pPin->Release();
if (SUCCEEDED(hr))
{
break;
}
}
pEnum->Release();
return hr;
}
void FindPin(IBaseFilter* baseFilter, PIN_DIRECTION direction, int pinNumber, IPin** destPin)
{
IEnumPins *enumPins = 0;
*destPin = NULL;
if (SUCCEEDED(baseFilter->EnumPins(&enumPins))) {
ULONG numFound;
IPin* tmpPin;
while (SUCCEEDED(enumPins->Next(1, &tmpPin, &numFound))) {
PIN_DIRECTION pinDirection;
tmpPin->QueryDirection(&pinDirection);
if (pinDirection == direction) {
if (pinNumber == 0) {
// Return the pin's interface
*destPin = tmpPin;
break;
}
pinNumber--;
}
tmpPin->Release();
}
}
if (enumPins)
{
enumPins->Release();
}
}
//
// CFilePlayer::IsOvMConnected(): Private method to detect if the video stream
// is passing through the Overlay Mixer (i.e, is it connected?).
//
BOOL CFilePlayer::IsOvMConnected(IBaseFilter *pOvM)
{
DbgLog((LOG_TRACE, 5, TEXT("CFilePlayer::IsOvMConnected() entered"))) ;
IEnumPins *pEnumPins ;
IPin *pPin ;
IPin *pPin2 ;
ULONG ul ;
HRESULT hr ;
BOOL bConnected = FALSE ;
pOvM->EnumPins(&pEnumPins) ;
while (S_OK == pEnumPins->Next(1, &pPin, &ul) && 1 == ul)
{
hr = pPin->ConnectedTo(&pPin2) ;
if (SUCCEEDED(hr) && pPin2)
{
DbgLog((LOG_TRACE, 3, TEXT("Found pin %s connected to pin %s"),
(LPCTSTR)CDisp(pPin), (LPCTSTR)CDisp(pPin2))) ;
bConnected = TRUE ;
pPin2->Release() ;
}
pPin->Release() ;
}
pEnumPins->Release() ;
return bConnected ;
}
gboolean
gst_dshow_get_pin_from_filter (IBaseFilter * filter, PIN_DIRECTION pindir,
IPin ** pin)
{
gboolean ret = FALSE;
IEnumPins *enumpins = NULL;
IPin *pintmp = NULL;
HRESULT hres;
*pin = NULL;
hres = filter->EnumPins (&enumpins);
if (FAILED (hres)) {
return ret;
}
while (enumpins->Next (1, &pintmp, NULL) == S_OK) {
PIN_DIRECTION pindirtmp;
hres = pintmp->QueryDirection (&pindirtmp);
if (hres == S_OK && pindir == pindirtmp) {
*pin = pintmp;
ret = TRUE;
break;
}
pintmp->Release ();
}
enumpins->Release ();
return ret;
}
bool CaptureDShow::isPinConnected(IPin *pPin, bool *ok) const
{
IPin *pTmp = NULL;
HRESULT hr = pPin->ConnectedTo(&pTmp);
if (ok)
*ok = true;
if (hr == VFW_E_NOT_CONNECTED)
return false;
if (FAILED(hr)) {
if (ok)
*ok = false;
return false;
}
if (!pTmp)
return false;
pTmp->Release();
return true;
}
PinList CaptureDShow::enumPins(IBaseFilter *filter,
PIN_DIRECTION direction) const
{
if (!filter)
return PinList();
PinList pinList;
IEnumPins *enumPins = NULL;
if (SUCCEEDED(filter->EnumPins(&enumPins))) {
IPin *pin = NULL;
while (S_OK == enumPins->Next(1, &pin, NULL)) {
PIN_DIRECTION pinDir;
if (SUCCEEDED(pin->QueryDirection(&pinDir))
&& pinDir == direction) {
pinList << PinPtr(pin, this->deleteUnknown);
continue;
}
pin->Release();
pin = NULL;
}
}
enumPins->Release();
return pinList;
}
static HRESULT ConnectTwoFilters(IGraphBuilder *pGraph, IBaseFilter *pFirst, IBaseFilter *pSecond)
{
IPin *pOut = NULL, *pIn = NULL;
HRESULT hr = GetPin(pFirst, PINDIR_OUTPUT, &pOut);
if (FAILED(hr)) return hr;
hr = GetPin(pSecond, PINDIR_INPUT, &pIn);
if (FAILED(hr))
{
pOut->Release();
return E_FAIL;
}
hr = pGraph->Connect(pOut, pIn);
pIn->Release();
pOut->Release();
return hr;
}
IPin * GetOutPin( IBaseFilter * pFilter, int PinNum )
{
IEnumPins * pEnum = 0;
HRESULT hr = pFilter->EnumPins( &pEnum );
pEnum->Reset( );
ULONG Fetched;
do
{
Fetched = 0;
IPin * pPin = 0;
pEnum->Next( 1, &pPin, &Fetched );
if( Fetched )
{
PIN_DIRECTION pd;
pPin->QueryDirection( &pd);
pPin->Release( );
if( pd == PINDIR_OUTPUT )
{
if( PinNum == 0 )
{
pEnum->Release( );
return pPin;
}
PinNum--;
}
}
}
while( Fetched );
pEnum->Release( );
return NULL;
}
HRESULT win_webcam_utils::get_pin(IBaseFilter * filter, PIN_DIRECTION dirrequired, int num, IPin **pin)
{
CComPtr<IEnumPins> enum_pin;
*pin = nullptr;
HRESULT res = filter->EnumPins(&enum_pin);
if (S_OK != res)
{
return res;
}
ULONG found;
IPin *pPin;
res = E_FAIL;
while (S_OK == enum_pin->Next(1, &pPin, &found))
{
PIN_DIRECTION pindir = (PIN_DIRECTION)3;
pPin->QueryDirection(&pindir);
if (pindir == dirrequired)
{
if (num == 0)
{
*pin = pPin; // Return the pin's interface
res = S_OK; // Found requested pin, so clear error
break;
}
num--;
}
pPin->Release();
}
return res;
}
/* Display filter or pin */
CDisp::CDisp(IUnknown *pUnk)
{
IBaseFilter *pf;
HRESULT hr = pUnk->QueryInterface(IID_IBaseFilter, (void **)&pf);
if(SUCCEEDED(hr))
{
FILTER_INFO fi;
hr = pf->QueryFilterInfo(&fi);
if(SUCCEEDED(hr))
{
QueryFilterInfoReleaseGraph(fi);
m_pString = new TCHAR[lstrlenW(fi.achName) + 1];
if(m_pString)
{
wsprintf(m_pString, TEXT("%ls"), fi.achName);
}
}
pf->Release();
return;
}
IPin *pp;
hr = pUnk->QueryInterface(IID_IPin, (void **)&pp);
if(SUCCEEDED(hr))
{
CDisp::CDisp(pp);
pp->Release();
return;
}
}
HRESULT ConnectFilters(
IGraphBuilder *pGraph, // Filter Graph Manager.
IPin *pOut, // Output pin on the upstream filter.
IBaseFilter *pDest) // Downstream filter.
{
if ((pGraph == NULL) || (pOut == NULL) || (pDest == NULL))
{
return E_POINTER;
}
#ifdef _DEBUG
PIN_DIRECTION PinDir;
pOut->QueryDirection(&PinDir);
_ASSERTE(PinDir == PINDIR_OUTPUT);
#endif
// Find an input pin on the downstream filter.
IPin *pIn = 0;
HRESULT hr = GetUnconnectedPin(pDest, PINDIR_INPUT, &pIn);
if (FAILED(hr))
{
return hr;
}
// Try to connect them.
hr = pGraph->Connect(pOut, pIn);
pIn->Release();
return hr;
}
