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