1499 lines
39 KiB
C++
1499 lines
39 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// Module: gni.cpp
|
|
//
|
|
// Description:
|
|
//
|
|
// Graph Node Instance
|
|
//
|
|
//@@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"
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
GUID aguidSysAudioCategories[] = {
|
|
STATICGUIDOF(KSCATEGORY_SYSAUDIO)
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
CGraphNodeInstance::CGraphNodeInstance(
|
|
PGRAPH_NODE pGraphNode,
|
|
PFILTER_INSTANCE pFilterInstance
|
|
)
|
|
{
|
|
Assert(pGraphNode);
|
|
Assert(pFilterInstance);
|
|
this->pFilterInstance = pFilterInstance;
|
|
this->ulFlags = pFilterInstance->ulFlags;
|
|
this->pGraphNode = pGraphNode;
|
|
AddList(&pGraphNode->lstGraphNodeInstance);
|
|
}
|
|
|
|
CGraphNodeInstance::CGraphNodeInstance(
|
|
PGRAPH_NODE pGraphNode
|
|
)
|
|
{
|
|
Assert(pGraphNode);
|
|
this->ulFlags = pGraphNode->ulFlags;
|
|
this->pGraphNode = pGraphNode;
|
|
AddList(&pGraphNode->lstGraphNodeInstance);
|
|
}
|
|
|
|
CGraphNodeInstance::~CGraphNodeInstance(
|
|
)
|
|
{
|
|
Assert(this);
|
|
RemoveList();
|
|
if(pFilterInstance != NULL) {
|
|
Assert(pFilterInstance);
|
|
pFilterInstance->pGraphNodeInstance = NULL;
|
|
pFilterInstance->ParentInstance.Invalidate();
|
|
}
|
|
DestroyPinDescriptors();
|
|
DestroySysAudioTopology();
|
|
delete[] paulNodeNumber;
|
|
}
|
|
|
|
NTSTATUS
|
|
CGraphNodeInstance::Create(
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG i, n;
|
|
|
|
if(this == NULL) {
|
|
Status = STATUS_NO_SUCH_DEVICE;
|
|
goto exit;
|
|
}
|
|
Assert(this);
|
|
Assert(pGraphNode);
|
|
|
|
Status = CreatePinDescriptors();
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
Status = CreateSysAudioTopology();
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
if(gcVirtualSources != 0) {
|
|
paulNodeNumber = new ULONG[gcVirtualSources];
|
|
if(paulNodeNumber == NULL) {
|
|
Trap();
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
for(i = 0; i < gcVirtualSources; i++) {
|
|
for(n = 0; n < cTopologyNodes; n++) {
|
|
if(pGraphNode->pDeviceNode->papVirtualSourceData[i]->
|
|
pTopologyNode == papTopologyNode[n]) {
|
|
paulNodeNumber[i] = n;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
CGraphNodeInstance::GetTopologyNodeFileObject(
|
|
OUT PFILE_OBJECT *ppFileObject,
|
|
IN ULONG NodeId
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
if(this == NULL) {
|
|
Status = STATUS_NO_SUCH_DEVICE;
|
|
goto exit;
|
|
}
|
|
Assert(this);
|
|
|
|
if(NodeId >= cTopologyNodes) {
|
|
DPF2(100,
|
|
"GetTopologyNodeFileObject: NodeId(%d) >= cTopologyNodes(%d)",
|
|
NodeId,
|
|
cTopologyNodes);
|
|
Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
goto exit;
|
|
}
|
|
|
|
// If virtual topology node, return error
|
|
if(papTopologyNode[NodeId]->ulRealNodeNumber == MAXULONG) {
|
|
DPF(100, "GetTopologyNodeFileObject: ulRealNodeNumber == MAXULONG");
|
|
Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
goto exit;
|
|
}
|
|
|
|
if(papFilterNodeInstanceTopologyTable == NULL) {
|
|
Trap();
|
|
Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
goto exit;
|
|
}
|
|
|
|
if(papFilterNodeInstanceTopologyTable[NodeId] == NULL) {
|
|
Status = CFilterNodeInstance::Create(
|
|
&papFilterNodeInstanceTopologyTable[NodeId],
|
|
papTopologyNode[NodeId]->lstLogicalFilterNode.GetListFirstData(),
|
|
pGraphNode->pDeviceNode,
|
|
TRUE); // Reuse an instance
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
Assert(papFilterNodeInstanceTopologyTable[NodeId]);
|
|
*ppFileObject = papFilterNodeInstanceTopologyTable[NodeId]->pFileObject;
|
|
|
|
DPF1(110,
|
|
"GetToplogyNodeFileObject: using filter for node: %d\n",
|
|
NodeId);
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
CGraphNodeInstance::CreateSysAudioTopology(
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
Assert(this);
|
|
ASSERT(Topology.TopologyNodes == NULL);
|
|
ASSERT(Topology.TopologyConnections == NULL);
|
|
ASSERT(papFilterNodeInstanceTopologyTable == NULL);
|
|
|
|
Topology.CategoriesCount = SIZEOF_ARRAY(aguidSysAudioCategories);
|
|
Topology.Categories = aguidSysAudioCategories;
|
|
|
|
CreateTopologyTables();
|
|
|
|
if(cTopologyNodes != 0) {
|
|
|
|
Topology.TopologyNodes = new GUID[cTopologyNodes];
|
|
if(Topology.TopologyNodes == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
papFilterNodeInstanceTopologyTable =
|
|
new PFILTER_NODE_INSTANCE[cTopologyNodes];
|
|
|
|
if(papFilterNodeInstanceTopologyTable == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
papTopologyNode = new PTOPOLOGY_NODE[cTopologyNodes];
|
|
if(papTopologyNode == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
}
|
|
if(cTopologyConnections != 0) {
|
|
|
|
Topology.TopologyConnections =
|
|
new KSTOPOLOGY_CONNECTION[cTopologyConnections];
|
|
|
|
if(Topology.TopologyConnections == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
}
|
|
CreateTopologyTables();
|
|
exit:
|
|
if(!NT_SUCCESS(Status)) {
|
|
DestroySysAudioTopology();
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
VOID
|
|
CGraphNodeInstance::DestroySysAudioTopology(
|
|
)
|
|
{
|
|
ULONG n;
|
|
|
|
delete[] (PVOID)Topology.TopologyNodes;
|
|
Topology.TopologyNodes = NULL;
|
|
delete[] (PVOID)Topology.TopologyConnections;
|
|
Topology.TopologyConnections = NULL;
|
|
delete[] papTopologyNode;
|
|
papTopologyNode = NULL;
|
|
|
|
if(papFilterNodeInstanceTopologyTable != NULL) {
|
|
for(n = 0; n < cTopologyNodes; n++) {
|
|
papFilterNodeInstanceTopologyTable[n]->Destroy();
|
|
}
|
|
delete[] papFilterNodeInstanceTopologyTable;
|
|
papFilterNodeInstanceTopologyTable = NULL;
|
|
}
|
|
}
|
|
|
|
typedef ENUMFUNC (CTopologyNode::*CLIST_TN_PFN2)(PVOID, PVOID);
|
|
|
|
VOID
|
|
CGraphNodeInstance::CreateTopologyTables(
|
|
)
|
|
{
|
|
Assert(this);
|
|
Assert(pGraphNode);
|
|
|
|
cTopologyNodes = 0;
|
|
cTopologyConnections = 0;
|
|
|
|
// Initialize the "ulSysaudioNodeNumber" field in the TopologyNodes first
|
|
ProcessLogicalFilterNodeTopologyNode(
|
|
&pGraphNode->pDeviceNode->lstLogicalFilterNode,
|
|
CTopologyNode::InitializeTopologyNode);
|
|
|
|
ProcessLogicalFilterNodeTopologyNode(
|
|
&pGraphNode->lstLogicalFilterNode,
|
|
CTopologyNode::InitializeTopologyNode);
|
|
|
|
// All the nodes need to be processed first so the ulSysaudioNodeNumber in
|
|
// the TopologyNode is correct before any connections are processed.
|
|
ProcessLogicalFilterNodeTopologyNode(
|
|
&pGraphNode->pDeviceNode->lstLogicalFilterNode,
|
|
CTopologyNode::AddTopologyNode);
|
|
|
|
ProcessLogicalFilterNodeTopologyNode(
|
|
&pGraphNode->lstLogicalFilterNode,
|
|
CTopologyNode::AddTopologyNode);
|
|
|
|
// Now process all the topology connection lists
|
|
ProcessLogicalFilterNodeTopologyConnection(
|
|
&pGraphNode->pDeviceNode->lstLogicalFilterNode,
|
|
CTopologyConnection::ProcessTopologyConnection);
|
|
|
|
ProcessLogicalFilterNodeTopologyConnection(
|
|
&pGraphNode->lstLogicalFilterNode,
|
|
CTopologyConnection::ProcessTopologyConnection);
|
|
|
|
pGraphNode->lstTopologyConnection.EnumerateList(
|
|
CTopologyConnection::ProcessTopologyConnection,
|
|
(PVOID)this);
|
|
}
|
|
|
|
VOID
|
|
CGraphNodeInstance::ProcessLogicalFilterNodeTopologyNode(
|
|
PLIST_MULTI_LOGICAL_FILTER_NODE plstLogicalFilterNode,
|
|
NTSTATUS (CTopologyNode::*Function)(
|
|
PVOID pGraphNodeInstance
|
|
)
|
|
)
|
|
{
|
|
PLOGICAL_FILTER_NODE pLogicalFilterNode;
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
plstLogicalFilterNode,
|
|
pLogicalFilterNode) {
|
|
Assert(pLogicalFilterNode);
|
|
pLogicalFilterNode->lstTopologyNode.EnumerateList(Function, this);
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
VOID
|
|
CGraphNodeInstance::ProcessLogicalFilterNodeTopologyConnection(
|
|
PLIST_MULTI_LOGICAL_FILTER_NODE plstLogicalFilterNode,
|
|
NTSTATUS (CTopologyConnection::*Function)(
|
|
PVOID pGraphNodeInstance
|
|
)
|
|
)
|
|
{
|
|
PLOGICAL_FILTER_NODE pLogicalFilterNode;
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
plstLogicalFilterNode,
|
|
pLogicalFilterNode) {
|
|
Assert(pLogicalFilterNode);
|
|
pLogicalFilterNode->lstTopologyConnection.EnumerateList(Function, this);
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
ENUMFUNC
|
|
CTopologyConnection::ProcessTopologyConnection(
|
|
PVOID pReference
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance = (PGRAPH_NODE_INSTANCE)pReference;
|
|
PSTART_NODE pStartNode;
|
|
ULONG ulFromPin;
|
|
ULONG ulFromNode;
|
|
ULONG ulToPin;
|
|
ULONG ulToNode;
|
|
ULONG PinId;
|
|
|
|
Assert(this);
|
|
Assert(pGraphNodeInstance);
|
|
|
|
ulFromPin = MAXULONG;
|
|
ulToPin = MAXULONG;
|
|
#ifdef DEBUG
|
|
ulFromNode = MAXULONG;
|
|
ulToNode = MAXULONG;
|
|
#endif
|
|
|
|
// If the connection doesn't connect LFNs on this GraphNode, skip connection
|
|
if(!IsTopologyConnectionOnGraphNode(pGraphNodeInstance->pGraphNode)) {
|
|
DPF3(100, "ProcessTC: %s TC %08x GN %08x - skip TC",
|
|
pGraphNodeInstance->pGraphNode->pDeviceNode->DumpName(),
|
|
this,
|
|
pGraphNodeInstance->pGraphNode);
|
|
goto exit;
|
|
}
|
|
|
|
if(pTopologyPinFrom != NULL) {
|
|
ulFromNode = pTopologyPinFrom->pTopologyNode->ulSysaudioNodeNumber;
|
|
ulFromPin = pTopologyPinFrom->ulPinNumber;
|
|
|
|
ASSERT(pPinInfoFrom == NULL);
|
|
ASSERT(ulFromNode != MAXULONG);
|
|
ASSERT(ulFromPin != MAXULONG);
|
|
}
|
|
|
|
if(pTopologyPinTo != NULL) {
|
|
ulToNode = pTopologyPinTo->pTopologyNode->ulSysaudioNodeNumber;
|
|
ulToPin = pTopologyPinTo->ulPinNumber;
|
|
|
|
ASSERT(pPinInfoTo == NULL);
|
|
ASSERT(ulToNode != MAXULONG);
|
|
ASSERT(ulToPin != MAXULONG);
|
|
}
|
|
|
|
if(pGraphNodeInstance->aplstStartNode != NULL) {
|
|
|
|
for(PinId = 0; PinId < pGraphNodeInstance->cPins; PinId++) {
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
pGraphNodeInstance->aplstStartNode[PinId],
|
|
pStartNode) {
|
|
|
|
Assert(pStartNode);
|
|
if(pPinInfoFrom != NULL) {
|
|
ASSERT(pTopologyPinFrom == NULL);
|
|
|
|
if(pStartNode->pPinNode->pPinInfo == pPinInfoFrom) {
|
|
// This code assumes that a filter's pininfo will show
|
|
// up in one SAD pin. If a filter exposes more than one
|
|
// major format on the same pin, that pininfo show on
|
|
// two different SAD pins.
|
|
ASSERT(ulFromNode == KSFILTER_NODE);
|
|
ASSERT(ulFromPin == MAXULONG || ulFromPin == PinId);
|
|
|
|
pStartNode->GetStartInfo()->
|
|
ulTopologyConnectionTableIndex =
|
|
pGraphNodeInstance->cTopologyConnections;
|
|
|
|
ulFromNode = KSFILTER_NODE;
|
|
ulFromPin = PinId;
|
|
}
|
|
}
|
|
|
|
if(pPinInfoTo != NULL) {
|
|
ASSERT(pTopologyPinTo == NULL);
|
|
|
|
if(pStartNode->pPinNode->pPinInfo == pPinInfoTo) {
|
|
// See above.
|
|
ASSERT(ulToNode == KSFILTER_NODE);
|
|
ASSERT(ulToPin == MAXULONG || ulToPin == PinId);
|
|
|
|
pStartNode->GetStartInfo()->
|
|
ulTopologyConnectionTableIndex =
|
|
pGraphNodeInstance->cTopologyConnections;
|
|
|
|
ulToNode = KSFILTER_NODE;
|
|
ulToPin = PinId;
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
}
|
|
if(ulFromPin != MAXULONG && ulToPin != MAXULONG) {
|
|
pGraphNodeInstance->AddTopologyConnection(
|
|
ulFromNode,
|
|
ulFromPin,
|
|
ulToNode,
|
|
ulToPin);
|
|
}
|
|
exit:
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
ENUMFUNC
|
|
CTopologyNode::InitializeTopologyNode(
|
|
PVOID pReference
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance = (PGRAPH_NODE_INSTANCE)pReference;
|
|
|
|
Assert(this);
|
|
Assert(pGraphNodeInstance);
|
|
ulSysaudioNodeNumber = MAXULONG;
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
ENUMFUNC
|
|
CTopologyNode::AddTopologyNode(
|
|
PVOID pReference
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance = (PGRAPH_NODE_INSTANCE)pReference;
|
|
|
|
Assert(this);
|
|
Assert(pGraphNodeInstance);
|
|
|
|
// Skip duplicate TopologyNodes
|
|
if(ulSysaudioNodeNumber != MAXULONG) {
|
|
DPF1(100, "AddTopologyNode: dup TN: %08x", this);
|
|
goto exit;
|
|
}
|
|
ulSysaudioNodeNumber = pGraphNodeInstance->cTopologyNodes;
|
|
|
|
if(pGraphNodeInstance->papTopologyNode != NULL) {
|
|
pGraphNodeInstance->papTopologyNode[
|
|
pGraphNodeInstance->cTopologyNodes] = this;
|
|
}
|
|
if(pGraphNodeInstance->Topology.TopologyNodes != NULL) {
|
|
((GUID *)(pGraphNodeInstance->Topology.TopologyNodes))[
|
|
pGraphNodeInstance->cTopologyNodes] = *pguidType;
|
|
}
|
|
DPF3(115, "AddTopologyNode: %02x GNI: %08x TN: %08x",
|
|
pGraphNodeInstance->cTopologyNodes,
|
|
pGraphNodeInstance,
|
|
this);
|
|
|
|
++pGraphNodeInstance->cTopologyNodes;
|
|
exit:
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
VOID
|
|
CGraphNodeInstance::AddTopologyConnection(
|
|
ULONG ulFromNode,
|
|
ULONG ulFromPin,
|
|
ULONG ulToNode,
|
|
ULONG ulToPin
|
|
)
|
|
{
|
|
Assert(this);
|
|
if(Topology.TopologyConnections != NULL) {
|
|
PKSTOPOLOGY_CONNECTION pKSTopologyConnection =
|
|
(PKSTOPOLOGY_CONNECTION)&Topology.TopologyConnections[
|
|
cTopologyConnections];
|
|
|
|
pKSTopologyConnection->FromNode = ulFromNode;
|
|
pKSTopologyConnection->FromNodePin = ulFromPin;
|
|
pKSTopologyConnection->ToNode = ulToNode;
|
|
pKSTopologyConnection->ToNodePin = ulToPin;
|
|
}
|
|
++cTopologyConnections;
|
|
|
|
DPF4(115, "AddTopologyConnection: FN:%02x FNP:%02x TN:%02x TNP:%02x",
|
|
ulFromNode,
|
|
ulFromPin,
|
|
ulToNode,
|
|
ulToPin);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
CGraphNodeInstance::CreatePinDescriptors(
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ListDataAssertLess<LIST_DATA_START_NODE> lstStartNodeLists;
|
|
ListDataAssertLess<KSDATARANGE> lstDataRange;
|
|
PLIST_DATA_START_NODE plstStartNodeOrdered;
|
|
PSTART_NODE pStartNodeSorted;
|
|
PSTART_NODE pStartNode;
|
|
BOOL fSorted;
|
|
ULONG PinId;
|
|
|
|
Assert(this);
|
|
Assert(pGraphNode);
|
|
ASSERT(paPinDescriptors == NULL);
|
|
ASSERT(aplstStartNode == NULL);
|
|
ASSERT(palstTopologyNodeSelect == NULL);
|
|
ASSERT(palstTopologyNodeNotSelect == NULL);
|
|
ASSERT(pacPinInstances == NULL);
|
|
ASSERT(pulPinFlags == NULL);
|
|
ASSERT(cPins == 0);
|
|
|
|
#ifdef REGISTRY_PREFERRED_DEVICE
|
|
// Clear the graph node preferred device type bits
|
|
pGraphNode->ulFlags &= ~GN_FLAGS_PREFERRED_MASK;
|
|
#endif
|
|
// Sort StartNodes by Communication, DataFlow and Major Format GUID
|
|
FOR_EACH_LIST_ITEM(&pGraphNode->lstStartNode, pStartNode) {
|
|
Assert(pStartNode->pPinNode);
|
|
Assert(pStartNode->pPinNode->pPinInfo);
|
|
|
|
// Skip any start nodes with no data range
|
|
if(pStartNode->pPinNode->pDataRange == NULL) {
|
|
Trap();
|
|
continue;
|
|
}
|
|
// Skip any start nodes with no instances left on the pin
|
|
if(ulFlags & FLAGS_COMBINE_PINS) {
|
|
if(pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SINK ||
|
|
pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SOURCE ||
|
|
pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH) {
|
|
|
|
if(!pStartNode->IsPossibleInstances()) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
fSorted = FALSE;
|
|
FOR_EACH_LIST_ITEM(&lstStartNodeLists, plstStartNodeOrdered) {
|
|
|
|
FOR_EACH_LIST_ITEM(plstStartNodeOrdered, pStartNodeSorted) {
|
|
Assert(pStartNodeSorted);
|
|
Assert(pStartNodeSorted->pPinNode);
|
|
Assert(pStartNodeSorted->pPinNode->pPinInfo);
|
|
|
|
// If the same actual pin, combine the pin nodes
|
|
if((pStartNode->pPinNode->pPinInfo ==
|
|
pStartNodeSorted->pPinNode->pPinInfo) ||
|
|
|
|
// Combine only if client wants it that way
|
|
(ulFlags & FLAGS_COMBINE_PINS) &&
|
|
|
|
// Combine only AUDIO major formats
|
|
IsEqualGUID(
|
|
&pStartNode->pPinNode->pDataRange->MajorFormat,
|
|
&KSDATAFORMAT_TYPE_AUDIO) &&
|
|
|
|
// Only combine SINK, SOURCE, BOTH StartNodes; keep
|
|
// NONE and BRIDGE as separate SAD pins
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SINK) ||
|
|
(pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SOURCE) ||
|
|
(pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH)) &&
|
|
|
|
// Combine if same data flow
|
|
(pStartNode->pPinNode->pPinInfo->DataFlow ==
|
|
pStartNodeSorted->pPinNode->pPinInfo->DataFlow) &&
|
|
|
|
// Combine if same communication type OR
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
pStartNodeSorted->pPinNode->pPinInfo->Communication) ||
|
|
|
|
// Combine a SINK and a BOTH
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SINK) &&
|
|
(pStartNodeSorted->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH)) ||
|
|
|
|
// Combine a BOTH and a SINK
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH) &&
|
|
(pStartNodeSorted->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SINK)) ||
|
|
|
|
// Combine a SOURCE and a BOTH
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SOURCE) &&
|
|
(pStartNodeSorted->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH)) ||
|
|
|
|
// Combine a BOTH and a SOURCE
|
|
((pStartNode->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_BOTH) &&
|
|
(pStartNodeSorted->pPinNode->pPinInfo->Communication ==
|
|
KSPIN_COMMUNICATION_SOURCE))) &&
|
|
|
|
// Combine if major format is the same
|
|
IsEqualGUID(
|
|
&pStartNode->pPinNode->pDataRange->MajorFormat,
|
|
&pStartNodeSorted->pPinNode->pDataRange->MajorFormat)) {
|
|
|
|
Status = plstStartNodeOrdered->AddListOrdered(
|
|
pStartNode,
|
|
FIELD_OFFSET(START_NODE, ulOverhead));
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
fSorted = TRUE;
|
|
break;
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if(fSorted) {
|
|
break;
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if(!fSorted) {
|
|
plstStartNodeOrdered = new LIST_DATA_START_NODE;
|
|
if(plstStartNodeOrdered == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
Status = plstStartNodeOrdered->AddListOrdered(
|
|
pStartNode,
|
|
FIELD_OFFSET(START_NODE, ulOverhead));
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
Status = lstStartNodeLists.AddList(plstStartNodeOrdered);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
// Allocate the pin descriptors, pin instance and start node arrays
|
|
cPins = lstStartNodeLists.CountList();
|
|
|
|
// if there are no pins, exit
|
|
if(cPins == 0) {
|
|
goto exit;
|
|
}
|
|
|
|
paPinDescriptors = new KSPIN_DESCRIPTOR[cPins];
|
|
if(paPinDescriptors == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
aplstStartNode = new PLIST_DATA_START_NODE[cPins];
|
|
if(aplstStartNode == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
DPF1(100, "CreatePinDescriptors: cPins %d", cPins);
|
|
|
|
// For each pin, create a list of interfaces, mediums and dataranges
|
|
PinId = 0;
|
|
FOR_EACH_LIST_ITEM(&lstStartNodeLists, plstStartNodeOrdered) {
|
|
PKSDATARANGE pDataRange, *apDataRanges;
|
|
BOOL fBoth = TRUE;
|
|
|
|
ASSERT(PinId < cPins);
|
|
ASSERT(!plstStartNodeOrdered->IsLstEmpty());
|
|
aplstStartNode[PinId] = plstStartNodeOrdered;
|
|
|
|
FOR_EACH_LIST_ITEM(plstStartNodeOrdered, pStartNode) {
|
|
Assert(pStartNode);
|
|
Assert(pStartNode->pPinNode);
|
|
Assert(pStartNode->pPinNode->pPinInfo);
|
|
|
|
paPinDescriptors[PinId].DataFlow =
|
|
pStartNode->pPinNode->pPinInfo->DataFlow;
|
|
|
|
if(pStartNode->pPinNode->pPinInfo->Communication !=
|
|
KSPIN_COMMUNICATION_BOTH) {
|
|
fBoth = FALSE;
|
|
paPinDescriptors[PinId].Communication =
|
|
pStartNode->pPinNode->pPinInfo->Communication;
|
|
}
|
|
|
|
if(paPinDescriptors[PinId].Category == NULL ||
|
|
IsEqualGUID(
|
|
paPinDescriptors[PinId].Category,
|
|
&GUID_NULL)) {
|
|
|
|
paPinDescriptors[PinId].Category =
|
|
pStartNode->pPinNode->pPinInfo->pguidCategory;
|
|
|
|
paPinDescriptors[PinId].Name =
|
|
pStartNode->pPinNode->pPinInfo->pguidName;
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if(fBoth) {
|
|
paPinDescriptors[PinId].Communication = KSPIN_COMMUNICATION_SINK;
|
|
}
|
|
|
|
// Make a list of all the DataRanges this pin will support
|
|
Status = plstStartNodeOrdered->CreateUniqueList(
|
|
&lstDataRange,
|
|
(UNIQUE_LIST_PFN)GetStartNodeDataRange,
|
|
(UNIQUE_LIST_PFN2)CompareDataRangeExact);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
// Put the number of data ranges into the pin descriptor
|
|
paPinDescriptors[PinId].DataRangesCount = lstDataRange.CountList();
|
|
if(paPinDescriptors[PinId].DataRangesCount != 0) {
|
|
|
|
// Allocate the array of ptrs to DataRanges; put it into the desc
|
|
paPinDescriptors[PinId].DataRanges = new PKSDATARANGE[
|
|
paPinDescriptors[PinId].DataRangesCount];
|
|
|
|
if(paPinDescriptors[PinId].DataRanges == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
// Put each data range pointer into the array
|
|
apDataRanges = (PKSDATARANGE *)paPinDescriptors[PinId].DataRanges;
|
|
|
|
FOR_EACH_LIST_ITEM(&lstDataRange, pDataRange) {
|
|
|
|
#ifdef REGISTRY_PREFERRED_DEVICE
|
|
if(IsEqualGUID(
|
|
&pDataRange->MajorFormat,
|
|
&KSDATAFORMAT_TYPE_AUDIO) &&
|
|
IsEqualGUID(
|
|
&pDataRange->SubFormat,
|
|
&KSDATAFORMAT_SUBTYPE_PCM)) {
|
|
|
|
if(paPinDescriptors[PinId].DataFlow == KSPIN_DATAFLOW_IN) {
|
|
pGraphNode->ulFlags |= GN_FLAGS_PLAYBACK;
|
|
}
|
|
else {
|
|
pGraphNode->ulFlags |= GN_FLAGS_RECORD;
|
|
}
|
|
}
|
|
|
|
if(IsEqualGUID(
|
|
&pDataRange->MajorFormat,
|
|
&KSDATAFORMAT_TYPE_MUSIC) &&
|
|
IsEqualGUID(
|
|
&pDataRange->SubFormat,
|
|
&KSDATAFORMAT_SUBTYPE_MIDI)) {
|
|
|
|
if(paPinDescriptors[PinId].DataFlow == KSPIN_DATAFLOW_IN) {
|
|
pGraphNode->ulFlags |= GN_FLAGS_MIDI;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
*apDataRanges = pDataRange;
|
|
apDataRanges++;
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
// Destroy the data range list
|
|
lstDataRange.DestroyList();
|
|
|
|
// Create the interface array for the pin descriptor
|
|
Status = CreateIdentifierArray(
|
|
plstStartNodeOrdered,
|
|
&paPinDescriptors[PinId].InterfacesCount,
|
|
(PKSIDENTIFIER *)&paPinDescriptors[PinId].Interfaces,
|
|
GetStartNodeInterface);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
// Create the medium array for the pin descriptor
|
|
Status = CreateIdentifierArray(
|
|
plstStartNodeOrdered,
|
|
&paPinDescriptors[PinId].MediumsCount,
|
|
(PKSIDENTIFIER *)&paPinDescriptors[PinId].Mediums,
|
|
GetStartNodeMedium);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
DPF6(100, "PinId %d DataFlow %d cD %d cI %d cM %d cSN %d",
|
|
PinId,
|
|
paPinDescriptors[PinId].DataFlow,
|
|
paPinDescriptors[PinId].DataRangesCount,
|
|
paPinDescriptors[PinId].InterfacesCount,
|
|
paPinDescriptors[PinId].MediumsCount,
|
|
aplstStartNode[PinId]->CountList());
|
|
|
|
// Next pin number
|
|
PinId++;
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if((ulFlags & FLAGS_MIXER_TOPOLOGY) == 0) {
|
|
palstTopologyNodeSelect = new LIST_DATA_TOPOLOGY_NODE[cPins];
|
|
if(palstTopologyNodeSelect == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
palstTopologyNodeNotSelect = new LIST_DATA_TOPOLOGY_NODE[cPins];
|
|
if(palstTopologyNodeNotSelect == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
PLOGICAL_FILTER_NODE pLogicalFilterNode;
|
|
PTOPOLOGY_NODE pTopologyNode;
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
&pGraphNode->lstLogicalFilterNode,
|
|
pLogicalFilterNode) {
|
|
|
|
if(pLogicalFilterNode->GetFlags() & LFN_FLAGS_NOT_SELECT) {
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
&pLogicalFilterNode->lstTopologyNode,
|
|
pTopologyNode) {
|
|
|
|
for(PinId = 0; PinId < cPins; PinId++) {
|
|
Status = palstTopologyNodeNotSelect[PinId].AddList(
|
|
pTopologyNode);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
pacPinInstances = new KSPIN_CINSTANCES[cPins];
|
|
if(pacPinInstances == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
pulPinFlags = new ULONG[cPins];
|
|
if (NULL == pulPinFlags) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
for(PinId = 0; PinId < cPins; PinId++) {
|
|
LIST_DATA_GRAPH_PIN_INFO lstGraphPinInfo;
|
|
PSTART_NODE pStartNode2;
|
|
PPIN_INFO pPinInfo;
|
|
BOOL fHWRender = TRUE;
|
|
|
|
FOR_EACH_LIST_ITEM(aplstStartNode[PinId], pStartNode2) {
|
|
PGRAPH_PIN_INFO pGraphPinInfo;
|
|
|
|
pGraphPinInfo = pStartNode2->GetGraphPinInfo();
|
|
Assert(pGraphPinInfo);
|
|
|
|
//
|
|
// Set pin type.
|
|
// If all startnodes are connected directly to renderer.
|
|
//
|
|
pPinInfo = pGraphPinInfo->GetPinInfo();
|
|
|
|
ASSERT(pPinInfo);
|
|
if ((!(pPinInfo->pFilterNode->GetType() & FILTER_TYPE_RENDERER)) ||
|
|
(KSPIN_DATAFLOW_IN != pPinInfo->DataFlow) ||
|
|
(KSPIN_COMMUNICATION_SINK != pPinInfo->Communication)) {
|
|
fHWRender = FALSE;
|
|
}
|
|
|
|
if(lstGraphPinInfo.CheckDupList(pGraphPinInfo)) {
|
|
continue;
|
|
}
|
|
|
|
Status = lstGraphPinInfo.AddList(pGraphPinInfo);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Set cinstances.
|
|
//
|
|
if(pGraphPinInfo->IsPinReserved()) {
|
|
pacPinInstances[PinId].CurrentCount = 1;
|
|
}
|
|
if(pGraphPinInfo->GetPinInstances()->PossibleCount == MAXULONG) {
|
|
pacPinInstances[PinId].PossibleCount = MAXULONG;
|
|
break;
|
|
}
|
|
pacPinInstances[PinId].PossibleCount +=
|
|
pGraphPinInfo->GetPinInstances()->PossibleCount;
|
|
|
|
if (fHWRender) {
|
|
fHWRender = (1 < pGraphPinInfo->GetPinInstances()->PossibleCount);
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
pulPinFlags[PinId] = fHWRender;
|
|
|
|
lstGraphPinInfo.DestroyList();
|
|
}
|
|
|
|
exit:
|
|
if(!NT_SUCCESS(Status)) {
|
|
DestroyPinDescriptors();
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
VOID
|
|
CGraphNodeInstance::DestroyPinDescriptors(
|
|
)
|
|
{
|
|
ULONG PinId;
|
|
|
|
Assert(this);
|
|
for(PinId = 0; PinId < cPins; PinId++) {
|
|
if(paPinDescriptors != NULL) {
|
|
delete (PVOID)paPinDescriptors[PinId].DataRanges;
|
|
if(paPinDescriptors[PinId].InterfacesCount > 1) {
|
|
delete (PVOID)paPinDescriptors[PinId].Interfaces;
|
|
}
|
|
if(paPinDescriptors[PinId].MediumsCount > 1) {
|
|
delete (PVOID)paPinDescriptors[PinId].Mediums;
|
|
}
|
|
}
|
|
if(aplstStartNode != NULL) {
|
|
delete aplstStartNode[PinId];
|
|
}
|
|
}
|
|
delete[cPins] aplstStartNode;
|
|
aplstStartNode = NULL;
|
|
delete[cPins] paPinDescriptors;
|
|
paPinDescriptors = NULL;
|
|
delete[cPins] palstTopologyNodeSelect;
|
|
palstTopologyNodeSelect = NULL;
|
|
delete[cPins] palstTopologyNodeNotSelect;
|
|
palstTopologyNodeNotSelect = NULL;
|
|
delete[cPins] pacPinInstances;
|
|
pacPinInstances = NULL;
|
|
delete[cPins] pulPinFlags;
|
|
pulPinFlags = NULL;
|
|
}
|
|
|
|
NTSTATUS
|
|
CreateIdentifierArray(
|
|
PLIST_DATA_START_NODE plstStartNode,
|
|
PULONG pulCount,
|
|
PKSIDENTIFIER *ppIdentifier,
|
|
PKSIDENTIFIER (*GetFunction)(
|
|
PSTART_NODE pStartNode
|
|
)
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
KSIDENTIFIER *pIdentifier1, *pIdentifier2;
|
|
ListDataAssertLess<KSIDENTIFIER> lstIdentifier;
|
|
|
|
Status = plstStartNode->CreateUniqueList(
|
|
&lstIdentifier,
|
|
(UNIQUE_LIST_PFN)GetFunction,
|
|
(UNIQUE_LIST_PFN2)CompareIdentifier);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
if((*pulCount = lstIdentifier.CountList()) == 0) {
|
|
*ppIdentifier = NULL;
|
|
}
|
|
else {
|
|
if(*pulCount == 1) {
|
|
*ppIdentifier = lstIdentifier.GetListFirstData();
|
|
}
|
|
else {
|
|
*ppIdentifier = new KSIDENTIFIER[*pulCount];
|
|
if(*ppIdentifier == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
pIdentifier1 = *ppIdentifier;
|
|
AssertAligned(pIdentifier1);
|
|
FOR_EACH_LIST_ITEM(&lstIdentifier, pIdentifier2) {
|
|
AssertAligned(pIdentifier1);
|
|
AssertAligned(pIdentifier2);
|
|
RtlCopyMemory(pIdentifier1, pIdentifier2, sizeof(KSIDENTIFIER));
|
|
pIdentifier1++;
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
}
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
PKSDATARANGE
|
|
GetStartNodeDataRange(
|
|
PSTART_NODE pStartNode
|
|
)
|
|
{
|
|
return(pStartNode->pPinNode->pDataRange);
|
|
}
|
|
|
|
PKSIDENTIFIER
|
|
GetStartNodeInterface(
|
|
PSTART_NODE pStartNode
|
|
)
|
|
{
|
|
return(pStartNode->pPinNode->pInterface);
|
|
}
|
|
|
|
PKSIDENTIFIER
|
|
GetStartNodeMedium(
|
|
PSTART_NODE pStartNode
|
|
)
|
|
{
|
|
return(pStartNode->pPinNode->pMedium);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
ENUMFUNC
|
|
FindTopologyNode(
|
|
IN PTOPOLOGY_CONNECTION pTopologyConnection,
|
|
IN BOOL fToDirection,
|
|
IN PTOPOLOGY_NODE pTopologyNode
|
|
)
|
|
{
|
|
Assert(pTopologyConnection);
|
|
|
|
if(IS_CONNECTION_TYPE(pTopologyConnection, GRAPH)) {
|
|
return(STATUS_DEAD_END);
|
|
}
|
|
if(fToDirection) {
|
|
if(pTopologyConnection->pTopologyPinTo != NULL) {
|
|
if(pTopologyNode ==
|
|
pTopologyConnection->pTopologyPinTo->pTopologyNode) {
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if(pTopologyConnection->pTopologyPinFrom != NULL) {
|
|
if(pTopologyNode ==
|
|
pTopologyConnection->pTopologyPinFrom->pTopologyNode) {
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
}
|
|
}
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
BOOL
|
|
CGraphNodeInstance::IsGraphValid(
|
|
PSTART_NODE pStartNode,
|
|
ULONG PinId
|
|
)
|
|
{
|
|
PFILTER_INSTANCE pFilterInstance;
|
|
PTOPOLOGY_NODE pTopologyNode;
|
|
BOOL fCheck;
|
|
|
|
Assert(this);
|
|
Assert(pGraphNode);
|
|
Assert(pStartNode);
|
|
Assert(pStartNode->pPinNode);
|
|
Assert(pStartNode->pPinNode->pPinInfo);
|
|
Assert(pGraphNode->pDeviceNode);
|
|
ASSERT(PinId < cPins);
|
|
|
|
if(pStartNode->pPinNode->pPinInfo->DataFlow == KSPIN_DATAFLOW_IN) {
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
&pGraphNode->pDeviceNode->lstFilterInstance,
|
|
pFilterInstance) {
|
|
|
|
if(pFilterInstance->pGraphNodeInstance == NULL) {
|
|
continue;
|
|
}
|
|
Assert(pFilterInstance->pGraphNodeInstance);
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
&pFilterInstance->pGraphNodeInstance->lstTopologyNodeGlobalSelect,
|
|
pTopologyNode) {
|
|
|
|
if(EnumerateGraphTopology(
|
|
pStartNode->GetStartInfo(),
|
|
(TOP_PFN)FindTopologyNode,
|
|
pTopologyNode) == STATUS_CONTINUE) {
|
|
|
|
DPF2(80,
|
|
"IsGraphValid: TN %08x SN %08x not found Global",
|
|
pTopologyNode,
|
|
pStartNode);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
if (palstTopologyNodeSelect) {
|
|
FOR_EACH_LIST_ITEM(&palstTopologyNodeSelect[PinId], pTopologyNode) {
|
|
|
|
if(EnumerateGraphTopology(
|
|
pStartNode->GetStartInfo(),
|
|
(TOP_PFN)FindTopologyNode,
|
|
pTopologyNode) == STATUS_CONTINUE) {
|
|
|
|
DPF2(80, "IsGraphValid: TN %08x SN %08x not found Select",
|
|
pTopologyNode,
|
|
pStartNode);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
// If a NotSelectNode is in the GlobalSelectList of another FilterInstance,
|
|
// don't consider this as an invalid Graph.
|
|
// This behaves like an implicit SelectGraph.
|
|
//
|
|
if (palstTopologyNodeNotSelect) {
|
|
FOR_EACH_LIST_ITEM(&palstTopologyNodeNotSelect[PinId], pTopologyNode) {
|
|
|
|
fCheck = TRUE;
|
|
if(pStartNode->pPinNode->pPinInfo->DataFlow == KSPIN_DATAFLOW_IN) {
|
|
|
|
FOR_EACH_LIST_ITEM(
|
|
&pGraphNode->pDeviceNode->lstFilterInstance,
|
|
pFilterInstance) {
|
|
|
|
if(pFilterInstance->pGraphNodeInstance == NULL) {
|
|
continue;
|
|
}
|
|
Assert(pFilterInstance->pGraphNodeInstance);
|
|
|
|
// Is this NotSelectNode in the GlobalSelectList of
|
|
// another FilterInstance.
|
|
// Remove it from NotSelectList and add it to
|
|
// GlobalSelectList for this filter as well.
|
|
//
|
|
if(pFilterInstance->pGraphNodeInstance->
|
|
lstTopologyNodeGlobalSelect.EnumerateList(
|
|
CTopologyNode::MatchTopologyNode,
|
|
pTopologyNode) == STATUS_SUCCESS) {
|
|
|
|
if (NT_SUCCESS(lstTopologyNodeGlobalSelect.
|
|
AddListDup(pTopologyNode))) {
|
|
|
|
palstTopologyNodeNotSelect[PinId].
|
|
RemoveList(pTopologyNode);
|
|
|
|
DPF2(50, "Removing TN %X %s",
|
|
pTopologyNode,
|
|
pTopologyNode->pFilterNode->DumpName());
|
|
}
|
|
else {
|
|
DPF2(4, "Failed to add TN %X to GNI %X GlobalSelectList",
|
|
pTopologyNode,
|
|
this);
|
|
Trap();
|
|
}
|
|
|
|
fCheck = FALSE;
|
|
break;
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
if(fCheck) {
|
|
if(EnumerateGraphTopology(
|
|
pStartNode->GetStartInfo(),
|
|
(TOP_PFN)FindTopologyNode,
|
|
pTopologyNode) == STATUS_SUCCESS) {
|
|
|
|
DPF2(80, "IsGraphValid: TN %08x SN %08x found NotSelect",
|
|
pTopologyNode,
|
|
pStartNode);
|
|
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
NTSTATUS
|
|
CGraphNodeInstance::GetPinInstances(
|
|
PIRP pIrp,
|
|
PKSP_PIN pPin,
|
|
PKSPIN_CINSTANCES pcInstances
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG ulPinId = pPin->PinId;
|
|
|
|
//
|
|
// For HW Accelerated pins, send the request to HW filter.
|
|
//
|
|
if (pulPinFlags[ulPinId]) {
|
|
PSTART_NODE pStartNode;
|
|
PPIN_INFO pPinInfo;
|
|
ULONG BytesReturned;
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PFILTER_NODE_INSTANCE pFilterNodeInstance = NULL;
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
|
|
pStartNode = aplstStartNode[ulPinId]->GetListFirstData();
|
|
|
|
pPinInfo = pStartNode->pPinNode->pPinInfo;
|
|
|
|
Status = CFilterNodeInstance::Create(
|
|
&pFilterNodeInstance,
|
|
pStartNode->pPinNode->pLogicalFilterNode,
|
|
pGraphNode->pDeviceNode,
|
|
TRUE);
|
|
|
|
if(NT_SUCCESS(Status)) {
|
|
pPin->PinId = pPinInfo->PinId;
|
|
pPin->Property.Id = KSPROPERTY_PIN_CINSTANCES;
|
|
|
|
AssertFileObject(pFilterNodeInstance->pFileObject);
|
|
Status = KsSynchronousIoControlDevice(
|
|
pFilterNodeInstance->pFileObject,
|
|
KernelMode,
|
|
IOCTL_KS_PROPERTY,
|
|
pPin,
|
|
pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
|
|
pcInstances,
|
|
pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
|
|
&BytesReturned);
|
|
|
|
if(NT_SUCCESS(Status)) {
|
|
pIrp->IoStatus.Information = BytesReturned;
|
|
}
|
|
|
|
if (pFilterNodeInstance) {
|
|
pFilterNodeInstance->Destroy();
|
|
}
|
|
}
|
|
else {
|
|
DPF2(10, "GetPinInstances FAILS %08x %s",
|
|
Status,
|
|
pPinInfo->pFilterNode->DumpName());
|
|
}
|
|
}
|
|
//
|
|
// For other pins use the cached instances
|
|
//
|
|
else {
|
|
Status = STATUS_SUCCESS;
|
|
*pcInstances = pacPinInstances[ulPinId];
|
|
}
|
|
|
|
return Status;
|
|
} // GetPinInstances
|
|
|
|
|
|
BOOL
|
|
CGraphNodeInstance::IsPinInstances(
|
|
ULONG ulPinId)
|
|
{
|
|
//
|
|
// For HW Accelerated pins, always allow further operations.
|
|
//
|
|
if (pulPinFlags[ulPinId]) {
|
|
return TRUE;
|
|
}
|
|
//
|
|
// For other pins check cached instances.
|
|
//
|
|
else
|
|
{
|
|
if(pacPinInstances[ulPinId].CurrentCount >=
|
|
pacPinInstances[ulPinId].PossibleCount) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} // IsPinInstances
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
#ifdef DEBUG
|
|
|
|
ENUMFUNC
|
|
CGraphNodeInstance::Dump()
|
|
{
|
|
// .siv
|
|
if(ulDebugFlags & (DEBUG_FLAGS_VERBOSE | DEBUG_FLAGS_OBJECT)) {
|
|
dprintf("GNI: %08x GN %08x FI %08x cPins %u cTN %u cTC %u paulNN ",
|
|
this,
|
|
pGraphNode,
|
|
pFilterInstance,
|
|
cPins,
|
|
cTopologyNodes,
|
|
cTopologyConnections);
|
|
for(ULONG i = 0; i < gcVirtualSources; i++) {
|
|
dprintf("%02x ", paulNodeNumber[i]);
|
|
}
|
|
dprintf("\n paPinDesc: %08x papTN %08x ulFlags %08x ",
|
|
paPinDescriptors,
|
|
papTopologyNode,
|
|
ulFlags);
|
|
if(ulFlags & FLAGS_COMBINE_PINS) {
|
|
dprintf("COMBINE_PINS ");
|
|
}
|
|
if(ulFlags & FLAGS_MIXER_TOPOLOGY) {
|
|
dprintf("MIXER_TOPOLOGY ");
|
|
}
|
|
dprintf("\n aplstSN: %08x papFNI %08x palstTN %08x !%08x\n",
|
|
aplstStartNode,
|
|
papFilterNodeInstanceTopologyTable,
|
|
palstTopologyNodeSelect,
|
|
palstTopologyNodeNotSelect);
|
|
|
|
dprintf(" pacPI: %08x ", pacPinInstances);
|
|
for(ULONG p = 0; p < cPins; p++) {
|
|
dprintf("[C%dP%d]",
|
|
pacPinInstances[p].CurrentCount,
|
|
pacPinInstances[p].PossibleCount);
|
|
}
|
|
dprintf("\n lstTNGlobalSelect:");
|
|
lstTopologyNodeGlobalSelect.DumpAddress();
|
|
|
|
dprintf("\n lstSNI:");
|
|
// .sivx
|
|
if(ulDebugFlags & DEBUG_FLAGS_DETAILS) {
|
|
dprintf("\n");
|
|
lstStartNodeInstance.Dump();
|
|
}
|
|
else {
|
|
lstStartNodeInstance.DumpAddress();
|
|
dprintf("\n");
|
|
}
|
|
}
|
|
// .sit
|
|
if(ulDebugFlags & DEBUG_FLAGS_TOPOLOGY) {
|
|
dprintf("GNI: %08x\n", this);
|
|
for(ULONG i = 0; i < cTopologyNodes; i++) {
|
|
if(papFilterNodeInstanceTopologyTable[i] != NULL) {
|
|
dprintf(" %02x FNI %08x %s\n",
|
|
i,
|
|
papFilterNodeInstanceTopologyTable[i],
|
|
papTopologyNode[i]->pFilterNode->DumpName());
|
|
}
|
|
}
|
|
}
|
|
// .sip
|
|
if(ulDebugFlags & DEBUG_FLAGS_PIN) {
|
|
dprintf("GNI: %08x\n", this);
|
|
DumpPinDescriptors();
|
|
}
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
extern PSZ apszDataFlow[];
|
|
extern PSZ apszCommunication[];
|
|
|
|
VOID
|
|
CGraphNodeInstance::DumpPinDescriptors(
|
|
)
|
|
{
|
|
ULONG p, i, m, d;
|
|
|
|
Assert(this);
|
|
for(p = 0; p < cPins; p++) {
|
|
dprintf(
|
|
"PinId: %d DataFlow %08x %s Comm %08x %s cPossible %d cCurrent %d\n",
|
|
p,
|
|
paPinDescriptors[p].DataFlow,
|
|
apszDataFlow[paPinDescriptors[p].DataFlow],
|
|
paPinDescriptors[p].Communication,
|
|
apszCommunication[paPinDescriptors[p].Communication],
|
|
pacPinInstances[p].CurrentCount,
|
|
pacPinInstances[p].PossibleCount);
|
|
dprintf(" Category: %s\n",
|
|
DbgGuid2Sz((GUID*)paPinDescriptors[p].Category));
|
|
dprintf(" Name: %s\n",
|
|
DbgGuid2Sz((GUID*)paPinDescriptors[p].Name));
|
|
dprintf(" palstTNSelect:");
|
|
palstTopologyNodeSelect[p].DumpAddress();
|
|
dprintf("\n");
|
|
dprintf(" palstTNNot:");
|
|
palstTopologyNodeNotSelect[p].DumpAddress();
|
|
dprintf("\n");
|
|
// .sipv
|
|
if(ulDebugFlags & DEBUG_FLAGS_VERBOSE) {
|
|
for(i = 0;
|
|
i < paPinDescriptors[p].InterfacesCount;
|
|
i++) {
|
|
|
|
dprintf(" Interface %u: %s\n",
|
|
i,
|
|
DbgIdentifier2Sz((PKSIDENTIFIER)
|
|
&paPinDescriptors[p].Interfaces[i]));
|
|
}
|
|
for(m = 0; m < paPinDescriptors[p].MediumsCount; m++) {
|
|
|
|
dprintf(" Medium %u: %s\n",
|
|
m,
|
|
DbgIdentifier2Sz((PKSIDENTIFIER)
|
|
&paPinDescriptors[p].Mediums[m]));
|
|
}
|
|
for(d = 0; d < paPinDescriptors[p].DataRangesCount; d++) {
|
|
|
|
dprintf(" DataRange %u:\n", d);
|
|
dprintf(" MajorFormat: %s\n",
|
|
DbgGuid2Sz(&paPinDescriptors[p].DataRanges[d]->MajorFormat));
|
|
|
|
dprintf(" SubFormat: %s\n",
|
|
DbgGuid2Sz(&paPinDescriptors[p].DataRanges[d]->SubFormat));
|
|
|
|
dprintf(" Specifier: %s\n",
|
|
DbgGuid2Sz(&paPinDescriptors[p].DataRanges[d]->Specifier));
|
|
|
|
dprintf(" ");
|
|
DumpDataRangeAudio((PKSDATARANGE_AUDIO)
|
|
paPinDescriptors[p].DataRanges[d]);
|
|
}
|
|
}
|
|
// .sipx
|
|
if(ulDebugFlags & DEBUG_FLAGS_DETAILS) {
|
|
if(ulDebugFlags & DEBUG_FLAGS_VERBOSE) {
|
|
dprintf(" aplstSN:\n");
|
|
}
|
|
aplstStartNode[p]->Dump();
|
|
}
|
|
dprintf("\n");
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
//---------------------------------------------------------------------------
|