ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions | Variables
legacy.c File Reference
#include "wdmaud.h"
#include <debug.h>
#include <mmebuddy_debug.h>
Include dependency graph for legacy.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define KERNEL_DEVICE_NAME   L"\\\\.\\wdmaud"
 

Functions

DWORD WINAPI MixerEventThreadRoutine (LPVOID Parameter)
 
MMRESULT WdmAudCleanupByLegacy ()
 
MMRESULT WdmAudGetNumWdmDevsByLegacy (IN MMDEVICE_TYPE DeviceType, OUT DWORD *DeviceCount)
 
MMRESULT WdmAudGetCapabilitiesByLegacy (IN PSOUND_DEVICE SoundDevice, IN DWORD DeviceId, OUT PVOID Capabilities, IN DWORD CapabilitiesSize)
 
MMRESULT WdmAudOpenSoundDeviceByLegacy (IN PSOUND_DEVICE SoundDevice, OUT PVOID *Handle)
 
MMRESULT WdmAudCloseSoundDeviceByLegacy (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Handle)
 
MMRESULT WdmAudSetMixerDeviceFormatByLegacy (IN PSOUND_DEVICE_INSTANCE Instance, IN DWORD DeviceId, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)
 
MMRESULT WdmAudSetWaveDeviceFormatByLegacy (IN PSOUND_DEVICE_INSTANCE Instance, IN DWORD DeviceId, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)
 
VOID CALLBACK LegacyCompletionRoutine (IN DWORD dwErrorCode, IN DWORD dwNumberOfBytesTransferred, IN LPOVERLAPPED lpOverlapped)
 
MMRESULT WdmAudCommitWaveBufferByLegacy (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID OffsetPtr, IN DWORD Length, IN PSOUND_OVERLAPPED Overlap, IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
 
MMRESULT WdmAudSetWaveStateByLegacy (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN BOOL bStart)
 
MMRESULT WdmAudGetDeviceInterfaceStringByLegacy (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN LPWSTR Interface, IN DWORD InterfaceLength, OUT DWORD *InterfaceSize)
 
MMRESULT WdmAudGetWavePositionByLegacy (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMTIME *Time)
 
MMRESULT WdmAudGetVolumeByLegacy (_In_ PSOUND_DEVICE_INSTANCE SoundDeviceInstance, _In_ DWORD DeviceId, _Out_ PDWORD pdwVolume)
 
MMRESULT WdmAudSetVolumeByLegacy (_In_ PSOUND_DEVICE_INSTANCE SoundDeviceInstance, _In_ DWORD DeviceId, _In_ DWORD dwVolume)
 
MMRESULT WdmAudResetStreamByLegacy (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMDEVICE_TYPE DeviceType, IN BOOLEAN bStartReset)
 
MMRESULT WdmAudQueryMixerInfoByLegacy (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN DWORD DeviceId, IN UINT uMsg, IN LPVOID Parameter, IN DWORD Flags)
 

Variables

HANDLE KernelHandle = INVALID_HANDLE_VALUE
 
DWORD OpenCount = 0
 

Macro Definition Documentation

◆ KERNEL_DEVICE_NAME

#define KERNEL_DEVICE_NAME   L"\\\\.\\wdmaud"

Definition at line 22 of file legacy.c.

◆ NDEBUG

#define NDEBUG

Definition at line 18 of file legacy.c.

Function Documentation

◆ LegacyCompletionRoutine()

VOID CALLBACK LegacyCompletionRoutine ( IN DWORD  dwErrorCode,
IN DWORD  dwNumberOfBytesTransferred,
IN LPOVERLAPPED  lpOverlapped 
)

Definition at line 597 of file legacy.c.

601{
602 PSOUND_OVERLAPPED Overlap;
603 PWDMAUD_DEVICE_INFO DeviceInfo;
604
605 Overlap = (PSOUND_OVERLAPPED)lpOverlapped;
606 DeviceInfo = (PWDMAUD_DEVICE_INFO)Overlap->CompletionContext;
607
608 /* Call mmebuddy overlap routine */
609 Overlap->OriginalCompletionRoutine(dwErrorCode, DeviceInfo->Header.DataUsed, lpOverlapped);
610
611 HeapFree(GetProcessHeap(), 0, DeviceInfo);
612}
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
PSOUND_OVERLAPPED
struct _SOUND_OVERLAPPED * PSOUND_OVERLAPPED
lpOverlapped
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:93
WDMAUD_DEVICE_INFO
Definition: interface.h:26
_SOUND_OVERLAPPED
Definition: mmebuddy.h:119
_SOUND_OVERLAPPED::CompletionContext
PVOID CompletionContext
Definition: mmebuddy.h:125
_SOUND_OVERLAPPED::OriginalCompletionRoutine
LPOVERLAPPED_COMPLETION_ROUTINE OriginalCompletionRoutine
Definition: mmebuddy.h:124
PWDMAUD_DEVICE_INFO
struct WDMAUD_DEVICE_INFO * PWDMAUD_DEVICE_INFO

Referenced by WdmAudCommitWaveBufferByLegacy().

◆ MixerEventThreadRoutine()

DWORD WINAPI MixerEventThreadRoutine ( LPVOID  Parameter)

Definition at line 29 of file legacy.c.

31{
32 HANDLE WaitObjects[2];
33 DWORD dwResult;
34 MMRESULT Result;
35 WDMAUD_DEVICE_INFO DeviceInfo;
36 PSOUND_DEVICE_INSTANCE Instance = (PSOUND_DEVICE_INSTANCE)Parameter;
37
38 /* setup wait objects */
39 WaitObjects[0] = Instance->hNotifyEvent;
40 WaitObjects[1] = Instance->hStopEvent;
41
42 /* zero device info */
43 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
44
45 DeviceInfo.hDevice = Instance->Handle;
46 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
47
48 do
49 {
50 dwResult = WaitForMultipleObjects(2, WaitObjects, FALSE, INFINITE);
51
52 if (dwResult == WAIT_OBJECT_0 + 1)
53 {
54 /* stop event was signalled */
55 break;
56 }
57
58 do
59 {
60 Result = SyncOverlappedDeviceIoControl(KernelHandle,
61 IOCTL_GET_MIXER_EVENT,
62 (LPVOID) &DeviceInfo,
63 sizeof(WDMAUD_DEVICE_INFO),
64 (LPVOID) &DeviceInfo,
65 sizeof(WDMAUD_DEVICE_INFO),
66 NULL);
67
68 if (Result == MMSYSERR_NOERROR)
69 {
70 DriverCallback(Instance->WinMM.ClientCallback,
71 HIWORD(Instance->WinMM.Flags),
72 Instance->WinMM.Handle,
73 DeviceInfo.u.MixerEvent.NotificationType,
74 Instance->WinMM.ClientCallbackInstanceData,
75 (DWORD_PTR)DeviceInfo.u.MixerEvent.Value,
76 0);
77 }
78 }while(Result == MMSYSERR_NOERROR);
79 }while(TRUE);
80
81 /* done */
82 return 0;
83}
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
SyncOverlappedDeviceIoControl
DWORD SyncOverlappedDeviceIoControl(IN HANDLE Handle, IN DWORD IoControlCode, IN LPVOID InBuffer, IN DWORD InBufferSize, OUT LPVOID OutBuffer, IN DWORD OutBufferSize, OUT LPDWORD BytesTransferred OPTIONAL)
Definition: misc.c:298
DriverCallback
BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
KernelHandle
HANDLE KernelHandle
Definition: legacy.c:24
INFINITE
#define INFINITE
Definition: serial.h:102
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
ZeroMemory
#define ZeroMemory
Definition: minwinbase.h:31
PSOUND_DEVICE_INSTANCE
struct _SOUND_DEVICE_INSTANCE * PSOUND_DEVICE_INSTANCE
MMRESULT
UINT MMRESULT
Definition: mmsystem.h:962
MMSYSERR_NOERROR
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
MIXER_DEVICE_TYPE
@ MIXER_DEVICE_TYPE
Definition: sndtypes.h:33
_SOUND_DEVICE_INSTANCE
Definition: mmebuddy.h:280
WaitForMultipleObjects
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151
DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65
HIWORD
#define HIWORD(l)
Definition: typedefs.h:247
Instance
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_WMI_INSTANCE_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_opt_ WDFWMIINSTANCE * Instance
Definition: wdfwmi.h:481
IOCTL_GET_MIXER_EVENT
#define IOCTL_GET_MIXER_EVENT
Definition: interface.h:359
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383
Result
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Parameter
_Inout_opt_ PVOID Parameter
Definition: rtltypes.h:336

Referenced by WdmAudSetMixerDeviceFormatByLegacy().

◆ WdmAudCleanupByLegacy()

MMRESULT WdmAudCleanupByLegacy ( )

Definition at line 86 of file legacy.c.

87{
88 if (KernelHandle != INVALID_HANDLE_VALUE)
89 {
90 CloseHandle(KernelHandle);
91 KernelHandle = INVALID_HANDLE_VALUE;
92 }
93
94 return MMSYSERR_NOERROR;
95}
CloseHandle
#define CloseHandle
Definition: compat.h:739
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731

◆ WdmAudCloseSoundDeviceByLegacy()

MMRESULT WdmAudCloseSoundDeviceByLegacy ( IN struct _SOUND_DEVICE_INSTANCE *  SoundDeviceInstance,
IN PVOID  Handle 
)

Definition at line 320 of file legacy.c.

323{
324 WDMAUD_DEVICE_INFO DeviceInfo;
325 MMRESULT Result;
326 MMDEVICE_TYPE DeviceType;
327 PSOUND_DEVICE SoundDevice;
328
329 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
330
331 if ( ! MMSUCCESS(Result) )
332 {
333 return TranslateInternalMmResult(Result);
334 }
335
336 if ( OpenCount == 0 )
337 {
338 return MMSYSERR_NOERROR;
339 }
340
341 SND_ASSERT( KernelHandle != INVALID_HANDLE_VALUE );
342
343 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
344 SND_ASSERT( Result == MMSYSERR_NOERROR );
345
346 if (SoundDeviceInstance->Handle != (PVOID)KernelHandle)
347 {
348 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
349
350 DeviceInfo.DeviceType = DeviceType;
351 DeviceInfo.hDevice = SoundDeviceInstance->Handle;
352
353 /* First stop the stream */
354 if (DeviceType != MIXER_DEVICE_TYPE)
355 {
356 DeviceInfo.u.State = KSSTATE_PAUSE;
357 SyncOverlappedDeviceIoControl(KernelHandle,
358 IOCTL_SETDEVICE_STATE,
359 (LPVOID) &DeviceInfo,
360 sizeof(WDMAUD_DEVICE_INFO),
361 (LPVOID) &DeviceInfo,
362 sizeof(WDMAUD_DEVICE_INFO),
363 NULL);
364
365 DeviceInfo.u.State = KSSTATE_ACQUIRE;
366 SyncOverlappedDeviceIoControl(KernelHandle,
367 IOCTL_SETDEVICE_STATE,
368 (LPVOID) &DeviceInfo,
369 sizeof(WDMAUD_DEVICE_INFO),
370 (LPVOID) &DeviceInfo,
371 sizeof(WDMAUD_DEVICE_INFO),
372 NULL);
373
374
375 DeviceInfo.u.State = KSSTATE_STOP;
376 SyncOverlappedDeviceIoControl(KernelHandle,
377 IOCTL_SETDEVICE_STATE,
378 (LPVOID) &DeviceInfo,
379 sizeof(WDMAUD_DEVICE_INFO),
380 (LPVOID) &DeviceInfo,
381 sizeof(WDMAUD_DEVICE_INFO),
382 NULL);
383 }
384
385 SyncOverlappedDeviceIoControl(KernelHandle,
386 IOCTL_CLOSE_WDMAUD,
387 (LPVOID) &DeviceInfo,
388 sizeof(WDMAUD_DEVICE_INFO),
389 (LPVOID) &DeviceInfo,
390 sizeof(WDMAUD_DEVICE_INFO),
391 NULL);
392 }
393
394 if (DeviceType == MIXER_DEVICE_TYPE)
395 {
396 SetEvent(SoundDeviceInstance->hStopEvent);
397 CloseHandle(SoundDeviceInstance->hStopEvent);
398 CloseHandle(SoundDeviceInstance->hNotifyEvent);
399 }
400
401 --OpenCount;
402
403 if ( OpenCount < 1 )
404 {
405 CloseHandle(KernelHandle);
406 KernelHandle = INVALID_HANDLE_VALUE;
407 }
408
409 return MMSYSERR_NOERROR;
410}
OpenCount
DWORD OpenCount
Definition: legacy.c:25
KSSTATE_ACQUIRE
@ KSSTATE_ACQUIRE
Definition: ks.h:1216
KSSTATE_PAUSE
@ KSSTATE_PAUSE
Definition: ks.h:1217
KSSTATE_STOP
@ KSSTATE_STOP
Definition: ks.h:1215
DeviceType
DeviceType
Definition: mmdrv.h:42
MMDEVICE_TYPE
UCHAR MMDEVICE_TYPE
Definition: mmebuddy.h:88
GetSoundDeviceFromInstance
MMRESULT GetSoundDeviceFromInstance(IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, OUT PSOUND_DEVICE *SoundDevice)
Definition: deviceinstance.c:325
TranslateInternalMmResult
MMRESULT TranslateInternalMmResult(IN MMRESULT Result)
Definition: utility.c:132
GetSoundDeviceType
MMRESULT GetSoundDeviceType(IN PSOUND_DEVICE SoundDevice, OUT PMMDEVICE_TYPE DeviceType)
Definition: devicelist.c:346
MMSUCCESS
#define MMSUCCESS(result)
Definition: mmebuddy.h:80
SND_ASSERT
#define SND_ASSERT(condition)
Definition: mmebuddy_debug.h:41
_SOUND_DEVICE
Definition: mmebuddy.h:269
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
IOCTL_CLOSE_WDMAUD
#define IOCTL_CLOSE_WDMAUD
Definition: interface.h:99
IOCTL_SETDEVICE_STATE
#define IOCTL_SETDEVICE_STATE
Definition: interface.h:134

◆ WdmAudCommitWaveBufferByLegacy()

MMRESULT WdmAudCommitWaveBufferByLegacy ( IN PSOUND_DEVICE_INSTANCE  SoundDeviceInstance,
IN PVOID  OffsetPtr,
IN DWORD  Length,
IN PSOUND_OVERLAPPED  Overlap,
IN LPOVERLAPPED_COMPLETION_ROUTINE  CompletionRoutine 
)

Definition at line 615 of file legacy.c.

621{
622 HANDLE Handle;
623 MMRESULT Result;
624 PWDMAUD_DEVICE_INFO DeviceInfo;
625 PSOUND_DEVICE SoundDevice;
626 MMDEVICE_TYPE DeviceType;
627 BOOL Ret;
628
629 VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
630 VALIDATE_MMSYS_PARAMETER( OffsetPtr );
631 VALIDATE_MMSYS_PARAMETER( Overlap );
632 VALIDATE_MMSYS_PARAMETER( CompletionRoutine );
633
634 GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
635 SND_ASSERT(Handle);
636
637 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
638
639 if ( ! MMSUCCESS(Result) )
640 {
641 return TranslateInternalMmResult(Result);
642 }
643
644 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
645 SND_ASSERT( Result == MMSYSERR_NOERROR );
646
647 DeviceInfo = (PWDMAUD_DEVICE_INFO)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WDMAUD_DEVICE_INFO));
648 if (!DeviceInfo)
649 {
650 // no memory
651 return MMSYSERR_NOMEM;
652 }
653
654 DeviceInfo->Header.FrameExtent = Length;
655 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
656 {
657 DeviceInfo->Header.DataUsed = Length;
658 }
659 DeviceInfo->Header.Data = OffsetPtr;
660 DeviceInfo->Header.Size = sizeof(WDMAUD_DEVICE_INFO);
661 DeviceInfo->Header.PresentationTime.Numerator = 1;
662 DeviceInfo->Header.PresentationTime.Denominator = 1;
663 DeviceInfo->hDevice = Handle;
664 DeviceInfo->DeviceType = DeviceType;
665
666
667 // create completion event
668 Overlap->Standard.hEvent = Handle = CreateEventW(NULL, FALSE, FALSE, NULL);
669 if (Overlap->Standard.hEvent == NULL)
670 {
671 // no memory
672 HeapFree(GetProcessHeap(), 0, DeviceInfo);
673 return MMSYSERR_NOMEM;
674 }
675
676 Overlap->OriginalCompletionRoutine = CompletionRoutine;
677 Overlap->CompletionContext = (PVOID)DeviceInfo;
678
679 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
680 {
681 Ret = WriteFileEx(KernelHandle, DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, LegacyCompletionRoutine);
682 if (Ret)
683 WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
684 }
685 else if (DeviceType == WAVE_IN_DEVICE_TYPE)
686 {
687 Ret = ReadFileEx(KernelHandle, DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, LegacyCompletionRoutine);
688 if (Ret)
689 WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
690 }
691
692 // close event handle
693 CloseHandle(Handle);
694
695 return MMSYSERR_NOERROR;
696}
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
ReadFileEx
BOOL WINAPI ReadFileEx(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead OPTIONAL, IN LPOVERLAPPED lpOverlapped, IN LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
Definition: rw.c:299
WriteFileEx
BOOL WINAPI WriteFileEx(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, IN LPOVERLAPPED lpOverlapped, IN LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
Definition: rw.c:262
LegacyCompletionRoutine
VOID CALLBACK LegacyCompletionRoutine(IN DWORD dwErrorCode, IN DWORD dwNumberOfBytesTransferred, IN LPOVERLAPPED lpOverlapped)
Definition: legacy.c:597
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
Handle
ULONG Handle
Definition: gdb_input.c:15
VALIDATE_MMSYS_PARAMETER
#define VALIDATE_MMSYS_PARAMETER(parameter_condition)
Definition: mmebuddy.h:71
GetSoundDeviceInstanceHandle
MMRESULT GetSoundDeviceInstanceHandle(IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, OUT PVOID *Handle)
Definition: deviceinstance.c:338
MMSYSERR_NOMEM
#define MMSYSERR_NOMEM
Definition: mmsystem.h:103
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
WAVE_IN_DEVICE_TYPE
@ WAVE_IN_DEVICE_TYPE
Definition: sndtypes.h:28
WAVE_OUT_DEVICE_TYPE
@ WAVE_OUT_DEVICE_TYPE
Definition: sndtypes.h:29
DeviceInfo::Data
WCHAR Data[ANYSIZE_ARRAY]
Definition: setupapi_private.h:187
_OVERLAPPED
Definition: minwinbase.h:218
WaitForSingleObjectEx
DWORD WINAPI WaitForSingleObjectEx(IN HANDLE hHandle, IN DWORD dwMilliseconds, IN BOOL bAlertable)
Definition: synch.c:94
CreateEventW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
PVOID
void * PVOID
Definition: typedefs.h:50
CompletionRoutine
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine
Definition: wdfrequest.h:895

◆ WdmAudGetCapabilitiesByLegacy()

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

Definition at line 133 of file legacy.c.

138{
139 MMRESULT Result;
140 MMDEVICE_TYPE DeviceType;
141 WDMAUD_DEVICE_INFO DeviceInfo;
142
143 SND_ASSERT( SoundDevice );
144 SND_ASSERT( Capabilities );
145
146 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
147 SND_ASSERT( Result == MMSYSERR_NOERROR );
148
149 if ( ! MMSUCCESS(Result) )
150 return Result;
151
152 SND_TRACE(L"WDMAUD - GetWdmDeviceCapabilities DeviceType %u DeviceId %u\n", DeviceType, DeviceId);
153
154 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
155 DeviceInfo.DeviceType = DeviceType;
156 DeviceInfo.DeviceIndex = DeviceId;
157
158 Result = SyncOverlappedDeviceIoControl(KernelHandle,
159 IOCTL_GETCAPABILITIES,
160 (LPVOID) &DeviceInfo,
161 sizeof(WDMAUD_DEVICE_INFO),
162 (LPVOID) &DeviceInfo,
163 sizeof(WDMAUD_DEVICE_INFO),
164 NULL);
165
166 if ( ! MMSUCCESS(Result) )
167 {
168 return TranslateInternalMmResult(Result);
169 }
170
171 /* This is pretty much a big hack right now */
172 switch ( DeviceType )
173 {
174 case MIXER_DEVICE_TYPE:
175 {
176 LPMIXERCAPSW MixerCaps = (LPMIXERCAPSW) Capabilities;
177
178 DeviceInfo.u.MixCaps.szPname[MAXPNAMELEN-1] = L'\0';
179 CopyWideString(MixerCaps->szPname, DeviceInfo.u.MixCaps.szPname);
180
181 MixerCaps->cDestinations = DeviceInfo.u.MixCaps.cDestinations;
182 MixerCaps->fdwSupport = DeviceInfo.u.MixCaps.fdwSupport;
183 MixerCaps->vDriverVersion = DeviceInfo.u.MixCaps.vDriverVersion;
184 MixerCaps->wMid = DeviceInfo.u.MixCaps.wMid;
185 MixerCaps->wPid = DeviceInfo.u.MixCaps.wPid;
186 break;
187 }
188 case WAVE_OUT_DEVICE_TYPE :
189 {
190 LPWAVEOUTCAPSW WaveOutCaps = (LPWAVEOUTCAPSW) Capabilities;
191
192 DeviceInfo.u.WaveOutCaps.szPname[MAXPNAMELEN-1] = L'\0';
193 WaveOutCaps->wMid = DeviceInfo.u.WaveOutCaps.wMid;
194 WaveOutCaps->wPid = DeviceInfo.u.WaveOutCaps.wPid;
195
196 WaveOutCaps->vDriverVersion = DeviceInfo.u.WaveOutCaps.vDriverVersion;
197 CopyWideString(WaveOutCaps->szPname, DeviceInfo.u.WaveOutCaps.szPname);
198
199 WaveOutCaps->dwFormats = DeviceInfo.u.WaveOutCaps.dwFormats;
200 WaveOutCaps->wChannels = DeviceInfo.u.WaveOutCaps.wChannels;
201 WaveOutCaps->dwSupport = DeviceInfo.u.WaveOutCaps.dwSupport;
202 break;
203 }
204 case WAVE_IN_DEVICE_TYPE :
205 {
206 LPWAVEINCAPSW WaveInCaps = (LPWAVEINCAPSW) Capabilities;
207
208 DeviceInfo.u.WaveInCaps.szPname[MAXPNAMELEN-1] = L'\0';
209
210 WaveInCaps->wMid = DeviceInfo.u.WaveInCaps.wMid;
211 WaveInCaps->wPid = DeviceInfo.u.WaveInCaps.wPid;
212
213 WaveInCaps->vDriverVersion = DeviceInfo.u.WaveInCaps.vDriverVersion;
214 CopyWideString(WaveInCaps->szPname, DeviceInfo.u.WaveInCaps.szPname);
215
216 WaveInCaps->dwFormats = DeviceInfo.u.WaveInCaps.dwFormats;
217 WaveInCaps->wChannels = DeviceInfo.u.WaveInCaps.wChannels;
218 WaveInCaps->wReserved1 = 0;
219 break;
220 }
221 case MIDI_IN_DEVICE_TYPE :
222 {
223 LPMIDIINCAPSW MidiInCaps = (LPMIDIINCAPSW)Capabilities;
224
225 DeviceInfo.u.MidiInCaps.szPname[MAXPNAMELEN-1] = L'\0';
226
227 MidiInCaps->vDriverVersion = DeviceInfo.u.MidiInCaps.vDriverVersion;
228 MidiInCaps->wMid = DeviceInfo.u.MidiInCaps.wMid;
229 MidiInCaps->wPid = DeviceInfo.u.MidiInCaps.wPid;
230 MidiInCaps->dwSupport = DeviceInfo.u.MidiInCaps.dwSupport;
231
232 CopyWideString(MidiInCaps->szPname, DeviceInfo.u.MidiInCaps.szPname);
233 break;
234 }
235 case MIDI_OUT_DEVICE_TYPE :
236 {
237 LPMIDIOUTCAPSW MidiOutCaps = (LPMIDIOUTCAPSW)Capabilities;
238
239 DeviceInfo.u.MidiOutCaps.szPname[MAXPNAMELEN-1] = L'\0';
240
241 MidiOutCaps->vDriverVersion = DeviceInfo.u.MidiOutCaps.vDriverVersion;
242 MidiOutCaps->wMid = DeviceInfo.u.MidiOutCaps.wMid;
243 MidiOutCaps->wPid = DeviceInfo.u.MidiOutCaps.wPid;
244 MidiOutCaps->dwSupport = DeviceInfo.u.MidiOutCaps.dwSupport;
245
246 CopyWideString(MidiOutCaps->szPname, DeviceInfo.u.MidiOutCaps.szPname);
247 break;
248 }
249 }
250
251 return MMSYSERR_NOERROR;
252}
L
#define L(x)
Definition: resources.c:13
Capabilities
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
CopyWideString
#define CopyWideString(dest, source)
Definition: mmebuddy.h:39
SND_TRACE
#define SND_TRACE(...)
Definition: mmebuddy_debug.h:77
LPMIXERCAPSW
struct tagMIXERCAPSW * LPMIXERCAPSW
LPWAVEINCAPSW
struct tagWAVEINCAPSW * LPWAVEINCAPSW
LPMIDIOUTCAPSW
struct tagMIDIOUTCAPSW * LPMIDIOUTCAPSW
LPMIDIINCAPSW
struct tagMIDIINCAPSW * LPMIDIINCAPSW
MAXPNAMELEN
#define MAXPNAMELEN
Definition: mmsystem.h:24
LPWAVEOUTCAPSW
struct tagWAVEOUTCAPSW * LPWAVEOUTCAPSW
MIDI_OUT_DEVICE_TYPE
@ MIDI_OUT_DEVICE_TYPE
Definition: sndtypes.h:31
MIDI_IN_DEVICE_TYPE
@ MIDI_IN_DEVICE_TYPE
Definition: sndtypes.h:30
tagMIDIINCAPSW::vDriverVersion
MMVERSION vDriverVersion
Definition: mmsystem.h:1145
tagMIDIINCAPSW::dwSupport
DWORD dwSupport
Definition: mmsystem.h:1147
tagMIDIINCAPSW::szPname
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1146
tagMIDIOUTCAPSW::vDriverVersion
MMVERSION vDriverVersion
Definition: mmsystem.h:1125
tagMIDIOUTCAPSW::szPname
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1126
tagMIXERCAPSW::cDestinations
DWORD cDestinations
Definition: mmsystem.h:1228
tagMIXERCAPSW::vDriverVersion
MMVERSION vDriverVersion
Definition: mmsystem.h:1225
tagMIXERCAPSW::fdwSupport
DWORD fdwSupport
Definition: mmsystem.h:1227
tagMIXERCAPSW::szPname
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1226
tagWAVEINCAPSW::szPname
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1060
tagWAVEINCAPSW::vDriverVersion
MMVERSION vDriverVersion
Definition: mmsystem.h:1059
tagWAVEINCAPSW::dwFormats
DWORD dwFormats
Definition: mmsystem.h:1061
tagWAVEOUTCAPSW::vDriverVersion
MMVERSION vDriverVersion
Definition: mmsystem.h:1038
tagWAVEOUTCAPSW::szPname
WCHAR szPname[MAXPNAMELEN]
Definition: mmsystem.h:1039
IOCTL_GETCAPABILITIES
#define IOCTL_GETCAPABILITIES
Definition: interface.h:204

◆ WdmAudGetDeviceInterfaceStringByLegacy()

MMRESULT WdmAudGetDeviceInterfaceStringByLegacy ( IN MMDEVICE_TYPE  DeviceType,
IN DWORD  DeviceId,
IN LPWSTR  Interface,
IN DWORD  InterfaceLength,
OUT DWORD *  InterfaceSize 
)

Definition at line 742 of file legacy.c.

748{
749 WDMAUD_DEVICE_INFO DeviceInfo;
750 MMRESULT Result;
751
752 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
753 DeviceInfo.DeviceType = DeviceType;
754 DeviceInfo.DeviceIndex = DeviceId;
755
756
757 Result = SyncOverlappedDeviceIoControl(KernelHandle,
758 IOCTL_QUERYDEVICEINTERFACESTRING,
759 (LPVOID) &DeviceInfo,
760 sizeof(WDMAUD_DEVICE_INFO),
761 (LPVOID) &DeviceInfo,
762 sizeof(WDMAUD_DEVICE_INFO),
763 NULL);
764
765
766 if ( ! MMSUCCESS(Result) )
767 {
768 return TranslateInternalMmResult(Result);
769 }
770
771
772 if (!Interface)
773 {
774 SND_ASSERT(InterfaceSize);
775
776 *InterfaceSize = DeviceInfo.u.Interface.DeviceInterfaceStringSize;
777 return MMSYSERR_NOERROR;
778 }
779
780 if (InterfaceLength < DeviceInfo.u.Interface.DeviceInterfaceStringSize)
781 {
782 /* buffer is too small */
783 return MMSYSERR_MOREDATA;
784 }
785
786 DeviceInfo.u.Interface.DeviceInterfaceStringSize = InterfaceLength;
787 DeviceInfo.u.Interface.DeviceInterfaceString = Interface;
788
789 Result = SyncOverlappedDeviceIoControl(KernelHandle,
790 IOCTL_QUERYDEVICEINTERFACESTRING,
791 (LPVOID) &DeviceInfo,
792 sizeof(WDMAUD_DEVICE_INFO),
793 (LPVOID) &DeviceInfo,
794 sizeof(WDMAUD_DEVICE_INFO),
795 NULL);
796
797 if ( MMSUCCESS(Result) && InterfaceLength > 2)
798 {
799 Interface[1] = L'\\';
800 Interface[InterfaceLength-1] = L'\0';
801 }
802
803 return Result;
804}
MMSYSERR_MOREDATA
#define MMSYSERR_MOREDATA
Definition: mmsystem.h:117
Interface
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
IOCTL_QUERYDEVICEINTERFACESTRING
#define IOCTL_QUERYDEVICEINTERFACESTRING
Definition: interface.h:343

◆ WdmAudGetNumWdmDevsByLegacy()

MMRESULT WdmAudGetNumWdmDevsByLegacy ( IN MMDEVICE_TYPE  DeviceType,
OUT DWORD *  DeviceCount 
)

Definition at line 98 of file legacy.c.

101{
102 MMRESULT Result;
103 WDMAUD_DEVICE_INFO DeviceInfo;
104
105 VALIDATE_MMSYS_PARAMETER( KernelHandle != INVALID_HANDLE_VALUE );
106 VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
107 VALIDATE_MMSYS_PARAMETER( DeviceCount );
108
109 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
110 DeviceInfo.DeviceType = DeviceType;
111
112 Result = SyncOverlappedDeviceIoControl(KernelHandle,
113 IOCTL_GETNUMDEVS_TYPE,
114 (LPVOID) &DeviceInfo,
115 sizeof(WDMAUD_DEVICE_INFO),
116 (LPVOID) &DeviceInfo,
117 sizeof(WDMAUD_DEVICE_INFO),
118 NULL);
119
120 if ( ! MMSUCCESS( Result ) )
121 {
122 SND_ERR(L"Call to IOCTL_GETNUMDEVS_TYPE failed\n");
123 *DeviceCount = 0;
124 return TranslateInternalMmResult(Result);
125 }
126
127 *DeviceCount = DeviceInfo.DeviceCount;
128
129 return MMSYSERR_NOERROR;
130}
SND_ERR
#define SND_ERR(...)
Definition: mmebuddy_debug.h:40
DeviceCount
ULONG DeviceCount
Definition: mpu401.c:26
IS_VALID_SOUND_DEVICE_TYPE
#define IS_VALID_SOUND_DEVICE_TYPE(x)
Definition: sndtypes.h:43
IOCTL_GETNUMDEVS_TYPE
#define IOCTL_GETNUMDEVS_TYPE
Definition: interface.h:117

◆ WdmAudGetVolumeByLegacy()

MMRESULT WdmAudGetVolumeByLegacy ( _In_ PSOUND_DEVICE_INSTANCE  SoundDeviceInstance,
_In_ DWORD  DeviceId,
_Out_ PDWORD  pdwVolume 
)

Definition at line 854 of file legacy.c.

858{
859 /* FIXME */
860 return MMSYSERR_NOTSUPPORTED;
861}
MMSYSERR_NOTSUPPORTED
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104

◆ WdmAudGetWavePositionByLegacy()

MMRESULT WdmAudGetWavePositionByLegacy ( IN struct _SOUND_DEVICE_INSTANCE *  SoundDeviceInstance,
IN MMTIME *  Time 
)

Definition at line 807 of file legacy.c.

810{
811 MMRESULT Result;
812 PSOUND_DEVICE SoundDevice;
813 WDMAUD_DEVICE_INFO DeviceInfo;
814 MMDEVICE_TYPE DeviceType;
815 HANDLE Handle;
816
817 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
818
819 if ( ! MMSUCCESS(Result) )
820 {
821 return TranslateInternalMmResult(Result);
822 }
823
824 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
825 SND_ASSERT( Result == MMSYSERR_NOERROR );
826
827 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
828 SND_ASSERT( Result == MMSYSERR_NOERROR );
829
830 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
831 DeviceInfo.hDevice = Handle;
832 DeviceInfo.DeviceType = DeviceType;
833
834 Result = SyncOverlappedDeviceIoControl(KernelHandle,
835 IOCTL_GETPOS,
836 (LPVOID) &DeviceInfo,
837 sizeof(WDMAUD_DEVICE_INFO),
838 (LPVOID) &DeviceInfo,
839 sizeof(WDMAUD_DEVICE_INFO),
840 NULL);
841
842 if ( ! MMSUCCESS(Result) )
843 {
844 return TranslateInternalMmResult(Result);
845 }
846
847 Time->wType = TIME_BYTES;
848 Time->u.cb = (DWORD)DeviceInfo.u.Position;
849
850 return MMSYSERR_NOERROR;
851}
TIME_BYTES
#define TIME_BYTES
Definition: mmsystem.h:30
Time
static PLARGE_INTEGER Time
Definition: time.c:105
DWORD
#define DWORD
Definition: nt_native.h:44
_LARGE_INTEGER::u
struct _LARGE_INTEGER::@2479 u
IOCTL_GETPOS
#define IOCTL_GETPOS
Definition: interface.h:238

◆ WdmAudOpenSoundDeviceByLegacy()

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

Definition at line 255 of file legacy.c.

258{
259 HDEVINFO hDevInfo;
260 SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
261 GUID SWBusGuid = {STATIC_KSCATEGORY_WDMAUD};
262 PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData;
263
264 if ( KernelHandle == INVALID_HANDLE_VALUE )
265 {
266 hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, DIGCF_DEVICEINTERFACE| DIGCF_PRESENT);
267 if (!hDevInfo)
268 {
269 // failed
270 return MMSYSERR_ERROR;
271 }
272
273 DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
274 if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
275 {
276 // failed
277 SetupDiDestroyDeviceInfoList(hDevInfo);
278 return MMSYSERR_ERROR;
279 }
280
281 DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W));
282 if (!DeviceInterfaceDetailData)
283 {
284 // failed
285 SetupDiDestroyDeviceInfoList(hDevInfo);
286 return MMSYSERR_ERROR;
287 }
288
289 DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
290 if (!SetupDiGetDeviceInterfaceDetailW(hDevInfo, &DeviceInterfaceData, DeviceInterfaceDetailData,MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W), NULL, NULL))
291 {
292 // failed
293 HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
294 SetupDiDestroyDeviceInfoList(hDevInfo);
295 return MMSYSERR_ERROR;
296 }
297 SND_TRACE(L"Opening wdmaud device '%s'\n",DeviceInterfaceDetailData->DevicePath);
298 KernelHandle = CreateFileW(DeviceInterfaceDetailData->DevicePath,
299 GENERIC_READ | GENERIC_WRITE,
300 0,
301 NULL,
302 OPEN_EXISTING,
303 FILE_FLAG_OVERLAPPED,
304 NULL);
305
306 HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
307 SetupDiDestroyDeviceInfoList(hDevInfo);
308 }
309
310
311 if ( KernelHandle == INVALID_HANDLE_VALUE )
312 return MMSYSERR_ERROR;
313
314 ++ OpenCount;
315 return MMSYSERR_NOERROR;
316
317}
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
CreateFileW
#define CreateFileW
Definition: compat.h:741
SetupDiEnumDeviceInterfaces
BOOL WINAPI SetupDiEnumDeviceInterfaces(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, CONST GUID *InterfaceClassGuid, DWORD MemberIndex, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
Definition: devinst.c:2780
SetupDiGetClassDevsW
HDEVINFO WINAPI SetupDiGetClassDevsW(CONST GUID *class, LPCWSTR enumstr, HWND parent, DWORD flags)
Definition: devinst.c:2292
SetupDiGetDeviceInterfaceDetailW
BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData, DWORD DeviceInterfaceDetailDataSize, PDWORD RequiredSize, PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:3011
SetupDiDestroyDeviceInfoList
BOOL WINAPI SetupDiDestroyDeviceInfoList(HDEVINFO devinfo)
Definition: devinst.c:2893
STATIC_KSCATEGORY_WDMAUD
#define STATIC_KSCATEGORY_WDMAUD
Definition: ksmedia.h:219
MMSYSERR_ERROR
#define MMSYSERR_ERROR
Definition: mmsystem.h:97
FILE_FLAG_OVERLAPPED
#define FILE_FLAG_OVERLAPPED
Definition: disk.h:46
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
DIGCF_DEVICEINTERFACE
#define DIGCF_DEVICEINTERFACE
Definition: setupapi.h:175
SP_DEVICE_INTERFACE_DETAIL_DATA_W
struct _SP_DEVICE_INTERFACE_DETAIL_DATA_W SP_DEVICE_INTERFACE_DETAIL_DATA_W
DIGCF_PRESENT
#define DIGCF_PRESENT
Definition: setupapi.h:172
PSP_DEVICE_INTERFACE_DETAIL_DATA_W
struct _SP_DEVICE_INTERFACE_DETAIL_DATA_W * PSP_DEVICE_INTERFACE_DETAIL_DATA_W
SP_DEVICE_INTERFACE_DATA
struct _SP_DEVICE_INTERFACE_DATA SP_DEVICE_INTERFACE_DATA
_SP_DEVICE_INTERFACE_DATA
Definition: setupapi.h:841
_SP_DEVICE_INTERFACE_DATA::cbSize
DWORD cbSize
Definition: setupapi.h:842
_SP_DEVICE_INTERFACE_DETAIL_DATA_W
Definition: setupapi.h:854
_SP_DEVICE_INTERFACE_DETAIL_DATA_W::DevicePath
WCHAR DevicePath[ANYSIZE_ARRAY]
Definition: setupapi.h:856
_SP_DEVICE_INTERFACE_DETAIL_DATA_W::cbSize
DWORD cbSize
Definition: setupapi.h:855
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ WdmAudQueryMixerInfoByLegacy()

MMRESULT WdmAudQueryMixerInfoByLegacy ( IN struct _SOUND_DEVICE_INSTANCE *  SoundDeviceInstance,
IN DWORD  DeviceId,
IN UINT  uMsg,
IN LPVOID  Parameter,
IN DWORD  Flags 
)

Definition at line 902 of file legacy.c.

908{
909 MMRESULT Result;
910 WDMAUD_DEVICE_INFO DeviceInfo;
911 HANDLE Handle;
912 DWORD IoControlCode;
913 LPMIXERLINEW MixLine;
914 LPMIXERLINECONTROLSW MixControls;
915 LPMIXERCONTROLDETAILS MixDetails;
916
917 SND_TRACE(L"uMsg %x Flags %x\n", uMsg, Flags);
918
919 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
920 SND_ASSERT( Result == MMSYSERR_NOERROR );
921
922 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
923 DeviceInfo.hDevice = Handle;
924 DeviceInfo.DeviceIndex = DeviceId;
925 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
926 DeviceInfo.Flags = Flags;
927
928 MixLine = (LPMIXERLINEW)Parameter;
929 MixControls = (LPMIXERLINECONTROLSW)Parameter;
930 MixDetails = (LPMIXERCONTROLDETAILS)Parameter;
931
932 switch(uMsg)
933 {
934 case MXDM_GETLINEINFO:
935 RtlCopyMemory(&DeviceInfo.u.MixLine, MixLine, sizeof(MIXERLINEW));
936 IoControlCode = IOCTL_GETLINEINFO;
937 break;
938 case MXDM_GETLINECONTROLS:
939 RtlCopyMemory(&DeviceInfo.u.MixControls, MixControls, sizeof(MIXERLINECONTROLSW));
940 IoControlCode = IOCTL_GETLINECONTROLS;
941 break;
942 case MXDM_SETCONTROLDETAILS:
943 RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
944 IoControlCode = IOCTL_SETCONTROLDETAILS;
945 break;
946 case MXDM_GETCONTROLDETAILS:
947 RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
948 IoControlCode = IOCTL_GETCONTROLDETAILS;
949 break;
950 default:
951 SND_ASSERT(0);
952 return MMSYSERR_NOTSUPPORTED;
953 }
954
955 Result = SyncOverlappedDeviceIoControl(KernelHandle,
956 IoControlCode,
957 (LPVOID) &DeviceInfo,
958 sizeof(WDMAUD_DEVICE_INFO),
959 (LPVOID) &DeviceInfo,
960 sizeof(WDMAUD_DEVICE_INFO),
961 NULL);
962
963 if ( ! MMSUCCESS(Result) )
964 {
965 return Result;
966 }
967
968 switch(uMsg)
969 {
970 case MXDM_GETLINEINFO:
971 {
972 RtlCopyMemory(MixLine, &DeviceInfo.u.MixLine, sizeof(MIXERLINEW));
973 break;
974 }
975 }
976
977 return Result;
978}
MXDM_GETCONTROLDETAILS
#define MXDM_GETCONTROLDETAILS
Definition: mmddk.h:197
MXDM_GETLINECONTROLS
#define MXDM_GETLINECONTROLS
Definition: mmddk.h:196
MXDM_SETCONTROLDETAILS
#define MXDM_SETCONTROLDETAILS
Definition: mmddk.h:198
MXDM_GETLINEINFO
#define MXDM_GETLINEINFO
Definition: mmddk.h:195
LPMIXERLINECONTROLSW
struct tagMIXERLINECONTROLSW * LPMIXERLINECONTROLSW
LPMIXERLINEW
struct tagMIXERLINEW * LPMIXERLINEW
LPMIXERCONTROLDETAILS
struct tMIXERCONTROLDETAILS * LPMIXERCONTROLDETAILS
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
IoControlCode
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
IOCTL_GETCONTROLDETAILS
#define IOCTL_GETCONTROLDETAILS
Definition: interface.h:325
IOCTL_SETCONTROLDETAILS
#define IOCTL_SETCONTROLDETAILS
Definition: interface.h:307
IOCTL_GETLINEINFO
#define IOCTL_GETLINEINFO
Definition: interface.h:272
IOCTL_GETLINECONTROLS
#define IOCTL_GETLINECONTROLS
Definition: interface.h:290
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

◆ WdmAudResetStreamByLegacy()

MMRESULT WdmAudResetStreamByLegacy ( IN struct _SOUND_DEVICE_INSTANCE *  SoundDeviceInstance,
IN MMDEVICE_TYPE  DeviceType,
IN BOOLEAN  bStartReset 
)

Definition at line 874 of file legacy.c.

878{
879 MMRESULT Result;
880 HANDLE Handle;
881 WDMAUD_DEVICE_INFO DeviceInfo;
882
883 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
884 SND_ASSERT( Result == MMSYSERR_NOERROR );
885
886 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
887 DeviceInfo.hDevice = Handle;
888 DeviceInfo.DeviceType = DeviceType;
889 DeviceInfo.u.ResetStream = (bStartReset ? KSRESET_BEGIN : KSRESET_END);
890
891 Result = SyncOverlappedDeviceIoControl(KernelHandle,
892 IOCTL_RESET_STREAM,
893 (LPVOID) &DeviceInfo,
894 sizeof(WDMAUD_DEVICE_INFO),
895 (LPVOID) &DeviceInfo,
896 sizeof(WDMAUD_DEVICE_INFO),
897 NULL);
898 return Result;
899}
KSRESET_BEGIN
@ KSRESET_BEGIN
Definition: ks.h:1227
KSRESET_END
@ KSRESET_END
Definition: ks.h:1228
IOCTL_RESET_STREAM
#define IOCTL_RESET_STREAM
Definition: interface.h:374

◆ WdmAudSetMixerDeviceFormatByLegacy()

MMRESULT WdmAudSetMixerDeviceFormatByLegacy ( IN PSOUND_DEVICE_INSTANCE  Instance,
IN DWORD  DeviceId,
IN PWAVEFORMATEX  WaveFormat,
IN DWORD  WaveFormatSize 
)

Definition at line 413 of file legacy.c.

418{
419 MMRESULT Result;
420 WDMAUD_DEVICE_INFO DeviceInfo;
421 HANDLE hThread;
422
423 Instance->hNotifyEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
424 if ( ! Instance->hNotifyEvent )
425 return MMSYSERR_NOMEM;
426
427 if (Instance->Handle != NULL)
428 {
429 /* device is already open */
430 return MMSYSERR_NOERROR;
431 }
432
433 Instance->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
434 if ( ! Instance->hStopEvent )
435 return MMSYSERR_NOMEM;
436
437 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
438 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
439 DeviceInfo.DeviceIndex = DeviceId;
440 DeviceInfo.u.hNotifyEvent = Instance->hNotifyEvent;
441
442 Result = SyncOverlappedDeviceIoControl(KernelHandle,
443 IOCTL_OPEN_WDMAUD,
444 (LPVOID) &DeviceInfo,
445 sizeof(WDMAUD_DEVICE_INFO),
446 (LPVOID) &DeviceInfo,
447 sizeof(WDMAUD_DEVICE_INFO),
448 NULL);
449
450 if ( ! MMSUCCESS(Result) )
451 {
452 CloseHandle(Instance->hNotifyEvent);
453 CloseHandle(Instance->hStopEvent);
454 return TranslateInternalMmResult(Result);
455 }
456
457 hThread = CreateThread(NULL, 0, MixerEventThreadRoutine, (LPVOID)Instance, 0, NULL);
458 if ( hThread )
459 {
460 CloseHandle(hThread);
461 }
462
463 /* Store sound device handle instance handle */
464 Instance->Handle = (PVOID)DeviceInfo.hDevice;
465
466 return MMSYSERR_NOERROR;
467}
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
MixerEventThreadRoutine
DWORD WINAPI MixerEventThreadRoutine(LPVOID Parameter)
Definition: legacy.c:29
hThread
HANDLE hThread
Definition: wizard.c:28
IOCTL_OPEN_WDMAUD
#define IOCTL_OPEN_WDMAUD
Definition: interface.h:82

◆ WdmAudSetVolumeByLegacy()

MMRESULT WdmAudSetVolumeByLegacy ( _In_ PSOUND_DEVICE_INSTANCE  SoundDeviceInstance,
_In_ DWORD  DeviceId,
_In_ DWORD  dwVolume 
)

Definition at line 864 of file legacy.c.

868{
869 /* FIXME */
870 return MMSYSERR_NOTSUPPORTED;
871}

◆ WdmAudSetWaveDeviceFormatByLegacy()

MMRESULT WdmAudSetWaveDeviceFormatByLegacy ( IN PSOUND_DEVICE_INSTANCE  Instance,
IN DWORD  DeviceId,
IN PWAVEFORMATEX  WaveFormat,
IN DWORD  WaveFormatSize 
)

Definition at line 470 of file legacy.c.

475{
476 MMRESULT Result;
477 PSOUND_DEVICE SoundDevice;
478 PVOID Identifier;
479 WDMAUD_DEVICE_INFO DeviceInfo;
480 MMDEVICE_TYPE DeviceType;
481
482 Result = GetSoundDeviceFromInstance(Instance, &SoundDevice);
483
484 if ( ! MMSUCCESS(Result) )
485 {
486 return TranslateInternalMmResult(Result);
487 }
488
489 Result = GetSoundDeviceIdentifier(SoundDevice, &Identifier);
490
491 if ( ! MMSUCCESS(Result) )
492 {
493 return TranslateInternalMmResult(Result);
494 }
495
496 if (Instance->Handle != NULL)
497 {
498 /* device is already open */
499 return MMSYSERR_NOERROR;
500 }
501
502 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
503
504 SND_ASSERT( Result == MMSYSERR_NOERROR );
505
506 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
507 DeviceInfo.DeviceType = DeviceType;
508 DeviceInfo.DeviceIndex = DeviceId;
509 DeviceInfo.u.WaveFormatEx.cbSize = WaveFormat->cbSize;
510 DeviceInfo.u.WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
511#ifdef USERMODE_MIXER
512 DeviceInfo.u.WaveFormatEx.nChannels = 2;
513 DeviceInfo.u.WaveFormatEx.nSamplesPerSec = 44100;
514 DeviceInfo.u.WaveFormatEx.nBlockAlign = 4;
515 DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = 176400;
516 DeviceInfo.u.WaveFormatEx.wBitsPerSample = 16;
517#else
518 DeviceInfo.u.WaveFormatEx.nChannels = WaveFormat->nChannels;
519 DeviceInfo.u.WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
520 DeviceInfo.u.WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
521 DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
522 DeviceInfo.u.WaveFormatEx.wBitsPerSample = (DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec * 8) / (DeviceInfo.u.WaveFormatEx.nSamplesPerSec * DeviceInfo.u.WaveFormatEx.nChannels);
523#endif
524
525 Result = SyncOverlappedDeviceIoControl(KernelHandle,
526 IOCTL_OPEN_WDMAUD,
527 (LPVOID) &DeviceInfo,
528 sizeof(WDMAUD_DEVICE_INFO),
529 (LPVOID) &DeviceInfo,
530 sizeof(WDMAUD_DEVICE_INFO),
531 NULL);
532
533 if ( ! MMSUCCESS(Result) )
534 {
535 return TranslateInternalMmResult(Result);
536 }
537
538 if (WaveFormatSize >= sizeof(WAVEFORMAT))
539 {
540 /* Store format */
541 Instance->WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
542 Instance->WaveFormatEx.nChannels = WaveFormat->nChannels;
543 Instance->WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
544 Instance->WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
545 Instance->WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
546 }
547
548 /* store details */
549 Instance->WaveFormatEx.cbSize = WaveFormat->cbSize;
550 Instance->WaveFormatEx.wBitsPerSample = (DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec * 8) / (DeviceInfo.u.WaveFormatEx.nSamplesPerSec * DeviceInfo.u.WaveFormatEx.nChannels);
551
552 /* Store sound device handle instance handle */
553 Instance->Handle = (PVOID)DeviceInfo.hDevice;
554
555 /* Now determine framing requirements */
556 Result = SyncOverlappedDeviceIoControl(KernelHandle,
557 IOCTL_GETFRAMESIZE,
558 (LPVOID) &DeviceInfo,
559 sizeof(WDMAUD_DEVICE_INFO),
560 (LPVOID) &DeviceInfo,
561 sizeof(WDMAUD_DEVICE_INFO),
562 NULL);
563
564 if ( MMSUCCESS(Result) )
565 {
566 if (DeviceInfo.u.FrameSize)
567 {
568 Instance->FrameSize = DeviceInfo.u.FrameSize * 2;
569 Instance->BufferCount = WaveFormat->nAvgBytesPerSec / Instance->FrameSize;
570 SND_TRACE(L"FrameSize %u BufferCount %u\n", Instance->FrameSize, Instance->BufferCount);
571 }
572 }
573 else
574 {
575 // use a default of 100 buffers
576 Instance->BufferCount = 100;
577 }
578
579 /* Now acquire resources */
580 DeviceInfo.u.State = KSSTATE_ACQUIRE;
581 SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
582
583 /* pause the pin */
584 DeviceInfo.u.State = KSSTATE_PAUSE;
585 SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
586
587 /* start the pin */
588 DeviceInfo.u.State = KSSTATE_RUN;
589 SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
590
591
592 return MMSYSERR_NOERROR;
593}
Identifier
@ Identifier
Definition: asmpp.cpp:95
KSSTATE_RUN
@ KSSTATE_RUN
Definition: ks.h:1218
GetSoundDeviceIdentifier
MMRESULT GetSoundDeviceIdentifier(IN PSOUND_DEVICE SoundDevice, OUT PVOID *Identifier)
Definition: devicelist.c:328
waveformat_tag
Definition: mmsystem.h:1066
IOCTL_GETFRAMESIZE
#define IOCTL_GETFRAMESIZE
Definition: interface.h:255

◆ WdmAudSetWaveStateByLegacy()

MMRESULT WdmAudSetWaveStateByLegacy ( IN struct _SOUND_DEVICE_INSTANCE *  SoundDeviceInstance,
IN BOOL  bStart 
)

Definition at line 699 of file legacy.c.

702{
703 MMRESULT Result;
704 PSOUND_DEVICE SoundDevice;
705 WDMAUD_DEVICE_INFO DeviceInfo;
706 MMDEVICE_TYPE DeviceType;
707 HANDLE Handle;
708
709 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
710
711 if ( ! MMSUCCESS(Result) )
712 {
713 return TranslateInternalMmResult(Result);
714 }
715
716 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
717 SND_ASSERT( Result == MMSYSERR_NOERROR );
718
719 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
720 SND_ASSERT( Result == MMSYSERR_NOERROR );
721
722 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
723 DeviceInfo.hDevice = Handle;
724 DeviceInfo.DeviceType = DeviceType;
725
726 if (bStart)
727 DeviceInfo.u.State = KSSTATE_RUN;
728 else
729 DeviceInfo.u.State = KSSTATE_PAUSE;
730 Result = SyncOverlappedDeviceIoControl(KernelHandle,
731 IOCTL_SETDEVICE_STATE,
732 (LPVOID) &DeviceInfo,
733 sizeof(WDMAUD_DEVICE_INFO),
734 (LPVOID) &DeviceInfo,
735 sizeof(WDMAUD_DEVICE_INFO),
736 NULL);
737
738 return Result;
739}

Variable Documentation

◆ KernelHandle

HANDLE KernelHandle = INVALID_HANDLE_VALUE

Definition at line 24 of file legacy.c.

Referenced by CmpConvertHandleToKernelHandle(), MixerEventThreadRoutine(), NtWaitForMultipleObjects(), ObDuplicateObject(), ObpCreateHandle(), ObpCreateUnnamedHandle(), WdmAudCleanupByLegacy(), WdmAudCloseSoundDeviceByLegacy(), WdmAudCommitWaveBufferByLegacy(), WdmAudGetCapabilitiesByLegacy(), WdmAudGetDeviceInterfaceStringByLegacy(), WdmAudGetNumWdmDevsByLegacy(), WdmAudGetWavePositionByLegacy(), WdmAudOpenSoundDeviceByLegacy(), WdmAudQueryMixerInfoByLegacy(), WdmAudResetStreamByLegacy(), WdmAudSetMixerDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByLegacy(), WdmAudSetWaveStateByLegacy(), and WriteFileEx_Remixer().

◆ OpenCount

_Must_inspect_result_ _In_ PIRP _In_ ULONG OpenCount = 0

Definition at line 25 of file legacy.c.

Referenced by FsRtlOplockFsctrl(), RxCommonCleanup(), WdmAudCloseSoundDeviceByLegacy(), and WdmAudOpenSoundDeviceByLegacy().