自学教程：C++ DeleteMediaType函数代码示例

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;}

//-----------------------------------------------------------------------------// GetPin// Find the pin of the specified format type on the given filter// This method leaves an outstanding reference on the pin if successfulHRESULT 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;}

STDMETHODIMP CStreamSwitcherFilter::Enable(long lIndex, DWORD dwFlags){    if (dwFlags != AMSTREAMSELECTENABLE_ENABLE) {        return E_NOTIMPL;    }    PauseGraph;    bool bFound = false;    int i = 0;    CStreamSwitcherInputPin* pNewInputPin = nullptr;    POSITION pos = m_pInputs.GetHeadPosition();    while (pos && !bFound) {        pNewInputPin = m_pInputs.GetNext(pos);        if (pNewInputPin->IsConnected()) {            if (CComPtr<IAMStreamSelect> pSSF = pNewInputPin->GetStreamSelectionFilter()) {                DWORD cStreams = 0;                HRESULT hr = pSSF->Count(&cStreams);                if (SUCCEEDED(hr)) {                    for (i = 0; i < (int)cStreams; i++) {                        AM_MEDIA_TYPE* pmt = nullptr;                        hr = pSSF->Info(i, &pmt, nullptr, nullptr, NULL, nullptr, nullptr, nullptr);                        if (SUCCEEDED(hr) && pmt && pmt->majortype == MEDIATYPE_Audio) {                            if (lIndex == 0) {                                bFound = true;                                DeleteMediaType(pmt);                                break;                            } else {                                lIndex--;                            }                        }                        DeleteMediaType(pmt);                    }                }            } else if (lIndex == 0) {                bFound = true;            } else {                lIndex--;            }        }    }    if (!bFound) {        return E_INVALIDARG;    }    SelectInput(pNewInputPin);    if (CComPtr<IAMStreamSelect> pSSF = pNewInputPin->GetStreamSelectionFilter()) {        pSSF->Enable(i, dwFlags);    }    ResumeGraph;    return S_OK;}

IPin* FindDecoderSubpictureOutputPin(IBaseFilter* pFilter){    IEnumPins* pEnum = NULL;    HRESULT hr = pFilter->EnumPins(&pEnum);    if (hr != NOERROR)        return NULL;    ULONG ulFound;    IPin *pPin = NULL;    hr = E_FAIL;    while(S_OK == pEnum->Next(1, &pPin, &ulFound))    {		PIN_INFO PinInfo;		//		// grab this, so we can examine its name field		//	    hr = pPin->QueryPinInfo(&PinInfo);	    if(SUCCEEDED(hr))		{			PinInfo.pFilter->Release();			//			// check direction			//			if (PinInfo.dir == PINDIR_OUTPUT)			{				// Make sure its not connected yet and its a video type.				IPin* dummyPin = NULL;				hr = pPin->ConnectedTo(&dummyPin);				SAFE_RELEASE(dummyPin);				if (hr == VFW_E_NOT_CONNECTED)				{					IEnumMediaTypes *mtEnum = NULL;					pPin->EnumMediaTypes(&mtEnum);					AM_MEDIA_TYPE *pMT = NULL;					while (S_OK == mtEnum->Next(1, &pMT, NULL))					{						if (pMT->majortype == MEDIATYPE_Video)						{							DeleteMediaType(pMT);							SAFE_RELEASE(mtEnum);							SAFE_RELEASE(pEnum);							return pPin;						}						DeleteMediaType(pMT);					}					SAFE_RELEASE(mtEnum);				}			}		}        pPin->Release();    }     SAFE_RELEASE(pEnum);	return NULL;}

/* 设置捕获图像帧的格式，遍历所有格式是否有预定格式，若没有则以默认格式捕获 */HRESULT CVMR_Capture::InitVideoWindow(HWND hWnd,int width, int height){	HRESULT hr;	RECT rcDest;	    IAMStreamConfig *pConfig;    IEnumMediaTypes *pMedia;    AM_MEDIA_TYPE *pmt = NULL, *pfnt = NULL;    hr = m_pCamOutPin->EnumMediaTypes( &pMedia );    if(SUCCEEDED(hr))    {		//把所有视频的所有格式遍历一遍，看是否有预定的格式        while(pMedia->Next(1, &pmt, 0) == S_OK)        {            if( pmt->formattype == FORMAT_VideoInfo )            {                VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)pmt->pbFormat;				// 当前的格式是否与预定格式相同，即宽和高相同                if( vih->bmiHeader.biWidth == width && vih->bmiHeader.biHeight == height )                {                    pfnt = pmt;				    break;                }                DeleteMediaType( pmt );            }          }        pMedia->Release();    }	    hr = m_pCamOutPin->QueryInterface( IID_IAMStreamConfig, (void **) &pConfig );    if(SUCCEEDED(hr))    {		// 有预定的格式        if( pfnt != NULL )        {            hr=pConfig->SetFormat( pfnt );            DeleteMediaType( pfnt );        }		// 没有预定的格式，读取缺省媒体格式        hr = pConfig->GetFormat( &pfnt );        if(SUCCEEDED(hr))        {            m_nWidth = ((VIDEOINFOHEADER *)pfnt->pbFormat)->bmiHeader.biWidth;   //读取高            m_nHeight = ((VIDEOINFOHEADER *)pfnt->pbFormat)->bmiHeader.biHeight; //读取宽            DeleteMediaType( pfnt );        }    }	// 获取传入窗口的区域，以设置显示窗口	::GetClientRect (hWnd,&rcDest);    hr = m_pWC->SetVideoPosition(NULL, &rcDest);    return hr;}

//// Receive//// Do something with this media sample//STDMETHODIMP CWasapiInputPin::Receive(IMediaSample *pSample){//	DebugPrintf(L"Receive/n");	CAutoLock lock(m_pReceiveLock);    CheckPointer(pSample,E_POINTER);	bool mediaTypeFailed=false;    HRESULT hr = CBaseInputPin::Receive(pSample);	if(hr!=S_OK)	{		DebugPrintf(L"CWasapiInputPin::Receive CBaseInputPin returned error. %d /n",hr);		goto exit;	}	CMediaType* mediaType=NULL;	hr=pSample->GetMediaType((AM_MEDIA_TYPE**)&mediaType);	if(hr==S_OK)	{		hr = CBasePin::SetMediaType(mediaType);		DeleteMediaType(mediaType);	}	hr= m_pManager->SampleReceived(pSample);	if(hr==S_FALSE)		//Media type rejected by Wasapi engine	{		DebugPrintf(L"CWasapiInputPin::Receive returning EC_ERRORABORT. /n");		CBasePin::EndOfStream();		m_pFilter->NotifyEvent(EC_ERRORABORT,NULL,NULL);		goto exit;	}exit:	return hr; }

void DeviceSource::SetAudioInfo(AM_MEDIA_TYPE *audioMediaType, GUID &expectedAudioType){    expectedAudioType = audioMediaType->subtype;    if(audioMediaType->formattype == FORMAT_WaveFormatEx)    {        WAVEFORMATEX *pFormat = reinterpret_cast<WAVEFORMATEX*>(audioMediaType->pbFormat);        mcpy(&audioFormat, pFormat, sizeof(audioFormat));        Log(TEXT("    device audio info - bits per sample: %u, channels: %u, samples per sec: %u, block size: %u"),            audioFormat.wBitsPerSample, audioFormat.nChannels, audioFormat.nSamplesPerSec, audioFormat.nBlockAlign);        //avoid local resampling if possible        /*if(pFormat->nSamplesPerSec != 44100)        {            pFormat->nSamplesPerSec = 44100;            if(SUCCEEDED(audioConfig->SetFormat(audioMediaType)))            {                Log(TEXT("    also successfully set samples per sec to 44.1k"));                audioFormat.nSamplesPerSec = 44100;            }        }*/    }    else    {        AppWarning(TEXT("DShowAudioPlugin: Audio format was not a normal wave format"));        soundOutputType = 0;    }    DeleteMediaType(audioMediaType);}

STDMETHODIMPCMediaSample::SetMediaType(AM_MEDIA_TYPE *pMediaType){	/* Delete the current media type */	if (m_pMediaType) {		DeleteMediaType(m_pMediaType);		m_pMediaType = NULL;	}	/* Mechanism for resetting the format type */	if (pMediaType == NULL) {		m_dwFlags &= ~Sample_TypeChanged;		return NOERROR;	}	ASSERT(pMediaType);	ValidateReadPtr(pMediaType,sizeof(AM_MEDIA_TYPE));	/* Take a copy of the media type */	m_pMediaType = CreateMediaType(pMediaType);	if (m_pMediaType == NULL) {		m_dwFlags &= ~Sample_TypeChanged;		return E_OUTOFMEMORY;	}	m_dwFlags |= Sample_TypeChanged;	return NOERROR;}

HRESULT CBaseVideoFilter::Receive(IMediaSample* pIn){#ifndef _WIN64    // TODOX64 : fixme!    _mm_empty(); // just for safety#endif    CAutoLock cAutoLock(&m_csReceive);    HRESULT hr;    AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();    if (pProps->dwStreamId != AM_STREAM_MEDIA) {        return m_pOutput->Deliver(pIn);    }    AM_MEDIA_TYPE* pmt;    if (SUCCEEDED(pIn->GetMediaType(&pmt)) && pmt) {        CMediaType mt(*pmt);        m_pInput->SetMediaType(&mt);        DeleteMediaType(pmt);    }    if (FAILED(hr = Transform(pIn))) {        return hr;    }    return S_OK;}

HRESULT CBaseVideoFilter::GetDeliveryBuffer(int w, int h, IMediaSample** ppOut){    CheckPointer(ppOut, E_POINTER);    HRESULT hr;    if (FAILED(hr = ReconnectOutput(w, h))) {        return hr;    }    if (FAILED(hr = m_pOutput->GetDeliveryBuffer(ppOut, NULL, NULL, 0))) {        return hr;    }    AM_MEDIA_TYPE* pmt;    if (SUCCEEDED((*ppOut)->GetMediaType(&pmt)) && pmt) {        CMediaType mt = *pmt;        m_pOutput->SetMediaType(&mt);        DeleteMediaType(pmt);    }    (*ppOut)->SetDiscontinuity(FALSE);    (*ppOut)->SetSyncPoint(TRUE);    // FIXME: hell knows why but without this the overlay mixer starts very skippy    // (don't enable this for other renderers, the old for example will go crazy if you do)    if (GetCLSID(m_pOutput->GetConnected()) == CLSID_OverlayMixer) {        (*ppOut)->SetDiscontinuity(TRUE);    }    return S_OK;}

STDMETHODIMP CStreamSwitcherFilter::Count(DWORD* pcStreams){    if (!pcStreams) {        return E_POINTER;    }    CAutoLock cAutoLock(&m_csPins);    *pcStreams = 0;    POSITION pos = m_pInputs.GetHeadPosition();    while (pos) {        CStreamSwitcherInputPin* pInputPin = m_pInputs.GetNext(pos);        if (pInputPin->IsConnected()) {            if (CComPtr<IAMStreamSelect> pSSF = pInputPin->GetStreamSelectionFilter()) {                DWORD cStreams = 0;                HRESULT hr = pSSF->Count(&cStreams);                if (SUCCEEDED(hr)) {                    for (int i = 0; i < (int)cStreams; i++) {                        AM_MEDIA_TYPE* pmt = nullptr;                        hr = pSSF->Info(i, &pmt, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);                        if (SUCCEEDED(hr) && pmt && pmt->majortype == MEDIATYPE_Audio) {                            (*pcStreams)++;                        }                        DeleteMediaType(pmt);                    }                }            } else {                (*pcStreams)++;            }        }    }    return S_OK;}

STDMETHODIMP TffdshowEncDshow::getDstBuffer(IMediaSample* *pOut, const TffPict &pict){    *pOut = NULL;    BYTE *data;    HRESULT hr;    if (FAILED(hr = getDeliveryBuffer(pOut, &data))) {        return hr;    }    if (pict.rtStart == REFTIME_INVALID || pict.rtStop == REFTIME_INVALID) {        REFERENCE_TIME tStart = (params.framenum) * inpin->avgTimePerFrame;        REFERENCE_TIME tStop = (params.framenum + 1) * inpin->avgTimePerFrame;        setPropsTime(*pOut, tStart, tStop, m_pInput->SampleProps(), &m_bSampleSkipped);        //DPRINTF("tStart:%i, tStop:%i, AVIfps:%i",int(tStart),int(tStop),timePerFrame);    } else {        (*pOut)->SetTime((REFERENCE_TIME*)&pict.rtStart, (REFERENCE_TIME*)&pict.rtStop);    }    AM_MEDIA_TYPE *mtOut;    (*pOut)->GetMediaType(&mtOut);    if (mtOut != NULL) {        HRESULT result = S_OK;        DeleteMediaType(mtOut);        if (result != S_OK) {            return result;        }    }    return S_OK;}

HRESULT CStreamSwitcherOutputPin::GetMediaType(int iPosition, CMediaType* pmt){    CStreamSwitcherInputPin* pIn = (static_cast<CStreamSwitcherFilter*>(m_pFilter))->GetInputPin();    if (!pIn || !pIn->IsConnected()) {        return E_UNEXPECTED;    }    CComPtr<IEnumMediaTypes> pEM;    if (FAILED(pIn->GetConnected()->EnumMediaTypes(&pEM))) {        return VFW_S_NO_MORE_ITEMS;    }    if (iPosition > 0 && FAILED(pEM->Skip(iPosition))) {        return VFW_S_NO_MORE_ITEMS;    }    AM_MEDIA_TYPE* tmp = nullptr;    if (S_OK != pEM->Next(1, &tmp, nullptr) || !tmp) {        return VFW_S_NO_MORE_ITEMS;    }    CopyMediaType(pmt, tmp);    DeleteMediaType(tmp);    /*        if (iPosition < 0) return E_INVALIDARG;        if (iPosition > 0) return VFW_S_NO_MORE_ITEMS;        CopyMediaType(pmt, &pIn->CurrentMediaType());    */    return S_OK;}

void VideoCapture::EnumResolutions(){	int iCount, iSize, iChosen=-1;	IBaseFilter *pSource;   	CComPtr <ICaptureGraphBuilder2> pCaptB;	VIDEO_STREAM_CONFIG_CAPS caps;	HRESULT hr;	bool response;	IAMStreamConfig *pConfig;	devices_resolutions = new DeviceResolutions[nDevices];	pCaptB.CoCreateInstance(CLSID_CaptureGraphBuilder2);	for (unsigned int iDevice=0; iDevice<nDevices; iDevice++)	{		response = BindFilter(iDevice, &pSource);		hr = pCaptB->FindInterface(        &PIN_CATEGORY_CAPTURE,        &MEDIATYPE_Video,        pSource,        IID_IAMStreamConfig,        (void**)&pConfig);		if (!SUCCEEDED(hr))		{			pSource->Release();			devices_resolutions[iDevice].nResolutions = 0;			continue;		}		pConfig->GetNumberOfCapabilities(&iCount, &iSize);		devices_resolutions[iDevice].SetNResolutions(iCount);		for(int i=0; i < iCount; i++) {			AM_MEDIA_TYPE *pmt;			if( pConfig->GetStreamCaps(i, &pmt, reinterpret_cast<BYTE*>(&caps)) == S_OK ) {				VIDEOINFOHEADER *pVih = 					reinterpret_cast<VIDEOINFOHEADER*>(pmt->pbFormat);								devices_resolutions[iDevice].x[i] = caps.InputSize.cx;				devices_resolutions[iDevice].y[i] = caps.InputSize.cy;				devices_resolutions[iDevice].color_space[i] = pmt->subtype;				devices_resolutions[iDevice].compression[i] = pVih->bmiHeader.biCompression;				DeleteMediaType(pmt);			}		}		pSource->Release();		pConfig->Release();		pSource = 0;	}}

HRESULT CDeCSSFilter::Transform(IMediaSample* pIn, IMediaSample* pOut){    AM_MEDIA_TYPE* pmt;    if (SUCCEEDED(pIn->GetMediaType(&pmt)) && pmt) {        CMediaType mt = *pmt;        m_pInput->SetMediaType(&mt);        mt.majortype = m_pOutput->CurrentMediaType().majortype;        m_pOutput->SetMediaType(&mt);        pOut->SetMediaType(&mt);        DeleteMediaType(pmt);    }    BYTE* pDataIn = NULL;    BYTE* pDataOut = NULL;    pIn->GetPointer(&pDataIn);    pOut->GetPointer(&pDataOut);    long len = pIn->GetActualDataLength();    long size = pOut->GetSize();    if (len == 0 || pDataIn == NULL) { // format changes do not carry any data        pOut->SetActualDataLength(0);        return S_OK;    }    if (m_pOutput->CurrentMediaType().majortype == MEDIATYPE_MPEG2_PES) {        if (*(DWORD*)pDataIn == 0xBA010000) {            len -= 14;            pDataIn += 14;            if (int stuffing = (pDataIn[-1] & 7)) {                len -= stuffing;                pDataIn += stuffing;            }        }        if (len <= 0) {            return S_FALSE;        }        if (*(DWORD*)pDataIn == 0xBB010000) {            len -= 4;            pDataIn += 4;            int hdrlen = ((pDataIn[0] << 8) | pDataIn[1]) + 2;            len -= hdrlen;            pDataIn += hdrlen;        }        if (len <= 0) {            return S_FALSE;        }    }    if (!pDataIn || !pDataOut || len > size || len < 0) {        return S_FALSE;    }    memcpy(pDataOut, pDataIn, min(len, size));    pOut->SetActualDataLength(min(len, size));    return S_OK;}

// Format negotiationHRESULT CTimeStretchFilter::NegotiateFormat(const WAVEFORMATEXTENSIBLE* pwfx, int nApplyChangesDepth, ChannelOrder* pChOrder){  if (!pwfx)    return VFW_E_TYPE_NOT_ACCEPTED;#ifdef INTEGER_SAMPLES  // only accept 16bit int  if (pwfx->Format.wBitsPerSample != 16 || pwfx->SubFormat != KSDATAFORMAT_SUBTYPE_PCM)    return VFW_E_TYPE_NOT_ACCEPTED;#else   // only accept 32bit float  if (pwfx->Format.wBitsPerSample != 32 || pwfx->SubFormat != KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)    return VFW_E_TYPE_NOT_ACCEPTED;#endif  if (FormatsEqual(pwfx, m_pInputFormat))  {    *pChOrder = m_chOrder;    return S_OK;  }  bool bApplyChanges = (nApplyChangesDepth != 0);  if (nApplyChangesDepth != INFINITE && nApplyChangesDepth > 0)    nApplyChangesDepth--;  HRESULT hr = m_pNextSink->NegotiateFormat(pwfx, nApplyChangesDepth, pChOrder);  if (FAILED(hr))    return hr;  hr = VFW_E_CANNOT_CONNECT;    if (!pwfx)    return SetFormat(NULL);  if (bApplyChanges)  {    LogWaveFormat(pwfx, "TS   - applying ");    AM_MEDIA_TYPE tmp;    HRESULT result = CreateAudioMediaType((WAVEFORMATEX*)pwfx, &tmp, true);    if (SUCCEEDED(result))    {      if (m_pMediaType)        DeleteMediaType(m_pMediaType);      m_pMediaType = CreateMediaType(&tmp);    }    SetInputFormat(pwfx);    SetOutputFormat(pwfx);    SetFormat(pwfx);  }  else    LogWaveFormat(pwfx, "TS   -          ");  m_chOrder = *pChOrder;  return S_OK;}

HRESULT CTimeStretchFilter::CheckSample(IMediaSample* pSample){  if (!pSample)    return S_OK;  AM_MEDIA_TYPE *pmt = NULL;  bool bFormatChanged = false;    HRESULT hr = S_OK;  if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)    bFormatChanged = !FormatsEqual((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, m_pInputFormat);  if (bFormatChanged)  {    uint unprocessedSamplesBefore = numUnprocessedSamples();     uint zeros = flushEx();    uint unprocessedSamplesAfter = numUnprocessedSamples();    UINT32 outFramesAfter = numSamples();        UINT32 totalSamples = zeros + unprocessedSamplesBefore;    UINT32 totalProcessedSamples = totalSamples - unprocessedSamplesAfter;    //double bias = (double)totalProcessedSamples / (double)outFramesAfter;    REFERENCE_TIME estimatedSampleDuration = totalProcessedSamples * UNITS / m_pOutputFormat->Format.nSamplesPerSec;    double bias = m_pClock->GetBias();    double adjustment = m_pClock->Adjustment();    double AVMult = m_pClock->SuggestedAudioMultiplier(estimatedSampleDuration, bias, adjustment);    setTempoInternal(AVMult, 1.0);    CreateOutput(totalProcessedSamples, outFramesAfter, bias, adjustment, AVMult, true);        // Empty SoundTouch's buffers    clear();    // Apply format change    ChannelOrder chOrder;    hr = NegotiateFormat((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, 1, &chOrder);    pSample->SetDiscontinuity(false);    if (FAILED(hr))    {      DeleteMediaType(pmt);      Log("CTimeStretchFilter::CheckFormat failed to change format: 0x%08x", hr);      return hr;    }    else    {      m_chOrder = chOrder;      return S_FALSE; // format changed    }  }  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;}

void CCaptureDevice::SetCaptureBufferSize(void){	IPin * pCapturePin = GetPin();	if (pCapturePin)	{		DWORD  dwBytesPerSec = 0;		AM_MEDIA_TYPE * pmt = {0};		IAMStreamConfig * pCfg = NULL;		HRESULT hr = pCapturePin->QueryInterface(IID_IAMStreamConfig, (void **)&pCfg);		if ( hr==S_OK )		{            hr = pCfg->GetFormat(&pmt);			if ( hr==S_OK )			{				WAVEFORMATEX *pWF = (WAVEFORMATEX *) pmt->pbFormat;				dwBytesPerSec = pWF->nAvgBytesPerSec;				pWF->nChannels = 1;				pWF->wBitsPerSample = 8;				pWF->nSamplesPerSec = 11025;				pWF->nAvgBytesPerSec = pWF->nSamplesPerSec * pWF->nChannels * pWF->wBitsPerSample / 8;				pWF->nBlockAlign = 1;/*	info.cbSize = sizeof(WAVEFORMATEX);	info.wFormatTag = 1;	info.nChannels = 2;	info.nSamplesPerSec = 44100;	//info.nSamplesPerSec = 22050;	11025	info.wBitsPerSample = 16;	info.nAvgBytesPerSec = info.nSamplesPerSec * info.nChannels * info.wBitsPerSample / 8;	info.nBlockAlign = 4;	*/				pCfg->SetFormat( pmt );				DeleteMediaType(pmt);			}			pCfg->Release();		}/*		if (dwBytesPerSec)		{			IAMBufferNegotiation * pNeg = NULL;			hr = pCapturePin->QueryInterface(IID_IAMBufferNegotiation, 				(void **)&pNeg);			if (SUCCEEDED(hr))			{				ALLOCATOR_PROPERTIES AllocProp;				AllocProp.cbAlign  = -1;  // -1 means no preference.				AllocProp.cbBuffer = dwBytesPerSec *  dwLatencyInMilliseconds / 1000;				AllocProp.cbPrefix = -1;				AllocProp.cBuffers = -1;				hr = pNeg->SuggestAllocatorProperties(&AllocProp);				pNeg->Release();			}		}*/	}}

CClip::~CClip(void){  CAutoLock vectorVLock(&m_sectionVectorVideo);  CAutoLock vectorALock(&m_sectionVectorAudio);  FlushAudio();  FlushVideo();  DeleteMediaType(m_videoPmt);  if (m_pSparseVideoPacket)    delete m_pSparseVideoPacket;  m_pSparseVideoPacket = NULL;}

STDMETHODIMP TffdshowVideoInputPin::Receive(IMediaSample* pSample){    AM_MEDIA_TYPE *pmt = NULL;    if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt) {        CAutoLock lock2(&m_csCodecs_and_imgFilters);        CMediaType mt(*pmt);        SetMediaType(&mt);        allocator.mtChanged = false;        DeleteMediaType(pmt);    }    return TinputPin::Receive(pSample);}

CTimeStretchFilter::~CTimeStretchFilter(void){  Log("CTimeStretchFilter - destructor - instance 0x%x", this);    SetEvent(m_hStopThreadEvent);  WaitForSingleObject(m_hThread, INFINITE);  CAutoLock lock(&m_csResources);  SetFormat(NULL);  DeleteMediaType(m_pMediaType);  Log("CTimeStretchFilter - destructor - instance 0x%x - end", this);}

HRESULT CWASAPIRenderFilter::CheckSample(IMediaSample* pSample, UINT32 framesToFlush){  if (!pSample)    return S_OK;  AM_MEDIA_TYPE *pmt = NULL;  bool bFormatChanged = false;    HRESULT hr = S_OK;  if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)    bFormatChanged = !FormatsEqual((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, m_pInputFormat);  if (bFormatChanged)  {    // Release outstanding buffer    hr = m_pRenderClient->ReleaseBuffer(framesToFlush, 0);    if (FAILED(hr))      Log("CWASAPIRenderFilter::CheckFormat - ReleaseBuffer: 0x%08x", hr);    // Apply format change    ChannelOrder chOrder;    hr = NegotiateFormat((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, 1, &chOrder);    pSample->SetDiscontinuity(false);    if (FAILED(hr))    {      DeleteMediaType(pmt);      Log("CWASAPIRenderFilter::CheckFormat failed to change format: 0x%08x", hr);      return hr;    }    else    {      m_chOrder = chOrder;      return S_FALSE;    }  }  else if (pSample->IsDiscontinuity() == S_OK)  {    hr = m_pRenderClient->ReleaseBuffer(framesToFlush, 0);    if (FAILED(hr))      Log("CWASAPIRenderFilter::CheckFormat - discontinuity - ReleaseBuffer: 0x%08x", hr);        pSample->SetDiscontinuity(false);    m_nSampleNum = 0;    return S_FALSE;  }  return S_OK;}

HRESULT CTimeStretchFilter::CheckSample(IMediaSample* pSample, REFERENCE_TIME* rtDrained){  if (!pSample)    return S_OK;  AM_MEDIA_TYPE *pmt = NULL;  bool bFormatChanged = false;    HRESULT hr = S_OK;  if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)    bFormatChanged = !FormatsEqual((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, m_pInputFormat);  if (bFormatChanged)  {    REFERENCE_TIME rtStart = 0;    REFERENCE_TIME rtStop = 0;    HRESULT hr = pSample->GetTime(&rtStart, &rtStop);        if (SUCCEEDED(hr))    {      Log("CTimeStretchFilter - CheckSample - resyncing in middle of stream on format change - rtStart: %6.3f m_rtInSampleTime: %6.3f",         rtStart / 10000000.0, m_rtInSampleTime / 10000000.0);      *rtDrained = DrainBuffers(pSample, rtStart);    }    else      Log("CTimeStretchFilter::CheckFormat failed to get timestamps from sample: 0x%08x", hr);    // Apply format change    ChannelOrder chOrder;    hr = NegotiateFormat((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, 1, &chOrder);    pSample->SetDiscontinuity(false);    if (FAILED(hr))    {      DeleteMediaType(pmt);      Log("CTimeStretchFilter::CheckFormat failed to change format: 0x%08x", hr);      return hr;    }    else    {      m_chOrder = chOrder;      return S_FALSE; // format changed    }  }  return S_OK;}

static HRESULT WINAPIVfwPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum){    VfwPinImpl *This = impl_from_IPin(iface);    AM_MEDIA_TYPE *pmt;    HRESULT hr;    hr = qcap_driver_get_format(This->parent->driver_info, &pmt);    if (SUCCEEDED(hr)) {        hr = BasePinImpl_EnumMediaTypes(iface, ppEnum);        DeleteMediaType(pmt);    }    TRACE("%p -- %x/n", This, hr);    return hr;}

/// Make destination an identical copy of sourceHRESULT DShowIMediaSampleCopy(IMediaSample *pSource, IMediaSample *pDest, bool bCopyData){	CheckPointer(pSource, E_POINTER);	CheckPointer(pDest, E_POINTER);	if (bCopyData) {		// Copy the sample data		BYTE *pSourceBuffer, *pDestBuffer;		long lSourceSize = pSource->GetActualDataLength();	#ifdef DEBUG    		long lDestSize = pDest->GetSize();		ASSERT(lDestSize >= lSourceSize);	#endif		pSource->GetPointer(&pSourceBuffer);		pDest->GetPointer(&pDestBuffer);		CopyMemory((PVOID) pDestBuffer,(PVOID) pSourceBuffer, lSourceSize);	}	// Copy the sample times	REFERENCE_TIME TimeStart, TimeEnd;	if(NOERROR == pSource->GetTime(&TimeStart, &TimeEnd))	{		pDest->SetTime(&TimeStart, &TimeEnd);	}	LONGLONG MediaStart, MediaEnd;	if(pSource->GetMediaTime(&MediaStart,&MediaEnd) == NOERROR)	{		pDest->SetMediaTime(&MediaStart,&MediaEnd);	}	// Copy the media type	AM_MEDIA_TYPE *pMediaType;	pSource->GetMediaType(&pMediaType);	pDest->SetMediaType(pMediaType);	DeleteMediaType(pMediaType);	// Copy the actual data length	long lDataLength = pSource->GetActualDataLength();	pDest->SetActualDataLength(lDataLength);	return NOERROR;}