mment4.h File Reference

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

Go to the source code of this file.

Typedefs
typedef BOOLEAN(*	SOUND_DEVICE_DETECTED_PROC) (UCHAR DeviceType, PWSTR DevicePath)

Functions
MMRESULT	EnumerateNt4ServiceSoundDevices (IN LPWSTR ServiceName, IN MMDEVICE_TYPE DeviceType, IN SOUND_DEVICE_DETECTED_PROC SoundDeviceDetectedProc)
MMRESULT	DetectNt4SoundDevices (IN MMDEVICE_TYPE DeviceType, IN PWSTR BaseDeviceName, IN SOUND_DEVICE_DETECTED_PROC SoundDeviceDetectedProc)
MMRESULT	OpenSoundDriverParametersRegKey (IN LPWSTR ServiceName, OUT PHKEY KeyHandle)
MMRESULT	OpenSoundDeviceRegKey (IN LPWSTR ServiceName, IN DWORD DeviceIndex, OUT PHKEY KeyHandle)
MMRESULT	GetNt4SoundDeviceCapabilities (IN PSOUND_DEVICE SoundDevice, OUT PVOID Capabilities, IN DWORD CapabilitiesSize)
MMRESULT	QueryNt4WaveDeviceFormatSupport (IN PSOUND_DEVICE SoundDevice, IN LPWAVEFORMATEX Format, IN DWORD FormatSize)
MMRESULT	SetNt4WaveDeviceFormat (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN DWORD DeviceId, IN LPWAVEFORMATEX Format, IN DWORD FormatSize)
MMRESULT	OpenNt4SoundDevice (IN PSOUND_DEVICE SoundDevice, OUT PVOID *Handle)
MMRESULT	CloseNt4SoundDevice (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID Handle)

Typedef Documentation

SOUND_DEVICE_DETECTED_PROC

typedef BOOLEAN(* SOUND_DEVICE_DETECTED_PROC) (UCHAR DeviceType, PWSTR DevicePath)

Definition at line 24 of file mment4.h.

Function Documentation

CloseNt4SoundDevice()

MMRESULT CloseNt4SoundDevice	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PVOID	Handle
	)

Definition at line 65 of file control.c.

{
    SND_TRACE(L"Closing NT4 style sound device\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    return CloseKernelSoundDevice((HANDLE) Handle);
}

Referenced by FoundDevice().

DetectNt4SoundDevices()

MMRESULT DetectNt4SoundDevices	(	IN MMDEVICE_TYPE	DeviceType,
		IN PWSTR	BaseDeviceName,
		IN SOUND_DEVICE_DETECTED_PROC	SoundDeviceDetectedProc
	)

Definition at line 151 of file detect.c.

{
    SIZE_T DeviceNameLength = 0;
    PWSTR DeviceName = NULL;
    ULONG Index = 0;
    HANDLE DeviceHandle;
    BOOLEAN DoSearch = TRUE;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) );
 
    DeviceNameLength = wcslen(BaseDeviceName);
    /* Consider the length of the number */
    DeviceNameLength += GetDigitCount(Index);
 
    DeviceName = AllocateWideString(DeviceNameLength);
 
    if ( ! DeviceName )
    {
        return MMSYSERR_NOMEM;
    }
 
    while ( DoSearch )
    {
        /* Nothing like a nice clean device name */
        ZeroWideString(DeviceName);
        wsprintf(DeviceName, L"%ls%d", BaseDeviceName, Index);
 
        if ( OpenKernelSoundDeviceByName(DeviceName,
                                         TRUE,
                                         &DeviceHandle) == MMSYSERR_NOERROR )
        {
            /* Notify the callback function */
            SND_TRACE(L"Found device: %wS\n", DeviceName);
            SoundDeviceDetectedProc(DeviceType, DeviceName);
 
            CloseHandle(DeviceHandle);
 
            ++ Index;
        }
        else
        {
            DoSearch = FALSE;
        }
    }
 
    FreeMemory(DeviceName);
 
    return MMSYSERR_NOERROR;
}

EnumerateNt4ServiceSoundDevices()

MMRESULT EnumerateNt4ServiceSoundDevices	(	IN LPWSTR	ServiceName,
		IN MMDEVICE_TYPE	DeviceType,
		IN SOUND_DEVICE_DETECTED_PROC	SoundDeviceDetectedProc
	)

Definition at line 26 of file detect.c.

{
    HKEY Key;
    DWORD KeyIndex = 0;
 
    VALIDATE_MMSYS_PARAMETER( ServiceName );
 
    /* Device type zero means "all" */
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) ||
                              DeviceType == 0 );
 
    while ( OpenSoundDeviceRegKey(ServiceName, KeyIndex, &Key) == MMSYSERR_NOERROR )
    {
        HKEY DevicesKey;
        DWORD ValueType = REG_NONE, ValueIndex = 0;
        DWORD MaxNameLength = 0, ValueNameLength = 0;
        PWSTR DevicePath = NULL, ValueName = NULL;
        DWORD ValueDataLength = sizeof(DWORD);
        DWORD ValueData;
 
        if ( RegOpenKeyEx(Key,
                          REG_DEVICES_KEY_NAME_U,
                          0,
                          KEY_READ,
                          &DevicesKey) == ERROR_SUCCESS )
        {
            /* Find out how much memory is needed for the key name */
            if ( RegQueryInfoKey(DevicesKey,
                                 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                                 &MaxNameLength,
                                 NULL, NULL, NULL) != ERROR_SUCCESS )
            {
                SND_ERR(L"Failed to query registry key information\n");
                RegCloseKey(DevicesKey);
                RegCloseKey(Key);
 
                return MMSYSERR_ERROR;
            }
 
            DevicePath = AllocateWideString(MaxNameLength +
                                            strlen("\\\\.\\"));
 
            /* Check that the memory allocation was successful */
            if ( ! DevicePath )
            {
                /* There's no point in going further */
                RegCloseKey(DevicesKey);
                RegCloseKey(Key);
 
                return MMSYSERR_NOMEM;
            }
 
            /* Insert the device path prefix */
            wsprintf(DevicePath, L"\\\\.\\");
 
            /* The offset of the string following this prefix */
            ValueName = DevicePath + strlen("\\\\.\\");
 
            /* Copy this so that it may be overwritten - include NULL */
            ValueNameLength = MaxNameLength + sizeof(WCHAR);
 
            SND_TRACE(L"Interested in devices beginning with %wS\n", DevicePath);
 
            while ( RegEnumValue(DevicesKey,
                                 ValueIndex,
                                 ValueName,
                                 &ValueNameLength,
                                 NULL,
                                 &ValueType,
                                 (LPBYTE) &ValueData,
                                 &ValueDataLength) == ERROR_SUCCESS )
            {
                /* Device types are stored as DWORDs */
                if ( ( ValueType == REG_DWORD ) &&
                     ( ValueDataLength == sizeof(DWORD) ) )
                {
                    if ( ( DeviceType == 0 ) ||
                         ( DeviceType == ValueData ) )
                    {
                        SND_TRACE(L"Found device: %wS\n", DevicePath);
                        SoundDeviceDetectedProc(ValueData, DevicePath);
                    }
                }
 
                /* Reset variables for the next iteration */
                ValueNameLength = MaxNameLength + sizeof(WCHAR);
                ZeroMemory(ValueName, (MaxNameLength+1)*sizeof(WCHAR));
                /*ZeroWideString(ValueName);*/
                ValueDataLength = sizeof(DWORD);
                ValueData = 0;
                ValueType = REG_NONE;
 
                ++ ValueIndex;
            }
 
            FreeMemory(DevicePath);
 
            RegCloseKey(DevicesKey);
        }
        else
        {
            SND_WARN(L"Unable to open the Devices key!\n");
        }
 
        ++ KeyIndex;
 
        RegCloseKey(Key);
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by DriverProc().

GetNt4SoundDeviceCapabilities()

MMRESULT GetNt4SoundDeviceCapabilities	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PVOID	Capabilities,
		IN DWORD	CapabilitiesSize
	)

Definition at line 80 of file control.c.

{
    MMRESULT Result;
    MMDEVICE_TYPE DeviceType;
    DWORD IoCtl;
    HANDLE DeviceHandle;
 
    /* If these are bad there's an internal error with MME-Buddy! */
    SND_ASSERT( SoundDevice );
    SND_ASSERT( Capabilities );
    SND_ASSERT( CapabilitiesSize > 0 );
 
    SND_TRACE(L"NT4 get-capabilities routine called\n");
 
    /* Get the device type */
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Choose the appropriate IOCTL */
    if ( IS_WAVE_DEVICE_TYPE(DeviceType) )
    {
        IoCtl = IOCTL_WAVE_GET_CAPABILITIES;
    }
    else if ( IS_MIDI_DEVICE_TYPE(DeviceType) )
    {
        IoCtl = IOCTL_MIDI_GET_CAPABILITIES;
    }
    else
    {
        /* FIXME - need to support AUX and mixer devices */
        SND_ASSERT( FALSE );
        IoCtl = 0;
    }
 
    /* Get the capabilities information from the driver */
    Result = OpenNt4KernelSoundDevice(SoundDevice, TRUE, &DeviceHandle);
 
    if ( ! MMSUCCESS(Result) )
    {
        SND_ERR(L"Failed to open device\n");
        return TranslateInternalMmResult(Result);
    }
 
    Result = SyncOverlappedDeviceIoControl(DeviceHandle,
                                           IoCtl,
                                           Capabilities,
                                           CapabilitiesSize,
                                           NULL,
                                           0,
                                           NULL);
 
    CloseKernelSoundDevice(DeviceHandle);
 
    if ( ! MMSUCCESS(Result) )
    {
        SND_ERR(L"Retrieval of capabilities information failed\n");
        Result = TranslateInternalMmResult(Result);
    }
 
    return Result;
}

Referenced by GetSoundBlasterDeviceCapabilities().

OpenNt4SoundDevice()

MMRESULT OpenNt4SoundDevice	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PVOID *	Handle
	)

Definition at line 52 of file control.c.

{
    SND_TRACE(L"Opening NT4 style sound device\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( Handle );
 
    return OpenNt4KernelSoundDevice(SoundDevice, FALSE, Handle);
}

Referenced by FoundDevice().

OpenSoundDeviceRegKey()

MMRESULT OpenSoundDeviceRegKey	(	IN LPWSTR	ServiceName,
		IN DWORD	DeviceIndex,
		OUT PHKEY	KeyHandle
	)

Definition at line 73 of file registry.c.

{
    SIZE_T PathLength;
    PWCHAR RegPath;
 
    VALIDATE_MMSYS_PARAMETER( ServiceName );
    VALIDATE_MMSYS_PARAMETER( KeyHandle );
 
    /*
        Work out the space required to hold the path:
 
        HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\
            sndblst\
                Parameters\
                    Device123\
    */
    PathLength = wcslen(REG_SERVICES_KEY_NAME_U) + 1
               + wcslen(ServiceName) + 1
               + wcslen(REG_PARAMETERS_KEY_NAME_U) + 1
               + wcslen(REG_DEVICE_KEY_NAME_U)
               + GetDigitCount(DeviceIndex);
 
    /* Allocate storage for the string */
    RegPath = AllocateWideString(PathLength);
 
    if ( ! RegPath )
    {
        return MMSYSERR_NOMEM;
    }
 
    /* Write the path */
    wsprintf(RegPath,
             L"%ls\\%ls\\%ls\\%ls%d",
             REG_SERVICES_KEY_NAME_U,
             ServiceName,
             REG_PARAMETERS_KEY_NAME_U,
             REG_DEVICE_KEY_NAME_U,
             DeviceIndex);
 
    SND_TRACE(L"Opening reg key: %wS\n", RegPath);
 
    /* Perform the open */
    if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                      RegPath,
                      0,
                      KEY_READ,
                      KeyHandle) != ERROR_SUCCESS )
    {
        /* Couldn't open the key */
        SND_ERR(L"Failed to open reg key: %wS\n", RegPath);
        FreeMemory(RegPath);
        return MMSYSERR_ERROR;
    }
 
    FreeMemory(RegPath);
 
    return MMSYSERR_NOERROR;
}

Referenced by EnumerateNt4ServiceSoundDevices().

OpenSoundDriverParametersRegKey()

MMRESULT OpenSoundDriverParametersRegKey	(	IN LPWSTR	ServiceName,
		OUT PHKEY	KeyHandle
	)

Definition at line 20 of file registry.c.

{
    SIZE_T KeyLength;
    PWCHAR ParametersKeyName;
 
    VALIDATE_MMSYS_PARAMETER( ServiceName );
    VALIDATE_MMSYS_PARAMETER( KeyHandle );
 
    /* Work out how long the string will be */
    KeyLength = wcslen(REG_SERVICES_KEY_NAME_U) + 1
              + wcslen(ServiceName) + 1
              + wcslen(REG_PARAMETERS_KEY_NAME_U);
 
    /* Allocate memory for the string */
    ParametersKeyName = AllocateWideString(KeyLength);
 
    if ( ! ParametersKeyName )
        return MMSYSERR_NOMEM;
 
    /* Construct the registry path */
    wsprintf(ParametersKeyName,
             L"%s\\%s\\%s",
             REG_SERVICES_KEY_NAME_U,
             ServiceName,
             REG_PARAMETERS_KEY_NAME_U);
 
    SND_TRACE(L"Opening reg key: %wS\n", ParametersKeyName);
 
    /* Perform the open */
    if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                      ParametersKeyName,
                      0,
                      KEY_READ,
                      KeyHandle) != ERROR_SUCCESS )
    {
        /* Couldn't open the key */
        SND_ERR(L"Failed to open reg key: %wS\n", ParametersKeyName);
        FreeMemory(ParametersKeyName);
        return MMSYSERR_ERROR;
    }
 
    FreeMemory(ParametersKeyName);
 
    return MMSYSERR_NOERROR;
}

QueryNt4WaveDeviceFormatSupport()

MMRESULT QueryNt4WaveDeviceFormatSupport	(	IN PSOUND_DEVICE	SoundDevice,
		IN LPWAVEFORMATEX	Format,
		IN DWORD	FormatSize
	)

Definition at line 154 of file control.c.

{
    MMRESULT Result;
    HANDLE Handle;
 
    SND_TRACE(L"NT4 wave format support querying routine called\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( Format );
    VALIDATE_MMSYS_PARAMETER( FormatSize >= sizeof(WAVEFORMATEX) );
 
    /* Get the device path */
    Result = OpenNt4KernelSoundDevice(SoundDevice,
                                      FALSE,
                                      &Handle);
 
    if ( ! MMSUCCESS(Result) )
    {
        SND_ERR(L"Unable to open kernel sound device\n");
        return TranslateInternalMmResult(Result);
    }
 
    Result = SyncOverlappedDeviceIoControl(Handle,
                                           IOCTL_WAVE_QUERY_FORMAT,
                                           (LPVOID) Format,
                                           FormatSize,
                                           NULL,
                                           0,
                                           NULL);
 
    if ( ! MMSUCCESS(Result) )
    {
        SND_ERR(L"Sync overlapped I/O failed - MMSYS_ERROR %d\n", Result);
        Result = TranslateInternalMmResult(Result);
    }
 
    CloseKernelSoundDevice(Handle);
 
    return MMSYSERR_NOERROR;
}

Referenced by FoundDevice().

SetNt4WaveDeviceFormat()

MMRESULT SetNt4WaveDeviceFormat	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN DWORD	DeviceId,
		IN LPWAVEFORMATEX	Format,
		IN DWORD	FormatSize
	)

Definition at line 199 of file control.c.

{
    MMRESULT Result;
    HANDLE Handle;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( Format );
    VALIDATE_MMSYS_PARAMETER( FormatSize >= sizeof(WAVEFORMATEX) );
 
    Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    SND_TRACE(L"Setting wave device format on handle %x\n", Handle);
 
    Result = SyncOverlappedDeviceIoControl(Handle,
                                           IOCTL_WAVE_SET_FORMAT,
                                           (LPVOID) Format,
                                           FormatSize,
                                           NULL,
                                           0,
                                           NULL);
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    return MMSYSERR_NOERROR;
}

Referenced by FoundDevice().