wdmaud.h File Reference

#include <portcls.h>
#include <mmsystem.h>
#include "interface.h"

Include dependency graph for wdmaud.h:

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

Go to the source code of this file.

Classes
struct	WDMAUD_COMPLETION_CONTEXT
struct	WDMAUD_HANDLE
struct	WDMAUD_CLIENT
struct	EVENT_ENTRY
struct	SYSAUDIO_ENTRY
struct	WDMAUD_DEVICE_EXTENSION
struct	PIN_CREATE_CONTEXT

Typedefs
typedef struct WDMAUD_COMPLETION_CONTEXT *	PWDMAUD_COMPLETION_CONTEXT
typedef struct WDMAUD_HANDLE *	PWDMAUD_HANDLE
typedef struct WDMAUD_CLIENT *	PWDMAUD_CLIENT
typedef struct EVENT_ENTRY *	PEVENT_ENTRY
typedef struct SYSAUDIO_ENTRY *	PSYSAUDIO_ENTRY
typedef struct WDMAUD_DEVICE_EXTENSION *	PWDMAUD_DEVICE_EXTENSION
typedef struct PIN_CREATE_CONTEXT *	PPIN_CREATE_CONTEXT

Functions
NTSTATUS NTAPI	OpenWavePin (IN PWDMAUD_DEVICE_EXTENSION DeviceExtension, IN ULONG FilterId, IN ULONG PinId, IN LPWAVEFORMATEX WaveFormatEx, IN ACCESS_MASK DesiredAccess, OUT PHANDLE PinHandle)
NTSTATUS	WdmAudRegisterDeviceInterface (IN PDEVICE_OBJECT PhysicalDeviceObject, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	WdmAudOpenSysAudioDevices (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	WdmAudOpenSysaudio (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_CLIENT *pClient)
NTSTATUS NTAPI	WdmAudDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	WdmAudReadWrite (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	WdmAudWrite (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	WdmAudControlOpenMixer (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS	WdmAudControlCloseMixer (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo, IN ULONG Index)
VOID	WdmAudCloseAllMixers (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_CLIENT ClientInfo, IN ULONG Index)
NTSTATUS	WdmAudControlOpenWave (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS	WdmAudControlOpenMidi (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
ULONG	GetNumOfMixerDevices (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	SetIrpIoStatus (IN PIRP Irp, IN NTSTATUS Status, IN ULONG Length)
NTSTATUS	WdmAudOpenSysAudioDevice (IN LPWSTR DeviceName, OUT PHANDLE Handle)
NTSTATUS	FindProductName (IN LPWSTR PnpName, IN ULONG ProductNameSize, OUT LPWSTR ProductName)
NTSTATUS	WdmAudMixerCapabilities (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	WdmAudWaveCapabilities (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	WdmAudMidiCapabilities (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	WdmAudGetPosition (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PWDMAUD_DEVICE_INFO DeviceInfo)
NTSTATUS NTAPI	WdmAudFrameSize (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS NTAPI	WdmAudGetLineInfo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS NTAPI	WdmAudGetLineControls (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS NTAPI	WdmAudSetControlDetails (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS NTAPI	WdmAudGetMixerEvent (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS NTAPI	WdmAudGetControlDetails (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo)
NTSTATUS	WdmAudMixerInitialize (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	WdmAudWaveInitialize (IN PDEVICE_OBJECT DeviceObject)
ULONG	ClosePin (IN PWDMAUD_CLIENT ClientInfo, IN ULONG FilterId, IN ULONG PinId, IN SOUND_DEVICE_TYPE DeviceType)
NTSTATUS	InsertPinHandle (IN PWDMAUD_CLIENT ClientInfo, IN ULONG FilterId, IN ULONG PinId, IN SOUND_DEVICE_TYPE DeviceType, IN HANDLE PinHandle, IN ULONG FreeIndex)
NTSTATUS	GetSysAudioDevicePnpName (IN PDEVICE_OBJECT DeviceObject, IN ULONG DeviceIndex, OUT LPWSTR *Device)
NTSTATUS	OpenSysAudioDeviceByIndex (IN PDEVICE_OBJECT DeviceObject, IN ULONG DeviceIndex, IN PHANDLE DeviceHandle, IN PFILE_OBJECT *FileObject)
NTSTATUS	OpenDevice (IN LPWSTR Device, OUT PHANDLE DeviceHandle, OUT PFILE_OBJECT *FileObject)
ULONG	WdmAudGetMixerDeviceCount (VOID)
ULONG	WdmAudGetWaveInDeviceCount (VOID)
ULONG	WdmAudGetWaveOutDeviceCount (VOID)
ULONG	WdmAudGetMidiInDeviceCount (VOID)
ULONG	WdmAudGetMidiOutDeviceCount (VOID)
NTSTATUS	WdmAudGetPnpNameByIndexAndType (IN ULONG DeviceIndex, IN SOUND_DEVICE_TYPE DeviceType, OUT LPWSTR *Device)
ULONG	GetSysAudioDeviceCount (IN PDEVICE_OBJECT DeviceObject)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID	FreeItem (IN PVOID Item)

Typedef Documentation

PEVENT_ENTRY

typedef struct EVENT_ENTRY * PEVENT_ENTRY

PPIN_CREATE_CONTEXT

typedef struct PIN_CREATE_CONTEXT * PPIN_CREATE_CONTEXT

PSYSAUDIO_ENTRY

typedef struct SYSAUDIO_ENTRY * PSYSAUDIO_ENTRY

PWDMAUD_CLIENT

typedef struct WDMAUD_CLIENT * PWDMAUD_CLIENT

PWDMAUD_COMPLETION_CONTEXT

typedef struct WDMAUD_COMPLETION_CONTEXT * PWDMAUD_COMPLETION_CONTEXT

PWDMAUD_DEVICE_EXTENSION

typedef struct WDMAUD_DEVICE_EXTENSION * PWDMAUD_DEVICE_EXTENSION

PWDMAUD_HANDLE

typedef struct WDMAUD_HANDLE * PWDMAUD_HANDLE

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

ClosePin()

ULONG ClosePin	(	IN PWDMAUD_CLIENT	ClientInfo,
		IN ULONG	FilterId,
		IN ULONG	PinId,
		IN SOUND_DEVICE_TYPE	DeviceType
	)

Definition at line 72 of file sup.c.

{
    ULONG Index;
 
    for(Index = 0; Index < ClientInfo->NumPins; Index++)
    {
        if (ClientInfo->hPins[Index].FilterId == FilterId && ClientInfo->hPins[Index].PinId == PinId && ClientInfo->hPins[Index].Handle && ClientInfo->hPins[Index].Type == DeviceType)
        {
            if (ClientInfo->hPins[Index].Type != MIXER_DEVICE_TYPE)
            {
                ZwClose(ClientInfo->hPins[Index].Handle);
            }
            ClientInfo->hPins[Index].Handle = NULL;
            return Index;
        }
    }
    return MAXULONG;
}

Referenced by CreatePinCallback().

FindProductName()

NTSTATUS FindProductName	(	IN LPWSTR	PnpName,
		IN ULONG	ProductNameSize,
		OUT LPWSTR	ProductName
	)

Definition at line 243 of file sup.c.

{
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\{4D36E96C-E325-11CE-BFC1-08002BE10318}");
 
    UNICODE_STRING SubKeyName;
    WCHAR SubKey[20];
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hKey, hSubKey;
    NTSTATUS Status;
    ULONG Length, Index;
    PKEY_FULL_INFORMATION KeyInformation;
 
    for(Index = 0; Index < wcslen(PnpName); Index++)
    {
        if (PnpName[Index] == '#')
            PnpName[Index] = L'\\';
    }
 
 
    /* initialize key attributes */
    InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF, NULL, NULL);
 
    /* open the key */
    Status = ZwOpenKey(&hKey, GENERIC_READ, &ObjectAttributes);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* query num of subkeys */
    Status = ZwQueryKey(hKey, KeyFullInformation, NULL, 0, &Length);
 
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        DPRINT1("ZwQueryKey failed with %x\n", Status);
        /* failed */
        ZwClose(hKey);
        return Status;
    }
 
    /* allocate key information struct */
    KeyInformation = AllocateItem(NonPagedPool, Length);
    if (!KeyInformation)
    {
        /* no memory */
        ZwClose(hKey);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* query num of subkeys */
    Status = ZwQueryKey(hKey, KeyFullInformation, (PVOID)KeyInformation, Length, &Length);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwQueryKey failed with %x\n", Status);
        FreeItem(KeyInformation);
        ZwClose(hKey);
        return Status;
    }
 
    /* now iterate through all subkeys */
    for(Index = 0; Index < KeyInformation->SubKeys; Index++)
    {
        /* subkeys are always in the format 0000-XXXX */
        swprintf(SubKey, L"%04u", Index);
 
        /* initialize subkey name */
        RtlInitUnicodeString(&SubKeyName, SubKey);
 
        /* initialize key attributes */
        InitializeObjectAttributes(&ObjectAttributes, &SubKeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF, hKey, NULL);
 
        /* open the sub key */
        Status = ZwOpenKey(&hSubKey, GENERIC_READ, &ObjectAttributes);
 
        /* check for success */
        if (NT_SUCCESS(Status))
        {
            /* compare product name */
            Status = CompareProductName(hSubKey, PnpName, ProductNameSize, ProductName);
 
            /* close subkey */
            ZwClose(hSubKey);
 
            if (NT_SUCCESS(Status))
                break;
        }
    }
 
    /* free buffer */
    FreeItem(KeyInformation);
 
    /* close key */
    ZwClose(hKey);
 
    /* no matching key found */
    return Status;
}

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

GetNumOfMixerDevices()

ULONG GetNumOfMixerDevices

(

IN PDEVICE_OBJECT

DeviceObject

)

GetSysAudioDeviceCount()

ULONG GetSysAudioDeviceCount

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 35 of file sup.c.

{
    PWDMAUD_DEVICE_EXTENSION DeviceExtension;
    KSPROPERTY Pin;
    ULONG Count, BytesReturned;
    NTSTATUS Status;
 
    /* setup the query request */
    Pin.Set = KSPROPSETID_Sysaudio;
    Pin.Id = KSPROPERTY_SYSAUDIO_DEVICE_COUNT;
    Pin.Flags = KSPROPERTY_TYPE_GET;
 
    DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* query sysaudio for the device count */
    Status = KsSynchronousIoControlDevice(DeviceExtension->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY), (PVOID)&Count, sizeof(ULONG), &BytesReturned);
    if (!NT_SUCCESS(Status))
        return 0;
 
    return Count;
}

Referenced by Enum(), GetSysAudioDevicePnpName(), WdmAudCloseAllMixers(), and WdmAudInitWorkerRoutine().

GetSysAudioDevicePnpName()

NTSTATUS GetSysAudioDevicePnpName	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	DeviceIndex,
		OUT LPWSTR *	Device
	)

Definition at line 346 of file sup.c.

{
    ULONG BytesReturned;
    KSP_PIN Pin;
    NTSTATUS Status;
    PWDMAUD_DEVICE_EXTENSION DeviceExtension;
 
   /* first check if the device index is within bounds */
   if (DeviceIndex >= GetSysAudioDeviceCount(DeviceObject))
       return STATUS_INVALID_PARAMETER;
 
    /* setup the query request */
    Pin.Property.Set = KSPROPSETID_Sysaudio;
    Pin.Property.Id = KSPROPERTY_SYSAUDIO_DEVICE_INTERFACE_NAME;
    Pin.Property.Flags = KSPROPERTY_TYPE_GET;
    Pin.PinId = DeviceIndex;
 
    DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    /* query sysaudio for the device path */
    Status = KsSynchronousIoControlDevice(DeviceExtension->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY) + sizeof(ULONG), NULL, 0, &BytesReturned);
 
    /* check if the request failed */
    if (Status != STATUS_BUFFER_TOO_SMALL || BytesReturned == 0)
        return STATUS_UNSUCCESSFUL;
 
    /* allocate buffer for the device */
    *Device = AllocateItem(NonPagedPool, BytesReturned);
    if (!Device)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* query sysaudio again for the device path */
    Status = KsSynchronousIoControlDevice(DeviceExtension->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY) + sizeof(ULONG), (PVOID)*Device, BytesReturned, &BytesReturned);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        FreeItem(*Device);
        return Status;
    }
 
    return Status;
}

Referenced by Enum().

InsertPinHandle()

NTSTATUS InsertPinHandle	(	IN PWDMAUD_CLIENT	ClientInfo,
		IN ULONG	FilterId,
		IN ULONG	PinId,
		IN SOUND_DEVICE_TYPE	DeviceType,
		IN HANDLE	PinHandle,
		IN ULONG	FreeIndex
	)

Definition at line 96 of file sup.c.

{
    PWDMAUD_HANDLE Handles;
 
    if (FreeIndex != MAXULONG)
    {
        /* re-use a free index */
        ClientInfo->hPins[FreeIndex].Handle = PinHandle;
        ClientInfo->hPins[FreeIndex].FilterId = FilterId;
        ClientInfo->hPins[FreeIndex].PinId = PinId;
        ClientInfo->hPins[FreeIndex].Type = DeviceType;
 
        return STATUS_SUCCESS;
    }
 
    Handles = AllocateItem(NonPagedPool, sizeof(WDMAUD_HANDLE) * (ClientInfo->NumPins+1));
 
    if (!Handles)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    if (ClientInfo->NumPins)
    {
        RtlMoveMemory(Handles, ClientInfo->hPins, sizeof(WDMAUD_HANDLE) * ClientInfo->NumPins);
        FreeItem(ClientInfo->hPins);
    }
 
    ClientInfo->hPins = Handles;
    ClientInfo->hPins[ClientInfo->NumPins].Handle = PinHandle;
    ClientInfo->hPins[ClientInfo->NumPins].Type = DeviceType;
    ClientInfo->hPins[ClientInfo->NumPins].FilterId = FilterId;
    ClientInfo->hPins[ClientInfo->NumPins].PinId = PinId;
    ClientInfo->NumPins++;
 
    return STATUS_SUCCESS;
}

Referenced by CreatePinCallback().

OpenDevice()

NTSTATUS OpenDevice	(	IN LPWSTR	Device,
		OUT PHANDLE	DeviceHandle,
		OUT PFILE_OBJECT *	FileObject
	)

Definition at line 394 of file sup.c.

{
    NTSTATUS Status;
    HANDLE hDevice;
 
    /* now open the device */
    Status = WdmAudOpenSysAudioDevice(Device, &hDevice);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    *DeviceHandle = hDevice;
 
    if (FileObject)
    {
        Status = ObReferenceObjectByHandle(hDevice, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID*)FileObject, NULL);
 
        if (!NT_SUCCESS(Status))
        {
            ZwClose(hDevice);
        }
    }
 
    return Status;
}

OpenSysAudioDeviceByIndex()

NTSTATUS OpenSysAudioDeviceByIndex	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	DeviceIndex,
		IN PHANDLE	DeviceHandle,
		IN PFILE_OBJECT *	FileObject
	)

OpenWavePin()

NTSTATUS NTAPI OpenWavePin	(	IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension,
		IN ULONG	FilterId,
		IN ULONG	PinId,
		IN LPWAVEFORMATEX	WaveFormatEx,
		IN ACCESS_MASK	DesiredAccess,
		OUT PHANDLE	PinHandle
	)

SetIrpIoStatus()

NTSTATUS SetIrpIoStatus	(	IN PIRP	Irp,
		IN NTSTATUS	Status,
		IN ULONG	Length
	)

Definition at line 59 of file sup.c.

{
    Irp->IoStatus.Information = Length;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by HandleSysAudioFilterPinProperties(), SysAudioHandleProperty(), SysAudioOpenVirtualDevice(), WdmAudCapabilities(), WdmAudControlCloseMixer(), WdmAudControlDeviceState(), WdmAudControlDeviceType(), WdmAudControlOpen(), WdmAudControlOpenMidi(), WdmAudControlOpenMixer(), WdmAudControlOpenWave(), WdmAudDeviceControl(), WdmAudFrameSize(), WdmAudGetControlDetails(), WdmAudGetDeviceInterface(), WdmAudGetLineControls(), WdmAudGetLineInfo(), WdmAudGetMixerEvent(), WdmAudGetPosition(), WdmAudIoctlClose(), WdmAudReadWrite(), WdmAudResetStream(), and WdmAudSetControlDetails().

WdmAudCloseAllMixers()

VOID WdmAudCloseAllMixers	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_CLIENT	ClientInfo,
		IN ULONG	Index
	)

Definition at line 501 of file mmixer.c.

{
    ULONG DeviceCount, DeviceIndex;
 
    /* Get all mixers */
    DeviceCount = GetSysAudioDeviceCount(DeviceObject);
 
    /* Close every mixer attached to the device */
    for (DeviceIndex = 0; DeviceIndex < DeviceCount; DeviceIndex++)
    {
        if (MMixerClose(&MixerContext, DeviceIndex, ClientInfo, EventCallback) != MM_STATUS_SUCCESS)
        {
            DPRINT1("Failed to close mixer for device %lu\n", DeviceIndex);
        }
    }
 
    /* Dereference event */
    if (ClientInfo->hPins[Index].NotifyEvent)
    {
        ObDereferenceObject(ClientInfo->hPins[Index].NotifyEvent);
        ClientInfo->hPins[Index].NotifyEvent = NULL;
    }
}

Referenced by WdmAudCleanup().

WdmAudControlCloseMixer()

NTSTATUS WdmAudControlCloseMixer	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo,
		IN ULONG	Index
	)

Definition at line 475 of file mmixer.c.

{
    /* Remove event associated to this client */
    if (MMixerClose(&MixerContext, DeviceInfo->DeviceIndex, ClientInfo, EventCallback) != MM_STATUS_SUCCESS)
    {
        DPRINT1("Failed to close mixer\n");
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
    }
 
    /* Dereference event */
    if (ClientInfo->hPins[Index].NotifyEvent)
    {
        ObDereferenceObject(ClientInfo->hPins[Index].NotifyEvent);
        ClientInfo->hPins[Index].NotifyEvent = NULL;
    }
 
    /* FIXME: do we need to free ClientInfo->hPins ? */
    return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudIoctlClose().

WdmAudControlOpenMidi()

NTSTATUS WdmAudControlOpenMidi	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 869 of file mmixer.c.

{
    MIXER_STATUS Status;
    PIN_CREATE_CONTEXT Context;
 
    Context.ClientInfo = ClientInfo;
    Context.DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    Context.DeviceType = DeviceInfo->DeviceType;
 
    Status = MMixerOpenMidi(&MixerContext, DeviceInfo->DeviceIndex, DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE, CreatePinCallback, &Context, &DeviceInfo->hDevice);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_NOT_SUPPORTED, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudControlOpen().

WdmAudControlOpenMixer()

NTSTATUS WdmAudControlOpenMixer	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 411 of file mmixer.c.

{
    HANDLE hMixer;
    PWDMAUD_HANDLE Handles;
    //PWDMAUD_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    PKEVENT EventObject = NULL;
 
    DPRINT("WdmAudControlOpenMixer\n");
 
    //DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    if (DeviceInfo->u.hNotifyEvent)
    {
        Status = ObReferenceObjectByHandle(DeviceInfo->u.hNotifyEvent, EVENT_MODIFY_STATE, *ExEventObjectType, UserMode, (LPVOID*)&EventObject, NULL);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Invalid notify event passed %p from client %p\n", DeviceInfo->u.hNotifyEvent, ClientInfo);
            DbgBreakPoint();
            return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
        }
    }
 
    if (MMixerOpen(&MixerContext, DeviceInfo->DeviceIndex, ClientInfo, EventCallback, &hMixer) != MM_STATUS_SUCCESS)
    {
        ObDereferenceObject(EventObject);
        DPRINT1("Failed to open mixer\n");
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
    }
 
 
    Handles = AllocateItem(NonPagedPool, sizeof(WDMAUD_HANDLE) * (ClientInfo->NumPins+1));
 
    if (Handles)
    {
        if (ClientInfo->NumPins)
        {
            RtlMoveMemory(Handles, ClientInfo->hPins, sizeof(WDMAUD_HANDLE) * ClientInfo->NumPins);
            FreeItem(ClientInfo->hPins);
        }
 
        ClientInfo->hPins = Handles;
        ClientInfo->hPins[ClientInfo->NumPins].Handle = hMixer;
        ClientInfo->hPins[ClientInfo->NumPins].Type = MIXER_DEVICE_TYPE;
        ClientInfo->hPins[ClientInfo->NumPins].NotifyEvent = EventObject;
        ClientInfo->NumPins++;
    }
    else
    {
        ObDereferenceObject(EventObject);
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
    }
 
    DeviceInfo->hDevice = hMixer;
 
    return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudControlOpen().

WdmAudControlOpenWave()

NTSTATUS WdmAudControlOpenWave	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 847 of file mmixer.c.

{
    MIXER_STATUS Status;
    PIN_CREATE_CONTEXT Context;
 
    Context.ClientInfo = ClientInfo;
    Context.DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    Context.DeviceType = DeviceInfo->DeviceType;
 
    Status = MMixerOpenWave(&MixerContext, DeviceInfo->DeviceIndex, DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE, &DeviceInfo->u.WaveFormatEx, CreatePinCallback, &Context, &DeviceInfo->hDevice);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_NOT_SUPPORTED, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudControlOpen().

WdmAudDeviceControl()

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

Definition at line 302 of file control.c.

{
    PIO_STACK_LOCATION IoStack;
    PWDMAUD_DEVICE_INFO DeviceInfo;
    PWDMAUD_CLIENT ClientInfo;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    DPRINT("WdmAudDeviceControl entered\n");
 
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(WDMAUD_DEVICE_INFO))
    {
        /* invalid parameter */
        DPRINT1("Input buffer too small size %u expected %u\n", IoStack->Parameters.DeviceIoControl.InputBufferLength, sizeof(WDMAUD_DEVICE_INFO));
        return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
    }
 
    DeviceInfo = (PWDMAUD_DEVICE_INFO)Irp->AssociatedIrp.SystemBuffer;
 
    if (DeviceInfo->DeviceType < MIN_SOUND_DEVICE_TYPE || DeviceInfo->DeviceType > MAX_SOUND_DEVICE_TYPE)
    {
        /* invalid parameter */
        DPRINT1("Error: device type not set\n");
        return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
    }
 
    if (!IoStack->FileObject || !IoStack->FileObject->FsContext)
    {
        /* file object parameter */
        DPRINT1("Error: file object is not attached\n");
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
    }
    ClientInfo = (PWDMAUD_CLIENT)IoStack->FileObject->FsContext;
 
    DPRINT("WdmAudDeviceControl entered\n");
 
    switch(IoStack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_OPEN_WDMAUD:
            return WdmAudControlOpen(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETNUMDEVS_TYPE:
            return WdmAudControlDeviceType(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_SETDEVICE_STATE:
            return WdmAudControlDeviceState(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETCAPABILITIES:
            return WdmAudCapabilities(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_CLOSE_WDMAUD:
            return WdmAudIoctlClose(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETFRAMESIZE:
            return WdmAudFrameSize(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETLINEINFO:
            return WdmAudGetLineInfo(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETLINECONTROLS:
            return WdmAudGetLineControls(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_SETCONTROLDETAILS:
            return WdmAudSetControlDetails(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_GETCONTROLDETAILS:
            return WdmAudGetControlDetails(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_QUERYDEVICEINTERFACESTRING:
            return WdmAudGetDeviceInterface(DeviceObject, Irp, DeviceInfo);
        case IOCTL_GET_MIXER_EVENT:
            return WdmAudGetMixerEvent(DeviceObject, Irp, DeviceInfo, ClientInfo);
        case IOCTL_RESET_STREAM:
            return WdmAudResetStream(DeviceObject, Irp, DeviceInfo);
        case IOCTL_GETPOS:
            return WdmAudGetPosition(DeviceObject, Irp, DeviceInfo);
        case IOCTL_GETDEVID:
        case IOCTL_GETVOLUME:
        case IOCTL_SETVOLUME:
 
           DPRINT1("Unhandled %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
           break;
    }
 
    return SetIrpIoStatus(Irp, STATUS_NOT_IMPLEMENTED, 0);
}

Referenced by DriverEntry().

WdmAudFrameSize()

NTSTATUS NTAPI WdmAudFrameSize	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 180 of file control.c.

{
    PFILE_OBJECT FileObject;
    KSPROPERTY Property;
    ULONG BytesReturned;
    KSALLOCATOR_FRAMING Framing;
    NTSTATUS Status;
 
    /* Get sysaudio pin file object */
    Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Invalid buffer handle %p\n", DeviceInfo->hDevice);
        return SetIrpIoStatus(Irp, Status, 0);
    }
 
    /* Setup get framing request */
    Property.Id = KSPROPERTY_CONNECTION_ALLOCATORFRAMING;
    Property.Flags = KSPROPERTY_TYPE_GET;
    Property.Set = KSPROPSETID_Connection;
 
    Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&Framing, sizeof(KSALLOCATOR_FRAMING), &BytesReturned);
    /* Did we succeed */
    if (NT_SUCCESS(Status))
    {
        /* Store framesize */
        DeviceInfo->u.FrameSize = Framing.FrameSize;
    }
 
    /* Release file object */
    ObDereferenceObject(FileObject);
 
    return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 
}

Referenced by WdmAudDeviceControl().

WdmAudGetControlDetails()

NTSTATUS NTAPI WdmAudGetControlDetails	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 530 of file mmixer.c.

{
    MIXER_STATUS Status;
 
    /* clear hmixer type flag */
    DeviceInfo->Flags &= ~MIXER_OBJECTF_HMIXER;
 
    /* query mmixer library */
    Status = MMixerGetControlDetails(&MixerContext, DeviceInfo->hDevice, DeviceInfo->DeviceIndex, DeviceInfo->Flags, &DeviceInfo->u.MixDetails);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
}

WdmAudGetLineControls()

NTSTATUS NTAPI WdmAudGetLineControls	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 574 of file mmixer.c.

{
    MIXER_STATUS Status;
 
    /* clear hmixer type flag */
    DeviceInfo->Flags &= ~MIXER_OBJECTF_HMIXER;
 
    /* query mixer library */
    Status = MMixerGetLineControls(&MixerContext, DeviceInfo->hDevice, DeviceInfo->DeviceIndex, DeviceInfo->Flags, &DeviceInfo->u.MixControls);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
 
 
}

WdmAudGetLineInfo()

NTSTATUS NTAPI WdmAudGetLineInfo	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 552 of file mmixer.c.

{
    MIXER_STATUS Status;
 
    /* clear hmixer type flag */
    DeviceInfo->Flags &= ~MIXER_OBJECTF_HMIXER;
 
    /* query mixer library */
    Status = MMixerGetLineInfo(&MixerContext, DeviceInfo->hDevice, DeviceInfo->DeviceIndex, DeviceInfo->Flags, &DeviceInfo->u.MixLine);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
}

WdmAudGetMidiInDeviceCount()

ULONG WdmAudGetMidiInDeviceCount

(

VOID

)

WdmAudGetMidiOutDeviceCount()

ULONG WdmAudGetMidiOutDeviceCount

(

VOID

)

WdmAudGetMixerDeviceCount()

ULONG WdmAudGetMixerDeviceCount

(

VOID

)

WdmAudGetMixerEvent()

NTSTATUS NTAPI WdmAudGetMixerEvent	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 620 of file mmixer.c.

{
    PLIST_ENTRY Entry;
    PEVENT_ENTRY EventEntry;
 
    /* enumerate event list and check if there is a new event */
    Entry = ClientInfo->MixerEventList.Flink;
 
    while(Entry != &ClientInfo->MixerEventList)
    {
        /* grab event entry */
        EventEntry = (PEVENT_ENTRY)CONTAINING_RECORD(Entry, EVENT_ENTRY, Entry);
 
        if (EventEntry->hMixer == DeviceInfo->hDevice)
        {
            /* found an entry */
            DeviceInfo->u.MixerEvent.hMixer = EventEntry->hMixer;
            DeviceInfo->u.MixerEvent.NotificationType = EventEntry->NotificationType;
            DeviceInfo->u.MixerEvent.Value = EventEntry->Value;
 
            /* remove entry from list */
            RemoveEntryList(&EventEntry->Entry);
 
            /* free event entry */
            FreeItem(EventEntry);
 
            /* done */
            return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
        }
 
        /* move to next */
        Entry = Entry->Flink;
    }
 
    /* no event entry available */
    return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudDeviceControl().

WdmAudGetPnpNameByIndexAndType()

NTSTATUS WdmAudGetPnpNameByIndexAndType	(	IN ULONG	DeviceIndex,
		IN SOUND_DEVICE_TYPE	DeviceType,
		OUT LPWSTR *	Device
	)

Definition at line 693 of file mmixer.c.

{
    if (DeviceType == WAVE_IN_DEVICE_TYPE || DeviceType == WAVE_OUT_DEVICE_TYPE)
    {
        if (MMixerGetWaveDevicePath(&MixerContext, DeviceType == WAVE_IN_DEVICE_TYPE, DeviceIndex, DevicePath) == MM_STATUS_SUCCESS)
            return STATUS_SUCCESS;
        else
            return STATUS_UNSUCCESSFUL;
    }
    else if (DeviceType == MIDI_IN_DEVICE_TYPE || DeviceType == MIDI_OUT_DEVICE_TYPE)
    {
        if (MMixerGetMidiDevicePath(&MixerContext, DeviceType == MIDI_IN_DEVICE_TYPE, DeviceIndex, DevicePath) == MM_STATUS_SUCCESS)
            return STATUS_SUCCESS;
        else
            return STATUS_UNSUCCESSFUL;
    }
    else if (DeviceType == MIXER_DEVICE_TYPE)
    {
        UNIMPLEMENTED;
    }
 
    return STATUS_UNSUCCESSFUL;
}

Referenced by WdmAudGetDeviceInterface().

WdmAudGetPosition()

NTSTATUS NTAPI WdmAudGetPosition	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ PWDMAUD_DEVICE_INFO	DeviceInfo
	)

Definition at line 774 of file mmixer.c.

{
    MIXER_STATUS Status;
    ULONG Position;
 
    /* Get position */
    Status = MMixerGetWavePosition(&MixerContext, DeviceInfo->hDevice, &Position);
 
    if (Status == MM_STATUS_SUCCESS)
    {   
        DeviceInfo->u.Position = (ULONGLONG)Position;
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    }
    else
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
}

Referenced by WdmAudDeviceControl().

WdmAudGetWaveInDeviceCount()

ULONG WdmAudGetWaveInDeviceCount

(

VOID

)

WdmAudGetWaveOutDeviceCount()

ULONG WdmAudGetWaveOutDeviceCount

(

VOID

)

WdmAudMidiCapabilities()

NTSTATUS WdmAudMidiCapabilities	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo,
		IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 747 of file mmixer.c.

{
    MIXER_STATUS Status = MM_STATUS_UNSUCCESSFUL;
 
    if (DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE)
    {
        /* get capabilities */
        Status = MMixerMidiInCapabilities(&MixerContext, DeviceInfo->DeviceIndex, &DeviceInfo->u.MidiInCaps);
    }
    else if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
    {
        /* get capabilities */
        Status = MMixerMidiOutCapabilities(&MixerContext, DeviceInfo->DeviceIndex, &DeviceInfo->u.MidiOutCaps);
    }
 
    if (Status == MM_STATUS_SUCCESS)
        return STATUS_SUCCESS;
    else
        return STATUS_UNSUCCESSFUL;
}

Referenced by WdmAudCapabilities().

WdmAudMixerCapabilities()

NTSTATUS WdmAudMixerCapabilities	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo,
		IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 398 of file mmixer.c.

{
    if (MMixerGetCapabilities(&MixerContext, DeviceInfo->DeviceIndex, &DeviceInfo->u.MixCaps) == MM_STATUS_SUCCESS)
        return STATUS_SUCCESS;
 
    return STATUS_INVALID_PARAMETER;
}

Referenced by WdmAudCapabilities().

WdmAudMixerInitialize()

NTSTATUS WdmAudMixerInitialize

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 380 of file mmixer.c.

{
    MIXER_STATUS Status;
 
    /* initialize the mixer library */
    Status = MMixerInitialize(&MixerContext, Enum, (PVOID)DeviceObject);
 
    if (Status != MM_STATUS_SUCCESS)
    {
        /* failed to initialize mmixer library */
        DPRINT("MMixerInitialize failed with %lx\n", Status);
    }
 
    return Status;
}

Referenced by WdmAudInitWorkerRoutine().

WdmAudOpenSysaudio()

NTSTATUS WdmAudOpenSysaudio	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_CLIENT *	pClient
	)

Definition at line 206 of file deviface.c.

{
    PWDMAUD_CLIENT Client;
    PWDMAUD_DEVICE_EXTENSION DeviceExtension;
 
    /* get device extension */
    DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    if (!DeviceExtension->NumSysAudioDevices)
    {
        /* wdmaud failed to open sysaudio */
        return STATUS_UNSUCCESSFUL;
    }
 
    /* sanity check */
    ASSERT(!IsListEmpty(&DeviceExtension->SysAudioDeviceList));
 
    /* allocate client context struct */
    Client = AllocateItem(NonPagedPool, sizeof(WDMAUD_CLIENT));
 
    /* check for allocation failure */
    if (!Client)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* zero client context struct */
    RtlZeroMemory(Client, sizeof(WDMAUD_CLIENT));
 
    /* initialize mixer event list */
    InitializeListHead(&Client->MixerEventList);
 
    /* store result */
    *pClient = Client;
 
    /* insert client into list */
    ExInterlockedInsertTailList(&DeviceExtension->WdmAudClientList, &Client->Entry, &DeviceExtension->Lock);
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by WdmAudCreate().

WdmAudOpenSysAudioDevice()

NTSTATUS WdmAudOpenSysAudioDevice	(	IN LPWSTR	DeviceName,
		OUT PHANDLE	Handle
	)

Definition at line 16 of file deviface.c.

{
    UNICODE_STRING SymbolicLink;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    NTSTATUS Status;
 
    RtlInitUnicodeString(&SymbolicLink, DeviceName);
    InitializeObjectAttributes(&ObjectAttributes, &SymbolicLink, OBJ_OPENIF | OBJ_KERNEL_HANDLE, NULL, NULL);
 
    Status = IoCreateFile(Handle,
                          SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          0,
                          0,
                          FILE_OPEN,
                          FILE_SYNCHRONOUS_IO_NONALERT,
                          NULL,
                          0,
                          CreateFileTypeNone,
                          NULL,
                          IO_NO_PARAMETER_CHECKING | IO_FORCE_ACCESS_CHECK);
 
    return Status;
}

Referenced by Open(), OpenDevice(), and WdmAudOpenSysAudioDevices().

WdmAudOpenSysAudioDevices()

NTSTATUS WdmAudOpenSysAudioDevices	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 93 of file deviface.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    LPWSTR SymbolicLinkList;
    SYSAUDIO_ENTRY * Entry;
    ULONG Length;
    HANDLE hSysAudio;
    PFILE_OBJECT FileObject;
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\sysaudio\\GLOBAL");
 
    if (DeviceExtension->DeviceInterfaceSupport)
    {
        Status = IoGetDeviceInterfaces(&KSCATEGORY_SYSAUDIO,
                                       NULL,
                                       0,
                                       &SymbolicLinkList);
 
        if (NT_SUCCESS(Status))
        {
            WdmAudOpenSysAudioDeviceInterfaces(DeviceExtension, SymbolicLinkList);
            FreeItem(SymbolicLinkList);
        }
 
 
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                               (PVOID)&KSCATEGORY_SYSAUDIO,
                                                DeviceObject->DriverObject,
                                                DeviceInterfaceChangeCallback,
                                               (PVOID)DeviceExtension,
                                               &DeviceExtension->SysAudioNotification);
    }
    else
    {
            Entry = (SYSAUDIO_ENTRY*)AllocateItem(NonPagedPool, sizeof(SYSAUDIO_ENTRY));
            if (!Entry)
            {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
 
            Length = wcslen(DeviceName.Buffer) + 1;
            Entry->SymbolicLink.Length = 0;
            Entry->SymbolicLink.MaximumLength = Length * sizeof(WCHAR);
            Entry->SymbolicLink.Buffer = AllocateItem(NonPagedPool, Entry->SymbolicLink.MaximumLength);
 
            if (!Entry->SymbolicLink.Buffer)
            {
                FreeItem(Entry);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            Status = RtlAppendUnicodeStringToString(&Entry->SymbolicLink, &DeviceName);
 
            if (!NT_SUCCESS(Status))
            {
                FreeItem(Entry->SymbolicLink.Buffer);
                FreeItem(Entry);
                return Status;
            }
 
            DPRINT("Opening device %S\n", Entry->SymbolicLink.Buffer);
            Status = WdmAudOpenSysAudioDevice(Entry->SymbolicLink.Buffer, &hSysAudio);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to open sysaudio %x\n", Status);
                FreeItem(Entry->SymbolicLink.Buffer);
                FreeItem(Entry);
                return Status;
            }
 
            InsertTailList(&DeviceExtension->SysAudioDeviceList, &Entry->Entry);
            DeviceExtension->NumSysAudioDevices++;
 
            /* get the file object */
            Status = ObReferenceObjectByHandle(hSysAudio, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to reference FileObject %x\n", Status);
                ZwClose(hSysAudio);
                return Status;
            }
            DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
            DeviceExtension->hSysAudio = hSysAudio;
            DeviceExtension->FileObject = FileObject;
    }
 
    return Status;
}

Referenced by WdmAudInitWorkerRoutine().

WdmAudReadWrite()

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

Definition at line 437 of file control.c.

{
    NTSTATUS Status;
    PWDMAUD_DEVICE_INFO DeviceInfo;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION IoStack;
    ULONG Length;
    PMDL Mdl;
    BOOLEAN Read = TRUE;
    PWDMAUD_COMPLETION_CONTEXT Context;
 
    /* allocate completion context */
    Context = AllocateItem(NonPagedPool, sizeof(WDMAUD_COMPLETION_CONTEXT));
 
    if (!Context)
    {
        /* not enough memory */
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        /* done */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* store the input buffer in UserBuffer - as KsProbeStreamIrp operates on IRP_MJ_DEVICE_CONTROL */
    Irp->UserBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
 
    /* sanity check */
    ASSERT(Irp->UserBuffer);
 
    /* get the length of the request length */
    Length = IoStack->Parameters.Write.Length;
 
    /* store outputbuffer length */
    IoStack->Parameters.DeviceIoControl.OutputBufferLength = Length;
 
    /* setup context */
    Context->Length = Length;
    Context->Function = (IoStack->MajorFunction == IRP_MJ_WRITE ? IOCTL_KS_WRITE_STREAM : IOCTL_KS_READ_STREAM);
    Context->Mdl = Irp->MdlAddress;
 
    /* store mdl address */
    Mdl = Irp->MdlAddress;
 
    /* remove mdladdress as KsProbeStreamIrp will interpret it as an already probed audio buffer */
    Irp->MdlAddress = NULL;
 
    if (IoStack->MajorFunction == IRP_MJ_WRITE)
    {
        /* probe the write stream irp */
        Read = FALSE;
        Status = KsProbeStreamIrp(Irp, KSPROBE_STREAMWRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK, Length);
    }
    else
    {
        /* probe the read stream irp */
        Status = KsProbeStreamIrp(Irp, KSPROBE_STREAMREAD | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK, Length);
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("KsProbeStreamIrp failed with Status %x Cancel %u\n", Status, Irp->Cancel);
        Irp->MdlAddress = Mdl;
        FreeItem(Context);
        return SetIrpIoStatus(Irp, Status, 0);
    }
 
    /* get device info */
    DeviceInfo = (PWDMAUD_DEVICE_INFO)Irp->AssociatedIrp.SystemBuffer;
    ASSERT(DeviceInfo);
 
    /* now get sysaudio file object */
    Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Invalid pin handle %p\n", DeviceInfo->hDevice);
        Irp->MdlAddress = Mdl;
        FreeItem(Context);
        return SetIrpIoStatus(Irp, Status, 0);
    }
 
    /* store file object whose reference is released in the completion callback */
    Context->FileObject = FileObject;
 
    /* skip current irp stack location */
    IoSkipCurrentIrpStackLocation(Irp);
 
    /* get next stack location */
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    /* prepare stack location */
    IoStack->FileObject = FileObject;
    IoStack->Parameters.Write.Length = Length;
    IoStack->MajorFunction = IRP_MJ_WRITE;
    IoStack->Parameters.DeviceIoControl.IoControlCode = (Read ? IOCTL_KS_READ_STREAM : IOCTL_KS_WRITE_STREAM);
    IoSetCompletionRoutine(Irp, IoCompletion, (PVOID)Context, TRUE, TRUE, TRUE);
 
    /* mark irp as pending */
//    IoMarkIrpPending(Irp);
    /* call the driver */
    Status = IoCallDriver(IoGetRelatedDeviceObject(FileObject), Irp);
    return Status;
}

Referenced by DriverEntry().

WdmAudRegisterDeviceInterface()

NTSTATUS WdmAudRegisterDeviceInterface	(	IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 186 of file deviface.c.

{
    NTSTATUS Status;
    UNICODE_STRING SymbolicLinkName;
 
    Status = IoRegisterDeviceInterface(PhysicalDeviceObject, &KSCATEGORY_WDMAUD, NULL, &SymbolicLinkName);
    if (NT_SUCCESS(Status))
    {
        IoSetDeviceInterfaceState(&SymbolicLinkName, TRUE);
        RtlFreeUnicodeString(&SymbolicLinkName);
        //DeviceExtension->DeviceInterfaceSupport = TRUE;
        return Status;
    }
 
    return Status;
}

Referenced by WdmaudAddDevice().

WdmAudSetControlDetails()

NTSTATUS NTAPI WdmAudSetControlDetails	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo
	)

Definition at line 598 of file mmixer.c.

{
    MIXER_STATUS Status;
 
    /* clear hmixer type flag */
    DeviceInfo->Flags &= ~MIXER_OBJECTF_HMIXER;
 
    /* query mixer library */
    Status = MMixerSetControlDetails(&MixerContext, DeviceInfo->hDevice, DeviceInfo->DeviceIndex, DeviceInfo->Flags, &DeviceInfo->u.MixDetails);
 
    if (Status == MM_STATUS_SUCCESS)
        return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
    else
        return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, sizeof(WDMAUD_DEVICE_INFO));
}

WdmAudWaveCapabilities()

NTSTATUS WdmAudWaveCapabilities	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PWDMAUD_DEVICE_INFO	DeviceInfo,
		IN PWDMAUD_CLIENT	ClientInfo,
		IN PWDMAUD_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 721 of file mmixer.c.

{
    MIXER_STATUS Status = MM_STATUS_UNSUCCESSFUL;
 
    if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
    {
        /* get capabilities */
        Status = MMixerWaveInCapabilities(&MixerContext, DeviceInfo->DeviceIndex, &DeviceInfo->u.WaveInCaps);
    }
    else if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
    {
        /* get capabilities */
        Status = MMixerWaveOutCapabilities(&MixerContext, DeviceInfo->DeviceIndex, &DeviceInfo->u.WaveOutCaps);
    }
 
    if (Status == MM_STATUS_SUCCESS)
        return STATUS_SUCCESS;
    else
        return Status;
}

Referenced by WdmAudCapabilities().

WdmAudWaveInitialize()

NTSTATUS NTAPI WdmAudWaveInitialize

(

IN PDEVICE_OBJECT

DeviceObject

)

WdmAudWrite()

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