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; }
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(); } }
// 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); }
PinPtr CaptureDShow::findUnconnectedPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir) const { IEnumPins *pEnum = NULL; if (FAILED(pFilter->EnumPins(&pEnum))) return PinPtr(); PinPtr matchedPin; IPin *pPin = NULL; while (pEnum->Next(1, &pPin, NULL) == S_OK) { PIN_DIRECTION pinDir; if (FAILED(pPin->QueryDirection(&pinDir)) || pinDir != PinDir) continue; bool ok; bool connected = this->isPinConnected(pPin, &ok); if (!ok || connected) continue; matchedPin = PinPtr(pPin, this->deletePin); pPin->AddRef(); break; } pEnum->Release(); return matchedPin; }
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; }
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; }
HRESULT CDirSoundSource::GetPin( IBaseFilter * pFilter, PIN_DIRECTION dirrequired, int iNum, CComPtr<IPin> &pin) { CComPtr< IEnumPins > pEnum; pin = NULL; HRESULT hr = pFilter->EnumPins(&pEnum); if(FAILED(hr)) return hr; ULONG ulFound; IPin *pPin; hr = E_FAIL; while(S_OK == pEnum->Next(1, &pPin, &ulFound)) { PIN_DIRECTION pindir = (PIN_DIRECTION)3; pPin->QueryDirection(&pindir); if(pindir == dirrequired) { if(iNum == 0) { pin = pPin; // Found requested pin, so clear error hr = S_OK; break; } iNum--; } pPin->Release(); } return hr; }
// 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; }
IPin* EMTestVideoOut::GetPin(IBaseFilter *pFilter, PIN_DIRECTION PinDir) { BOOL bFound = FALSE; IEnumPins *pEnum; IPin *pPin; bool FoundIt = false; pFilter->EnumPins(&pEnum); while(pEnum->Next(1, &pPin, 0) == S_OK) { PIN_DIRECTION PinDirThis; pPin->QueryDirection(&PinDirThis); if (bFound = (PinDir == PinDirThis)) { // MessageBox(NULL, "Found Matching PIN_DIRECTION", "Looking for a PIN", MB_OK); FoundIt = true; break; } pPin->Release(); // MessageBox(NULL, "Found A Non Matching PIN_DIRECTION", "Looking for a PIN", MB_OK); } // if(!FoundIt) // MessageBox(NULL, "DIDN'T FIND A MATCHING PIN", "WARNING WARNING!!!", MB_OK); pEnum->Release(); return (bFound ? pPin : 0); }
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; }
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 GetPinCountForOneType(IUnknown* pUnk, PIN_DIRECTION direction, LPDWORD pPinCount) { (*pPinCount) = 0; IBaseFilter* pBaseFilter = NULL; HRESULT hr = pUnk->QueryInterface(IID_IBaseFilter, (VOID**)&pBaseFilter); if (SUCCEEDED(hr)) { IEnumPins* pEnumPins = NULL; hr = pBaseFilter->EnumPins(&pEnumPins); if (SUCCEEDED(hr)) { pEnumPins->Reset(); if (SUCCEEDED(hr)) { IPin* pPin = NULL; BOOL bFound = FALSE; DWORD dwFetched = 0; while (((pEnumPins->Next(1, &pPin, &dwFetched)) == S_OK) && !bFound) { PIN_DIRECTION fetchedDir; hr = pPin->QueryDirection(&fetchedDir); if (SUCCEEDED(hr) && (fetchedDir == direction)) { (*pPinCount)++; } pPin->Release(); } } pEnumPins->Release(); } pBaseFilter->Release(); } return hr; }
HRESULT GetAMConfigForSinglePin(IUnknown* pUnk, PIN_DIRECTION direction, IAMStreamConfig** ppConfig) { IBaseFilter* pBaseFilter = NULL; HRESULT hr = pUnk->QueryInterface(IID_IBaseFilter, (void**)&pBaseFilter); if (SUCCEEDED(hr)) { IEnumPins* pEnumPins = NULL; hr = pBaseFilter->EnumPins(&pEnumPins); if (SUCCEEDED(hr)) { pEnumPins->Reset(); if (SUCCEEDED(hr)) { IPin* pPin = NULL; BOOL bFound = FALSE; while (((pEnumPins->Next(1, &pPin, NULL)) == S_OK) && !bFound) { PIN_DIRECTION fetchedDir; hr = pPin->QueryDirection(&fetchedDir); if (SUCCEEDED(hr) && (fetchedDir == direction)) { hr = pPin->QueryInterface(IID_IAMStreamConfig, (void**)ppConfig); bFound = SUCCEEDED(hr); } pPin->Release(); } } pEnumPins->Release(); } pBaseFilter->Release(); } return hr; }
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; }
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; }
//----------------------------------------------------------------------------- // GetPin // Find the pin of the specified format type on the given filter // This method leaves an outstanding reference on the pin if successful HRESULT CDSUtils::GetPin(IBaseFilter* pFilter, const GUID* pFormat, PIN_DIRECTION PinDir, IPin** ppPin) { HRESULT hr = S_OK; if (pFilter && pFormat && ppPin) { CComPtr<IEnumPins> pIEnumPins = NULL; hr = pFilter->EnumPins(&pIEnumPins); if (SUCCEEDED(hr)) { // find the pin with the specified format IPin* pIPin = NULL; while (S_OK == pIEnumPins->Next(1, &pIPin, NULL)) { // match the pin direction PIN_DIRECTION pinDir; pIPin->QueryDirection(&pinDir); if (pinDir == PinDir) { // match pin direction check the first media type returned from the upstream pin CComPtr<IEnumMediaTypes> pIEnumMT = NULL; hr = pIPin->EnumMediaTypes(&pIEnumMT); if (SUCCEEDED(hr)) { AM_MEDIA_TYPE* pmt = NULL; hr = pIEnumMT->Next(1, &pmt, NULL); if (S_OK == hr) { if (pmt->majortype == *pFormat) { // found the pin with the specified format *ppPin = pIPin; DeleteMediaType(pmt); break; } else { DeleteMediaType(pmt); } } } } SAFE_RELEASE(pIPin); } if (NULL == *ppPin) { // failed to find the named pin hr = E_FAIL; } } } else { hr = E_INVALIDARG; } 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 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; }
//------------------------------------------------------------------------------------------------- // GetUnconnectedPin // Attemptes to locate an unconnected pin on filter HRESULT CDSUtils::GetUnconnectedPin(IBaseFilter* pFilter, PIN_DIRECTION PinDir, IPin** ppPin) { HRESULT hr = S_OK; if (pFilter && ppPin) { CComPtr<IEnumPins> pEnum = NULL; IPin* pPin = NULL; hr = pFilter->EnumPins(&pEnum); if (SUCCEEDED(hr)) { while (pEnum->Next(1, &pPin, NULL) == S_OK) { PIN_DIRECTION ThisPinDir; pPin->QueryDirection(&ThisPinDir); if (ThisPinDir == PinDir) { IPin* pPinTemp = NULL; hr = pPin->ConnectedTo(&pPinTemp); if (SUCCEEDED(hr)) { SAFE_RELEASE(pPinTemp); } else { // unconnected, return this pin *ppPin = pPin; hr = S_OK; break; } } SAFE_RELEASE(pPin); } } if (NULL == *ppPin) { // failed to find an unconnected pin hr = E_FAIL; } } else { hr = E_INVALIDARG; } return hr; }
//得到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; }
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; }
HRESULT CDShowControl::CreateMoviePlayGraph(HWND hWnd, CString fileName) { HRESULT hr; CComPtr<IEnumPins> pEnumPins, pEnumPins2; IPin *pPin = NULL; PIN_DIRECTION direction; BOOL isSuccess = FALSE; CComPtr<IBaseFilter> pWMVReader; ReleaseMoviePlayGraph(); RETURNIF(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)); RETURNIF(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void**)&m_moviePlayGraph)); CoUninitialize(); RETURNIF(CreateFilter(L"WM ASF Reader",&pWMVReader,FILTERCG_DSHOW)); CComQIPtr<IFileSourceFilter> pFileSrcFilter(pWMVReader); pFileSrcFilter->Load(fileName.AllocSysString(),NULL); RETURNIF(m_moviePlayGraph->AddFilter(pWMVReader,L"WMVReader")); RETURNIF(pWMVReader->EnumPins(&pEnumPins)); while (pEnumPins->Next(1, &pPin, 0) == S_OK) { RETURNIF(pPin->QueryDirection(&direction)); if (direction == PINDIR_OUTPUT) { m_moviePlayGraph->Render(pPin); } SAFE_RELEASE(pPin); } CComQIPtr<IVideoWindow>pVW(m_moviePlayGraph); if (pVW != NULL) { CComQIPtr<IBasicVideo> pBV(m_moviePlayGraph); CRect rect,videoRect; RETURNIF(pVW->put_Owner((OAHWND)hWnd)); RETURNIF(pVW->put_WindowStyle(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS)); RETURNIF(pVW->put_MessageDrain((long)hWnd)); CRect ClientRect; ::GetClientRect(hWnd, &ClientRect); pVW->SetWindowPosition(0, 0, ClientRect.Width(), ClientRect.Height()); pVW->put_AutoShow(OATRUE); pVW->put_Visible(OATRUE); } return S_OK; }
HRESULT GetNextFilter(IBaseFilter* filter, PIN_DIRECTION dir, IBaseFilter*& nextFilter) { IEnumPins *enumPins; IPin* pin; HRESULT hr; hr = filter->EnumPins(&enumPins); if(FAILED(hr)) { ErrorPrint("Get enum pins error", hr); return hr; } ComReleaser enumPinsReleaser(enumPins); while (enumPins->Next(1, &pin, NULL) == S_OK) { ComReleaser pinReleaser(pin); PIN_DIRECTION thisDir; hr = pin->QueryDirection(&thisDir); if(FAILED(hr)) { ErrorPrint("Query direction error", hr); return hr; } if(thisDir == dir) { IPin *nextPin; hr = pin->ConnectedTo(&nextPin); if(SUCCEEDED(hr)) { ComReleaser nextPinReleaser(nextPin); PIN_INFO nextPinInfo; hr = nextPin->QueryPinInfo(&nextPinInfo); if(SUCCEEDED(hr)) { nextFilter = nextPinInfo.pFilter; return S_OK; } else { return E_UNEXPECTED; } } } } return E_FAIL; }
//查找引脚 IPin* CCaptureVideo::FindPin(IBaseFilter *pFilter, PIN_DIRECTION dir) { IEnumPins* pEnumPins; IPin* pOutpin; PIN_DIRECTION pDir; pFilter->EnumPins(&pEnumPins); while (pEnumPins->Next(1,&pOutpin,NULL)==S_OK) { pOutpin->QueryDirection(&pDir); if (pDir==dir) { return pOutpin; } } return 0; }
IPin* getPin(IBaseFilter* filter, PIN_DIRECTION direct) { IEnumPins* enumPins; filter->EnumPins(&enumPins); IPin* pin = NULL; PIN_DIRECTION pd; while(SUCCEEDED(enumPins->Next(1, &pin, 0))) { if (SUCCEEDED(pin->QueryDirection(&pd)) && pd == direct) { break; } pin->Release(); } enumPins->Release(); return pin; }
HRESULT GetAMConfigForMultiPin(IUnknown* pUnk, PIN_DIRECTION direct, IAMStreamConfig** ppConfig) { IBaseFilter* pBaseFilter = NULL; HRESULT hr = pUnk->QueryInterface(IID_IBaseFilter, (void**)&pBaseFilter); if (SUCCEEDED(hr)) { IEnumPins* pEnumPins = NULL; hr = pBaseFilter->EnumPins(&pEnumPins); if (SUCCEEDED(hr)) { pEnumPins->Reset(); if (SUCCEEDED(hr)) { IPin* pPin = NULL; BOOL bFound = FALSE; while ((pEnumPins->Next(1, &pPin, NULL) == S_OK) && !bFound) { PIN_DIRECTION fetchedDir; hr = pPin->QueryDirection(&fetchedDir); if (SUCCEEDED(hr) && (fetchedDir == direct)) { IKsPropertySet* pPS; hr = pPin->QueryInterface(IID_IKsPropertySet, (void**)&pPS); if (SUCCEEDED(hr)) { GUID guid = { 0 }; DWORD dwReturn = 0; hr = pPS->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, 0, 0, &guid, sizeof(guid), &dwReturn); if (SUCCEEDED(hr) && ::IsEqualGUID(guid, PIN_CATEGORY_CAPTURE)) { hr = pPin->QueryInterface(IID_IAMStreamConfig, (void**)ppConfig); bFound = SUCCEEDED(hr); } pPS->Release(); } } pPin->Release(); } } pEnumPins->Release(); } pBaseFilter->Release(); } return hr; }