Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-01 18:24:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/ksfilter/ks/pin.c

2649 lines
72 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
* FILE: drivers/ksfilter/ks/worker.c
* PURPOSE: KS pin functions
* PROGRAMMER: Johannes Anderwald
*/
#include "precomp.h"
#include <bdamedia.h>
#define NDEBUG
#include <debug.h>
typedef struct _KSISTREAM_POINTER
{
PFNKSSTREAMPOINTER Callback;
PIRP Irp;
KTIMER Timer;
KDPC TimerDpc;
struct _KSISTREAM_POINTER *Next;
PKSPIN Pin;
PVOID Data;
ULONG Offset;
ULONG Length;
KSSTREAM_POINTER StreamPointer;
KSPIN_LOCK Lock;
}KSISTREAM_POINTER, *PKSISTREAM_POINTER;
typedef struct
{
KSBASIC_HEADER BasicHeader;
KSPIN Pin;
PKSIOBJECT_HEADER ObjectHeader;
KSPROCESSPIN ProcessPin;
LIST_ENTRY Entry;
LONG ref;
IKsFilter * Filter;
KMUTEX ProcessingMutex;
PFILE_OBJECT FileObject;
PKSGATE AttachedGate;
BOOL OrGate;
LIST_ENTRY IrpList;
KSPIN_LOCK IrpListLock;
volatile LONG IrpCount;
PKSISTREAM_POINTER ClonedStreamPointer;
KSISTREAM_POINTER LeadingEdgeStreamPointer;
KSISTREAM_POINTER TrailingStreamPointer;
PFNKSPINPOWER Sleep;
PFNKSPINPOWER Wake;
PFNKSPINHANDSHAKE Handshake;
PFNKSPINFRAMERETURN FrameReturn;
PFNKSPINIRPCOMPLETION IrpCompletion;
KSCLOCK_FUNCTIONTABLE ClockTable;
PFILE_OBJECT ClockFileObject;
IKsReferenceClockVtbl * lpVtblReferenceClock;
PKSDEFAULTCLOCK DefaultClock;
PKSWORKER PinWorker;
WORK_QUEUE_ITEM PinWorkQueueItem;
KEVENT FrameComplete;
ULONG FrameSize;
ULONG NumFrames;
PDMA_ADAPTER Dma;
ULONG MapRegisters;
}IKsPinImpl;
NTSTATUS NTAPI IKsPin_PinStatePropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI IKsPin_PinDataFormatPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI IKsPin_PinAllocatorFramingPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI IKsPin_PinStreamAllocator(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI IKsPin_PinMasterClock(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI IKsPin_PinPipeId(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
DEFINE_KSPROPERTY_CONNECTIONSET(PinConnectionSet, IKsPin_PinStatePropertyHandler, IKsPin_PinDataFormatPropertyHandler, IKsPin_PinAllocatorFramingPropertyHandler);
DEFINE_KSPROPERTY_STREAMSET(PinStreamSet, IKsPin_PinStreamAllocator, IKsPin_PinMasterClock, IKsPin_PinPipeId);
//TODO
// KSPROPSETID_Connection
// KSPROPERTY_CONNECTION_ACQUIREORDERING
// KSPROPSETID_StreamInterface
// KSPROPERTY_STREAMINTERFACE_HEADERSIZE
KSPROPERTY_SET PinPropertySet[] =
{
{
&KSPROPSETID_Connection,
sizeof(PinConnectionSet) / sizeof(KSPROPERTY_ITEM),
(const KSPROPERTY_ITEM*)&PinConnectionSet,
0,
NULL
},
{
&KSPROPSETID_Stream,
sizeof(PinStreamSet) / sizeof(KSPROPERTY_ITEM),
(const KSPROPERTY_ITEM*)&PinStreamSet,
0,
NULL
}
};
const GUID KSPROPSETID_Connection = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
const GUID KSPROPSETID_Stream = {0x65aaba60L, 0x98ae, 0x11cf, {0xa1, 0x0d, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4}};
const GUID KSPROPSETID_Clock = {0xDF12A4C0L, 0xAC17, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
NTSTATUS
NTAPI
IKsPin_PinStreamAllocator(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_PinMasterClock(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
NTSTATUS Status = STATUS_SUCCESS;
PHANDLE Handle;
PFILE_OBJECT FileObject;
KPROCESSOR_MODE Mode;
KSPROPERTY Property;
ULONG BytesReturned;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
DPRINT("IKsPin_PinMasterClock\n");
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* sanity check */
ASSERT(ObjectHeader);
/* locate ks pin implementation from KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
/* sanity check */
ASSERT(This);
Handle = (PHANDLE)Data;
if (Request->Flags & KSPROPERTY_TYPE_GET)
{
if (This->Pin.Descriptor->PinDescriptor.Communication != KSPIN_COMMUNICATION_NONE &&
This->Pin.Descriptor->Dispatch &&
(This->Pin.Descriptor->Flags & KSPIN_FLAG_IMPLEMENT_CLOCK))
{
*Handle = NULL;
Status = STATUS_SUCCESS;
}
else
{
/* no clock available */
Status = STATUS_UNSUCCESSFUL;
}
}
else if (Request->Flags & KSPROPERTY_TYPE_SET)
{
if (This->Pin.ClientState != KSSTATE_STOP)
{
/* can only set in stopped state */
Status = STATUS_INVALID_DEVICE_STATE;
}
else
{
if (*Handle)
{
Mode = ExGetPreviousMode();
Status = ObReferenceObjectByHandle(*Handle, SYNCHRONIZE | DIRECTORY_QUERY, *IoFileObjectType, Mode, (PVOID*)&FileObject, NULL);
DPRINT("IKsPin_PinMasterClock ObReferenceObjectByHandle %lx\n", Status);
if (NT_SUCCESS(Status))
{
Property.Set = KSPROPSETID_Clock;
Property.Id = KSPROPERTY_CLOCK_FUNCTIONTABLE;
Property.Flags = KSPROPERTY_TYPE_GET;
Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), &This->ClockTable, sizeof(KSCLOCK_FUNCTIONTABLE), &BytesReturned);
DPRINT("IKsPin_PinMasterClock KSPROPERTY_CLOCK_FUNCTIONTABLE %lx\n", Status);
if (NT_SUCCESS(Status))
{
This->ClockFileObject = FileObject;
}
else
{
ObDereferenceObject(FileObject);
}
}
}
else
{
/* zeroing clock handle */
RtlZeroMemory(&This->ClockTable, sizeof(KSCLOCK_FUNCTIONTABLE));
Status = STATUS_SUCCESS;
if (This->ClockFileObject)
{
FileObject = This->ClockFileObject;
This->ClockFileObject = NULL;
ObDereferenceObject(This->ClockFileObject);
}
}
}
}
DPRINT("IKsPin_PinMasterClock Status %lx\n", Status);
return Status;
}
NTSTATUS
NTAPI
IKsPin_PinPipeId(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_PinStatePropertyHandler(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
NTSTATUS Status = STATUS_SUCCESS;
KSSTATE OldState;
PKSSTATE NewState;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
DPRINT("IKsPin_PinStatePropertyHandler\n");
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* locate ks pin implementation from KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
/* acquire control mutex */
KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
/* grab state */
NewState = (PKSSTATE)Data;
if (Request->Flags & KSPROPERTY_TYPE_GET)
{
*NewState = This->Pin.DeviceState;
Irp->IoStatus.Information = sizeof(KSSTATE);
}
else if (Request->Flags & KSPROPERTY_TYPE_SET)
{
if (This->Pin.Descriptor->Dispatch->SetDeviceState)
{
/* backup old state */
OldState = This->Pin.ClientState;
/* set new state */
This->Pin.ClientState = *NewState;
This->Pin.DeviceState = KSSTATE_RUN;
/* check if it supported */
Status = This->Pin.Descriptor->Dispatch->SetDeviceState(&This->Pin, *NewState, OldState);
DPRINT("IKsPin_PinStatePropertyHandler NewState %lu Result %lx\n", *NewState, Status);
if (!NT_SUCCESS(Status))
{
/* revert to old state */
This->Pin.ClientState = OldState;
This->Pin.DeviceState = OldState;
DPRINT("IKsPin_PinStatePropertyHandler failed to set state %lx Result %lx\n", *NewState, Status);
DbgBreakPoint();
}
else
{
/* update device state */
This->Pin.DeviceState = *NewState;
}
}
else
{
/* just set new state */
This->Pin.DeviceState = *NewState;
This->Pin.ClientState = *NewState;
}
}
/* release processing mutex */
KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
DPRINT("IKsPin_PinStatePropertyHandler Status %lx\n", Status);
return Status;
}
NTSTATUS
NTAPI
IKsPin_PinAllocatorFramingPropertyHandler(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
ULONG Size;
NTSTATUS Status = STATUS_SUCCESS;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* locate ks pin implementation from KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
/* setting allocator flags is not supported */
ASSERT(!(Request->Flags & KSPROPERTY_TYPE_SET));
/* acquire control mutex */
KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
if (This->Pin.Descriptor->AllocatorFraming)
{
/* calculate size */
Size = FIELD_OFFSET(KSALLOCATOR_FRAMING_EX, FramingItem[0]) + This->Pin.Descriptor->AllocatorFraming->CountItems * sizeof(KS_FRAMING_ITEM);
if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == 0)
{
/* no buffer */
Status = STATUS_BUFFER_OVERFLOW;
}
else if (Size > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
{
/* buffer too small */
Status = STATUS_BUFFER_TOO_SMALL;
}
else
{
/* copy buffer */
RtlMoveMemory(Data, This->Pin.Descriptor->AllocatorFraming, Size);
}
/* store size */
Irp->IoStatus.Information = Size;
}
else
{
/* no allocator framing details */
Status = STATUS_NOT_FOUND;
}
/* release processing mutex */
KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
DPRINT("IKsPin_PinAllocatorFramingPropertyHandler Status %lx\n", Status);
return Status;
}
NTSTATUS
NTAPI
IKsPin_PinDataFormatPropertyHandler(
IN PIRP Irp,
IN PKSPROPERTY Request,
IN OUT PVOID Data)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
NTSTATUS Status = STATUS_SUCCESS;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
DPRINT("IKsPin_PinDataFormatPropertyHandler\n");
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* locate ks pin implementation from KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
/* acquire control mutex */
KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
if (Request->Flags & KSPROPERTY_TYPE_GET)
{
if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < This->Pin.ConnectionFormat->FormatSize)
{
/* buffer too small */
Irp->IoStatus.Information = This->Pin.ConnectionFormat->FormatSize;
Status = STATUS_BUFFER_TOO_SMALL;
}
else
{
/* copy format */
RtlMoveMemory(Data, This->Pin.ConnectionFormat, This->Pin.ConnectionFormat->FormatSize);
}
}
else if (Request->Flags & KSPROPERTY_TYPE_SET)
{
/* set format */
if (This->Pin.Descriptor->Flags & KSPIN_FLAG_FIXED_FORMAT)
{
/* format cannot be changed */
Status = STATUS_INVALID_DEVICE_REQUEST;
}
else
{
/* FIXME check if the format is supported */
Status = _KsEdit(This->Pin.Bag, (PVOID*)&This->Pin.ConnectionFormat, IoStack->Parameters.DeviceIoControl.OutputBufferLength, This->Pin.ConnectionFormat->FormatSize, 0);
if (NT_SUCCESS(Status))
{
/* store new format */
RtlMoveMemory(This->Pin.ConnectionFormat, Data, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
}
}
}
/* release processing mutex */
KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
DPRINT("IKsPin_PinDataFormatPropertyHandler Status %lx\n", Status);
return Status;
}
NTSTATUS
NTAPI
IKsPin_fnQueryInterface(
IKsPin * iface,
IN REFIID refiid,
OUT PVOID* Output)
{
NTSTATUS Status;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
{
*Output = &This->BasicHeader.OuterUnknown;
_InterlockedIncrement(&This->ref);
return STATUS_SUCCESS;
}
if (This->BasicHeader.ClientAggregate)
{
/* using client aggregate */
Status = This->BasicHeader.ClientAggregate->lpVtbl->QueryInterface(This->BasicHeader.ClientAggregate, refiid, Output);
if (NT_SUCCESS(Status))
{
/* client aggregate supports interface */
return Status;
}
}
DPRINT("IKsPin_fnQueryInterface no interface\n");
return STATUS_NOT_SUPPORTED;
}
ULONG
NTAPI
IKsPin_fnAddRef(
IKsPin * iface)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
return InterlockedIncrement(&This->ref);
}
ULONG
NTAPI
IKsPin_fnRelease(
IKsPin * iface)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
InterlockedDecrement(&This->ref);
if (This->ref == 0)
{
FreeItem(This);
return 0;
}
/* Return new reference count */
return This->ref;
}
NTSTATUS
NTAPI
IKsPin_fnTransferKsIrp(
IN IKsPin *iface,
IN PIRP Irp,
IN IKsTransport **OutTransport)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
VOID
NTAPI
IKsPin_fnDiscardKsIrp(
IN IKsPin *iface,
IN PIRP Irp,
IN IKsTransport * *OutTransport)
{
UNIMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnConnect(
IN IKsPin *iface,
IN IKsTransport * TransportIn,
OUT IKsTransport ** OutTransportIn,
OUT IKsTransport * *OutTransportOut,
IN KSPIN_DATAFLOW DataFlow)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnSetDeviceState(
IN IKsPin *iface,
IN KSSTATE OldState,
IN KSSTATE NewState,
IN IKsTransport * *OutTransport)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
VOID
NTAPI
IKsPin_fnSetResetState(
IN IKsPin *iface,
IN KSRESET ResetState,
OUT IKsTransport * * OutTransportOut)
{
UNIMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnGetTransportConfig(
IN IKsPin *iface,
IN struct KSPTRANSPORTCONFIG * TransportConfig,
OUT IKsTransport ** OutTransportIn,
OUT IKsTransport ** OutTransportOut)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnSetTransportConfig(
IN IKsPin *iface,
IN struct KSPTRANSPORTCONFIG const * TransportConfig,
OUT IKsTransport ** OutTransportIn,
OUT IKsTransport ** OutTransportOut)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnResetTransportConfig(
IN IKsPin *iface,
OUT IKsTransport ** OutTransportIn,
OUT IKsTransport ** OutTransportOut)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
PKSPIN
NTAPI
IKsPin_fnGetStruct(
IN IKsPin *iface)
{
UNIMPLEMENTED;
return NULL;
}
PKSPROCESSPIN
NTAPI
IKsPin_fnGetProcessPin(
IN IKsPin *iface)
{
UNIMPLEMENTED;
return NULL;
}
NTSTATUS
NTAPI
IKsPin_fnAttemptBypass(
IN IKsPin *iface)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnAttemptUnbypass(
IN IKsPin *iface)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
VOID
NTAPI
IKsPin_fnGenerateConnectionEvents(
IN IKsPin *iface,
IN ULONG EventMask)
{
UNIMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_fnClientSetDeviceState(
IN IKsPin *iface,
IN KSSTATE StateIn,
IN KSSTATE StateOut)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static IKsPinVtbl vt_IKsPin =
{
IKsPin_fnQueryInterface,
IKsPin_fnAddRef,
IKsPin_fnRelease,
IKsPin_fnTransferKsIrp,
IKsPin_fnDiscardKsIrp,
IKsPin_fnConnect,
IKsPin_fnSetDeviceState,
IKsPin_fnSetResetState,
IKsPin_fnGetTransportConfig,
IKsPin_fnSetTransportConfig,
IKsPin_fnResetTransportConfig,
IKsPin_fnGetStruct,
IKsPin_fnGetProcessPin,
IKsPin_fnAttemptBypass,
IKsPin_fnAttemptUnbypass,
IKsPin_fnGenerateConnectionEvents,
IKsPin_fnClientSetDeviceState
};
//==============================================================
NTSTATUS
NTAPI
IKsReferenceClock_fnQueryInterface(
IKsReferenceClock * iface,
IN REFIID refiid,
OUT PVOID* Output)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
return IKsPin_fnQueryInterface((IKsPin*)&This->BasicHeader.OuterUnknown, refiid, Output);
}
ULONG
NTAPI
IKsReferenceClock_fnAddRef(
IKsReferenceClock * iface)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
return IKsPin_fnAddRef((IKsPin*)&This->BasicHeader.OuterUnknown);
}
ULONG
NTAPI
IKsReferenceClock_fnRelease(
IKsReferenceClock * iface)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
return IKsPin_fnRelease((IKsPin*)&This->BasicHeader.OuterUnknown);
}
LONGLONG
NTAPI
IKsReferenceClock_fnGetTime(
IKsReferenceClock * iface)
{
LONGLONG Result;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetTime\n");
if (!This->ClockFileObject || !This->ClockTable.GetTime)
{
Result = 0;
}
else
{
Result = This->ClockTable.GetTime(This->ClockFileObject);
}
return Result;
}
LONGLONG
NTAPI
IKsReferenceClock_fnGetPhysicalTime(
IKsReferenceClock * iface)
{
LONGLONG Result;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetPhysicalTime\n");
if (!This->ClockFileObject || !This->ClockTable.GetPhysicalTime)
{
Result = 0;
}
else
{
Result = This->ClockTable.GetPhysicalTime(This->ClockFileObject);
}
return Result;
}
LONGLONG
NTAPI
IKsReferenceClock_fnGetCorrelatedTime(
IKsReferenceClock * iface,
OUT PLONGLONG SystemTime)
{
LONGLONG Result;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetCorrelatedTime\n");
if (!This->ClockFileObject || !This->ClockTable.GetCorrelatedTime)
{
Result = 0;
}
else
{
Result = This->ClockTable.GetCorrelatedTime(This->ClockFileObject, SystemTime);
}
return Result;
}
LONGLONG
NTAPI
IKsReferenceClock_fnGetCorrelatedPhysicalTime(
IKsReferenceClock * iface,
OUT PLONGLONG SystemTime)
{
LONGLONG Result;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetCorrelatedPhysicalTime\n");
if (!This->ClockFileObject || !This->ClockTable.GetCorrelatedPhysicalTime)
{
Result = 0;
}
else
{
Result = This->ClockTable.GetCorrelatedPhysicalTime(This->ClockFileObject, SystemTime);
}
return Result;
}
NTSTATUS
NTAPI
IKsReferenceClock_fnGetResolution(
IKsReferenceClock * iface,
OUT PKSRESOLUTION Resolution)
{
KSPROPERTY Property;
ULONG BytesReturned;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetResolution\n");
if (!This->ClockFileObject)
{
Resolution->Error = 0;
Resolution->Granularity = 1;
DPRINT1("IKsReferenceClock_fnGetResolution Using HACK\n");
return STATUS_SUCCESS;
}
if (!This->ClockFileObject)
return STATUS_DEVICE_NOT_READY;
Property.Set = KSPROPSETID_Clock;
Property.Id = KSPROPERTY_CLOCK_RESOLUTION;
Property.Flags = KSPROPERTY_TYPE_GET;
return KsSynchronousIoControlDevice(This->ClockFileObject, KernelMode, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), Resolution, sizeof(KSRESOLUTION), &BytesReturned);
}
NTSTATUS
NTAPI
IKsReferenceClock_fnGetState(
IKsReferenceClock * iface,
OUT PKSSTATE State)
{
KSPROPERTY Property;
ULONG BytesReturned;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
DPRINT1("IKsReferenceClock_fnGetState\n");
if (!This->ClockFileObject)
{
*State = This->Pin.ClientState;
DPRINT1("IKsReferenceClock_fnGetState Using HACK\n");
return STATUS_SUCCESS;
}
if (!This->ClockFileObject)
return STATUS_DEVICE_NOT_READY;
Property.Set = KSPROPSETID_Clock;
Property.Id = KSPROPERTY_CLOCK_RESOLUTION;
Property.Flags = KSPROPERTY_TYPE_GET;
return KsSynchronousIoControlDevice(This->ClockFileObject, KernelMode, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), State, sizeof(KSSTATE), &BytesReturned);
}
static IKsReferenceClockVtbl vt_ReferenceClock =
{
IKsReferenceClock_fnQueryInterface,
IKsReferenceClock_fnAddRef,
IKsReferenceClock_fnRelease,
IKsReferenceClock_fnGetTime,
IKsReferenceClock_fnGetPhysicalTime,
IKsReferenceClock_fnGetCorrelatedTime,
IKsReferenceClock_fnGetCorrelatedPhysicalTime,
IKsReferenceClock_fnGetResolution,
IKsReferenceClock_fnGetState
};
//==============================================================
/*
@implemented
*/
VOID
NTAPI
KsPinAcquireProcessingMutex(
IN PKSPIN Pin)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
}
/*
@implemented
*/
VOID
NTAPI
KsPinAttachAndGate(
IN PKSPIN Pin,
IN PKSGATE AndGate OPTIONAL)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* FIXME attach to filter's and gate (filter-centric processing) */
This->AttachedGate = AndGate;
This->OrGate = FALSE;
}
/*
@implemented
*/
VOID
NTAPI
KsPinAttachOrGate(
IN PKSPIN Pin,
IN PKSGATE OrGate OPTIONAL)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* FIXME attach to filter's and gate (filter-centric processing) */
This->AttachedGate = OrGate;
This->OrGate = TRUE;
}
/*
@implemented
*/
PKSGATE
NTAPI
KsPinGetAndGate(
IN PKSPIN Pin)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
return This->AttachedGate;
}
/*
@unimplemented
*/
VOID
NTAPI
KsPinAttemptProcessing(
IN PKSPIN Pin,
IN BOOLEAN Asynchronous)
{
DPRINT("KsPinAttemptProcessing\n");
DbgBreakPoint();
UNIMPLEMENTED;
}
/*
@unimplemented
*/
NTSTATUS
NTAPI
KsPinGetAvailableByteCount(
IN PKSPIN Pin,
OUT PLONG InputDataBytes OPTIONAL,
OUT PLONG OutputBufferBytes OPTIONAL)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
/*
@unimplemented
*/
NTSTATUS
NTAPI
KsPinGetConnectedFilterInterface(
IN PKSPIN Pin,
IN const GUID* InterfaceId,
OUT PVOID* Interface)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
/*
@unimplemented
*/
PDEVICE_OBJECT
NTAPI
KsPinGetConnectedPinDeviceObject(
IN PKSPIN Pin)
{
UNIMPLEMENTED;
return NULL;
}
/*
@unimplemented
*/
PFILE_OBJECT
NTAPI
KsPinGetConnectedPinFileObject(
IN PKSPIN Pin)
{
UNIMPLEMENTED;
return NULL;
}
/*
@unimplemented
*/
NTSTATUS
NTAPI
KsPinGetConnectedPinInterface(
IN PKSPIN Pin,
IN const GUID* InterfaceId,
OUT PVOID* Interface)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
/*
@unimplemented
*/
VOID
NTAPI
KsPinGetCopyRelationships(
IN PKSPIN Pin,
OUT PKSPIN* CopySource,
OUT PKSPIN* DelegateBranch)
{
UNIMPLEMENTED;
}
/*
@implemented
*/
PKSPIN
NTAPI
KsPinGetNextSiblingPin(
IN PKSPIN Pin)
{
return KsGetNextSibling((PVOID)Pin);
}
/*
@implemented
*/
PKSFILTER
NTAPI
KsPinGetParentFilter(
IN PKSPIN Pin)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* return parent filter */
return This->BasicHeader.Parent.KsFilter;
}
/*
@implemented
*/
NTSTATUS
NTAPI
KsPinGetReferenceClockInterface(
IN PKSPIN Pin,
OUT PIKSREFERENCECLOCK* Interface)
{
NTSTATUS Status = STATUS_DEVICE_NOT_READY;
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
if (This->ClockFileObject)
{
/* clock is available */
*Interface = (PIKSREFERENCECLOCK)&This->lpVtblReferenceClock;
Status = STATUS_SUCCESS;
}
DPRINT("KsPinGetReferenceClockInterface Pin %p Interface %p Status %x\n", Pin, Interface, Status);
return Status;
}
/*
@implemented
*/
VOID
NTAPI
KsPinRegisterFrameReturnCallback(
IN PKSPIN Pin,
IN PFNKSPINFRAMERETURN FrameReturn)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* register frame return callback */
This->FrameReturn = FrameReturn;
}
/*
@implemented
*/
VOID
NTAPI
KsPinRegisterHandshakeCallback(
IN PKSPIN Pin,
IN PFNKSPINHANDSHAKE Handshake)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* register private protocol handshake callback */
This->Handshake = Handshake;
}
/*
@implemented
*/
VOID
NTAPI
KsPinRegisterIrpCompletionCallback(
IN PKSPIN Pin,
IN PFNKSPINIRPCOMPLETION IrpCompletion)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* register irp completion callback */
This->IrpCompletion = IrpCompletion;
}
/*
@implemented
*/
VOID
NTAPI
KsPinRegisterPowerCallbacks(
IN PKSPIN Pin,
IN PFNKSPINPOWER Sleep OPTIONAL,
IN PFNKSPINPOWER Wake OPTIONAL)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* register power callbacks */
This->Sleep = Sleep;
This->Wake = Wake;
}
/*
@implemented
*/
VOID
NTAPI
KsPinReleaseProcessingMutex(
IN PKSPIN Pin)
{
IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* release processing mutex */
KeReleaseMutex(&This->ProcessingMutex, FALSE);
}
/*
@implemented
*/
KSDDKAPI
PKSPIN
NTAPI
KsGetPinFromIrp(
IN PIRP Irp)
{
PKSIOBJECT_HEADER ObjectHeader;
PKSPIN Pin;
PKSBASIC_HEADER Header;
PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
DPRINT("KsGetPinFromIrp\n");
/* get object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
if (!ObjectHeader)
return NULL;
Pin = (PKSPIN)ObjectHeader->ObjectType;
Header = (PKSBASIC_HEADER)((ULONG_PTR)Pin - sizeof(KSBASIC_HEADER));
/* sanity check */
ASSERT(Header->Type == KsObjectTypePin);
/* return object type */
return Pin;
}
/*
@unimplemented
*/
VOID
NTAPI
KsPinSetPinClockTime(
IN PKSPIN Pin,
IN LONGLONG Time)
{
UNIMPLEMENTED;
}
/*
@unimplemented
*/
NTSTATUS
NTAPI
KsPinSubmitFrame(
IN PKSPIN Pin,
IN PVOID Data OPTIONAL,
IN ULONG Size OPTIONAL,
IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
IN PVOID Context OPTIONAL)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsPinSubmitFrameMdl(
IN PKSPIN Pin,
IN PMDL Mdl OPTIONAL,
IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
IN PVOID Context OPTIONAL)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI
BOOLEAN
NTAPI
KsProcessPinUpdate(
IN PKSPROCESSPIN ProcessPin)
{
UNIMPLEMENTED;
return FALSE;
}
NTSTATUS
IKsPin_PrepareStreamHeader(
IN IKsPinImpl * This,
IN PKSISTREAM_POINTER StreamPointer)
{
PKSSTREAM_HEADER Header;
ULONG Length;
/* grab new irp */
StreamPointer->Irp = KsRemoveIrpFromCancelableQueue(&This->IrpList, &This->IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
if (!StreamPointer->Irp)
{
/* run out of mappings */
DPRINT("OutOfMappings\n");
return STATUS_DEVICE_NOT_READY;
}
InterlockedDecrement(&This->IrpCount);
KsDecrementCountedWorker(This->PinWorker);
/* get stream header */
if (StreamPointer->Irp->RequestorMode == UserMode)
Header = (PKSSTREAM_HEADER)StreamPointer->Irp->AssociatedIrp.SystemBuffer;
else
Header = (PKSSTREAM_HEADER)StreamPointer->Irp->UserBuffer;
/* initialize stream pointer */
StreamPointer->Callback = NULL;
StreamPointer->Length = max(Header->DataUsed, Header->FrameExtent);
StreamPointer->Next = NULL;
StreamPointer->Offset = 0;
StreamPointer->Pin = &This->Pin;
StreamPointer->Data = Header->Data;
StreamPointer->StreamPointer.Context = NULL;
StreamPointer->StreamPointer.Pin = &This->Pin;
StreamPointer->StreamPointer.StreamHeader = Header;
if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
StreamPointer->StreamPointer.Offset = &StreamPointer->StreamPointer.OffsetIn;
else
StreamPointer->StreamPointer.Offset = &StreamPointer->StreamPointer.OffsetOut;
#ifndef _WIN64
StreamPointer->StreamPointer.Offset->Alignment = 0;
#endif
StreamPointer->StreamPointer.Offset->Count = 0;
StreamPointer->StreamPointer.Offset->Data = NULL;
StreamPointer->StreamPointer.Offset->Remaining = 0;
ASSERT(StreamPointer->StreamPointer.Offset->Remaining == 0);
//StreamPointer->Offset += StreamPointer->StreamPointer.Offset->Count;
ASSERT(StreamPointer->Length > StreamPointer->Offset);
ASSERT(StreamPointer->StreamPointer.StreamHeader);
ASSERT(This->FrameSize);
/* calculate length */
/* TODO split into frames */
Length = StreamPointer->Length;
/* FIXME */
ASSERT(Length);
#ifndef _WIN64
StreamPointer->StreamPointer.Offset->Alignment = 0;
#endif
StreamPointer->StreamPointer.Context = NULL;
StreamPointer->StreamPointer.Pin = &This->Pin;
StreamPointer->StreamPointer.Offset->Count = Length;
StreamPointer->StreamPointer.Offset->Remaining = Length;
StreamPointer->StreamPointer.Offset->Data = (PVOID)((ULONG_PTR)StreamPointer->Data + StreamPointer->Offset);
StreamPointer->StreamPointer.StreamHeader->FrameExtent = Length;
if (StreamPointer->StreamPointer.StreamHeader->DataUsed)
StreamPointer->StreamPointer.StreamHeader->DataUsed = Length;
StreamPointer->StreamPointer.StreamHeader->Data = StreamPointer->StreamPointer.Offset->Data;
return STATUS_SUCCESS;
}
/*
@unimplemented
*/
KSDDKAPI
PKSSTREAM_POINTER
NTAPI
KsPinGetLeadingEdgeStreamPointer(
IN PKSPIN Pin,
IN KSSTREAM_POINTER_STATE State)
{
IKsPinImpl * This;
NTSTATUS Status;
This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
DPRINT("KsPinGetLeadingEdgeStreamPointer Pin %p State %x Count %lu Remaining %lu\n", Pin, State,
This->LeadingEdgeStreamPointer.Length,
This->LeadingEdgeStreamPointer.Offset);
/* sanity check */
ASSERT(State == KSSTREAM_POINTER_STATE_LOCKED);
if (State == KSSTREAM_POINTER_STATE_LOCKED)
{
if (!This->LeadingEdgeStreamPointer.Irp || This->LeadingEdgeStreamPointer.StreamPointer.Offset->Remaining == 0)
{
Status = IKsPin_PrepareStreamHeader(This, &This->LeadingEdgeStreamPointer);
if (!NT_SUCCESS(Status))
return NULL;
}
DPRINT("KsPinGetLeadingEdgeStreamPointer NewOffset %lu TotalLength %lu\n", This->LeadingEdgeStreamPointer.Offset, This->LeadingEdgeStreamPointer.Length);
}
return &This->LeadingEdgeStreamPointer.StreamPointer;
}
/*
@unimplemented
*/
KSDDKAPI
PKSSTREAM_POINTER
NTAPI
KsPinGetTrailingEdgeStreamPointer(
IN PKSPIN Pin,
IN KSSTREAM_POINTER_STATE State)
{
UNIMPLEMENTED;
return NULL;
}
/*
@unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsStreamPointerSetStatusCode(
IN PKSSTREAM_POINTER StreamPointer,
IN NTSTATUS Status)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsStreamPointerLock(
IN PKSSTREAM_POINTER StreamPointer)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI
VOID
NTAPI
KsStreamPointerUnlock(
IN PKSSTREAM_POINTER StreamPointer,
IN BOOLEAN Eject)
{
PKSISTREAM_POINTER Pointer = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
DPRINT1("KsStreamPointerUnlock StreamPointer %pEject %lu\n", StreamPointer, Eject);
Pointer->Irp = NULL;
}
/*
@unimplemented
*/
KSDDKAPI
VOID
NTAPI
KsStreamPointerAdvanceOffsetsAndUnlock(
IN PKSSTREAM_POINTER StreamPointer,
IN ULONG InUsed,
IN ULONG OutUsed,
IN BOOLEAN Eject)
{
DPRINT1("KsStreamPointerAdvanceOffsets InUsed %lu OutUsed %lu Eject %lu\n", InUsed, OutUsed, Eject);
DbgBreakPoint();
UNIMPLEMENTED;
}
/*
@implemented
*/
KSDDKAPI
VOID
NTAPI
KsStreamPointerDelete(
IN PKSSTREAM_POINTER StreamPointer)
{
IKsPinImpl * This;
PKSISTREAM_POINTER Cur, Last;
PKSISTREAM_POINTER Pointer = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
DPRINT("KsStreamPointerDelete %p\n", Pointer);
DbgBreakPoint();
This = (IKsPinImpl*)CONTAINING_RECORD(Pointer->StreamPointer.Pin, IKsPinImpl, Pin);
/* point to first stream pointer */
Last = NULL;
Cur = This->ClonedStreamPointer;
while(Cur != Pointer && Cur)
{
Last = Cur;
/* iterate to next cloned pointer */
Cur = Cur->Next;
}
if (!Cur)
{
/* you naughty driver */
return;
}
if (!Last)
{
/* remove first cloned pointer */
This->ClonedStreamPointer = Pointer->Next;
}
else
{
Last->Next = Pointer->Next;
}
/* FIXME make sure no timeouts are pending */
FreeItem(Pointer);
}
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsStreamPointerClone(
IN PKSSTREAM_POINTER StreamPointer,
IN PFNKSSTREAMPOINTER CancelCallback OPTIONAL,
IN ULONG ContextSize,
OUT PKSSTREAM_POINTER* CloneStreamPointer)
{
IKsPinImpl * This;
PKSISTREAM_POINTER CurFrame;
PKSISTREAM_POINTER NewFrame;
ULONG_PTR RefCount;
NTSTATUS Status;
ULONG Size;
DPRINT("KsStreamPointerClone StreamPointer %p CancelCallback %p ContextSize %p CloneStreamPointer %p\n", StreamPointer, CancelCallback, ContextSize, CloneStreamPointer);
/* get stream pointer */
CurFrame = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
/* calculate context size */
Size = sizeof(KSISTREAM_POINTER) + ContextSize;
/* allocate new stream pointer */
NewFrame = (PKSISTREAM_POINTER)AllocateItem(NonPagedPool, Size);
if (!NewFrame)
return STATUS_INSUFFICIENT_RESOURCES;
/* get current irp stack location */
RefCount = (ULONG_PTR)CurFrame->Irp->Tail.Overlay.DriverContext[0];
/* increment reference count */
RefCount++;
CurFrame->Irp->Tail.Overlay.DriverContext[0] = (PVOID)RefCount;
/* copy stream pointer */
RtlMoveMemory(NewFrame, CurFrame, sizeof(KSISTREAM_POINTER));
/* locate pin */
This = (IKsPinImpl*)CONTAINING_RECORD(CurFrame->Pin, IKsPinImpl, Pin);
/* prepare stream header in case required */
if (CurFrame->StreamPointer.Offset->Remaining == 0)
{
Status = IKsPin_PrepareStreamHeader(This, NewFrame);
if (!NT_SUCCESS(Status))
{
FreeItem(NewFrame);
return STATUS_DEVICE_NOT_READY;
}
}
if (ContextSize)
NewFrame->StreamPointer.Context = (NewFrame + 1);
if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
NewFrame->StreamPointer.Offset = &NewFrame->StreamPointer.OffsetIn;
else
NewFrame->StreamPointer.Offset = &NewFrame->StreamPointer.OffsetOut;
NewFrame->StreamPointer.Pin = &This->Pin;
ASSERT(NewFrame->StreamPointer.Pin);
ASSERT(NewFrame->StreamPointer.Context);
ASSERT(NewFrame->StreamPointer.Offset);
ASSERT(NewFrame->StreamPointer.StreamHeader);
/* store result */
*CloneStreamPointer = &NewFrame->StreamPointer;
DPRINT("KsStreamPointerClone CloneStreamPointer %p\n", *CloneStreamPointer);
return STATUS_SUCCESS;
}
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsStreamPointerAdvanceOffsets(
IN PKSSTREAM_POINTER StreamPointer,
IN ULONG InUsed,
IN ULONG OutUsed,
IN BOOLEAN Eject)
{
PKSISTREAM_POINTER CurFrame;
IKsPinImpl * This;
NTSTATUS Status;
DPRINT("KsStreamPointerAdvanceOffsets StreamPointer %p InUsed %lu OutUsed %lu Eject %lu\n", StreamPointer, InUsed, OutUsed, Eject);
/* get stream pointer */
CurFrame = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
/* locate pin */
This = (IKsPinImpl*)CONTAINING_RECORD(CurFrame->Pin, IKsPinImpl, Pin);
/* TODO */
ASSERT(InUsed == 0);
ASSERT(Eject == 0);
ASSERT(OutUsed);
DPRINT("KsStreamPointerAdvanceOffsets Offset %lu Length %lu NewOffset %lu Remaining %lu LeadingEdge %p DataUsed %lu\n", CurFrame->Offset, CurFrame->Length, CurFrame->Offset + OutUsed,
CurFrame->StreamPointer.OffsetOut.Remaining, &This->LeadingEdgeStreamPointer.StreamPointer, CurFrame->StreamPointer.StreamHeader->DataUsed);
DbgBreakPoint();
if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
{
ASSERT(CurFrame->StreamPointer.OffsetIn.Remaining >= InUsed);
CurFrame->StreamPointer.OffsetIn.Remaining -= InUsed;
CurFrame->StreamPointer.OffsetIn.Data = (PVOID)((ULONG_PTR)CurFrame->StreamPointer.OffsetIn.Data + InUsed);
}
else
{
if (!CurFrame->StreamPointer.OffsetOut.Remaining)
{
Status = IKsPin_PrepareStreamHeader(This, CurFrame);
if (!NT_SUCCESS(Status))
{
return STATUS_DEVICE_NOT_READY;
}
}
else
{
ASSERT(CurFrame->StreamPointer.OffsetOut.Remaining >= OutUsed);
CurFrame->StreamPointer.OffsetOut.Remaining -= OutUsed;
CurFrame->StreamPointer.OffsetOut.Data = (PVOID)((ULONG_PTR)CurFrame->StreamPointer.OffsetOut.Data + OutUsed);
}
}
return STATUS_SUCCESS;
}
/*
@unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsStreamPointerAdvance(
IN PKSSTREAM_POINTER StreamPointer)
{
UNIMPLEMENTED;
DbgBreakPoint();
return STATUS_NOT_IMPLEMENTED;
}
/*
@unimplemented
*/
KSDDKAPI
PMDL
NTAPI
KsStreamPointerGetMdl(
IN PKSSTREAM_POINTER StreamPointer)
{
UNIMPLEMENTED;
return NULL;
}
/*
@unimplemented
*/
KSDDKAPI
PIRP
NTAPI
KsStreamPointerGetIrp(
IN PKSSTREAM_POINTER StreamPointer,
OUT PBOOLEAN FirstFrameInIrp OPTIONAL,
OUT PBOOLEAN LastFrameInIrp OPTIONAL)
{
UNIMPLEMENTED;
return NULL;
}
/*
@implemented
*/
KSDDKAPI
VOID
NTAPI
KsStreamPointerScheduleTimeout(
IN PKSSTREAM_POINTER StreamPointer,
IN PFNKSSTREAMPOINTER Callback,
IN ULONGLONG Interval)
{
LARGE_INTEGER DueTime;
PKSISTREAM_POINTER Pointer;
/* get stream pointer */
Pointer = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
/* setup timer callback */
Pointer->Callback = Callback;
/* setup expiration */
DueTime.QuadPart = (LONGLONG)Interval;
/* setup the timer */
KeSetTimer(&Pointer->Timer, DueTime, &Pointer->TimerDpc);
}
/*
@implemented
*/
KSDDKAPI
VOID
NTAPI
KsStreamPointerCancelTimeout(
IN PKSSTREAM_POINTER StreamPointer)
{
PKSISTREAM_POINTER Pointer;
/* get stream pointer */
Pointer = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
KeCancelTimer(&Pointer->Timer);
}
/*
@implemented
*/
KSDDKAPI
PKSSTREAM_POINTER
NTAPI
KsPinGetFirstCloneStreamPointer(
IN PKSPIN Pin)
{
IKsPinImpl * This;
DPRINT("KsPinGetFirstCloneStreamPointer %p\n", Pin);
This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
if (!This->ClonedStreamPointer)
return NULL;
/* return first cloned stream pointer */
return &This->ClonedStreamPointer->StreamPointer;
}
/*
@implemented
*/
KSDDKAPI
PKSSTREAM_POINTER
NTAPI
KsStreamPointerGetNextClone(
IN PKSSTREAM_POINTER StreamPointer)
{
PKSISTREAM_POINTER Pointer;
DPRINT("KsStreamPointerGetNextClone\n");
DbgBreakPoint();
/* get stream pointer */
Pointer = (PKSISTREAM_POINTER)CONTAINING_RECORD(StreamPointer, KSISTREAM_POINTER, StreamPointer);
/* is there a another cloned stream pointer */
if (!Pointer->Next)
return NULL;
/* return next stream pointer */
return &Pointer->Next->StreamPointer;
}
VOID
NTAPI
IKsPin_PinCentricWorker(
IN PVOID Parameter)
{
NTSTATUS Status;
IKsPinImpl * This = (IKsPinImpl*)Parameter;
DPRINT("IKsPin_PinCentricWorker\n");
/* sanity checks */
ASSERT(This);
ASSERT(This->Pin.Descriptor);
ASSERT(This->Pin.Descriptor->Dispatch);
ASSERT(This->Pin.Descriptor->Dispatch->Process);
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING));
ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_GENERATE_MAPPINGS));
do
{
DPRINT("IKsPin_PinCentricWorker calling Pin Process Routine\n");
Status = This->Pin.Descriptor->Dispatch->Process(&This->Pin);
DPRINT("IKsPin_PinCentricWorker Status %lx, Offset %lu Length %lu\n", Status,
This->LeadingEdgeStreamPointer.Offset,
This->LeadingEdgeStreamPointer.Length);
break;
}while(This->IrpCount);
}
NTSTATUS
NTAPI
IKsPin_DispatchKsStream(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
IKsPinImpl * This)
{
PKSPROCESSPIN_INDEXENTRY ProcessPinIndex;
PKSSTREAM_HEADER Header;
ULONG NumHeaders;
PKSFILTER Filter;
PIO_STACK_LOCATION IoStack;
NTSTATUS Status = STATUS_SUCCESS;
DPRINT("IKsPin_DispatchKsStream\n");
/* FIXME handle reset states */
ASSERT(This->Pin.ResetState == KSRESET_END);
/* get current stack location */
IoStack = IoGetCurrentIrpStackLocation(Irp);
/* probe stream pointer */
if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM)
Status = KsProbeStreamIrp(Irp, KSSTREAM_WRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, This->Pin.StreamHeaderSize);
else
Status = KsProbeStreamIrp(Irp, KSSTREAM_READ | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, This->Pin.StreamHeaderSize);
if (!NT_SUCCESS(Status))
{
DPRINT1("KsProbeStreamIrp failed with %x\n", Status);
Irp->IoStatus.Status = Status;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
if (Irp->RequestorMode == UserMode)
Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
else
Header = (PKSSTREAM_HEADER)Irp->UserBuffer;
if (!Header)
{
DPRINT("NoHeader Canceling Irp %p\n", Irp);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
/* calculate num headers */
NumHeaders = IoStack->Parameters.DeviceIoControl.OutputBufferLength / Header->Size;
/* assume headers of same length */
ASSERT(IoStack->Parameters.DeviceIoControl.OutputBufferLength % Header->Size == 0);
/* FIXME support multiple stream headers */
ASSERT(NumHeaders == 1);
if (Irp->RequestorMode == UserMode)
{
/* prepare header */
ASSERT(Irp->MdlAddress);
Header->Data = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
if (!Header->Data)
{
DPRINT("NoHeader->Data Canceling Irp %p\n", Irp);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
if (This->Pin.Descriptor->Dispatch->Process)
{
/* it is a pin centric avstream */
/* mark irp as pending */
IoMarkIrpPending(Irp);
/* add irp to cancelable queue */
KsAddIrpToCancelableQueue(&This->IrpList, &This->IrpListLock, Irp, KsListEntryTail, NULL /* FIXME */);
/* sanity checks */
ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING));
ASSERT(This->PinWorker);
InterlockedIncrement(&This->IrpCount);
DPRINT("IKsPin_DispatchKsStream IrpCount %lu\n", This->IrpCount);
/* start the processing loop */
KsIncrementCountedWorker(This->PinWorker);
Status = STATUS_PENDING;
}
else
{
/* filter-centric avstream */
ASSERT(This->Filter);
ProcessPinIndex = This->Filter->lpVtbl->GetProcessDispatch(This->Filter);
Filter = This->Filter->lpVtbl->GetStruct(This->Filter);
ASSERT(ProcessPinIndex);
ASSERT(Filter);
ASSERT(Filter->Descriptor);
ASSERT(Filter->Descriptor->Dispatch);
if (!Filter->Descriptor->Dispatch->Process)
{
/* invalid device request */
DPRINT("Filter Centric Processing No Process Routine\n");
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
/* mark irp as pending */
IoMarkIrpPending(Irp);
/* add irp to cancelable queue */
KsAddIrpToCancelableQueue(&This->IrpList, &This->IrpListLock, Irp, KsListEntryTail, NULL /* FIXME */);
Status = Filter->Descriptor->Dispatch->Process(Filter, ProcessPinIndex);
DPRINT("IKsPin_DispatchKsStream FilterCentric: Status %lx \n", Status);
}
return Status;
}
NTSTATUS
NTAPI
IKsPin_DispatchDeviceIoControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
NTSTATUS Status;
UNICODE_STRING GuidString;
PKSPROPERTY Property;
ULONG SetCount = 0;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* locate ks pin implementation from KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
/* current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_READ_STREAM ||
IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM)
{
/* handle ks stream packets */
return IKsPin_DispatchKsStream(DeviceObject, Irp, This);
}
/* get property from input buffer */
Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
/* sanity check */
ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSIDENTIFIER));
ASSERT(This->Pin.Descriptor->AutomationTable);
RtlStringFromGUID(&Property->Set, &GuidString);
DPRINT("IKsPin_DispatchDeviceIoControl property Set |%S| Id %u Flags %x\n", GuidString.Buffer, Property->Id, Property->Flags);
RtlFreeUnicodeString(&GuidString);
if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_METHOD)
{
const KSMETHOD_SET *MethodSet = NULL;
ULONG MethodItemSize = 0;
/* check if the driver supports method sets */
if (This->Pin.Descriptor->AutomationTable->MethodSetsCount)
{
SetCount = This->Pin.Descriptor->AutomationTable->MethodSetsCount;
MethodSet = This->Pin.Descriptor->AutomationTable->MethodSets;
MethodItemSize = This->Pin.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 (This->Pin.Descriptor->AutomationTable->PropertySetsCount)
{
SetCount = This->Pin.Descriptor->AutomationTable->PropertySetsCount;
PropertySet = This->Pin.Descriptor->AutomationTable->PropertySets;
PropertyItemSize = This->Pin.Descriptor->AutomationTable->PropertyItemSize;
}
/* 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,
This->Pin.Descriptor->AutomationTable->EventSetsCount,
(PKSEVENT_SET)This->Pin.Descriptor->AutomationTable->EventSets,
&This->BasicHeader.EventList,
KSEVENTS_SPINLOCK,
(PVOID)&This->BasicHeader.EventListLock,
NULL,
This->Pin.Descriptor->AutomationTable->EventItemSize);
}
else
{
/* disable event handler */
Status = KsDisableEvent(Irp, &This->BasicHeader.EventList, KSEVENTS_SPINLOCK, &This->BasicHeader.EventListLock);
}
}
RtlStringFromGUID(&Property->Set, &GuidString);
DPRINT("IKsPin_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);
if (Status != STATUS_PENDING)
{
Irp->IoStatus.Status = Status;
CompleteRequest(Irp, IO_NO_INCREMENT);
}
/* done */
return Status;
}
NTSTATUS
NTAPI
IKsPin_Close(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStack;
PKSIOBJECT_HEADER ObjectHeader;
IKsPinImpl * This;
NTSTATUS Status = STATUS_SUCCESS;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
/* sanity check */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FsContext2);
/* get the object header */
ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
/* locate ks pin implementation fro KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(ObjectHeader->ObjectType, IKsPinImpl, Pin);
if (This->Pin.Descriptor->Dispatch->Close)
{
/* call pin close routine */
Status = This->Pin.Descriptor->Dispatch->Close(&This->Pin, Irp);
if (!NT_SUCCESS(Status))
{
/* abort closing */
Irp->IoStatus.Status = Status;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
/* remove pin from filter pin list and decrement reference count */
IKsFilter_RemovePin(This->Filter->lpVtbl->GetStruct(This->Filter), &This->Pin);
if (Status != STATUS_PENDING)
{
Irp->IoStatus.Status = Status;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
return Status;
}
NTSTATUS
NTAPI
IKsPin_DispatchCreateAllocator(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
UNIMPLEMENTED;
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
IKsPin_DispatchCreateClock(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PKSPIN Pin;
NTSTATUS Status = STATUS_SUCCESS;
IKsPinImpl * This;
KSRESOLUTION Resolution;
PKSRESOLUTION pResolution = NULL;
PKSOBJECT_CREATE_ITEM CreateItem;
DPRINT("IKsPin_DispatchCreateClock\n");
/* get the create item */
CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
/* sanity check */
ASSERT(CreateItem);
/* get the pin object */
Pin = (PKSPIN)CreateItem->Context;
/* sanity check */
ASSERT(Pin);
/* locate ks pin implementation fro KSPIN offset */
This = (IKsPinImpl*)CONTAINING_RECORD(Pin, IKsPinImpl, Pin);
/* sanity check */
ASSERT(This->BasicHeader.Type == KsObjectTypePin);
ASSERT(This->BasicHeader.ControlMutex);
/* acquire control mutex */
KsAcquireControl(Pin);
if ((This->Pin.Descriptor->PinDescriptor.Communication != KSPIN_COMMUNICATION_NONE &&
This->Pin.Descriptor->Dispatch) ||
(This->Pin.Descriptor->Flags & KSPIN_FLAG_IMPLEMENT_CLOCK))
{
if (!This->DefaultClock)
{
if (This->Pin.Descriptor->Dispatch && This->Pin.Descriptor->Dispatch->Clock)
{
if (This->Pin.Descriptor->Dispatch->Clock->Resolution)
{
This->Pin.Descriptor->Dispatch->Clock->Resolution(&This->Pin, &Resolution);
pResolution = &Resolution;
}
Status = KsAllocateDefaultClockEx(&This->DefaultClock,
(PVOID)&This->Pin,
(PFNKSSETTIMER)This->Pin.Descriptor->Dispatch->Clock->SetTimer,
(PFNKSCANCELTIMER)This->Pin.Descriptor->Dispatch->Clock->CancelTimer,
(PFNKSCORRELATEDTIME)This->Pin.Descriptor->Dispatch->Clock->CorrelatedTime,
pResolution,
0);
}
else
{
Status = KsAllocateDefaultClockEx(&This->DefaultClock, (PVOID)&This->Pin, NULL, NULL, NULL, NULL, 0);
}
}
if (NT_SUCCESS(Status))
{
Status = KsCreateDefaultClock(Irp, This->DefaultClock);
}
}
DPRINT("IKsPin_DispatchCreateClock %lx\n", Status);
/* release control mutex */
KsReleaseControl(Pin);
/* done */
Irp->IoStatus.Status = Status;
CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
NTSTATUS
NTAPI
IKsPin_DispatchCreateNode(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
UNIMPLEMENTED;
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
static KSDISPATCH_TABLE PinDispatchTable =
{
IKsPin_DispatchDeviceIoControl,
KsDispatchInvalidDeviceRequest,
KsDispatchInvalidDeviceRequest,
KsDispatchInvalidDeviceRequest,
IKsPin_Close,
KsDispatchQuerySecurity,
KsDispatchSetSecurity,
KsDispatchFastIoDeviceControlFailure,
KsDispatchFastReadFailure,
KsDispatchFastReadFailure
};
NTSTATUS
KspCreatePin(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PKSDEVICE KsDevice,
IN IKsFilterFactory * FilterFactory,
IN IKsFilter* Filter,
IN PKSPIN_CONNECT Connect,
IN KSPIN_DESCRIPTOR_EX* Descriptor)
{
IKsPinImpl * This;
PIO_STACK_LOCATION IoStack;
IKsDevice * Device;
PDEVICE_EXTENSION DeviceExtension;
PKSOBJECT_CREATE_ITEM CreateItem;
NTSTATUS Status;
PKSDATAFORMAT DataFormat;
PKSBASIC_HEADER BasicHeader;
ULONG Index;
ULONG FrameSize = 0;
ULONG NumFrames = 0;
KSAUTOMATION_TABLE AutomationTable;
/* sanity checks */
ASSERT(Descriptor->Dispatch);
DPRINT("KspCreatePin PinId %lu Flags %x\n", Connect->PinId, Descriptor->Flags);
//Output Pin: KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY
//Input Pin: KSPIN_FLAG_FIXED_FORMAT|KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT|KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING
DPRINT("KspCreatePin Dataflow %lu\n", Descriptor->PinDescriptor.DataFlow);
DPRINT("KspCreatePin Communication %lu\n", Descriptor->PinDescriptor.Communication);
if (Descriptor->AllocatorFraming)
{
DPRINT("KspCreatePin CountItems %lu\n", Descriptor->AllocatorFraming->CountItems);
DPRINT("KspCreatePin PinFlags %lx\n", Descriptor->AllocatorFraming->PinFlags);
DPRINT("KspCreatePin OutputCompression RatioNumerator %lu RatioDenominator %lu RatioConstantMargin %lu\n", Descriptor->AllocatorFraming->OutputCompression.RatioNumerator,
Descriptor->AllocatorFraming->OutputCompression.RatioDenominator, Descriptor->AllocatorFraming->OutputCompression.RatioConstantMargin);
DPRINT("KspCreatePin PinWeight %lx\n", Descriptor->AllocatorFraming->PinWeight);
for(Index = 0; Index < Descriptor->AllocatorFraming->CountItems; Index++)
{
DPRINT("KspCreatePin Index %lu MemoryFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryFlags);
DPRINT("KspCreatePin Index %lu BusFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].BusFlags);
DPRINT("KspCreatePin Index %lu Flags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Flags);
DPRINT("KspCreatePin Index %lu Frames %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Frames);
DPRINT("KspCreatePin Index %lu FileAlignment %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].FileAlignment);
DPRINT("KspCreatePin Index %lu MemoryTypeWeight %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryTypeWeight);
DPRINT("KspCreatePin Index %lu PhysicalRange MinFrameSize %lu MaxFrameSize %lu Stepping %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MinFrameSize,
Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MaxFrameSize,
Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.Stepping);
DPRINT("KspCreatePin Index %lu FramingRange MinFrameSize %lu MaxFrameSize %lu Stepping %lu InPlaceWeight %lu NotInPlaceWeight %lu\n",
Index,
Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MinFrameSize,
Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize,
Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.Stepping,
Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.InPlaceWeight,
Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.NotInPlaceWeight);
FrameSize = Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize;
NumFrames = Descriptor->AllocatorFraming->FramingItem[Index].Frames;
}
}
for (Index = 0; Index < Descriptor->PinDescriptor.DataRangesCount; Index++)
{
UNICODE_STRING GuidString;
/* convert the guid to string */
RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->MajorFormat, &GuidString);
DPRINT("Index %lu MajorFormat %S\n", Index, GuidString.Buffer);
RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &GuidString);
DPRINT("Index %lu SubFormat %S\n", Index, GuidString.Buffer);
RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
DPRINT("Index %lu Specifier %S\n", Index, GuidString.Buffer);
RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
DPRINT("Index %lu FormatSize %lu Flags %lu SampleSize %lu Reserved %lu KSDATAFORMAT %lu\n", Index,
Descriptor->PinDescriptor.DataRanges[Index]->FormatSize, Descriptor->PinDescriptor.DataRanges[Index]->Flags, Descriptor->PinDescriptor.DataRanges[Index]->SampleSize, Descriptor->PinDescriptor.DataRanges[Index]->Reserved, sizeof(KSDATAFORMAT));
if (IsEqualGUIDAligned(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT))
{
#if !defined(NDEBUG)
PKS_DATARANGE_BDA_TRANSPORT Transport = (PKS_DATARANGE_BDA_TRANSPORT)&Descriptor->PinDescriptor.DataRanges[Index];
DPRINT("KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT AvgTimePerFrame %I64u ulcbPhyiscalFrame %lu ulcbPhyiscalFrameAlignment %lu ulcbPhyiscalPacket %lu\n", Transport->BdaTransportInfo.AvgTimePerFrame, Transport->BdaTransportInfo.ulcbPhyiscalFrame,
Transport->BdaTransportInfo.ulcbPhyiscalFrameAlignment, Transport->BdaTransportInfo.ulcbPhyiscalPacket);
#endif
}
}
if (!FrameSize)
{
/* default to 50 * 188 (MPEG2 TS packet size) */
FrameSize = 9400;
}
if (!NumFrames)
{
NumFrames = 8;
}
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
/* get device extension */
DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
/* get ks device interface */
Device = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
/* first allocate pin ctx */
This = AllocateItem(NonPagedPool, sizeof(IKsPinImpl));
if (!This)
{
/* not enough memory */
return STATUS_INSUFFICIENT_RESOURCES;
}
/* allocate create item */
CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * 3);
if (!CreateItem)
{
/* not enough memory */
FreeItem(This);
DPRINT("KspCreatePin OutOfMemory\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
/* initialize basic header */
This->BasicHeader.KsDevice = KsDevice;
This->BasicHeader.Type = KsObjectTypePin;
This->BasicHeader.Parent.KsFilter = Filter->lpVtbl->GetStruct(Filter);
This->BasicHeader.OuterUnknown = (PUNKNOWN)&vt_IKsPin;
InitializeListHead(&This->BasicHeader.EventList);
KeInitializeSpinLock(&This->BasicHeader.EventListLock);
ASSERT(This->BasicHeader.Parent.KsFilter);
BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)This->BasicHeader.Parent.KsFilter - sizeof(KSBASIC_HEADER));
This->BasicHeader.ControlMutex = BasicHeader->ControlMutex;
ASSERT(This->BasicHeader.ControlMutex);
InitializeListHead(&This->BasicHeader.EventList);
KeInitializeSpinLock(&This->BasicHeader.EventListLock);
/* initialize pin */
This->FrameSize = FrameSize;
This->NumFrames = NumFrames;
This->lpVtblReferenceClock = &vt_ReferenceClock;
This->ref = 1;
This->FileObject = IoStack->FileObject;
This->Filter = Filter;
KeInitializeMutex(&This->ProcessingMutex, 0);
InitializeListHead(&This->IrpList);
KeInitializeSpinLock(&This->IrpListLock);
/* allocate object bag */
This->Pin.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
if (!This->Pin.Bag)
{
/* not enough memory */
FreeItem(This);
FreeItem(CreateItem);
return STATUS_INSUFFICIENT_RESOURCES;
}
/* initialize object bag */
Device->lpVtbl->InitializeObjectBag(Device, This->Pin.Bag, NULL);
/* allocate pin descriptor */
This->Pin.Descriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
if (!This->Pin.Descriptor)
{
/* not enough memory */
KsFreeObjectBag(This->Pin.Bag);
FreeItem(This);
FreeItem(CreateItem);
return STATUS_INSUFFICIENT_RESOURCES;
}
/* copy pin descriptor */
RtlMoveMemory((PVOID)This->Pin.Descriptor, Descriptor, sizeof(KSPIN_DESCRIPTOR_EX));
/* initialize automation table */
RtlZeroMemory(&AutomationTable, sizeof(KSAUTOMATION_TABLE));
AutomationTable.PropertyItemSize = sizeof(KSPROPERTY_ITEM);
AutomationTable.PropertySets = PinPropertySet;
AutomationTable.PropertySetsCount = sizeof(PinPropertySet) / sizeof(KSPROPERTY_SET);
/* merge in pin property sets */
Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&This->Pin.Descriptor->AutomationTable, (PKSAUTOMATION_TABLE)Descriptor->AutomationTable, &AutomationTable, This->Pin.Bag);
if (!NT_SUCCESS(Status))
{
/* not enough memory */
KsFreeObjectBag(This->Pin.Bag);
FreeItem(This);
FreeItem(CreateItem);
return Status;
}
/* get format */
DataFormat = (PKSDATAFORMAT)(Connect + 1);
/* initialize pin descriptor */
This->Pin.Context = NULL;
This->Pin.Id = Connect->PinId;
This->Pin.Communication = Descriptor->PinDescriptor.Communication;
This->Pin.ConnectionIsExternal = FALSE; //FIXME
RtlMoveMemory(&This->Pin.ConnectionInterface, &Connect->Interface, sizeof(KSPIN_INTERFACE));
RtlMoveMemory(&This->Pin.ConnectionMedium, &Connect->Medium, sizeof(KSPIN_MEDIUM));
RtlMoveMemory(&This->Pin.ConnectionPriority, &Connect->Priority, sizeof(KSPRIORITY));
/* allocate format */
Status = _KsEdit(This->Pin.Bag, (PVOID*)&This->Pin.ConnectionFormat, DataFormat->FormatSize, DataFormat->FormatSize, 0);
if (!NT_SUCCESS(Status))
{
/* failed to allocate format */
KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
FreeItem(This);
FreeItem(CreateItem);
return STATUS_INSUFFICIENT_RESOURCES;
}
/* copy format */
RtlMoveMemory((PVOID)This->Pin.ConnectionFormat, DataFormat, DataFormat->FormatSize);
This->Pin.AttributeList = NULL; //FIXME
This->Pin.StreamHeaderSize = sizeof(KSSTREAM_HEADER);
This->Pin.DataFlow = Descriptor->PinDescriptor.DataFlow;
This->Pin.DeviceState = KSSTATE_STOP;
This->Pin.ResetState = KSRESET_END;
This->Pin.ClientState = KSSTATE_STOP;
/* initialize allocator create item */
CreateItem[0].Context = (PVOID)&This->Pin;
CreateItem[0].Create = IKsPin_DispatchCreateAllocator;
CreateItem[0].Flags = KSCREATE_ITEM_FREEONSTOP;
RtlInitUnicodeString(&CreateItem[0].ObjectClass, KSSTRING_Allocator);
/* initialize clock create item */
CreateItem[1].Context = (PVOID)&This->Pin;
CreateItem[1].Create = IKsPin_DispatchCreateClock;
CreateItem[1].Flags = KSCREATE_ITEM_FREEONSTOP;
RtlInitUnicodeString(&CreateItem[1].ObjectClass, KSSTRING_Clock);
/* initialize topology node create item */
CreateItem[2].Context = (PVOID)&This->Pin;
CreateItem[2].Create = IKsPin_DispatchCreateNode;
CreateItem[2].Flags = KSCREATE_ITEM_FREEONSTOP;
RtlInitUnicodeString(&CreateItem[2].ObjectClass, KSSTRING_TopologyNode);
/* now allocate object header */
Status = KsAllocateObjectHeader((KSOBJECT_HEADER*)&This->ObjectHeader, 3, CreateItem, Irp, &PinDispatchTable);
if (!NT_SUCCESS(Status))
{
/* failed to create object header */
DPRINT("KspCreatePin KsAllocateObjectHeader failed %lx\n", Status);
KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
FreeItem(This);
FreeItem(CreateItem);
/* return failure code */
return Status;
}
/* add extra info to object header */
This->ObjectHeader->Type = KsObjectTypePin;
This->ObjectHeader->Unknown = (PUNKNOWN)&This->BasicHeader.OuterUnknown;
This->ObjectHeader->ObjectType = (PVOID)&This->Pin;
if (!Descriptor->Dispatch || !Descriptor->Dispatch->Process)
{
/* the pin is part of filter-centric processing filter
* add process pin to filter
*/
This->ProcessPin.BytesAvailable = 0;
This->ProcessPin.BytesUsed = 0;
This->ProcessPin.CopySource = NULL;
This->ProcessPin.Data = NULL;
This->ProcessPin.DelegateBranch = NULL;
This->ProcessPin.Flags = 0;
This->ProcessPin.InPlaceCounterpart = NULL;
This->ProcessPin.Pin = &This->Pin;
This->ProcessPin.StreamPointer = (PKSSTREAM_POINTER)&This->LeadingEdgeStreamPointer.StreamPointer;
This->ProcessPin.Terminate = FALSE;
Status = Filter->lpVtbl->AddProcessPin(Filter, &This->ProcessPin);
DPRINT("KspCreatePin AddProcessPin %lx\n", Status);
if (!NT_SUCCESS(Status))
{
/* failed to add process pin */
KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
KsFreeObjectHeader(&This->ObjectHeader);
FreeItem(This);
FreeItem(CreateItem);
/* return failure code */
return Status;
}
}
else if (Descriptor->Dispatch && Descriptor->Dispatch->Process)
{
/* pin centric processing filter */
/* initialize work item */
ExInitializeWorkItem(&This->PinWorkQueueItem, IKsPin_PinCentricWorker, (PVOID)This);
/* allocate counted work item */
Status = KsRegisterCountedWorker(HyperCriticalWorkQueue, &This->PinWorkQueueItem, &This->PinWorker);
if (!NT_SUCCESS(Status))
{
DPRINT("Failed to register Worker %lx\n", Status);
KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
KsFreeObjectHeader(&This->ObjectHeader);
FreeItem(This);
FreeItem(CreateItem);
return Status;
}
if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetIn;
else
This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetOut;
KeInitializeEvent(&This->FrameComplete, NotificationEvent, FALSE);
}
/* FIXME add pin instance to filter instance */
IKsFilter_AddPin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
if (Descriptor->Dispatch && Descriptor->Dispatch->SetDataFormat)
{
Status = Descriptor->Dispatch->SetDataFormat(&This->Pin, NULL, NULL, This->Pin.ConnectionFormat, NULL);
DPRINT("KspCreatePin SetDataFormat %lx\n", Status);
}
/* does the driver have a pin dispatch */
if (Descriptor->Dispatch && Descriptor->Dispatch->Create)
{
/* now inform the driver to create a new pin */
Status = Descriptor->Dispatch->Create(&This->Pin, Irp);
DPRINT("KspCreatePin DispatchCreate %lx\n", Status);
}
DPRINT("KspCreatePin Status %lx KsDevice %p\n", Status, KsDevice);
if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
{
/* failed to create pin, release resources */
IKsFilter_RemovePin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
KsFreeObjectHeader((KSOBJECT_HEADER)This->ObjectHeader);
FreeItem(This);
/* return failure code */
return Status;
}
return Status;
}
Reference in a new issue View git blame Copy permalink