//---------------------------------------------------------------------------
//
//  Module:   topology.c
//
//  Description:
//
//
//@@BEGIN_MSINTERNAL
//  Development Team:
//     Mike McLaughlin
//
//  History:   Date	  Author      Comment
//
//  To Do:     Date	  Author      Comment
//
//@@END_MSINTERNAL
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  Copyright (c) 1996-1999 Microsoft Corporation.  All Rights Reserved.
//
//---------------------------------------------------------------------------

#include "common.h"

//---------------------------------------------------------------------------

ENUMFUNC
EnumerateTopology(
    IN PPIN_INFO pPinInfo,
    IN NTSTATUS (*Function)(
	IN PTOPOLOGY_CONNECTION pTopologyConnection,
	IN BOOL fToDirection,
	IN OUT PVOID pReference
    ),
    IN OUT PVOID pReference
)
{
    ENUM_TOPOLOGY EnumTopology;
    NTSTATUS Status;

    Assert(pPinInfo);
    EnumTopology.cTopologyRecursion = 0;
    EnumTopology.Function = Function;
    EnumTopology.fToDirection = (pPinInfo->DataFlow == KSPIN_DATAFLOW_IN);
    EnumTopology.pReference = pReference;
    Status = EnumeratePinInfoTopology(pPinInfo, &EnumTopology);
    return(Status);
}

ENUMFUNC
EnumerateGraphTopology(
    IN PSTART_INFO pStartInfo,
    IN NTSTATUS (*Function)(
	IN PTOPOLOGY_CONNECTION pTopologyConnection,
	IN BOOL fToDirection,
	IN OUT PVOID pReference
    ),
    IN OUT PVOID pReference
)
{
    PCONNECT_INFO pConnectInfo;
    NTSTATUS Status;

    Assert(pStartInfo);
    Assert(pStartInfo->GetPinInfo());

    Status = EnumerateTopology(
      pStartInfo->GetPinInfo(),
      Function,
      pReference);

    if(Status != STATUS_CONTINUE) {
	goto exit;
    }
    for(pConnectInfo = pStartInfo->GetFirstConnectInfo();
	pConnectInfo != NULL;
	pConnectInfo = pConnectInfo->GetNextConnectInfo()) {

	Assert(pConnectInfo);
	Status = EnumerateTopology(
	  pConnectInfo->pPinInfoSink,
	  Function,
	  pReference);

	if(Status != STATUS_CONTINUE) {
	    goto exit;
	}
    }
exit:
    return(Status);
}

ENUMFUNC
EnumeratePinInfoTopology(
    IN PPIN_INFO pPinInfo,
    IN PENUM_TOPOLOGY pEnumTopology
)
{
    PTOPOLOGY_CONNECTION pTopologyConnection;
    NTSTATUS Status = STATUS_CONTINUE;

    Assert(pPinInfo);
    Assert(pEnumTopology);
    DPF2(110, "EnumerateTopologyPinInfo %08x #%x", pPinInfo, pPinInfo->PinId);

    FOR_EACH_LIST_ITEM(
      &pPinInfo->lstTopologyConnection,
      pTopologyConnection) {

	Assert(pTopologyConnection);
	if(pEnumTopology->fToDirection) {
	    if(pTopologyConnection->pPinInfoFrom != pPinInfo) {
		continue;
	    }
	    ASSERT(pTopologyConnection->pPinInfoTo != pPinInfo);
	}
	else {
	    if(pTopologyConnection->pPinInfoTo != pPinInfo) {
		continue;
	    }
	    ASSERT(pTopologyConnection->pPinInfoFrom != pPinInfo);
	}
	Status = EnumerateTopologyConnection(
	  pTopologyConnection,
	  pEnumTopology);

	if(Status != STATUS_CONTINUE) {
	    goto exit;
	}

    } END_EACH_LIST_ITEM
exit:
    return(Status);
}

ENUMFUNC
EnumerateTopologyPin(
    IN PTOPOLOGY_PIN pTopologyPin,
    IN PENUM_TOPOLOGY pEnumTopology
)
{
    PTOPOLOGY_CONNECTION pTopologyConnection;
    PTOPOLOGY_PIN pTopologyPin2;
    NTSTATUS Status = STATUS_CONTINUE;
    BOOL fFromPinEqual = TRUE;
    ULONG ulFromPinNumber = MAXULONG;
    BOOL fToPinEqual = TRUE;
    ULONG ulToPinNumber = MAXULONG;
    BOOL fPinEqual;
    ULONG ulPinNumber;

    Assert(pTopologyPin);
    Assert(pEnumTopology);
    DPF3(110, "EnumerateTopologyPin %08x TP #%x TN #%x",
      pTopologyPin, 
      pTopologyPin->ulPinNumber,
      pTopologyPin->pTopologyNode->ulRealNodeNumber);

    if(IsEqualGUID(
      &KSNODETYPE_ACOUSTIC_ECHO_CANCEL,
      pTopologyPin->pTopologyNode->pguidType)) {
	switch(pTopologyPin->ulPinNumber) {
	    case KSNODEPIN_AEC_RENDER_OUT:
		ASSERT(!pEnumTopology->fToDirection);
	    case KSNODEPIN_AEC_RENDER_IN:
		ulFromPinNumber = KSNODEPIN_AEC_RENDER_IN;
		ulToPinNumber = KSNODEPIN_AEC_RENDER_OUT;
		break;

	    case KSNODEPIN_AEC_CAPTURE_OUT:
		ASSERT(!pEnumTopology->fToDirection);
	    case KSNODEPIN_AEC_CAPTURE_IN:
		ulFromPinNumber = KSNODEPIN_AEC_CAPTURE_IN;
		ulToPinNumber = KSNODEPIN_AEC_CAPTURE_OUT;
		break;
	}
    }
    else if(IsEqualGUID(
      &KSNODETYPE_SUM,
      pTopologyPin->pTopologyNode->pguidType) ||

      IsEqualGUID(
      &KSNODETYPE_MUX,
      pTopologyPin->pTopologyNode->pguidType)) {

	ulFromPinNumber = KSNODEPIN_SUM_MUX_IN;
	fFromPinEqual = FALSE;
	ulToPinNumber = KSNODEPIN_SUM_MUX_OUT;
    }
    else if(IsEqualGUID(
      &KSNODETYPE_DEMUX,
      pTopologyPin->pTopologyNode->pguidType)) {

	ulFromPinNumber = KSNODEPIN_DEMUX_IN;
	ulToPinNumber = KSNODEPIN_DEMUX_OUT;
	fToPinEqual = FALSE;
    }
    else {
	ulFromPinNumber = KSNODEPIN_STANDARD_IN;
	ulToPinNumber = KSNODEPIN_STANDARD_OUT;
    }

    // Swap pin numbers and flags
    if(!pEnumTopology->fToDirection) {
       ulPinNumber = ulToPinNumber;
       ulToPinNumber = ulFromPinNumber;
       ulFromPinNumber = ulPinNumber;
       fPinEqual = fToPinEqual;
       fToPinEqual = fFromPinEqual;
       fFromPinEqual = fPinEqual;
    }
    ASSERT(ulToPinNumber != MAXULONG);
    ASSERT(ulFromPinNumber != MAXULONG);

    // Validate input/from pin(s)
    if(fFromPinEqual) {
	if(pTopologyPin->ulPinNumber != ulFromPinNumber) {
	    DPF2(5, "EnumerateTopologyPin: %s bad 'from' pin number %08x",
	      pTopologyPin->pTopologyNode->pFilterNode->DumpName(),
	      pTopologyPin->ulPinNumber);
	    Status = STATUS_INVALID_DEVICE_REQUEST;
	    goto exit;
	}
    }
    else {
	if(pTopologyPin->ulPinNumber < ulFromPinNumber) {
	    DPF2(5, "EnumerateTopologyPin: %s bad 'from' pin number %08x",
	      pTopologyPin->pTopologyNode->pFilterNode->DumpName(),
	      pTopologyPin->ulPinNumber);
	    Status = STATUS_INVALID_DEVICE_REQUEST;
	    goto exit;
	}
    }

    FOR_EACH_LIST_ITEM(
      &pTopologyPin->pTopologyNode->lstTopologyPin,
      pTopologyPin2) {

	if(pTopologyPin == pTopologyPin2) {
	    continue;
	}

	// Pick the right output/to pin(s)
	if(fToPinEqual) {
	    if(pTopologyPin2->ulPinNumber != ulToPinNumber) {
		continue;
	    }
	}
	else {
	    if(pTopologyPin2->ulPinNumber < ulToPinNumber) {
		continue;
	    }
	}

	FOR_EACH_LIST_ITEM(
	  &pTopologyPin2->lstTopologyConnection,
	  pTopologyConnection) {

	    Assert(pTopologyConnection);
	    if(pEnumTopology->fToDirection) {
		if(pTopologyConnection->pTopologyPinFrom != pTopologyPin2) {
		    continue;
		}
		ASSERT(pTopologyConnection->pTopologyPinTo != pTopologyPin2);
	    }
	    else {
		if(pTopologyConnection->pTopologyPinTo != pTopologyPin2) {
		    continue;
		}
		ASSERT(pTopologyConnection->pTopologyPinFrom != pTopologyPin2);
	    }
	    Status = EnumerateTopologyConnection(
	      pTopologyConnection,
	      pEnumTopology);

	    if(Status != STATUS_CONTINUE) {
		goto exit;
	    }

	} END_EACH_LIST_ITEM

    } END_EACH_LIST_ITEM
exit:
    return(Status);
}

ENUMFUNC
EnumerateTopologyConnection(
    IN PTOPOLOGY_CONNECTION pTopologyConnection,
    IN PENUM_TOPOLOGY pEnumTopology
)
{
    PTOPOLOGY_PIN pTopologyPin;
    PPIN_INFO pPinInfo;
    NTSTATUS Status;

    Assert(pEnumTopology);
    Assert(pTopologyConnection);
    DPF1(110, "EnumerateTopologyConnection %08x", pTopologyConnection);

    if(pEnumTopology->cTopologyRecursion++ > (gcTopologyConnections + 16)) {
	Trap();
	DPF(5, "EnumerateTopologyConnection: recursion too deep");
	Status = STATUS_STACK_OVERFLOW;
	goto exit;
    }
    // Have we visited this topology connection already?
    Status = VisitedTopologyConnection(pTopologyConnection, pEnumTopology);
    if(Status != STATUS_CONTINUE) {
	if(Status == STATUS_DEAD_END) {
	    Status = STATUS_CONTINUE;
	}
	goto exit;
    }
    Status = (*pEnumTopology->Function)(
      pTopologyConnection,
      pEnumTopology->fToDirection,
      pEnumTopology->pReference);

    if(Status != STATUS_CONTINUE) {
	if(Status == STATUS_DEAD_END) {
	    Status = STATUS_CONTINUE;
	}
	goto exit;
    }
    if(pEnumTopology->fToDirection) {
       pTopologyPin = pTopologyConnection->pTopologyPinTo;
       pPinInfo = pTopologyConnection->pPinInfoTo;
    }
    else {
       pTopologyPin = pTopologyConnection->pTopologyPinFrom;
       pPinInfo = pTopologyConnection->pPinInfoFrom;
    }
    if(pTopologyPin != NULL) {

	Status = EnumerateTopologyPin(pTopologyPin, pEnumTopology);
	if(Status != STATUS_CONTINUE) {
	    goto exit;
	}
    }
    if(pPinInfo != NULL) {

	Status = EnumeratePinInfoTopology(pPinInfo, pEnumTopology);
	if(Status != STATUS_CONTINUE) {
	    goto exit;
	}
    }
exit:
    pEnumTopology->cTopologyRecursion--;
    return(Status);
}

ENUMFUNC
VisitedTopologyConnection(
    IN PTOPOLOGY_CONNECTION pTopologyConnection,
    IN PENUM_TOPOLOGY pEnumTopology
)
{
    NTSTATUS Status;

    Assert(pEnumTopology);
    Assert(pTopologyConnection);

    // Have we visited this topology connection already?
    if(pTopologyConnection->CheckDupList(
      &pEnumTopology->lstTopologyConnection)) {
	DPF1(100, "VisitedTopologyConnection: %08x already visited",
	  pTopologyConnection);
	Status = STATUS_DEAD_END;
	goto exit;		// yes, break cycle in topology
    }
    // Add topology pin to list of pin's visited
    Status = pTopologyConnection->AddList(
      &pEnumTopology->lstTopologyConnection);
    if(!NT_SUCCESS(Status)) {
	goto exit;
    }
    Status = STATUS_CONTINUE;
exit:
    return(Status);
}

//---------------------------------------------------------------------------