bdasup.c File Reference

#include "precomp.h"

Include dependency graph for bdasup.c:

Go to the source code of this file.

Functions
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID	FreeItem (IN PVOID Item)
PBDA_FILTER_INSTANCE_ENTRY	GetFilterInstanceEntry (IN PKSFILTERFACTORY FilterFactory)
NTSTATUS NTAPI	DllInitialize (PUNICODE_STRING RegistryPath)
NTSTATUS NTAPI	BdaCheckChanges (IN PIRP Irp)
NTSTATUS NTAPI	BdaCommitChanges (IN PIRP Irp)
NTSTATUS NTAPI	BdaCreateFilterFactory (IN PKSDEVICE pKSDevice, IN const KSFILTER_DESCRIPTOR *pFilterDescriptor, IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
VOID NTAPI	FreeFilterInstance (IN PVOID Context)
NTSTATUS NTAPI	BdaCreateFilterFactoryEx (IN PKSDEVICE pKSDevice, IN const KSFILTER_DESCRIPTOR *pFilterDescriptor, IN const BDA_FILTER_TEMPLATE *BdaFilterTemplate, OUT PKSFILTERFACTORY *ppKSFilterFactory)
NTSTATUS NTAPI	BdaCreatePin (IN PKSFILTER pKSFilter, IN ULONG ulPinType, OUT ULONG *pulPinId)
NTSTATUS NTAPI	BdaMethodCreatePin (IN PIRP Irp, IN KSMETHOD *pKSMethod, OUT ULONG *pulPinFactoryID)
NTSTATUS NTAPI	BdaInitFilter (IN PKSFILTER pKSFilter, IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
NTSTATUS NTAPI	BdaCreateTopology (IN PKSFILTER pKSFilter, IN ULONG InputPinId, IN ULONG OutputPinId)
NTSTATUS NTAPI	BdaDeletePin (IN PKSFILTER pKSFilter, IN ULONG *pulPinId)
NTSTATUS NTAPI	BdaFilterFactoryUpdateCacheData (IN PKSFILTERFACTORY FilterFactory, IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL)
NTSTATUS NTAPI	BdaGetChangeState (IN PIRP Irp, OUT BDA_CHANGE_STATE *ChangeState)
NTSTATUS NTAPI	BdaMethodCreateTopology (IN PIRP Irp, IN KSMETHOD *pKSMethod, OPTIONAL PVOID pvIgnored)
NTSTATUS NTAPI	BdaMethodDeletePin (IN PIRP Irp, IN KSMETHOD *pKSMethod, OPTIONAL PVOID pvIgnored)
NTSTATUS NTAPI	BdaPropertyGetControllingPinId (IN PIRP Irp, IN KSP_BDA_NODE_PIN *pProperty, OUT ULONG *pulControllingPinId)
NTSTATUS NTAPI	BdaPropertyGetPinControl (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
NTSTATUS NTAPI	BdaPropertyNodeDescriptors (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT BDANODE_DESCRIPTOR *pNodeDescriptorProperty)
NTSTATUS NTAPI	BdaPropertyNodeEvents (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
NTSTATUS NTAPI	BdaPropertyNodeMethods (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
NTSTATUS NTAPI	BdaPropertyNodeProperties (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
NTSTATUS NTAPI	BdaPropertyNodeTypes (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
NTSTATUS NTAPI	BdaPropertyPinTypes (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
NTSTATUS NTAPI	BdaPropertyTemplateConnections (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT KSTOPOLOGY_CONNECTION *pConnectionProperty)
NTSTATUS NTAPI	BdaStartChanges (IN PIRP Irp)
NTSTATUS NTAPI	BdaUninitFilter (IN PKSFILTER pKSFilter)
NTSTATUS NTAPI	BdaValidateNodeProperty (IN PIRP Irp, IN KSPROPERTY *KSProperty)

Variables
const GUID	KSPROPSETID_BdaPinControl = {0xded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}}
const GUID	KSMETHODSETID_BdaDeviceConfiguration = {0x71985f45, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}
const GUID	KSPROPSETID_BdaTopology = {0xa14ee835, 0x0a23, 0x11d3, {0x9c, 0xc7, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}
BDA_GLOBAL	g_Settings
KSPROPERTY_ITEM	FilterPropertyItem []
KSPROPERTY_SET	FilterPropertySet
KSMETHOD_ITEM	FilterMethodItem []
KSMETHOD_SET	FilterMethodSet
KSAUTOMATION_TABLE	FilterAutomationTable
KSPROPERTY_ITEM	PinPropertyItem []
KSPROPERTY_SET	PinPropertySet
KSAUTOMATION_TABLE	PinAutomationTable

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes
	)

Definition at line 95 of file bdasup.c.

{
    PVOID Item = ExAllocatePool(PoolType, NumberOfBytes);
    if (!Item)
        return Item;
 
    RtlZeroMemory(Item, NumberOfBytes);
    return Item;
}

Referenced by BdaCreateFilterFactoryEx(), and BdaCreatePin().

BdaCheckChanges()

NTSTATUS NTAPI BdaCheckChanges

(

IN PIRP

Irp

)

Definition at line 174 of file bdasup.c.

{
    DPRINT("BdaCheckChanges\n");
 
    if (!Irp)
        return STATUS_INVALID_PARAMETER;
 
    return STATUS_SUCCESS;
}

BdaCommitChanges()

NTSTATUS NTAPI BdaCommitChanges

(

IN PIRP

Irp

)

Definition at line 189 of file bdasup.c.

{
    DPRINT("BdaCommitChanges\n");
 
    if (!Irp)
        return STATUS_INVALID_PARAMETER;
 
    return STATUS_SUCCESS;
}

BdaCreateFilterFactory()

NTSTATUS NTAPI BdaCreateFilterFactory	(	IN PKSDEVICE	pKSDevice,
		IN const KSFILTER_DESCRIPTOR *	pFilterDescriptor,
		IN const BDA_FILTER_TEMPLATE *	pBdaFilterTemplate
	)

Definition at line 204 of file bdasup.c.

{
    return BdaCreateFilterFactoryEx(pKSDevice, pFilterDescriptor, pBdaFilterTemplate, NULL);
}

BdaCreateFilterFactoryEx()

NTSTATUS NTAPI BdaCreateFilterFactoryEx	(	IN PKSDEVICE	pKSDevice,
		IN const KSFILTER_DESCRIPTOR *	pFilterDescriptor,
		IN const BDA_FILTER_TEMPLATE *	BdaFilterTemplate,
		OUT PKSFILTERFACTORY *	ppKSFilterFactory
	)

Definition at line 254 of file bdasup.c.

{
    PKSFILTERFACTORY FilterFactory;
    PBDA_FILTER_INSTANCE_ENTRY FilterInstance;
    KIRQL OldLevel;
    NTSTATUS Status;
    PKSFILTER_DESCRIPTOR FilterDescriptor;
 
    DPRINT("BdaCreateFilterFactoryEx\n");
 
    FilterDescriptor = AllocateItem(NonPagedPool, sizeof(KSFILTER_DESCRIPTOR));
    if (!FilterDescriptor)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy filter descriptor template */
    RtlMoveMemory(FilterDescriptor, pFilterDescriptor, sizeof(KSFILTER_DESCRIPTOR));
 
    /* erase pin / nodes / connections from filter descriptor */
    FilterDescriptor->PinDescriptorsCount = 0;
    FilterDescriptor->PinDescriptors = NULL;
    FilterDescriptor->NodeDescriptorsCount = 0;
    FilterDescriptor->NodeDescriptors = NULL;
    FilterDescriptor->ConnectionsCount = 0;
    FilterDescriptor->Connections = NULL;
 
    /* merge the automation tables */
    Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&FilterDescriptor->AutomationTable, (PKSAUTOMATION_TABLE)pFilterDescriptor->AutomationTable, &FilterAutomationTable, NULL);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("KsMergeAutomationTables failed with %lx\n", Status);
        FreeItem(FilterDescriptor);
        return Status;
    }
 
    /* allocate filter instance */
    FilterInstance = AllocateItem(NonPagedPool, sizeof(BDA_FILTER_INSTANCE_ENTRY));
    if (!FilterInstance)
    {
        /* not enough memory */
        FreeItem(FilterDescriptor);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* create the filter factory */
    Status = KsCreateFilterFactory(pKSDevice->FunctionalDeviceObject, FilterDescriptor, NULL, NULL, 0, NULL, NULL, &FilterFactory);
 
    /* check for success */
    if (NT_SUCCESS(Status))
    {
        if (FilterDescriptor->AutomationTable != &FilterAutomationTable)
        {
            /* add the item to filter object bag */
            KsAddItemToObjectBag(FilterFactory->Bag, (PVOID)FilterDescriptor->AutomationTable, FreeFilterInstance);
        }
        else
        {
            /* make sure the automation table is not-read only */
            Status = _KsEdit(FilterFactory->Bag, (PVOID*)&FilterDescriptor->AutomationTable, sizeof(KSAUTOMATION_TABLE), sizeof(KSAUTOMATION_TABLE), 0);
 
            /* sanity check */
            ASSERT(Status == STATUS_SUCCESS);
 
            /* add to object bag */
            KsAddItemToObjectBag(FilterFactory->Bag, (PVOID)FilterDescriptor->AutomationTable, FreeFilterInstance);
        }
 
        /* initialize filter instance entry */
        FilterInstance->FilterFactoryInstance = FilterFactory;
        FilterInstance->FilterTemplate = (BDA_FILTER_TEMPLATE *)BdaFilterTemplate;
 
        /* acquire list lock */
        KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
 
        /* insert factory at the end */
        InsertTailList(&g_Settings.FilterFactoryInstanceList, &FilterInstance->Entry);
 
        /* release spin lock */
        KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
 
 
        if (ppKSFilterFactory)
        {
            /* store result */
            *ppKSFilterFactory = FilterFactory;
        }
    }
    else
    {
        /* failed to create filter factory */
        FreeItem(FilterInstance);
        FreeItem(FilterDescriptor);
    }
 
    /* done */
    DPRINT("BdaCreateFilterFactoryEx Status %x\n", Status);
    return Status;
}

Referenced by BdaCreateFilterFactory().

BdaCreatePin()

NTSTATUS NTAPI BdaCreatePin	(	IN PKSFILTER	pKSFilter,
		IN ULONG	ulPinType,
		OUT ULONG *	pulPinId
	)

Definition at line 366 of file bdasup.c.

{
    PKSPIN_DESCRIPTOR_EX PinDescriptor;
    PKSFILTERFACTORY FilterFactory;
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
    NTSTATUS Status;
    ULONG PinId;
    PKSPIN_DESCRIPTOR_EX NewPinDescriptor;
 
    DPRINT("BdaCreatePin\n");
 
    if (!pulPinId || !pKSFilter)
        return STATUS_INVALID_PARAMETER;
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
 
    /* sanity check */
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
 
    if (!InstanceEntry)
    {
        /* the filter was not initialized with BDA */
        return STATUS_NOT_FOUND;
    }
 
    /* sanity checks */
    ASSERT(InstanceEntry->FilterTemplate);
    ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor);
 
    /* does the filter support any pins */
    if (!InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount)
    {
        /* no pins supported */
        DPRINT("BdaCreatePin NoPins supported\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    /* is pin factory still existing */
    if (InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount <= ulPinType)
    {
        /* pin request is out of bounds */
        DPRINT("BdaCreatePin ulPinType %lu >= PinDescriptorCount %lu\n", ulPinType, InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* FIXME custom pin descriptors */
    ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
 
    /* get pin descriptor */
    PinDescriptor = (PKSPIN_DESCRIPTOR_EX)&InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptors[ulPinType];
 
    /* allocate pin descriptor */
    NewPinDescriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
    if (!NewPinDescriptor)
    {
        /* no memory */
        DPRINT("BdaCreatePin OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
   /* make a copy of the pin descriptor */
   RtlMoveMemory(NewPinDescriptor, PinDescriptor, sizeof(KSPIN_DESCRIPTOR_EX));
 
    /* merge the automation tables */
    Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&NewPinDescriptor->AutomationTable, (PKSAUTOMATION_TABLE)PinDescriptor->AutomationTable, &PinAutomationTable, pKSFilter->Bag);
 
    /* check for success */
    if (NT_SUCCESS(Status))
    {
        /* create the pin factory */
        Status = KsFilterCreatePinFactory(pKSFilter, NewPinDescriptor, &PinId);
 
        /* check for success */
        if (NT_SUCCESS(Status))
        {
            /* store result */
            *pulPinId = PinId;
        }
    }
 
 
    DPRINT("BdaCreatePin Result %x PinId %u\n", Status, PinId);
    return Status;
}

Referenced by BdaInitFilter(), and BdaMethodCreatePin().

BdaCreateTopology()

NTSTATUS NTAPI BdaCreateTopology	(	IN PKSFILTER	pKSFilter,
		IN ULONG	InputPinId,
		IN ULONG	OutputPinId
	)

Definition at line 553 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
    PKSFILTERFACTORY FilterFactory;
    KSTOPOLOGY_CONNECTION Connection;
 
    DPRINT("BdaCreateTopology\n");
 
    /* check input parameters */
    if (!pKSFilter)
        return STATUS_INVALID_PARAMETER;
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
 
    /* sanity check */
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
 
    if (!InstanceEntry)
    {
        /* the filter was not initialized with BDA */
        return STATUS_NOT_FOUND;
    }
 
    if (InputPinId >= InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount ||
        OutputPinId >= InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount)
    {
        /* invalid pin id */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* initialize topology connection */
    Connection.FromNode = KSFILTER_NODE;
    Connection.ToNode = KSFILTER_NODE;
    Connection.FromNodePin = InputPinId;
    Connection.ToNodePin = OutputPinId;
 
    /* add the connection */
    return KsFilterAddTopologyConnections(pKSFilter, 1, &Connection);
}

Referenced by BdaMethodCreateTopology().

BdaDeletePin()

NTSTATUS NTAPI BdaDeletePin	(	IN PKSFILTER	pKSFilter,
		IN ULONG *	pulPinId
	)

Definition at line 605 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaDeletePin\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaFilterFactoryUpdateCacheData()

NTSTATUS NTAPI BdaFilterFactoryUpdateCacheData	(	IN PKSFILTERFACTORY	FilterFactory,
		IN const KSFILTER_DESCRIPTOR *FilterDescriptor	OPTIONAL
	)

Definition at line 619 of file bdasup.c.

{
    DPRINT("BdaFilterFactoryUpdateCacheData\n");
    return KsFilterFactoryUpdateCacheData(FilterFactory, FilterDescriptor);
}

BdaGetChangeState()

NTSTATUS NTAPI BdaGetChangeState	(	IN PIRP	Irp,
		OUT BDA_CHANGE_STATE *	ChangeState
	)

Definition at line 632 of file bdasup.c.

{
    DPRINT("BdaGetChangeState\n");
 
    if (Irp && ChangeState)
    {
        *ChangeState = BDA_CHANGES_COMPLETE;
        return STATUS_SUCCESS;
    }
 
    /* invalid parameters supplied */
    return STATUS_INVALID_PARAMETER;
 
}

BdaInitFilter()

NTSTATUS NTAPI BdaInitFilter	(	IN PKSFILTER	pKSFilter,
		IN const BDA_FILTER_TEMPLATE *	pBdaFilterTemplate
	)

Definition at line 498 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
    PKSFILTERFACTORY FilterFactory;
    ULONG Index, PinId;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("BdaInitFilter %p\n", pBdaFilterTemplate);
 
    /* check input parameters */
    if (!pKSFilter)
        return STATUS_INVALID_PARAMETER;
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
 
    /* sanity check */
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
 
    /* sanity check */
    ASSERT(InstanceEntry);
 
    if (!pBdaFilterTemplate)
    {
        /* use template from BdaCreateFilterFactoryEx */
        pBdaFilterTemplate = InstanceEntry->FilterTemplate;
    }
 
    /* now create the pins */
    for(Index = 0; Index < pBdaFilterTemplate->pFilterDescriptor->PinDescriptorsCount; Index++)
    {
        /* create the pin */
        Status = BdaCreatePin(pKSFilter, Index, &PinId);
 
        /* check for success */
        if (!NT_SUCCESS(Status))
            break;
    }
 
    /* done */
    return Status;
}

BdaMethodCreatePin()

NTSTATUS NTAPI BdaMethodCreatePin	(	IN PIRP	Irp,
		IN KSMETHOD *	pKSMethod,
		OUT ULONG *	pulPinFactoryID
	)

Definition at line 463 of file bdasup.c.

{
    PKSM_PIN Pin;
    PKSFILTER Filter;
 
    DPRINT("BdaMethodCreatePin\n");
 
    if (!Irp)
    {
        /* invalid parameter */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* get filter from irp */
    Filter = KsGetFilterFromIrp(Irp);
 
    /* sanity check */
    ASSERT(Filter);
    ASSERT(pKSMethod);
 
    /* get method request */
    Pin = (PKSM_PIN)pKSMethod;
 
    /* create the pin */
    return BdaCreatePin(Filter, Pin->PinId, pulPinFactoryID);
}

BdaMethodCreateTopology()

NTSTATUS NTAPI BdaMethodCreateTopology	(	IN PIRP	Irp,
		IN KSMETHOD *	pKSMethod,
		OPTIONAL PVOID	pvIgnored
	)

Definition at line 654 of file bdasup.c.

{
    PKSFILTER Filter;
    PKSP_BDA_NODE_PIN Node;
 
    DPRINT("BdaMethodCreateTopology\n");
 
    /* check input parameters */
    if (!Irp || !pKSMethod)
        return STATUS_INVALID_PARAMETER;
 
    /* get filter */
    Filter = KsGetFilterFromIrp(Irp);
 
    /* sanity check */
    ASSERT(Filter);
 
    /* get method request */
    Node = (PKSP_BDA_NODE_PIN)pKSMethod;
 
    /* create the topology */
    return BdaCreateTopology(Filter, Node->ulInputPinId, Node->ulOutputPinId);
}

BdaMethodDeletePin()

NTSTATUS NTAPI BdaMethodDeletePin	(	IN PIRP	Irp,
		IN KSMETHOD *	pKSMethod,
		OPTIONAL PVOID	pvIgnored
	)

Definition at line 686 of file bdasup.c.

{
    DPRINT("BdaMethodDeletePin\n");
 
    if (!Irp)
        return STATUS_INVALID_PARAMETER;
 
    return STATUS_SUCCESS;
}

BdaPropertyGetControllingPinId()

NTSTATUS NTAPI BdaPropertyGetControllingPinId	(	IN PIRP	Irp,
		IN KSP_BDA_NODE_PIN *	pProperty,
		OUT ULONG *	pulControllingPinId
	)

Definition at line 704 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaPropertyGetControllingPinId\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaPropertyGetPinControl()

NTSTATUS NTAPI BdaPropertyGetPinControl	(	IN PIRP	Irp,
		IN KSPROPERTY *	pKSProperty,
		OUT ULONG *	pulProperty
	)

Definition at line 719 of file bdasup.c.

{
    PKSPIN Pin;
    PKSFILTER Filter;
    PKSFILTERFACTORY FilterFactory;
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
 
    DPRINT("BdaPropertyGetPinControl\n");
 
    /* first get the pin */
    Pin = KsGetPinFromIrp(Irp);
    ASSERT(Pin);
 
    /* now get the parent filter */
    Filter = KsPinGetParentFilter(Pin);
    ASSERT(Filter);
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(Filter);
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
    ASSERT(InstanceEntry);
 
    /* sanity check */
    pKSProperty++;
    ASSERT(pKSProperty->Id == KSPROPERTY_BDA_PIN_TYPE);
 
    /* store pin id */
    *pulProperty = Pin->Id;
 
    return STATUS_SUCCESS;
}

BdaPropertyNodeDescriptors()

NTSTATUS NTAPI BdaPropertyNodeDescriptors	(	IN PIRP	Irp,
		IN KSPROPERTY *	pKSProperty,
		OUT BDANODE_DESCRIPTOR *	pNodeDescriptorProperty
	)

Definition at line 762 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaPropertyNodeDescriptors\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaPropertyNodeEvents()

NTSTATUS NTAPI BdaPropertyNodeEvents	(	IN PIRP	Irp,
		IN KSP_NODE *	pKSProperty,
		OUT GUID *	pguidProperty
	)

Definition at line 777 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaPropertyNodeEvents\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaPropertyNodeMethods()

NTSTATUS NTAPI BdaPropertyNodeMethods	(	IN PIRP	Irp,
		IN KSP_NODE *	pKSProperty,
		OUT GUID *	pguidProperty
	)

Definition at line 792 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaPropertyNodeMethods\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaPropertyNodeProperties()

NTSTATUS NTAPI BdaPropertyNodeProperties	(	IN PIRP	Irp,
		IN KSP_NODE *	pKSProperty,
		OUT GUID *	pguidProperty
	)

Definition at line 807 of file bdasup.c.

{
    UNIMPLEMENTED;
    DPRINT("BdaPropertyNodeProperties\n");
    return STATUS_NOT_IMPLEMENTED;
}

BdaPropertyNodeTypes()

NTSTATUS NTAPI BdaPropertyNodeTypes	(	IN PIRP	Irp,
		IN KSPROPERTY *	pKSProperty,
		OUT ULONG *	pulProperty
	)

Definition at line 822 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
    PKSFILTERFACTORY FilterFactory;
    PKSFILTER pKSFilter;
    PIO_STACK_LOCATION IoStack;
    ULONG Index;
 
    DPRINT("BdaPropertyNodeTypes\n");
 
    /* check input parameter */
    if (!Irp || !pKSProperty)
        return STATUS_INVALID_PARAMETER;
 
    /* first get the filter */
    pKSFilter = KsGetFilterFromIrp(Irp);
 
    /* sanity check */
    ASSERT(pKSFilter);
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
 
    /* sanity check */
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
    ASSERT(InstanceEntry);
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* are there node types provided */
    if (!pulProperty)
    {
        /* no node entry array provided */
        Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG);
        Irp->IoStatus.Status = STATUS_MORE_ENTRIES;
        return STATUS_MORE_ENTRIES;
    }
 
    if (InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        /* buffer too small */
        Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG);
        Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* now copy all descriptors */
    for(Index = 0; Index < InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount; Index++)
    {
        /* use the index as the type */
        pulProperty[Index] = Index;
    }
 
    return STATUS_SUCCESS;
}

BdaPropertyPinTypes()

NTSTATUS NTAPI BdaPropertyPinTypes	(	IN PIRP	Irp,
		IN KSPROPERTY *	pKSProperty,
		OUT ULONG *	pulProperty
	)

Definition at line 890 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
    PKSFILTERFACTORY FilterFactory;
    PKSFILTER pKSFilter;
    PIO_STACK_LOCATION IoStack;
    ULONG Index;
 
    DPRINT("BdaPropertyPinTypes\n");
 
    /* check input parameter */
    if (!Irp || !pKSProperty)
        return STATUS_INVALID_PARAMETER;
 
    /* first get the filter */
    pKSFilter = KsGetFilterFromIrp(Irp);
 
    /* sanity check */
    ASSERT(pKSFilter);
 
    /* get parent filter factory */
    FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
 
    /* sanity check */
    ASSERT(FilterFactory);
 
    /* find instance entry */
    InstanceEntry = GetFilterInstanceEntry(FilterFactory);
    ASSERT(InstanceEntry);
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* are there node types provided */
    if (!pKSProperty)
    {
        /* no node entry array provided */
        Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG);
        Irp->IoStatus.Status = STATUS_MORE_ENTRIES;
        return STATUS_MORE_ENTRIES;
    }
 
    if (InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        /* buffer too small */
        Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG);
        Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* now copy all descriptors */
    for(Index = 0; Index < InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount; Index++)
    {
        /* use the index as the type */
        pulProperty[Index] = Index;
    }
 
    return STATUS_SUCCESS;
}

BdaPropertyTemplateConnections()

NTSTATUS NTAPI BdaPropertyTemplateConnections	(	IN PIRP	Irp,
		IN KSPROPERTY *	pKSProperty,
		OUT KSTOPOLOGY_CONNECTION *	pConnectionProperty
	)

Definition at line 958 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY FilterInstance;
    PKSFILTER Filter;
    PIO_STACK_LOCATION IoStack;
    ULONG Index;
 
    DPRINT("BdaPropertyTemplateConnections\n");
 
    /* validate parameters */
    if (!Irp || !pKSProperty)
        return STATUS_INVALID_PARAMETER;
 
    /* first get the filter */
    Filter = KsGetFilterFromIrp(Irp);
 
    /* sanity check */
    ASSERT(Filter);
 
    /* verify filter has been registered with BDA */
    FilterInstance = GetFilterInstanceEntry(KsFilterGetParentFilterFactory(Filter));
 
    if (!FilterInstance)
        return STATUS_INVALID_PARAMETER;
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (!pConnectionProperty)
    {
        /* caller needs the size first */
        Irp->IoStatus.Information = FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION);
        Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;
        return STATUS_BUFFER_OVERFLOW;
    }
 
    /* sanity check */
    ASSERT(FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION) <= IoStack->Parameters.DeviceIoControl.OutputBufferLength);
 
    for(Index = 0; Index < FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount; Index++)
    {
        /* sanity check */
        ASSERT(FilterInstance->FilterTemplate->pFilterDescriptor->Connections);
 
        /* copy connection */
        RtlMoveMemory(pConnectionProperty, &FilterInstance->FilterTemplate->pFilterDescriptor->Connections[Index], sizeof(KSTOPOLOGY_CONNECTION));
    }
 
    /* store result */
    Irp->IoStatus.Information = FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION);
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    /* done */
    return STATUS_SUCCESS;
 
}

BdaStartChanges()

NTSTATUS NTAPI BdaStartChanges

(

IN PIRP

Irp

)

Definition at line 1023 of file bdasup.c.

{
    DPRINT("BdaStartChanges\n");
 
    if (Irp)
        return STATUS_SUCCESS;
    else
        return STATUS_INVALID_PARAMETER;
 
}

BdaUninitFilter()

NTSTATUS NTAPI BdaUninitFilter

(

IN PKSFILTER

pKSFilter

)

Definition at line 1039 of file bdasup.c.

{
    DPRINT("BdaUninitFilter\n");
    return STATUS_SUCCESS;
}

BdaValidateNodeProperty()

NTSTATUS NTAPI BdaValidateNodeProperty	(	IN PIRP	Irp,
		IN KSPROPERTY *	KSProperty
	)

Definition at line 1050 of file bdasup.c.

{
    DPRINT("BdaValidateNodeProperty\n");
 
    /* check for valid parameter */
    if (Irp && KSProperty)
        return STATUS_SUCCESS;
 
    return STATUS_INVALID_PARAMETER;
}

DllInitialize()

NTSTATUS NTAPI DllInitialize

(

PUNICODE_STRING

RegistryPath

)

Definition at line 157 of file bdasup.c.

{
    DPRINT("BDASUP::DllInitialize\n");
 
    KeInitializeSpinLock(&g_Settings.FilterFactoryInstanceListLock);
    InitializeListHead(&g_Settings.FilterFactoryInstanceList);
    g_Settings.Initialized = TRUE;
 
    return STATUS_SUCCESS;
}

FreeFilterInstance()

VOID NTAPI FreeFilterInstance

(

IN PVOID

Context

)

Definition at line 214 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
    PLIST_ENTRY Entry;
    KIRQL OldLevel;
 
    /* acquire list lock */
    KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
 
    /* point to first entry */
    Entry = g_Settings.FilterFactoryInstanceList.Flink;
 
    while(Entry != &g_Settings.FilterFactoryInstanceList)
    {
        /* get instance entry from list entry offset */
        InstanceEntry = (PBDA_FILTER_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BDA_FILTER_INSTANCE_ENTRY, Entry);
 
        /* is the instance entry the requested one */
        if (InstanceEntry == (PBDA_FILTER_INSTANCE_ENTRY)Context)
        {
            RemoveEntryList(&InstanceEntry->Entry);
            FreeItem(InstanceEntry);
            break;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* release spin lock */
    KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
}

Referenced by BdaCreateFilterFactoryEx().

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 108 of file bdasup.c.

{
    ExFreePool(Item);
}

Referenced by BdaCreateFilterFactoryEx(), and FreeFilterInstance().

GetFilterInstanceEntry()

PBDA_FILTER_INSTANCE_ENTRY GetFilterInstanceEntry

(

IN PKSFILTERFACTORY

FilterFactory

)

Definition at line 116 of file bdasup.c.

{
    PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
    PLIST_ENTRY Entry;
    KIRQL OldLevel;
 
    /* acquire list lock */
    KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
 
    /* point to first entry */
    Entry = g_Settings.FilterFactoryInstanceList.Flink;
 
    while(Entry != &g_Settings.FilterFactoryInstanceList)
    {
        /* get instance entry from list entry offset */
        InstanceEntry = (PBDA_FILTER_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BDA_FILTER_INSTANCE_ENTRY, Entry);
 
        /* is the instance entry the requested one */
        if (InstanceEntry->FilterFactoryInstance == FilterFactory)
            break;
 
        /* move to next entry */
        Entry = Entry->Flink;
        /* set to null as it has not been found */
        InstanceEntry = NULL;
    }
 
 
    /* release spin lock */
    KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
 
    /* return result */
    return InstanceEntry;
}

Referenced by BdaCreatePin(), BdaCreateTopology(), BdaInitFilter(), BdaPropertyGetPinControl(), BdaPropertyNodeTypes(), BdaPropertyPinTypes(), and BdaPropertyTemplateConnections().

Variable Documentation

FilterAutomationTable

KSAUTOMATION_TABLE FilterAutomationTable

Initial value:

=
{
    1,
    sizeof(KSPROPERTY_ITEM),
    &FilterPropertySet,
    1,
    sizeof(KSMETHOD_ITEM),
    &FilterMethodSet,
    0,
    sizeof(KSEVENT_ITEM),
    NULL
}

Definition at line 52 of file bdasup.c.

Referenced by BdaCreateFilterFactoryEx().

FilterMethodItem

KSMETHOD_ITEM FilterMethodItem[]

Initial value:

=
{
    
 
}

Definition at line 37 of file bdasup.c.

FilterMethodSet

KSMETHOD_SET FilterMethodSet

Initial value:

=
{
    &KSMETHODSETID_BdaDeviceConfiguration,
    2,
    FilterMethodItem,
    0,
    NULL
}

Definition at line 43 of file bdasup.c.

FilterPropertyItem

KSPROPERTY_ITEM FilterPropertyItem[]

Initial value:

=
{
    DEFINE_KSPROPERTY_ITEM_BDA_NODE_TYPES(BdaPropertyNodeTypes, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_PIN_TYPES( BdaPropertyPinTypes, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_TEMPLATE_CONNECTIONS(BdaPropertyTemplateConnections, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_NODE_METHODS(BdaPropertyNodeMethods, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_NODE_PROPERTIES(BdaPropertyNodeProperties, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_NODE_EVENTS(BdaPropertyNodeEvents, NULL),
    DEFINE_KSPROPERTY_ITEM_BDA_CONTROLLING_PIN_ID(BdaPropertyGetControllingPinId, NULL),
 
}

Definition at line 15 of file bdasup.c.

Referenced by PcAddToPropertyTable().

FilterPropertySet

KSPROPERTY_SET FilterPropertySet

Initial value:

=
{
    &KSPROPSETID_BdaTopology,
    8,
    FilterPropertyItem,
    0,
    NULL
}

Definition at line 28 of file bdasup.c.

g_Settings

BDA_GLOBAL g_Settings

Initial value:

=
{
    0,
    0,
    {NULL, NULL}
}

Definition at line 8 of file bdasup.c.

Referenced by BdaCreateFilterFactoryEx(), DllInitialize(), FreeFilterInstance(), and GetFilterInstanceEntry().

KSMETHODSETID_BdaDeviceConfiguration

const GUID KSMETHODSETID_BdaDeviceConfiguration = {0x71985f45, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}

Definition at line 5 of file bdasup.c.

KSPROPSETID_BdaPinControl

const GUID KSPROPSETID_BdaPinControl = {0xded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}}

Definition at line 4 of file bdasup.c.

KSPROPSETID_BdaTopology

const GUID KSPROPSETID_BdaTopology = {0xa14ee835, 0x0a23, 0x11d3, {0x9c, 0xc7, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}

Definition at line 6 of file bdasup.c.

PinAutomationTable

KSAUTOMATION_TABLE PinAutomationTable

Initial value:

=
{
    1,
    sizeof(KSPROPERTY_ITEM),
    &PinPropertySet,
    0,
    sizeof(KSMETHOD_ITEM),
    NULL,
    0,
    sizeof(KSEVENT_ITEM),
    NULL
}

Definition at line 80 of file bdasup.c.

Referenced by BdaCreatePin().

PinPropertyItem

KSPROPERTY_ITEM PinPropertyItem[]

Initial value:

=
{
    DEFINE_KSPROPERTY_ITEM_BDA_PIN_ID(BdaPropertyGetPinControl, NULL),
 
}

Definition at line 65 of file bdasup.c.

PinPropertySet

KSPROPERTY_SET PinPropertySet

Initial value:

=
{
    &KSPROPSETID_BdaPinControl,
    2,
    PinPropertyItem,
    0,
    NULL
}

Definition at line 71 of file bdasup.c.