TRACE_LEAVE();
return pPin;}}
return NULL;}
В файле audfilter.h
Что заменить:
CKsAudRenPin* CreateRenderPin(const WAVEFORMATEX* pwfx, BOOL fLooped);
Заменить на:
CKsAudRenPin * CreateRenderPin(BOOL fLooped);
CKsAudRenPin* FindViablePin(const WAVEFORMATEX* pwfx);
CKsAudRenPin * FindViablePin();
В файле audpin.cpp
BOOL CKsAudPin::IsFormatSupported(const WAVEFORMATEX* pwfx)
{TRACE_ENTER();
LISTPOS listPosRange = m_listDataRange.GetHeadPosition();
KSDATARANGE_AUDIO* pKSDATARANGE_AUDIO;
while( m_listDataRange.GetNext( listPosRange, &pKSDATARANGE_AUDIO ) )
{if( KSDATAFORMAT_TYPE_WILDCARD == pKSDATARANGE_AUDIO->DataRange.MajorFormat
|| KSDATAFORMAT_TYPE_AUDIO == pKSDATARANGE_AUDIO->DataRange.MajorFormat )
{// Set the format to search for
GUID guidFormat = {DEFINE_WAVEFORMATEX_GUID(pwfx->wFormatTag)};
// If this is a WaveFormatExtensible structure, then use its defined SubFormat
if( WAVE_FORMAT_EXTENSIBLE == pwfx->wFormatTag )
{guidFormat = ((WAVEFORMATEXTENSIBLE *)pwfx)->SubFormat;}
if( KSDATAFORMAT_SUBTYPE_WILDCARD == pKSDATARANGE_AUDIO->DataRange.SubFormat
|| guidFormat == pKSDATARANGE_AUDIO->DataRange.SubFormat )
{if( KSDATAFORMAT_SPECIFIER_WILDCARD == pKSDATARANGE_AUDIO->DataRange.Specifier
|| KSDATAFORMAT_SPECIFIER_WAVEFORMATEX == pKSDATARANGE_AUDIO->DataRange.Specifier )
{if( pKSDATARANGE_AUDIO->MaximumChannels >= pwfx->nChannels
&& pKSDATARANGE_AUDIO->MinimumBitsPerSample <= pwfx->wBitsPerSample
&& pKSDATARANGE_AUDIO->MaximumBitsPerSample >= pwfx->wBitsPerSample
&& pKSDATARANGE_AUDIO->MinimumSampleFrequency <= pwfx->nSamplesPerSec
&& pKSDATARANGE_AUDIO->MaximumSampleFrequency >= pwfx->nSamplesPerSec )
{// This should be a valid pin
return TRUE;}}}}}
return FALSE;}
BOOL CKsAudPin::IsFormatSupported()
KSDATARANGE_MUSIC * pKSDATARANGE_MUSIC;
while(m_listDataRange.GetNext(listPosRange, &pKSDATARANGE_MUSIC))
{if(KSDATAFORMAT_TYPE_WILDCARD == pKSDATARANGE_MUSIC->DataRange.MajorFormat
||KSDATAFORMAT_TYPE_MUSIC == pKSDATARANGE_MUSIC->DataRange.MajorFormat)
{if(KSDATAFORMAT_SUBTYPE_WILDCARD == pKSDATARANGE_MUSIC->DataRange.SubFormat
||KSDATAFORMAT_SUBTYPE_MIDI == pKSDATARANGE_MUSIC->DataRange.SubFormat)
{if(KSDATAFORMAT_SPECIFIER_WILDCARD == pKSDATARANGE_MUSIC->DataRange.Specifier
||KSDATAFORMAT_SPECIFIER_NONE == pKSDATARANGE_MUSIC->DataRange.Specifier)
{if(KSMUSIC_TECHNOLOGY_SWSYNTH == pKSDATARANGE_MUSIC->Technology)
HRESULT CKsAudPin::Init()
HRESULT hr = S_OK;
BOOL fViablePin = FALSE;
// Make sure at least one interface is standard streaming
if (SUCCEEDED(hr))
{fViablePin = FALSE;
for(ULONG i = 0; i < m_Descriptor.cInterfaces && !fViablePin; i++)
if (!fViablePin)
{DebugPrintf(TRACE_ERROR, TEXT("No standard streaming interfaces on the pin"));
hr = E_FAIL;}}
// Make sure at least one medium is standard streaming
{DebugPrintf(TRACE_ERROR, TEXT("No standard streaming mediums on the pin"));
// Make sure at least one datarange supports audio
PKSDATARANGE pDataRange = m_Descriptor.pDataRanges;
for(ULONG i = 0; i < m_Descriptor.cDataRanges; i++)
{// SubType should either be compatible with WAVEFORMATEX or
// it should be WILDCARD
fViablePin =
fViablePin ||
IS_VALID_WAVEFORMATEX_GUID(&pDataRange->SubFormat) ||
IsEqualGUIDAligned(pDataRange->SubFormat, KSDATAFORMAT_SUBTYPE_PCM) ||
IsEqualGUIDAligned(pDataRange->SubFormat, KSDATAFORMAT_SUBTYPE_WILDCARD);
if (fViablePin && IsEqualGUIDAligned(pDataRange->MajorFormat, KSDATAFORMAT_TYPE_AUDIO))
{// Copy the data range into the pin
PKSDATARANGE_AUDIO pCopyDataRangeAudio = new KSDATARANGE_AUDIO;
if( pCopyDataRangeAudio )
{PKSDATARANGE_AUDIO pDataRangeAudio = (PKSDATARANGE_AUDIO)pDataRange;
CopyMemory( pCopyDataRangeAudio, pDataRangeAudio, sizeof(KSDATARANGE_AUDIO) );
if (NULL == m_listDataRange.AddTail( pCopyDataRangeAudio ))
{delete pCopyDataRangeAudio;
pCopyDataRangeAudio = NULL;
DebugPrintf(TRACE_ERROR, TEXT("Unable to allocate list entry to save datarange in"));
hr = E_OUTOFMEMORY;}}
else
{DebugPrintf(TRACE_ERROR, TEXT("Unable to allocate memory to save datarange in"));
pDataRange = (PKSDATARANGE)( ((PBYTE)pDataRange) + pDataRange->FormatSize);}
{DebugPrintf(TRACE_ERROR, TEXT("No audio dataranges on the pin"));
TRACE_LEAVE_HRESULT(hr);
return hr;}
{fViablePin = fViablePin ||
IsEqualGUIDAligned(pDataRange->SubFormat, KSDATAFORMAT_SUBTYPE_MIDI) ||
if (fViablePin && IsEqualGUIDAligned(pDataRange->MajorFormat, KSDATAFORMAT_TYPE_MUSIC))
PKSDATARANGE_MUSIC pCopyDataRangeAudio = new KSDATARANGE_MUSIC;
{PKSDATARANGE_MUSIC pDataRangeAudio = (PKSDATARANGE_MUSIC)pDataRange;
CopyMemory( pCopyDataRangeAudio, pDataRangeAudio, sizeof(KSDATARANGE_MUSIC) );
CKsAudPin::~CKsAudPin(void)
KSDATARANGE_AUDIO *pKSDATARANGE_AUDIO;
CKsNode *pKsNode;
// Clear datarange list
while( m_listDataRange.RemoveHead(&pKSDATARANGE_AUDIO) )
{delete pKSDATARANGE_AUDIO;}
// Clear the node list
while( m_listNodes.RemoveHead(&pKsNode) )
{delete pKsNode;}
delete[] (BYTE *)m_pWaveFormatEx;
return;}
CKsNode * pKsNode;
while(m_listDataRange.RemoveHead(&pKSDATARANGE_MUSIC))
{delete pKSDATARANGE_MUSIC;}
while(m_listNodes.RemoveHead(&pKsNode))
CKsAudPin::CKsAudPin
(CKsAudFilter* pFilter,
ULONG nId,
HRESULT* phr
) : CKsPin(pFilter, nId, phr),
m_pAudFilter(pFilter),
m_pWaveFormatEx(NULL),
m_pksDataFormatWfx(NULL)
HRESULT hr = *phr;
{hr = m_listDataRange.Initialize(1);
if (FAILED(hr))
DebugPrintf(TRACE_ERROR,TEXT("Failed to Initialize m_listDataRange"));}
{hr = m_listNodes.Initialize(1);
DebugPrintf(TRACE_ERROR,TEXT("Failed to Initialize m_listNodes"));}
// create a KSPIN_CONNECT structure to describe a waveformatex pin
{m_cbPinCreateSize = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT_WAVEFORMATEX);
m_pksPinCreate = (PKSPIN_CONNECT)new BYTE[m_cbPinCreateSize];
if (!m_pksPinCreate)
{DebugPrintf(TRACE_ERROR,TEXT("Failed to allocate m_pksPinCreate"));
{m_pksPinCreate->Interface.Set = KSINTERFACESETID_Standard;
m_pksPinCreate->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
m_pksPinCreate->Interface.Flags = 0;
m_pksPinCreate->Medium.Set = KSMEDIUMSETID_Standard;
m_pksPinCreate->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
m_pksPinCreate->Medium.Flags = 0;
m_pksPinCreate->PinId = nId;
m_pksPinCreate->PinToHandle = NULL;
m_pksPinCreate->Priority.PriorityClass = KSPRIORITY_NORMAL;
m_pksPinCreate->Priority.PrioritySubClass = 1;
// point m_pksDataFormatWfx to just after the pConnect struct
PKSDATAFORMAT_WAVEFORMATEX pksDataFormatWfx = (PKSDATAFORMAT_WAVEFORMATEX)(m_pksPinCreate + 1);
// set up format for KSDATAFORMAT_WAVEFORMATEX
pksDataFormatWfx->DataFormat.FormatSize = sizeof(KSDATAFORMAT_WAVEFORMATEX);
pksDataFormatWfx->DataFormat.Flags = 0;
pksDataFormatWfx->DataFormat.Reserved = 0;
pksDataFormatWfx->DataFormat.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
pksDataFormatWfx->DataFormat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
pksDataFormatWfx->DataFormat.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
m_pksDataFormatWfx = pksDataFormatWfx;}
// Initialize the Pin;
{hr = CKsAudPin::Init();}
*phr = hr;
m_pksDataFormat(NULL)
{m_cbPinCreateSize = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT);
// point m_pksDataFormat to just after the pConnect struct
PKSDATAFORMAT pksDataFormat = (PKSDATAFORMAT)(m_pksPinCreate + 1);
// set up format for KSDATAFORMAT
pksDataFormat->FormatSize = sizeof(KSDATAFORMAT);
pksDataFormat->Flags = 0;
pksDataFormat->SampleSize = 0;
pksDataFormat->Reserved = 0;
pksDataFormat->MajorFormat = KSDATAFORMAT_TYPE_MUSIC;
pksDataFormat->SubFormat = KSDATAFORMAT_SUBTYPE_MIDI;
pksDataFormat->Specifier = KSDATAFORMAT_SPECIFIER_NONE;
m_pksDataFormat = pksDataFormat;}
В файле audpin.h
TList<KSDATARANGE_AUDIO> m_listDataRange;
TList<KSDATARANGE_MUSIC> m_listDataRange;
BOOL IsFormatSupported(const WAVEFORMATEX* pwfx);
BOOL IsFormatSupported();
KSDATAFORMAT_WAVEFORMATEX* m_pksDataFormatWfx;
KSDATAFORMAT * m_pksDataFormat;
Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9