mmixer.c File Reference

#include "wdmaud.h"
#include <mmixer.h>
#include <debug.h>

Include dependency graph for mmixer.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PVOID	Alloc (ULONG NumBytes)
MIXER_STATUS	Close (HANDLE hDevice)
VOID	Free (PVOID Block)
VOID	Copy (PVOID Src, PVOID Dst, ULONG NumBytes)
MIXER_STATUS	Open (IN LPWSTR DevicePath, OUT PHANDLE hDevice)
MIXER_STATUS	Control (IN HANDLE hMixer, IN ULONG dwIoControlCode, IN PVOID lpInBuffer, IN ULONG nInBufferSize, OUT PVOID lpOutBuffer, ULONG nOutBufferSize, PULONG lpBytesReturned)
MIXER_STATUS	Enum (IN PVOID EnumContext, IN ULONG DeviceIndex, OUT LPWSTR *DeviceName, OUT PHANDLE OutHandle, OUT PHANDLE OutKey)
MIXER_STATUS	OpenKey (IN HANDLE hKey, IN LPWSTR SubKey, IN ULONG DesiredAccess, OUT PHANDLE OutKey)
MIXER_STATUS	CloseKey (IN HANDLE hKey)
MIXER_STATUS	QueryKeyValue (IN HANDLE hKey, IN LPWSTR KeyName, OUT PVOID *ResultBuffer, OUT PULONG ResultLength, OUT PULONG KeyType)
PVOID	AllocEventData (IN ULONG ExtraSize)
VOID	FreeEventData (IN PVOID EventData)
VOID CALLBACK	EventCallback (IN PVOID MixerEventContext, IN HANDLE hMixer, IN ULONG NotificationType, IN ULONG Value)
NTSTATUS	WdmAudMixerInitialize (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	WdmAudMixerCapabilities (IN PDEVICE_OBJECT DeviceObject, IN PWDMAUD_DEVICE_INFO DeviceInfo, IN PWDMAUD_CLIENT ClientInfo, IN PWDMAUD_DEVICE_EXTENSION DeviceExtension)
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 NTAPI	WdmAudGetControlDetails (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)
ULONG	WdmAudGetMixerDeviceCount ()
ULONG	WdmAudGetWaveInDeviceCount ()
ULONG	WdmAudGetWaveOutDeviceCount ()
ULONG	WdmAudGetMidiInDeviceCount ()
ULONG	WdmAudGetMidiOutDeviceCount ()
NTSTATUS	WdmAudGetPnpNameByIndexAndType (IN ULONG DeviceIndex, IN SOUND_DEVICE_TYPE DeviceType, OUT LPWSTR *DevicePath)
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)
MIXER_STATUS	CreatePinCallback (IN PVOID Ctx, IN ULONG VirtualDeviceId, IN ULONG PinId, IN HANDLE hFilter, IN PKSPIN_CONNECT PinConnect, IN ACCESS_MASK DesiredAccess, OUT PHANDLE PinHandle)
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)

Variables
MIXER_CONTEXT	MixerContext
GUID	CategoryGuid = {STATIC_KSCATEGORY_AUDIO}

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file mmixer.c.

Function Documentation

Alloc()

PVOID Alloc

(

ULONG

NumBytes

)

Definition at line 154 of file mmixer.c.

{
    return AllocateItem(NonPagedPool, NumBytes);
}

AllocEventData()

PVOID AllocEventData

(

IN ULONG

ExtraSize

)

Definition at line 302 of file mmixer.c.

{
    PKSEVENTDATA Data = (PKSEVENTDATA)AllocateItem(NonPagedPool, sizeof(KSEVENTDATA) + ExtraSize);
    if (!Data)
        return NULL;
 
    Data->EventObject.Event = AllocateItem(NonPagedPool, sizeof(KEVENT));
    if (!Data->EventHandle.Event)
    {
        FreeItem(Data);
        return NULL;
    }
 
    KeInitializeEvent(Data->EventObject.Event, NotificationEvent, FALSE);
 
    Data->NotificationType = KSEVENTF_EVENT_HANDLE;
    return Data;
}

Close()

MIXER_STATUS Close

(

HANDLE

hDevice

)

Definition at line 160 of file mmixer.c.

{
    if (ZwClose(hDevice) == STATUS_SUCCESS)
        return MM_STATUS_SUCCESS;
    else
        return MM_STATUS_UNSUCCESSFUL;
}

CloseKey()

MIXER_STATUS CloseKey

(

IN HANDLE

hKey

)

Definition at line 144 of file mmixer.c.

{
    if (ZwClose(hKey) == STATUS_SUCCESS)
        return MM_STATUS_SUCCESS;
    else
        return MM_STATUS_UNSUCCESSFUL;
}

Control()

MIXER_STATUS Control	(	IN HANDLE	hMixer,
		IN ULONG	dwIoControlCode,
		IN PVOID	lpInBuffer,
		IN ULONG	nInBufferSize,
		OUT PVOID	lpOutBuffer,
		ULONG	nOutBufferSize,
		PULONG	lpBytesReturned
	)

Definition at line 192 of file mmixer.c.

{
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
 
    /* get file object */
    Status = ObReferenceObjectByHandle(hMixer, GENERIC_READ | GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("failed to reference %p with %lx\n", hMixer, Status);
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    /* perform request */
    Status = KsSynchronousIoControlDevice(FileObject, KernelMode, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned);
 
    /* release object reference */
    ObDereferenceObject(FileObject);
 
    if (Status == STATUS_MORE_ENTRIES || Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
    {
        /* more data is available */
        return MM_STATUS_MORE_ENTRIES;
    }
    else if (Status == STATUS_SUCCESS)
    {
        /* operation succeeded */
        return MM_STATUS_SUCCESS;
    }
    else
    {
        DPRINT("Failed with %lx\n", Status);
        return MM_STATUS_UNSUCCESSFUL;
    }
}

Copy()

VOID Copy	(	PVOID	Src,
		PVOID	Dst,
		ULONG	NumBytes
	)

Definition at line 175 of file mmixer.c.

{
    RtlMoveMemory(Src, Dst, NumBytes);
}

CreatePinCallback()

MIXER_STATUS CreatePinCallback	(	IN PVOID	Ctx,
		IN ULONG	VirtualDeviceId,
		IN ULONG	PinId,
		IN HANDLE	hFilter,
		IN PKSPIN_CONNECT	PinConnect,
		IN ACCESS_MASK	DesiredAccess,
		OUT PHANDLE	PinHandle
	)

Definition at line 796 of file mmixer.c.

{
    ULONG BytesReturned;
    SYSAUDIO_INSTANCE_INFO InstanceInfo;
    NTSTATUS Status;
    ULONG FreeIndex;
    PPIN_CREATE_CONTEXT Context = (PPIN_CREATE_CONTEXT)Ctx;
 
    /* setup property request */
    InstanceInfo.Property.Set = KSPROPSETID_Sysaudio;
    InstanceInfo.Property.Id = KSPROPERTY_SYSAUDIO_INSTANCE_INFO;
    InstanceInfo.Property.Flags = KSPROPERTY_TYPE_SET;
    InstanceInfo.Flags = 0;
    InstanceInfo.DeviceNumber = VirtualDeviceId;
 
    /* attach to virtual device */
    Status = KsSynchronousIoControlDevice(Context->DeviceExtension->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&InstanceInfo, sizeof(SYSAUDIO_INSTANCE_INFO), NULL, 0, &BytesReturned);
 
    if (!NT_SUCCESS(Status))
        return MM_STATUS_UNSUCCESSFUL;
 
    /* close existing pin */
    FreeIndex = ClosePin(Context->ClientInfo, VirtualDeviceId, PinId, Context->DeviceType);
 
    /* now create the pin */
    Status = KsCreatePin(Context->DeviceExtension->hSysAudio, PinConnect, DesiredAccess, PinHandle);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
        return MM_STATUS_UNSUCCESSFUL;
 
    /* store the handle */
    Status = InsertPinHandle(Context->ClientInfo, VirtualDeviceId, PinId, Context->DeviceType, *PinHandle, FreeIndex);
    if (!NT_SUCCESS(Status))
    {
        /* failed to insert handle */
        ZwClose(*PinHandle);
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    return MM_STATUS_SUCCESS;
}

Referenced by WdmAudControlOpenMidi(), and WdmAudControlOpenWave().

Enum()

MIXER_STATUS Enum	(	IN PVOID	EnumContext,
		IN ULONG	DeviceIndex,
		OUT LPWSTR *	DeviceName,
		OUT PHANDLE	OutHandle,
		OUT PHANDLE	OutKey
	)

Definition at line 236 of file mmixer.c.

{
    PDEVICE_OBJECT DeviceObject;
    ULONG DeviceCount;
    NTSTATUS Status;
    UNICODE_STRING KeyName;
 
    /* get enumeration context */
    DeviceObject = (PDEVICE_OBJECT)EnumContext;
 
    /* get device count */
    DeviceCount = GetSysAudioDeviceCount(DeviceObject);
 
    if (DeviceIndex >= DeviceCount)
    {
        /* no more devices */
        return MM_STATUS_NO_MORE_DEVICES;
    }
 
    /* get device name */
    Status = GetSysAudioDevicePnpName(DeviceObject, DeviceIndex, DeviceName);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed to retrieve device name */
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    /* initialize key name */
    RtlInitUnicodeString(&KeyName, *DeviceName);
 
    /* open device interface key */
    Status = IoOpenDeviceInterfaceRegistryKey(&KeyName, GENERIC_READ | GENERIC_WRITE, OutKey);
 
    if (!NT_SUCCESS(Status))
    {
        *OutKey = NULL;
    }
 
#if 0
    if (!NT_SUCCESS(Status))
    {
        /* failed to open key */
        DPRINT("IoOpenDeviceInterfaceRegistryKey failed with %lx\n", Status);
        FreeItem(*DeviceName);
        return MM_STATUS_UNSUCCESSFUL;
    }
#endif
 
    /* open device handle */
    Status = OpenDevice(*DeviceName, OutHandle, NULL);
    if (!NT_SUCCESS(Status))
    {
        /* failed to open device */
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    return MM_STATUS_SUCCESS;
}

EventCallback()

VOID CALLBACK EventCallback	(	IN PVOID	MixerEventContext,
		IN HANDLE	hMixer,
		IN ULONG	NotificationType,
		IN ULONG	Value
	)

Definition at line 333 of file mmixer.c.

{
    PWDMAUD_CLIENT ClientInfo;
    PEVENT_ENTRY Entry;
    ULONG Index;
 
    /* get client context */
    ClientInfo = (PWDMAUD_CLIENT)MixerEventContext;
 
    /* now search for the mixer which originated the request */
    for(Index = 0; Index < ClientInfo->NumPins; Index++)
    {
        if (ClientInfo->hPins[Index].Handle == hMixer && ClientInfo->hPins[Index].Type == MIXER_DEVICE_TYPE)
        {
            if (ClientInfo->hPins[Index].NotifyEvent)
            {
                /* allocate event entry */
                Entry = AllocateItem(NonPagedPool, sizeof(EVENT_ENTRY));
                if (!Entry)
                {
                    /* no memory */
                    break;
                }
 
                /* setup event entry */
                Entry->NotificationType = NotificationType;
                Entry->Value = Value;
                Entry->hMixer = hMixer;
 
                /* insert entry */
                InsertTailList(&ClientInfo->MixerEventList, &Entry->Entry);
 
                /* now notify the client */
                KeSetEvent(ClientInfo->hPins[Index].NotifyEvent, 0, FALSE);
            }
            /* done */
            break;
        }
    }
}

Referenced by WdmAudCloseAllMixers(), WdmAudControlCloseMixer(), and WdmAudControlOpenMixer().

Free()

VOID Free

(

PVOID

Block

)

Definition at line 169 of file mmixer.c.

{
    FreeItem(Block);
}

FreeEventData()

VOID FreeEventData

(

IN PVOID

EventData

)

Definition at line 323 of file mmixer.c.

{
    PKSEVENTDATA Data = (PKSEVENTDATA)EventData;
 
    FreeItem(Data->EventHandle.Event);
    FreeItem(Data);
}

Open()

MIXER_STATUS Open	(	IN LPWSTR	DevicePath,
		OUT PHANDLE	hDevice
	)

Definition at line 181 of file mmixer.c.

{
    if (WdmAudOpenSysAudioDevice(DevicePath, hDevice) == STATUS_SUCCESS)
        return MM_STATUS_SUCCESS;
    else
        return MM_STATUS_UNSUCCESSFUL;
}

OpenKey()

MIXER_STATUS OpenKey	(	IN HANDLE	hKey,
		IN LPWSTR	SubKey,
		IN ULONG	DesiredAccess,
		OUT PHANDLE	OutKey
	)

Definition at line 118 of file mmixer.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING SubKeyName;
    NTSTATUS Status;
 
    /* initialize sub key name */
    RtlInitUnicodeString(&SubKeyName, lpSubKeyName);
 
    /* initialize key attributes */
    InitializeObjectAttributes(&ObjectAttributes, &SubKeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF, hKey, NULL);
 
    /* open the key */
    Status = ZwOpenKey(OutKey, DesiredAccess, &ObjectAttributes);
 
    if (NT_SUCCESS(Status))
        return MM_STATUS_SUCCESS;
    else
        return MM_STATUS_UNSUCCESSFUL;
}

QueryKeyValue()

MIXER_STATUS QueryKeyValue	(	IN HANDLE	hKey,
		IN LPWSTR	KeyName,
		OUT PVOID *	ResultBuffer,
		OUT PULONG	ResultLength,
		OUT PULONG	KeyType
	)

Definition at line 49 of file mmixer.c.

{
    NTSTATUS Status;
    UNICODE_STRING KeyName;
    ULONG Length;
    PKEY_VALUE_PARTIAL_INFORMATION PartialInformation;
 
    /* initialize key name */
    RtlInitUnicodeString(&KeyName, lpKeyName);
 
    /* now query MatchingDeviceId key */
    Status = ZwQueryValueKey(hKey, &KeyName, KeyValuePartialInformation, NULL, 0, &Length);
 
    /* check for success */
    if (Status != STATUS_BUFFER_TOO_SMALL)
        return MM_STATUS_UNSUCCESSFUL;
 
    /* allocate a buffer for key data */
    PartialInformation = AllocateItem(NonPagedPool, Length);
 
    if (!PartialInformation)
        return MM_STATUS_NO_MEMORY;
 
 
    /* now query MatchingDeviceId key */
    Status = ZwQueryValueKey(hKey, &KeyName, KeyValuePartialInformation, PartialInformation, Length, &Length);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        FreeItem(PartialInformation);
        return MM_STATUS_UNSUCCESSFUL;
    }
 
    if (KeyType)
    {
        /* return key type */
        *KeyType = PartialInformation->Type;
    }
 
    if (ResultLength)
    {
        /* return data length */
        *ResultLength = PartialInformation->DataLength;
    }
 
    *ResultBuffer = AllocateItem(NonPagedPool, PartialInformation->DataLength);
    if (!*ResultBuffer)
    {
        /* not enough memory */
        FreeItem(PartialInformation);
        return MM_STATUS_NO_MEMORY;
    }
 
    /* copy key value */
    RtlMoveMemory(*ResultBuffer, PartialInformation->Data, PartialInformation->DataLength);
 
    /* free key info */
    FreeItem(PartialInformation);
 
    return MM_STATUS_SUCCESS;
}

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().

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

(

)

Definition at line 681 of file mmixer.c.

{
    return MMixerGetMidiInCount(&MixerContext);
}

Referenced by WdmAudControlDeviceType().

WdmAudGetMidiOutDeviceCount()

ULONG WdmAudGetMidiOutDeviceCount

(

)

Definition at line 687 of file mmixer.c.

{
    return MMixerGetWaveOutCount(&MixerContext);
}

Referenced by WdmAudControlDeviceType().

WdmAudGetMixerDeviceCount()

ULONG WdmAudGetMixerDeviceCount

(

)

Definition at line 663 of file mmixer.c.

{
    return MMixerGetCount(&MixerContext);
}

Referenced by WdmAudControlDeviceType(), and WdmAudInitWorkerRoutine().

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 *	DevicePath
	)

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

(

)

Definition at line 669 of file mmixer.c.

{
    return MMixerGetWaveInCount(&MixerContext);
}

Referenced by WdmAudControlDeviceType(), and WdmAudInitWorkerRoutine().

WdmAudGetWaveOutDeviceCount()

ULONG WdmAudGetWaveOutDeviceCount

(

)

Definition at line 675 of file mmixer.c.

{
    return MMixerGetWaveOutCount(&MixerContext);
}

Referenced by WdmAudControlDeviceType(), and WdmAudInitWorkerRoutine().

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().

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().

Variable Documentation

CategoryGuid

GUID CategoryGuid = {STATIC_KSCATEGORY_AUDIO}

Definition at line 46 of file mmixer.c.

MixerContext

MIXER_CONTEXT MixerContext

Initial value:

=
{
    sizeof(MIXER_CONTEXT),
    NULL,
    Alloc,
    Control,
    Free,
    Open,
    Close,
    Copy,
    OpenKey,
    QueryKeyValue,
    CloseKey,
    AllocEventData,
    FreeEventData
}

Definition at line 29 of file mmixer.c.