C++ SmartPtr::QueryDirection方法代码示例

HRESULT CSampleCGB::FindMPEG2Pin( IBaseFilter *pFilter, IPin** ppPin )
{
	if(!pFilter)return E_INVALIDARG;

	SmartPtr<IEnumPins> pEnumPins;
	HRESULT hr = pFilter->EnumPins(&pEnumPins);
	if(FAILED(hr))return hr;
	SmartPtr<IPin> pTempPin;
	ULONG fetched;
	PIN_DIRECTION dir;

	hr = pEnumPins->Reset();

	while(pTempPin.Release(),S_OK == pEnumPins->Next(1,&pTempPin,&fetched))
	{
		hr = pTempPin->QueryDirection(&dir);
		if(FAILED(hr) || PINDIR_INPUT == dir)
		{
			continue;
		}
		if(IsMPEG2Pin(pTempPin))
		{
			(*ppPin) = pTempPin.Detach();
			return S_OK;
		}
	}
	return E_FAIL;
}

//
//  search the encoder that has this special medium
//  video == TRUE -- look for a video pin
//  video == FALSE -- look for a audio pin  
//
HRESULT ISampleCaptureGraphBuilder::FindPin( 
            IBaseFilter *pFilter, 
            const REGPINMEDIUM& regPinMedium, 
            PIN_DIRECTION direction, 
            BOOL video,             
            IPin **ppPin)
{
    if( !pFilter )
    {
        return E_POINTER;
    }

    SmartPtr<IEnumPins> pEnumPins;
    HRESULT hr = pFilter->EnumPins( &pEnumPins );
    if( FAILED( hr ) )
    {
        return hr;
    }
    
    SmartPtr<IPin>   pTempPin;
    ULONG           fetched;
    REGPINMEDIUM    regPinMediumTemp;
    PIN_DIRECTION   dir;

    hr = pEnumPins->Reset( );
    while( pTempPin.Release(), S_OK == pEnumPins->Next( 1, &pTempPin, &fetched ) )
    {
        ASSERT( pTempPin );

        hr = pTempPin->QueryDirection( &dir );
        if( FAILED( hr ) || dir != direction )
        {
            continue;
        }

        hr = GetMedium( pTempPin, regPinMediumTemp );
        if( FAILED( hr ) )
        {
            continue;
        }

        if( !IsVideoPin( pTempPin ) )
        {
            continue;
        }

        if( ::IsEqualGUID( regPinMediumTemp.clsMedium, regPinMedium.clsMedium  ) &&
            regPinMediumTemp.dw1 == regPinMedium.dw1 )
        {
            (*ppPin) = pTempPin.Detach();
            return S_OK;
        }
    }

    return E_FAIL;
}

HRESULT CSampleCGB::ConnectPin( IPin *pPin, IBaseFilter *pFilter )
{
	if(!pPin || !pFilter)return E_INVALIDARG;

	PIN_DIRECTION pinDirection;
	HRESULT hr = pPin->QueryDirection(&pinDirection);
	if(FAILED(hr) || PINDIR_INPUT == pinDirection)return E_FAIL;

	//Add the filter to the graph
	BOOL bConnected = FALSE;
	ULONG cFetched = 0;
	SmartPtr<IPin> pDownFilterPin;

	//
	//  Loop through every input pin from downstream filter
	//  and try to connect the pin
	//  

	SmartPtr<IEnumPins> pEnumDownFiltersPins;
	hr = pFilter->EnumPins(&pEnumDownFiltersPins);
	if(FAILED(hr))return hr;

	while(pDownFilterPin.Release(),pEnumDownFiltersPins->Next(1,&pDownFilterPin,&cFetched))
	{
		hr = pDownFilterPin->QueryDirection(&pinDirection);
		if(FAILED(hr))
		{
			continue;
		}

		if(pinDirection == PINDIR_OUTPUT)
		{
			continue;
		}

		hr = graph_->ConnectDirect(pPin,pDownFilterPin,NULL);
		if(SUCCEEDED(hr))
		{
			bConnected = TRUE;
			break;
		}
	}

	if(!bConnected)
	{
		graph_->RemoveFilter(pFilter);
		return E_FAIL;
	}
	return S_OK;
}

HRESULT 
ISampleCaptureGraphBuilder::ConnectFilters(IBaseFilter *pUpFilter, IBaseFilter *pDownFilter)
{
    if( !pUpFilter || !pDownFilter )
    {
        return E_INVALIDARG;
    }

    // All the need pin & pin enumerator pointers
    SmartPtr<IEnumPins>  pEnumUpFilterPins , 
                        pEnumDownFilterPins;

    SmartPtr<IPin>   pUpFilterPin , 
                    pDownFilterPin;

    HRESULT hr = S_OK;

    // Get the pin enumerators for both the filtera
    hr = pUpFilter->EnumPins(&pEnumUpFilterPins); 
    if( FAILED( hr ) )
    {
        return hr;
    }

    hr= pDownFilter->EnumPins(&pEnumDownFilterPins); 
    if( FAILED( hr ) )
    {
        return hr;
    }


    // Loop on every pin on the Upstream Filter
    BOOL bConnected = FALSE;
    PIN_DIRECTION pinDir;
    ULONG nFetched = 0;
    while(pUpFilterPin.Release( ), S_OK == pEnumUpFilterPins->Next(1, &pUpFilterPin, &nFetched) )
    {
        // Make sure that we have the output pin of the upstream filter
        hr = pUpFilterPin->QueryDirection( &pinDir );
        if( FAILED( hr ) || PINDIR_INPUT == pinDir )
        {
            continue;
        }

        //
        // I have an output pin; loop on every pin on the Downstream Filter
        //
        while(pDownFilterPin.Release( ), S_OK == pEnumDownFilterPins->Next(1, &pDownFilterPin, &nFetched) )
        {
            hr = pDownFilterPin->QueryDirection( &pinDir );
            if( FAILED( hr ) || PINDIR_OUTPUT == pinDir )
            {
                continue;
            }

            // Try to connect them and exit if u can else loop more until you can
            if(SUCCEEDED(graph_->ConnectDirect(pUpFilterPin, pDownFilterPin, NULL)))
            {
                bConnected = TRUE;
                break;
            }
        }

        hr = pEnumDownFilterPins->Reset();
        if( FAILED( hr ) )
        {
            return hr;
        }
    }

    if( !bConnected )
    {
        return E_FAIL;
    }

    return S_OK;
}