pin_wavecyclic.cpp File Reference

#include "private.hpp"
#include <debug.h>

Include dependency graph for pin_wavecyclic.cpp:

Go to the source code of this file.

Classes
class	CPortPinWaveCyclic
struct	LOOPEDSTREAMING_EVENT_CONTEXT
struct	ENDOFSTREAM_EVENT_CONTEXT
struct	SETPIN_CONTEXT

Macros
#define	NDEBUG

Typedefs
typedef struct LOOPEDSTREAMING_EVENT_CONTEXT *	PLOOPEDSTREAMING_EVENT_CONTEXT
typedef struct ENDOFSTREAM_EVENT_CONTEXT *	PENDOFSTREAM_EVENT_CONTEXT
typedef struct SETPIN_CONTEXT *	PSETPIN_CONTEXT

Functions
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)
NTSTATUS NTAPI	PinWaveCyclicDRMHandler (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
	DEFINE_KSPROPERTY_CONNECTIONSET (PinWaveCyclicConnectionSet, PinWaveCyclicState, PinWaveCyclicDataFormat, PinWaveCyclicAllocatorFraming)
	DEFINE_KSPROPERTY_AUDIOSET (PinWaveCyclicAudioSet, PinWaveCyclicAudioPosition)
	DEFINE_KSPROPERTY_DRMSET (PinWaveCyclicDRMSet, PinWaveCyclicDRMHandler)
VOID CALLBACK	PinSetStateWorkerRoutine (IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
NTSTATUS	NewPortPinWaveCyclic (OUT IPortPinWaveCyclic **OutPin)

Variables
KSEVENT_ITEM	PinWaveCyclicConnectionEventSet
KSEVENT_ITEM	PinWaveCyclicStreamingEventSet
KSPROPERTY_SET	PinWaveCyclicPropertySet []
KSEVENT_SET	PinWaveCyclicEventSet []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file pin_wavecyclic.cpp.

Typedef Documentation

PENDOFSTREAM_EVENT_CONTEXT

typedef struct ENDOFSTREAM_EVENT_CONTEXT * PENDOFSTREAM_EVENT_CONTEXT

PLOOPEDSTREAMING_EVENT_CONTEXT

typedef struct LOOPEDSTREAMING_EVENT_CONTEXT * PLOOPEDSTREAMING_EVENT_CONTEXT

PSETPIN_CONTEXT

typedef struct SETPIN_CONTEXT * PSETPIN_CONTEXT

Function Documentation

DEFINE_KSPROPERTY_AUDIOSET()

DEFINE_KSPROPERTY_AUDIOSET	(	PinWaveCyclicAudioSet	,
		PinWaveCyclicAudioPosition
	)

DEFINE_KSPROPERTY_CONNECTIONSET()

DEFINE_KSPROPERTY_CONNECTIONSET	(	PinWaveCyclicConnectionSet	,
		PinWaveCyclicState	,
		PinWaveCyclicDataFormat	,
		PinWaveCyclicAllocatorFraming
	)

DEFINE_KSPROPERTY_DRMSET()

DEFINE_KSPROPERTY_DRMSET	(	PinWaveCyclicDRMSet	,
		PinWaveCyclicDRMHandler
	)

NewPortPinWaveCyclic()

NTSTATUS NewPortPinWaveCyclic

(

OUT IPortPinWaveCyclic **

OutPin

)

Definition at line 1396 of file pin_wavecyclic.cpp.

{
    CPortPinWaveCyclic * This;

    This = new(NonPagedPool, TAG_PORTCLASS)CPortPinWaveCyclic(NULL);
    if (!This)
        return STATUS_INSUFFICIENT_RESOURCES;

    This->AddRef();

    // store result
    *OutPin = (IPortPinWaveCyclic*)This;

    return STATUS_SUCCESS;
}

PinSetStateWorkerRoutine()

VOID CALLBACK PinSetStateWorkerRoutine	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVOID	Context
	)

Definition at line 410 of file pin_wavecyclic.cpp.

{
    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 successful 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);

}

PinWaveCyclicAddEndOfStreamEvent()

NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent	(	IN PIRP	Irp,
		IN PKSEVENTDATA	EventData,
		IN PKSEVENT_ENTRY	EventEntry
	)

Definition at line 238 of file pin_wavecyclic.cpp.

{
    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;
}

PinWaveCyclicAddLoopedStreamEvent()

NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent	(	IN PIRP	Irp,
		IN PKSEVENTDATA	EventData,
		IN PKSEVENT_ENTRY	EventEntry
	)

Definition at line 273 of file pin_wavecyclic.cpp.

{
    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;
}

PinWaveCyclicAllocatorFraming()

NTSTATUS NTAPI PinWaveCyclicAllocatorFraming	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 314 of file pin_wavecyclic.cpp.

{
    CPortPinWaveCyclic *Pin;
    PSUBDEVICE_DESCRIPTOR Descriptor;

    // 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;


    if (Request->Flags & KSPROPERTY_TYPE_GET)
    {
        // copy pin framing
        RtlMoveMemory(Data, &Pin->m_AllocatorFraming, sizeof(KSALLOCATOR_FRAMING));

        Irp->IoStatus.Information = sizeof(KSALLOCATOR_FRAMING);
        return STATUS_SUCCESS;
    }

    // not supported
    return STATUS_NOT_SUPPORTED;
}

PinWaveCyclicAudioPosition()

NTSTATUS NTAPI PinWaveCyclicAudioPosition	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 349 of file pin_wavecyclic.cpp.

{
    CPortPinWaveCyclic *Pin;
    PSUBDEVICE_DESCRIPTOR Descriptor;
    PKSAUDIO_POSITION Position;

    // 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;

    //sanity check
    PC_ASSERT(Pin->m_Stream);

    if (Request->Flags & KSPROPERTY_TYPE_GET)
    {
        // FIXME non multithreading-safe
        // copy audio position

        Position = (PKSAUDIO_POSITION)Data;

        if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_STREAMING)
        {
            RtlMoveMemory(Data, &Pin->m_Position, sizeof(KSAUDIO_POSITION));
            DPRINT("Play %lu Record %lu\n", Pin->m_Position.PlayOffset, Pin->m_Position.WriteOffset);
        }
        else if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
        {
            Position->PlayOffset = Pin->m_Position.PlayOffset;
            Position->WriteOffset = (ULONGLONG)Pin->m_IrpQueue->GetCurrentIrpOffset();
            DPRINT("Play %lu Write %lu\n", Position->PlayOffset, Position->WriteOffset);
        }

        Irp->IoStatus.Information = sizeof(KSAUDIO_POSITION);
        return STATUS_SUCCESS;
    }

    // not supported
    return STATUS_NOT_SUPPORTED;
}

PinWaveCyclicDataFormat()

NTSTATUS NTAPI PinWaveCyclicDataFormat	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 525 of file pin_wavecyclic.cpp.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    CPortPinWaveCyclic *Pin;
    PSUBDEVICE_DESCRIPTOR Descriptor;
    PIO_STACK_LOCATION IoStack;

    // get current irp stack location
    IoStack = IoGetCurrentIrpStackLocation(Irp);

    // get sub device descriptor
    Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);

    // sanity check
    PC_ASSERT(Descriptor);
    PC_ASSERT(Descriptor->PortPin);

    // cast to pin impl
    Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;

    //sanity check
    PC_ASSERT(Pin->m_Stream);
    PC_ASSERT(Pin->m_Format);

    if (Request->Flags & KSPROPERTY_TYPE_SET)
    {
        // try to change data format
        PKSDATAFORMAT NewDataFormat, DataFormat = (PKSDATAFORMAT)Irp->UserBuffer;
        ULONG Size = min(Pin->m_Format->FormatSize, DataFormat->FormatSize);

        if (RtlCompareMemory(DataFormat, Pin->m_Format, Size) == Size)
        {
            // format is identical
            Irp->IoStatus.Information = DataFormat->FormatSize;
            return STATUS_SUCCESS;
        }

        // new change request
        PC_ASSERT(Pin->m_State != KSSTATE_RUN);
        // FIXME queue a work item when Irql != PASSIVE_LEVEL
        PC_ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);

        // allocate new data format
        NewDataFormat = (PKSDATAFORMAT)AllocateItem(NonPagedPool, DataFormat->FormatSize, TAG_PORTCLASS);
        if (!NewDataFormat)
        {
            // not enough memory
            return STATUS_NO_MEMORY;
        }

        // copy new data format
        RtlMoveMemory(NewDataFormat, DataFormat, DataFormat->FormatSize);

        // set new format
        Status = Pin->m_Stream->SetFormat(NewDataFormat);
        if (NT_SUCCESS(Status))
        {
            // free old format
            FreeItem(Pin->m_Format, TAG_PORTCLASS);

            // store new format
            Pin->m_Format = NewDataFormat;
            Irp->IoStatus.Information = NewDataFormat->FormatSize;

#if 0
            PC_ASSERT(NewDataFormat->FormatSize == sizeof(KSDATAFORMAT_WAVEFORMATEX));
            PC_ASSERT(IsEqualGUIDAligned(((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->DataFormat.MajorFormat, KSDATAFORMAT_TYPE_AUDIO));
            PC_ASSERT(IsEqualGUIDAligned(((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->DataFormat.SubFormat, KSDATAFORMAT_SUBTYPE_PCM));
            PC_ASSERT(IsEqualGUIDAligned(((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->DataFormat.Specifier, KSDATAFORMAT_SPECIFIER_WAVEFORMATEX));


            DPRINT("NewDataFormat: Channels %u Bits %u Samples %u\n", ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.nChannels,
                                                                       ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.wBitsPerSample,
                                                                       ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.nSamplesPerSec);
#endif

        }
        else
        {
            // failed to set format
            FreeItem(NewDataFormat, TAG_PORTCLASS);
        }


        // done
        return Status;
    }
    else if (Request->Flags & KSPROPERTY_TYPE_GET)
    {
        // get current data format
        PC_ASSERT(Pin->m_Format);

        if (Pin->m_Format->FormatSize > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
        {
            // buffer too small
            Irp->IoStatus.Information = Pin->m_Format->FormatSize;
            return STATUS_MORE_ENTRIES;
        }
        // copy data format
        RtlMoveMemory(Data, Pin->m_Format, Pin->m_Format->FormatSize);
        // store result size
        Irp->IoStatus.Information = Pin->m_Format->FormatSize;

        // done
        return STATUS_SUCCESS;
    }

    // unsupported request
    return STATUS_NOT_SUPPORTED;
}

PinWaveCyclicDRMHandler()

NTSTATUS NTAPI PinWaveCyclicDRMHandler	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 225 of file pin_wavecyclic.cpp.

{
    DPRINT1("PinWaveCyclicDRMHandler\n");
    ASSERT(0);
    return STATUS_INVALID_PARAMETER;
}

PinWaveCyclicState()

NTSTATUS NTAPI PinWaveCyclicState	(	IN PIRP	Irp,
		IN PKSIDENTIFIER	Request,
		IN OUT PVOID	Data
	)

Definition at line 453 of file pin_wavecyclic.cpp.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    CPortPinWaveCyclic *Pin;
    PSUBDEVICE_DESCRIPTOR Descriptor;
    PKSSTATE State = (PKSSTATE)Data;

    // 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;

    //sanity check
    PC_ASSERT(Pin->m_Stream);

    if (Request->Flags & KSPROPERTY_TYPE_SET)
    {
        // try set stream
        Status = Pin->m_Stream->SetState(*State);

        DPRINT("Setting state %u %x\n", *State, Status);
        if (NT_SUCCESS(Status))
        {
            // store new state
            Pin->m_State = *State;

            if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING && Pin->m_State == KSSTATE_STOP)
            {
                // FIXME
                // complete with successful state
                Pin->m_Stream->Silence(Pin->m_CommonBuffer, Pin->m_CommonBufferSize);
                Pin->m_IrpQueue->CancelBuffers();
                Pin->m_Position.PlayOffset = 0;
                Pin->m_Position.WriteOffset = 0;
            }
            else if (Pin->m_State == KSSTATE_STOP)
            {
                Pin->m_Stream->Silence(Pin->m_CommonBuffer, Pin->m_CommonBufferSize);
                Pin->m_IrpQueue->CancelBuffers();
                Pin->m_Position.PlayOffset = 0;
                Pin->m_Position.WriteOffset = 0;
            }
            // store result
            Irp->IoStatus.Information = sizeof(KSSTATE);
        }
        return Status;
    }
    else if (Request->Flags & KSPROPERTY_TYPE_GET)
    {
        // get current stream state
        *State = Pin->m_State;
        // store result
        Irp->IoStatus.Information = sizeof(KSSTATE);

        return STATUS_SUCCESS;
    }

    // unsupported request
    return STATUS_NOT_SUPPORTED;
}

Variable Documentation

PinWaveCyclicConnectionEventSet

KSEVENT_ITEM PinWaveCyclicConnectionEventSet

Initial value:

=
{
    KSEVENT_CONNECTION_ENDOFSTREAM,
    sizeof(KSEVENTDATA),
    sizeof(ENDOFSTREAM_EVENT_CONTEXT),
    PinWaveCyclicAddEndOfStreamEvent,
    0,
    0
}

Definition at line 134 of file pin_wavecyclic.cpp.

PinWaveCyclicEventSet

KSEVENT_SET PinWaveCyclicEventSet[]

Initial value:

=
{
    {
        &KSEVENTSETID_LoopedStreaming,
        sizeof(PinWaveCyclicStreamingEventSet) / sizeof(KSEVENT_ITEM),
        (const KSEVENT_ITEM*)&PinWaveCyclicStreamingEventSet
    },
    {
        &KSEVENTSETID_Connection,
        sizeof(PinWaveCyclicConnectionEventSet) / sizeof(KSEVENT_ITEM),
        (const KSEVENT_ITEM*)&PinWaveCyclicConnectionEventSet
    }
}

Definition at line 180 of file pin_wavecyclic.cpp.

PinWaveCyclicPropertySet

KSPROPERTY_SET PinWaveCyclicPropertySet[]

Initial value:

=
{
    {
        &KSPROPSETID_Connection,
        sizeof(PinWaveCyclicConnectionSet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&PinWaveCyclicConnectionSet,
        0,
        NULL
    },
    {
        &KSPROPSETID_Audio,
        sizeof(PinWaveCyclicAudioSet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&PinWaveCyclicAudioSet,
        0,
        NULL
    },
    {
        &KSPROPSETID_DrmAudioStream,
        sizeof(PinWaveCyclicDRMSet) / sizeof(KSPROPERTY_ITEM),
        (const KSPROPERTY_ITEM*)&PinWaveCyclicDRMSet,
        0,
        NULL
    }
}

Definition at line 155 of file pin_wavecyclic.cpp.

PinWaveCyclicStreamingEventSet

KSEVENT_ITEM PinWaveCyclicStreamingEventSet

Initial value:

=
{
    KSEVENT_LOOPEDSTREAMING_POSITION,
    sizeof(LOOPEDSTREAMING_POSITION_EVENT_DATA),
    sizeof(LOOPEDSTREAMING_EVENT_CONTEXT),
    PinWaveCyclicAddLoopedStreamEvent,
    0,
    0
}

Definition at line 144 of file pin_wavecyclic.cpp.