[silverblade] 19530: Partial implementation of WDMAUD.DRV - device capability querying fails
Partial implementation of WDMAUD.DRV - device capability querying fails Added: trunk/reactos/lib/wdmaud/ Added: trunk/reactos/lib/wdmaud/TODO Added: trunk/reactos/lib/wdmaud/control.c Added: trunk/reactos/lib/wdmaud/devices.c Added: trunk/reactos/lib/wdmaud/helper.c Added: trunk/reactos/lib/wdmaud/kernel.c Added: trunk/reactos/lib/wdmaud/threads.c Added: trunk/reactos/lib/wdmaud/user.c Added: trunk/reactos/lib/wdmaud/wavehdr.c Added: trunk/reactos/lib/wdmaud/wdmaud.def Added: trunk/reactos/lib/wdmaud/wdmaud.h Added: trunk/reactos/lib/wdmaud/wdmaud.rc Added: trunk/reactos/lib/wdmaud/wdmaud.xml _____
Added: trunk/reactos/lib/wdmaud/TODO --- trunk/reactos/lib/wdmaud/TODO 2005-11-24 14:34:44 UTC (rev 19529) +++ trunk/reactos/lib/wdmaud/TODO 2005-11-24 14:36:47 UTC (rev 19530) @@ -0,0 +1,4 @@
+To-Do: +- Globally store the heap handle +- Ensure cleanups are... clean... +- Clone device info in OPEN/close? _____
Added: trunk/reactos/lib/wdmaud/control.c --- trunk/reactos/lib/wdmaud/control.c 2005-11-24 14:34:44 UTC (rev 19529) +++ trunk/reactos/lib/wdmaud/control.c 2005-11-24 14:36:47 UTC (rev 19530) @@ -0,0 +1,47 @@
+/* + * + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Multimedia + * FILE: lib/wdmaud/wavehdr.c + * PURPOSE: WDM Audio Support - Device Control (Play/Stop etc.) + * PROGRAMMER: Andrew Greenwood + * UPDATE HISTORY: + * Nov 23, 2005: Created + */ + +#include <windows.h> +#include "wdmaud.h" + +/* + TODO: + Make these work for the other device types! +*/ + +MMRESULT StartDevice(PWDMAUD_DEVICE_INFO device) +{ + MMRESULT result; + DWORD ioctl_code; + + result = ValidateDeviceInfoAndState(device); + + if ( result != MMSYSERR_NOERROR ) + return result; + + ioctl_code = device == WDMAUD_WAVE_IN ? IOCTL_WDMAUD_WAVE_IN_START : + device == WDMAUD_WAVE_OUT ? IOCTL_WDMAUD_WAVE_OUT_START : + 0x0000; + + ASSERT( ioctl_code ); +} + +MMRESULT StopDevice(PWDMAUD_DEVICE_INFO device) +{ +} + +MMRESULT PauseDevice(PWDMAUD_DEVICE_INFO device) +{ +} + +MMRESULT StopDeviceLooping(PWDMAUD_DEVICE_INFO device) +{ +} Property changes on: trunk/reactos/lib/wdmaud/control.c ___________________________________________________________________ Name: svn:eol-style + native _____
Added: trunk/reactos/lib/wdmaud/devices.c --- trunk/reactos/lib/wdmaud/devices.c 2005-11-24 14:34:44 UTC (rev 19529) +++ trunk/reactos/lib/wdmaud/devices.c 2005-11-24 14:36:47 UTC (rev 19530) @@ -0,0 +1,697 @@
+/* + * + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Multimedia + * FILE: lib/wdmaud/devices.c + * PURPOSE: WDM Audio Support - Device Management + * PROGRAMMER: Andrew Greenwood + * UPDATE HISTORY: + * Nov 18, 2005: Created + * + * WARNING! SOME OF THESE FUNCTIONS OUGHT TO COPY THE DEVICE INFO STRUCTURE + * THAT HAS BEEN FED TO THEM! +*/ + +#include <windows.h> +#include "wdmaud.h" + +const char WDMAUD_DEVICE_INFO_SIG[4] = "WADI"; +const char WDMAUD_DEVICE_STATE_SIG[4] = "WADS"; + + +BOOL IsValidDevicePath(WCHAR* path) +{ + if (IsBadReadPtr(path, 1)) /* TODO: Replace with flags */ + { + DPRINT1("Bad interface\n"); + return FALSE; + } + + /* Original driver seems to check for strlenW < 0x1000 */ + + return TRUE; +} + +MMRESULT ValidateDeviceInfo(PWDMAUD_DEVICE_INFO device_info) +{ + if ( IsBadWritePtr(device_info, sizeof(WDMAUD_DEVICE_INFO)) ) + return MMSYSERR_INVALPARAM; + + if ( *device_info->signature != *WDMAUD_DEVICE_INFO_SIG ) + return MMSYSERR_INVALPARAM; + + return MMSYSERR_NOERROR; +} + +MMRESULT ValidateDeviceState(PWDMAUD_DEVICE_STATE state) +{ + if ( IsBadWritePtr(state, sizeof(WDMAUD_DEVICE_INFO)) ) + return MMSYSERR_INVALPARAM; + + if ( *state->signature != *WDMAUD_DEVICE_STATE_SIG ) + return MMSYSERR_INVALPARAM; + + return MMSYSERR_NOERROR; +} + +/* + ValidateDeviceStateEvents should be used in conjunction with the standard + state validation routine. +*/ + +MMRESULT ValidateDeviceStateEvents(PWDMAUD_DEVICE_STATE state) +{ + if ( ( (DWORD) state->exit_thread_event == 0x00000000 ) && + ( (DWORD) state->exit_thread_event != 0x48484848 ) ) + { + DPRINT1("Bad exit thread event\n"); + return MMSYSERR_INVALPARAM; + } + + if ( ( (DWORD) state->queue_event == 0x00000000 ) && + ( (DWORD) state->queue_event != 0x42424242 ) && + ( (DWORD) state->queue_event != 0x43434343 ) ) + { + DPRINT1("Bad queue event\n"); + return MMSYSERR_INVALPARAM; + } + + return MMSYSERR_NOERROR; +} + +MMRESULT ValidateDeviceInfoAndState(PWDMAUD_DEVICE_INFO device_info) +{ + MMRESULT result; + + result = ValidateDeviceInfo(device_info); + + if ( result != MMSYSERR_NOERROR ) + return result; + + result = ValidateDeviceState(device_info->state); + + if ( result != MMSYSERR_NOERROR ) + return result; + + return MMSYSERR_NOERROR; +} + +PWDMAUD_DEVICE_INFO CreateDeviceData(CHAR device_type, WCHAR* device_path) +{ + HANDLE heap = 0; + PWDMAUD_DEVICE_INFO device_data = 0; + int path_size = 0; + + if ( ! IsValidDevicePath(device_path) ) + { + DPRINT1("No valid device interface given!\n"); + goto cleanup; + } + + /* Take into account this is a unicode string... */ + path_size = (lstrlen(device_path) + 1) * sizeof(WCHAR); + DPRINT("Size of path is %d\n", (int) path_size); + + heap = GetProcessHeap(); + + if ( ! heap ) + { + DPRINT1("Couldn't get the process heap (error %d)\n", + (int) GetLastError()); + goto cleanup; + } + + DPRINT("Allocating %d bytes\n", + path_size + sizeof(WDMAUD_DEVICE_INFO)); + + device_data = (PWDMAUD_DEVICE_INFO) HeapAlloc(heap, + HEAP_ZERO_MEMORY, + path_size + sizeof(WDMAUD_DEVICE_INFO)); + + if ( ! device_data ) + { + DPRINT1("Unable to allocate memory for device data (error %d)\n", + (int) GetLastError()); + goto cleanup; + } + + DPRINT("Copying signature\n"); + memcpy(device_data->signature, WDMAUD_DEVICE_INFO_SIG, 4); + + DPRINT("Copying path (0x%x)\n", (int)device_path); + lstrcpy(device_data->path, device_path); + + device_data->type = device_type; + + cleanup : + { + /* No cleanup needed (no failures possible after allocation.) */ + DPRINT("Performing cleanup\n"); + + return device_data; + } +} + +PWDMAUD_DEVICE_INFO CloneDeviceData(PWDMAUD_DEVICE_INFO original) +{ + PWDMAUD_DEVICE_INFO clone = NULL; + + if ( ValidateDeviceInfo(original) != MMSYSERR_NOERROR) + { + DPRINT1("Original device data was invalid\n"); + return NULL; + } + + /* This will set the type and path, so we can forget about those */ + clone = CreateDeviceData(original->type, original->path); + + if ( ! clone ) + { + DPRINT1("Clone creation failed\n"); + return NULL; + } + + clone->id = original->id; + clone->wave_handle = original->wave_handle; /* ok? */ + + /* TODO: Maybe we should copy some more? */ + + return clone; +} + +void DeleteDeviceData(PWDMAUD_DEVICE_INFO device_data) +{ + ASSERT( device_data ); + /* TODO */ +} + +MMRESULT ModifyDevicePresence( + CHAR device_type, + WCHAR* device_path, + BOOL adding) +{ + DWORD ioctl = 0; + PWDMAUD_DEVICE_INFO device_data = 0; + MMRESULT result = MMSYSERR_ERROR; + MMRESULT kernel_result = MMSYSERR_ERROR; + + DPRINT("ModifyDevicePresence - %s a device\n", + adding ? "adding" : "removing"); + + DPRINT("Topology path %S\n", device_path); + + /* FIXME: DeviceType! */ + /* TODO: Assert on device type? */ + + ASSERT( IsValidDeviceType(device_type) ); + ASSERT( device_path ); + + device_data = CreateDeviceData(device_type, device_path); + + if ( ! device_data ) + { + DPRINT1("Couldn't allocate memory for device data\n"); + result = MMSYSERR_NOMEM; + goto cleanup; + } + +/* device_data->type = device_type; */ + + ioctl = adding ? IOCTL_WDMAUD_ADD_DEVICE : IOCTL_WDMAUD_REMOVE_DEVICE; + + kernel_result = CallKernelDevice(device_data, + ioctl, + 0, + 0); + + if ( kernel_result != MMSYSERR_NOERROR ) + { + DPRINT1("WdmAudioIoControl FAILED with error %d\n", (int) kernel_result); + + switch ( kernel_result ) + { + /* TODO: Translate into a real error code */ + default : + result = MMSYSERR_ERROR; + } + + goto cleanup; + } + + DPRINT("ModifyDevicePresence succeeded\n"); + + result = MMSYSERR_NOERROR; + + cleanup : + { + if ( device_data ) + DeleteDeviceData(device_data); + + return result; + } +} + +DWORD GetDeviceCount(CHAR device_type, WCHAR* topology_path) +{ + PWDMAUD_DEVICE_INFO device_data; + int device_count = 0; + + DPRINT("Topology path %S\n", topology_path); + + device_data = CreateDeviceData(device_type, topology_path); + + if (! device_data) + { + DPRINT1("Couldn't allocate device data\n"); + goto cleanup; + } + + DPRINT("Getting num devs\n"); + + /*device_data->type = device_type;*/ + device_data->with_critical_section = FALSE; + + if ( CallKernelDevice(device_data, + IOCTL_WDMAUD_GET_DEVICE_COUNT, + 0, + 0) != MMSYSERR_NOERROR ) + { + DPRINT1("Failed\n"); + goto cleanup; + } + + device_count = device_data->id; + + DPRINT("There are %d devs\n", device_count); + + cleanup : + { + if ( device_data ) + DeleteDeviceData(device_data); + + return device_count; + } +} + +/* + This is a bit messed up +*/ + +MMRESULT GetDeviceCapabilities( + CHAR device_type, + DWORD device_id, + WCHAR* device_path, + LPCOMMONCAPS caps +) +{ + PWDMAUD_DEVICE_INFO device = NULL; + MMRESULT result = MMSYSERR_ERROR; + + DPRINT("Device path %S\n", device_path); + + /* Hmm - caps->wMid seems to be 0x54 (84) from XP's winmm.dll */ + if (caps->wMid == 0) + { + return MMSYSERR_NOERROR; + + DPRINT("caps->wMid == 0\n"); + + DPRINT("Manufacturer: 0x%x (%d)\n", caps->wMid, caps->wMid); + DPRINT("Product: 0x%x (%d)\n", caps->wPid, caps->wPid); + DPRINT("Device is: %S\n", caps->szPname); + + if ( IsWaveOutDeviceType(device_type) ) + { + LPWAVEOUTCAPS woc = (LPWAVEOUTCAPS) caps; + DPRINT("Formats: %d\n", (int) woc->dwFormats); + DPRINT("Channels: %d\n", woc->wChannels); + DPRINT("Reserved: %d\n", woc->wReserved1); + DPRINT("Support: %d\n", (int) woc->dwSupport); + } + + return MMSYSERR_NOERROR; + } + +#if 0 + int i; + for (i = 0; i < 64; i ++) + { + DPRINT("0x%x\n", *(((UCHAR*)caps) + i)); + } + + return MMSYSERR_NOERROR; +#endif + + DPRINT("Going to have to query the kernel-mode part\n"); + + device = CreateDeviceData(device_type, device_path); + + if ( ! device ) + { + DPRINT("Unable to allocate device data memory\n"); + result = MMSYSERR_NOMEM; + goto cleanup; + } + + device->id = device_id; + device->with_critical_section = FALSE; + + /* ? */ + DPRINT("Caps wMid is 0x%x\n", (int) caps->wMid); + DPRINT("Driver version is 0x%x\n", (int) caps->vDriverVersion); + + DPRINT("%S\n", (WCHAR*) caps->vDriverVersion); + + LPWORD theword; + theword = (LPWORD) caps->vDriverVersion; + *theword = 0x43; + //caps->vDriverVersion=0x4300; + + + DPRINT("Calling kernel device\n"); + result = CallKernelDevice(device, + IOCTL_WDMAUD_GET_CAPABILITIES, + (DWORD)caps->wMid, + (DWORD)caps->vDriverVersion); + + if ( result != MMSYSERR_NOERROR ) + { + DPRINT("IoControl failed\n"); + goto cleanup; + } + + + + /* What do we return? */ + /*return MMSYSERR_NOERROR; */ /* already set by now */ + + cleanup : + { + if ( device ) + DeleteDeviceData(device); + + return result; + } +} + +MMRESULT TryOpenDevice( + PWDMAUD_DEVICE_INFO device, + LPWAVEFORMATEX format +) +{ + if ( device->id > 0x64 ) /* FIXME */ + { + DPRINT1("device->id > 0x64 ! ???\n"); + return MMSYSERR_BADDEVICEID; /* OK? */ + } + + /* We'll only have a format set for wave devices */ + if ( format ) + { + if ( format->wFormatTag == 1 ) + { + DWORD sample_size; + + DPRINT("Standard (PCM) format\n"); + sample_size = format->nChannels * format->wBitsPerSample; + device->state->sample_size = sample_size; + + if ( CallKernelDevice(device, + IOCTL_WDMAUD_OPEN_DEVICE, + 0x10, + (DWORD)format) + != MMSYSERR_NOERROR ) + { + DPRINT("Call failed\n"); + /* FIXME */ + return MMSYSERR_NOTSUPPORTED; /* WAVERR_BADFORMAT? */ + } + } + else + { + /* FIXME */ + DPRINT("Non-PCM format\n"); + return MMSYSERR_NOTSUPPORTED; + } + } + + /* If we got this far without error, the format is supported! */ + return MMSYSERR_NOERROR; +} + +MMRESULT OpenWaveDevice( + CHAR device_type, + DWORD device_id, + LPWAVEOPENDESC open_details, + DWORD flags, + DWORD user_data +) +{ + HANDLE heap = 0; + PWDMAUD_DEVICE_INFO device = NULL; + WCHAR* device_path = NULL; + MMRESULT result = MMSYSERR_ERROR; + + /* ASSERT(open_details); */ + + heap = GetProcessHeap(); + + if ( ! heap ) + { + DPRINT1("Couldn't get the process heap (error %d)\n", + (int) GetLastError()); + result = MMSYSERR_ERROR; + goto cleanup; + } + + DPRINT("OpenDevice called\n"); + + device_path = (WCHAR*) open_details->dnDevNode; + device = CreateDeviceData(device_type, device_path); + + if ( ! device ) + { + DPRINT1("Couldn't create device data\n"); + result = MMSYSERR_NOMEM; + goto cleanup; + } + + DPRINT("Allocated device data, allocating device state\n"); + + device->state = HeapAlloc(heap, + HEAP_ZERO_MEMORY, + sizeof(WDMAUD_DEVICE_STATE)); + + if ( ! device->state ) + { + DPRINT1("Couldn't allocate memory for device state (error %d)\n", + (int) GetLastError()); + result = MMSYSERR_NOMEM; + goto cleanup; + } + + /* FIXME: ok here ? */ + device->type = device_type; + device->id = device_id; + device->flags = flags; + + if ( flags & WAVE_FORMAT_QUERY ) + { + DPRINT("Do I support this format? Hmm...\n"); + + result = TryOpenDevice(device, open_details->lpFormat); + + if ( result != MMSYSERR_NOERROR ) + { + DPRINT("Format not supported\n"); + goto cleanup; + } + + DPRINT("Yes, I do support this format!\n"); + } + else + { + + DPRINT("You actually want me to open the device, huh?\n"); + + /* Allocate memory for the "queue" critical section */ + + device->state->queue_critical_section = + HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(CRITICAL_SECTION)); + + if ( ! device->state->queue_critical_section ) + { + DPRINT1("Couldn't allocate memory for queue critical section (error %d)\n", + (int) GetLastError()); + result = MMSYSERR_NOMEM; + goto cleanup; + } + + /* Initialize the critical section */ + InitializeCriticalSection(device->state->queue_critical_section); + + /* We need these so we can contact the client later */ + device->client_instance = open_details->dwInstance; + device->client_callback = open_details->dwCallback; + + /* Reset state */ + device->state->open_descriptor = NULL; + device->state->unknown_24 = 0; + + device->state->is_running = FALSE; + device->state->is_paused = + device->type == WDMAUD_WAVE_IN ? TRUE : FALSE; + + memcpy(device->state->signature, WDMAUD_DEVICE_STATE_SIG, 4); + + DPRINT("All systems are go...\n"); + + result = TryOpenDevice(device, open_details->lpFormat); + + if ( result != MMSYSERR_NOERROR ) + { + DPRINT1("Format not supported?\n"); + goto cleanup; /* no need to set result - already done */ + } + + /* Enter the critical section while updating the device list */ + EnterCriticalSection(device->state->queue_critical_section); + /* ... */ + LeaveCriticalSection(device->state->queue_critical_section); + + /* The wave device handle is actually our structure. Neat, eh? */ + open_details->hWave = (HWAVE) device; + + /* We also need to set our "user data" for winmm */ + LPVOID* ud = (LPVOID*) user_data; /* FIXME */ + *ud = device; + + if (device->client_callback) + { + DWORD message; + + message = (device->type == WDMAUD_WAVE_IN ? WIM_OPEN : + WDMAUD_WAVE_OUT ? WOM_OPEN : -1); + + DPRINT("About to call the client callback\n"); + + /* Call the callback */ + NotifyClient(device, message, 0, 0); + + DPRINT("...it is done!\n"); + } + + result = MMSYSERR_NOERROR; + } + + /* + This cleanup may need checking for memory leakage :/ + */ + + cleanup : + { + if ( ( result != MMSYSERR_NOERROR ) && ( heap ) ) + { + if ( device ) + { + if ( device->state ) + { + if ( device->state->queue_critical_section ) + { + DeleteCriticalSection(device->state->queue_critical_section); + HeapFree(heap, 0, device->state->queue_critical_section); + } + + HeapFree(heap, 0, device->state); + } + + DeleteDeviceData(device); + } + } + + DPRINT("Returning %d\n", (int) result); + + return result; + } +} + +MMRESULT CloseDevice( + PWDMAUD_DEVICE_INFO device +) +{ + MMRESULT result = MMSYSERR_ERROR; + + DPRINT("CloseDevice()\n"); + + DUMP_WDMAUD_DEVICE_INFO(device); + + if ( ValidateDeviceInfo(device) != MMSYSERR_NOERROR ) + { + DPRINT1("Invalid device info passed to CloseDevice\n"); + result = MMSYSERR_INVALHANDLE; + goto cleanup; + } + + /* TODO: Check state! */ + + if ( device->id > 0x64 ) /* FIXME ? */ + { + DPRINT1("??\n"); + goto cleanup; + } + + switch(device->type) + { + case WDMAUD_WAVE_OUT : + { + if ( device->state->open_descriptor ) + { + DPRINT1("Device is still playing!\n"); + result = WAVERR_STILLPLAYING; + goto cleanup; + } + + /* TODO: Destroy completion thread */ + + break; + } + + default : + { + DPRINT1("Sorry, device type %d not supported yet!\n", (int) device->type); + goto cleanup; + } + } + + result = CallKernelDevice(device, IOCTL_WDMAUD_CLOSE_DEVICE, 0, 0); + + if ( result != MMSYSERR_NOERROR ) + { + DPRINT1("Couldn't close the device!\n"); + goto cleanup; + } + + if (device->client_callback) + { + DWORD message; + + message = (device->type == WDMAUD_WAVE_IN ? WIM_CLOSE : + WDMAUD_WAVE_OUT ? WOM_CLOSE : + WDMAUD_MIDI_IN ? MIM_CLOSE : + WDMAUD_MIDI_OUT ? MOM_CLOSE : -1); + + DPRINT("About to call the client callback\n"); + + /* Call the callback */ + NotifyClient(device, message, 0, 0); + + DPRINT("...it is done!\n"); + } + + /* Result was set earlier by CallKernelDevice */ + + cleanup : + { + return result; + } +} Property changes on: trunk/reactos/lib/wdmaud/devices.c ___________________________________________________________________ Name: svn:eol-style + native _____
Added: trunk/reactos/lib/wdmaud/helper.c --- trunk/reactos/lib/wdmaud/helper.c 2005-11-24 14:34:44 UTC (rev 19529) +++ trunk/reactos/lib/wdmaud/helper.c 2005-11-24 14:36:47 UTC (rev 19530) @@ -0,0 +1,46 @@
+/* + * + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Multimedia + * FILE: lib/wdmaud/helper.c + * PURPOSE: Multimedia User Mode Driver - Helper Funcs + * PROGRAMMER: Andrew Greenwood + * UPDATE HISTORY: + * Nov 13, 2005: Created + */ + +#include <windows.h> +#include <mmsystem.h> + +/* + TranslateWinError converts Win32 error codes (returned by + GetLastError, typically) into MMSYSERR codes. +*/ + +MMRESULT TranslateWinError(DWORD error) +{ + switch(error) + { + case NO_ERROR : + case ERROR_IO_PENDING : + return MMSYSERR_NOERROR; + + case ERROR_BUSY : + return MMSYSERR_ALLOCATED; + + case ERROR_NOT_SUPPORTED : + case ERROR_INVALID_FUNCTION : + return MMSYSERR_NOTSUPPORTED; + + case ERROR_NOT_ENOUGH_MEMORY : + return MMSYSERR_NOMEM; + + case ERROR_ACCESS_DENIED : + return MMSYSERR_BADDEVICEID; + + case ERROR_INSUFFICIENT_BUFFER : + return MMSYSERR_INVALPARAM; + } + + return MMSYSERR_ERROR; +} Property changes on: trunk/reactos/lib/wdmaud/helper.c ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native _____
Added: trunk/reactos/lib/wdmaud/kernel.c --- trunk/reactos/lib/wdmaud/kernel.c 2005-11-24 14:34:44 UTC (rev 19529) +++ trunk/reactos/lib/wdmaud/kernel.c 2005-11-24 14:36:47 UTC (rev 19530) @@ -0,0 +1,358 @@
+/* + * + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Multimedia + * FILE: lib/wdmaud/kernel.c + * PURPOSE: WDM Audio Support - Kernel Mode Interface + * PROGRAMMER: Andrew Greenwood + * UPDATE HISTORY: + * Nov 18, 2005: Created + */ + +#define INITGUID /* FIXME */ + +#include <windows.h> +#include <setupapi.h> +#include "wdmaud.h" + +/* HACK ALERT - This goes in ksmedia.h */ +DEFINE_GUID(KSCATEGORY_WDMAUD, + 0x3e227e76L, 0x690d, 0x11d2, 0x81, 0x61, 0x00, 0x00, 0xf8, 0x77, 0x5b, 0xf1); + +/* This stores the handle of the kernel device */ +static HANDLE kernel_device_handle = NULL; + +//static WCHAR* + + +/* + TODO: There's a variant of this that uses critical sections... +*/ + +MMRESULT CallKernelDevice( + PWDMAUD_DEVICE_INFO device, + DWORD ioctl_code, + DWORD param1, + DWORD param2) +{ + OVERLAPPED overlap; + MMRESULT result = MMSYSERR_ERROR; + DWORD name_len = 0; + DWORD bytes_returned = 0; + BOOL using_critical_section = FALSE; + + ASSERT(kernel_device_handle); + ASSERT(device); + + DPRINT("Creating event\n"); + overlap.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + + if ( ! overlap.hEvent ) + { + DPRINT1("CreateEvent failed - error %d\n", (int)GetLastError()); + result = MMSYSERR_NOMEM; + goto cleanup; + } + + DPRINT("Sizeof wchar == %d\n", (int) sizeof(WCHAR)); + name_len = lstrlen(device->path) * sizeof(WCHAR); /* ok ? */ + + /* These seem to carry optional structures */ + device->ioctl_param1 = param1; + device->ioctl_param2 = param2; + + /* Enter critical section if wave/midi device, and if required */ + if ( ( ! IsMixerDeviceType(device->type) ) && + ( ! IsAuxDeviceType(device->type) ) && + ( device->with_critical_section ) ) + { + /* this seems to crash under some conditions */ + ASSERT(device->state); + using_critical_section = TRUE; + EnterCriticalSection(device->state->queue_critical_section); + } + + DPRINT("Calling DeviceIoControl with IOCTL %x\n", (int) ioctl_code); + + if ( ! DeviceIoControl(kernel_device_handle, + ioctl_code, + device, + name_len + sizeof(WDMAUD_DEVICE_INFO), + device, + sizeof(WDMAUD_DEVICE_INFO), + &bytes_returned, + &overlap) ) + { + DWORD error = GetLastError(); + + if (error != ERROR_IO_PENDING) + { + DPRINT1("FAILED in CallKernelDevice (error %d)\n", (int) error); + + DUMP_WDMAUD_DEVICE_INFO(device); + + result = TranslateWinError(error); + goto cleanup; + } + + DPRINT("Waiting for overlap I/O event\n"); + + /* Wait for the IO to be complete */ + WaitForSingleObject(overlap.hEvent, INFINITE); + } + + result = MMSYSERR_NOERROR; + DPRINT("CallKernelDevice succeeded :)\n"); + + DUMP_WDMAUD_DEVICE_INFO(device); + + cleanup : + { + /* Leave the critical section */ + if ( using_critical_section ) + LeaveCriticalSection(device->state->queue_critical_section); + + if ( overlap.hEvent ) + CloseHandle(overlap.hEvent); + + return result; + } +} + + +static BOOL ChangeKernelDeviceState(BOOL enable) +{ + PWDMAUD_DEVICE_INFO device = NULL; + DWORD ioctl_code; + MMRESULT call_result; + + ioctl_code = enable ? IOCTL_WDMAUD_HELLO : IOCTL_WDMAUD_GOODBYE; + + device = CreateDeviceData(WDMAUD_AUX, L""); + + if ( ! device ) + { + DPRINT1("Couldn't create a new device instance structure\n"); + return FALSE; + } + + DPRINT("Setting device type and disabling critical section\n"); + + device->type = WDMAUD_AUX; + device->with_critical_section = FALSE; + + DPRINT("Calling kernel device\n"); + + call_result = CallKernelDevice(device, ioctl_code, 0, 0); + + DeleteDeviceData(device); + + if ( call_result != MMSYSERR_NOERROR ) + { + DPRINT1("Kernel device doesn't like us! (error %d)\n", (int) GetLastError()); + return FALSE; + } + else + { + return TRUE; + } +} + + +BOOL EnableKernelInterface() +{ + /* SetupAPI variables/structures for querying device data */ + SP_DEVICE_INTERFACE_DATA interface_data; + PSP_DEVICE_INTERFACE_DETAIL_DATA detail = NULL; + DWORD detail_size = 0; [truncated at 1000 lines; 2036 more skipped]
-
silverblade＠svn.reactos.com