BOOL CSampleCGB::IsMPEG2Pin( IPin *pPin )
{
if(!pPin)return FALSE;
SmartPtr<IEnumMediaTypes> pMediaTypes;
HRESULT hr = pPin->EnumMediaTypes(&pMediaTypes);
if(FAILED(hr))return FALSE;
hr = pMediaTypes->Reset();
if(FAILED(hr))return FALSE;
ULONG fetched;
AM_MEDIA_TYPE* pTempMediaType;
while(S_OK == pMediaTypes->Next(1,&pTempMediaType,&fetched))
{
if(
(
::IsEqualGUID(pTempMediaType->majortype,MEDIATYPE_Video) ||
::IsEqualGUID(pTempMediaType->majortype,MEDIATYPE_Stream)
)
&&
(
::IsEqualGUID(pTempMediaType->subtype,MEDIASUBTYPE_MPEG2_VIDEO) ||
::IsEqualGUID(pTempMediaType->subtype,MEDIASUBTYPE_MPEG2_PROGRAM)
)
)
{
DeleteMediaType(pTempMediaType);
return TRUE;
}
DeleteMediaType(pTempMediaType);
}
return FALSE;
}
BOOL CSampleCGB::HasMediaType(IPin *pPin, REFGUID majorType )
{
if(!pPin)
{
return FALSE;
}
SmartPtr<IEnumMediaTypes> pMediaTypes;
HRESULT hr = pPin->EnumMediaTypes(&pMediaTypes);
if(FAILED(hr))return FALSE;
hr = pMediaTypes->Reset();
if(FAILED(hr))return FALSE;
ULONG cFetched;
AM_MEDIA_TYPE* pTempMediaType;
while(S_OK == pMediaTypes->Next(1,&pTempMediaType,&cFetched))
{
if(::IsEqualGUID(pTempMediaType->majortype,majorType))
{
DeleteMediaType(pTempMediaType);
return TRUE;
}
DeleteMediaType(pTempMediaType);
}
return FALSE;
}
HRESULT
ISampleCaptureGraphBuilder::FindAudioPin(
IBaseFilter *pFilter,
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;
hr = pEnumPins->Reset( );
while( pTempPin.Release(), S_OK == pEnumPins->Next( 1, &pTempPin, &fetched ) )
{
if( IsAudioPin( pTempPin ) )
{
(*ppPin) = pTempPin.Detach();
return S_OK;
}
}
return E_FAIL;
}
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;
}
//
// Loop through every media type supported by this pin
// to see if there is one which can be considered MPEG2
//
BOOL ISampleCaptureGraphBuilder::IsMPEG2Pin( IPin *pPin )
{
if( !pPin )
{
return FALSE; // NULL pointer
}
SmartPtr<IEnumMediaTypes> pMediaTypes;
HRESULT hr = pPin->EnumMediaTypes( &pMediaTypes );
if( FAILED( hr ) )
{
return FALSE;
}
hr = pMediaTypes->Reset();
if( FAILED( hr ) )
{
return FALSE;
}
ULONG fetched;
AM_MEDIA_TYPE *mediaType;
while( S_OK == pMediaTypes->Next( 1, &mediaType, &fetched ) )
{
if(
(
::IsEqualGUID( mediaType->majortype, MEDIATYPE_Video ) ||
::IsEqualGUID( mediaType->majortype, MEDIATYPE_Stream )
)
&&
(
::IsEqualGUID( mediaType->subtype, MEDIASUBTYPE_MPEG2_VIDEO ) ||
::IsEqualGUID( mediaType->subtype, MEDIASUBTYPE_MPEG2_PROGRAM )
)
)
{
DeleteMediaType( mediaType );
return TRUE;
}
DeleteMediaType( mediaType );
}
return FALSE;
}
HRESULT CSampleCGB::FindAudioPin( IBaseFilter *pFilter, IPin **ppPin )
{
if(!pFilter)return E_POINTER;
SmartPtr<IEnumPins> pEnumPins;
HRESULT hr = pFilter->EnumPins(&pEnumPins);
if(FAILED(hr))return hr;
SmartPtr<IPin> pTempPin;
ULONG cFetched;
hr = pEnumPins->Reset();
if(FAILED(hr))return hr;
while(pTempPin.Release(),pEnumPins->Next(1,&pTempPin,&cFetched))
{
if(IsAudioPin(pTempPin))
{
*ppPin = pTempPin.Detach();
return S_OK;
}
}
return E_FAIL;
}
BOOL ISampleCaptureGraphBuilder::HasMediaType(IPin *pPin, REFGUID majorType )
{
if( !pPin )
{
return FALSE;
}
SmartPtr<IEnumMediaTypes> pMediaTypes;
HRESULT hr = pPin->EnumMediaTypes( &pMediaTypes );
if( FAILED( hr ) )
{
return FALSE;
}
hr = pMediaTypes->Reset();
if( FAILED( hr ) )
{
return FALSE;
}
ULONG fetched;
AM_MEDIA_TYPE *mediaType;
while( S_OK == pMediaTypes->Next( 1, &mediaType, &fetched ) )
{
if( ::IsEqualGUID( mediaType->majortype, majorType ) )
{
DeleteMediaType( mediaType );
return TRUE;
}
DeleteMediaType( mediaType );
}
return FALSE;
}
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;
}
HRESULT
ISampleCaptureGraphBuilder::ConnectAudioPinToMultiplexer(
IPin *pPin,
IBaseFilter *pMultiplexer)
{
if( !pPin || !pMultiplexer )
{
return E_INVALIDARG;
}
REGPINMEDIUM pinMedium;
HRESULT hr = GetMedium( pPin, pinMedium );
if( FAILED( hr ) )
{
return hr;
}
SmartPtr<IBaseFilter> pEncoder;
SmartPtr<IEnumMoniker> pEncoders;
if( FALSE == ::IsEqualGUID( pinMedium.clsMedium, GUID_NULL ) )
{
//
// search through encoders category; identify
// the encoder using the medium
//
hr = GetEncodersByCategory( &pEncoders );
if( FAILED( hr ) )
{
return hr;
}
hr = FindEncoder( pEncoders, pinMedium, &pEncoder );
if( SUCCEEDED( hr ) )
{
hr = graph_->AddFilter( pEncoder, L"Audio Encoder" );
if( SUCCEEDED( hr ) &&
SUCCEEDED( ConnectPin( pPin, pEncoder ) ) &&
SUCCEEDED( ConnectFilters( pEncoder, pMultiplexer ) )
)
{
return S_OK;
}
}
pEncoders = NULL;
hr = GetEncodersByEnumerating( pPin, pinMedium, &pEncoders );
if( FAILED( hr ) )
{
return hr;
}
hr = FindEncoder( pEncoders, pinMedium, &pEncoder );
if( SUCCEEDED( hr ) )
{
hr = graph_->AddFilter( pEncoder, L"Audio Encoder" );
if( SUCCEEDED( hr ) &&
SUCCEEDED( ConnectPin( pPin, pEncoder ) ) &&
SUCCEEDED( ConnectFilters( pEncoder, pMultiplexer ) )
)
{
return S_OK;
}
}
return E_FAIL;
}
//
// Search throgh the codec category
//
hr = GetEncodersByCategory( &pEncoders );
if( FAILED( hr ) )
{
return hr;
}
SmartPtr<IBaseFilter> pFilter;
SmartPtr<IMoniker> pMoniker;
ULONG fetched;
while( pFilter.Release(), pMoniker.Release(), S_OK == pEncoders->Next( 1, &pMoniker, &fetched ) )
{
hr = pMoniker->BindToObject(
0, 0, IID_IBaseFilter, reinterpret_cast<void **>( &pFilter ) );
if( FAILED( hr ) )
{
continue;
}
hr = graph_->AddFilter( pFilter, L"Audio Encoder" );
if( FAILED( hr ) )
{
continue;
}
hr = ConnectPin( pPin, pFilter );
if( FAILED( hr ) )
{
graph_->RemoveFilter( pFilter );
continue;
}
hr = ConnectFilters( pFilter, pMultiplexer );
if( SUCCEEDED( hr ) )
{
return S_OK;
}
graph_->RemoveFilter( pFilter );
}
return E_FAIL;
}