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

//// FindPin//// If Id is In or Out then return the IPin* for that pin// creating the pin if need be.  Otherwise return NULL with an error.STDMETHODIMP CParserFilter::FindPin(LPCWSTR Id, IPin **ppPin) {    CheckPointer(ppPin,E_POINTER);    ValidateReadWritePtr(ppPin,sizeof(IPin *));    if(0==lstrcmpW(Id,L"In")) {        *ppPin = GetPin(0);    }    else if(0==lstrcmpW(Id,L"Out")) {        *ppPin = GetPin(1);    }    else {        *ppPin = NULL;        return VFW_E_NOT_FOUND;    }    HRESULT hr = NOERROR;    //  AddRef() returned pointer - but GetPin could fail if memory is low.    if(*ppPin) {        (*ppPin)->AddRef();    }    else {        hr = E_OUTOFMEMORY;  // probably.  There's no pin anyway.    }    return hr;}

static HRESULT ConnectFilters(IGraphBuilder *graph,							  IBaseFilter *lhs,							  IBaseFilter *rhs){	HRESULT hr = S_OK;    IPin *out = 0;	IPin *in  = 0;	    hr = GetPin(lhs, PINDIR_OUTPUT, &out);	    if (FAILED(hr))		return hr;	    hr = GetPin(rhs, PINDIR_INPUT, &in);	    if (FAILED(hr))     {        out->Release();        return hr;	}	    hr = graph->Connect(out, in);    in->Release();    out->Release();    return hr;}

//-----------------------------------------------------------------------------// ConnectFilters// Connects two filters by finding a pin on the upstream filter with the specified// major format type, e.g. For connecting an audio pin to a downstream filterHRESULT CDSUtils::ConnectFilters(IGraphBuilder* pGraph, IBaseFilter* pUpstream, IBaseFilter* pDownstream, const GUID* pFormat){	HRESULT hr = S_OK;	if (pUpstream && pDownstream && pFormat)	{		// find the upstream output pin with the specified format		CComPtr<IPin> pIPinOutput = NULL;		hr = GetPin(pUpstream, pFormat, PINDIR_OUTPUT, &pIPinOutput);		if (SUCCEEDED(hr))		{			// get the downstream input pin			CComPtr<IPin> pIPinInput = NULL;			hr = GetPin(pDownstream, pFormat, PINDIR_INPUT, &pIPinInput);			if (SUCCEEDED(hr))			{				// connect the pins				hr = pGraph->Connect(pIPinOutput, pIPinInput);			}		}	}	else	{		hr = E_INVALIDARG;	}	return hr;}

void bmp (void) {  uprintf("Command Excepted/r");  switch (ExtractNum(3)) {    case 0:itoa(GetPin('B',4),dumb,10);break;    case 1:itoa(GetPin('B',5),dumb,10);break;  }  uprintf(dumb);  uprintf("/r");}

STDMETHODIMP CDynamicSource::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR pName){    CAutoLock lock(&m_cStateLock);    HRESULT hr;    int nCurrentPin;    CDynamicSourceStream* pOutputPin;    // The filter is joining the filter graph.    if(NULL != pGraph)    {        IGraphConfig* pGraphConfig = NULL;        hr = pGraph->QueryInterface(IID_IGraphConfig, (void**)&pGraphConfig);        if(FAILED(hr))        {            return hr;        }        hr = CBaseFilter::JoinFilterGraph(pGraph, pName);        if(FAILED(hr))        {            pGraphConfig->Release();            return hr;        }        for(nCurrentPin = 0; nCurrentPin < GetPinCount(); nCurrentPin++)        {            pOutputPin = (CDynamicSourceStream*) GetPin(nCurrentPin);            pOutputPin->SetConfigInfo(pGraphConfig, m_evFilterStoppingEvent);        }        pGraphConfig->Release();    }    else    {        hr = CBaseFilter::JoinFilterGraph(pGraph, pName);        if(FAILED(hr))        {            return hr;        }        for(nCurrentPin = 0; nCurrentPin < GetPinCount(); nCurrentPin++)        {            pOutputPin = (CDynamicSourceStream*)GetPin(nCurrentPin);            pOutputPin->SetConfigInfo(NULL, NULL);        }    }    return S_OK;}

STDMETHODIMP CDynamicSource::Stop(void){    m_evFilterStoppingEvent.Set();    HRESULT hr = CBaseFilter::Stop();    // The following code ensures that a pins thread will be destroyed even     // if the pin is disconnected when CBaseFilter::Stop() is called.    int nCurrentPin;    CDynamicSourceStream* pOutputPin;    {        // This code holds the pin state lock because it        // does not want the number of pins to change         // while it executes.        CAutoLock alPinStateLock(&m_csPinStateLock);        for(nCurrentPin = 0; nCurrentPin < GetPinCount(); nCurrentPin++)        {            pOutputPin = (CDynamicSourceStream*)GetPin(nCurrentPin);            if(pOutputPin->ThreadExists())            {                pOutputPin->DestroySourceThread();            }        }    }    if(FAILED(hr))    {        return hr;    }    return NOERROR;}

STDMETHODIMPBaseFilter::FindPin(LPCWSTR aId,                    IPin** aPin){  if (!aPin)    return E_POINTER;  *aPin = NULL;  CriticalSectionAutoEnter monitor(mLock);  int numPins = GetPinCount();  for (int i = 0; i < numPins; i++) {    BasePin* pin = GetPin(i);    if (NULL == pin) {      assert(pin != NULL);      return VFW_E_NOT_FOUND;    }    if (!pin->Name().compare(aId)) {      // Found a pin with a matching name, AddRef() and return it.      *aPin = pin;      NS_IF_ADDREF(pin);      return S_OK;    }  }  return VFW_E_NOT_FOUND;}

static HRESULT ConnectTwoFilters(IGraphBuilder *pGraph, IBaseFilter *pFirst, IBaseFilter *pSecond){    IPin *pOut = NULL, *pIn = NULL;    HRESULT hr = GetPin(pFirst, PINDIR_OUTPUT, &pOut);    if (FAILED(hr)) return hr;    hr = GetPin(pSecond, PINDIR_INPUT, &pIn);    if (FAILED(hr))     {        pOut->Release();        return E_FAIL;     }    hr = pGraph->Connect(pOut, pIn);    pIn->Release();    pOut->Release();    return hr;}

HRESULT STDMETHODCALLTYPE XnVideoSource::SetMode( IPin *pPin, long Mode ){    XN_METHOD_START;    XN_METHOD_CHECK_POINTER(pPin);    HRESULT hr = S_OK;    // we have only 1 pin, make sure this is it    XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0));    if (pPin != static_cast<IPin*>(pVideoStream))    {        XN_METHOD_RETURN(E_FAIL);    }    xnLogVerbose(XN_MASK_FILTER, "Setting flip mode to %d", Mode);    hr = pVideoStream->SetMirror(Mode & VideoControlFlag_FlipHorizontal);    if (FAILED(hr))        XN_METHOD_RETURN(hr);    hr = pVideoStream->SetVerticalFlip(Mode & VideoControlFlag_FlipVertical);    if (FAILED(hr))        XN_METHOD_RETURN(hr);    XN_METHOD_RETURN(S_OK);}

// Function name	: CVMR9Graph::RenderGraph// Description	    : render the graph// Return type		: BOOL BOOL CVMR9Graph::RenderGraph(){	HRESULT hr;	if (m_pFilterGraph2 == NULL) {		ReportError("Could not render the graph because it is not fully constructed", E_FAIL);		return FALSE;	}	for (int i=0; i<10; i++) {		IBaseFilter* pBaseFilter = m_srcFilterArray[i];		if (pBaseFilter != NULL) {			IPin* pPin;      while ((pPin = GetPin(pBaseFilter, PINDIR_OUTPUT)) != NULL)      {        hr = m_pFilterGraph2->RenderEx(pPin, AM_RENDEREX_RENDERTOEXISTINGRENDERERS, NULL);        if (FAILED(hr))        {          ReportError("Unable to render the pin", hr);          return FALSE;        }      }		}	}	return TRUE;}

HRESULT CAnalyzerWriterFilter::GetMediaPositionInterface(REFIID riid, __deref_out void **ppv){    CAutoLock cObjectCreationLock(&m_ObjectCreationLock);    if (m_pPosition) {        return m_pPosition->NonDelegatingQueryInterface(riid,ppv);    }    CBasePin *pPin = GetPin(0);    if (NULL == pPin) {        return E_OUTOFMEMORY;    }    HRESULT hr = NOERROR;    // Create implementation of this dynamically since sometimes we may    // never try and do a seek. The helper object implements a position    // control interface (IMediaPosition) which in fact simply takes the    // calls normally from the filter graph and passes them upstream    m_pPosition = new CAnalyzerPosPassThru(NAME("Renderer CPosPassThru"),                                           CBaseFilter::GetOwner(),                                           (HRESULT *) &hr,                                           pPin,                                           m_analyzer);    if (m_pPosition == NULL) {        return E_OUTOFMEMORY;    }    if (FAILED(hr)) {        delete m_pPosition;        m_pPosition = NULL;        return E_NOINTERFACE;    }    return GetMediaPositionInterface(riid,ppv);}

CTextOutFilter::CTextOutFilter(LPUNKNOWN pUnk,HRESULT *phr) :    CBaseRenderer(CLSID_TextRender, NAME("Text Display Filter/0"), pUnk, phr),    m_TextWindow(NAME("Text properties/0"),GetOwner(),phr,&m_InterfaceLock,this){    m_TextWindow.SetControlWindowPin( GetPin(0) );} // (Constructor)

bool ChannelPinMapper::TogglePin(int pinIdx, int chIdx) {  bool on = GetPin(pinIdx, chIdx);  on = !on;  SetPin(pinIdx, chIdx, on);   return on;}

void OggDemuxFilter::notifyPinConnected(){    LOG(logDEBUG) << __FUNCTIONW__;    if (!m_streamMapper->allStreamsReady())     {        return;    }    if (m_seekTable)     {        return;    }    m_seekTable = new CustomOggChainGranuleSeekTable();    int outputPinCount = GetPinCount();    for (int i = 1; i < outputPinCount; i++)     {        OggDemuxOutputPin* pin = static_cast<OggDemuxOutputPin*>(GetPin(i));        LOG(logDEBUG) << L"Adding decoder interface to seek table, serial no: " << pin->getSerialNo();        m_seekTable->addStream(pin->getSerialNo(), pin->getDecoderInterface());    }#ifndef WINCE    LOG(logDEBUG) << __FUNCTIONW__ << L" Building seek table...";    CComPtr<IAsyncReader> reader = m_inputPin.GetReader();    static_cast<CustomOggChainGranuleSeekTable*>(m_seekTable)->buildTable(reader);    LOG(logDEBUG) << __FUNCTIONW__ << L" Built.";#endif}

CDXFilter::CDXFilter( IUnknown * pOuter, HRESULT * phr, BOOL ModifiesData )                : CTransInPlaceFilter( TEXT("DXFilter"), (IUnknown*) pOuter,                                        CLSID_DXFilter, phr#if !defined(_WIN32_WCE)									   ,(BOOL)ModifiesData#endif									   )                , m_callback( NULL ){    // this is used to override the input pin with our own       m_pInput = (CTransInPlaceInputPin*) new CDXFilterInPin( this, phr );    if( !m_pInput )    {        if (phr)            *phr = E_OUTOFMEMORY;    }        // Ensure that the output pin gets created.  This is necessary because our    // SetDeliveryBuffer() method assumes that the input/output pins are created, but    // the output pin isn't created until GetPin() is called.  The     // CTransInPlaceFilter::GetPin() method will create the output pin, since we    // have not already created one.    IPin *pOutput = GetPin(1);    // The pointer is not AddRef'ed by GetPin(), so don't release it}

void PinView::Update () {    PinGraphic* pin = GetPin();    Graphic* pingr = pin;        IncurDamage(pin);    *pingr = *GetPinComp()->GetGraphic();    IncurDamage(pin);    EraseHandles();}

// Handler to respond to pin interruptsstatic void EncoderHandler(void *data) {    tEncoder *enc = data;        // Determine actual value of pins    // and normalize inputs for lookup in a table    int input = (GetPin(enc->pinA) ? 0x1 : 0x0) |                (GetPin(enc->pinB) ? 0x2 : 0x0);        // Add the value in the FSM to the current tick count    // (or substract if invert is set)    if (enc->invert) {        enc->ticks -= enc->decoder->value[input];    } else {        enc->ticks += enc->decoder->value[input];    }    // Setup the next state of the mealy machine    enc->decoder = &DecoderFSM[input];}

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();			}		}*/	}}

VideoCapture::VideoCapture(HWND hWnd){    CoInitialize(NULL);    //	HRESULT hr;    InitVideoFilters();    IPin *pPin = GetPin(m_pBaseFilter, PINDIR_OUTPUT);    ShowFilterProperty(pPin);    StartRender(hWnd);}

HRESULT CMPEGFilter::GetMediaPositionInterface(REFIID riid, void **ppv){    CAutoLock cObjectCreationLock(&m_ObjectCreationLock);	    if (m_pPosition) {        return m_pPosition->NonDelegatingQueryInterface(riid,ppv);    }    HRESULT hr = NOERROR;    // Create implementation of this dynamically since sometimes we may    // never try and do a seek. The helper object implements a position    // control interface (IMediaPosition) which in fact simply takes the    // calls normally from the filter graph and passes them upstream	/*    m_pPosition = new CRendererPosPassThru(NAME("Renderer CPosPassThru"),                                           CBaseFilter::GetOwner(),                                           (HRESULT *) &hr,                                           GetPin(0));*/	m_pPosition = new CMPEGSeeking(NAME("Renderer CPosPassThru"),                                           CBaseFilter::GetOwner(),                                           (HRESULT *) &hr,                                           GetPin(0),										   GetPin(1),										   m_pMPEGObj);    if (m_pPosition == NULL) {        return E_OUTOFMEMORY;    }    if (FAILED(hr)) {        delete m_pPosition;        m_pPosition = NULL;        return E_NOINTERFACE;    }	m_pPosition->AddRef();	*ppv = m_pPosition;    return S_OK;}

void SCH_SCREEN::MarkConnections( SCH_LINE* aSegment ){    wxCHECK_RET( (aSegment) && (aSegment->Type() == SCH_LINE_T),                 wxT( "Invalid object pointer." ) );    for( SCH_ITEM* item = m_drawList.begin(); item; item = item->Next() )    {        if( item->GetFlags() & CANDIDATE )            continue;        if( item->Type() == SCH_JUNCTION_T )        {            SCH_JUNCTION* junction = (SCH_JUNCTION*) item;            if( aSegment->IsEndPoint( junction->GetPosition() ) )                item->SetFlags( CANDIDATE );            continue;        }        if( item->Type() != SCH_LINE_T )            continue;        SCH_LINE* segment = (SCH_LINE*) item;        if( aSegment->IsEndPoint( segment->GetStartPoint() )            && !GetPin( segment->GetStartPoint(), NULL, true ) )        {            item->SetFlags( CANDIDATE );            MarkConnections( segment );        }        if( aSegment->IsEndPoint( segment->GetEndPoint() )            && !GetPin( segment->GetEndPoint(), NULL, true ) )        {            item->SetFlags( CANDIDATE );            MarkConnections( segment );        }    }}

//// If the format changes, we need to reconnect//void CSynthFilter::ReconnectWithNewFormat(void) {    // The caller must hold the state lock because this    // function calls IsConnected().    ASSERT(CritCheckIn(pStateLock()));    // The synth filter's only has one pin.  The pin is an output pin.    CDynamicSourceStream* pOutputPin = (CDynamicSourceStream*)GetPin(0);    if( pOutputPin->IsConnected() ) {        pOutputPin->OutputPinNeedsToBeReconnected();    }}

//----------------------------------------------------------------------------//! @brief	  	
C++ GetPitch函数代码示例
C++ GetPictureScreen函数代码示例