windows-xp/Source/XPSP1/NT/drivers/storage/redbook/sysaudio.c

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       sysaudio.c
//
//--------------------------------------------------------------------------


#include "redbook.h"
#include "proto.h"
#include <wdmguid.h>
#include <ksmedia.h>

#include "sysaudio.tmh"

//////////////////////////////////////////////////////////////////////


#ifdef ALLOC_PRAGMA
    #pragma alloc_text(PAGE, AttachVirtualSource)
    #pragma alloc_text(PAGE, CloseSysAudio)
    #pragma alloc_text(PAGE, GetPinProperty)
    #pragma alloc_text(PAGE, GetVolumeNodeId)
    #pragma alloc_text(PAGE, InitializeVirtualSource)
    #pragma alloc_text(PAGE, OpenInterfaceByGuid)
    #pragma alloc_text(PAGE, OpenSysAudio)
    #pragma alloc_text(PAGE, RedBookKsSetVolume)
    #pragma alloc_text(PAGE, SetNextDeviceState)
    #pragma alloc_text(PAGE, SysAudioPnpNotification)
    #pragma alloc_text(PAGE, UninitializeVirtualSource)
#endif // ALLOC_PRAGMA


//////////////////////////////////////////////////////////////////////

NTSTATUS
OpenSysAudio(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

    This routine is a wrapper around all the work that must be done
    just to open sysaudio for playback.  the code was swiped from
    Win98, and then translated into CSN (Cutler Standard Notation)

Arguments:

    DeviceExtensionPinConnect - if successful, this will be the pin to send data to

    PinFileObject - if successful, the file object this pin is associated
        with is returned in this structure

    PinDeviceObject - if successful, the device object this pin is
        associated with is returned in this structure

    VolumeNodeId - ?? No idea what this is... yet.

Return Value:

    status

--*/


{
    PFILE_OBJECT guidFileObject;
    PFILE_OBJECT pinFileObject;
    HANDLE deviceHandle;
    NTSTATUS status;
    HANDLE pinHandle;
    ULONG volumeNodeId;
    ULONG mixerPinId;

    ULONG pins, pinId;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    guidFileObject = NULL;
    pinFileObject = NULL;
    deviceHandle = NULL;
    status = STATUS_SUCCESS;
    pinHandle = NULL;
    volumeNodeId = -1;
    mixerPinId = DeviceExtension->Stream.MixerPinId;


    TRY {
        ASSERT( mixerPinId != MAXULONG );

        //
        // Note dependency on IoRegisterPlugPlayNotification() in pnp.c
        //

        status = OpenInterfaceByGuid(
                                     //&KSCATEGORY_SYSAUDIO,
                                     &KSCATEGORY_PREFERRED_WAVEOUT_DEVICE,
                                     &deviceHandle,
                                     &guidFileObject);

        if (!NT_SUCCESS(status)) {
            LEAVE;
        }

        //
        // Get the number of pins
        //
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                   "SysAudio => Getting Pin Property PIN_CTYPES\n"));

        status = GetPinProperty(guidFileObject,
                                KSPROPERTY_PIN_CTYPES,
                                0, // doesn't matter for ctypes
                                sizeof(pins),
                                &pins);

        if (!NT_SUCCESS(status)) {

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                       "SysAudio !! Unable to get number of pins %lx\n",
                       status));
            RedBookLogError(DeviceExtension,
                            REDBOOK_ERR_CANNOT_GET_NUMBER_OF_PINS,
                            status);
            LEAVE;
        }

        //
        // Try to get a matching pin -- brute force method
        //

        for( pinId = 0; pinId < pins; pinId++) {

            KSPIN_COMMUNICATION communication;
            KSPIN_DATAFLOW dataFlow;

            //
            // check communication of the pin. accept either
            // a sink or a pin that is both a source and sink
            //

            status = GetPinProperty(guidFileObject,
                                    KSPROPERTY_PIN_COMMUNICATION,
                                    pinId,
                                    sizeof(communication),
                                    &communication);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                           "SysAudio !! Pin %d communication query "
                           "failed %lx\n", pinId, status ));
                continue;
            }

            if ( communication != KSPIN_COMMUNICATION_SINK &&
                 communication != KSPIN_COMMUNICATION_BOTH ) continue;

            //
            // only use this pin if it accepts incoming data
            //

            status = GetPinProperty(guidFileObject,
                                    KSPROPERTY_PIN_DATAFLOW,
                                    pinId,
                                    sizeof(dataFlow),
                                    &dataFlow);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                           "SysAudio !! Pin %d dataflow query failed %lx\n",
                           pinId, status));
                continue;
            }

            if (dataFlow != KSPIN_DATAFLOW_IN) continue;

            //
            // we have found a matching pin, so attempt to connect
            //

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SysAudio => Attempt to connect to pin %d\n", pinId));

            DeviceExtension->Stream.Connect.PinId       = pinId;
            DeviceExtension->Stream.Connect.PinToHandle = NULL;

            status = KsCreatePin(deviceHandle,
                                 &DeviceExtension->Stream.Connect,
                                 GENERIC_WRITE, // FILE_WRITE_ACCESS
                                 &pinHandle);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                           "SysAudio => Cannot create a writable pin %d\n",
                           pinId));
                continue;
            }

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SysAudio => Connected to pin %d\n", pinId ));

            //
            // get the object associated with the pinHandle just created
            // so we can then get other information about the pin
            //

            status = ObReferenceObjectByHandle(pinHandle,
                                               GENERIC_READ | GENERIC_WRITE,
                                               NULL,
                                               KernelMode,
                                               &pinFileObject,
                                               NULL);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                             "SysAudio !! Object from handle for pin "
                             "failed %lx\n", status));
                LEAVE;
            }

            //
            // this allows us to change our output volume
            // this just sends a ks ioctl, no referencing done here
            //

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SysAudio => Getting VolumeNodeId\n"));

            status = GetVolumeNodeId(pinFileObject,
                                     &volumeNodeId);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                           "SysAudio !! Unable to get volume node "
                           "id %lx\n", status));
                LEAVE;
            }

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SysAudio => Attaching PinFileObject %p "
                       "to MixerPinId %d\n", pinFileObject,
                       mixerPinId));

            //
            // this just sends a ks ioctl, no referencing done here
            //

            status = AttachVirtualSource(pinFileObject, mixerPinId);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                           "SysAudio !! Unable to attach virtual "
                           "source %lx\n", status));
                LEAVE;
            }

            //
            // successful completion
            //

            status = STATUS_SUCCESS;

            LEAVE;
        }

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "Sysaudio !! Unable to connect to any pins\n"));
        RedBookLogError(DeviceExtension,
                        REDBOOK_ERR_CANNOT_CONNECT_TO_PLAYBACK_PINS,
                        status);

        //
        // no pin succeeded, so set status to failure
        //
        status = STATUS_INVALID_DEVICE_REQUEST;
        LEAVE;


    } FINALLY {

        //
        // the pin handle is not required, as we've referenced
        // the pin in pinFileObject.  close it here.
        //

        if (pinHandle != NULL) {
            ZwClose(pinHandle);
            pinHandle = NULL;
        }

        //
        // the device handle is only required to create
        // the actual pin.  close it here.
        //

        if (deviceHandle != NULL) {
            ZwClose(deviceHandle);
            deviceHandle = NULL;
        }

        //
        // the guidFileObject is also only required to query
        // and create the pins.  close it here.
        //
        // (pinFileObject is still important)
        //

        if (guidFileObject != NULL) {
            ObDereferenceObject(guidFileObject);
            guidFileObject = NULL;
        }

        if (!NT_SUCCESS(status)) {

            if (pinFileObject != NULL) {
                ObDereferenceObject(pinFileObject);
                pinFileObject = NULL;
            }

        }

    }

    //
    // the MixerPinId should not have changed in this function
    //

    ASSERT(mixerPinId == DeviceExtension->Stream.MixerPinId);

    if (NT_SUCCESS(status)) {

        DeviceExtension->Stream.PinFileObject   = pinFileObject;
        DeviceExtension->Stream.PinDeviceObject =
            IoGetRelatedDeviceObject(pinFileObject);
        DeviceExtension->Stream.VolumeNodeId = volumeNodeId;

    } else {

        DeviceExtension->Stream.PinFileObject   = NULL;
        DeviceExtension->Stream.PinDeviceObject = NULL;
        DeviceExtension->Stream.VolumeNodeId = -1;

    }

    return status;

}

NTSTATUS
    CloseSysAudio(
        PREDBOOK_DEVICE_EXTENSION DeviceExtension
        )
{
    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    ASSERT(DeviceExtension->Stream.PinFileObject);
    ASSERT(DeviceExtension->Stream.PinDeviceObject);

    ObDereferenceObject(DeviceExtension->Stream.PinFileObject);
    DeviceExtension->Stream.PinDeviceObject = NULL;
    DeviceExtension->Stream.PinFileObject = NULL;

    return STATUS_SUCCESS;
}

NTSTATUS
GetPinProperty(
    IN  PFILE_OBJECT FileObject,
    IN  ULONG        PropertyId,
    IN  ULONG        PinId,
    IN  ULONG        PropertySize,
    OUT PVOID        Property
    )
/*++

Routine Description:

    another wrapper to hide getting pin properties

Arguments:

    FileObject - file object to query

    PropertyId - what property to query

    PinId - which pin to query

    PropertySize - size of output buffer

    Property - output buffer for property

Return Value:

    status

--*/
{
    ULONG    bytesReturned;
    KSP_PIN  prop;
    NTSTATUS status;

    PAGED_CODE();

    prop.Property.Set       = KSPROPSETID_Pin;
    prop.Property.Id        = PropertyId;
    prop.Property.Flags     = KSPROPERTY_TYPE_GET;
    prop.PinId              = PinId;
    prop.Reserved           = 0;

    status = KsSynchronousIoControlDevice( FileObject,
                                           KernelMode,
                                           IOCTL_KS_PROPERTY,
                                           &prop,
                                           sizeof(prop),
                                           Property,
                                           PropertySize,
                                           &bytesReturned
                                           );

    if ( !NT_SUCCESS(status) ) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "GetPinProperty !! fileobj %p  property %p  "
                   "pin %d  status %lx\n",
                   FileObject, Property, PinId, status));
        return status;
    }

    ASSERT( bytesReturned == PropertySize );
    return status;
}

NTSTATUS
GetVolumeNodeId(
    IN  PFILE_OBJECT FileObject,
    OUT PULONG       VolumeNodeId
    )
/*++

Routine Description:

    Gets the pin to set the volume for playback

Arguments:

    FileObject - The fileobject which contains the pin

    VolumeNodeId - id of the volume node

Return Value:

    status

--*/
{
    KSPROPERTY property;
    ULONG      bytesReturned;
    NTSTATUS   status;

    PAGED_CODE();

    property.Set   = KSPROPSETID_Sysaudio_Pin;
    property.Id    = KSPROPERTY_SYSAUDIO_PIN_VOLUME_NODE;
    property.Flags = KSPROPERTY_TYPE_GET;

    status = KsSynchronousIoControlDevice( FileObject,
                                           KernelMode,
                                           IOCTL_KS_PROPERTY,
                                           &property,
                                           sizeof(property),
                                           VolumeNodeId,
                                           sizeof(ULONG),
                                           &bytesReturned
                                           );

    if ( !NT_SUCCESS(status) ) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "GetVolumeNodeId !! fileobj %p status %lx\n",
                   FileObject, status));
        return status;
    }

    ASSERT(bytesReturned == sizeof(ULONG));
    return(status);
}


NTSTATUS
UninitializeVirtualSource(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
{
    ULONG state;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    ASSERT(DeviceExtension->Stream.MixerPinId != -1);
    ASSERT(DeviceExtension->Stream.MixerFileObject != NULL);

    state = GetCdromState(DeviceExtension);
    ASSERT(state == CD_STOPPED);

    DeviceExtension->Stream.MixerPinId = -1;
    ObDereferenceObject(DeviceExtension->Stream.MixerFileObject);
    DeviceExtension->Stream.MixerFileObject = NULL;

    return STATUS_SUCCESS;
}


NTSTATUS
InitializeVirtualSource(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

Arguments:

    MixerPinId - initialized to the correct pin id of mixer

Return Value:

    status

--*/
{
    SYSAUDIO_CREATE_VIRTUAL_SOURCE createVirtualSource;
    PFILE_OBJECT                   fileObject;
    NTSTATUS                       status;
    HANDLE                         deviceHandle;
    ULONG                          bytesReturned;
    ULONG                          mixerPinId;
    ULONG                          state;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    ASSERT(DeviceExtension->Stream.MixerPinId == -1);
    ASSERT(DeviceExtension->Stream.MixerFileObject == NULL);

    state = GetCdromState(DeviceExtension);
    ASSERT(state == CD_STOPPED);

    fileObject = NULL;
    status = STATUS_SUCCESS;
    deviceHandle = NULL;
    mixerPinId = -1;

    //
    // use IoGetDeviceInterfaces()
    //
    status = OpenInterfaceByGuid(&KSCATEGORY_SYSAUDIO,
                                 &deviceHandle,
                                 &fileObject);

    if ( !NT_SUCCESS(status) ) {
        RedBookLogError(DeviceExtension,
                        REDBOOK_ERR_CANNOT_OPEN_SYSAUDIO_MIXER,
                        status);
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "CreateVirtSource !! Unable to open sysaudio\\mixer %lx\n",
                   status));
        goto exit;
    }

    createVirtualSource.Property.Set   = KSPROPSETID_Sysaudio;
    createVirtualSource.Property.Id    = KSPROPERTY_SYSAUDIO_CREATE_VIRTUAL_SOURCE;
    createVirtualSource.Property.Flags = KSPROPERTY_TYPE_GET;
    createVirtualSource.PinCategory    = KSNODETYPE_CD_PLAYER;
    createVirtualSource.PinName        = KSNODETYPE_CD_PLAYER;

    status = KsSynchronousIoControlDevice(fileObject,
                                          KernelMode,
                                          IOCTL_KS_PROPERTY,
                                          &createVirtualSource,
                                          sizeof(createVirtualSource),
                                          &mixerPinId,
                                          sizeof(ULONG), // MixerPinId
                                          &bytesReturned
                                          );

    if ( !NT_SUCCESS(status) ) {
        RedBookLogError(DeviceExtension,
                        REDBOOK_ERR_CANNOT_CREATE_VIRTUAL_SOURCE,
                        status);
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugError, "[redbook] "
                   "CreateVirtSource !! creating virtual source "
                   "failed %lx\n", status));
        goto exit;
    }

    ASSERT( bytesReturned == sizeof(ULONG) );

exit:

    if (NT_SUCCESS(status)) {

        DeviceExtension->Stream.MixerPinId = mixerPinId;
        DeviceExtension->Stream.MixerFileObject = fileObject;

    } else if (fileObject != NULL) {

        //
        // failed to open, so deref object if non-null
        //

        ObDereferenceObject(fileObject);
        fileObject = NULL;

    }

    if (deviceHandle != NULL) {
        ZwClose(deviceHandle);
        deviceHandle = NULL;
    }


    return status;
}

NTSTATUS
AttachVirtualSource(
    IN  PFILE_OBJECT PinFileObject,
    IN  ULONG        MixerPinId
    )
/*++

Routine Description:


Arguments:

    FileObject - ??

    MixerPinId - ??

Return Value:

    status

--*/
{
    SYSAUDIO_ATTACH_VIRTUAL_SOURCE attachVirtualSource;
    NTSTATUS status;
    ULONG bytesReturned;

    PAGED_CODE();

    //
    // if the source hasn't been initialized, reject this
    // request as invalid
    //

    if(MixerPinId == MAXULONG) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugError, "[redbook] "
                   "AttatchVirtSource !! Mixer Pin uninitialized\n"));
        ASSERT(!"Mixer Pin Uninitialized");
        return STATUS_INVALID_DEVICE_REQUEST;
    }

    attachVirtualSource.Property.Set   = KSPROPSETID_Sysaudio_Pin;
    attachVirtualSource.Property.Id    = KSPROPERTY_SYSAUDIO_ATTACH_VIRTUAL_SOURCE;
    attachVirtualSource.Property.Flags = KSPROPERTY_TYPE_SET;
    attachVirtualSource.MixerPinId     = MixerPinId;

    status = KsSynchronousIoControlDevice(PinFileObject,
                                          KernelMode,
                                          IOCTL_KS_PROPERTY,
                                          &attachVirtualSource,
                                          sizeof(attachVirtualSource),
                                          NULL,
                                          0,
                                          &bytesReturned
                                          );

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "AttachVirtSource !! Couldn't attatch %lx\n", status));
        return status;
    }
    return status;
}

VOID
SetNextDeviceState(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension,
    KSSTATE State
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    KSIDENTIFIER stateProperty;
    NTSTATUS     status;
    ULONG        bytesReturned;
    KSSTATE      acquireState;
    PFILE_OBJECT fileObject;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    fileObject = DeviceExtension->Stream.PinFileObject;

    acquireState = KSSTATE_ACQUIRE;

    stateProperty.Set   = KSPROPSETID_Connection;
    stateProperty.Id    = KSPROPERTY_CONNECTION_STATE;
    stateProperty.Flags = KSPROPERTY_TYPE_SET;

    ASSERT(fileObject);
    status = KsSynchronousIoControlDevice(fileObject,
                                          KernelMode,
                                          IOCTL_KS_PROPERTY,
                                          &stateProperty,
                                          sizeof(stateProperty),
                                          &acquireState,
                                          sizeof(acquireState),
                                          &bytesReturned
                                          );

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugError, "[redbook] "
                   "SetDeviceState => (1) Audio device error %x.  need to "
                   "stop playback AND change audio devices\n", status));
    }

    //
    // now that it's acquired, set the new state
    //

    stateProperty.Set   = KSPROPSETID_Connection;
    stateProperty.Id    = KSPROPERTY_CONNECTION_STATE;
    stateProperty.Flags = KSPROPERTY_TYPE_SET;

    status = KsSynchronousIoControlDevice(fileObject,
                                          KernelMode,
                                          IOCTL_KS_PROPERTY,
                                          &stateProperty,
                                          sizeof(stateProperty),
                                          &State,
                                          sizeof(State),
                                          &bytesReturned
                                          );
    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugError, "[redbook] "
                   "SetDeviceState => (2) Audio device error %x.  need to "
                   "stop playback AND change audio devices\n", status));
    }
    return;
}

//////////////////////////////////////////////////////////////////////
//                                                                  //
// this table is in 1/65536 decibles for a UCHAR setting:           //
//    20 * log10( Level / 256 ) * 65536                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////

AttenuationTable[] = {
    0x7fffffff, 0xffcfd5d0, 0xffd5db16, 0xffd960ad, //  0- 3
    0xffdbe05c, 0xffddd08a, 0xffdf65f3, 0xffe0bcb7, //  4- 7
    0xffe1e5a2, 0xffe2eb89, 0xffe3d5d0, 0xffe4a9be, //  8- b
    0xffe56b39, 0xffe61d34, 0xffe6c1fd, 0xffe75b67, //  c- f
    0xffe7eae8, 0xffe871b6, 0xffe8f0cf, 0xffe96908, // 10-13
    0xffe9db16, 0xffea4793, 0xffeaaf04, 0xffeb11dc, // 14-17
    0xffeb707f, 0xffebcb44, 0xffec227a, 0xffec7665, // 18-1b
    0xffecc743, 0xffed154b, 0xffed60ad, 0xffeda996, // 1c-1f
    0xffedf02e, 0xffee349b, 0xffee76fc, 0xffeeb771, // 20-23
    0xffeef615, 0xffef3302, 0xffef6e4e, 0xffefa810, // 24-27
    0xffefe05c, 0xfff01744, 0xfff04cda, 0xfff0812c, // 28-2b
    0xfff0b44b, 0xfff0e643, 0xfff11722, 0xfff146f4, // 2c-2f
    0xfff175c5, 0xfff1a39e, 0xfff1d08a, 0xfff1fc93, // 30-33
    0xfff227c0, 0xfff2521b, 0xfff27bab, 0xfff2a478, // 34-37
    0xfff2cc89, 0xfff2f3e5, 0xfff31a91, 0xfff34093, // 38-3b
    0xfff365f3, 0xfff38ab4, 0xfff3aedc, 0xfff3d270, // 3c-3f
    0xfff3f574, 0xfff417ee, 0xfff439e1, 0xfff45b51, // 40-43
    0xfff47c42, 0xfff49cb8, 0xfff4bcb7, 0xfff4dc42, // 44-47
    0xfff4fb5b, 0xfff51a07, 0xfff53848, 0xfff55621, // 48-4b
    0xfff57394, 0xfff590a5, 0xfff5ad56, 0xfff5c9aa, // 4c-4f
    0xfff5e5a2, 0xfff60142, 0xfff61c8a, 0xfff6377e, // 50-53
    0xfff65220, 0xfff66c70, 0xfff68672, 0xfff6a027, // 54-57
    0xfff6b991, 0xfff6d2b1, 0xfff6eb89, 0xfff7041b, // 58-5b
    0xfff71c68, 0xfff73472, 0xfff74c3a, 0xfff763c2, // 5c-5f
    0xfff77b0b, 0xfff79216, 0xfff7a8e4, 0xfff7bf77, // 60-63
    0xfff7d5d0, 0xfff7ebf0, 0xfff801d9, 0xfff8178a, // 64-67
    0xfff82d06, 0xfff8424d, 0xfff85761, 0xfff86c42, // 68-6b
    0xfff880f1, 0xfff89570, 0xfff8a9be, 0xfff8bdde, // 6c-6f
    0xfff8d1cf, 0xfff8e593, 0xfff8f92b, 0xfff90c96, // 70-73
    0xfff91fd7, 0xfff932ed, 0xfff945d9, 0xfff9589d, // 74-77
    0xfff96b39, 0xfff97dad, 0xfff98ffa, 0xfff9a221, // 78-7b
    0xfff9b422, 0xfff9c5fe, 0xfff9d7b6, 0xfff9e94a, // 7c-7f
    0xfff9faba, 0xfffa0c08, 0xfffa1d34, 0xfffa2e3e, // 80-83
    0xfffa3f27, 0xfffa4fef, 0xfffa6097, 0xfffa711f, // 84-87
    0xfffa8188, 0xfffa91d3, 0xfffaa1ff, 0xfffab20d, // 88-8b
    0xfffac1fd, 0xfffad1d1, 0xfffae188, 0xfffaf122, // 8c-8f
    0xfffb00a1, 0xfffb1004, 0xfffb1f4d, 0xfffb2e7a, // 90-93
    0xfffb3d8e, 0xfffb4c87, 0xfffb5b67, 0xfffb6a2d, // 94-97
    0xfffb78da, 0xfffb876f, 0xfffb95eb, 0xfffba450, // 98-9b
    0xfffbb29c, 0xfffbc0d2, 0xfffbcef0, 0xfffbdcf7, // 9c-9f
    0xfffbeae8, 0xfffbf8c3, 0xfffc0688, 0xfffc1437, // a0-a3
    0xfffc21d0, 0xfffc2f55, 0xfffc3cc4, 0xfffc4a1f, // a4-a7
    0xfffc5766, 0xfffc6498, 0xfffc71b6, 0xfffc7ec1, // a8-ab
    0xfffc8bb8, 0xfffc989c, 0xfffca56d, 0xfffcb22b, // ac-af
    0xfffcbed7, 0xfffccb70, 0xfffcd7f7, 0xfffce46c, // b0-b3
    0xfffcf0cf, 0xfffcfd21, 0xfffd0961, 0xfffd1590, // b4-b7
    0xfffd21ae, 0xfffd2dbc, 0xfffd39b8, 0xfffd45a4, // b8-bb
    0xfffd5180, 0xfffd5d4c, 0xfffd6908, 0xfffd74b4, // bc-bf
    0xfffd8051, 0xfffd8bde, 0xfffd975c, 0xfffda2ca, // c0-c3
    0xfffdae2a, 0xfffdb97b, 0xfffdc4bd, 0xfffdcff1, // c4-c7
    0xfffddb16, 0xfffde62d, 0xfffdf136, 0xfffdfc31, // c8-cb
    0xfffe071f, 0xfffe11fe, 0xfffe1cd0, 0xfffe2795, // cc-cf
    0xfffe324c, 0xfffe3cf6, 0xfffe4793, 0xfffe5224, // d0-d3
    0xfffe5ca7, 0xfffe671e, 0xfffe7188, 0xfffe7be6, // d4-d7
    0xfffe8637, 0xfffe907d, 0xfffe9ab6, 0xfffea4e3, // d8-db
    0xfffeaf04, 0xfffeb91a, 0xfffec324, 0xfffecd22, // dc-df
    0xfffed715, 0xfffee0fd, 0xfffeead9, 0xfffef4aa, // e0-e3
    0xfffefe71, 0xffff082c, 0xffff11dc, 0xffff1b82, // e4-e7
    0xffff251d, 0xffff2ead, 0xffff3833, 0xffff41ae, // e8-eb
    0xffff4b1f, 0xffff5486, 0xffff5de3, 0xffff6736, // ec-ef
    0xffff707f, 0xffff79be, 0xffff82f3, 0xffff8c1e, // f0-f3
    0xffff9540, 0xffff9e58, 0xffffa767, 0xffffb06c, // f4-f7
    0xffffb968, 0xffffc25b, 0xffffcb44, 0xffffd425, // f8-fb
    0xffffdcfc, 0xffffe5ca, 0xffffee90, 0x00000000, // fc-ff
};

#define DA_CHANNEL_LEFT  0
#define DA_CHANNEL_RIGHT 1
#define DA_CHANNEL_MAX   2

VOID
RedBookKsSetVolume(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{

    KSNODEPROPERTY_AUDIO_CHANNEL volumeProperty;
    VOLUME_CONTROL volume;
    NTSTATUS status;
    ULONG32 channel;
    ULONG32 bytesReturned = 0;
    BOOLEAN mute;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    volume = DeviceExtension->CDRom.Volume;

    //
    // These settings are common for all the sets
    //

    volumeProperty.NodeProperty.Property.Set   = KSPROPSETID_Audio;
    volumeProperty.NodeProperty.Property.Flags = KSPROPERTY_TYPE_SET |
                                                 KSPROPERTY_TYPE_TOPOLOGY;
    volumeProperty.NodeProperty.NodeId = DeviceExtension->Stream.VolumeNodeId;

    //
    // Do both Left and right channels
    //

    for ( channel = 0; channel < DA_CHANNEL_MAX; channel++ ) {

        //
        // handle the correct channel
        //

        volumeProperty.Channel = channel;

        //
        // if not muting the channel, set the volume
        //

        if ( volume.PortVolume[channel] != 0 ) {
            ULONG32 level;
            ULONG32 index;

            volumeProperty.NodeProperty.Property.Id = KSPROPERTY_AUDIO_VOLUMELEVEL;

            level = AttenuationTable[ volume.PortVolume[channel] ];

            ASSERT(DeviceExtension->Stream.PinFileObject);

            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SetVolume => Setting channel %d to %lx\n",
                       channel, level ));
            status = KsSynchronousIoControlDevice(DeviceExtension->Stream.PinFileObject,
                                                  KernelMode,
                                                  IOCTL_KS_PROPERTY,
                                                  &volumeProperty,
                                                  sizeof(volumeProperty),
                                                  &level,
                                                  sizeof(level),
                                                  &bytesReturned
                                                  );
            // ASSERT( NT_SUCCESS(status) );
            mute = FALSE;
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SetVolume => Un-Muting channel %d\n", channel));
        } else {
            mute = TRUE;
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "SetVolume => Muting channel %d\n", channel));
        }
        volumeProperty.NodeProperty.Property.Id    = KSPROPERTY_AUDIO_MUTE;

        status = KsSynchronousIoControlDevice(DeviceExtension->Stream.PinFileObject,
                                              KernelMode,
                                              IOCTL_KS_PROPERTY,
                                              &volumeProperty,
                                              sizeof(volumeProperty),
                                              &mute,
                                              sizeof(mute),
                                              &bytesReturned
                                              );
        // ASSERT( NT_SUCCESS(status) );

    }

    //
    // End of all channels
    //

    return;

}


NTSTATUS
OpenInterfaceByGuid(
    IN  CONST GUID   * InterfaceClassGuid,
    OUT HANDLE       * Handle,
    OUT PFILE_OBJECT * FileObject
    )
{
    PWSTR tempString;
    PWSTR symbolicLinkList;
    HANDLE localHandle;
    PFILE_OBJECT localFileObject;
    NTSTATUS status;

    PAGED_CODE();

    localHandle = NULL;
    tempString = NULL;
    symbolicLinkList = NULL;
    *Handle = NULL;
    *FileObject = NULL;

    status = IoGetDeviceInterfaces(InterfaceClassGuid,
                                   // currently, the GUID is one of
                                   //  KSCATEGORY_PREFERRED_WAVEOUT_DEVICE
                                   //  or KSCATEGORY_SYSAUDIO
                                   NULL, // no preferred device object
                                   0,
                                   &symbolicLinkList);
    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "OpenDevice !! IoGetDeviceInterfaces failed %x\n",
                   status));
        return status;
    }

#if DBG
    tempString = symbolicLinkList;
    while (*tempString != UNICODE_NULL) {

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                   "OpenDevice => Possible Device: %ws\n", tempString));

        //
        // get the next symbolic link
        //

        while(*tempString++ != UNICODE_NULL) {
            NOTHING;
        }
    }
#endif

    //
    // this code is proudly propogated from wdmaud.sys
    //

    tempString = symbolicLinkList;
    while (*tempString != UNICODE_NULL) {

        IO_STATUS_BLOCK   ioStatusBlock;
        UNICODE_STRING    deviceString;
        OBJECT_ATTRIBUTES objectAttributes;

        RtlInitUnicodeString( &deviceString, tempString);

        InitializeObjectAttributes(&objectAttributes,
                                   &deviceString,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL
                                   );

        //
        // could use IoCreateFile(), based on
        // ntos\dd\wdm\audio\legacy\wdmaud.sys\sysaudio.c:OpenDevice()
        //

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                   "OpenDevice => Opening %ws\n", tempString));
        status = ZwCreateFile(&localHandle,
                              GENERIC_READ | GENERIC_WRITE,
                              &objectAttributes,
                              &ioStatusBlock,
                              NULL,       // ignored on non-create
                              FILE_ATTRIBUTE_NORMAL,
                              0,          // no share access
                              FILE_OPEN,  // open the existing file
                              0, NULL, 0  // options
                              );

        if (NT_SUCCESS(status)) {

            ASSERT(localHandle != NULL);
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "OpenDevice => Opened %ws\n", tempString));
            break; // out of the while loop

        }

        ASSERT(localHandle == NULL);

        //
        // get the next symbolic link
        //

        while(*tempString++ != UNICODE_NULL) {
            NOTHING;
        }

    }

    if (symbolicLinkList != NULL) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                   "OpenDevice => Freeing list from IoGetDevInt...\n"));
        ExFreePool(symbolicLinkList);
        symbolicLinkList = NULL;
        tempString = NULL;
    }


    //
    // if succeeded to open the file, try to get
    // the FileObject that is related to this handle.
    //

    if (localHandle != NULL) {

        status = ObReferenceObjectByHandle(localHandle,
                                           GENERIC_READ | GENERIC_WRITE,
                                           NULL,
                                           KernelMode,
                                           &localFileObject, // double pointer
                                           NULL);

        if (NT_SUCCESS(status)) {
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugSysaudio, "[redbook] "
                       "OpenDevice => Succeeded\n"));

            *Handle = localHandle;
            *FileObject = localFileObject;

            return status; // Exit point for success
        }

        ZwClose(localHandle);
        localHandle = NULL;

    }

    KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
               "OpenDevice => unable to open any audio devices\n"));
    status = STATUS_NO_SUCH_DEVICE;
    return status;


}


NTSTATUS
SysAudioPnpNotification(
    PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification,
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
{
    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    InterlockedExchange(&DeviceExtension->Stream.UpdateMixerPin, 1);

    return STATUS_SUCCESS;
}