Hackfix wdmaud.drv for now (Johannes Anderwald)
[reactos.git] / reactos / dll / win32 / wdmaud.drv / legacy.c
1 /*
2 * PROJECT: ReactOS Sound System
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/wdmaud.drv/wdmaud.c
5 *
6 * PURPOSE: WDM Audio Driver (User-mode part)
7 * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
8 Johannes Anderwald
9 *
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.
13 *
14 */
15
16 #include "wdmaud.h"
17
18 #define KERNEL_DEVICE_NAME L"\\\\.\\wdmaud"
19 extern HANDLE KernelHandle;
20 extern DWORD OpenCount;
21
22 DWORD
23 WINAPI
24 MixerEventThreadRoutine(
25 LPVOID Parameter)
26 {
27 HANDLE WaitObjects[2];
28 DWORD dwResult;
29 MMRESULT Result;
30 WDMAUD_DEVICE_INFO DeviceInfo;
31 PSOUND_DEVICE_INSTANCE Instance = (PSOUND_DEVICE_INSTANCE)Parameter;
32
33 /* setup wait objects */
34 WaitObjects[0] = Instance->hNotifyEvent;
35 WaitObjects[1] = Instance->hStopEvent;
36
37 /* zero device info */
38 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
39
40 DeviceInfo.hDevice = Instance->Handle;
41 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
42
43 do
44 {
45 dwResult = WaitForMultipleObjects(2, WaitObjects, FALSE, INFINITE);
46
47 if (dwResult == WAIT_OBJECT_0 + 1)
48 {
49 /* stop event was signalled */
50 break;
51 }
52
53 do
54 {
55 Result = SyncOverlappedDeviceIoControl(KernelHandle,
56 IOCTL_GET_MIXER_EVENT,
57 (LPVOID) &DeviceInfo,
58 sizeof(WDMAUD_DEVICE_INFO),
59 (LPVOID) &DeviceInfo,
60 sizeof(WDMAUD_DEVICE_INFO),
61 NULL);
62
63 if (Result == MMSYSERR_NOERROR)
64 {
65 DriverCallback(Instance->WinMM.ClientCallback,
66 HIWORD(Instance->WinMM.Flags),
67 Instance->WinMM.Handle,
68 DeviceInfo.u.MixerEvent.NotificationType,
69 Instance->WinMM.ClientCallbackInstanceData,
70 (DWORD_PTR)DeviceInfo.u.MixerEvent.Value,
71 0);
72 }
73 }while(Result == MMSYSERR_NOERROR);
74 }while(TRUE);
75
76 /* done */
77 return 0;
78 }
79
80 VOID
81 WdmAudCleanupLegacy()
82 {
83 if ( KernelHandle != INVALID_HANDLE_VALUE )
84 {
85 CloseHandle(KernelHandle);
86 KernelHandle = INVALID_HANDLE_VALUE;
87 }
88 }
89
90 MMRESULT
91 WdmAudGetNumWdmDevsByLegacy(
92 IN MMDEVICE_TYPE DeviceType,
93 OUT DWORD* DeviceCount)
94 {
95 MMRESULT Result;
96 WDMAUD_DEVICE_INFO DeviceInfo;
97
98 VALIDATE_MMSYS_PARAMETER( KernelHandle != INVALID_HANDLE_VALUE );
99 VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
100 VALIDATE_MMSYS_PARAMETER( DeviceCount );
101
102 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
103 DeviceInfo.DeviceType = DeviceType;
104
105 Result = SyncOverlappedDeviceIoControl(KernelHandle,
106 IOCTL_GETNUMDEVS_TYPE,
107 (LPVOID) &DeviceInfo,
108 sizeof(WDMAUD_DEVICE_INFO),
109 (LPVOID) &DeviceInfo,
110 sizeof(WDMAUD_DEVICE_INFO),
111 NULL);
112
113 if ( ! MMSUCCESS( Result ) )
114 {
115 SND_ERR(L"Call to IOCTL_GETNUMDEVS_TYPE failed\n");
116 *DeviceCount = 0;
117 return TranslateInternalMmResult(Result);
118 }
119
120 *DeviceCount = DeviceInfo.DeviceCount;
121
122 return MMSYSERR_NOERROR;
123 }
124
125 MMRESULT
126 WdmAudGetCapabilitiesByLegacy(
127 IN PSOUND_DEVICE SoundDevice,
128 IN DWORD DeviceId,
129 OUT PVOID Capabilities,
130 IN DWORD CapabilitiesSize)
131 {
132 MMRESULT Result;
133 MMDEVICE_TYPE DeviceType;
134 WDMAUD_DEVICE_INFO DeviceInfo;
135
136 SND_ASSERT( SoundDevice );
137 SND_ASSERT( Capabilities );
138
139 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
140 SND_ASSERT( Result == MMSYSERR_NOERROR );
141
142 if ( ! MMSUCCESS(Result) )
143 return Result;
144
145 SND_TRACE(L"WDMAUD - GetWdmDeviceCapabilities DeviceType %u DeviceId %u\n", DeviceType, DeviceId);
146
147 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
148 DeviceInfo.DeviceType = DeviceType;
149 DeviceInfo.DeviceIndex = DeviceId;
150
151 Result = SyncOverlappedDeviceIoControl(KernelHandle,
152 IOCTL_GETCAPABILITIES,
153 (LPVOID) &DeviceInfo,
154 sizeof(WDMAUD_DEVICE_INFO),
155 (LPVOID) &DeviceInfo,
156 sizeof(WDMAUD_DEVICE_INFO),
157 NULL);
158
159 if ( ! MMSUCCESS(Result) )
160 {
161 return TranslateInternalMmResult(Result);
162 }
163
164 /* This is pretty much a big hack right now */
165 switch ( DeviceType )
166 {
167 case MIXER_DEVICE_TYPE:
168 {
169 LPMIXERCAPS MixerCaps = (LPMIXERCAPS) Capabilities;
170
171 DeviceInfo.u.MixCaps.szPname[MAXPNAMELEN-1] = L'\0';
172 CopyWideString(MixerCaps->szPname, DeviceInfo.u.MixCaps.szPname);
173
174 MixerCaps->cDestinations = DeviceInfo.u.MixCaps.cDestinations;
175 MixerCaps->fdwSupport = DeviceInfo.u.MixCaps.fdwSupport;
176 MixerCaps->vDriverVersion = DeviceInfo.u.MixCaps.vDriverVersion;
177 MixerCaps->wMid = DeviceInfo.u.MixCaps.wMid;
178 MixerCaps->wPid = DeviceInfo.u.MixCaps.wPid;
179 break;
180 }
181 case WAVE_OUT_DEVICE_TYPE :
182 {
183 LPWAVEOUTCAPS WaveOutCaps = (LPWAVEOUTCAPS) Capabilities;
184
185 DeviceInfo.u.WaveOutCaps.szPname[MAXPNAMELEN-1] = L'\0';
186 WaveOutCaps->wMid = DeviceInfo.u.WaveOutCaps.wMid;
187 WaveOutCaps->wPid = DeviceInfo.u.WaveOutCaps.wPid;
188
189 WaveOutCaps->vDriverVersion = 0x0001;
190 CopyWideString(WaveOutCaps->szPname, DeviceInfo.u.WaveOutCaps.szPname);
191
192 WaveOutCaps->dwFormats = DeviceInfo.u.WaveOutCaps.dwFormats;
193 WaveOutCaps->wChannels = DeviceInfo.u.WaveOutCaps.wChannels;
194 WaveOutCaps->dwSupport = DeviceInfo.u.WaveOutCaps.dwSupport;
195 break;
196 }
197 case WAVE_IN_DEVICE_TYPE :
198 {
199 LPWAVEINCAPSW WaveInCaps = (LPWAVEINCAPSW) Capabilities;
200
201 DeviceInfo.u.WaveInCaps.szPname[MAXPNAMELEN-1] = L'\0';
202
203 WaveInCaps->wMid = DeviceInfo.u.WaveInCaps.wMid;
204 WaveInCaps->wPid = DeviceInfo.u.WaveInCaps.wPid;
205
206 WaveInCaps->vDriverVersion = 0x0001;
207 CopyWideString(WaveInCaps->szPname, DeviceInfo.u.WaveInCaps.szPname);
208
209 WaveInCaps->dwFormats = DeviceInfo.u.WaveInCaps.dwFormats;
210 WaveInCaps->wChannels = DeviceInfo.u.WaveInCaps.wChannels;
211 WaveInCaps->wReserved1 = 0;
212 break;
213 }
214 }
215
216 return MMSYSERR_NOERROR;
217 }
218
219 MMRESULT
220 WdmAudOpenSoundDeviceByLegacy()
221 {
222 /* Only open this if it's not already open */
223 if ( KernelHandle == INVALID_HANDLE_VALUE )
224 {
225 SND_TRACE(L"Opening wdmaud device\n");
226 KernelHandle = CreateFileW(KERNEL_DEVICE_NAME,
227 GENERIC_READ | GENERIC_WRITE,
228 0,
229 NULL,
230 OPEN_EXISTING,
231 FILE_FLAG_OVERLAPPED,
232 NULL);
233 }
234
235 if ( KernelHandle == INVALID_HANDLE_VALUE )
236 return MMSYSERR_ERROR;
237
238 ++ OpenCount;
239
240 return MMSYSERR_NOERROR;
241 }
242
243 MMRESULT
244 WdmAudCloseSoundDeviceByLegacy(
245 IN struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
246 IN PVOID Handle)
247 {
248 WDMAUD_DEVICE_INFO DeviceInfo;
249 MMRESULT Result;
250 MMDEVICE_TYPE DeviceType;
251 PSOUND_DEVICE SoundDevice;
252
253 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
254
255 if ( ! MMSUCCESS(Result) )
256 {
257 return TranslateInternalMmResult(Result);
258 }
259
260 if ( OpenCount == 0 )
261 {
262 return MMSYSERR_NOERROR;
263 }
264
265 SND_ASSERT( KernelHandle != INVALID_HANDLE_VALUE );
266
267 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
268 SND_ASSERT( Result == MMSYSERR_NOERROR );
269
270 if (SoundDeviceInstance->Handle != (PVOID)KernelHandle)
271 {
272 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
273
274 DeviceInfo.DeviceType = DeviceType;
275 DeviceInfo.hDevice = SoundDeviceInstance->Handle;
276
277 /* First stop the stream */
278 if (DeviceType != MIXER_DEVICE_TYPE)
279 {
280 DeviceInfo.u.State = KSSTATE_STOP;
281 SyncOverlappedDeviceIoControl(KernelHandle,
282 IOCTL_SETDEVICE_STATE,
283 (LPVOID) &DeviceInfo,
284 sizeof(WDMAUD_DEVICE_INFO),
285 (LPVOID) &DeviceInfo,
286 sizeof(WDMAUD_DEVICE_INFO),
287 NULL);
288 }
289
290 SyncOverlappedDeviceIoControl(KernelHandle,
291 IOCTL_CLOSE_WDMAUD,
292 (LPVOID) &DeviceInfo,
293 sizeof(WDMAUD_DEVICE_INFO),
294 (LPVOID) &DeviceInfo,
295 sizeof(WDMAUD_DEVICE_INFO),
296 NULL);
297 }
298
299 if (DeviceType == MIXER_DEVICE_TYPE)
300 {
301 SetEvent(SoundDeviceInstance->hStopEvent);
302 CloseHandle(SoundDeviceInstance->hStopEvent);
303 CloseHandle(SoundDeviceInstance->hNotifyEvent);
304 }
305
306 --OpenCount;
307
308 if ( OpenCount < 1 )
309 {
310 CloseHandle(KernelHandle);
311 KernelHandle = INVALID_HANDLE_VALUE;
312 }
313
314 return MMSYSERR_NOERROR;
315 }
316
317 MMRESULT
318 WdmAudSetMixerDeviceFormatByLegacy(
319 IN PSOUND_DEVICE_INSTANCE Instance,
320 IN DWORD DeviceId,
321 IN PWAVEFORMATEX WaveFormat,
322 IN DWORD WaveFormatSize)
323 {
324 MMRESULT Result;
325 WDMAUD_DEVICE_INFO DeviceInfo;
326 HANDLE hThread;
327
328
329 Instance->hNotifyEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
330 if ( ! Instance->hNotifyEvent )
331 return MMSYSERR_NOMEM;
332
333 if (Instance->Handle != KernelHandle)
334 {
335 /* device is already open */
336 return MMSYSERR_NOERROR;
337 }
338
339 Instance->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
340 if ( ! Instance->hStopEvent )
341 return MMSYSERR_NOMEM;
342
343 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
344 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
345 DeviceInfo.DeviceIndex = DeviceId;
346 DeviceInfo.u.hNotifyEvent = Instance->hNotifyEvent;
347
348 Result = SyncOverlappedDeviceIoControl(KernelHandle,
349 IOCTL_OPEN_WDMAUD,
350 (LPVOID) &DeviceInfo,
351 sizeof(WDMAUD_DEVICE_INFO),
352 (LPVOID) &DeviceInfo,
353 sizeof(WDMAUD_DEVICE_INFO),
354 NULL);
355
356 if ( ! MMSUCCESS(Result) )
357 {
358 CloseHandle(Instance->hNotifyEvent);
359 CloseHandle(Instance->hStopEvent);
360 return TranslateInternalMmResult(Result);
361 }
362
363 hThread = CreateThread(NULL, 0, MixerEventThreadRoutine, (LPVOID)Instance, 0, NULL);
364 if ( hThread )
365 {
366 CloseHandle(hThread);
367 }
368
369 /* Store sound device handle instance handle */
370 Instance->Handle = (PVOID)DeviceInfo.hDevice;
371
372 return MMSYSERR_NOERROR;
373 }
374
375 MMRESULT
376 WdmAudSetWaveDeviceFormatByLegacy(
377 IN PSOUND_DEVICE_INSTANCE Instance,
378 IN DWORD DeviceId,
379 IN PWAVEFORMATEX WaveFormat,
380 IN DWORD WaveFormatSize)
381 {
382 MMRESULT Result;
383 PSOUND_DEVICE SoundDevice;
384 PVOID Identifier;
385 WDMAUD_DEVICE_INFO DeviceInfo;
386 MMDEVICE_TYPE DeviceType;
387
388 Result = GetSoundDeviceFromInstance(Instance, &SoundDevice);
389
390 if ( ! MMSUCCESS(Result) )
391 {
392 return TranslateInternalMmResult(Result);
393 }
394
395 Result = GetSoundDeviceIdentifier(SoundDevice, &Identifier);
396
397 if ( ! MMSUCCESS(Result) )
398 {
399 return TranslateInternalMmResult(Result);
400 }
401
402 if (Instance->Handle != KernelHandle)
403 {
404 /* device is already open */
405 return MMSYSERR_NOERROR;
406 }
407
408 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
409
410 SND_ASSERT( Result == MMSYSERR_NOERROR );
411
412 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
413 DeviceInfo.DeviceType = DeviceType;
414 DeviceInfo.DeviceIndex = DeviceId;
415 DeviceInfo.u.WaveFormatEx.cbSize = sizeof(WAVEFORMATEX); //WaveFormat->cbSize;
416 DeviceInfo.u.WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
417 #ifdef USERMODE_MIXER
418 DeviceInfo.u.WaveFormatEx.nChannels = 2;
419 DeviceInfo.u.WaveFormatEx.nSamplesPerSec = 44100;
420 DeviceInfo.u.WaveFormatEx.nBlockAlign = 4;
421 DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = 176400;
422 DeviceInfo.u.WaveFormatEx.wBitsPerSample = 16;
423 #else
424 DeviceInfo.u.WaveFormatEx.nChannels = WaveFormat->nChannels;
425 DeviceInfo.u.WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
426 DeviceInfo.u.WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
427 DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
428 DeviceInfo.u.WaveFormatEx.wBitsPerSample = WaveFormat->wBitsPerSample;
429 #endif
430
431 Result = SyncOverlappedDeviceIoControl(KernelHandle,
432 IOCTL_OPEN_WDMAUD,
433 (LPVOID) &DeviceInfo,
434 sizeof(WDMAUD_DEVICE_INFO),
435 (LPVOID) &DeviceInfo,
436 sizeof(WDMAUD_DEVICE_INFO),
437 NULL);
438
439 if ( ! MMSUCCESS(Result) )
440 {
441 return TranslateInternalMmResult(Result);
442 }
443
444 /* Store format */
445 Instance->WaveFormatEx.cbSize = WaveFormat->cbSize;
446 Instance->WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
447 Instance->WaveFormatEx.nChannels = WaveFormat->nChannels;
448 Instance->WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
449 Instance->WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
450 Instance->WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
451 Instance->WaveFormatEx.wBitsPerSample = WaveFormat->wBitsPerSample;
452
453 /* Store sound device handle instance handle */
454 Instance->Handle = (PVOID)DeviceInfo.hDevice;
455
456 /* Now determine framing requirements */
457 Result = SyncOverlappedDeviceIoControl(KernelHandle,
458 IOCTL_GETFRAMESIZE,
459 (LPVOID) &DeviceInfo,
460 sizeof(WDMAUD_DEVICE_INFO),
461 (LPVOID) &DeviceInfo,
462 sizeof(WDMAUD_DEVICE_INFO),
463 NULL);
464
465 if ( MMSUCCESS(Result) )
466 {
467 if (DeviceInfo.u.FrameSize)
468 {
469 Instance->FrameSize = DeviceInfo.u.FrameSize * 2;
470 Instance->BufferCount = WaveFormat->nAvgBytesPerSec / Instance->FrameSize;
471 SND_TRACE(L"FrameSize %u BufferCount %u\n", Instance->FrameSize, Instance->BufferCount);
472 }
473 }
474 else
475 {
476 // use a default of 100 buffers
477 Instance->BufferCount = 100;
478 }
479
480 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
481 {
482 /* Now start the stream */
483 DeviceInfo.u.State = KSSTATE_RUN;
484 SyncOverlappedDeviceIoControl(KernelHandle,
485 IOCTL_SETDEVICE_STATE,
486 (LPVOID) &DeviceInfo,
487 sizeof(WDMAUD_DEVICE_INFO),
488 (LPVOID) &DeviceInfo,
489 sizeof(WDMAUD_DEVICE_INFO),
490 NULL);
491 }
492
493 return MMSYSERR_NOERROR;
494 }
495
496 MMRESULT
497 WriteFileEx_Committer2(
498 IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
499 IN PVOID OffsetPtr,
500 IN DWORD Length,
501 IN PSOUND_OVERLAPPED Overlap,
502 IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
503 {
504 HANDLE Handle;
505 MMRESULT Result;
506 WDMAUD_DEVICE_INFO DeviceInfo;
507 PSOUND_DEVICE SoundDevice;
508 MMDEVICE_TYPE DeviceType;
509 BOOL Ret;
510
511 VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
512 VALIDATE_MMSYS_PARAMETER( OffsetPtr );
513 VALIDATE_MMSYS_PARAMETER( Overlap );
514 VALIDATE_MMSYS_PARAMETER( CompletionRoutine );
515
516 GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
517
518
519 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
520
521 if ( ! MMSUCCESS(Result) )
522 {
523 return TranslateInternalMmResult(Result);
524 }
525
526 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
527 SND_ASSERT( Result == MMSYSERR_NOERROR );
528
529 SND_ASSERT(Handle);
530
531 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
532
533 DeviceInfo.Header.FrameExtent = Length;
534 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
535 {
536 DeviceInfo.Header.DataUsed = Length;
537 }
538 DeviceInfo.Header.Data = OffsetPtr;
539 DeviceInfo.Header.Size = sizeof(WDMAUD_DEVICE_INFO);
540 DeviceInfo.Header.PresentationTime.Numerator = 1;
541 DeviceInfo.Header.PresentationTime.Denominator = 1;
542 DeviceInfo.hDevice = Handle;
543 DeviceInfo.DeviceType = DeviceType;
544
545 Overlap->Standard.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
546
547 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
548 {
549 Ret = WriteFileEx(KernelHandle, &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, CompletionRoutine);
550 if (Ret)
551 WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
552 }
553 else if (DeviceType == WAVE_IN_DEVICE_TYPE)
554 {
555 Ret = ReadFileEx(KernelHandle, &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, CompletionRoutine);
556 //if (Ret)
557 // WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
558 }
559
560 return MMSYSERR_NOERROR;
561 }
562
563
564
565 MMRESULT
566 WdmAudSetWaveStateByLegacy(
567 IN struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
568 IN BOOL bStart)
569 {
570 MMRESULT Result;
571 PSOUND_DEVICE SoundDevice;
572 WDMAUD_DEVICE_INFO DeviceInfo;
573 MMDEVICE_TYPE DeviceType;
574 HANDLE Handle;
575
576 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
577
578 if ( ! MMSUCCESS(Result) )
579 {
580 return TranslateInternalMmResult(Result);
581 }
582
583 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
584 SND_ASSERT( Result == MMSYSERR_NOERROR );
585
586 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
587 SND_ASSERT( Result == MMSYSERR_NOERROR );
588
589 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
590 DeviceInfo.hDevice = Handle;
591 DeviceInfo.DeviceType = DeviceType;
592
593 if (bStart)
594 DeviceInfo.u.State = KSSTATE_RUN;
595 else
596 DeviceInfo.u.State = KSSTATE_PAUSE;
597 Result = SyncOverlappedDeviceIoControl(KernelHandle,
598 IOCTL_SETDEVICE_STATE,
599 (LPVOID) &DeviceInfo,
600 sizeof(WDMAUD_DEVICE_INFO),
601 (LPVOID) &DeviceInfo,
602 sizeof(WDMAUD_DEVICE_INFO),
603 NULL);
604
605 return Result;
606 }
607
608 MMRESULT
609 WdmAudGetDeviceInterfaceStringByLegacy(
610 IN MMDEVICE_TYPE DeviceType,
611 IN DWORD DeviceId,
612 IN LPWSTR Interface,
613 IN DWORD InterfaceLength,
614 OUT DWORD * InterfaceSize)
615 {
616 WDMAUD_DEVICE_INFO DeviceInfo;
617 MMRESULT Result;
618
619 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
620 DeviceInfo.DeviceType = DeviceType;
621 DeviceInfo.DeviceIndex = DeviceId;
622
623
624 Result = SyncOverlappedDeviceIoControl(KernelHandle,
625 IOCTL_QUERYDEVICEINTERFACESTRING,
626 (LPVOID) &DeviceInfo,
627 sizeof(WDMAUD_DEVICE_INFO),
628 (LPVOID) &DeviceInfo,
629 sizeof(WDMAUD_DEVICE_INFO),
630 NULL);
631
632
633 if ( ! MMSUCCESS(Result) )
634 {
635 return TranslateInternalMmResult(Result);
636 }
637
638
639 if (!Interface)
640 {
641 SND_ASSERT(InterfaceSize);
642
643 *InterfaceSize = DeviceInfo.u.Interface.DeviceInterfaceStringSize;
644 return MMSYSERR_NOERROR;
645 }
646
647 if (InterfaceLength < DeviceInfo.u.Interface.DeviceInterfaceStringSize)
648 {
649 /* buffer is too small */
650 return MMSYSERR_MOREDATA;
651 }
652
653 DeviceInfo.u.Interface.DeviceInterfaceStringSize = InterfaceLength;
654 DeviceInfo.u.Interface.DeviceInterfaceString = Interface;
655
656 Result = SyncOverlappedDeviceIoControl(KernelHandle,
657 IOCTL_QUERYDEVICEINTERFACESTRING,
658 (LPVOID) &DeviceInfo,
659 sizeof(WDMAUD_DEVICE_INFO),
660 (LPVOID) &DeviceInfo,
661 sizeof(WDMAUD_DEVICE_INFO),
662 NULL);
663
664 if ( MMSUCCESS(Result) && InterfaceLength > 2)
665 {
666 Interface[1] = L'\\';
667 Interface[InterfaceLength-1] = L'\0';
668 }
669
670 return Result;
671 }
672
673 MMRESULT
674 WdmAudGetWavePositionByLegacy(
675 IN struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
676 IN MMTIME* Time)
677 {
678 MMRESULT Result;
679 PSOUND_DEVICE SoundDevice;
680 WDMAUD_DEVICE_INFO DeviceInfo;
681 MMDEVICE_TYPE DeviceType;
682 HANDLE Handle;
683
684 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
685
686 if ( ! MMSUCCESS(Result) )
687 {
688 return TranslateInternalMmResult(Result);
689 }
690
691 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
692 SND_ASSERT( Result == MMSYSERR_NOERROR );
693
694 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
695 SND_ASSERT( Result == MMSYSERR_NOERROR );
696
697 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
698 DeviceInfo.hDevice = Handle;
699 DeviceInfo.DeviceType = DeviceType;
700
701 Result = SyncOverlappedDeviceIoControl(KernelHandle,
702 IOCTL_OPEN_WDMAUD,
703 (LPVOID) &DeviceInfo,
704 sizeof(WDMAUD_DEVICE_INFO),
705 (LPVOID) &DeviceInfo,
706 sizeof(WDMAUD_DEVICE_INFO),
707 NULL);
708
709 if ( ! MMSUCCESS(Result) )
710 {
711 return TranslateInternalMmResult(Result);
712 }
713
714 Time->wType = TIME_BYTES;
715 Time->u.cb = (DWORD)DeviceInfo.u.Position;
716
717 return MMSYSERR_NOERROR;
718 }
719
720
721 MMRESULT
722 WdmAudResetStreamByLegacy(
723 IN struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
724 IN MMDEVICE_TYPE DeviceType,
725 IN BOOLEAN bStartReset)
726 {
727 MMRESULT Result;
728 HANDLE Handle;
729 WDMAUD_DEVICE_INFO DeviceInfo;
730
731 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
732 SND_ASSERT( Result == MMSYSERR_NOERROR );
733
734 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
735 DeviceInfo.hDevice = Handle;
736 DeviceInfo.DeviceType = DeviceType;
737 DeviceInfo.u.ResetStream = (bStartReset ? KSRESET_BEGIN : KSRESET_END);
738
739 Result = SyncOverlappedDeviceIoControl(KernelHandle,
740 IOCTL_RESET_STREAM,
741 (LPVOID) &DeviceInfo,
742 sizeof(WDMAUD_DEVICE_INFO),
743 (LPVOID) &DeviceInfo,
744 sizeof(WDMAUD_DEVICE_INFO),
745 NULL);
746 return Result;
747 }
748
749 MMRESULT
750 WdmAudQueryMixerInfoByLegacy(
751 IN struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
752 IN UINT uMsg,
753 IN LPVOID Parameter,
754 IN DWORD Flags)
755 {
756 MMRESULT Result;
757 WDMAUD_DEVICE_INFO DeviceInfo;
758 HANDLE Handle;
759 DWORD IoControlCode;
760 LPMIXERLINEW MixLine;
761 LPMIXERLINECONTROLSW MixControls;
762 LPMIXERCONTROLDETAILS MixDetails;
763
764 SND_TRACE(L"uMsg %x Flags %x\n", uMsg, Flags);
765
766 Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
767 SND_ASSERT( Result == MMSYSERR_NOERROR );
768
769 ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
770 DeviceInfo.hDevice = Handle;
771 DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
772 DeviceInfo.Flags = Flags;
773
774 MixLine = (LPMIXERLINEW)Parameter;
775 MixControls = (LPMIXERLINECONTROLSW)Parameter;
776 MixDetails = (LPMIXERCONTROLDETAILS)Parameter;
777
778 switch(uMsg)
779 {
780 case MXDM_GETLINEINFO:
781 RtlCopyMemory(&DeviceInfo.u.MixLine, MixLine, sizeof(MIXERLINEW));
782 IoControlCode = IOCTL_GETLINEINFO;
783 break;
784 case MXDM_GETLINECONTROLS:
785 RtlCopyMemory(&DeviceInfo.u.MixControls, MixControls, sizeof(MIXERLINECONTROLSW));
786 IoControlCode = IOCTL_GETLINECONTROLS;
787 break;
788 case MXDM_SETCONTROLDETAILS:
789 RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
790 IoControlCode = IOCTL_SETCONTROLDETAILS;
791 break;
792 case MXDM_GETCONTROLDETAILS:
793 RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
794 IoControlCode = IOCTL_GETCONTROLDETAILS;
795 break;
796 default:
797 SND_ASSERT(0);
798 return MMSYSERR_NOTSUPPORTED;
799 }
800
801 Result = SyncOverlappedDeviceIoControl(KernelHandle,
802 IoControlCode,
803 (LPVOID) &DeviceInfo,
804 sizeof(WDMAUD_DEVICE_INFO),
805 (LPVOID) &DeviceInfo,
806 sizeof(WDMAUD_DEVICE_INFO),
807 NULL);
808
809 if ( ! MMSUCCESS(Result) )
810 {
811 return Result;
812 }
813
814 switch(uMsg)
815 {
816 case MXDM_GETLINEINFO:
817 {
818 RtlCopyMemory(MixLine, &DeviceInfo.u.MixLine, sizeof(MIXERLINEW));
819 break;
820 }
821 }
822
823 return Result;
824 }