sysaudio.h File Reference

#include <portcls.h>

Include dependency graph for sysaudio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	PIN_INFO
struct	KSAUDIO_DEVICE_ENTRY
struct	SYSAUDIODEVEXT
struct	DISPATCH_CONTEXT

Typedefs
typedef struct KSAUDIO_DEVICE_ENTRY *	PKSAUDIO_DEVICE_ENTRY
typedef struct SYSAUDIODEVEXT *	PSYSAUDIODEVEXT
typedef struct DISPATCH_CONTEXT *	PDISPATCH_CONTEXT

Functions
NTSTATUS	SysAudioAllocateDeviceHeader (IN SYSAUDIODEVEXT *DeviceExtension)
NTSTATUS	SysAudioRegisterDeviceInterfaces (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	SysAudioRegisterNotifications (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	SysAudioHandleProperty (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	SysAudioOpenKMixer (IN SYSAUDIODEVEXT *DeviceExtension)
NTSTATUS	OpenDevice (IN PUNICODE_STRING DeviceName, IN PHANDLE HandleOut, IN PFILE_OBJECT *FileObjectOut)
PKSAUDIO_DEVICE_ENTRY	GetListEntry (IN PLIST_ENTRY Head, IN ULONG Index)
NTSTATUS NTAPI	DispatchCreateSysAudioPin (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
ULONG	GetDeviceCount (PSYSAUDIODEVEXT DeviceExtension, BOOL WaveIn)
NTSTATUS	GetPinInstanceCount (PKSAUDIO_DEVICE_ENTRY Entry, PKSPIN_CINSTANCES PinInstances, PKSPIN_CONNECT PinConnect)
NTSTATUS	ComputeCompatibleFormat (IN PKSAUDIO_DEVICE_ENTRY Entry, IN ULONG PinId, IN PKSDATAFORMAT_WAVEFORMATEX ClientFormat, OUT PKSDATAFORMAT_WAVEFORMATEX MixerFormat)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID	FreeItem (IN PVOID Item)

Typedef Documentation

PDISPATCH_CONTEXT

typedef struct DISPATCH_CONTEXT * PDISPATCH_CONTEXT

PKSAUDIO_DEVICE_ENTRY

typedef struct KSAUDIO_DEVICE_ENTRY * PKSAUDIO_DEVICE_ENTRY

PSYSAUDIODEVEXT

typedef struct SYSAUDIODEVEXT * PSYSAUDIODEVEXT

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

Referenced by BdaCreateFilterFactoryEx(), BdaCreatePin(), FindProductName(), GetSysAudioDevicePnpName(), InsertPinHandle(), KspCopyCreateRequest(), ReadKeyValue(), USBSTOR_ClassRequest(), and USBSTOR_GetMaxLUN().

ComputeCompatibleFormat()

NTSTATUS ComputeCompatibleFormat	(	IN PKSAUDIO_DEVICE_ENTRY	Entry,
		IN ULONG	PinId,
		IN PKSDATAFORMAT_WAVEFORMATEX	ClientFormat,
		OUT PKSDATAFORMAT_WAVEFORMATEX	MixerFormat
	)

Definition at line 135 of file control.c.

{
    BOOL bFound;
    ULONG BytesReturned;
    PKSP_PIN PinRequest;
    NTSTATUS Status;
    PKSMULTIPLE_ITEM MultipleItem;
    ULONG Length;
    PKSDATARANGE_AUDIO AudioRange;
    ULONG Index;
 
    Length = sizeof(KSP_PIN) + sizeof(KSMULTIPLE_ITEM) + ClientFormat->DataFormat.FormatSize;
    PinRequest = AllocateItem(NonPagedPool, Length);
    if (!PinRequest)
        return STATUS_UNSUCCESSFUL;
 
    PinRequest->PinId = PinId;
    PinRequest->Property.Set = KSPROPSETID_Pin;
    PinRequest->Property.Flags = KSPROPERTY_TYPE_GET;
    PinRequest->Property.Id = KSPROPERTY_PIN_DATAINTERSECTION;
 
    MultipleItem = (PKSMULTIPLE_ITEM)(PinRequest + 1);
    MultipleItem->Count = 1;
    MultipleItem->Size = ClientFormat->DataFormat.FormatSize;
 
    RtlMoveMemory(MultipleItem + 1, ClientFormat, ClientFormat->DataFormat.FormatSize);
    /* Query the miniport data intersection handler */
    Status = KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)PinRequest, Length, (PVOID)MixerFormat, sizeof(KSDATAFORMAT_WAVEFORMATEX), &BytesReturned);
 
    DPRINT("Status %x\n", Status);
 
    if (NT_SUCCESS(Status))
    {
        FreeItem(PinRequest);
        return Status;
    }
 
    /* Setup request block */
    PinRequest->Property.Id = KSPROPERTY_PIN_DATARANGES;
    /* Query pin data ranges */
    Status = KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)PinRequest, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
 
    if (Status != STATUS_MORE_ENTRIES)
    {
        /* Failed to get data ranges */
        return Status;
    }
 
    MultipleItem = AllocateItem(NonPagedPool, BytesReturned);
    if (!MultipleItem)
    {
        FreeItem(PinRequest);
        return STATUS_NO_MEMORY;
    }
 
    Status = KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)PinRequest, sizeof(KSP_PIN), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Property Request KSPROPERTY_PIN_DATARANGES failed with %x\n", Status);
        FreeItem(MultipleItem);
        FreeItem(PinRequest);
        return STATUS_UNSUCCESSFUL;
    }
 
    AudioRange = (PKSDATARANGE_AUDIO)(MultipleItem + 1);
    bFound = FALSE;
    for(Index = 0; Index < MultipleItem->Count; Index++)
    {
        if (AudioRange->DataRange.FormatSize != sizeof(KSDATARANGE_AUDIO))
        {
            UNIMPLEMENTED;
            AudioRange = (PKSDATARANGE_AUDIO)((PUCHAR)AudioRange + AudioRange->DataRange.FormatSize);
            continue;
        }
        /* Select best quality available */
 
        MixerFormat->DataFormat.FormatSize = sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX);
        MixerFormat->DataFormat.Flags = 0;
        MixerFormat->DataFormat.Reserved = 0;
        MixerFormat->DataFormat.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
        MixerFormat->DataFormat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
        MixerFormat->DataFormat.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
        MixerFormat->DataFormat.SampleSize = 4;
        MixerFormat->WaveFormatEx.wFormatTag = ClientFormat->WaveFormatEx.wFormatTag;
#ifndef NO_AC97_HACK
        /* HACK: AC97 does not support mono render / record */
        MixerFormat->WaveFormatEx.nChannels = 2;
        /*HACK: AC97 only supports 16-Bit Bits */
        MixerFormat->WaveFormatEx.wBitsPerSample = 16;
 
#else
        MixerFormat->WaveFormatEx.nChannels = min(ClientFormat->WaveFormatEx.nChannels, AudioRange->MaximumChannels);
        MixerFormat->WaveFormatEx.wBitsPerSample = AudioRange->MaximumBitsPerSample;
#endif
 
#ifdef KMIXER_RESAMPLING_IMPLEMENTED
        MixerFormat->WaveFormatEx.nSamplesPerSec = AudioRange->MaximumSampleFrequency;
#else
        MixerFormat->WaveFormatEx.nSamplesPerSec = max(AudioRange->MinimumSampleFrequency, min(ClientFormat->WaveFormatEx.nSamplesPerSec, AudioRange->MaximumSampleFrequency));
#endif
 
        MixerFormat->WaveFormatEx.cbSize = 0;
        MixerFormat->WaveFormatEx.nBlockAlign = (MixerFormat->WaveFormatEx.nChannels * MixerFormat->WaveFormatEx.wBitsPerSample) / 8;
        MixerFormat->WaveFormatEx.nAvgBytesPerSec = MixerFormat->WaveFormatEx.nChannels * MixerFormat->WaveFormatEx.nSamplesPerSec * (MixerFormat->WaveFormatEx.wBitsPerSample / 8);
 
        bFound = TRUE;
        break;
 
        AudioRange = (PKSDATARANGE_AUDIO)((PUCHAR)AudioRange + AudioRange->DataRange.FormatSize);
    }
 
#if 0
    DPRINT1("\nNum Max Channels %u Channels %u Old Channels %u\n Max SampleRate %u SampleRate %u Old SampleRate %u\n Max BitsPerSample %u BitsPerSample %u Old BitsPerSample %u\n",
           AudioRange->MaximumChannels, MixerFormat->WaveFormatEx.nChannels, ClientFormat->WaveFormatEx.nChannels,
           AudioRange->MaximumSampleFrequency, MixerFormat->WaveFormatEx.nSamplesPerSec, ClientFormat->WaveFormatEx.nSamplesPerSec,
           AudioRange->MaximumBitsPerSample, MixerFormat->WaveFormatEx.wBitsPerSample, ClientFormat->WaveFormatEx.wBitsPerSample);
 
 
#endif
 
    FreeItem(MultipleItem);
    FreeItem(PinRequest);
 
    if (bFound)
        return STATUS_SUCCESS;
    else
        return STATUS_NOT_IMPLEMENTED;
}

Referenced by InstantiatePins().

DispatchCreateSysAudioPin()

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

Definition at line 431 of file pin.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IoStack;
    PKSAUDIO_DEVICE_ENTRY DeviceEntry;
    PKSPIN_CONNECT Connect;
    PDISPATCH_CONTEXT DispatchContext;
 
    DPRINT("DispatchCreateSysAudioPin entered\n");
 
    /* get current stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity checks */
    ASSERT(IoStack->FileObject);
    ASSERT(IoStack->FileObject->RelatedFileObject);
    ASSERT(IoStack->FileObject->RelatedFileObject->FsContext);
 
    /* get current attached virtual device */
    DeviceEntry = (PKSAUDIO_DEVICE_ENTRY)IoStack->FileObject->RelatedFileObject->FsContext;
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    /* get connect details */
    Status = GetConnectRequest(Irp, &Connect);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed to obtain connect details */
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
 
    /* allocate dispatch context */
    DispatchContext = AllocateItem(NonPagedPool, sizeof(DISPATCH_CONTEXT));
    if (!DispatchContext)
    {
        /* failed */
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* zero dispatch context */
    RtlZeroMemory(DispatchContext, sizeof(DISPATCH_CONTEXT));
 
    /* allocate object header */
    Status = KsAllocateObjectHeader(&DispatchContext->ObjectHeader, 0, NULL, Irp, &PinTable);
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        FreeItem(DispatchContext);
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    /* now instantiate the pins */
    Status = InstantiatePins(DeviceEntry, Connect, DispatchContext, (PSYSAUDIODEVEXT)DeviceObject->DeviceExtension);
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        KsFreeObjectHeader(DispatchContext->ObjectHeader);
        FreeItem(DispatchContext);
    }
    else
    {
        /* store dispatch context */
        IoStack->FileObject->FsContext = (PVOID)DispatchContext;
    }
 
 
    /* FIXME create items for clocks / allocators */
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by DispatchCreateSysAudio().

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

Referenced by BdaCreateFilterFactoryEx(), CompareProductName(), FindProductName(), FreeFilterInstance(), GetSysAudioDevicePnpName(), InsertPinHandle(), ReadKeyValue(), SysAudio_Shutdown(), USBSTOR_ClassRequest(), and USBSTOR_GetMaxLUN().

GetDeviceCount()

ULONG GetDeviceCount	(	PSYSAUDIODEVEXT	DeviceExtension,
		BOOL	WaveIn
	)

GetListEntry()

PKSAUDIO_DEVICE_ENTRY GetListEntry	(	IN PLIST_ENTRY	Head,
		IN ULONG	Index
	)

Definition at line 45 of file control.c.

{
    PLIST_ENTRY Entry = Head->Flink;
 
    while(Index-- && Entry != Head)
        Entry = Entry->Flink;
 
    if (Entry == Head)
        return NULL;
 
    return (PKSAUDIO_DEVICE_ENTRY)CONTAINING_RECORD(Entry, KSAUDIO_DEVICE_ENTRY, Entry);
}

Referenced by HandleSysAudioFilterPinProperties(), CIconWatcher::RemoveIconFromWatcher(), SysAudioHandleProperty(), and SysAudioOpenVirtualDevice().

GetPinInstanceCount()

NTSTATUS GetPinInstanceCount	(	PKSAUDIO_DEVICE_ENTRY	Entry,
		PKSPIN_CINSTANCES	PinInstances,
		PKSPIN_CONNECT	PinConnect
	)

Definition at line 269 of file control.c.

{
    KSP_PIN PinRequest;
    ULONG BytesReturned;
 
    /* query the instance count */
    PinRequest.PinId = PinConnect->PinId;
    PinRequest.Property.Set = KSPROPSETID_Pin;
    PinRequest.Property.Flags = KSPROPERTY_TYPE_GET;
    PinRequest.Property.Id = KSPROPERTY_PIN_CINSTANCES;
    ASSERT(Entry->FileObject);
    return KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&PinRequest, sizeof(KSP_PIN), (PVOID)PinInstances, sizeof(KSPIN_CINSTANCES), &BytesReturned);
 
}

Referenced by InstantiatePins().

OpenDevice()

NTSTATUS OpenDevice	(	IN PUNICODE_STRING	DeviceName,
		IN PHANDLE	HandleOut,
		IN PFILE_OBJECT *	FileObjectOut
	)

Definition at line 21 of file deviface.c.

{
    NTSTATUS Status;
    HANDLE NodeHandle;
    PFILE_OBJECT FileObject;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
 
    InitializeObjectAttributes(&ObjectAttributes, DeviceName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
 
    Status = ZwCreateFile(&NodeHandle,
                          GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          0,
                          0,
                          FILE_OPEN,
                          FILE_SYNCHRONOUS_IO_NONALERT,
                          NULL,
                          0);
 
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwCreateFile failed with %x %S\n", Status, DeviceName->Buffer);
        return Status;
    }
 
    Status = ObReferenceObjectByHandle(NodeHandle, GENERIC_READ | GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        ZwClose(NodeHandle);
        DPRINT("ObReferenceObjectByHandle failed with %x\n", Status);
        return Status;
    }
 
    *HandleOut = NodeHandle;
    *FileObjectOut = FileObject;
    return Status;
}

Referenced by InsertAudioDevice().

SysAudioAllocateDeviceHeader()

NTSTATUS SysAudioAllocateDeviceHeader

(

IN SYSAUDIODEVEXT *

DeviceExtension

)

Definition at line 104 of file dispatcher.c.

{
    NTSTATUS Status;
    PKSOBJECT_CREATE_ITEM CreateItem;
 
    /* allocate create item */
    CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM));
    if (!CreateItem)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* initialize create item struct */
    RtlZeroMemory(CreateItem, sizeof(KSOBJECT_CREATE_ITEM));
    CreateItem->Create = DispatchCreateSysAudio;
 
    /* FIXME Sysaudio doesnt need a named create item because it installs itself
     * via the device interface
     */
    RtlInitUnicodeString(&CreateItem->ObjectClass, L"GLOBAL");
    CreateItem->Flags = KSCREATE_ITEM_WILDCARD;
 
    Status = KsAllocateDeviceHeader(&DeviceExtension->KsDeviceHeader,
                                    1,
                                    CreateItem);
    return Status;
}

Referenced by SysAudio_AddDevice().

SysAudioHandleProperty()

NTSTATUS SysAudioHandleProperty	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 288 of file control.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
    KSPROPERTY PropertyRequest;
    KSCOMPONENTID ComponentId;
    PULONG Index;
    PKSPROPERTY Property;
    PSYSAUDIODEVEXT DeviceExtension;
    PKSAUDIO_DEVICE_ENTRY Entry;
    PSYSAUDIO_INSTANCE_INFO InstanceInfo;
    ULONG BytesReturned;
    UNICODE_STRING GuidString;
    PKSP_PIN Pin;
    LPWSTR DeviceName;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY))
    {
        /* buffer must be at least of sizeof KSPROPERTY */
        return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(KSPROPERTY));
    }
 
    Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
    DeviceExtension = (PSYSAUDIODEVEXT)DeviceObject->DeviceExtension;
 
    if (IsEqualGUIDAligned(&Property->Set, &KSPROPSETID_Pin))
    {
        return HandleSysAudioFilterPinProperties(Irp, Property, DeviceExtension);
    }
    else if(IsEqualGUIDAligned(&Property->Set, &KSPROPSETID_Topology))
    {
        if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSP_PIN))
        {
            /* too small buffer */
            return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(KSP_PIN));
        }
        Pin = (PKSP_PIN)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
        Entry = GetListEntry(&DeviceExtension->KsAudioDeviceList, Pin->Reserved);
        ASSERT(Entry != NULL);
 
        /* forward request to the filter implementing the property */
        Status = KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY,
                                             (PVOID)IoStack->Parameters.DeviceIoControl.Type3InputBuffer,
                                             IoStack->Parameters.DeviceIoControl.InputBufferLength,
                                             Irp->UserBuffer,
                                             IoStack->Parameters.DeviceIoControl.OutputBufferLength,
                                             &BytesReturned);
 
        return SetIrpIoStatus(Irp, Status, BytesReturned);
    }
    else if (IsEqualGUIDAligned(&Property->Set, &KSPROPSETID_Sysaudio))
    {
        if (Property->Id == KSPROPERTY_SYSAUDIO_DEVICE_INTERFACE_NAME)
        {
            if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY) + sizeof(ULONG))
            {
                /* invalid request */
                return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(KSPROPERTY) + sizeof(ULONG));
            }
            Index = (PULONG)(Property + 1);
 
            if (DeviceExtension->NumberOfKsAudioDevices <= *Index)
            {
                /* invalid index */
                return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
            }
 
            Entry = GetListEntry(&DeviceExtension->KsAudioDeviceList, *Index);
            ASSERT(Entry != NULL);
 
            BytesReturned = Entry->DeviceName.Length + sizeof(WCHAR);
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < BytesReturned)
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, BytesReturned);
            }
 
            /* copy device name */
            DeviceName = (LPWSTR)Irp->UserBuffer;
 
            RtlMoveMemory(DeviceName, Entry->DeviceName.Buffer, Entry->DeviceName.Length);
            DeviceName[Entry->DeviceName.Length / sizeof(WCHAR)] = L'\0';
            return SetIrpIoStatus(Irp, STATUS_SUCCESS, BytesReturned);
        }
 
        if (Property->Id == KSPROPERTY_SYSAUDIO_COMPONENT_ID)
        {
            if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY) + sizeof(ULONG))
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(KSPROPERTY) + sizeof(ULONG));
            }
 
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(KSCOMPONENTID))
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(KSCOMPONENTID));
            }
 
            Index = (PULONG)(Property + 1);
 
            if (DeviceExtension->NumberOfKsAudioDevices <= *Index)
            {
                /* invalid index */
                return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
            }
            Entry = GetListEntry(&DeviceExtension->KsAudioDeviceList, *Index);
            ASSERT(Entry != NULL);
 
            PropertyRequest.Set = KSPROPSETID_General;
            PropertyRequest.Id = KSPROPERTY_GENERAL_COMPONENTID;
            PropertyRequest.Flags = KSPROPERTY_TYPE_GET;
 
            /* call the filter */
            Status = KsSynchronousIoControlDevice(Entry->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&PropertyRequest, sizeof(KSPROPERTY), (PVOID)&ComponentId, sizeof(KSCOMPONENTID), &BytesReturned);
            if (!NT_SUCCESS(Status))
            {
                DPRINT("KsSynchronousIoControlDevice failed with %x for KSPROPERTY_GENERAL_COMPONENTID\n", Status);
                return SetIrpIoStatus(Irp, Status, 0);
            }
            RtlMoveMemory(Irp->UserBuffer, &ComponentId, sizeof(KSCOMPONENTID));
            return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(KSCOMPONENTID));
        }
        else if (Property->Id == KSPROPERTY_SYSAUDIO_DEVICE_COUNT)
        {
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(ULONG));
            }
 
            *((PULONG)Irp->UserBuffer) = DeviceExtension->NumberOfKsAudioDevices;
            return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(ULONG));
        }
        else if (Property->Id == KSPROPERTY_SYSAUDIO_DEVICE_INSTANCE)
        {
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(ULONG));
            }
 
            if (Property->Flags & KSPROPERTY_TYPE_SET)
            {
                Index = (PULONG)Irp->UserBuffer;
                return SysAudioOpenVirtualDevice(Irp, *Index, DeviceExtension);
            }
        }
        else if (Property->Id == KSPROPERTY_SYSAUDIO_INSTANCE_INFO)
        {
            if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SYSAUDIO_INSTANCE_INFO))
            {
                /* too small buffer */
                return SetIrpIoStatus(Irp, STATUS_BUFFER_TOO_SMALL, sizeof(SYSAUDIO_INSTANCE_INFO));
            }
 
            /* get input parameter */
            InstanceInfo = (PSYSAUDIO_INSTANCE_INFO)Property;
 
            if (Property->Flags & KSPROPERTY_TYPE_SET)
            {
                return SysAudioOpenVirtualDevice(Irp, InstanceInfo->DeviceNumber, DeviceExtension);
            }
        }
    }
 
    RtlStringFromGUID(&Property->Set, &GuidString);
    DPRINT1("Unhandled property Set |%S| Id %u Flags %x\n", GuidString.Buffer, Property->Id, Property->Flags);
    RtlFreeUnicodeString(&GuidString);
    return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
}

Referenced by Dispatch_fnDeviceIoControl().

SysAudioOpenKMixer()

NTSTATUS SysAudioOpenKMixer

(

IN SYSAUDIODEVEXT *

DeviceExtension

)

Definition at line 132 of file dispatcher.c.

{
    NTSTATUS Status;
    UNICODE_STRING DeviceInstanceName = RTL_CONSTANT_STRING(L"\\Device\\kmixer\\GLOBAL");
    UNICODE_STRING DevicePath = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\kmixer");
 
    Status = ZwLoadDriver(&DevicePath);
 
    if (NT_SUCCESS(Status))
    {
        Status = OpenDevice(&DeviceInstanceName, &DeviceExtension->KMixerHandle, &DeviceExtension->KMixerFileObject);
        if (!NT_SUCCESS(Status))
        {
            DeviceExtension->KMixerHandle = NULL;
            DeviceExtension->KMixerFileObject = NULL;
        }
    }
 
    DPRINT("Status %lx KMixerHandle %p KMixerFileObject %p\n", Status, DeviceExtension->KMixerHandle, DeviceExtension->KMixerFileObject);
    return STATUS_SUCCESS;
}

Referenced by SysAudio_AddDevice().

SysAudioRegisterDeviceInterfaces()

NTSTATUS SysAudioRegisterDeviceInterfaces

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 214 of file deviface.c.

{
    NTSTATUS Status;
    UNICODE_STRING SymbolicLink;
 
    Status = IoRegisterDeviceInterface(DeviceObject, &KSCATEGORY_PREFERRED_MIDIOUT_DEVICE, NULL, &SymbolicLink);
    if (NT_SUCCESS(Status))
    {
        IoSetDeviceInterfaceState(&SymbolicLink, TRUE);
        RtlFreeUnicodeString(&SymbolicLink);
    }
    else
    {
        DPRINT("Failed to register KSCATEGORY_PREFERRED_MIDIOUT_DEVICE interface Status %x\n", Status);
        return Status;
    }
 
    Status = IoRegisterDeviceInterface(DeviceObject, &KSCATEGORY_PREFERRED_WAVEIN_DEVICE, NULL, &SymbolicLink);
    if (NT_SUCCESS(Status))
    {
        IoSetDeviceInterfaceState(&SymbolicLink, TRUE);
        RtlFreeUnicodeString(&SymbolicLink);
    }
    else
    {
        DPRINT("Failed to register KSCATEGORY_PREFERRED_WAVEIN_DEVICE interface Status %x\n", Status);
        return Status;
    }
 
    Status = IoRegisterDeviceInterface(DeviceObject, &KSCATEGORY_PREFERRED_WAVEOUT_DEVICE, NULL, &SymbolicLink);
    if (NT_SUCCESS(Status))
    {
        IoSetDeviceInterfaceState(&SymbolicLink, TRUE);
        RtlFreeUnicodeString(&SymbolicLink);
    }
    else
    {
        DPRINT("Failed to register KSCATEGORY_PREFERRED_WAVEOUT_DEVICE interface Status %x\n", Status);
    }
 
    Status = IoRegisterDeviceInterface(DeviceObject, &KSCATEGORY_SYSAUDIO, NULL, &SymbolicLink);
    if (NT_SUCCESS(Status))
    {
        IoSetDeviceInterfaceState(&SymbolicLink, TRUE);
        RtlFreeUnicodeString(&SymbolicLink);
    }
    else
    {
        DPRINT("Failed to register KSCATEGORY_SYSAUDIO interface Status %x\n", Status);
    }
 
    return Status;
}

Referenced by SysAudio_AddDevice().

SysAudioRegisterNotifications()

NTSTATUS SysAudioRegisterNotifications	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 172 of file deviface.c.

{
    NTSTATUS Status;
    PSYSAUDIODEVEXT DeviceExtension;
 
    DeviceExtension = (PSYSAUDIODEVEXT)DeviceObject->DeviceExtension;
 
    Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                            PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                            (PVOID)&KS_CATEGORY_AUDIO,
                                            DriverObject,
                                            DeviceInterfaceChangeCallback,
                                            (PVOID)DeviceObject,
                                            (PVOID*)&DeviceExtension->KsAudioNotificationEntry);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("IoRegisterPlugPlayNotification failed with %x\n", Status);
    }
 
    Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                            PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                            (PVOID)&DMOCATEGORY_ACOUSTIC_ECHO_CANCEL,
                                            DriverObject,
                                            DeviceInterfaceChangeCallback,
                                            (PVOID)DeviceObject,
                                            (PVOID*)&DeviceExtension->EchoCancelNotificationEntry);
 
    if (!NT_SUCCESS(Status))
    {
        /* ignore failure for now */
        DPRINT("IoRegisterPlugPlayNotification failed for DMOCATEGORY_ACOUSTIC_ECHO_CANCEL\n", Status);
    }
 
    return STATUS_SUCCESS;
}

Referenced by SysAudio_AddDevice().