CPortPinWaveCyclic(IUnknown *OuterUnknown){}
virtual ~CPortPinWaveCyclic(){}
- VOID SetState(KSSTATE State);
-
protected:
VOID UpdateCommonBuffer(ULONG Position, ULONG MaxTransferCount);
VOID UpdateCommonBufferOverlap(ULONG Position, ULONG MaxTransferCount);
- NTSTATUS NTAPI HandleKsStream(IN PIRP Irp);
- NTSTATUS NTAPI HandleKsProperty(IN PIRP Irp);
-
+ VOID GeneratePositionEvents(IN ULONGLONG OldOffset, IN ULONGLONG NewOffset);
friend NTSTATUS NTAPI PinWaveCyclicState(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
friend NTSTATUS NTAPI PinWaveCyclicDataFormat(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
friend NTSTATUS NTAPI PinWaveCyclicAudioPosition(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
friend NTSTATUS NTAPI PinWaveCyclicAllocatorFraming(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
+ friend NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry);
+ friend NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry);
+ friend VOID CALLBACK PinSetStateWorkerRoutine(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context);
IPortWaveCyclic * m_Port;
IPortFilterWaveCyclic * m_Filter;
KSALLOCATOR_FRAMING m_AllocatorFraming;
SUBDEVICE_DESCRIPTOR m_Descriptor;
+ KSPIN_LOCK m_EventListLock;
+ LIST_ENTRY m_EventList;
+
+ KSRESET m_ResetState;
+
ULONG m_Delay;
LONG m_Ref;
typedef struct
{
- CPortPinWaveCyclic *Pin;
- PIO_WORKITEM WorkItem;
- KSSTATE State;
-}SETSTREAM_CONTEXT, *PSETSTREAM_CONTEXT;
+ ULONG bLoopedStreaming;
+ ULONGLONG Position;
+}LOOPEDSTREAMING_EVENT_CONTEXT, *PLOOPEDSTREAMING_EVENT_CONTEXT;
+
+typedef struct
+{
+ ULONG bLoopedStreaming;
+}ENDOFSTREAM_EVENT_CONTEXT, *PENDOFSTREAM_EVENT_CONTEXT;
+
+
NTSTATUS NTAPI PinWaveCyclicState(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI PinWaveCyclicDataFormat(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI PinWaveCyclicAudioPosition(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
NTSTATUS NTAPI PinWaveCyclicAllocatorFraming(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
+NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry);
+NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry);
+
DEFINE_KSPROPERTY_CONNECTIONSET(PinWaveCyclicConnectionSet, PinWaveCyclicState, PinWaveCyclicDataFormat, PinWaveCyclicAllocatorFraming);
DEFINE_KSPROPERTY_AUDIOSET(PinWaveCyclicAudioSet, PinWaveCyclicAudioPosition);
+KSEVENT_ITEM PinWaveCyclicConnectionEventSet =
+{
+ KSEVENT_CONNECTION_ENDOFSTREAM,
+ sizeof(KSEVENTDATA),
+ sizeof(ENDOFSTREAM_EVENT_CONTEXT),
+ PinWaveCyclicAddEndOfStreamEvent,
+ 0,
+ 0
+};
+
+KSEVENT_ITEM PinWaveCyclicStreamingEventSet =
+{
+ KSEVENT_LOOPEDSTREAMING_POSITION,
+ sizeof(LOOPEDSTREAMING_POSITION_EVENT_DATA),
+ sizeof(LOOPEDSTREAMING_EVENT_CONTEXT),
+ PinWaveCyclicAddLoopedStreamEvent,
+ 0,
+ 0
+};
+
+
KSPROPERTY_SET PinWaveCyclicPropertySet[] =
{
{
}
};
+KSEVENT_SET PinWaveCyclicEventSet[] =
+{
+ {
+ &KSEVENTSETID_LoopedStreaming,
+ sizeof(PinWaveCyclicStreamingEventSet) / sizeof(KSEVENT_ITEM),
+ (const KSEVENT_ITEM*)&PinWaveCyclicStreamingEventSet
+ },
+ {
+ &KSEVENTSETID_Connection,
+ sizeof(PinWaveCyclicConnectionEventSet) / sizeof(KSEVENT_ITEM),
+ (const KSEVENT_ITEM*)&PinWaveCyclicConnectionEventSet
+ }
+};
+
+
//==================================================================================================================================
NTSTATUS
return STATUS_UNSUCCESSFUL;
}
+NTSTATUS
+NTAPI
+PinWaveCyclicAddEndOfStreamEvent(
+ IN PIRP Irp,
+ IN PKSEVENTDATA EventData,
+ IN PKSEVENT_ENTRY EventEntry)
+{
+ PENDOFSTREAM_EVENT_CONTEXT Entry;
+ PSUBDEVICE_DESCRIPTOR Descriptor;
+ CPortPinWaveCyclic *Pin;
+
+ // get sub device descriptor
+ Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
+
+ // sanity check
+ PC_ASSERT(Descriptor);
+ PC_ASSERT(Descriptor->PortPin);
+ PC_ASSERT_IRQL(DISPATCH_LEVEL);
+
+ // cast to pin impl
+ Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
+
+ // get extra size
+ Entry = (PENDOFSTREAM_EVENT_CONTEXT)(EventEntry + 1);
+
+ // not a looped event
+ Entry->bLoopedStreaming = FALSE;
+
+ // insert item
+ (void)ExInterlockedInsertTailList(&Pin->m_EventList, &EventEntry->ListEntry, &Pin->m_EventListLock);
+
+ // done
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+PinWaveCyclicAddLoopedStreamEvent(
+ IN PIRP Irp,
+ IN PKSEVENTDATA EventData,
+ IN PKSEVENT_ENTRY EventEntry)
+{
+ PLOOPEDSTREAMING_POSITION_EVENT_DATA Data;
+ PLOOPEDSTREAMING_EVENT_CONTEXT Entry;
+ PSUBDEVICE_DESCRIPTOR Descriptor;
+ CPortPinWaveCyclic *Pin;
+
+ // get sub device descriptor
+ Descriptor = (PSUBDEVICE_DESCRIPTOR)KSEVENT_ITEM_IRP_STORAGE(Irp);
+
+ // sanity check
+ PC_ASSERT(Descriptor);
+ PC_ASSERT(Descriptor->PortPin);
+ PC_ASSERT_IRQL(DISPATCH_LEVEL);
+
+ // cast to pin impl
+ Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
+
+ // cast to looped event
+ Data = (PLOOPEDSTREAMING_POSITION_EVENT_DATA)EventData;
+
+ // get extra size
+ Entry = (PLOOPEDSTREAMING_EVENT_CONTEXT)(EventEntry + 1);
+
+ Entry->bLoopedStreaming = TRUE;
+ Entry->Position = Data->Position;
+
+ DPRINT1("Added event\n");
+
+ // insert item
+ (void)ExInterlockedInsertTailList(&Pin->m_EventList, &EventEntry->ListEntry, &Pin->m_EventListLock);
+
+ // done
+ return STATUS_SUCCESS;
+}
+
NTSTATUS
NTAPI
PinWaveCyclicAllocatorFraming(
PSUBDEVICE_DESCRIPTOR Descriptor;
// get sub device descriptor
- Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
+ Descriptor = (PSUBDEVICE_DESCRIPTOR)KSEVENT_ITEM_IRP_STORAGE(Irp);
// sanity check
PC_ASSERT(Descriptor);
}
else if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
{
- Position->PlayOffset = Pin->m_Position.PlayOffset % Pin->m_Position.WriteOffset;
+ Position->PlayOffset = Pin->m_Position.PlayOffset;
Position->WriteOffset = (ULONGLONG)Pin->m_IrpQueue->GetCurrentIrpOffset();
DPRINT("Play %lu Write %lu\n", Position->PlayOffset, Position->WriteOffset);
}
return STATUS_NOT_SUPPORTED;
}
+typedef struct
+{
+ CPortPinWaveCyclic *Pin;
+ KSSTATE NewState;
+ PIO_WORKITEM WorkItem;
+ PIRP Irp;
+
+}SETPIN_CONTEXT, *PSETPIN_CONTEXT;
+
+VOID
+CALLBACK
+PinSetStateWorkerRoutine(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PVOID Context)
+{
+ PSETPIN_CONTEXT PinWorkContext = (PSETPIN_CONTEXT)Context;
+ NTSTATUS Status;
+
+ // try set stream
+ Status = PinWorkContext->Pin->m_Stream->SetState(PinWorkContext->NewState);
+
+ DPRINT1("Setting state %u %x\n", PinWorkContext->NewState, Status);
+ if (NT_SUCCESS(Status))
+ {
+ // store new state
+ PinWorkContext->Pin->m_State = PinWorkContext->NewState;
+
+ if (PinWorkContext->Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING && PinWorkContext->Pin->m_State == KSSTATE_STOP)
+ {
+ /* FIXME complete pending irps with successfull state */
+ PinWorkContext->Pin->m_IrpQueue->CancelBuffers();
+ }
+ //HACK
+ //PinWorkContext->Pin->m_IrpQueue->CancelBuffers();
+ }
+
+ // store result
+ PinWorkContext->Irp->IoStatus.Information = sizeof(KSSTATE);
+ PinWorkContext->Irp->IoStatus.Status = Status;
+
+ // complete irp
+ IoCompleteRequest(PinWorkContext->Irp, IO_NO_INCREMENT);
+
+ // free work item
+ IoFreeWorkItem(PinWorkContext->WorkItem);
+
+ // free work context
+ FreeItem(PinWorkContext, TAG_PORTCLASS);
+
+}
+
NTSTATUS
NTAPI
if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING && Pin->m_State == KSSTATE_STOP)
{
- /* FIXME complete pending irps with successfull state */
+ // FIXME
+ // complete with successful state
Pin->m_IrpQueue->CancelBuffers();
}
- }
-
// store result
Irp->IoStatus.Information = sizeof(KSSTATE);
- return Status;
+ }
}
else if (Request->Flags & KSPROPERTY_TYPE_GET)
{
}
// new change request
- PC_ASSERT(Pin->m_State == KSSTATE_STOP);
+ PC_ASSERT(Pin->m_State != KSSTATE_RUN);
// FIXME queue a work item when Irql != PASSIVE_LEVEL
PC_ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
return STATUS_NOT_SUPPORTED;
}
+VOID
+CPortPinWaveCyclic::GeneratePositionEvents(
+ IN ULONGLONG OldOffset,
+ IN ULONGLONG NewOffset)
+{
+ PLIST_ENTRY Entry;
+ PKSEVENT_ENTRY EventEntry;
+ PLOOPEDSTREAMING_EVENT_CONTEXT Context;
+
+ // acquire event lock
+ KeAcquireSpinLockAtDpcLevel(&m_EventListLock);
+
+ // point to first entry
+ Entry = m_EventList.Flink;
+
+ while(Entry != &m_EventList)
+ {
+ // get event entry
+ EventEntry = (PKSEVENT_ENTRY)CONTAINING_RECORD(Entry, KSEVENT_ENTRY, ListEntry);
+
+ // get event entry context
+ Context = (PLOOPEDSTREAMING_EVENT_CONTEXT)(EventEntry + 1);
+
+ if (Context->bLoopedStreaming == TRUE)
+ {
+ if (NewOffset > OldOffset)
+ {
+ /* buffer progress no overlap */
+ if (OldOffset < Context->Position && Context->Position <= NewOffset)
+ {
+ /* when someone eventually fixes sprintf... */
+ DPRINT("Generating event at OldOffset %I64u\n", OldOffset);
+ DPRINT("Context->Position %I64u\n", Context->Position);
+ DPRINT("NewOffset %I64u\n", NewOffset);
+ /* generate event */
+ KsGenerateEvent(EventEntry);
+ }
+ }
+ else
+ {
+ /* buffer wrap-arround */
+ if (OldOffset < Context->Position || NewOffset > Context->Position)
+ {
+ /* when someone eventually fixes sprintf... */
+ DPRINT("Generating event at OldOffset %I64u\n", OldOffset);
+ DPRINT("Context->Position %I64u\n", Context->Position);
+ DPRINT("NewOffset %I64u\n", NewOffset);
+ /* generate event */
+ KsGenerateEvent(EventEntry);
+ }
+ }
+ }
+
+ // move to next entry
+ Entry = Entry->Flink;
+ }
+
+ // release lock
+ KeReleaseSpinLockFromDpcLevel(&m_EventListLock);
+}
VOID
CPortPinWaveCyclic::UpdateCommonBuffer(
BufferLength = Position - m_CommonBufferOffset;
m_Position.PlayOffset += BytesToCopy;
+
+ if (m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
+ {
+ // normalize position
+ m_Position.PlayOffset = m_Position.PlayOffset % m_Position.WriteOffset;
}
}
+}
VOID
CPortPinWaveCyclic::UpdateCommonBufferOverlap(
m_Position.PlayOffset += BytesToCopy;
BufferLength = m_CommonBufferSize - m_CommonBufferOffset;
+
+ if (m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
+ {
+ // normalize position
+ m_Position.PlayOffset = m_Position.PlayOffset % m_Position.WriteOffset;
+ }
+
}
if (Gap == Length)
NTSTATUS Status;
PUCHAR Buffer;
ULONG BufferSize;
+ ULONGLONG OldOffset, NewOffset;
PC_ASSERT_IRQL(DISPATCH_LEVEL);
Status = m_Stream->GetPosition(&Position);
DPRINT("Position %u Buffer %p BufferSize %u ActiveIrpOffset %u Capture %u\n", Position, Buffer, m_CommonBufferSize, BufferSize, m_Capture);
+ OldOffset = m_Position.PlayOffset;
+
if (Position < m_CommonBufferOffset)
{
UpdateCommonBufferOverlap(Position, m_FrameSize);
{
UpdateCommonBuffer(Position, m_FrameSize);
}
+
+ NewOffset = m_Position.PlayOffset;
+
+ GeneratePositionEvents(OldOffset, NewOffset);
}
NTSTATUS
NTSTATUS
NTAPI
-CPortPinWaveCyclic::HandleKsProperty(
+CPortPinWaveCyclic::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
+ PIO_STACK_LOCATION IoStack;
PKSPROPERTY Property;
- NTSTATUS Status;
UNICODE_STRING GuidString;
- PIO_STACK_LOCATION IoStack;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
-
- DPRINT("IPortPinWave_HandleKsProperty entered\n");
+ NTSTATUS Status = STATUS_NOT_SUPPORTED;
+ ULONG Data = 0;
+ KSRESET ResetValue;
+ /* get current irp stack location */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- if (IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_PROPERTY)
+ if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY)
{
- DPRINT("Unhandled function %lx Length %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode, IoStack->Parameters.DeviceIoControl.InputBufferLength);
-
- Irp->IoStatus.Status = STATUS_SUCCESS;
-
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return STATUS_SUCCESS;
- }
-
+ /* handle property with subdevice descriptor */
Status = PcHandlePropertyWithTable(Irp, m_Descriptor.FilterPropertySetCount, m_Descriptor.FilterPropertySet, &m_Descriptor);
if (Status == STATUS_NOT_FOUND)
DPRINT("Unhandeled property Set |%S| Id %u Flags %x\n", GuidString.Buffer, Property->Id, Property->Flags);
RtlFreeUnicodeString(&GuidString);
}
-
- if (Status != STATUS_PENDING)
+ }
+ else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT)
{
- Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ Status = PcHandleEnableEventWithTable(Irp, &m_Descriptor);
}
-
- return Status;
+ else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_DISABLE_EVENT)
+ {
+ Status = PcHandleDisableEventWithTable(Irp, &m_Descriptor);
}
-
-NTSTATUS
-NTAPI
-CPortPinWaveCyclic::HandleKsStream(
- IN PIRP Irp)
+ else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_RESET_STATE)
{
- NTSTATUS Status;
- ULONG Data = 0;
- InterlockedIncrement((PLONG)&m_TotalPackets);
-
- DPRINT("IPortPinWaveCyclic_HandleKsStream entered Total %u State %x MinData %u\n", m_TotalPackets, m_State, m_IrpQueue->NumData());
-
- Status = m_IrpQueue->AddMapping(Irp, &Data);
-
+ /// FIXME
+ Status = KsAcquireResetValue(Irp, &ResetValue);
+ DPRINT("Status %x Value %u\n", Status, ResetValue);
+ /* check for success */
if (NT_SUCCESS(Status))
{
- m_Position.WriteOffset += Data;
-
- return STATUS_PENDING;
+ if (ResetValue == KSRESET_BEGIN)
+ {
+ m_IrpQueue->CancelBuffers();
+ m_ResetState = KSRESET_BEGIN;
}
-
- return Status;
+ else if (ResetValue == KSRESET_END)
+ {
+ m_ResetState = KSRESET_END;
}
-
-NTSTATUS
-NTAPI
-CPortPinWaveCyclic::DeviceIoControl(
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
+ }
+ }
+ else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM || IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_READ_STREAM)
{
- PIO_STACK_LOCATION IoStack;
+ /* increment total number of packets */
+ InterlockedIncrement((PLONG)&m_TotalPackets);
- IoStack = IoGetCurrentIrpStackLocation(Irp);
+ DPRINT("New Packet Total %u State %x MinData %u\n", m_TotalPackets, m_State, m_IrpQueue->NumData());
+ /* is the device not currently reset */
+ if (m_ResetState == KSRESET_END)
+ {
+ /* add the mapping */
+ Status = m_IrpQueue->AddMapping(Irp, &Data);
- if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY)
+ /* check for success */
+ if (NT_SUCCESS(Status))
{
- return HandleKsProperty(Irp);
+ m_Position.WriteOffset += Data;
+ Status = STATUS_PENDING;
}
- else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT)
- {
- /// FIXME
- /// handle enable event
}
- else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_DISABLE_EVENT)
+ else
{
- /// FIXME
- /// handle disable event
+ /* reset request is currently in progress */
+ Status = STATUS_DEVICE_NOT_READY;
+ DPRINT1("NotReady\n");
}
- else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_RESET_STATE)
- {
- /// FIXME
- /// handle reset state
- }
- else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM || IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_READ_STREAM)
- {
- return HandleKsStream(Irp);
}
else
{
return KsDefaultDeviceIoCompletion(DeviceObject, Irp);
}
- UNIMPLEMENTED
-
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
+ if (Status != STATUS_PENDING)
+ {
+ Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
- return STATUS_UNSUCCESSFUL;
+ return Status;
}
NTSTATUS
}
#endif
- DPRINT("CPortPinWaveCyclic::Init Status %x PinId %u Capture %u\n", Status, ConnectDetails->PinId, Capture);
- DPRINT("Bits %u Samples %u Channels %u Tag %u FrameSize %u\n", ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.wBitsPerSample, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.nSamplesPerSec, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.nChannels, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.wFormatTag, m_FrameSize);
+ DPRINT1("CPortPinWaveCyclic::Init Status %x PinId %u Capture %u\n", Status, ConnectDetails->PinId, Capture);
+ DPRINT1("Bits %u Samples %u Channels %u Tag %u FrameSize %u\n", ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.wBitsPerSample, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.nSamplesPerSec, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.nChannels, ((PKSDATAFORMAT_WAVEFORMATEX)(DataFormat))->WaveFormatEx.wFormatTag, m_FrameSize);
if (!NT_SUCCESS(Status))
return Status;
return Status;
}
+ /* initialize event management */
+ InitializeListHead(&m_EventList);
+ KeInitializeSpinLock(&m_EventListLock);
+
/* set up subdevice descriptor */
RtlZeroMemory(&m_Descriptor, sizeof(SUBDEVICE_DESCRIPTOR));
m_Descriptor.FilterPropertySet = PinWaveCyclicPropertySet;
m_Descriptor.DeviceDescriptor = SubDeviceDescriptor->DeviceDescriptor;
m_Descriptor.UnknownMiniport = SubDeviceDescriptor->UnknownMiniport;
m_Descriptor.PortPin = (PVOID)this;
+ m_Descriptor.EventSetCount = sizeof(PinWaveCyclicEventSet) / sizeof(KSEVENT_SET);
+ m_Descriptor.EventSet = PinWaveCyclicEventSet;
+ m_Descriptor.EventList = &m_EventList;
+ m_Descriptor.EventListLock = &m_EventListLock;
+
+ // initialize reset state
+ m_ResetState = KSRESET_END;
// release subdevice descriptor
Subdevice->Release();
m_AllocatorFraming.FrameSize = m_FrameSize;
m_Stream->Silence(SilenceBuffer, m_FrameSize);
+ m_Stream->Silence(m_CommonBuffer, m_CommonBufferSize);
Status = m_IrpQueue->Init(ConnectDetails, DataFormat, DeviceObject, m_FrameSize, 0, SilenceBuffer);
if (!NT_SUCCESS(Status))
RtlMoveMemory(m_Format, DataFormat, DataFormat->FormatSize);
- PKSDATAFORMAT_WAVEFORMATEX Wave = (PKSDATAFORMAT_WAVEFORMATEX)m_Format;
-
- DPRINT1("Bits %u Samples %u Channels %u Tag %u FrameSize %u\n", Wave->WaveFormatEx.wBitsPerSample, Wave->WaveFormatEx.nSamplesPerSec, Wave->WaveFormatEx.nChannels, Wave->WaveFormatEx.wFormatTag, m_FrameSize);
-
-
-
Port->AddRef();
Filter->AddRef();
m_Port = Port;
m_Filter = Filter;
- DPRINT("Setting state to acquire %x\n", m_Stream->SetState(KSSTATE_ACQUIRE));
- DPRINT("Setting state to pause %x\n", m_Stream->SetState(KSSTATE_PAUSE));
+ //DPRINT("Setting state to acquire %x\n", m_Stream->SetState(KSSTATE_ACQUIRE));
+ //DPRINT("Setting state to pause %x\n", m_Stream->SetState(KSSTATE_PAUSE));
return STATUS_SUCCESS;
}