STDMETHODIMP BasePin::ReceiveConnection(IPin * aPin, const AM_MEDIA_TYPE *aMediaType) { if (!aPin) return E_POINTER; if (!aMediaType) E_POINTER; CriticalSectionAutoEnter monitor(*mLock); if (IsConnected()) return VFW_E_ALREADY_CONNECTED; if (!IsStopped()) return VFW_E_NOT_STOPPED; HRESULT hr = CheckConnect(aPin); if (FAILED(hr)) { BreakConnect(); return hr; } // See if subclass supports the specified media type. const MediaType* mediaType = reinterpret_cast<const MediaType*>(aMediaType); hr = CheckMediaType(mediaType); if (FAILED(hr)) { BreakConnect(); return hr; } // Supported, set it. hr = SetMediaType(mediaType); if (FAILED(hr)) return hr; // Complete the connection. mConnectedPin = aPin; // Give the subclass one last chance to refuse the connection. hr = CompleteConnect(aPin); if (FAILED(hr)) { // Subclass refused connection, fail... mConnectedPin = NULL; BreakConnect(); return hr; } // It's all good, we're connected. return S_OK; }
// Attempt to connect this pin to |aPin| using given media type. HRESULT BasePin::AttemptConnection(IPin* aPin, const MediaType* aMediaType) { CriticalSectionAutoEnter monitor(*mLock); // Ensure we can connect to the other pin. Gives subclasses a chance // to prevent connection. HRESULT hr = CheckConnect(aPin); if (FAILED(hr)) { BreakConnect(); return hr; } // Ensure we can connect with this media type. This gives subclasses a // chance to abort the connection. hr = CheckMediaType(aMediaType); if (FAILED(hr)) return hr; hr = SetMediaType(aMediaType); if (FAILED(hr)) return hr; // Ask the other pin if it will accept a connection with our media type. hr = aPin->ReceiveConnection(static_cast<IPin*>(this), aMediaType); if (FAILED(hr)) return hr; // Looks good so far, give subclass one final chance to refuse connection... mConnectedPin = aPin; hr = CompleteConnect(aPin); if (FAILED(hr)) { // Subclass refused the connection, inform the other pin that we're // disconnecting, and break the connection. aPin->Disconnect(); BreakConnect(); mConnectedPin = NULL; mMediaType.Clear(); return VFW_E_TYPE_NOT_ACCEPTED; } // Otherwise, we're all good! return S_OK; }
ErrorCode BasePinImpl::ReceiveConnection(IPin *pConnector, MediaType* pMediaType) { if (pConnector == NULL) { ASSERT(0); //return E_INVALIDARG; throw -1; } if (m_dir != PINDIR_INPUT) { ASSERT(0); return Error; } ErrorCode hr; hr = CheckConnect(pConnector); if (hr < 0) { BreakConnect(); return hr; } hr = CheckMediaType(pMediaType); if (hr < 0) { BreakConnect(); return hr; } // Is the order of these last two correct? SetMediaType(pMediaType); hr = CompleteConnect(pConnector); if (hr < 0) { // BreakConnect(); ?? return hr; } return 0; }
int Connections::CompleteIO(IOCONTEXT* IOContext, DWORD Param) { switch (IOContext->iomode) { case IOMODE_ACCEPT: return CompleteAccept(Param); case IOMODE_CONNECT: return CompleteConnect(Param); case IOMODE_RECV: return CompleteRecv(Param); case IOMODE_SEND: return CompleteSend(Param); default: return -1; //ERR_NET_INVALID_COMPLETE_IO_MODE } }
//----------------------------------------------------------------------------------- // Purpose : // Return : //----------------------------------------------------------------------------------- // Called by Worker TH ( IOCP ) //----------------------------------------------------------------------------------- int CNtlConnection::CompleteIO(sIOCONTEXT * pIOContext, DWORD dwParam) { switch( pIOContext->iomode ) { case IOMODE_ACCEPT: return CompleteAccept( dwParam ); case IOMODE_CONNECT: return CompleteConnect( dwParam ); case IOMODE_RECV: return CompleteRecv( dwParam ); case IOMODE_SEND: return CompleteSend( dwParam ); default: return NTL_ERR_NET_INVALID_COMPLETE_IO_MODE; } }
ErrorCode BasePinImpl::AttemptConnection(IPin *pReceivePin, MediaType* mt) { ErrorCode hr; //CheckConnect( Why Is this called here, it will be called multiple times if it's here? hr = CheckConnect(pReceivePin); if (hr < 0) { BreakConnect(); return hr; } hr = CheckMediaType(mt); if (hr < 0) { BreakConnect(); return hr; } hr = pReceivePin->ReceiveConnection(this, mt); if (hr < 0) return hr; hr = SetMediaType(mt); // ?? Have this here?? if (hr < 0) { BreakConnect(); return hr; } hr = CompleteConnect(pReceivePin); if (hr < 0) { Disconnect(); return hr; } return 0; }
void PVAuthorEngineNodeUtility::NodeCommandCompleted(const PVMFCmdResp& aResponse) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVAuthorEngineNodeUtility::NodeCommandCompleted")); if (iCmdQueue.empty()) { LOG_ERR((0, "PVAuthorEngineNodeUtility::NodeCommandCompleted: Error - Empty command queue")); PVMFAsyncEvent event(PVMFErrorEvent, PVMFFailure, NULL, NULL); iObserver->NodeUtilErrorEvent(event); return; } PVAENodeUtilCmd cmd = iCmdQueue[0]; if (aResponse.GetCmdStatus() != PVMFSuccess) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "PVAuthorEngineNodeUtility::NodeCommandCompleted: Command failed - context=0x%x, status=0x%x", aResponse.GetContext(), aResponse.GetCmdStatus())); CompleteUtilityCmd(cmd, aResponse.GetCmdStatus()); return; } PVMFStatus status = PVMFSuccess; switch (cmd.iType) { case PVAENU_CMD_CONNECT: status = CompleteConnect(cmd, aResponse); break; case PVAENU_CMD_DISCONNECT: status = DoDisconnect(cmd); break; case PVAENU_CMD_QUERY_UUID: status = PVMFSuccess; break; case PVAENU_CMD_QUERY_INTERFACE: status = CompleteQueryInterface(cmd); break; case PVAENU_CMD_INIT: status = CompleteStateTransition(cmd, EPVMFNodeInitialized); break; case PVAENU_CMD_PREPARE: status = CompleteStateTransition(cmd, EPVMFNodePrepared); break; case PVAENU_CMD_START: status = CompleteStateTransition(cmd, EPVMFNodeStarted); break; case PVAENU_CMD_PAUSE: status = CompleteStateTransition(cmd, EPVMFNodePaused); break; case PVAENU_CMD_STOP: case PVAENU_CMD_FLUSH: status = CompleteStateTransition(cmd, EPVMFNodePrepared); break; case PVAENU_CMD_RESET: status = CompleteStateTransition(cmd, EPVMFNodeCreated); break; default: status = PVMFFailure; break; } if (status != PVMFPending) { CompleteUtilityCmd(cmd, status); } else if (iCmdQueue.size() == 1) { // kick off the execution of the command RunIfNotReady(); } }
STDMETHODIMP CBasePin::ReceiveConnection( IPin * pConnector, // this is the pin who we will connect to const AM_MEDIA_TYPE *pmt // this is the media type we will exchange ) { CheckPointer(pConnector,E_POINTER); CheckPointer(pmt,E_POINTER); ValidateReadPtr(pConnector,sizeof(IPin)); ValidateReadPtr(pmt,sizeof(AM_MEDIA_TYPE)); CComAutoLock cObjectLock(m_pLock); #ifdef _DEBUG PIN_INFO PinInfo; if(!FAILED(pConnector->QueryPinInfo(&PinInfo))) { CEasyString PinName=PinInfo.achName; PrintSystemLog(0,"RecvPin:%s",(LPCTSTR)PinName); if(PinInfo.pFilter) { FILTER_INFO FilterInfo; if (!FAILED(PinInfo.pFilter->QueryFilterInfo(&FilterInfo))) { CLSID ClassID; PinInfo.pFilter->GetClassID(&ClassID); CEasyString FilterName=FilterInfo.achName; PrintSystemLog(0,"RecvPinFilter:%s",(LPCTSTR)FilterName); // The FILTER_INFO structure holds a pointer to the Filter Graph // Manager, with a reference count that must be released. if (FilterInfo.pGraph != NULL) { FilterInfo.pGraph->Release(); } } PinInfo.pFilter->Release(); } //MessageBox(NULL, (LPCTSTR)PinName, TEXT("Filter Name"), MB_OK); } #endif /* Are we already connected */ if (m_Connected) { return VFW_E_ALREADY_CONNECTED; } /* See if the filter is active */ if (!IsStopped() && !m_bCanReconnectWhenActive) { return VFW_E_NOT_STOPPED; } HRESULT hr = CheckConnect(pConnector); if (FAILED(hr)) { // Since the procedure is already returning an error code, there // is nothing else this function can do to report the error. EXECUTE_ASSERT( SUCCEEDED( BreakConnect() ) ); return hr; } /* Ask derived class if this media type is ok */ CMediaType * pcmt = (CMediaType*) pmt; hr = CheckMediaType(pcmt); if (hr != NOERROR) { // no -we don't support this media type // Since the procedure is already returning an error code, there // is nothing else this function can do to report the error. EXECUTE_ASSERT( SUCCEEDED( BreakConnect() ) ); // return a specific media type error if there is one // or map a general failure code to something more helpful // (in particular S_FALSE gets changed to an error code) if (SUCCEEDED(hr) || (hr == E_FAIL) || (hr == E_INVALIDARG)) { hr = VFW_E_TYPE_NOT_ACCEPTED; } return hr; } /* Complete the connection */ m_Connected = pConnector; m_Connected->AddRef(); hr = SetMediaType(pcmt); if (SUCCEEDED(hr)) { hr = CompleteConnect(pConnector); if (SUCCEEDED(hr)) { return NOERROR; } } DbgLog((LOG_TRACE, CONNECT_TRACE_LEVEL, TEXT("Failed to set the media type or failed to complete the connection."))); m_Connected->Release(); m_Connected = NULL; // Since the procedure is already returning an error code, there // is nothing else this function can do to report the error. EXECUTE_ASSERT( SUCCEEDED( BreakConnect() ) ); return hr; }
// given a specific media type, attempt a connection (includes // checking that the type is acceptable to this pin) HRESULT CBasePin::AttemptConnection( IPin* pReceivePin, // connect to this pin const CMediaType* pmt // using this type ) { // The caller should hold the filter lock becasue this function // uses m_Connected. The caller should also hold the filter lock // because this function calls SetMediaType(), IsStopped() and // CompleteConnect(). ASSERT(CritCheckIn(m_pLock)); // Check that the connection is valid -- need to do this for every // connect attempt since BreakConnect will undo it. HRESULT hr = CheckConnect(pReceivePin); if (FAILED(hr)) { DbgLog((LOG_TRACE, CONNECT_TRACE_LEVEL, TEXT("CheckConnect failed"))); // Since the procedure is already returning an error code, there // is nothing else this function can do to report the error. EXECUTE_ASSERT( SUCCEEDED( BreakConnect() ) ); return hr; } DisplayTypeInfo(pReceivePin, pmt); /* Check we will accept this media type */ hr = CheckMediaType(pmt); if (hr == NOERROR) { /* Make ourselves look connected otherwise ReceiveConnection may not be able to complete the connection */ m_Connected = pReceivePin; m_Connected->AddRef(); hr = SetMediaType(pmt); if (SUCCEEDED(hr)) { /* See if the other pin will accept this type */ hr = pReceivePin->ReceiveConnection((IPin *)this, pmt); if (SUCCEEDED(hr)) { /* Complete the connection */ hr = CompleteConnect(pReceivePin); if (SUCCEEDED(hr)) { return hr; } else { DbgLog((LOG_TRACE, CONNECT_TRACE_LEVEL, TEXT("Failed to complete connection"))); pReceivePin->Disconnect(); } } } } else { // we cannot use this media type // return a specific media type error if there is one // or map a general failure code to something more helpful // (in particular S_FALSE gets changed to an error code) if (SUCCEEDED(hr) || (hr == E_FAIL) || (hr == E_INVALIDARG)) { hr = VFW_E_TYPE_NOT_ACCEPTED; } } // BreakConnect and release any connection here in case CheckMediaType // failed, or if we set anything up during a call back during // ReceiveConnection. // Since the procedure is already returning an error code, there // is nothing else this function can do to report the error. EXECUTE_ASSERT( SUCCEEDED( BreakConnect() ) ); /* If failed then undo our state */ if (m_Connected) { m_Connected->Release(); m_Connected = NULL; } return hr; }