2 * PROJECT: ReactOS Sound System
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/wdmaud.drv/wdmaud.c
6 * PURPOSE: WDM Audio Driver (User-mode part)
7 * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
10 * NOTES: Looking for wodMessage & co? You won't find them here. Try
11 * the MME Buddy library, which is where these routines are
12 * actually implemented.
20 #define KERNEL_DEVICE_NAME L"\\\\.\\wdmaud"
22 HANDLE KernelHandle
= INVALID_HANDLE_VALUE
;
27 MixerEventThreadRoutine(
30 HANDLE WaitObjects
[2];
33 WDMAUD_DEVICE_INFO DeviceInfo
;
34 PSOUND_DEVICE_INSTANCE Instance
= (PSOUND_DEVICE_INSTANCE
)Parameter
;
36 /* setup wait objects */
37 WaitObjects
[0] = Instance
->hNotifyEvent
;
38 WaitObjects
[1] = Instance
->hStopEvent
;
40 /* zero device info */
41 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
43 DeviceInfo
.hDevice
= Instance
->Handle
;
44 DeviceInfo
.DeviceType
= MIXER_DEVICE_TYPE
;
48 dwResult
= WaitForMultipleObjects(2, WaitObjects
, FALSE
, INFINITE
);
50 if (dwResult
== WAIT_OBJECT_0
+ 1)
52 /* stop event was signalled */
58 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
59 IOCTL_GET_MIXER_EVENT
,
61 sizeof(WDMAUD_DEVICE_INFO
),
63 sizeof(WDMAUD_DEVICE_INFO
),
66 if (Result
== MMSYSERR_NOERROR
)
68 DriverCallback(Instance
->WinMM
.ClientCallback
,
69 HIWORD(Instance
->WinMM
.Flags
),
70 Instance
->WinMM
.Handle
,
71 DeviceInfo
.u
.MixerEvent
.NotificationType
,
72 Instance
->WinMM
.ClientCallbackInstanceData
,
73 (DWORD_PTR
)DeviceInfo
.u
.MixerEvent
.Value
,
76 }while(Result
== MMSYSERR_NOERROR
);
84 WdmAudCleanupByLegacy()
86 if (KernelHandle
!= INVALID_HANDLE_VALUE
)
88 CloseHandle(KernelHandle
);
89 KernelHandle
= INVALID_HANDLE_VALUE
;
92 return MMSYSERR_NOERROR
;
96 WdmAudGetNumWdmDevsByLegacy(
97 IN MMDEVICE_TYPE DeviceType
,
98 OUT DWORD
* DeviceCount
)
101 WDMAUD_DEVICE_INFO DeviceInfo
;
103 VALIDATE_MMSYS_PARAMETER( KernelHandle
!= INVALID_HANDLE_VALUE
);
104 VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType
) );
105 VALIDATE_MMSYS_PARAMETER( DeviceCount
);
107 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
108 DeviceInfo
.DeviceType
= DeviceType
;
110 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
111 IOCTL_GETNUMDEVS_TYPE
,
112 (LPVOID
) &DeviceInfo
,
113 sizeof(WDMAUD_DEVICE_INFO
),
114 (LPVOID
) &DeviceInfo
,
115 sizeof(WDMAUD_DEVICE_INFO
),
118 if ( ! MMSUCCESS( Result
) )
120 SND_ERR(L
"Call to IOCTL_GETNUMDEVS_TYPE failed\n");
122 return TranslateInternalMmResult(Result
);
125 *DeviceCount
= DeviceInfo
.DeviceCount
;
127 return MMSYSERR_NOERROR
;
131 WdmAudGetCapabilitiesByLegacy(
132 IN PSOUND_DEVICE SoundDevice
,
134 OUT PVOID Capabilities
,
135 IN DWORD CapabilitiesSize
)
138 MMDEVICE_TYPE DeviceType
;
139 WDMAUD_DEVICE_INFO DeviceInfo
;
141 SND_ASSERT( SoundDevice
);
142 SND_ASSERT( Capabilities
);
144 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
145 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
147 if ( ! MMSUCCESS(Result
) )
150 SND_TRACE(L
"WDMAUD - GetWdmDeviceCapabilities DeviceType %u DeviceId %u\n", DeviceType
, DeviceId
);
152 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
153 DeviceInfo
.DeviceType
= DeviceType
;
154 DeviceInfo
.DeviceIndex
= DeviceId
;
156 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
157 IOCTL_GETCAPABILITIES
,
158 (LPVOID
) &DeviceInfo
,
159 sizeof(WDMAUD_DEVICE_INFO
),
160 (LPVOID
) &DeviceInfo
,
161 sizeof(WDMAUD_DEVICE_INFO
),
164 if ( ! MMSUCCESS(Result
) )
166 return TranslateInternalMmResult(Result
);
169 /* This is pretty much a big hack right now */
170 switch ( DeviceType
)
172 case MIXER_DEVICE_TYPE
:
174 LPMIXERCAPS MixerCaps
= (LPMIXERCAPS
) Capabilities
;
176 DeviceInfo
.u
.MixCaps
.szPname
[MAXPNAMELEN
-1] = L
'\0';
177 CopyWideString(MixerCaps
->szPname
, DeviceInfo
.u
.MixCaps
.szPname
);
179 MixerCaps
->cDestinations
= DeviceInfo
.u
.MixCaps
.cDestinations
;
180 MixerCaps
->fdwSupport
= DeviceInfo
.u
.MixCaps
.fdwSupport
;
181 MixerCaps
->vDriverVersion
= DeviceInfo
.u
.MixCaps
.vDriverVersion
;
182 MixerCaps
->wMid
= DeviceInfo
.u
.MixCaps
.wMid
;
183 MixerCaps
->wPid
= DeviceInfo
.u
.MixCaps
.wPid
;
186 case WAVE_OUT_DEVICE_TYPE
:
188 LPWAVEOUTCAPS WaveOutCaps
= (LPWAVEOUTCAPS
) Capabilities
;
190 DeviceInfo
.u
.WaveOutCaps
.szPname
[MAXPNAMELEN
-1] = L
'\0';
191 WaveOutCaps
->wMid
= DeviceInfo
.u
.WaveOutCaps
.wMid
;
192 WaveOutCaps
->wPid
= DeviceInfo
.u
.WaveOutCaps
.wPid
;
194 WaveOutCaps
->vDriverVersion
= 0x0001;
195 CopyWideString(WaveOutCaps
->szPname
, DeviceInfo
.u
.WaveOutCaps
.szPname
);
197 WaveOutCaps
->dwFormats
= DeviceInfo
.u
.WaveOutCaps
.dwFormats
;
198 WaveOutCaps
->wChannels
= DeviceInfo
.u
.WaveOutCaps
.wChannels
;
199 WaveOutCaps
->dwSupport
= DeviceInfo
.u
.WaveOutCaps
.dwSupport
;
202 case WAVE_IN_DEVICE_TYPE
:
204 LPWAVEINCAPSW WaveInCaps
= (LPWAVEINCAPSW
) Capabilities
;
206 DeviceInfo
.u
.WaveInCaps
.szPname
[MAXPNAMELEN
-1] = L
'\0';
208 WaveInCaps
->wMid
= DeviceInfo
.u
.WaveInCaps
.wMid
;
209 WaveInCaps
->wPid
= DeviceInfo
.u
.WaveInCaps
.wPid
;
211 WaveInCaps
->vDriverVersion
= 0x0001;
212 CopyWideString(WaveInCaps
->szPname
, DeviceInfo
.u
.WaveInCaps
.szPname
);
214 WaveInCaps
->dwFormats
= DeviceInfo
.u
.WaveInCaps
.dwFormats
;
215 WaveInCaps
->wChannels
= DeviceInfo
.u
.WaveInCaps
.wChannels
;
216 WaveInCaps
->wReserved1
= 0;
221 return MMSYSERR_NOERROR
;
225 WdmAudOpenSoundDeviceByLegacy()
227 /* Only open this if it's not already open */
228 if ( KernelHandle
== INVALID_HANDLE_VALUE
)
230 SND_TRACE(L
"Opening wdmaud device\n");
231 KernelHandle
= CreateFileW(KERNEL_DEVICE_NAME
,
232 GENERIC_READ
| GENERIC_WRITE
,
236 FILE_FLAG_OVERLAPPED
,
240 if ( KernelHandle
== INVALID_HANDLE_VALUE
)
241 return MMSYSERR_ERROR
;
245 return MMSYSERR_NOERROR
;
249 WdmAudCloseSoundDeviceByLegacy(
250 IN
struct _SOUND_DEVICE_INSTANCE
* SoundDeviceInstance
,
253 WDMAUD_DEVICE_INFO DeviceInfo
;
255 MMDEVICE_TYPE DeviceType
;
256 PSOUND_DEVICE SoundDevice
;
258 Result
= GetSoundDeviceFromInstance(SoundDeviceInstance
, &SoundDevice
);
260 if ( ! MMSUCCESS(Result
) )
262 return TranslateInternalMmResult(Result
);
265 if ( OpenCount
== 0 )
267 return MMSYSERR_NOERROR
;
270 SND_ASSERT( KernelHandle
!= INVALID_HANDLE_VALUE
);
272 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
273 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
275 if (SoundDeviceInstance
->Handle
!= (PVOID
)KernelHandle
)
277 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
279 DeviceInfo
.DeviceType
= DeviceType
;
280 DeviceInfo
.hDevice
= SoundDeviceInstance
->Handle
;
282 /* First stop the stream */
283 if (DeviceType
!= MIXER_DEVICE_TYPE
)
285 DeviceInfo
.u
.State
= KSSTATE_STOP
;
286 SyncOverlappedDeviceIoControl(KernelHandle
,
287 IOCTL_SETDEVICE_STATE
,
288 (LPVOID
) &DeviceInfo
,
289 sizeof(WDMAUD_DEVICE_INFO
),
290 (LPVOID
) &DeviceInfo
,
291 sizeof(WDMAUD_DEVICE_INFO
),
295 SyncOverlappedDeviceIoControl(KernelHandle
,
297 (LPVOID
) &DeviceInfo
,
298 sizeof(WDMAUD_DEVICE_INFO
),
299 (LPVOID
) &DeviceInfo
,
300 sizeof(WDMAUD_DEVICE_INFO
),
304 if (DeviceType
== MIXER_DEVICE_TYPE
)
306 SetEvent(SoundDeviceInstance
->hStopEvent
);
307 CloseHandle(SoundDeviceInstance
->hStopEvent
);
308 CloseHandle(SoundDeviceInstance
->hNotifyEvent
);
315 CloseHandle(KernelHandle
);
316 KernelHandle
= INVALID_HANDLE_VALUE
;
319 return MMSYSERR_NOERROR
;
323 WdmAudSetMixerDeviceFormatByLegacy(
324 IN PSOUND_DEVICE_INSTANCE Instance
,
326 IN PWAVEFORMATEX WaveFormat
,
327 IN DWORD WaveFormatSize
)
330 WDMAUD_DEVICE_INFO DeviceInfo
;
333 Instance
->hNotifyEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
334 if ( ! Instance
->hNotifyEvent
)
335 return MMSYSERR_NOMEM
;
337 if (Instance
->Handle
!= NULL
)
339 /* device is already open */
340 return MMSYSERR_NOERROR
;
343 Instance
->hStopEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
344 if ( ! Instance
->hStopEvent
)
345 return MMSYSERR_NOMEM
;
347 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
348 DeviceInfo
.DeviceType
= MIXER_DEVICE_TYPE
;
349 DeviceInfo
.DeviceIndex
= DeviceId
;
350 DeviceInfo
.u
.hNotifyEvent
= Instance
->hNotifyEvent
;
352 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
354 (LPVOID
) &DeviceInfo
,
355 sizeof(WDMAUD_DEVICE_INFO
),
356 (LPVOID
) &DeviceInfo
,
357 sizeof(WDMAUD_DEVICE_INFO
),
360 if ( ! MMSUCCESS(Result
) )
362 CloseHandle(Instance
->hNotifyEvent
);
363 CloseHandle(Instance
->hStopEvent
);
364 return TranslateInternalMmResult(Result
);
367 hThread
= CreateThread(NULL
, 0, MixerEventThreadRoutine
, (LPVOID
)Instance
, 0, NULL
);
370 CloseHandle(hThread
);
373 /* Store sound device handle instance handle */
374 Instance
->Handle
= (PVOID
)DeviceInfo
.hDevice
;
376 return MMSYSERR_NOERROR
;
380 WdmAudSetWaveDeviceFormatByLegacy(
381 IN PSOUND_DEVICE_INSTANCE Instance
,
383 IN PWAVEFORMATEX WaveFormat
,
384 IN DWORD WaveFormatSize
)
387 PSOUND_DEVICE SoundDevice
;
389 WDMAUD_DEVICE_INFO DeviceInfo
;
390 MMDEVICE_TYPE DeviceType
;
392 Result
= GetSoundDeviceFromInstance(Instance
, &SoundDevice
);
394 if ( ! MMSUCCESS(Result
) )
396 return TranslateInternalMmResult(Result
);
399 Result
= GetSoundDeviceIdentifier(SoundDevice
, &Identifier
);
401 if ( ! MMSUCCESS(Result
) )
403 return TranslateInternalMmResult(Result
);
406 if (Instance
->Handle
!= NULL
)
408 /* device is already open */
409 return MMSYSERR_NOERROR
;
412 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
414 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
416 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
417 DeviceInfo
.DeviceType
= DeviceType
;
418 DeviceInfo
.DeviceIndex
= DeviceId
;
419 DeviceInfo
.u
.WaveFormatEx
.cbSize
= sizeof(WAVEFORMATEX
); //WaveFormat->cbSize;
420 DeviceInfo
.u
.WaveFormatEx
.wFormatTag
= WaveFormat
->wFormatTag
;
421 #ifdef USERMODE_MIXER
422 DeviceInfo
.u
.WaveFormatEx
.nChannels
= 2;
423 DeviceInfo
.u
.WaveFormatEx
.nSamplesPerSec
= 44100;
424 DeviceInfo
.u
.WaveFormatEx
.nBlockAlign
= 4;
425 DeviceInfo
.u
.WaveFormatEx
.nAvgBytesPerSec
= 176400;
426 DeviceInfo
.u
.WaveFormatEx
.wBitsPerSample
= 16;
428 DeviceInfo
.u
.WaveFormatEx
.nChannels
= WaveFormat
->nChannels
;
429 DeviceInfo
.u
.WaveFormatEx
.nSamplesPerSec
= WaveFormat
->nSamplesPerSec
;
430 DeviceInfo
.u
.WaveFormatEx
.nBlockAlign
= WaveFormat
->nBlockAlign
;
431 DeviceInfo
.u
.WaveFormatEx
.nAvgBytesPerSec
= WaveFormat
->nAvgBytesPerSec
;
432 DeviceInfo
.u
.WaveFormatEx
.wBitsPerSample
= WaveFormat
->wBitsPerSample
;
435 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
437 (LPVOID
) &DeviceInfo
,
438 sizeof(WDMAUD_DEVICE_INFO
),
439 (LPVOID
) &DeviceInfo
,
440 sizeof(WDMAUD_DEVICE_INFO
),
443 if ( ! MMSUCCESS(Result
) )
445 return TranslateInternalMmResult(Result
);
449 Instance
->WaveFormatEx
.cbSize
= WaveFormat
->cbSize
;
450 Instance
->WaveFormatEx
.wFormatTag
= WaveFormat
->wFormatTag
;
451 Instance
->WaveFormatEx
.nChannels
= WaveFormat
->nChannels
;
452 Instance
->WaveFormatEx
.nSamplesPerSec
= WaveFormat
->nSamplesPerSec
;
453 Instance
->WaveFormatEx
.nBlockAlign
= WaveFormat
->nBlockAlign
;
454 Instance
->WaveFormatEx
.nAvgBytesPerSec
= WaveFormat
->nAvgBytesPerSec
;
455 Instance
->WaveFormatEx
.wBitsPerSample
= WaveFormat
->wBitsPerSample
;
457 /* Store sound device handle instance handle */
458 Instance
->Handle
= (PVOID
)DeviceInfo
.hDevice
;
460 /* Now determine framing requirements */
461 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
463 (LPVOID
) &DeviceInfo
,
464 sizeof(WDMAUD_DEVICE_INFO
),
465 (LPVOID
) &DeviceInfo
,
466 sizeof(WDMAUD_DEVICE_INFO
),
469 if ( MMSUCCESS(Result
) )
471 if (DeviceInfo
.u
.FrameSize
)
473 Instance
->FrameSize
= DeviceInfo
.u
.FrameSize
* 2;
474 Instance
->BufferCount
= WaveFormat
->nAvgBytesPerSec
/ Instance
->FrameSize
;
475 SND_TRACE(L
"FrameSize %u BufferCount %u\n", Instance
->FrameSize
, Instance
->BufferCount
);
480 // use a default of 100 buffers
481 Instance
->BufferCount
= 100;
484 if (DeviceType
== WAVE_OUT_DEVICE_TYPE
)
486 /* Now start the stream */
487 DeviceInfo
.u
.State
= KSSTATE_RUN
;
488 SyncOverlappedDeviceIoControl(KernelHandle
,
489 IOCTL_SETDEVICE_STATE
,
490 (LPVOID
) &DeviceInfo
,
491 sizeof(WDMAUD_DEVICE_INFO
),
492 (LPVOID
) &DeviceInfo
,
493 sizeof(WDMAUD_DEVICE_INFO
),
497 return MMSYSERR_NOERROR
;
501 WdmAudCommitWaveBufferByLegacy(
502 IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance
,
505 IN PSOUND_OVERLAPPED Overlap
,
506 IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine
)
510 WDMAUD_DEVICE_INFO DeviceInfo
;
511 PSOUND_DEVICE SoundDevice
;
512 MMDEVICE_TYPE DeviceType
;
515 VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance
);
516 VALIDATE_MMSYS_PARAMETER( OffsetPtr
);
517 VALIDATE_MMSYS_PARAMETER( Overlap
);
518 VALIDATE_MMSYS_PARAMETER( CompletionRoutine
);
520 GetSoundDeviceInstanceHandle(SoundDeviceInstance
, &Handle
);
523 Result
= GetSoundDeviceFromInstance(SoundDeviceInstance
, &SoundDevice
);
525 if ( ! MMSUCCESS(Result
) )
527 return TranslateInternalMmResult(Result
);
530 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
531 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
533 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
535 DeviceInfo
.Header
.FrameExtent
= Length
;
536 if (DeviceType
== WAVE_OUT_DEVICE_TYPE
)
538 DeviceInfo
.Header
.DataUsed
= Length
;
540 DeviceInfo
.Header
.Data
= OffsetPtr
;
541 DeviceInfo
.Header
.Size
= sizeof(WDMAUD_DEVICE_INFO
);
542 DeviceInfo
.Header
.PresentationTime
.Numerator
= 1;
543 DeviceInfo
.Header
.PresentationTime
.Denominator
= 1;
544 DeviceInfo
.hDevice
= Handle
;
545 DeviceInfo
.DeviceType
= DeviceType
;
549 Overlap
->Standard
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
551 if (DeviceType
== WAVE_OUT_DEVICE_TYPE
)
553 Ret
= WriteFileEx(KernelHandle
, &DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
), (LPOVERLAPPED
)Overlap
, CompletionRoutine
);
555 WaitForSingleObjectEx (KernelHandle
, INFINITE
, TRUE
);
557 else if (DeviceType
== WAVE_IN_DEVICE_TYPE
)
559 Ret
= ReadFileEx(KernelHandle
, &DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
), (LPOVERLAPPED
)Overlap
, CompletionRoutine
);
561 // WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
564 return MMSYSERR_NOERROR
;
570 WdmAudSetWaveStateByLegacy(
571 IN
struct _SOUND_DEVICE_INSTANCE
* SoundDeviceInstance
,
575 PSOUND_DEVICE SoundDevice
;
576 WDMAUD_DEVICE_INFO DeviceInfo
;
577 MMDEVICE_TYPE DeviceType
;
580 Result
= GetSoundDeviceFromInstance(SoundDeviceInstance
, &SoundDevice
);
582 if ( ! MMSUCCESS(Result
) )
584 return TranslateInternalMmResult(Result
);
587 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
588 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
590 Result
= GetSoundDeviceInstanceHandle(SoundDeviceInstance
, &Handle
);
591 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
593 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
594 DeviceInfo
.hDevice
= Handle
;
595 DeviceInfo
.DeviceType
= DeviceType
;
598 DeviceInfo
.u
.State
= KSSTATE_RUN
;
600 DeviceInfo
.u
.State
= KSSTATE_PAUSE
;
601 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
602 IOCTL_SETDEVICE_STATE
,
603 (LPVOID
) &DeviceInfo
,
604 sizeof(WDMAUD_DEVICE_INFO
),
605 (LPVOID
) &DeviceInfo
,
606 sizeof(WDMAUD_DEVICE_INFO
),
613 WdmAudGetDeviceInterfaceStringByLegacy(
614 IN MMDEVICE_TYPE DeviceType
,
617 IN DWORD InterfaceLength
,
618 OUT DWORD
* InterfaceSize
)
620 WDMAUD_DEVICE_INFO DeviceInfo
;
623 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
624 DeviceInfo
.DeviceType
= DeviceType
;
625 DeviceInfo
.DeviceIndex
= DeviceId
;
628 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
629 IOCTL_QUERYDEVICEINTERFACESTRING
,
630 (LPVOID
) &DeviceInfo
,
631 sizeof(WDMAUD_DEVICE_INFO
),
632 (LPVOID
) &DeviceInfo
,
633 sizeof(WDMAUD_DEVICE_INFO
),
637 if ( ! MMSUCCESS(Result
) )
639 return TranslateInternalMmResult(Result
);
645 SND_ASSERT(InterfaceSize
);
647 *InterfaceSize
= DeviceInfo
.u
.Interface
.DeviceInterfaceStringSize
;
648 return MMSYSERR_NOERROR
;
651 if (InterfaceLength
< DeviceInfo
.u
.Interface
.DeviceInterfaceStringSize
)
653 /* buffer is too small */
654 return MMSYSERR_MOREDATA
;
657 DeviceInfo
.u
.Interface
.DeviceInterfaceStringSize
= InterfaceLength
;
658 DeviceInfo
.u
.Interface
.DeviceInterfaceString
= Interface
;
660 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
661 IOCTL_QUERYDEVICEINTERFACESTRING
,
662 (LPVOID
) &DeviceInfo
,
663 sizeof(WDMAUD_DEVICE_INFO
),
664 (LPVOID
) &DeviceInfo
,
665 sizeof(WDMAUD_DEVICE_INFO
),
668 if ( MMSUCCESS(Result
) && InterfaceLength
> 2)
670 Interface
[1] = L
'\\';
671 Interface
[InterfaceLength
-1] = L
'\0';
678 WdmAudGetWavePositionByLegacy(
679 IN
struct _SOUND_DEVICE_INSTANCE
* SoundDeviceInstance
,
683 PSOUND_DEVICE SoundDevice
;
684 WDMAUD_DEVICE_INFO DeviceInfo
;
685 MMDEVICE_TYPE DeviceType
;
688 Result
= GetSoundDeviceFromInstance(SoundDeviceInstance
, &SoundDevice
);
690 if ( ! MMSUCCESS(Result
) )
692 return TranslateInternalMmResult(Result
);
695 Result
= GetSoundDeviceType(SoundDevice
, &DeviceType
);
696 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
698 Result
= GetSoundDeviceInstanceHandle(SoundDeviceInstance
, &Handle
);
699 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
701 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
702 DeviceInfo
.hDevice
= Handle
;
703 DeviceInfo
.DeviceType
= DeviceType
;
705 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
707 (LPVOID
) &DeviceInfo
,
708 sizeof(WDMAUD_DEVICE_INFO
),
709 (LPVOID
) &DeviceInfo
,
710 sizeof(WDMAUD_DEVICE_INFO
),
713 if ( ! MMSUCCESS(Result
) )
715 return TranslateInternalMmResult(Result
);
718 Time
->wType
= TIME_BYTES
;
719 Time
->u
.cb
= (DWORD
)DeviceInfo
.u
.Position
;
721 return MMSYSERR_NOERROR
;
726 WdmAudResetStreamByLegacy(
727 IN
struct _SOUND_DEVICE_INSTANCE
* SoundDeviceInstance
,
728 IN MMDEVICE_TYPE DeviceType
,
729 IN BOOLEAN bStartReset
)
733 WDMAUD_DEVICE_INFO DeviceInfo
;
735 Result
= GetSoundDeviceInstanceHandle(SoundDeviceInstance
, &Handle
);
736 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
738 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
739 DeviceInfo
.hDevice
= Handle
;
740 DeviceInfo
.DeviceType
= DeviceType
;
741 DeviceInfo
.u
.ResetStream
= (bStartReset
? KSRESET_BEGIN
: KSRESET_END
);
743 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
745 (LPVOID
) &DeviceInfo
,
746 sizeof(WDMAUD_DEVICE_INFO
),
747 (LPVOID
) &DeviceInfo
,
748 sizeof(WDMAUD_DEVICE_INFO
),
754 WdmAudQueryMixerInfoByLegacy(
755 IN
struct _SOUND_DEVICE_INSTANCE
* SoundDeviceInstance
,
761 WDMAUD_DEVICE_INFO DeviceInfo
;
764 LPMIXERLINEW MixLine
;
765 LPMIXERLINECONTROLSW MixControls
;
766 LPMIXERCONTROLDETAILS MixDetails
;
768 SND_TRACE(L
"uMsg %x Flags %x\n", uMsg
, Flags
);
770 Result
= GetSoundDeviceInstanceHandle(SoundDeviceInstance
, &Handle
);
771 SND_ASSERT( Result
== MMSYSERR_NOERROR
);
773 ZeroMemory(&DeviceInfo
, sizeof(WDMAUD_DEVICE_INFO
));
774 DeviceInfo
.hDevice
= Handle
;
775 DeviceInfo
.DeviceType
= MIXER_DEVICE_TYPE
;
776 DeviceInfo
.Flags
= Flags
;
778 MixLine
= (LPMIXERLINEW
)Parameter
;
779 MixControls
= (LPMIXERLINECONTROLSW
)Parameter
;
780 MixDetails
= (LPMIXERCONTROLDETAILS
)Parameter
;
784 case MXDM_GETLINEINFO
:
785 RtlCopyMemory(&DeviceInfo
.u
.MixLine
, MixLine
, sizeof(MIXERLINEW
));
786 IoControlCode
= IOCTL_GETLINEINFO
;
788 case MXDM_GETLINECONTROLS
:
789 RtlCopyMemory(&DeviceInfo
.u
.MixControls
, MixControls
, sizeof(MIXERLINECONTROLSW
));
790 IoControlCode
= IOCTL_GETLINECONTROLS
;
792 case MXDM_SETCONTROLDETAILS
:
793 RtlCopyMemory(&DeviceInfo
.u
.MixDetails
, MixDetails
, sizeof(MIXERCONTROLDETAILS
));
794 IoControlCode
= IOCTL_SETCONTROLDETAILS
;
796 case MXDM_GETCONTROLDETAILS
:
797 RtlCopyMemory(&DeviceInfo
.u
.MixDetails
, MixDetails
, sizeof(MIXERCONTROLDETAILS
));
798 IoControlCode
= IOCTL_GETCONTROLDETAILS
;
802 return MMSYSERR_NOTSUPPORTED
;
805 Result
= SyncOverlappedDeviceIoControl(KernelHandle
,
807 (LPVOID
) &DeviceInfo
,
808 sizeof(WDMAUD_DEVICE_INFO
),
809 (LPVOID
) &DeviceInfo
,
810 sizeof(WDMAUD_DEVICE_INFO
),
813 if ( ! MMSUCCESS(Result
) )
820 case MXDM_GETLINEINFO
:
822 RtlCopyMemory(MixLine
, &DeviceInfo
.u
.MixLine
, sizeof(MIXERLINEW
));