filter.c

Go to the documentation of this file.

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS Kernel Streaming
 * FILE:            drivers/ksfilter/ks/filter.c
 * PURPOSE:         KS IKsFilter interface functions
 * PROGRAMMER:      Johannes Anderwald
 */
 
#include "precomp.h"
 
#define NDEBUG
#include <debug.h>
 
typedef struct
{
    KSBASIC_HEADER Header;
    KSFILTER Filter;
 
    IKsControlVtbl *lpVtblKsControl;
    IKsFilterFactory * FilterFactory;
    IKsProcessingObjectVtbl * lpVtblKsProcessingObject;
    LONG ref;
 
    PKSIOBJECT_HEADER ObjectHeader;
    KSTOPOLOGY Topology;
    PKSFILTERFACTORY Factory;
    PFILE_OBJECT FileObject;
    KMUTEX ControlMutex;
    KMUTEX ProcessingMutex;
 
    PKSWORKER Worker;
    WORK_QUEUE_ITEM WorkItem;
    KSGATE Gate;
 
    PFNKSFILTERPOWER Sleep;
    PFNKSFILTERPOWER Wake;
 
    ULONG *PinInstanceCount;
    PKSPIN * FirstPin;
    PKSPROCESSPIN_INDEXENTRY ProcessPinIndex;
 
}IKsFilterImpl;
 
const GUID IID_IKsControl = {0x28F54685L, 0x06FD, 0x11D2, {0xB2, 0x7A, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
const GUID IID_IKsFilter  = {0x3ef6ee44L, 0x0D41, 0x11d2, {0xbe, 0xDA, 0x00, 0xc0, 0x4f, 0x8e, 0xF4, 0x57}};
const GUID KSPROPSETID_Topology                = {0x720D4AC0L, 0x7533, 0x11D0, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
const GUID KSPROPSETID_Pin                     = {0x8C134960L, 0x51AD, 0x11CF, {0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00}};
const GUID KSPROPSETID_General =                 {0x1464EDA5L, 0x6A8F, 0x11D1, {0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
 
VOID
IKsFilter_RemoveFilterFromFilterFactory(
    IKsFilterImpl * This,
    PKSFILTERFACTORY FilterFactory);
 
NTSTATUS NTAPI FilterTopologyPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER  Request, IN OUT PVOID  Data);
NTSTATUS NTAPI FilterPinPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER  Request, IN OUT PVOID  Data);
NTSTATUS NTAPI FilterGeneralComponentIdHandler(IN PIRP Irp, IN PKSIDENTIFIER  Request, IN OUT PVOID  Data);
 
DEFINE_KSPROPERTY_TOPOLOGYSET(IKsFilterTopologySet, FilterTopologyPropertyHandler);
DEFINE_KSPROPERTY_PINPROPOSEDATAFORMAT(IKsFilterPinSet, FilterPinPropertyHandler, FilterPinPropertyHandler, FilterPinPropertyHandler);
DEFINE_KSPROPERTY_GENEREAL_COMPONENTID(IKsFilterGeneralSet, FilterGeneralComponentIdHandler);
 
KSPROPERTY_SET FilterPropertySet[] =
{
    {
        &KSPROPSETID_Topology,
        sizeof(IKsFilterTopologySet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&IKsFilterTopologySet,
        0,
        NULL
    },
    {
        &KSPROPSETID_Pin,
        sizeof(IKsFilterPinSet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&IKsFilterPinSet,
        0,
        NULL
    },
    {
        &KSPROPSETID_General,
        sizeof(IKsFilterGeneralSet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&IKsFilterGeneralSet,
        0,
        NULL
    }
};
 
NTSTATUS
NTAPI
IKsProcessingObject_fnQueryInterface(
    IKsProcessingObject * iface,
    IN  REFIID refiid,
    OUT PVOID* Output)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
    {
        *Output = &This->Header.OuterUnknown;
        _InterlockedIncrement(&This->ref);
        return STATUS_SUCCESS;
    }
    return STATUS_UNSUCCESSFUL;
}
 
ULONG
NTAPI
IKsProcessingObject_fnAddRef(
    IKsProcessingObject * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    return InterlockedIncrement(&This->ref);
}
 
ULONG
NTAPI
IKsProcessingObject_fnRelease(
    IKsProcessingObject * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    InterlockedDecrement(&This->ref);
 
    /* Return new reference count */
    return This->ref;
}
 
VOID
NTAPI
IKsProcessingObject_fnProcessingObjectWork(
    IKsProcessingObject * iface)
{
    NTSTATUS Status;
    LARGE_INTEGER TimeOut;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    DPRINT1("processing object\n");
    /* first check if running at passive level */
    if (KeGetCurrentIrql() == PASSIVE_LEVEL)
    {
        /* acquire processing mutex */
        KeWaitForSingleObject(&This->ControlMutex, Executive, KernelMode, FALSE, NULL);
    }
    else
    {
        /* dispatch level processing */
        if (KeReadStateMutex(&This->ControlMutex) == 0)
        {
            /* some thread was faster */
            DPRINT1("processing object too slow\n");
            return;
        }
 
        /* acquire processing mutex */
        TimeOut.QuadPart = 0LL;
        Status = KeWaitForSingleObject(&This->ControlMutex, Executive, KernelMode, FALSE, &TimeOut);
 
        if (Status == STATUS_TIMEOUT)
        {
            /* some thread was faster */
            DPRINT1("processing object too slow\n");
            return;
        }
    }
 
    do
    {
 
        /* check if the and-gate has been enabled again */
        if (This->Gate.Count != 0)
        {
            /* gate is open */
            DPRINT1("processing object gate open\n");
            break;
        }
 
        DPRINT1("IKsProcessingObject_fnProcessingObjectWork not implemented\n");
        ASSERT(0);
 
    }while(TRUE);
 
    /* release process mutex */
    KeReleaseMutex(&This->ProcessingMutex, FALSE);
}
 
PKSGATE
NTAPI
IKsProcessingObject_fnGetAndGate(
    IKsProcessingObject * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    /* return and gate */
    return &This->Gate;
}
 
VOID
NTAPI
IKsProcessingObject_fnProcess(
    IKsProcessingObject * iface,
    IN BOOLEAN Asynchronous)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    /* should the action be asynchronous */
    if (Asynchronous)
    {
        /* queue work item */
        KsQueueWorkItem(This->Worker, &This->WorkItem);
DPRINT1("queueing\n");
        /* done */
        return;
    }
 
    /* does the filter require explicit deferred processing */
    if ((This->Filter.Descriptor->Flags & (KSFILTER_FLAG_DISPATCH_LEVEL_PROCESSING | KSFILTER_FLAG_CRITICAL_PROCESSING | KSFILTER_FLAG_HYPERCRITICAL_PROCESSING)) &&
         KeGetCurrentIrql() > PASSIVE_LEVEL)
    {
        /* queue work item */
        KsQueueWorkItem(This->Worker, &This->WorkItem);
DPRINT1("queueing\n");
        /* done */
        return;
    }
DPRINT1("invoke\n");
    /* call worker routine directly */
    iface->lpVtbl->ProcessingObjectWork(iface);
}
 
VOID
NTAPI
IKsProcessingObject_fnReset(
    IKsProcessingObject * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsProcessingObject);
 
    /* acquire processing mutex */
    KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
 
    /* check if the filter supports dispatch routines */
    if (This->Filter.Descriptor->Dispatch)
    {
        /* has the filter a reset routine */
        if (This->Filter.Descriptor->Dispatch->Reset)
        {
            /* reset filter */
            This->Filter.Descriptor->Dispatch->Reset(&This->Filter);
        }
    }
 
    /* release process mutex */
    KeReleaseMutex(&This->ProcessingMutex, FALSE);
}
 
VOID
NTAPI
IKsProcessingObject_fnTriggerNotification(
    IKsProcessingObject * iface)
{
 
}
 
static IKsProcessingObjectVtbl vt_IKsProcessingObject =
{
    IKsProcessingObject_fnQueryInterface,
    IKsProcessingObject_fnAddRef,
    IKsProcessingObject_fnRelease,
    IKsProcessingObject_fnProcessingObjectWork,
    IKsProcessingObject_fnGetAndGate,
    IKsProcessingObject_fnProcess,
    IKsProcessingObject_fnReset,
    IKsProcessingObject_fnTriggerNotification
};
 
 
//---------------------------------------------------------------------------------------------------------
NTSTATUS
NTAPI
IKsControl_fnQueryInterface(
    IKsControl * iface,
    IN  REFIID refiid,
    OUT PVOID* Output)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
    {
        *Output = &This->Header.OuterUnknown;
        _InterlockedIncrement(&This->ref);
        return STATUS_SUCCESS;
    }
    return STATUS_UNSUCCESSFUL;
}
 
ULONG
NTAPI
IKsControl_fnAddRef(
    IKsControl * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    return InterlockedIncrement(&This->ref);
}
 
ULONG
NTAPI
IKsControl_fnRelease(
    IKsControl * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    InterlockedDecrement(&This->ref);
 
    /* Return new reference count */
    return This->ref;
}
 
NTSTATUS
NTAPI
IKsControl_fnKsProperty(
    IKsControl * iface,
    IN PKSPROPERTY Property,
    IN ULONG PropertyLength,
    IN OUT PVOID PropertyData,
    IN ULONG DataLength,
    OUT ULONG* BytesReturned)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    return KsSynchronousIoControlDevice(This->FileObject, KernelMode, IOCTL_KS_PROPERTY, Property, PropertyLength, PropertyData, DataLength, BytesReturned);
}
 
 
NTSTATUS
NTAPI
IKsControl_fnKsMethod(
    IKsControl * iface,
    IN PKSMETHOD Method,
    IN ULONG MethodLength,
    IN OUT PVOID MethodData,
    IN ULONG DataLength,
    OUT ULONG* BytesReturned)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    return KsSynchronousIoControlDevice(This->FileObject, KernelMode, IOCTL_KS_METHOD, Method, MethodLength, MethodData, DataLength, BytesReturned);
}
 
 
NTSTATUS
NTAPI
IKsControl_fnKsEvent(
    IKsControl * iface,
    IN PKSEVENT Event OPTIONAL,
    IN ULONG EventLength,
    IN OUT PVOID EventData,
    IN ULONG DataLength,
    OUT ULONG* BytesReturned)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, lpVtblKsControl);
 
    if (Event)
    {
       return KsSynchronousIoControlDevice(This->FileObject, KernelMode, IOCTL_KS_ENABLE_EVENT, Event, EventLength, EventData, DataLength, BytesReturned);
    }
    else
    {
       return KsSynchronousIoControlDevice(This->FileObject, KernelMode, IOCTL_KS_DISABLE_EVENT, EventData, DataLength, NULL, 0, BytesReturned);
    }
 
}
 
static IKsControlVtbl vt_IKsControl =
{
    IKsControl_fnQueryInterface,
    IKsControl_fnAddRef,
    IKsControl_fnRelease,
    IKsControl_fnKsProperty,
    IKsControl_fnKsMethod,
    IKsControl_fnKsEvent
};
 
 
NTSTATUS
NTAPI
IKsFilter_fnQueryInterface(
    IKsFilter * iface,
    IN  REFIID refiid,
    OUT PVOID* Output)
{
    NTSTATUS Status;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    if (IsEqualGUIDAligned(refiid, &IID_IUnknown) ||
        IsEqualGUIDAligned(refiid, &IID_IKsFilter))
    {
        *Output = &This->Header.OuterUnknown;
        _InterlockedIncrement(&This->ref);
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUIDAligned(refiid, &IID_IKsControl))
    {
        *Output = &This->lpVtblKsControl;
        _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("IKsFilter_fnQueryInterface no interface\n");
    return STATUS_NOT_SUPPORTED;
}
 
ULONG
NTAPI
IKsFilter_fnAddRef(
    IKsFilter * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    return InterlockedIncrement(&This->ref);
}
 
ULONG
NTAPI
IKsFilter_fnRelease(
    IKsFilter * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    InterlockedDecrement(&This->ref);
 
    if (This->ref == 0)
    {
        FreeItem(This);
        return 0;
    }
    /* Return new reference count */
    return This->ref;
 
}
 
PKSFILTER
NTAPI
IKsFilter_fnGetStruct(
    IKsFilter * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    return &This->Filter;
}
 
BOOL
NTAPI
IKsFilter_fnDoAllNecessaryPinsExist(
    IKsFilter * iface)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
NTSTATUS
NTAPI
IKsFilter_fnCreateNode(
    IKsFilter * iface,
    IN PIRP Irp,
    IN IKsPin * Pin,
    IN PLIST_ENTRY ListEntry)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
IKsFilter_fnBindProcessPinsToPipeSection(
    IKsFilter * iface,
    IN struct KSPROCESSPIPESECTION *Section,
    IN PVOID Create,
    IN PKSPIN KsPin,
    OUT IKsPin **Pin,
    OUT PKSGATE *OutGate)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
IKsFilter_fnUnbindProcessPinsFromPipeSection(
    IKsFilter * iface,
    IN struct KSPROCESSPIPESECTION *Section)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
IKsFilter_fnAddProcessPin(
    IKsFilter * iface,
    IN PKSPROCESSPIN ProcessPin)
{
    NTSTATUS Status;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    /* first acquire processing mutex */
    KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
 
    /* sanity check */
    ASSERT(This->Filter.Descriptor->PinDescriptorsCount > ProcessPin->Pin->Id);
 
    /* allocate new process pin array */
    Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->ProcessPinIndex[ProcessPin->Pin->Id].Pins,
                     (This->Filter.Descriptor->PinDescriptorsCount + 1) * sizeof(PVOID),
                     This->Filter.Descriptor->PinDescriptorsCount * sizeof(PVOID),
                     0);
 
    if (NT_SUCCESS(Status))
    {
        /* store process pin */
        This->ProcessPinIndex[ProcessPin->Pin->Id].Pins[This->ProcessPinIndex[ProcessPin->Pin->Id].Count] = ProcessPin;
        This->ProcessPinIndex[ProcessPin->Pin->Id].Count++;
    }
 
    /* release process mutex */
    KeReleaseMutex(&This->ProcessingMutex, FALSE);
 
    return Status;
}
 
NTSTATUS
NTAPI
IKsFilter_fnRemoveProcessPin(
    IKsFilter * iface,
    IN PKSPROCESSPIN ProcessPin)
{
    ULONG Index;
    ULONG Count;
    PKSPROCESSPIN * Pins;
 
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    /* first acquire processing mutex */
    KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
 
    /* sanity check */
    ASSERT(ProcessPin->Pin);
    ASSERT(ProcessPin->Pin->Id);
 
    Count = This->ProcessPinIndex[ProcessPin->Pin->Id].Count;
    Pins =  This->ProcessPinIndex[ProcessPin->Pin->Id].Pins;
 
    /* search for current process pin */
    for(Index = 0; Index < Count; Index++)
    {
        if (Pins[Index] == ProcessPin)
        {
            RtlMoveMemory(&Pins[Index], &Pins[Index + 1], (Count - (Index + 1)) * sizeof(PVOID));
            break;
        }
 
    }
 
    /* decrement pin count */
    This->ProcessPinIndex[ProcessPin->Pin->Id].Count--;
 
    if (!This->ProcessPinIndex[ProcessPin->Pin->Id].Count)
    {
        /* clear entry object bag will delete it */
       This->ProcessPinIndex[ProcessPin->Pin->Id].Pins = NULL;
    }
 
    /* release process mutex */
    KeReleaseMutex(&This->ProcessingMutex, FALSE);
 
    /* done */
    return STATUS_SUCCESS;
}
 
BOOL
NTAPI
IKsFilter_fnReprepareProcessPipeSection(
    IKsFilter * iface,
    IN struct KSPROCESSPIPESECTION *PipeSection,
    IN PULONG Data)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
VOID
NTAPI
IKsFilter_fnDeliverResetState(
    IKsFilter * iface,
    IN struct KSPROCESSPIPESECTION *PipeSection,
    IN KSRESET ResetState)
{
    UNIMPLEMENTED;
}
 
BOOL
NTAPI
IKsFilter_fnIsFrameHolding(
    IKsFilter * iface)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
VOID
NTAPI
IKsFilter_fnRegisterForCopyCallbacks(
    IKsFilter * iface,
    IKsQueue *Queue,
    BOOL Register)
{
    UNIMPLEMENTED;
}
 
PKSPROCESSPIN_INDEXENTRY
NTAPI
IKsFilter_fnGetProcessDispatch(
    IKsFilter * iface)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(iface, IKsFilterImpl, Header.OuterUnknown);
 
    return This->ProcessPinIndex;
}
 
static IKsFilterVtbl vt_IKsFilter =
{
    IKsFilter_fnQueryInterface,
    IKsFilter_fnAddRef,
    IKsFilter_fnRelease,
    IKsFilter_fnGetStruct,
    IKsFilter_fnDoAllNecessaryPinsExist,
    IKsFilter_fnCreateNode,
    IKsFilter_fnBindProcessPinsToPipeSection,
    IKsFilter_fnUnbindProcessPinsFromPipeSection,
    IKsFilter_fnAddProcessPin,
    IKsFilter_fnRemoveProcessPin,
    IKsFilter_fnReprepareProcessPipeSection,
    IKsFilter_fnDeliverResetState,
    IKsFilter_fnIsFrameHolding,
    IKsFilter_fnRegisterForCopyCallbacks,
    IKsFilter_fnGetProcessDispatch
};
 
NTSTATUS
IKsFilter_GetFilterFromIrp(
    IN PIRP Irp,
    OUT IKsFilter **Filter)
{
    PIO_STACK_LOCATION IoStack;
    PKSIOBJECT_HEADER ObjectHeader;
    NTSTATUS Status;
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity check */
    ASSERT(IoStack->FileObject != NULL);
 
    ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
 
    /* sanity is important */
    ASSERT(ObjectHeader != NULL);
    ASSERT(ObjectHeader->Type == KsObjectTypeFilter);
    ASSERT(ObjectHeader->Unknown != NULL);
 
    /* get our private interface */
    Status = ObjectHeader->Unknown->lpVtbl->QueryInterface(ObjectHeader->Unknown, &IID_IKsFilter, (PVOID*)Filter);
 
    if (!NT_SUCCESS(Status))
    {
        /* something is wrong here */
        DPRINT1("KS: Misbehaving filter %p\n", ObjectHeader->Unknown);
        Irp->IoStatus.Status = Status;
 
        /* complete and forget irp */
        CompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
    return Status;
}
 
 
NTSTATUS
NTAPI
IKsFilter_DispatchClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    IKsFilter * Filter;
    IKsFilterImpl * This;
    NTSTATUS Status;
 
    /* obtain filter from object header */
    Status = IKsFilter_GetFilterFromIrp(Irp, &Filter);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* get our real implementation */
    This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Header.OuterUnknown);
 
    /* does the driver support notifications */
    if (This->Filter.Descriptor && This->Filter.Descriptor->Dispatch && This->Filter.Descriptor->Dispatch->Close)
    {
        /* call driver's filter close function */
        Status = This->Filter.Descriptor->Dispatch->Close(&This->Filter, Irp);
    }
 
    if (NT_SUCCESS(Status) && Status != STATUS_PENDING)
    {
        /* save the result */
        Irp->IoStatus.Status = Status;
        /* complete irp */
        CompleteRequest(Irp, IO_NO_INCREMENT);
 
        /* remove our instance from the filter factory */
        IKsFilter_RemoveFilterFromFilterFactory(This, This->Factory);
 
        /* free object header */
        KsFreeObjectHeader(This->ObjectHeader);
    }
    else
    {
        /* complete and forget */
        Irp->IoStatus.Status = Status;
        /* complete irp */
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    /* done */
    return Status;
}
 
NTSTATUS
KspHandlePropertyInstances(
    IN PIO_STATUS_BLOCK IoStatus,
    IN PKSIDENTIFIER  Request,
    IN OUT PVOID  Data,
    IN IKsFilterImpl * This,
    IN BOOL Global)
{
    KSPIN_CINSTANCES * Instances;
    KSP_PIN * Pin = (KSP_PIN*)Request;
 
    if (!This->Filter.Descriptor || !This->Filter.Descriptor->PinDescriptorsCount)
    {
        /* no filter / pin descriptor */
        IoStatus->Status = STATUS_NOT_IMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* ignore custom structs for now */
    ASSERT(This->Filter.Descriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
    ASSERT(This->Filter.Descriptor->PinDescriptorsCount > Pin->PinId);
 
    Instances = (KSPIN_CINSTANCES*)Data;
    /* max instance count */
    Instances->PossibleCount = This->Filter.Descriptor->PinDescriptors[Pin->PinId].InstancesPossible;
    /* current instance count */
    Instances->CurrentCount = This->PinInstanceCount[Pin->PinId];
 
    IoStatus->Information = sizeof(KSPIN_CINSTANCES);
    IoStatus->Status = STATUS_SUCCESS;
    return STATUS_SUCCESS;
}
 
NTSTATUS
KspHandleNecessaryPropertyInstances(
    IN PIO_STATUS_BLOCK IoStatus,
    IN PKSIDENTIFIER  Request,
    IN OUT PVOID  Data,
    IN IKsFilterImpl * This)
{
    PULONG Result;
    KSP_PIN * Pin = (KSP_PIN*)Request;
 
    if (!This->Filter.Descriptor || !This->Filter.Descriptor->PinDescriptorsCount)
    {
        /* no filter / pin descriptor */
        IoStatus->Status = STATUS_NOT_IMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* ignore custom structs for now */
    ASSERT(This->Filter.Descriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
    ASSERT(This->Filter.Descriptor->PinDescriptorsCount > Pin->PinId);
 
    Result = (PULONG)Data;
    *Result = This->Filter.Descriptor->PinDescriptors[Pin->PinId].InstancesNecessary;
 
    IoStatus->Information = sizeof(ULONG);
    IoStatus->Status = STATUS_SUCCESS;
    return STATUS_SUCCESS;
}
 
NTSTATUS
KspHandleDataIntersection(
    IN PIRP Irp,
    IN PIO_STATUS_BLOCK IoStatus,
    IN PKSIDENTIFIER Request,
    IN OUT PVOID  Data,
    IN ULONG DataLength,
    IN IKsFilterImpl * This)
{
    PKSMULTIPLE_ITEM MultipleItem;
    PKSDATARANGE DataRange;
    NTSTATUS Status = STATUS_NO_MATCH;
    ULONG Index, Length;
    PIO_STACK_LOCATION IoStack;
    KSP_PIN * Pin = (KSP_PIN*)Request;
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity check */
    ASSERT(DataLength == IoStack->Parameters.DeviceIoControl.OutputBufferLength);
 
    /* Access parameters */
    MultipleItem = (PKSMULTIPLE_ITEM)(Pin + 1);
    DataRange = (PKSDATARANGE)(MultipleItem + 1);
 
    /* FIXME make sure its 64 bit aligned */
    ASSERT(((ULONG_PTR)DataRange & 0x7) == 0);
 
    if (!This->Filter.Descriptor || !This->Filter.Descriptor->PinDescriptorsCount)
    {
        /* no filter / pin descriptor */
        IoStatus->Status = STATUS_NOT_IMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* ignore custom structs for now */
    ASSERT(This->Filter.Descriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
    ASSERT(This->Filter.Descriptor->PinDescriptorsCount > Pin->PinId);
 
    if (This->Filter.Descriptor->PinDescriptors[Pin->PinId].IntersectHandler == NULL ||
        This->Filter.Descriptor->PinDescriptors[Pin->PinId].PinDescriptor.DataRanges == NULL ||
        This->Filter.Descriptor->PinDescriptors[Pin->PinId].PinDescriptor.DataRangesCount == 0)
    {
        /* no driver supported intersect handler / no provided data ranges */
        IoStatus->Status = STATUS_NOT_IMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
    for(Index = 0; Index < MultipleItem->Count; Index++)
    {
        UNICODE_STRING MajorFormat, SubFormat, Specifier;
        /* convert the guid to string */
        RtlStringFromGUID(&DataRange->MajorFormat, &MajorFormat);
        RtlStringFromGUID(&DataRange->SubFormat, &SubFormat);
        RtlStringFromGUID(&DataRange->Specifier, &Specifier);
 
        DPRINT("KspHandleDataIntersection Index %lu PinId %lu MajorFormat %S SubFormat %S Specifier %S FormatSize %lu SampleSize %lu Align %lu Flags %lx Reserved %lx DataLength %lu\n", Index, Pin->PinId, MajorFormat.Buffer, SubFormat.Buffer, Specifier.Buffer,
               DataRange->FormatSize, DataRange->SampleSize, DataRange->Alignment, DataRange->Flags, DataRange->Reserved, DataLength);
 
        /* FIXME implement KsPinDataIntersectionEx */
        /* Call miniport's proprietary handler */
        Status = This->Filter.Descriptor->PinDescriptors[Pin->PinId].IntersectHandler(&This->Filter,
                                                                                      Irp,
                                                                                      Pin,
                                                                                      DataRange,
                                                                                      This->Filter.Descriptor->PinDescriptors[Pin->PinId].PinDescriptor.DataRanges[0], /* HACK */
                                                                                      DataLength,
                                                                                      Data,
                                                                                      &Length);
        DPRINT("KspHandleDataIntersection Status %lx\n", Status);
 
        if (Status == STATUS_SUCCESS || Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
        {
            ASSERT(Length);
            IoStatus->Information = Length;
            break;
        }
 
        DataRange = (PKSDATARANGE)((PUCHAR)DataRange + DataRange->FormatSize);
        /* FIXME make sure its 64 bit aligned */
        ASSERT(((ULONG_PTR)DataRange & 0x7) == 0);
    }
    IoStatus->Status = Status;
    return Status;
}
 
NTSTATUS
NTAPI
FilterTopologyPropertyHandler(
    IN PIRP Irp,
    IN PKSIDENTIFIER  Request,
    IN OUT PVOID  Data)
{
    IKsFilterImpl * This;
 
    /* get filter implementation */
    This = (IKsFilterImpl*)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
 
    /* sanity check */
    ASSERT(This);
 
    return KsTopologyPropertyHandler(Irp, Request, Data, &This->Topology);
 
}
 
NTSTATUS
NTAPI
FilterGeneralComponentIdHandler(
    IN PIRP Irp,
    IN PKSIDENTIFIER  Request,
    IN OUT PVOID  Data)
{
    PIO_STACK_LOCATION IoStack;
    IKsFilterImpl * This;
 
    /* get filter implementation */
    This = (IKsFilterImpl*)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
 
    /* sanity check */
    ASSERT(This);
 
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    ASSERT(IoStack->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(KSCOMPONENTID));
 
    if (This->Filter.Descriptor->ComponentId != NULL)
    {
        RtlMoveMemory(Data, This->Filter.Descriptor->ComponentId, sizeof(KSCOMPONENTID));
        Irp->IoStatus.Information = sizeof(KSCOMPONENTID);
        return STATUS_SUCCESS;
    }
    else
    {
        /* not valid */
        return STATUS_NOT_FOUND;
    }
 
}
 
NTSTATUS
NTAPI
FilterPinPropertyHandler(
    IN PIRP Irp,
    IN PKSIDENTIFIER  Request,
    IN OUT PVOID  Data)
{
    PIO_STACK_LOCATION IoStack;
    IKsFilterImpl * This;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    /* get filter implementation */
    This = (IKsFilterImpl*)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
 
    /* sanity check */
    ASSERT(This);
 
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch(Request->Id)
    {
        case KSPROPERTY_PIN_CTYPES:
        case KSPROPERTY_PIN_DATAFLOW:
        case KSPROPERTY_PIN_DATARANGES:
        case KSPROPERTY_PIN_INTERFACES:
        case KSPROPERTY_PIN_MEDIUMS:
        case KSPROPERTY_PIN_COMMUNICATION:
        case KSPROPERTY_PIN_CATEGORY:
        case KSPROPERTY_PIN_NAME:
        case KSPROPERTY_PIN_CONSTRAINEDDATARANGES:
            Status = KspPinPropertyHandler(Irp, Request, Data, This->Filter.Descriptor->PinDescriptorsCount, (const KSPIN_DESCRIPTOR*)This->Filter.Descriptor->PinDescriptors, This->Filter.Descriptor->PinDescriptorSize);
            break;
        case KSPROPERTY_PIN_GLOBALCINSTANCES:
            Status = KspHandlePropertyInstances(&Irp->IoStatus, Request, Data, This, TRUE);
            break;
        case KSPROPERTY_PIN_CINSTANCES:
            Status = KspHandlePropertyInstances(&Irp->IoStatus, Request, Data, This, FALSE);
            break;
        case KSPROPERTY_PIN_NECESSARYINSTANCES:
            Status = KspHandleNecessaryPropertyInstances(&Irp->IoStatus, Request, Data, This);
            break;
 
        case KSPROPERTY_PIN_DATAINTERSECTION:
            Status = KspHandleDataIntersection(Irp, &Irp->IoStatus, Request, Data, IoStack->Parameters.DeviceIoControl.OutputBufferLength, This);
            break;
        default:
            UNIMPLEMENTED;
            Status = STATUS_NOT_FOUND;
    }
    DPRINT("KspPinPropertyHandler Pins %lu Request->Id %lu Status %lx\n", This->Filter.Descriptor->PinDescriptorsCount, Request->Id, Status);
 
 
    return Status;
}
 
NTSTATUS
NTAPI
IKsFilter_DispatchDeviceIoControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    PIO_STACK_LOCATION IoStack;
    IKsFilter * Filter;
    IKsFilterImpl * This;
    NTSTATUS Status;
    PKSFILTER FilterInstance;
    UNICODE_STRING GuidString;
    PKSPROPERTY Property;
    ULONG SetCount = 0;
    PKSP_NODE NodeProperty;
    PKSNODE_DESCRIPTOR NodeDescriptor;
 
    /* obtain filter from object header */
    Status = IKsFilter_GetFilterFromIrp(Irp, &Filter);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* get our real implementation */
    This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Header.OuterUnknown);
 
    /* current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get property from input buffer */
    Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 
    /* get filter instance */
    FilterInstance = Filter->lpVtbl->GetStruct(Filter);
 
    /* sanity check */
    ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSIDENTIFIER));
    ASSERT(FilterInstance);
    ASSERT(FilterInstance->Descriptor);
    ASSERT(FilterInstance->Descriptor->AutomationTable);
 
    /* acquire control mutex */
    KeWaitForSingleObject(This->Header.ControlMutex, Executive, KernelMode, FALSE, NULL);
 
    if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_METHOD)
    {
        const KSMETHOD_SET *MethodSet = NULL;
        ULONG MethodItemSize = 0;
 
        /* check if the driver supports method sets */
        if (FilterInstance->Descriptor->AutomationTable->MethodSetsCount)
        {
            SetCount = FilterInstance->Descriptor->AutomationTable->MethodSetsCount;
            MethodSet = FilterInstance->Descriptor->AutomationTable->MethodSets;
            MethodItemSize = FilterInstance->Descriptor->AutomationTable->MethodItemSize;
        }
 
        /* call method set handler */
        Status = KspMethodHandlerWithAllocator(Irp, SetCount, MethodSet, NULL, MethodItemSize);
    }
    else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY)
    {
        const KSPROPERTY_SET *PropertySet = NULL;
        ULONG PropertyItemSize = 0;
 
        /* check if the driver supports method sets */
        if (Property->Flags & KSPROPERTY_TYPE_TOPOLOGY)
        {
            ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSP_NODE));
            NodeProperty = (PKSP_NODE)Property;
            NodeDescriptor = (PKSNODE_DESCRIPTOR)((ULONG_PTR)FilterInstance->Descriptor->NodeDescriptors + FilterInstance->Descriptor->NodeDescriptorSize * NodeProperty->NodeId);
            if (NodeDescriptor->AutomationTable != NULL)
            {
                SetCount = NodeDescriptor->AutomationTable->PropertySetsCount;
                PropertySet = NodeDescriptor->AutomationTable->PropertySets;
                PropertyItemSize = 0;
            }
        }
        else if (FilterInstance->Descriptor->AutomationTable->PropertySetsCount)
        {
            SetCount = FilterInstance->Descriptor->AutomationTable->PropertySetsCount;
            PropertySet = FilterInstance->Descriptor->AutomationTable->PropertySets;
            PropertyItemSize = FilterInstance->Descriptor->AutomationTable->PropertyItemSize;
            // FIXME: handle variable sized property items
            ASSERT(PropertyItemSize == sizeof(KSPROPERTY_ITEM));
            PropertyItemSize = 0;
        }
 
        /* needed for our property handlers */
        KSPROPERTY_ITEM_IRP_STORAGE(Irp) = (KSPROPERTY_ITEM*)This;
 
        /* call property handler */
        Status = KspPropertyHandler(Irp, SetCount, PropertySet, NULL, PropertyItemSize);
    }
    else
    {
        /* sanity check */
        ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT ||
               IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_DISABLE_EVENT);
 
        if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT)
        {
            /* call enable event handlers */
            Status = KspEnableEvent(Irp,
                                    FilterInstance->Descriptor->AutomationTable->EventSetsCount,
                                    (PKSEVENT_SET)FilterInstance->Descriptor->AutomationTable->EventSets,
                                    &This->Header.EventList,
                                    KSEVENTS_SPINLOCK,
                                    (PVOID)&This->Header.EventListLock,
                                    NULL,
                                    FilterInstance->Descriptor->AutomationTable->EventItemSize);
        }
        else
        {
            /* disable event handler */
            Status = KsDisableEvent(Irp, &This->Header.EventList, KSEVENTS_SPINLOCK, &This->Header.EventListLock);
        }
    }
 
    RtlStringFromGUID(&Property->Set, &GuidString);
    DPRINT("IKsFilter_DispatchDeviceIoControl property PinCount %x\n", FilterInstance->Descriptor->PinDescriptorsCount);
    DPRINT("IKsFilter_DispatchDeviceIoControl property Set |%S| Id %u Flags %x Status %lx ResultLength %lu\n", GuidString.Buffer, Property->Id, Property->Flags, Status, Irp->IoStatus.Information);
    RtlFreeUnicodeString(&GuidString);
 
    /* release filter */
    Filter->lpVtbl->Release(Filter);
 
    /* release control mutex */
    KeReleaseMutex(This->Header.ControlMutex, FALSE);
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    /* done */
    return Status;
}
 
static KSDISPATCH_TABLE DispatchTable =
{
    IKsFilter_DispatchDeviceIoControl,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    KsDispatchInvalidDeviceRequest,
    IKsFilter_DispatchClose,
    KsDispatchQuerySecurity,
    KsDispatchSetSecurity,
    KsDispatchFastIoDeviceControlFailure,
    KsDispatchFastReadFailure,
    KsDispatchFastReadFailure,
};
 
 
NTSTATUS
IKsFilter_CreateDescriptors(
    IKsFilterImpl * This,
    KSFILTER_DESCRIPTOR* FilterDescriptor)
{
    ULONG Index = 0;
    NTSTATUS Status;
    PKSNODE_DESCRIPTOR NodeDescriptor;
 
    /* initialize pin descriptors */
    This->FirstPin = NULL;
    This->PinInstanceCount = NULL;
    This->ProcessPinIndex = NULL;
 
    /* initialize topology descriptor */
    This->Topology.CategoriesCount = FilterDescriptor->CategoriesCount;
    This->Topology.Categories = FilterDescriptor->Categories;
    This->Topology.TopologyNodesCount = FilterDescriptor->NodeDescriptorsCount;
    This->Topology.TopologyConnectionsCount = FilterDescriptor->ConnectionsCount;
    This->Topology.TopologyConnections = FilterDescriptor->Connections;
 
    /* are there any templates */
    if (FilterDescriptor->PinDescriptorsCount)
    {
        /* sanity check */
        ASSERT(FilterDescriptor->PinDescriptors);
 
        /* FIXME handle variable sized pin descriptors */
        ASSERT(FilterDescriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
 
        /* store pin descriptors ex */
        Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->Filter.Descriptor->PinDescriptors, FilterDescriptor->PinDescriptorSize * FilterDescriptor->PinDescriptorsCount,
                         FilterDescriptor->PinDescriptorSize * FilterDescriptor->PinDescriptorsCount, 0);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IKsFilter_CreateDescriptors _KsEdit failed %lx\n", Status);
            return Status;
        }
 
        /* store pin instance count */
        Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->PinInstanceCount, sizeof(ULONG) * FilterDescriptor->PinDescriptorsCount,
                         sizeof(ULONG) * FilterDescriptor->PinDescriptorsCount, 0);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IKsFilter_CreateDescriptors _KsEdit failed %lx\n", Status);
            return Status;
        }
 
        /* store instantiated pin arrays */
        Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->FirstPin, sizeof(PVOID) * FilterDescriptor->PinDescriptorsCount,
                         sizeof(PVOID) * FilterDescriptor->PinDescriptorsCount, 0);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IKsFilter_CreateDescriptors _KsEdit failed %lx\n", Status);
            return Status;
        }
 
        /* add new pin factory */
        RtlMoveMemory((PVOID)This->Filter.Descriptor->PinDescriptors, FilterDescriptor->PinDescriptors, FilterDescriptor->PinDescriptorSize * FilterDescriptor->PinDescriptorsCount);
 
        /* allocate process pin index */
        Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->ProcessPinIndex, sizeof(KSPROCESSPIN_INDEXENTRY) * FilterDescriptor->PinDescriptorsCount,
                         sizeof(KSPROCESSPIN_INDEXENTRY) * FilterDescriptor->PinDescriptorsCount, 0);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IKsFilter_CreateDescriptors _KsEdit failed %lx\n", Status);
            return Status;
        }
 
    }
 
 
    if (FilterDescriptor->ConnectionsCount)
    {
        /* modify connections array */
        Status = _KsEdit(This->Filter.Bag,
                        (PVOID*)&This->Filter.Descriptor->Connections,
                         FilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION),
                         FilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION),
                         0);
 
       This->Topology.TopologyConnections = This->Filter.Descriptor->Connections;
       This->Topology.TopologyConnectionsCount = ((PKSFILTER_DESCRIPTOR)This->Filter.Descriptor)->ConnectionsCount = FilterDescriptor->ConnectionsCount;
    }
 
    if (FilterDescriptor->NodeDescriptorsCount)
    {
        /* sanity check */
        ASSERT(FilterDescriptor->NodeDescriptors);
 
        /* sanity check */
        ASSERT(FilterDescriptor->NodeDescriptorSize >= sizeof(KSNODE_DESCRIPTOR));
 
        This->Topology.TopologyNodes = AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescriptor->NodeDescriptorsCount);
        /* allocate topology node types array */
        if (!This->Topology.TopologyNodes)
        {
            DPRINT("IKsFilter_CreateDescriptors OutOfMemory TopologyNodesCount %lu\n", FilterDescriptor->NodeDescriptorsCount);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        This->Topology.TopologyNodesNames = AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescriptor->NodeDescriptorsCount);
        /* allocate topology names array */
        if (!This->Topology.TopologyNodesNames)
        {
            FreeItem((PVOID)This->Topology.TopologyNodes);
            DPRINT("IKsFilter_CreateDescriptors OutOfMemory TopologyNodesCount %lu\n", FilterDescriptor->NodeDescriptorsCount);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        DPRINT("NodeDescriptorCount %lu\n", FilterDescriptor->NodeDescriptorsCount);
        NodeDescriptor = (PKSNODE_DESCRIPTOR)FilterDescriptor->NodeDescriptors;
        for(Index = 0; Index < FilterDescriptor->NodeDescriptorsCount; Index++)
        {
            DPRINT("Index %lu Type %p Name %p\n", Index, NodeDescriptor->Type, NodeDescriptor->Name);
 
            /* copy topology type */
            if (NodeDescriptor->Type)
                RtlMoveMemory((PVOID)&This->Topology.TopologyNodes[Index], NodeDescriptor->Type, sizeof(GUID));
 
            /* copy topology name */
            if (NodeDescriptor->Name)
                RtlMoveMemory((PVOID)&This->Topology.TopologyNodesNames[Index], NodeDescriptor->Name, sizeof(GUID));
 
            // next node descriptor
            NodeDescriptor = (PKSNODE_DESCRIPTOR)((ULONG_PTR)NodeDescriptor + FilterDescriptor->NodeDescriptorSize);
        }
    }
    /* done! */
    return STATUS_SUCCESS;
}
 
NTSTATUS
IKsFilter_CopyFilterDescriptor(
    IKsFilterImpl * This,
    const KSFILTER_DESCRIPTOR* FilterDescriptor)
{
    NTSTATUS Status;
    KSAUTOMATION_TABLE AutomationTable;
 
    This->Filter.Descriptor = AllocateItem(NonPagedPool, sizeof(KSFILTER_DESCRIPTOR));
    if (!This->Filter.Descriptor)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = KsAddItemToObjectBag(This->Filter.Bag, (PVOID)This->Filter.Descriptor, NULL);
    if (!NT_SUCCESS(Status))
    {
        FreeItem((PVOID)This->Filter.Descriptor);
        This->Filter.Descriptor = NULL;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy filter descriptor fields */
    RtlMoveMemory((PVOID)This->Filter.Descriptor, FilterDescriptor, sizeof(KSFILTER_DESCRIPTOR));
 
    /* zero automation table */
    RtlZeroMemory(&AutomationTable, sizeof(KSAUTOMATION_TABLE));
 
    /* setup filter property sets */
    AutomationTable.PropertyItemSize = sizeof(KSPROPERTY_ITEM);
    AutomationTable.PropertySetsCount = 3;
    AutomationTable.PropertySets = FilterPropertySet;
 
    /* merge filter automation table */
    Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&This->Filter.Descriptor->AutomationTable, (PKSAUTOMATION_TABLE)FilterDescriptor->AutomationTable, &AutomationTable, This->Filter.Bag);
 
    return Status;
}
 
 
VOID
IKsFilter_AddPin(
    PKSFILTER Filter,
    PKSPIN Pin)
{
    PKSPIN NextPin, CurPin;
    PKSBASIC_HEADER BasicHeader;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* sanity check */
    ASSERT(Pin->Id < This->Filter.Descriptor->PinDescriptorsCount);
 
    if (This->FirstPin[Pin->Id] == NULL)
    {
        /* welcome first pin */
        This->FirstPin[Pin->Id] = Pin;
        This->PinInstanceCount[Pin->Id]++;
        return;
    }
 
    /* get first pin */
    CurPin = This->FirstPin[Pin->Id];
 
    do
    {
        /* get next instantiated pin */
        NextPin = KsPinGetNextSiblingPin(CurPin);
        if (!NextPin)
            break;
 
        NextPin = CurPin;
 
    }while(NextPin != NULL);
 
    /* get basic header */
    BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)CurPin - sizeof(KSBASIC_HEADER));
 
    /* store pin */
    BasicHeader->Next.Pin = Pin;
}
 
VOID
IKsFilter_RemovePin(
    PKSFILTER Filter,
    PKSPIN Pin)
{
    PKSPIN NextPin, CurPin, LastPin;
    PKSBASIC_HEADER BasicHeader;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* sanity check */
    ASSERT(Pin->Id < This->Filter.Descriptor->PinDescriptorsCount);
 
    /* get first pin */
    CurPin = This->FirstPin[Pin->Id];
 
    LastPin = NULL;
    do
    {
        /* get next instantiated pin */
        NextPin = KsPinGetNextSiblingPin(CurPin);
 
        if (CurPin == Pin)
        {
            if (LastPin)
            {
                /* get basic header of last pin */
                BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)LastPin - sizeof(KSBASIC_HEADER));
 
                BasicHeader->Next.Pin = NextPin;
            }
            else
            {
                /* erase last pin */
                This->FirstPin[Pin->Id] = NextPin;
            }
            /* decrement pin instance count */
            This->PinInstanceCount[Pin->Id]--;
            return;
        }
 
        if (!NextPin)
            break;
 
        LastPin = CurPin;
        NextPin = CurPin;
 
    }while(NextPin != NULL);
 
    /* pin not found */
    ASSERT(0);
}
 
 
NTSTATUS
NTAPI
IKsFilter_DispatchCreatePin(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    IKsFilterImpl * This;
    PKSOBJECT_CREATE_ITEM CreateItem;
    PKSPIN_CONNECT Connect;
    NTSTATUS Status;
 
    DPRINT("IKsFilter_DispatchCreatePin\n");
 
    /* get the create item */
    CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
 
    /* get the filter object */
    This = (IKsFilterImpl*)CreateItem->Context;
 
    /* sanity check */
    ASSERT(This->Header.Type == KsObjectTypeFilter);
 
    /* acquire control mutex */
    KeWaitForSingleObject(This->Header.ControlMutex, Executive, KernelMode, FALSE, NULL);
 
    /* now validate the connect request */
    Status = KspValidateConnectRequest(Irp, This->Filter.Descriptor->PinDescriptorsCount, (PVOID)This->Filter.Descriptor->PinDescriptors, This->Filter.Descriptor->PinDescriptorSize, &Connect);
 
    DPRINT("IKsFilter_DispatchCreatePin KsValidateConnectRequest %lx\n", Status);
 
    if (NT_SUCCESS(Status))
    {
        /* sanity check */
        ASSERT(Connect->PinId < This->Filter.Descriptor->PinDescriptorsCount);
 
        DPRINT("IKsFilter_DispatchCreatePin KsValidateConnectRequest PinId %lu CurrentInstanceCount %lu MaxPossible %lu\n", Connect->PinId,
               This->PinInstanceCount[Connect->PinId],
               This->Filter.Descriptor->PinDescriptors[Connect->PinId].InstancesPossible);
 
        if (This->PinInstanceCount[Connect->PinId] < This->Filter.Descriptor->PinDescriptors[Connect->PinId].InstancesPossible)
        {
            /* create the pin */
            Status = KspCreatePin(DeviceObject, Irp, This->Header.KsDevice, This->FilterFactory, (IKsFilter*)&This->Header.OuterUnknown, Connect, (KSPIN_DESCRIPTOR_EX*)&This->Filter.Descriptor->PinDescriptors[Connect->PinId]);
 
            DPRINT("IKsFilter_DispatchCreatePin  KspCreatePin %lx\n", Status);
        }
        else
        {
            /* maximum instance count reached, bye-bye */
            Status = STATUS_UNSUCCESSFUL;
            DPRINT("IKsFilter_DispatchCreatePin  MaxInstance %lu CurInstance %lu %lx\n", This->Filter.Descriptor->PinDescriptors[Connect->PinId].InstancesPossible, This->PinInstanceCount[Connect->PinId]);
        }
    }
 
    /* release control mutex */
    KeReleaseMutex(This->Header.ControlMutex, FALSE);
 
    if (Status != STATUS_PENDING)
    {
        /* complete request */
        Irp->IoStatus.Status = Status;
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    /* done */
    DPRINT("IKsFilter_DispatchCreatePin Result %lx\n", Status);
    return Status;
}
 
NTSTATUS
NTAPI
IKsFilter_DispatchCreateNode(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    UNIMPLEMENTED;
    Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
    CompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_UNSUCCESSFUL;
}
 
 
VOID
IKsFilter_AttachFilterToFilterFactory(
    IKsFilterImpl * This,
    PKSFILTERFACTORY FilterFactory)
{
    PKSBASIC_HEADER BasicHeader;
    PKSFILTER Filter;
 
 
    /* get filter factory basic header */
    BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)FilterFactory - sizeof(KSBASIC_HEADER));
 
    /* sanity check */
    ASSERT(BasicHeader->Type == KsObjectTypeFilterFactory);
 
    if (BasicHeader->FirstChild.FilterFactory == NULL)
    {
        /* welcome first instantiated filter */
        BasicHeader->FirstChild.Filter = &This->Filter;
        return;
    }
 
    /* set to first entry */
    Filter = BasicHeader->FirstChild.Filter;
 
    do
    {
        /* get basic header */
        BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Filter - sizeof(KSBASIC_HEADER));
        /* sanity check */
        ASSERT(BasicHeader->Type == KsObjectTypeFilter);
 
        if (BasicHeader->Next.Filter)
        {
            /* iterate to next filter factory */
            Filter = BasicHeader->Next.Filter;
        }
        else
        {
            /* found last entry */
            break;
        }
    }while(TRUE);
 
    /* attach filter factory */
    BasicHeader->Next.Filter = &This->Filter;
}
 
VOID
IKsFilter_RemoveFilterFromFilterFactory(
    IKsFilterImpl * This,
    PKSFILTERFACTORY FilterFactory)
{
    PKSBASIC_HEADER BasicHeader;
    PKSFILTER Filter, LastFilter;
 
    /* get filter factory basic header */
    BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)FilterFactory - sizeof(KSBASIC_HEADER));
 
    /* sanity check */
    ASSERT(BasicHeader->Type == KsObjectTypeFilterFactory);
    ASSERT(BasicHeader->FirstChild.Filter != NULL);
 
 
    /* set to first entry */
    Filter = BasicHeader->FirstChild.Filter;
    LastFilter = NULL;
 
    do
    {
         if (Filter == &This->Filter)
         {
             if (LastFilter)
             {
                 /* get basic header */
                 BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)LastFilter - sizeof(KSBASIC_HEADER));
                 /* remove filter instance */
                 BasicHeader->Next.Filter = This->Header.Next.Filter;
                 break;
             }
             else
             {
                 /* remove filter instance */
                 BasicHeader->FirstChild.Filter = This->Header.Next.Filter;
                 break;
             }
         }
 
        /* get basic header */
        BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)Filter - sizeof(KSBASIC_HEADER));
        /* sanity check */
        ASSERT(BasicHeader->Type == KsObjectTypeFilter);
 
        LastFilter = Filter;
        if (BasicHeader->Next.Filter)
        {
            /* iterate to next filter factory */
            Filter = BasicHeader->Next.Filter;
        }
        else
        {
            /* filter is not in list */
            ASSERT(0);
            break;
        }
    }while(TRUE);
}
 
VOID
NTAPI
IKsFilter_FilterCentricWorker(
    IN PVOID Ctx)
{
    IKsProcessingObject * Object = (IKsProcessingObject*)Ctx;
 
    /* sanity check */
    ASSERT(Object);
 
    /* perform work */
    Object->lpVtbl->ProcessingObjectWork(Object);
}
 
NTSTATUS
NTAPI
KspCreateFilter(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN IKsFilterFactory *iface)
{
    IKsFilterImpl * This;
    IKsDevice *KsDevice;
    PKSFILTERFACTORY Factory;
    PIO_STACK_LOCATION IoStack;
    PDEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    PKSOBJECT_CREATE_ITEM CreateItem;
 
    /* get device extension */
    DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get the filter factory */
    Factory = iface->lpVtbl->GetStruct(iface);
 
    if (!Factory || !Factory->FilterDescriptor)
    {
        /* Sorry it just will not work */
        return STATUS_UNSUCCESSFUL;
    }
 
    if (Factory->FilterDescriptor->Flags & KSFILTER_FLAG_DENY_USERMODE_ACCESS)
    {
        if (Irp->RequestorMode == UserMode)
        {
            /* filter not accessible from user mode */
            DPRINT1("Access denied\n");
            return STATUS_UNSUCCESSFUL;
        }
    }
 
    /* allocate filter instance */
    This = AllocateItem(NonPagedPool, sizeof(IKsFilterImpl));
    if (!This)
    {
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize object bag */
    This->Filter.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
    if (!This->Filter.Bag)
    {
        /* no memory */
        FreeItem(This);
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    KsDevice = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
    KsDevice->lpVtbl->InitializeObjectBag(KsDevice, (PKSIOBJECT_BAG)This->Filter.Bag, NULL);
 
    /* copy filter descriptor */
    Status = IKsFilter_CopyFilterDescriptor(This, Factory->FilterDescriptor);
    if (!NT_SUCCESS(Status))
    {
        /* not enough memory */
        FreeItem(This->Filter.Bag);
        FreeItem(This);
        DPRINT("KspCreateFilter IKsFilter_CopyFilterDescriptor failed %lx\n", Status);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* get current irp stack */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* allocate create items */
    CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * 2);
    if (!CreateItem)
    {
        /* no memory */
        FreeItem(This->Filter.Bag);
        FreeItem(This);
        DPRINT1("KspCreateFilter OutOfMemory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* initialize pin create item */
    CreateItem[0].Create = IKsFilter_DispatchCreatePin;
    CreateItem[0].Context = (PVOID)This;
    CreateItem[0].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[0].ObjectClass, KSSTRING_Pin);
    /* initialize node create item */
    CreateItem[1].Create = IKsFilter_DispatchCreateNode;
    CreateItem[1].Context = (PVOID)This;
    CreateItem[1].Flags = KSCREATE_ITEM_FREEONSTOP;
    RtlInitUnicodeString(&CreateItem[1].ObjectClass, KSSTRING_TopologyNode);
 
 
    /* initialize filter instance */
    This->ref = 1;
    This->Header.OuterUnknown = (PUNKNOWN)&vt_IKsFilter;
    This->lpVtblKsControl = &vt_IKsControl;
    This->lpVtblKsProcessingObject = &vt_IKsProcessingObject;
 
    This->Factory = Factory;
    This->FilterFactory = iface;
    This->FileObject = IoStack->FileObject;
    KeInitializeMutex(&This->ProcessingMutex, 0);
 
    /* initialize basic header */
    This->Header.KsDevice = &DeviceExtension->DeviceHeader->KsDevice;
    This->Header.Parent.KsFilterFactory = iface->lpVtbl->GetStruct(iface);
    This->Header.Type = KsObjectTypeFilter;
    This->Header.ControlMutex = &This->ControlMutex;
    KeInitializeMutex(This->Header.ControlMutex, 0);
    InitializeListHead(&This->Header.EventList);
    KeInitializeSpinLock(&This->Header.EventListLock);
 
    /* initialize and gate */
    KsGateInitializeAnd(&This->Gate, NULL);
 
    /* FIXME initialize and gate based on pin flags */
 
    /* initialize work item */
    ExInitializeWorkItem(&This->WorkItem, IKsFilter_FilterCentricWorker, (PVOID)This->lpVtblKsProcessingObject);
 
    /* allocate counted work item */
    Status = KsRegisterCountedWorker(HyperCriticalWorkQueue, &This->WorkItem, &This->Worker);
    if (!NT_SUCCESS(Status))
    {
        /* what can go wrong, goes wrong */
        DPRINT1("KsRegisterCountedWorker failed with %lx\n", Status);
        FreeItem(This);
        FreeItem(CreateItem);
        return Status;
    }
 
    /* allocate the stream descriptors */
    Status = IKsFilter_CreateDescriptors(This, (PKSFILTER_DESCRIPTOR)Factory->FilterDescriptor);
    if (!NT_SUCCESS(Status))
    {
        /* what can go wrong, goes wrong */
        DPRINT1("IKsFilter_CreateDescriptors failed with %lx\n", Status);
        KsUnregisterWorker(This->Worker);
        FreeItem(This);
        FreeItem(CreateItem);
        return Status;
    }
 
 
 
    /* does the filter have a filter dispatch */
    if (Factory->FilterDescriptor->Dispatch)
    {
        /* does it have a create routine */
        if (Factory->FilterDescriptor->Dispatch->Create)
        {
            /* now let driver initialize the filter instance */
 
            ASSERT(This->Header.KsDevice);
            ASSERT(This->Header.KsDevice->Started);
            Status = Factory->FilterDescriptor->Dispatch->Create(&This->Filter, Irp);
 
            if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
            {
                /* driver failed to initialize */
                DPRINT1("Driver: Status %x\n", Status);
 
                /* free filter instance */
                KsUnregisterWorker(This->Worker);
                FreeItem(This);
                FreeItem(CreateItem);
                return Status;
            }
        }
    }
 
    /* now allocate the object header */
    Status = KsAllocateObjectHeader((PVOID*)&This->ObjectHeader, 2, CreateItem, Irp, &DispatchTable);
    if (!NT_SUCCESS(Status))
    {
        /* failed to allocate object header */
        DPRINT1("Failed to allocate object header %x\n", Status);
 
        return Status;
    }
 
    /* initialize object header extra fields */
    This->ObjectHeader->Type = KsObjectTypeFilter;
    This->ObjectHeader->Unknown = (PUNKNOWN)&This->Header.OuterUnknown;
    This->ObjectHeader->ObjectType = (PVOID)&This->Filter;
 
    /* attach filter to filter factory */
    IKsFilter_AttachFilterToFilterFactory(This, This->Header.Parent.KsFilterFactory);
 
    /* completed initialization */
    DPRINT1("KspCreateFilter done %lx KsDevice %p\n", Status, This->Header.KsDevice);
    return Status;
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsFilterAcquireProcessingMutex(
    IN PKSFILTER Filter)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsFilterReleaseProcessingMutex(
    IN PKSFILTER Filter)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    KeReleaseMutex(&This->ProcessingMutex, FALSE);
}
 
 
/*
    @implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsFilterAddTopologyConnections (
    IN PKSFILTER Filter,
    IN ULONG NewConnectionsCount,
    IN const KSTOPOLOGY_CONNECTION *const NewTopologyConnections)
{
    ULONG Count;
    NTSTATUS Status;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    DPRINT("KsFilterAddTopologyConnections\n");
 
    ASSERT(This->Filter.Descriptor);
    Count = This->Filter.Descriptor->ConnectionsCount + NewConnectionsCount;
 
 
    /* modify connections array */
    Status = _KsEdit(This->Filter.Bag,
                    (PVOID*)&This->Filter.Descriptor->Connections,
                     Count * sizeof(KSTOPOLOGY_CONNECTION),
                     This->Filter.Descriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION),
                     0);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        DPRINT("KsFilterAddTopologyConnections KsEdit failed with %lx\n", Status);
        return Status;
    }
 
    /* FIXME verify connections */
 
    /* copy new connections */
    RtlMoveMemory((PVOID)&This->Filter.Descriptor->Connections[This->Filter.Descriptor->ConnectionsCount],
                  NewTopologyConnections,
                  NewConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION));
 
    /* update topology */
    This->Topology.TopologyConnectionsCount += NewConnectionsCount;
    ((PKSFILTER_DESCRIPTOR)This->Filter.Descriptor)->ConnectionsCount += NewConnectionsCount;
    This->Topology.TopologyConnections = This->Filter.Descriptor->Connections;
 
    return Status;
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsFilterAttemptProcessing(
    IN PKSFILTER Filter,
    IN BOOLEAN Asynchronous)
{
    PKSGATE Gate;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* get gate */
    Gate = This->lpVtblKsProcessingObject->GetAndGate((IKsProcessingObject*)This->lpVtblKsProcessingObject);
 
    if (!KsGateCaptureThreshold(Gate))
    {
        /* filter control gate is closed */
        return;
    }
DPRINT1("processing\n");
    /* try initiate processing */
    This->lpVtblKsProcessingObject->Process((IKsProcessingObject*)This->lpVtblKsProcessingObject, Asynchronous);
}
 
/*
    @unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsFilterCreateNode (
    IN PKSFILTER Filter,
    IN const KSNODE_DESCRIPTOR *const NodeDescriptor,
    OUT PULONG NodeID)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
    @implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsFilterCreatePinFactory (
    IN PKSFILTER Filter,
    IN const KSPIN_DESCRIPTOR_EX *const InPinDescriptor,
    OUT PULONG PinID)
{
    ULONG Count;
    NTSTATUS Status;
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    DPRINT("KsFilterCreatePinFactory\n");
 
    /* calculate new count */
    Count = This->Filter.Descriptor->PinDescriptorsCount + 1;
 
    /* sanity check */
    ASSERT(This->Filter.Descriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
 
    /* modify pin descriptors ex array */
    Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->Filter.Descriptor->PinDescriptors, Count * This->Filter.Descriptor->PinDescriptorSize, This->Filter.Descriptor->PinDescriptorsCount * This->Filter.Descriptor->PinDescriptorSize, 0);
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        DPRINT("KsFilterCreatePinFactory _KsEdit failed with %lx\n", Status);
        return Status;
    }
 
    /* modify pin instance count array */
    Status = _KsEdit(This->Filter.Bag,(PVOID*)&This->PinInstanceCount, sizeof(ULONG) * Count, sizeof(ULONG) * This->Filter.Descriptor->PinDescriptorsCount, 0);
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        DPRINT("KsFilterCreatePinFactory _KsEdit failed with %lx\n", Status);
        return Status;
    }
 
    /* modify first pin array */
    Status = _KsEdit(This->Filter.Bag,(PVOID*)&This->FirstPin, sizeof(PVOID) * Count, sizeof(PVOID) * This->Filter.Descriptor->PinDescriptorsCount, 0);
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        DPRINT("KsFilterCreatePinFactory _KsEdit failed with %lx\n", Status);
        return Status;
    }
 
    /* add new pin factory */
    RtlMoveMemory((PVOID)&This->Filter.Descriptor->PinDescriptors[This->Filter.Descriptor->PinDescriptorsCount], InPinDescriptor, sizeof(KSPIN_DESCRIPTOR_EX));
 
    /* allocate process pin index */
    Status = _KsEdit(This->Filter.Bag, (PVOID*)&This->ProcessPinIndex, sizeof(KSPROCESSPIN_INDEXENTRY) * Count,
                     sizeof(KSPROCESSPIN_INDEXENTRY) * This->Filter.Descriptor->PinDescriptorsCount, 0);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("KsFilterCreatePinFactory _KsEdit failed %lx\n", Status);
        return Status;
    }
 
    /* store new pin id */
    *PinID = This->Filter.Descriptor->PinDescriptorsCount;
 
    /* increment pin descriptor count */
    ((PKSFILTER_DESCRIPTOR)This->Filter.Descriptor)->PinDescriptorsCount++;
 
 
    DPRINT("KsFilterCreatePinFactory done\n");
    return STATUS_SUCCESS;
 
}
 
/*
    @unimplemented
*/
KSDDKAPI
PKSGATE
NTAPI
KsFilterGetAndGate(
    IN PKSFILTER Filter)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    /* return and-gate */
    return &This->Gate;
}
 
/*
    @implemented
*/
KSDDKAPI
ULONG
NTAPI
KsFilterGetChildPinCount(
    IN PKSFILTER Filter,
    IN ULONG PinId)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    if (PinId >= This->Filter.Descriptor->PinDescriptorsCount)
    {
        /* index is out of bounds */
        return 0;
    }
    /* return pin instance count */
    return This->PinInstanceCount[PinId];
}
 
/*
    @implemented
*/
KSDDKAPI
PKSPIN
NTAPI
KsFilterGetFirstChildPin(
    IN PKSFILTER Filter,
    IN ULONG PinId)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    if (PinId >= This->Filter.Descriptor->PinDescriptorsCount)
    {
        /* index is out of bounds */
        return NULL;
    }
 
    /* return first pin index */
    return This->FirstPin[PinId];
}
 
/*
    @implemented
*/
KSDDKAPI
VOID
NTAPI
KsFilterRegisterPowerCallbacks(
    IN PKSFILTER Filter,
    IN PFNKSFILTERPOWER Sleep OPTIONAL,
    IN PFNKSFILTERPOWER Wake OPTIONAL)
{
    IKsFilterImpl * This = (IKsFilterImpl*)CONTAINING_RECORD(Filter, IKsFilterImpl, Filter);
 
    This->Sleep = Sleep;
    This->Wake = Wake;
}
 
/*
    @implemented
*/
KSDDKAPI
PKSFILTER
NTAPI
KsGetFilterFromIrp(
    IN PIRP Irp)
{
    PIO_STACK_LOCATION IoStack;
    PKSIOBJECT_HEADER ObjectHeader;
 
    DPRINT("KsGetFilterFromIrp\n");
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity check */
    ASSERT(IoStack->FileObject);
 
    /* get object header */
    ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
 
    if (ObjectHeader->Type == KsObjectTypeFilter)
    {
        /* irp is targeted at the filter */
        return (PKSFILTER)ObjectHeader->ObjectType;
    }
    else if (ObjectHeader->Type == KsObjectTypePin)
    {
        /* irp is for a pin */
        return KsPinGetParentFilter((PKSPIN)ObjectHeader->ObjectType);
    }
    else
    {
        /* irp is unappropiate to retrieve a filter */
        return NULL;
    }
}