filterfactory.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for filterfactory.c:

Go to the source code of this file.

Classes
struct	IKsFilterFactoryImpl

Macros
#define	NDEBUG

Functions
VOID NTAPI	IKsFilterFactory_ItemFreeCb (IN PKSOBJECT_CREATE_ITEM CreateItem)
NTSTATUS NTAPI	IKsFilterFactory_Create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	IKsFilterFactory_fnQueryInterface (IKsFilterFactory *iface, IN REFIID refiid, OUT PVOID *Output)
ULONG NTAPI	IKsFilterFactory_fnAddRef (IKsFilterFactory *iface)
ULONG NTAPI	IKsFilterFactory_fnRelease (IKsFilterFactory *iface)
KSFILTERFACTORY *NTAPI	IKsFilterFactory_fnGetStruct (IKsFilterFactory *iface)
NTSTATUS NTAPI	IKsFilterFactory_fnSetDeviceClassesState (IKsFilterFactory *iface, IN BOOLEAN Enable)
VOID	IKsFilterFactory_AttachFilterFactoryToDeviceHeader (IKsFilterFactoryImpl *This, PKSIDEVICE_HEADER DeviceHeader)
NTSTATUS NTAPI	IKsFilterFactory_fnInitialize (IKsFilterFactory *iface, IN PDEVICE_OBJECT DeviceObject, IN const KSFILTER_DESCRIPTOR *Descriptor, IN PWSTR RefString OPTIONAL, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags, IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL, IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL, OUT PKSFILTERFACTORY *FilterFactory OPTIONAL)
NTSTATUS NTAPI	KspCreateFilterFactory (IN PDEVICE_OBJECT DeviceObject, IN const KSFILTER_DESCRIPTOR *Descriptor, IN PWSTR RefString OPTIONAL, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags, IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL, IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL, OUT PKSFILTERFACTORY *FilterFactory OPTIONAL)
KSDDKAPI NTSTATUS NTAPI	KsCreateFilterFactory (IN PDEVICE_OBJECT DeviceObject, IN const KSFILTER_DESCRIPTOR *Descriptor, IN PWSTR RefString OPTIONAL, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags, IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL, IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL, OUT PKSFILTERFACTORY *FilterFactory OPTIONAL)
KSDDKAPI NTSTATUS NTAPI	KsFilterFactorySetDeviceClassesState (IN PKSFILTERFACTORY FilterFactory, IN BOOLEAN NewState)
KSDDKAPI PUNICODE_STRING NTAPI	KsFilterFactoryGetSymbolicLink (IN PKSFILTERFACTORY FilterFactory)
KSDDKAPI NTSTATUS NTAPI	KsFilterFactoryAddCreateItem (IN PKSFILTERFACTORY FilterFactory, IN PWSTR RefString, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags)
ULONG	KspCacheAddData (PKSPCACHE_DESCRIPTOR Descriptor, LPCVOID Data, ULONG Length)
KSDDKAPI NTSTATUS NTAPI	KsFilterFactoryUpdateCacheData (IN PKSFILTERFACTORY FilterFactory, IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL)

Variables
static IKsFilterFactoryVtbl	vt_IKsFilterFactoryVtbl

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file filterfactory.c.

Function Documentation

IKsFilterFactory_AttachFilterFactoryToDeviceHeader()

VOID IKsFilterFactory_AttachFilterFactoryToDeviceHeader	(	IKsFilterFactoryImpl *	This,
		PKSIDEVICE_HEADER	DeviceHeader
	)

Definition at line 173 of file filterfactory.c.

{
    PKSBASIC_HEADER BasicHeader;
    PKSFILTERFACTORY FilterFactory;
 
    if (DeviceHeader->BasicHeader.FirstChild.FilterFactory == NULL)
    {
        /* first attached filter factory */
        DeviceHeader->BasicHeader.FirstChild.FilterFactory = &This->FilterFactory;
        return;
    }
 
    /* set to first entry */
    FilterFactory = DeviceHeader->BasicHeader.FirstChild.FilterFactory;
 
    do
    {
        /* get basic header */
        BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)FilterFactory - sizeof(KSBASIC_HEADER));
        /* sanity check */
        ASSERT(BasicHeader->Type == KsObjectTypeFilterFactory);
 
        if (BasicHeader->Next.FilterFactory)
        {
            /* iterate to next filter factory */
            FilterFactory = BasicHeader->Next.FilterFactory;
        }
        else
        {
            /* found last entry */
            break;
        }
    }while(FilterFactory);
 
    /* attach filter factory */
    BasicHeader->Next.FilterFactory = &This->FilterFactory;
}

Referenced by IKsFilterFactory_fnInitialize().

IKsFilterFactory_Create()

NTSTATUS NTAPI IKsFilterFactory_Create	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 42 of file filterfactory.c.

{
    PKSOBJECT_CREATE_ITEM CreateItem;
    IKsFilterFactoryImpl * Factory;
    IKsFilterFactory * iface;
    NTSTATUS Status;
 
    /* access the create item */
    CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
    if (!CreateItem)
    {
        DPRINT1("IKsFilterFactory_Create no CreateItem\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    /* get filter factory interface */
    Factory = (IKsFilterFactoryImpl*)CONTAINING_RECORD(CreateItem->Context, IKsFilterFactoryImpl, FilterFactory);
 
    /* get interface */
    iface = (IKsFilterFactory*)&Factory->Header.OuterUnknown;
 
    /* create a filter instance */
    Status = KspCreateFilter(DeviceObject, Irp, iface);
 
    DPRINT("KspCreateFilter Status %x\n", Status);
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = Status;
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

Referenced by IKsFilterFactory_fnInitialize(), KsFilterFactoryAddCreateItem(), and KspSetFilterFactoriesState().

IKsFilterFactory_fnAddRef()

ULONG NTAPI IKsFilterFactory_fnAddRef

(

IKsFilterFactory *

iface

)

Definition at line 117 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    return InterlockedIncrement(&This->ref);
}

IKsFilterFactory_fnGetStruct()

KSFILTERFACTORY *NTAPI IKsFilterFactory_fnGetStruct

(

IKsFilterFactory *

iface

)

Definition at line 153 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    return &This->FilterFactory;
}

IKsFilterFactory_fnInitialize()

NTSTATUS NTAPI IKsFilterFactory_fnInitialize	(	IKsFilterFactory *	iface,
		IN PDEVICE_OBJECT	DeviceObject,
		IN const KSFILTER_DESCRIPTOR *	Descriptor,
		IN PWSTR RefString	OPTIONAL,
		IN PSECURITY_DESCRIPTOR SecurityDescriptor	OPTIONAL,
		IN ULONG	CreateItemFlags,
		IN PFNKSFILTERFACTORYPOWER SleepCallback	OPTIONAL,
		IN PFNKSFILTERFACTORYPOWER WakeCallback	OPTIONAL,
		OUT PKSFILTERFACTORY *FilterFactory	OPTIONAL
	)

Definition at line 215 of file filterfactory.c.

{
    UNICODE_STRING ReferenceString;
    NTSTATUS Status;
    PDEVICE_EXTENSION DeviceExtension;
    KSOBJECT_CREATE_ITEM CreateItem;
    BOOL FreeString = FALSE;
    IKsDevice * KsDevice;
 
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* initialize filterfactory */
    This->SleepCallback = SleepCallback;
    This->WakeCallback = WakeCallback;
    This->Header.KsDevice = &DeviceExtension->DeviceHeader->KsDevice;
    This->Header.Type = KsObjectTypeFilterFactory;
    This->Header.Parent.KsDevice = &DeviceExtension->DeviceHeader->KsDevice;
    This->DeviceHeader = DeviceExtension->DeviceHeader;
 
    /* copy descriptor */
    This->FilterFactory.FilterDescriptor = AllocateItem(NonPagedPool, sizeof(KSFILTER_DESCRIPTOR));
    if (!This->FilterFactory.FilterDescriptor)
    {
        DPRINT1("Out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlMoveMemory((PVOID)This->FilterFactory.FilterDescriptor, (PVOID)Descriptor, sizeof(KSFILTER_DESCRIPTOR));
 
    /* initialize filter factory control mutex */
    This->Header.ControlMutex = &This->ControlMutex;
    KeInitializeMutex(This->Header.ControlMutex, 0);
 
    /* unused fields */
    InitializeListHead(&This->Header.EventList);
    KeInitializeSpinLock(&This->Header.EventListLock);
 
    InitializeListHead(&This->SymbolicLinkList);
 
    /* does the device use a reference string */
    if (RefString || !Descriptor->ReferenceGuid)
    {
        /* use device reference string */
        RtlInitUnicodeString(&ReferenceString, RefString);
    }
    else
    {
        /* create reference string from descriptor guid */
        Status = RtlStringFromGUID(Descriptor->ReferenceGuid, &ReferenceString);
 
        /* check for success */
        if (!NT_SUCCESS(Status))
        {
            /* omg, we failed */
            return Status;
        }
 
        FreeString = TRUE;
    }
 
    DPRINT("IKsFilterFactory_fnInitialize CategoriesCount %u ReferenceString '%S'\n", Descriptor->CategoriesCount,ReferenceString.Buffer);
 
    /* now register the device interface */
    Status = KspRegisterDeviceInterfaces(DeviceExtension->DeviceHeader->KsDevice.PhysicalDeviceObject,
                                         Descriptor->CategoriesCount,
                                         Descriptor->Categories,
                                         &ReferenceString,
                                         &This->SymbolicLinkList);
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("KspRegisterDeviceInterfaces failed with %x\n", Status);
 
        if (FreeString)
        {
            /* free unicode string */
            RtlFreeUnicodeString(&ReferenceString);
        }
 
        return Status;
    }
 
    /* now setup the create item */
    CreateItem.SecurityDescriptor = SecurityDescriptor;
    CreateItem.Flags = CreateItemFlags;
    CreateItem.Create = IKsFilterFactory_Create;
    CreateItem.Context = (PVOID)&This->FilterFactory;
    RtlInitUnicodeString(&CreateItem.ObjectClass, ReferenceString.Buffer);
 
    /* insert create item to device header */
    Status = KsAllocateObjectCreateItem((KSDEVICE_HEADER)DeviceExtension->DeviceHeader, &CreateItem, TRUE, IKsFilterFactory_ItemFreeCb);
 
    if (FreeString)
    {
        /* free unicode string */
        RtlFreeUnicodeString(&ReferenceString);
    }
 
    /* create a object bag for the filter factory */
    This->FilterFactory.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
    if (This->FilterFactory.Bag)
    {
        /* initialize object bag */
        KsDevice = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
        KsDevice->lpVtbl->InitializeObjectBag(KsDevice, (PKSIOBJECT_BAG)This->FilterFactory.Bag, NULL);
    }
 
    if (FilterFactory)
    {
        /* return filterfactory */
        *FilterFactory = &This->FilterFactory;
    }
 
    /* attach filterfactory to device header */
    IKsFilterFactory_AttachFilterFactoryToDeviceHeader(This, DeviceExtension->DeviceHeader);
 
    /* return result */
    return Status;
}

IKsFilterFactory_fnQueryInterface()

NTSTATUS NTAPI IKsFilterFactory_fnQueryInterface	(	IKsFilterFactory *	iface,
		IN REFIID	refiid,
		OUT PVOID *	Output
	)

Definition at line 83 of file filterfactory.c.

{
    NTSTATUS Status;
 
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
    {
        *Output = &This->Header.OuterUnknown;
        _InterlockedIncrement(&This->ref);
        return STATUS_SUCCESS;
    }
 
    if (This->Header.ClientAggregate)
    {
         /* using client aggregate */
         Status = This->Header.ClientAggregate->lpVtbl->QueryInterface(This->Header.ClientAggregate, refiid, Output);
 
         if (NT_SUCCESS(Status))
         {
             /* client aggregate supports interface */
             return Status;
         }
    }
 
    DPRINT("IKsFilterFactory_fnQueryInterface no interface\n");
    return STATUS_NOT_SUPPORTED;
}

IKsFilterFactory_fnRelease()

ULONG NTAPI IKsFilterFactory_fnRelease

(

IKsFilterFactory *

iface

)

Definition at line 127 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    InterlockedDecrement(&This->ref);
 
    if (This->ref == 0)
    {
        if (!IsListEmpty(&This->SymbolicLinkList))
        {
            /* disable device interfaces */
            KspSetDeviceInterfacesState(&This->SymbolicLinkList, FALSE);
            /* free device interface strings */
            KspFreeDeviceInterfaces(&This->SymbolicLinkList);
        }
 
        FreeItem(This);
        return 0;
    }
    /* Return new reference count */
    return This->ref;
}

IKsFilterFactory_fnSetDeviceClassesState()

NTSTATUS NTAPI IKsFilterFactory_fnSetDeviceClassesState	(	IKsFilterFactory *	iface,
		IN BOOLEAN	Enable
	)

Definition at line 163 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(iface, IKsFilterFactoryImpl, Header.OuterUnknown);
 
    return KspSetDeviceInterfacesState(&This->SymbolicLinkList, Enable);
}

IKsFilterFactory_ItemFreeCb()

VOID NTAPI IKsFilterFactory_ItemFreeCb

(

IN PKSOBJECT_CREATE_ITEM

CreateItem

)

Definition at line 31 of file filterfactory.c.

{
    /* callback when create item is freed in the device header */
    IKsFilterFactory * iface = (IKsFilterFactory*)CONTAINING_RECORD(CreateItem->Context, IKsFilterFactoryImpl, FilterFactory);
 
    iface->lpVtbl->Release(iface);
}

Referenced by IKsFilterFactory_fnInitialize(), and KsFilterFactoryAddCreateItem().

KsCreateFilterFactory()

KSDDKAPI NTSTATUS NTAPI KsCreateFilterFactory	(	IN PDEVICE_OBJECT	DeviceObject,
		IN const KSFILTER_DESCRIPTOR *	Descriptor,
		IN PWSTR RefString	OPTIONAL,
		IN PSECURITY_DESCRIPTOR SecurityDescriptor	OPTIONAL,
		IN ULONG	CreateItemFlags,
		IN PFNKSFILTERFACTORYPOWER SleepCallback	OPTIONAL,
		IN PFNKSFILTERFACTORYPOWER WakeCallback	OPTIONAL,
		OUT PKSFILTERFACTORY *FilterFactory	OPTIONAL
	)

Definition at line 413 of file filterfactory.c.

{
    return KspCreateFilterFactory(DeviceObject, Descriptor, RefString, SecurityDescriptor, CreateItemFlags, SleepCallback, WakeCallback, FilterFactory);
 
}

Referenced by BdaCreateFilterFactoryEx(), and USBAudioCreateFilterContext().

KsFilterFactoryAddCreateItem()

KSDDKAPI NTSTATUS NTAPI KsFilterFactoryAddCreateItem	(	IN PKSFILTERFACTORY	FilterFactory,
		IN PWSTR	RefString,
		IN PSECURITY_DESCRIPTOR SecurityDescriptor	OPTIONAL,
		IN ULONG	CreateItemFlags
	)

Definition at line 476 of file filterfactory.c.

{
    KSOBJECT_CREATE_ITEM CreateItem;
 
    IKsFilterFactoryImpl * Factory = (IKsFilterFactoryImpl*)CONTAINING_RECORD(FilterFactory, IKsFilterFactoryImpl, FilterFactory);
 
    /* initialize create item */
    CreateItem.Context = (PVOID)&Factory->FilterFactory;
    CreateItem.Create = IKsFilterFactory_Create;
    CreateItem.Flags = CreateItemFlags;
    CreateItem.SecurityDescriptor = SecurityDescriptor;
    RtlInitUnicodeString(&CreateItem.ObjectClass, RefString);
 
    /* insert create item to device header */
    return KsAllocateObjectCreateItem((KSDEVICE_HEADER)Factory->DeviceHeader, &CreateItem, TRUE, IKsFilterFactory_ItemFreeCb);
}

KsFilterFactoryGetSymbolicLink()

KSDDKAPI PUNICODE_STRING NTAPI KsFilterFactoryGetSymbolicLink

(

IN PKSFILTERFACTORY

FilterFactory

)

Definition at line 451 of file filterfactory.c.

{
    PSYMBOLIC_LINK_ENTRY LinkEntry;
    IKsFilterFactoryImpl * Factory = (IKsFilterFactoryImpl*)CONTAINING_RECORD(FilterFactory, IKsFilterFactoryImpl, FilterFactory);
 
    if (IsListEmpty(&Factory->SymbolicLinkList))
    {
        /* device has not registered any interfaces */
        return NULL;
    }
 
    /* get first entry */
    LinkEntry = (PSYMBOLIC_LINK_ENTRY)CONTAINING_RECORD(Factory->SymbolicLinkList.Flink, SYMBOLIC_LINK_ENTRY, Entry);
 
    /* return first link */
    return &LinkEntry->SymbolicLink;
}

KsFilterFactorySetDeviceClassesState()

KSDDKAPI NTSTATUS NTAPI KsFilterFactorySetDeviceClassesState	(	IN PKSFILTERFACTORY	FilterFactory,
		IN BOOLEAN	NewState
	)

Definition at line 433 of file filterfactory.c.

{
    IKsFilterFactory * Factory;
    IKsFilterFactoryImpl * This = (IKsFilterFactoryImpl*)CONTAINING_RECORD(FilterFactory, IKsFilterFactoryImpl, FilterFactory);
 
    Factory = (IKsFilterFactory*)&This->Header.OuterUnknown;
    return Factory->lpVtbl->SetDeviceClassesState(Factory, NewState);
}

Referenced by KspSetFilterFactoriesState().

KsFilterFactoryUpdateCacheData()

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

Definition at line 541 of file filterfactory.c.

{
    KSPCACHE_DESCRIPTOR Descriptor;
    PKSPCACHE_FILTER_HEADER FilterHeader;
    UNICODE_STRING FilterData = RTL_CONSTANT_STRING(L"FilterData");
    PKSPCACHE_PIN_HEADER PinHeader;
    ULONG Index, SubIndex;
    PLIST_ENTRY Entry;
    PSYMBOLIC_LINK_ENTRY SymEntry;
    BOOLEAN Found;
    HANDLE hKey;
    NTSTATUS Status = STATUS_SUCCESS;
 
    IKsFilterFactoryImpl * Factory = (IKsFilterFactoryImpl*)CONTAINING_RECORD(FilterFactory, IKsFilterFactoryImpl, FilterFactory);
 
    DPRINT("KsFilterFactoryUpdateCacheData %p\n", FilterDescriptor);
 
    if (!FilterDescriptor)
        FilterDescriptor = Factory->FilterFactory.FilterDescriptor;
 
    ASSERT(FilterDescriptor);
 
    /* initialize cache descriptor */
    RtlZeroMemory(&Descriptor, sizeof(KSPCACHE_DESCRIPTOR));
 
    /* calculate filter data size */
    Descriptor.FilterLength = sizeof(KSPCACHE_FILTER_HEADER);
 
    /* FIXME support variable size pin descriptors */
    ASSERT(FilterDescriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
 
    for(Index = 0; Index < FilterDescriptor->PinDescriptorsCount; Index++)
    {
        /* add filter descriptor */
        Descriptor.FilterLength += sizeof(KSPCACHE_PIN_HEADER);
 
        if (FilterDescriptor->PinDescriptors[Index].PinDescriptor.Category)
        {
            /* add extra ULONG for offset to category */
            Descriptor.FilterLength += sizeof(ULONG);
 
            /* add size for clsid */
            Descriptor.DataLength += sizeof(CLSID);
        }
 
        /* add space for formats */
        Descriptor.FilterLength += FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRangesCount * sizeof(KSPCACHE_DATARANGE);
 
        /* add space for MajorFormat / MinorFormat */
        Descriptor.DataLength += FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRangesCount * sizeof(CLSID) * 2;
 
        /* add space for mediums */
        Descriptor.FilterLength += FilterDescriptor->PinDescriptors[Index].PinDescriptor.MediumsCount * sizeof(ULONG);
 
        /* add space for the data */
        Descriptor.DataLength += FilterDescriptor->PinDescriptors[Index].PinDescriptor.MediumsCount * sizeof(KSPCACHE_MEDIUM);
    }
 
    /* now allocate the space */
    Descriptor.FilterData = (PUCHAR)AllocateItem(NonPagedPool, Descriptor.DataLength + Descriptor.FilterLength);
    if (!Descriptor.FilterData)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize data cache */
    Descriptor.DataCache = (PUCHAR)((ULONG_PTR)Descriptor.FilterData + Descriptor.FilterLength);
 
    /* setup filter header */
    FilterHeader = (PKSPCACHE_FILTER_HEADER)Descriptor.FilterData;
 
    FilterHeader->dwVersion = 2;
    FilterHeader->dwMerit = MERIT_DO_NOT_USE;
    FilterHeader->dwUnused = 0;
    FilterHeader->dwPins = FilterDescriptor->PinDescriptorsCount;
 
    Descriptor.FilterOffset = sizeof(KSPCACHE_FILTER_HEADER);
 
    /* write pin headers */
    for(Index = 0; Index < FilterDescriptor->PinDescriptorsCount; Index++)
    {
        /* get offset to pin */
        PinHeader = (PKSPCACHE_PIN_HEADER)((ULONG_PTR)Descriptor.FilterData + Descriptor.FilterOffset);
 
        /* write pin header */
        PinHeader->Signature = 0x33697030 + Index;
        PinHeader->Flags = 0;
        PinHeader->Instances = FilterDescriptor->PinDescriptors[Index].InstancesPossible;
        if (PinHeader->Instances > 1)
            PinHeader->Flags |= REG_PINFLAG_B_MANY;
 
 
        PinHeader->MediaTypes = FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRangesCount;
        PinHeader->Mediums = FilterDescriptor->PinDescriptors[Index].PinDescriptor.MediumsCount;
        PinHeader->Category = (FilterDescriptor->PinDescriptors[Index].PinDescriptor.Category ? TRUE : FALSE);
 
        Descriptor.FilterOffset += sizeof(KSPCACHE_PIN_HEADER);
 
        if (PinHeader->Category)
        {
            /* get category offset */
            PULONG Category = (PULONG)(PinHeader + 1);
 
            /* write category offset */
            *Category = KspCacheAddData(&Descriptor, FilterDescriptor->PinDescriptors[Index].PinDescriptor.Category, sizeof(CLSID));
 
            /* adjust offset */
            Descriptor.FilterOffset += sizeof(ULONG);
        }
 
        /* add dataranges */
        for(SubIndex = 0; SubIndex < FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRangesCount; SubIndex++)
        {
            /* get datarange offset */
            PKSPCACHE_DATARANGE DataRange = (PKSPCACHE_DATARANGE)((ULONG_PTR)Descriptor.FilterData + Descriptor.FilterOffset);
 
            /* initialize data range */
            DataRange->Signature = 0x33797430 + SubIndex;
            DataRange->dwUnused = 0;
            DataRange->OffsetMajor = KspCacheAddData(&Descriptor, &FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRanges[SubIndex]->MajorFormat, sizeof(CLSID));
            DataRange->OffsetMinor = KspCacheAddData(&Descriptor, &FilterDescriptor->PinDescriptors[Index].PinDescriptor.DataRanges[SubIndex]->SubFormat, sizeof(CLSID));
 
            /* adjust offset */
            Descriptor.FilterOffset += sizeof(KSPCACHE_DATARANGE);
        }
 
        /* add mediums */
        for(SubIndex = 0; SubIndex < FilterDescriptor->PinDescriptors[Index].PinDescriptor.MediumsCount; SubIndex++)
        {
            KSPCACHE_MEDIUM Medium;
            PULONG MediumOffset;
 
            /* get pin medium offset */
            MediumOffset = (PULONG)((ULONG_PTR)Descriptor.FilterData + Descriptor.FilterOffset);
 
            /* copy medium guid */
            RtlMoveMemory(&Medium.Medium, &FilterDescriptor->PinDescriptors[Index].PinDescriptor.Mediums[SubIndex].Set, sizeof(GUID));
            Medium.dw1 = FilterDescriptor->PinDescriptors[Index].PinDescriptor.Mediums[SubIndex].Id; /* FIXME verify */
            Medium.dw2 = 0;
 
            *MediumOffset = KspCacheAddData(&Descriptor, &Medium, sizeof(KSPCACHE_MEDIUM));
 
            /* adjust offset */
            Descriptor.FilterOffset += sizeof(ULONG);
        }
    }
 
    /* sanity checks */
    ASSERT(Descriptor.FilterOffset == Descriptor.FilterLength);
    ASSERT(Descriptor.DataOffset <= Descriptor.DataLength);
 
 
    /* now go through all entries and update 'FilterData' key */
    for(Index = 0; Index < FilterDescriptor->CategoriesCount; Index++)
    {
        /* get first entry */
        Entry = Factory->SymbolicLinkList.Flink;
 
        /* set status to not found */
        Found = FALSE;
        /* loop list until the the current category is found */
        while(Entry != &Factory->SymbolicLinkList)
        {
            /* fetch symbolic link entry */
            SymEntry = (PSYMBOLIC_LINK_ENTRY)CONTAINING_RECORD(Entry, SYMBOLIC_LINK_ENTRY, Entry);
 
            if (IsEqualGUIDAligned(&SymEntry->DeviceInterfaceClass, &FilterDescriptor->Categories[Index]))
            {
                /* found category */
                Found = TRUE;
                break;
            }
 
            /* move to next entry */
            Entry = Entry->Flink;
        }
 
        if (!Found)
        {
            /* filter category is not present */
            Status = STATUS_INVALID_PARAMETER;
            break;
        }
 
        /* now open device interface */
        Status = IoOpenDeviceInterfaceRegistryKey(&SymEntry->SymbolicLink, KEY_WRITE, &hKey);
        if (!NT_SUCCESS(Status))
        {
            /* failed to open interface key */
            break;
        }
 
        /* update filterdata key */
        Status = ZwSetValueKey(hKey, &FilterData, 0, REG_BINARY, Descriptor.FilterData, Descriptor.FilterLength + Descriptor.DataOffset);
 
        /* close filterdata key */
        ZwClose(hKey);
 
        if (!NT_SUCCESS(Status))
        {
            /* failed to set key value */
            break;
        }
    }
    /* free filter data */
    FreeItem(Descriptor.FilterData);
 
    /* done */
    return Status;
}

Referenced by BdaFilterFactoryUpdateCacheData().

KspCacheAddData()

ULONG KspCacheAddData	(	PKSPCACHE_DESCRIPTOR	Descriptor,
		LPCVOID	Data,
		ULONG	Length
	)

Definition at line 498 of file filterfactory.c.

{
    ULONG Index;
 
    for(Index = 0; Index < Descriptor->DataOffset; Index++)
    {
        if (RtlCompareMemory(Descriptor->DataCache, Data, Length) == Length)
        {
            if (Index + Length > Descriptor->DataOffset)
            {
                /* adjust used space */
                Descriptor->DataOffset = Index + Length;
                /* return absolute offset */
                return Descriptor->DataLength + Index;
            }
        }
    }
 
    /* sanity check */
    ASSERT(Descriptor->DataOffset + Length < Descriptor->DataLength);
 
    /* copy to data blob */
    RtlMoveMemory((Descriptor->DataCache + Descriptor->DataOffset), Data, Length);
 
    /* backup offset */
    Index = Descriptor->DataOffset;
 
    /* adjust used space */
    Descriptor->DataOffset += Length;
 
    /* return absolute offset */
    return Descriptor->DataLength + Index;
}

Referenced by KsFilterFactoryUpdateCacheData().

KspCreateFilterFactory()

NTSTATUS NTAPI KspCreateFilterFactory	(	IN PDEVICE_OBJECT	DeviceObject,
		IN const KSFILTER_DESCRIPTOR *	Descriptor,
		IN PWSTR RefString	OPTIONAL,
		IN PSECURITY_DESCRIPTOR SecurityDescriptor	OPTIONAL,
		IN ULONG	CreateItemFlags,
		IN PFNKSFILTERFACTORYPOWER SleepCallback	OPTIONAL,
		IN PFNKSFILTERFACTORYPOWER WakeCallback	OPTIONAL,
		OUT PKSFILTERFACTORY *FilterFactory	OPTIONAL
	)

Definition at line 359 of file filterfactory.c.

{
    IKsFilterFactoryImpl * This;
    IKsFilterFactory * Filter;
    NTSTATUS Status;
 
    DPRINT("KsCreateFilterFactory\n");
 
    /* Lets allocate a filterfactory */
    This = AllocateItem(NonPagedPool, sizeof(IKsFilterFactoryImpl));
    if (!This)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize struct */
    This->ref = 1;
    This->Header.OuterUnknown = (PUNKNOWN)&vt_IKsFilterFactoryVtbl;
 
    /* map to com object */
    Filter = (IKsFilterFactory*)&This->Header.OuterUnknown;
 
    /* initialize filter */
    Status = Filter->lpVtbl->Initialize(Filter, DeviceObject, Descriptor, RefString, SecurityDescriptor, CreateItemFlags, SleepCallback, WakeCallback, FilterFactory);
    /* did we succeed */
    if (!NT_SUCCESS(Status))
    {
        /* destroy filterfactory */
        Filter->lpVtbl->Release(Filter);
    }
 
    /* return result */
    DPRINT("KsCreateFilterFactory %x\n", Status);
    /* sanity check */
    ASSERT(Status == STATUS_SUCCESS);
 
    return Status;
}

Referenced by KsCreateFilterFactory(), and KsInitializeDevice().

Variable Documentation

vt_IKsFilterFactoryVtbl

IKsFilterFactoryVtbl vt_IKsFilterFactoryVtbl

static

Initial value:

=
{
    IKsFilterFactory_fnQueryInterface,
    IKsFilterFactory_fnAddRef,
    IKsFilterFactory_fnRelease,
    IKsFilterFactory_fnGetStruct,
    IKsFilterFactory_fnSetDeviceClassesState,
    IKsFilterFactory_fnInitialize
}

Definition at line 346 of file filterfactory.c.

Referenced by KspCreateFilterFactory().