2 * Copyright 1993 Martin Ayotte
3 * 1998-2002 Eric Pouech
4 * 2011 Andrew Eikum for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
43 #include "mmdeviceapi.h"
44 #include "audioclient.h"
45 #include "audiopolicy.h"
47 #include "wine/debug.h"
49 /* TODO: Remove after dsound has been rewritten for mmdevapi */
52 #define DS_HW_ACCEL_FULL 0
54 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
56 /* FIXME: Should be localized */
57 static const WCHAR volumeW
[] = {'V','o','l','u','m','e',0};
58 static const WCHAR mastervolumeW
[] = {'M','a','s','t','e','r',' ','V','o','l',
60 static const WCHAR muteW
[] = {'M','u','t','e',0};
62 /* HWAVE (and HMIXER) format:
64 * XXXX... 1FDD DDDD IIII IIII
65 * X = unused (must be 0)
66 * 1 = the bit is set to 1, to avoid all-zero HWAVEs
67 * F = flow direction (0 = IN, 1 = OUT)
68 * D = index into g_out_mmdevices
69 * I = index in the mmdevice's devices array
71 * Two reasons that we don't just use pointers:
72 * - HWAVEs must fit into 16 bits for compatibility with old applications.
73 * - We must be able to identify bad devices without crashing.
76 #define MAX_DEVICES 256
78 typedef struct _WINMM_CBInfo
{
85 struct _WINMM_MMDevice
;
86 typedef struct _WINMM_MMDevice WINMM_MMDevice
;
88 typedef struct _WINMM_Device
{
97 IAudioRenderClient
*render
;
98 IAudioCaptureClient
*capture
;
100 IAudioStreamVolume
*volume
;
102 HACMSTREAM acm_handle
;
103 ACMSTREAMHEADER acm_hdr
;
106 WAVEHDR
*first
, *last
, *playing
, *loop_start
;
110 UINT32 bytes_per_frame
, samples_per_sec
, ofs_bytes
, played_frames
;
112 /* stored in frames of sample rate, *not* AC::GetFrequency */
113 UINT64 last_clock_pos
;
116 CRITICAL_SECTION lock
;
118 WINMM_MMDevice
*parent
;
121 struct _WINMM_MMDevice
{
122 WAVEOUTCAPSW out_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
123 WAVEINCAPSW in_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
126 ISimpleAudioVolume
*volume
;
130 /* HMIXER format is the same as the HWAVE format, but the I bits are
131 * replaced by the value of this counter, to keep each HMIXER unique */
134 CRITICAL_SECTION lock
;
136 WINMM_Device
*devices
[MAX_DEVICES
];
139 static WINMM_MMDevice
*g_out_mmdevices
;
140 static UINT g_outmmdevices_count
;
142 static WINMM_MMDevice
*g_in_mmdevices
;
143 static UINT g_inmmdevices_count
;
145 static IMMDeviceEnumerator
*g_devenum
;
147 static CRITICAL_SECTION g_devthread_lock
;
148 static HANDLE g_devices_thread
;
149 static HWND g_devices_hwnd
;
151 static UINT g_devhandle_count
;
152 static HANDLE
*g_device_handles
;
153 static WINMM_Device
**g_handle_devices
;
155 typedef struct _WINMM_OpenInfo
{
158 WAVEFORMATEX
*format
;
164 typedef struct _WINMM_ControlDetails
{
166 MIXERCONTROLDETAILS
*details
;
168 } WINMM_ControlDetails
;
170 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
);
171 static LRESULT
WOD_Close(HWAVEOUT hwave
);
172 static LRESULT
WID_Open(WINMM_OpenInfo
*info
);
173 static LRESULT
WID_Close(HWAVEIN hwave
);
175 BOOL
WINMM_InitWaveform(void)
177 InitializeCriticalSection(&g_devthread_lock
);
181 static inline HWAVE
WINMM_MakeHWAVE(UINT mmdevice
, BOOL is_out
, UINT device
)
183 return ULongToHandle((1 << 15) | ((!!is_out
) << 14) |
184 (mmdevice
<< 8) | device
);
187 static inline void WINMM_DecomposeHWAVE(HWAVE hwave
, UINT
*mmdevice_index
,
188 BOOL
*is_out
, UINT
*device_index
, UINT
*junk
)
190 ULONG32 l
= HandleToULong(hwave
);
191 *device_index
= l
& 0xFF;
192 *mmdevice_index
= (l
>> 8) & 0x3F;
193 *is_out
= (l
>> 14) & 0x1;
197 static void WINMM_InitDevice(WINMM_Device
*device
,
198 WINMM_MMDevice
*parent
, HWAVE hwave
)
200 InitializeCriticalSection(&device
->lock
);
201 device
->handle
= hwave
;
202 device
->parent
= parent
;
205 /* finds the first unused Device, marks it as "open", and returns
206 * a pointer to the device
208 * IMPORTANT: it is the caller's responsibility to release the device's lock
211 static WINMM_Device
*WINMM_FindUnusedDevice(BOOL is_out
, UINT mmdevice_index
)
213 WINMM_MMDevice
*mmdevice
;
217 mmdevice
= &g_out_mmdevices
[mmdevice_index
];
219 mmdevice
= &g_in_mmdevices
[mmdevice_index
];
221 EnterCriticalSection(&mmdevice
->lock
);
222 for(i
= 0; i
< MAX_DEVICES
; ++i
){
223 WINMM_Device
*device
= mmdevice
->devices
[i
];
226 device
= mmdevice
->devices
[i
] = HeapAlloc(GetProcessHeap(),
227 HEAP_ZERO_MEMORY
, sizeof(WINMM_Device
));
229 LeaveCriticalSection(&mmdevice
->lock
);
233 WINMM_InitDevice(device
, mmdevice
,
234 WINMM_MakeHWAVE(mmdevice_index
, is_out
, i
));
235 EnterCriticalSection(&device
->lock
);
237 EnterCriticalSection(&device
->lock
);
240 LeaveCriticalSection(&mmdevice
->lock
);
242 TRACE("Found free device: mmdevice: %u, device id: %u\n",
247 LeaveCriticalSection(&device
->lock
);
250 LeaveCriticalSection(&mmdevice
->lock
);
252 TRACE("All devices in use: mmdevice: %u\n", mmdevice_index
);
257 static inline BOOL
WINMM_ValidateAndLock(WINMM_Device
*device
)
262 EnterCriticalSection(&device
->lock
);
265 LeaveCriticalSection(&device
->lock
);
272 static WINMM_Device
*WINMM_GetDeviceFromHWAVE(HWAVE hwave
)
274 WINMM_MMDevice
*mmdevice
;
275 WINMM_Device
*device
;
276 UINT mmdevice_index
, device_index
, junk
;
279 WINMM_DecomposeHWAVE(hwave
, &mmdevice_index
, &is_out
, &device_index
, &junk
);
284 if(mmdevice_index
>= (is_out
? g_outmmdevices_count
: g_inmmdevices_count
))
288 mmdevice
= &g_out_mmdevices
[mmdevice_index
];
290 mmdevice
= &g_in_mmdevices
[mmdevice_index
];
292 EnterCriticalSection(&mmdevice
->lock
);
294 device
= mmdevice
->devices
[device_index
];
296 LeaveCriticalSection(&mmdevice
->lock
);
301 /* Note: NotifyClient should never be called while holding the device lock
302 * since the client may call wave* functions from within the callback. */
303 static inline void WINMM_NotifyClient(WINMM_CBInfo
*info
, WORD msg
, DWORD_PTR param1
,
306 DriverCallback(info
->callback
, info
->flags
, (HDRVR
)info
->hwave
,
307 msg
, info
->user
, param1
, param2
);
310 static HRESULT
WINMM_GetFriendlyName(IMMDevice
*device
, WCHAR
*out
,
317 hr
= IMMDevice_OpenPropertyStore(device
, STGM_READ
, &ps
);
321 PropVariantInit(&var
);
323 hr
= IPropertyStore_GetValue(ps
,
324 (PROPERTYKEY
*)&DEVPKEY_Device_FriendlyName
, &var
);
326 IPropertyStore_Release(ps
);
330 lstrcpynW(out
, var
.u
.pwszVal
, outlen
);
332 PropVariantClear(&var
);
334 IPropertyStore_Release(ps
);
339 static HRESULT
WINMM_TestFormat(IAudioClient
*client
, DWORD rate
, DWORD depth
,
342 WAVEFORMATEX fmt
, *junk
;
345 fmt
.wFormatTag
= WAVE_FORMAT_PCM
;
346 fmt
.nChannels
= channels
;
347 fmt
.nSamplesPerSec
= rate
;
348 fmt
.wBitsPerSample
= depth
;
349 fmt
.nBlockAlign
= (channels
* depth
) / 8;
350 fmt
.nAvgBytesPerSec
= rate
* fmt
.nBlockAlign
;
353 hr
= IAudioClient_IsFormatSupported(client
, AUDCLNT_SHAREMODE_SHARED
,
361 static struct _TestFormat
{
366 } formats_to_test
[] = {
367 { WAVE_FORMAT_1M08
, 11025, 8, 1 },
368 { WAVE_FORMAT_1M16
, 11025, 16, 1 },
369 { WAVE_FORMAT_1S08
, 11025, 8, 2 },
370 { WAVE_FORMAT_1S16
, 11025, 16, 2 },
371 { WAVE_FORMAT_2M08
, 22050, 8, 1 },
372 { WAVE_FORMAT_2M16
, 22050, 16, 1 },
373 { WAVE_FORMAT_2S08
, 22050, 8, 2 },
374 { WAVE_FORMAT_2S16
, 22050, 16, 2 },
375 { WAVE_FORMAT_4M08
, 44100, 8, 1 },
376 { WAVE_FORMAT_4M16
, 44100, 16, 1 },
377 { WAVE_FORMAT_4S08
, 44100, 8, 2 },
378 { WAVE_FORMAT_4S16
, 44100, 16, 2 },
379 { WAVE_FORMAT_48M08
, 48000, 8, 1 },
380 { WAVE_FORMAT_48M16
, 48000, 16, 1 },
381 { WAVE_FORMAT_48S08
, 48000, 8, 2 },
382 { WAVE_FORMAT_48S16
, 48000, 16, 2 },
383 { WAVE_FORMAT_96M08
, 96000, 8, 1 },
384 { WAVE_FORMAT_96M16
, 96000, 16, 1 },
385 { WAVE_FORMAT_96S08
, 96000, 8, 2 },
386 { WAVE_FORMAT_96S16
, 96000, 16, 2 },
390 static DWORD
WINMM_GetSupportedFormats(IMMDevice
*device
)
394 struct _TestFormat
*fmt
;
395 IAudioClient
*client
;
397 hr
= IMMDevice_Activate(device
, &IID_IAudioClient
,
398 CLSCTX_INPROC_SERVER
, NULL
, (void**)&client
);
402 for(fmt
= formats_to_test
; fmt
->flag
; ++fmt
){
403 hr
= WINMM_TestFormat(client
, fmt
->rate
, fmt
->depth
, fmt
->channels
);
408 IAudioClient_Release(client
);
413 static HRESULT
WINMM_InitMMDevice(EDataFlow flow
, IMMDevice
*device
,
414 WINMM_MMDevice
*dev
, UINT index
)
419 dev
->out_caps
.wMid
= 0xFF;
420 dev
->out_caps
.wPid
= 0xFF;
421 dev
->out_caps
.vDriverVersion
= 0x00010001;
422 dev
->out_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
423 dev
->out_caps
.wReserved1
= 0;
424 dev
->out_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
425 WAVECAPS_SAMPLEACCURATE
;
426 dev
->out_caps
.wChannels
= 2;
427 dev
->out_caps
.szPname
[0] = '\0';
429 hr
= WINMM_GetFriendlyName(device
, dev
->out_caps
.szPname
,
430 sizeof(dev
->out_caps
.szPname
) /
431 sizeof(*dev
->out_caps
.szPname
));
435 dev
->in_caps
.wMid
= 0xFF;
436 dev
->in_caps
.wPid
= 0xFF;
437 dev
->in_caps
.vDriverVersion
= 0x00010001;
438 dev
->in_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
439 dev
->in_caps
.wReserved1
= 0;
440 dev
->in_caps
.wChannels
= 2;
441 dev
->in_caps
.szPname
[0] = '\0';
443 hr
= WINMM_GetFriendlyName(device
, dev
->in_caps
.szPname
,
444 sizeof(dev
->in_caps
.szPname
) /
445 sizeof(*dev
->in_caps
.szPname
));
450 hr
= IMMDevice_GetId(device
, &dev
->dev_id
);
454 CoCreateGuid(&dev
->session
);
456 InitializeCriticalSection(&dev
->lock
);
461 static HRESULT
WINMM_EnumDevices(WINMM_MMDevice
**devices
, UINT
*devcount
,
464 IMMDeviceCollection
*devcoll
;
467 hr
= IMMDeviceEnumerator_EnumAudioEndpoints(g_devenum
, flow
,
468 DEVICE_STATE_ACTIVE
, &devcoll
);
472 hr
= IMMDeviceCollection_GetCount(devcoll
, devcount
);
474 IMMDeviceCollection_Release(devcoll
);
480 IMMDevice
*def_dev
= NULL
;
482 *devices
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
483 sizeof(WINMM_MMDevice
) * (*devcount
));
485 IMMDeviceCollection_Release(devcoll
);
486 return E_OUTOFMEMORY
;
491 /* make sure that device 0 is the default device */
492 hr
= IMMDeviceEnumerator_GetDefaultAudioEndpoint(g_devenum
,
493 flow
, eConsole
, &def_dev
);
495 WINMM_InitMMDevice(flow
, def_dev
, &(*devices
)[0], 0);
499 for(n
= 0; n
< *devcount
; ++n
){
502 hr
= IMMDeviceCollection_Item(devcoll
, n
, &device
);
504 if(device
!= def_dev
){
505 WINMM_InitMMDevice(flow
, device
, &(*devices
)[count
], count
);
509 IMMDevice_Release(device
);
514 IMMDevice_Release(def_dev
);
519 IMMDeviceCollection_Release(devcoll
);
524 static HRESULT
WINMM_InitMMDevices(void)
528 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
,
529 CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&g_devenum
);
533 hr
= WINMM_EnumDevices(&g_out_mmdevices
, &g_outmmdevices_count
, eRender
);
535 g_outmmdevices_count
= 0;
536 g_inmmdevices_count
= 0;
540 hr
= WINMM_EnumDevices(&g_in_mmdevices
, &g_inmmdevices_count
, eCapture
);
542 g_inmmdevices_count
= 0;
549 static inline BOOL
WINMM_IsMapper(UINT device
)
551 return (device
== WAVE_MAPPER
|| device
== (UINT16
)WAVE_MAPPER
);
554 static MMRESULT
WINMM_TryDeviceMapping(WINMM_OpenInfo
*info
, WORD channels
,
555 DWORD freq
, DWORD bits_per_samp
, BOOL is_out
)
557 WINMM_Device
*device
;
562 TRACE("format: %u, channels: %u, sample rate: %u, bit depth: %u\n",
563 WAVE_FORMAT_PCM
, channels
, freq
, bits_per_samp
);
565 target
.wFormatTag
= WAVE_FORMAT_PCM
;
566 target
.nChannels
= channels
;
567 target
.nSamplesPerSec
= freq
;
568 target
.wBitsPerSample
= bits_per_samp
;
569 target
.nBlockAlign
= (target
.nChannels
* target
.wBitsPerSample
) / 8;
570 target
.nAvgBytesPerSec
= target
.nSamplesPerSec
* target
.nBlockAlign
;
574 mr
= acmStreamOpen(NULL
, NULL
, info
->format
, &target
, NULL
, 0,
575 0, ACM_STREAMOPENF_QUERY
);
577 mr
= acmStreamOpen(NULL
, NULL
, &target
, info
->format
, NULL
, 0,
578 0, ACM_STREAMOPENF_QUERY
);
579 if(mr
!= MMSYSERR_NOERROR
)
582 /* ACM can convert from src->dst, so try to find a device
583 * that supports dst */
585 if(WINMM_IsMapper(info
->req_device
)){
586 for(i
= 0; i
< g_outmmdevices_count
; ++i
){
587 WINMM_OpenInfo l_info
= *info
;
588 l_info
.req_device
= i
;
589 l_info
.format
= &target
;
590 mr
= WOD_Open(&l_info
);
591 if(mr
== MMSYSERR_NOERROR
){
592 info
->handle
= l_info
.handle
;
597 WINMM_OpenInfo l_info
= *info
;
598 l_info
.flags
&= ~WAVE_MAPPED
;
599 l_info
.format
= &target
;
600 mr
= WOD_Open(&l_info
);
601 if(mr
== MMSYSERR_NOERROR
)
602 info
->handle
= l_info
.handle
;
605 if(WINMM_IsMapper(info
->req_device
)){
606 for(i
= 0; i
< g_inmmdevices_count
; ++i
){
607 WINMM_OpenInfo l_info
= *info
;
608 l_info
.req_device
= i
;
609 l_info
.format
= &target
;
610 mr
= WID_Open(&l_info
);
611 if(mr
== MMSYSERR_NOERROR
){
612 info
->handle
= l_info
.handle
;
617 WINMM_OpenInfo l_info
= *info
;
618 l_info
.flags
&= ~WAVE_MAPPED
;
619 l_info
.format
= &target
;
620 mr
= WID_Open(&l_info
);
621 if(mr
== MMSYSERR_NOERROR
)
622 info
->handle
= l_info
.handle
;
625 if(mr
!= MMSYSERR_NOERROR
)
626 return WAVERR_BADFORMAT
;
628 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)info
->handle
);
630 return MMSYSERR_INVALHANDLE
;
632 /* set up the ACM stream */
634 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, info
->format
, &target
,
637 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, &target
, info
->format
,
639 if(mr
!= MMSYSERR_NOERROR
){
641 WOD_Close((HWAVEOUT
)info
->handle
);
643 WID_Close((HWAVEIN
)info
->handle
);
648 return MMSYSERR_NOERROR
;
651 static MMRESULT
WINMM_MapDevice(WINMM_OpenInfo
*info
, BOOL is_out
)
655 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)info
->format
;
657 TRACE("(%p, %d)\n", info
, is_out
);
659 /* try to find a direct match */
661 WINMM_OpenInfo l_info
= *info
;
662 if(WINMM_IsMapper(info
->req_device
)){
663 for(i
= 0; i
< g_outmmdevices_count
; ++i
){
664 l_info
.req_device
= i
;
665 mr
= WOD_Open(&l_info
);
666 if(mr
== MMSYSERR_NOERROR
){
667 info
->handle
= l_info
.handle
;
672 l_info
.flags
&= ~WAVE_MAPPED
;
673 mr
= WOD_Open(&l_info
);
674 if(mr
== MMSYSERR_NOERROR
){
675 info
->handle
= l_info
.handle
;
680 WINMM_OpenInfo l_info
= *info
;
681 if(WINMM_IsMapper(info
->req_device
)){
682 for(i
= 0; i
< g_inmmdevices_count
; ++i
){
683 l_info
.req_device
= i
;
684 mr
= WID_Open(&l_info
);
685 if(mr
== MMSYSERR_NOERROR
){
686 info
->handle
= l_info
.handle
;
691 l_info
.flags
&= ~WAVE_MAPPED
;
692 mr
= WID_Open(&l_info
);
693 if(mr
== MMSYSERR_NOERROR
){
694 info
->handle
= l_info
.handle
;
700 /* no direct match, so set up the ACM stream */
701 if(info
->format
->wFormatTag
!= WAVE_FORMAT_PCM
&&
702 !(info
->format
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
703 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))){
704 /* convert to PCM format if it's not already */
705 mr
= WINMM_TryDeviceMapping(info
, info
->format
->nChannels
,
706 info
->format
->nSamplesPerSec
, 16, is_out
);
707 if(mr
== MMSYSERR_NOERROR
)
710 mr
= WINMM_TryDeviceMapping(info
, info
->format
->nChannels
,
711 info
->format
->nSamplesPerSec
, 8, is_out
);
712 if(mr
== MMSYSERR_NOERROR
)
717 /* first try just changing bit depth and channels */
718 channels
= info
->format
->nChannels
;
719 mr
= WINMM_TryDeviceMapping(info
, channels
,
720 info
->format
->nSamplesPerSec
, 16, is_out
);
721 if(mr
== MMSYSERR_NOERROR
)
723 mr
= WINMM_TryDeviceMapping(info
, channels
,
724 info
->format
->nSamplesPerSec
, 8, is_out
);
725 if(mr
== MMSYSERR_NOERROR
)
728 channels
= (channels
== 2) ? 1 : 2;
729 mr
= WINMM_TryDeviceMapping(info
, channels
,
730 info
->format
->nSamplesPerSec
, 16, is_out
);
731 if(mr
== MMSYSERR_NOERROR
)
733 mr
= WINMM_TryDeviceMapping(info
, channels
,
734 info
->format
->nSamplesPerSec
, 8, is_out
);
735 if(mr
== MMSYSERR_NOERROR
)
738 /* that didn't work, so now try different sample rates */
739 channels
= info
->format
->nChannels
;
740 mr
= WINMM_TryDeviceMapping(info
, channels
, 96000, 16, is_out
);
741 if(mr
== MMSYSERR_NOERROR
)
743 mr
= WINMM_TryDeviceMapping(info
, channels
, 48000, 16, is_out
);
744 if(mr
== MMSYSERR_NOERROR
)
746 mr
= WINMM_TryDeviceMapping(info
, channels
, 44100, 16, is_out
);
747 if(mr
== MMSYSERR_NOERROR
)
749 mr
= WINMM_TryDeviceMapping(info
, channels
, 22050, 16, is_out
);
750 if(mr
== MMSYSERR_NOERROR
)
752 mr
= WINMM_TryDeviceMapping(info
, channels
, 11025, 16, is_out
);
753 if(mr
== MMSYSERR_NOERROR
)
756 channels
= (channels
== 2) ? 1 : 2;
757 mr
= WINMM_TryDeviceMapping(info
, channels
, 96000, 16, is_out
);
758 if(mr
== MMSYSERR_NOERROR
)
760 mr
= WINMM_TryDeviceMapping(info
, channels
, 48000, 16, is_out
);
761 if(mr
== MMSYSERR_NOERROR
)
763 mr
= WINMM_TryDeviceMapping(info
, channels
, 44100, 16, is_out
);
764 if(mr
== MMSYSERR_NOERROR
)
766 mr
= WINMM_TryDeviceMapping(info
, channels
, 22050, 16, is_out
);
767 if(mr
== MMSYSERR_NOERROR
)
769 mr
= WINMM_TryDeviceMapping(info
, channels
, 11025, 16, is_out
);
770 if(mr
== MMSYSERR_NOERROR
)
773 channels
= info
->format
->nChannels
;
774 mr
= WINMM_TryDeviceMapping(info
, channels
, 96000, 8, is_out
);
775 if(mr
== MMSYSERR_NOERROR
)
777 mr
= WINMM_TryDeviceMapping(info
, channels
, 48000, 8, is_out
);
778 if(mr
== MMSYSERR_NOERROR
)
780 mr
= WINMM_TryDeviceMapping(info
, channels
, 44100, 8, is_out
);
781 if(mr
== MMSYSERR_NOERROR
)
783 mr
= WINMM_TryDeviceMapping(info
, channels
, 22050, 8, is_out
);
784 if(mr
== MMSYSERR_NOERROR
)
786 mr
= WINMM_TryDeviceMapping(info
, channels
, 11025, 8, is_out
);
787 if(mr
== MMSYSERR_NOERROR
)
790 channels
= (channels
== 2) ? 1 : 2;
791 mr
= WINMM_TryDeviceMapping(info
, channels
, 96000, 8, is_out
);
792 if(mr
== MMSYSERR_NOERROR
)
794 mr
= WINMM_TryDeviceMapping(info
, channels
, 48000, 8, is_out
);
795 if(mr
== MMSYSERR_NOERROR
)
797 mr
= WINMM_TryDeviceMapping(info
, channels
, 44100, 8, is_out
);
798 if(mr
== MMSYSERR_NOERROR
)
800 mr
= WINMM_TryDeviceMapping(info
, channels
, 22050, 8, is_out
);
801 if(mr
== MMSYSERR_NOERROR
)
803 mr
= WINMM_TryDeviceMapping(info
, channels
, 11025, 8, is_out
);
804 if(mr
== MMSYSERR_NOERROR
)
808 WARN("Unable to find compatible device!\n");
809 return WAVERR_BADFORMAT
;
812 static LRESULT
WINMM_OpenDevice(WINMM_Device
*device
, WINMM_MMDevice
*mmdevice
,
813 WINMM_OpenInfo
*info
)
815 WAVEFORMATEX
*closer_fmt
= NULL
, fmt
, *passed_fmt
;
816 LRESULT ret
= MMSYSERR_ERROR
;
819 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
,
822 ERR("Device %s (%s) unavailable: %08x\n",
823 wine_dbgstr_w(mmdevice
->dev_id
),
824 wine_dbgstr_w(mmdevice
->out_caps
.szPname
), hr
);
828 hr
= IMMDevice_Activate(device
->device
, &IID_IAudioClient
,
829 CLSCTX_INPROC_SERVER
, NULL
, (void**)&device
->client
);
831 ERR("Activate failed: %08x\n", hr
);
835 if(info
->format
->wFormatTag
== WAVE_FORMAT_PCM
){
836 /* we aren't guaranteed that the struct in lpFormat is a full
837 * WAVEFORMATEX struct, which IAC::IsFormatSupported requires */
839 memcpy(passed_fmt
, info
->format
, sizeof(PCMWAVEFORMAT
));
840 passed_fmt
->cbSize
= 0;
842 passed_fmt
= info
->format
;
844 hr
= IAudioClient_IsFormatSupported(device
->client
,
845 AUDCLNT_SHAREMODE_SHARED
, passed_fmt
, &closer_fmt
);
847 CoTaskMemFree(closer_fmt
);
848 if(FAILED(hr
) && hr
!= AUDCLNT_E_UNSUPPORTED_FORMAT
){
849 ERR("IsFormatSupported failed: %08x\n", hr
);
852 if(hr
== S_FALSE
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
){
853 ret
= WAVERR_BADFORMAT
;
856 if(info
->flags
& WAVE_FORMAT_QUERY
){
857 ret
= MMSYSERR_NOERROR
;
861 /* buffer size = 10 * 100000 (100 ns) = 0.1 seconds */
862 hr
= IAudioClient_Initialize(device
->client
, AUDCLNT_SHAREMODE_SHARED
,
863 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
| AUDCLNT_STREAMFLAGS_NOPERSIST
,
864 10 * 100000, 50000, passed_fmt
, &device
->parent
->session
);
866 ERR("Initialize failed: %08x\n", hr
);
870 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioClock
,
871 (void**)&device
->clock
);
873 ERR("GetService failed: %08x\n", hr
);
878 device
->event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
880 ERR("CreateEvent failed: %08x\n", hr
);
884 /* As the devices thread is waiting on g_device_handles, it can
885 * only be modified from within this same thread. */
886 if(g_device_handles
){
887 g_device_handles
= HeapReAlloc(GetProcessHeap(), 0, g_device_handles
,
888 sizeof(HANDLE
) * (g_devhandle_count
+ 1));
889 g_handle_devices
= HeapReAlloc(GetProcessHeap(), 0, g_handle_devices
,
890 sizeof(WINMM_Device
*) * (g_devhandle_count
+ 1));
892 g_device_handles
= HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE
));
893 g_handle_devices
= HeapAlloc(GetProcessHeap(), 0,
894 sizeof(WINMM_Device
*));
896 g_device_handles
[g_devhandle_count
] = device
->event
;
897 g_handle_devices
[g_devhandle_count
] = device
;
901 hr
= IAudioClient_SetEventHandle(device
->client
, device
->event
);
903 ERR("SetEventHandle failed: %08x\n", hr
);
907 device
->bytes_per_frame
= info
->format
->nBlockAlign
;
908 device
->samples_per_sec
= info
->format
->nSamplesPerSec
;
910 device
->played_frames
= 0;
911 device
->last_clock_pos
= 0;
912 device
->ofs_bytes
= 0;
913 device
->loop_counter
= 0;
914 device
->stopped
= TRUE
;
915 device
->first
= device
->last
= device
->playing
= device
->loop_start
= NULL
;
917 device
->cb_info
.flags
= HIWORD(info
->flags
& CALLBACK_TYPEMASK
);
918 device
->cb_info
.callback
= info
->callback
;
919 device
->cb_info
.user
= info
->cb_user
;
920 device
->cb_info
.hwave
= (HWAVE
)device
->handle
;
922 info
->handle
= device
->handle
;
924 return MMSYSERR_NOERROR
;
928 IAudioClient_Release(device
->client
);
929 device
->client
= NULL
;
932 IMMDevice_Release(device
->device
);
933 device
->device
= NULL
;
939 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
)
941 WINMM_MMDevice
*mmdevice
;
942 WINMM_Device
*device
= NULL
;
943 LRESULT ret
= MMSYSERR_ERROR
;
946 TRACE("(%u, %p, %08x)\n", info
->req_device
, info
, info
->flags
);
948 if(WINMM_IsMapper(info
->req_device
) || (info
->flags
& WAVE_MAPPED
))
949 return WINMM_MapDevice(info
, TRUE
);
951 if(info
->req_device
>= g_outmmdevices_count
)
952 return MMSYSERR_BADDEVICEID
;
954 mmdevice
= &g_out_mmdevices
[info
->req_device
];
956 if(!mmdevice
->out_caps
.szPname
[0])
957 return MMSYSERR_NOTENABLED
;
959 device
= WINMM_FindUnusedDevice(TRUE
, info
->req_device
);
961 return MMSYSERR_ALLOCATED
;
963 ret
= WINMM_OpenDevice(device
, mmdevice
, info
);
964 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
966 ret
= MMSYSERR_ERROR
;
968 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioRenderClient
,
969 (void**)&device
->render
);
971 ERR("GetService failed: %08x\n", hr
);
975 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioStreamVolume
,
976 (void**)&device
->volume
);
978 ERR("GetService failed: %08x\n", hr
);
982 LeaveCriticalSection(&device
->lock
);
984 return MMSYSERR_NOERROR
;
988 IMMDevice_Release(device
->device
);
989 device
->device
= NULL
;
992 IAudioClient_Release(device
->client
);
993 device
->client
= NULL
;
996 IAudioRenderClient_Release(device
->render
);
997 device
->render
= NULL
;
1000 IAudioStreamVolume_Release(device
->volume
);
1001 device
->volume
= NULL
;
1004 IAudioClock_Release(device
->clock
);
1005 device
->clock
= NULL
;
1007 device
->open
= FALSE
;
1008 LeaveCriticalSection(&device
->lock
);
1012 static LRESULT
WID_Open(WINMM_OpenInfo
*info
)
1014 WINMM_MMDevice
*mmdevice
;
1015 WINMM_Device
*device
= NULL
;
1016 LRESULT ret
= MMSYSERR_ERROR
;
1019 TRACE("(%u, %p, %08x)\n", info
->req_device
, info
, info
->flags
);
1021 if(WINMM_IsMapper(info
->req_device
) || info
->flags
& WAVE_MAPPED
)
1022 return WINMM_MapDevice(info
, FALSE
);
1024 if(info
->req_device
>= g_inmmdevices_count
)
1025 return MMSYSERR_BADDEVICEID
;
1027 mmdevice
= &g_in_mmdevices
[info
->req_device
];
1029 if(!mmdevice
->in_caps
.szPname
[0])
1030 return MMSYSERR_NOTENABLED
;
1032 device
= WINMM_FindUnusedDevice(FALSE
, info
->req_device
);
1034 return MMSYSERR_ALLOCATED
;
1036 ret
= WINMM_OpenDevice(device
, mmdevice
, info
);
1037 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
1039 ret
= MMSYSERR_ERROR
;
1041 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioCaptureClient
,
1042 (void**)&device
->capture
);
1044 ERR("GetService failed: %08x\n", hr
);
1048 LeaveCriticalSection(&device
->lock
);
1050 return MMSYSERR_NOERROR
;
1054 IMMDevice_Release(device
->device
);
1055 device
->device
= NULL
;
1058 IAudioClient_Release(device
->client
);
1059 device
->client
= NULL
;
1061 if(device
->capture
){
1062 IAudioCaptureClient_Release(device
->capture
);
1063 device
->capture
= NULL
;
1066 IAudioClock_Release(device
->clock
);
1067 device
->clock
= NULL
;
1069 device
->open
= FALSE
;
1070 LeaveCriticalSection(&device
->lock
);
1074 static HRESULT
WINMM_CloseDevice(WINMM_Device
*device
)
1076 device
->open
= FALSE
;
1078 if(!device
->stopped
){
1079 IAudioClient_Stop(device
->client
);
1080 device
->stopped
= TRUE
;
1083 if(device
->acm_handle
){
1084 acmStreamClose(device
->acm_handle
, 0);
1085 device
->acm_handle
= NULL
;
1088 IMMDevice_Release(device
->device
);
1089 device
->device
= NULL
;
1091 IAudioClient_Release(device
->client
);
1092 device
->client
= NULL
;
1094 IAudioClock_Release(device
->clock
);
1095 device
->clock
= NULL
;
1100 static LRESULT
WOD_Close(HWAVEOUT hwave
)
1102 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1104 TRACE("(%p)\n", hwave
);
1106 if(!WINMM_ValidateAndLock(device
))
1107 return MMSYSERR_INVALHANDLE
;
1109 WINMM_CloseDevice(device
);
1111 IAudioRenderClient_Release(device
->render
);
1112 device
->render
= NULL
;
1114 IAudioStreamVolume_Release(device
->volume
);
1115 device
->volume
= NULL
;
1117 LeaveCriticalSection(&device
->lock
);
1119 return MMSYSERR_NOERROR
;
1122 static LRESULT
WID_Close(HWAVEIN hwave
)
1124 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1126 TRACE("(%p)\n", hwave
);
1128 if(!WINMM_ValidateAndLock(device
))
1129 return MMSYSERR_INVALHANDLE
;
1131 WINMM_CloseDevice(device
);
1133 IAudioCaptureClient_Release(device
->capture
);
1134 device
->capture
= NULL
;
1136 LeaveCriticalSection(&device
->lock
);
1138 return MMSYSERR_NOERROR
;
1141 static LRESULT
WINMM_PrepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1143 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1145 TRACE("(%p, %p)\n", hwave
, header
);
1147 if(!WINMM_ValidateAndLock(device
))
1148 return MMSYSERR_INVALHANDLE
;
1150 if(device
->render
&& device
->acm_handle
){
1151 ACMSTREAMHEADER
*ash
;
1155 mr
= acmStreamSize(device
->acm_handle
, header
->dwBufferLength
, &size
,
1156 ACM_STREAMSIZEF_SOURCE
);
1157 if(mr
!= MMSYSERR_NOERROR
){
1158 LeaveCriticalSection(&device
->lock
);
1162 ash
= HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER
) + size
);
1164 LeaveCriticalSection(&device
->lock
);
1165 return MMSYSERR_NOMEM
;
1168 ash
->cbStruct
= sizeof(*ash
);
1170 ash
->dwUser
= (DWORD_PTR
)header
;
1171 ash
->pbSrc
= (BYTE
*)header
->lpData
;
1172 ash
->cbSrcLength
= header
->dwBufferLength
;
1173 ash
->dwSrcUser
= header
->dwUser
;
1174 ash
->pbDst
= (BYTE
*)ash
+ sizeof(ACMSTREAMHEADER
);
1175 ash
->cbDstLength
= size
;
1178 mr
= acmStreamPrepareHeader(device
->acm_handle
, ash
, 0);
1179 if(mr
!= MMSYSERR_NOERROR
){
1180 HeapFree(GetProcessHeap(), 0, ash
);
1181 LeaveCriticalSection(&device
->lock
);
1185 header
->reserved
= (DWORD_PTR
)ash
;
1188 LeaveCriticalSection(&device
->lock
);
1190 header
->dwFlags
|= WHDR_PREPARED
;
1191 header
->dwFlags
&= ~WHDR_DONE
;
1193 return MMSYSERR_NOERROR
;
1196 static LRESULT
WINMM_UnprepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1198 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1200 TRACE("(%p, %p)\n", hwave
, header
);
1202 if(!WINMM_ValidateAndLock(device
))
1203 return MMSYSERR_INVALHANDLE
;
1205 if(device
->render
&& device
->acm_handle
){
1206 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1208 acmStreamUnprepareHeader(device
->acm_handle
, ash
, 0);
1210 HeapFree(GetProcessHeap(), 0, ash
);
1213 LeaveCriticalSection(&device
->lock
);
1215 header
->dwFlags
&= ~WHDR_PREPARED
;
1216 header
->dwFlags
|= WHDR_DONE
;
1218 return MMSYSERR_NOERROR
;
1221 static UINT32
WINMM_HeaderLenBytes(WINMM_Device
*device
, WAVEHDR
*header
)
1223 if(device
->acm_handle
){
1224 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1225 return ash
->cbDstLengthUsed
;
1228 return header
->dwBufferLength
;
1231 static UINT32
WINMM_HeaderLenFrames(WINMM_Device
*device
, WAVEHDR
*header
)
1233 return WINMM_HeaderLenBytes(device
, header
) / device
->bytes_per_frame
;
1236 static WAVEHDR
*WOD_MarkDoneHeaders(WINMM_Device
*device
)
1239 WAVEHDR
*queue
, *first
= device
->first
;
1240 UINT64 clock_freq
, clock_pos
, clock_frames
;
1241 UINT32 nloops
, queue_frames
= 0;
1243 hr
= IAudioClock_GetFrequency(device
->clock
, &clock_freq
);
1245 ERR("GetFrequency failed: %08x\n", hr
);
1249 hr
= IAudioClock_GetPosition(device
->clock
, &clock_pos
, NULL
);
1251 ERR("GetPosition failed: %08x\n", hr
);
1255 clock_frames
= (clock_pos
/ (double)clock_freq
) * device
->samples_per_sec
;
1257 first
= queue
= device
->first
;
1258 nloops
= device
->loop_counter
;
1260 (queue_frames
+= WINMM_HeaderLenFrames(device
, queue
)) <=
1261 clock_frames
- device
->last_clock_pos
){
1263 device
->first
->dwFlags
&= ~WHDR_INQUEUE
;
1264 device
->first
->dwFlags
|= WHDR_DONE
;
1265 device
->last_clock_pos
+= queue_frames
;
1267 queue
= device
->first
= queue
->lpNext
;
1269 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1270 if(queue
->dwFlags
& WHDR_ENDLOOP
)
1273 queue
= queue
->lpNext
;
1274 }else if(queue
->dwFlags
& WHDR_ENDLOOP
){
1275 queue
= device
->loop_start
;
1284 static void WOD_PushData(WINMM_Device
*device
)
1286 WINMM_CBInfo cb_info
;
1288 UINT32 pad
, bufsize
, avail_frames
, queue_frames
, written
, ofs
;
1289 UINT32 queue_bytes
, nloops
;
1291 WAVEHDR
*queue
, *first
= NULL
;
1293 TRACE("(%p)\n", device
->handle
);
1295 EnterCriticalSection(&device
->lock
);
1301 device
->stopped
= TRUE
;
1302 device
->last_clock_pos
= 0;
1303 IAudioClient_Stop(device
->client
);
1304 IAudioClient_Reset(device
->client
);
1308 hr
= IAudioClient_GetBufferSize(device
->client
, &bufsize
);
1310 ERR("GetBufferSize failed: %08x\n", hr
);
1314 hr
= IAudioClient_GetCurrentPadding(device
->client
, &pad
);
1316 ERR("GetCurrentPadding failed: %08x\n", hr
);
1320 first
= WOD_MarkDoneHeaders(device
);
1322 /* determine which is larger between the available buffer size and
1323 * the amount of data left in the queue */
1324 avail_frames
= bufsize
- pad
;
1326 queue
= device
->playing
;
1327 ofs
= device
->ofs_bytes
;
1330 while(queue
&& queue_frames
< avail_frames
){
1331 queue_bytes
= WINMM_HeaderLenBytes(device
, queue
);
1332 queue_frames
= (queue_bytes
- ofs
) / device
->bytes_per_frame
;
1336 if(queue
->dwFlags
& WHDR_ENDLOOP
&& nloops
< device
->loop_counter
){
1337 queue
= device
->loop_start
;
1340 queue
= queue
->lpNext
;
1343 if(avail_frames
!= 0 && queue_frames
== 0){
1344 hr
= IAudioRenderClient_GetBuffer(device
->render
, avail_frames
, &data
);
1346 ERR("GetBuffer failed: %08x\n", hr
);
1350 hr
= IAudioRenderClient_ReleaseBuffer(device
->render
, avail_frames
,
1351 AUDCLNT_BUFFERFLAGS_SILENT
);
1353 ERR("ReleaseBuffer failed: %08x\n", hr
);
1360 if(queue_frames
< avail_frames
)
1361 avail_frames
= queue_frames
;
1362 if(avail_frames
== 0)
1365 hr
= IAudioRenderClient_GetBuffer(device
->render
, avail_frames
, &data
);
1367 ERR("GetBuffer failed: %08x\n", hr
);
1372 while(device
->playing
&& written
< avail_frames
){
1373 UINT32 copy_frames
, copy_bytes
;
1376 queue
= device
->playing
;
1378 if(device
->acm_handle
){
1379 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)queue
->reserved
;
1380 queue_bytes
= ash
->cbDstLengthUsed
;
1381 queue_data
= ash
->pbDst
;
1383 queue_bytes
= queue
->dwBufferLength
;
1384 queue_data
= (BYTE
*)queue
->lpData
;
1387 queue_frames
= (queue_bytes
- device
->ofs_bytes
) /
1388 device
->bytes_per_frame
;
1390 copy_frames
= queue_frames
< (avail_frames
- written
) ?
1391 queue_frames
: avail_frames
- written
;
1392 copy_bytes
= copy_frames
* device
->bytes_per_frame
;
1394 memcpy(data
, queue_data
+ device
->ofs_bytes
, copy_bytes
);
1397 written
+= copy_frames
;
1398 device
->ofs_bytes
+= copy_bytes
;
1400 if(device
->ofs_bytes
>= queue_bytes
){
1401 device
->ofs_bytes
= 0;
1403 if(!(queue
->dwFlags
& (WHDR_BEGINLOOP
| WHDR_ENDLOOP
)))
1404 device
->playing
= queue
->lpNext
;
1406 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1407 device
->loop_start
= device
->playing
;
1408 device
->playing
= queue
->lpNext
;
1409 device
->loop_counter
= queue
->dwLoops
;
1411 if(queue
->dwFlags
& WHDR_ENDLOOP
){
1412 --device
->loop_counter
;
1413 if(device
->loop_counter
)
1414 device
->playing
= device
->loop_start
;
1416 device
->loop_start
= device
->playing
= queue
->lpNext
;
1422 hr
= IAudioRenderClient_ReleaseBuffer(device
->render
, avail_frames
, 0);
1424 ERR("ReleaseBuffer failed: %08x\n", hr
);
1428 device
->played_frames
+= avail_frames
;
1431 cb_info
= device
->cb_info
;
1433 LeaveCriticalSection(&device
->lock
);
1435 while(first
&& (first
->dwFlags
& WHDR_DONE
)){
1436 WAVEHDR
*next
= first
->lpNext
;
1437 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
1442 static void WID_PullACMData(WINMM_Device
*device
)
1444 UINT32 packet
, packet_bytes
;
1451 if(device
->acm_hdr
.cbDstLength
== 0){
1452 hr
= IAudioClient_GetCurrentPadding(device
->client
, &packet
);
1454 ERR("GetCurrentPadding failed: %08x\n", hr
);
1461 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet
,
1462 &flags
, NULL
, NULL
);
1464 ERR("GetBuffer failed: %08x\n", hr
);
1468 acmStreamSize(device
->acm_handle
, packet
* device
->bytes_per_frame
,
1469 &packet_bytes
, ACM_STREAMSIZEF_SOURCE
);
1471 device
->acm_offs
= 0;
1473 device
->acm_hdr
.cbStruct
= sizeof(device
->acm_hdr
);
1474 device
->acm_hdr
.fdwStatus
= 0;
1475 device
->acm_hdr
.dwUser
= 0;
1476 device
->acm_hdr
.pbSrc
= data
;
1477 device
->acm_hdr
.cbSrcLength
= packet
* device
->bytes_per_frame
;
1478 device
->acm_hdr
.cbSrcLengthUsed
= 0;
1479 device
->acm_hdr
.dwSrcUser
= 0;
1480 device
->acm_hdr
.pbDst
= HeapAlloc(GetProcessHeap(), 0, packet_bytes
);
1481 device
->acm_hdr
.cbDstLength
= packet_bytes
;
1482 device
->acm_hdr
.cbDstLengthUsed
= 0;
1483 device
->acm_hdr
.dwDstUser
= 0;
1485 mr
= acmStreamPrepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1486 if(mr
!= MMSYSERR_NOERROR
){
1487 ERR("acmStreamPrepareHeader failed: %d\n", mr
);
1491 mr
= acmStreamConvert(device
->acm_handle
, &device
->acm_hdr
, 0);
1492 if(mr
!= MMSYSERR_NOERROR
){
1493 ERR("acmStreamConvert failed: %d\n", mr
);
1497 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet
);
1499 ERR("ReleaseBuffer failed: %08x\n", hr
);
1502 queue
= device
->first
;
1504 UINT32 to_copy_bytes
;
1506 to_copy_bytes
= min(queue
->dwBufferLength
- queue
->dwBytesRecorded
,
1507 device
->acm_hdr
.cbDstLengthUsed
- device
->acm_offs
);
1509 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
,
1510 device
->acm_hdr
.pbDst
+ device
->acm_offs
, to_copy_bytes
);
1512 queue
->dwBytesRecorded
+= to_copy_bytes
;
1513 device
->acm_offs
+= to_copy_bytes
;
1515 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1516 device
->bytes_per_frame
){
1517 queue
->dwFlags
&= ~WHDR_INQUEUE
;
1518 queue
->dwFlags
|= WHDR_DONE
;
1519 device
->first
= queue
= queue
->lpNext
;
1522 if(device
->acm_offs
>= device
->acm_hdr
.cbDstLengthUsed
){
1523 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1524 HeapFree(GetProcessHeap(), 0, device
->acm_hdr
.pbDst
);
1525 device
->acm_hdr
.cbDstLength
= 0;
1526 device
->acm_hdr
.cbDstLengthUsed
= 0;
1528 /* done with this ACM Header, so try to pull more data */
1529 WID_PullACMData(device
);
1534 /* out of WAVEHDRs to write into, so toss the rest of this packet */
1535 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1536 HeapFree(GetProcessHeap(), 0, device
->acm_hdr
.pbDst
);
1537 device
->acm_hdr
.cbDstLength
= 0;
1538 device
->acm_hdr
.cbDstLengthUsed
= 0;
1541 static void WID_PullData(WINMM_Device
*device
)
1543 WINMM_CBInfo cb_info
;
1544 WAVEHDR
*queue
, *first
= NULL
;
1547 TRACE("(%p)\n", device
->handle
);
1549 EnterCriticalSection(&device
->lock
);
1551 if(!device
->device
|| !device
->first
)
1554 first
= device
->first
;
1556 if(device
->acm_handle
){
1557 WID_PullACMData(device
);
1561 while(device
->first
){
1563 UINT32 pad
, packet_len
, packet
;
1566 hr
= IAudioClient_GetCurrentPadding(device
->client
, &pad
);
1568 ERR("GetCurrentPadding failed: %08x\n", hr
);
1575 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet
,
1576 &flags
, NULL
, NULL
);
1578 ERR("GetBuffer failed: %08x\n", hr
);
1582 packet_len
= packet
;
1583 queue
= device
->first
;
1584 while(queue
&& packet
> 0){
1585 UINT32 to_copy_bytes
;
1587 to_copy_bytes
= min(packet
* device
->bytes_per_frame
,
1588 queue
->dwBufferLength
- queue
->dwBytesRecorded
);
1590 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
, data
,
1593 queue
->dwBytesRecorded
+= to_copy_bytes
;
1595 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1596 device
->bytes_per_frame
){
1597 queue
->dwFlags
&= ~WHDR_INQUEUE
;
1598 queue
->dwFlags
|= WHDR_DONE
;
1599 device
->first
= queue
= queue
->lpNext
;
1602 packet
-= to_copy_bytes
/ device
->bytes_per_frame
;
1605 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet_len
);
1607 ERR("ReleaseBuffer failed: %08x\n", hr
);
1611 cb_info
= device
->cb_info
;
1613 LeaveCriticalSection(&device
->lock
);
1615 while(first
&& (first
->dwFlags
& WHDR_DONE
)){
1616 WAVEHDR
*next
= first
->lpNext
;
1617 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
1622 static HRESULT
WINMM_BeginPlaying(WINMM_Device
*device
)
1626 TRACE("(%p)\n", device
->handle
);
1629 /* prebuffer data before starting */
1630 WOD_PushData(device
);
1632 if(device
->stopped
){
1633 device
->stopped
= FALSE
;
1635 hr
= IAudioClient_Start(device
->client
);
1636 if(FAILED(hr
) && hr
!= AUDCLNT_E_NOT_STOPPED
){
1637 device
->stopped
= TRUE
;
1638 ERR("Start failed: %08x\n", hr
);
1646 static LRESULT
WINMM_Pause(HWAVE hwave
)
1648 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1651 TRACE("(%p)\n", hwave
);
1653 if(!WINMM_ValidateAndLock(device
))
1654 return MMSYSERR_INVALHANDLE
;
1656 hr
= IAudioClient_Stop(device
->client
);
1658 LeaveCriticalSection(&device
->lock
);
1659 ERR("Stop failed: %08x\n", hr
);
1660 return MMSYSERR_ERROR
;
1663 device
->stopped
= FALSE
;
1665 LeaveCriticalSection(&device
->lock
);
1667 return MMSYSERR_NOERROR
;
1670 static LRESULT
WINMM_Reset(HWAVE hwave
)
1672 WINMM_CBInfo cb_info
;
1673 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1677 TRACE("(%p)\n", hwave
);
1679 if(!WINMM_ValidateAndLock(device
))
1680 return MMSYSERR_INVALHANDLE
;
1682 mr
= WINMM_Pause(hwave
);
1683 if(mr
!= MMSYSERR_NOERROR
){
1684 LeaveCriticalSection(&device
->lock
);
1687 device
->stopped
= TRUE
;
1690 first
= WOD_MarkDoneHeaders(device
);
1692 first
= device
->first
;
1693 device
->first
= device
->last
= device
->playing
= NULL
;
1694 device
->ofs_bytes
= 0;
1695 device
->played_frames
= 0;
1696 device
->loop_counter
= 0;
1697 device
->last_clock_pos
= 0;
1699 cb_info
= device
->cb_info
;
1701 LeaveCriticalSection(&device
->lock
);
1704 WAVEHDR
*next
= first
->lpNext
;
1705 first
->dwFlags
&= ~WHDR_INQUEUE
;
1706 first
->dwFlags
|= WHDR_DONE
;
1708 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
1710 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
1714 return MMSYSERR_NOERROR
;
1717 static MMRESULT
WINMM_FramesToMMTime(MMTIME
*time
, UINT32 played_frames
,
1718 UINT32 sample_rate
, UINT32 bytes_per_frame
)
1720 switch(time
->wType
){
1722 time
->u
.sample
= played_frames
;
1723 return MMSYSERR_NOERROR
;
1725 time
->u
.ms
= (DWORD
)((played_frames
/ (double)sample_rate
) * 1000);
1726 return MMSYSERR_NOERROR
;
1728 time
->u
.smpte
.fps
= 30;
1729 if(played_frames
>= sample_rate
){
1730 time
->u
.smpte
.sec
= played_frames
/ (double)sample_rate
;
1731 time
->u
.smpte
.min
= time
->u
.smpte
.sec
/ 60;
1732 time
->u
.smpte
.hour
= time
->u
.smpte
.min
/ 60;
1733 time
->u
.smpte
.sec
%= 60;
1734 time
->u
.smpte
.min
%= 60;
1735 played_frames
%= sample_rate
;
1737 time
->u
.smpte
.sec
= 0;
1738 time
->u
.smpte
.min
= 0;
1739 time
->u
.smpte
.hour
= 0;
1741 time
->u
.smpte
.frame
= (played_frames
/ (double)sample_rate
) * 30;
1742 return MMSYSERR_NOERROR
;
1745 time
->wType
= TIME_BYTES
;
1746 time
->u
.cb
= played_frames
* bytes_per_frame
;
1747 return MMSYSERR_NOERROR
;
1750 return MMSYSERR_ERROR
;
1753 static LRESULT
WINMM_GetPosition(HWAVE hwave
, MMTIME
*time
)
1755 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1756 UINT32 played_frames
, sample_rate
, bytes_per_frame
;
1758 TRACE("(%p, %p)\n", hwave
, time
);
1760 if(!WINMM_ValidateAndLock(device
))
1761 return MMSYSERR_INVALHANDLE
;
1763 played_frames
= device
->played_frames
;
1764 sample_rate
= device
->samples_per_sec
;
1765 bytes_per_frame
= device
->bytes_per_frame
;
1767 LeaveCriticalSection(&device
->lock
);
1769 return WINMM_FramesToMMTime(time
, played_frames
, sample_rate
,
1773 static WINMM_MMDevice
*WINMM_GetMixerMMDevice(HMIXEROBJ hmix
, DWORD flags
,
1776 UINT mmdev
, dev
, junk
, *out
;
1784 switch(flags
& 0xF0000000){
1785 case MIXER_OBJECTF_MIXER
: /* == 0 */
1786 *out
= HandleToULong(hmix
);
1787 if(*out
< g_outmmdevices_count
)
1788 return &g_out_mmdevices
[*out
];
1789 if(*out
- g_outmmdevices_count
< g_inmmdevices_count
){
1790 *out
-= g_outmmdevices_count
;
1791 return &g_in_mmdevices
[*out
];
1793 /* fall through -- if it's not a valid mixer device, then
1794 * it could be a valid mixer handle. windows seems to do
1796 case MIXER_OBJECTF_HMIXER
:
1797 case MIXER_OBJECTF_HWAVEOUT
:
1798 case MIXER_OBJECTF_HWAVEIN
:
1799 WINMM_DecomposeHWAVE((HWAVE
)hmix
, out
, &is_out
, &dev
, &junk
);
1800 if(junk
!= 0x1 || (is_out
&& *out
>= g_outmmdevices_count
) ||
1801 (!is_out
&& *out
>= g_inmmdevices_count
))
1804 return &g_out_mmdevices
[*out
];
1805 return &g_in_mmdevices
[*out
];
1806 case MIXER_OBJECTF_WAVEOUT
:
1807 *out
= HandleToULong(hmix
);
1808 if(*out
< g_outmmdevices_count
)
1809 return &g_out_mmdevices
[*out
];
1811 case MIXER_OBJECTF_WAVEIN
:
1812 *out
= HandleToULong(hmix
);
1813 if(*out
< g_inmmdevices_count
)
1814 return &g_in_mmdevices
[*out
];
1821 static MMRESULT
WINMM_SetupMMDeviceVolume(WINMM_MMDevice
*mmdevice
)
1823 IAudioSessionManager
*sesman
;
1827 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
, &device
);
1829 ERR("Device %s (%s) unavailable: %08x\n",
1830 wine_dbgstr_w(mmdevice
->dev_id
),
1831 wine_dbgstr_w(mmdevice
->out_caps
.szPname
), hr
);
1832 return MMSYSERR_ERROR
;
1835 hr
= IMMDevice_Activate(device
, &IID_IAudioSessionManager
,
1836 CLSCTX_INPROC_SERVER
, NULL
, (void**)&sesman
);
1838 ERR("Activate failed: %08x\n", hr
);
1839 IMMDevice_Release(device
);
1840 return MMSYSERR_ERROR
;
1843 IMMDevice_Release(device
);
1845 hr
= IAudioSessionManager_GetSimpleAudioVolume(sesman
, &mmdevice
->session
,
1846 FALSE
, &mmdevice
->volume
);
1847 IAudioSessionManager_Release(sesman
);
1849 ERR("GetSimpleAudioVolume failed: %08x\n", hr
);
1850 return MMSYSERR_ERROR
;
1853 return MMSYSERR_NOERROR
;
1856 static LRESULT
MXD_GetControlDetails(WINMM_ControlDetails
*details
)
1858 WINMM_MMDevice
*mmdevice
;
1859 MIXERCONTROLDETAILS
*control
= details
->details
;
1862 TRACE("(%p)\n", details
->hmix
);
1864 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
1866 return MMSYSERR_INVALHANDLE
;
1868 EnterCriticalSection(&mmdevice
->lock
);
1870 if(!mmdevice
->volume
){
1873 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
1874 if(mr
!= MMSYSERR_NOERROR
){
1875 LeaveCriticalSection(&mmdevice
->lock
);
1880 if(control
->dwControlID
== 0){
1882 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
1884 if(!control
->paDetails
||
1885 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
1886 LeaveCriticalSection(&mmdevice
->lock
);
1887 return MMSYSERR_INVALPARAM
;
1890 hr
= ISimpleAudioVolume_GetMasterVolume(mmdevice
->volume
, &vol
);
1892 ERR("GetMasterVolume failed: %08x\n", hr
);
1893 LeaveCriticalSection(&mmdevice
->lock
);
1894 return MMSYSERR_ERROR
;
1897 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
1898 udet
->dwValue
= vol
* ((unsigned int)0xFFFF);
1899 }else if(control
->dwControlID
== 1){
1901 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
1903 if(!control
->paDetails
||
1904 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
1905 LeaveCriticalSection(&mmdevice
->lock
);
1906 return MMSYSERR_INVALPARAM
;
1909 hr
= ISimpleAudioVolume_GetMute(mmdevice
->volume
, &mute
);
1911 ERR("GetMute failed: %08x\n", hr
);
1912 LeaveCriticalSection(&mmdevice
->lock
);
1913 return MMSYSERR_ERROR
;
1916 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
1917 bdet
->fValue
= mute
;
1918 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
1919 FIXME("What should the sw-side mixer controls map to?\n");
1921 LeaveCriticalSection(&mmdevice
->lock
);
1922 return MIXERR_INVALCONTROL
;
1925 LeaveCriticalSection(&mmdevice
->lock
);
1927 return MMSYSERR_NOERROR
;
1930 static LRESULT
MXD_SetControlDetails(WINMM_ControlDetails
*details
)
1932 WINMM_MMDevice
*mmdevice
;
1933 MIXERCONTROLDETAILS
*control
= details
->details
;
1936 TRACE("(%p)\n", details
->hmix
);
1938 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
1940 return MMSYSERR_INVALHANDLE
;
1942 EnterCriticalSection(&mmdevice
->lock
);
1944 if(!mmdevice
->volume
){
1947 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
1948 if(mr
!= MMSYSERR_NOERROR
){
1949 LeaveCriticalSection(&mmdevice
->lock
);
1954 if(control
->dwControlID
== 0){
1956 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
1958 if(!control
->paDetails
||
1959 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
1960 LeaveCriticalSection(&mmdevice
->lock
);
1961 return MMSYSERR_INVALPARAM
;
1964 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
1966 if(udet
->dwValue
> 65535){
1967 LeaveCriticalSection(&mmdevice
->lock
);
1968 return MMSYSERR_INVALPARAM
;
1971 vol
= udet
->dwValue
/ 65535.f
;
1973 hr
= ISimpleAudioVolume_SetMasterVolume(mmdevice
->volume
, vol
, NULL
);
1975 ERR("SetMasterVolume failed: %08x\n", hr
);
1976 LeaveCriticalSection(&mmdevice
->lock
);
1977 return MMSYSERR_ERROR
;
1979 }else if(control
->dwControlID
== 1){
1981 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
1983 if(!control
->paDetails
||
1984 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
1985 LeaveCriticalSection(&mmdevice
->lock
);
1986 return MMSYSERR_INVALPARAM
;
1989 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
1990 mute
= bdet
->fValue
;
1992 hr
= ISimpleAudioVolume_SetMute(mmdevice
->volume
, mute
, NULL
);
1994 ERR("SetMute failed: %08x\n", hr
);
1995 LeaveCriticalSection(&mmdevice
->lock
);
1996 return MMSYSERR_ERROR
;
1998 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
1999 FIXME("What should the sw-side mixer controls map to?\n");
2001 LeaveCriticalSection(&mmdevice
->lock
);
2002 return MIXERR_INVALCONTROL
;
2005 LeaveCriticalSection(&mmdevice
->lock
);
2007 return MMSYSERR_NOERROR
;
2010 static LRESULT CALLBACK
WINMM_DevicesMsgProc(HWND hwnd
, UINT msg
, WPARAM wparam
,
2015 return WOD_Open((WINMM_OpenInfo
*)wparam
);
2017 return WOD_Close((HWAVEOUT
)wparam
);
2019 return WID_Open((WINMM_OpenInfo
*)wparam
);
2021 return WID_Close((HWAVEIN
)wparam
);
2022 case MXDM_GETCONTROLDETAILS
:
2023 return MXD_GetControlDetails((WINMM_ControlDetails
*)wparam
);
2024 case MXDM_SETCONTROLDETAILS
:
2025 return MXD_SetControlDetails((WINMM_ControlDetails
*)wparam
);
2027 return DefWindowProcW(hwnd
, msg
, wparam
, lparam
);
2030 static DWORD WINAPI
WINMM_DevicesThreadProc(void *arg
)
2034 static const WCHAR messageW
[] = {'M','e','s','s','a','g','e',0};
2036 hr
= CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
2038 ERR("CoInitializeEx failed: %08x\n", hr
);
2042 hr
= WINMM_InitMMDevices();
2048 g_devices_hwnd
= CreateWindowW(messageW
, NULL
, 0, 0, 0, 0, 0,
2049 HWND_MESSAGE
, NULL
, NULL
, NULL
);
2050 if(!g_devices_hwnd
){
2051 ERR("CreateWindow failed: %d\n", GetLastError());
2056 SetWindowLongPtrW(g_devices_hwnd
, GWLP_WNDPROC
,
2057 (LONG_PTR
)WINMM_DevicesMsgProc
);
2059 /* inform caller that the thread is ready to process messages */
2061 evt
= NULL
; /* do not use after this point */
2065 wait
= MsgWaitForMultipleObjects(g_devhandle_count
, g_device_handles
,
2066 FALSE
, INFINITE
, QS_ALLINPUT
);
2067 if(wait
== g_devhandle_count
+ WAIT_OBJECT_0
){
2069 if(PeekMessageW(&msg
, g_devices_hwnd
, 0, 0, PM_REMOVE
))
2070 ERR("Unexpected message: 0x%x\n", msg
.message
);
2071 }else if(wait
< g_devhandle_count
+ WAIT_OBJECT_0
){
2072 WINMM_Device
*device
= g_handle_devices
[wait
- WAIT_OBJECT_0
];
2074 WOD_PushData(device
);
2076 WID_PullData(device
);
2078 ERR("Unexpected MsgWait result 0x%x, GLE: %d\n", wait
,
2082 DestroyWindow(g_devices_hwnd
);
2089 static BOOL
WINMM_StartDevicesThread(void)
2094 EnterCriticalSection(&g_devthread_lock
);
2096 if(g_devices_thread
){
2099 wait
= WaitForSingleObject(g_devices_thread
, 0);
2100 if(wait
== WAIT_TIMEOUT
){
2101 LeaveCriticalSection(&g_devthread_lock
);
2104 if(wait
!= WAIT_OBJECT_0
){
2105 LeaveCriticalSection(&g_devthread_lock
);
2109 g_devices_thread
= NULL
;
2110 g_devices_hwnd
= NULL
;
2113 TRACE("Starting up devices thread\n");
2115 events
[0] = CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2117 g_devices_thread
= CreateThread(NULL
, 0, WINMM_DevicesThreadProc
,
2118 events
[0], 0, NULL
);
2119 if(!g_devices_thread
){
2120 LeaveCriticalSection(&g_devthread_lock
);
2121 CloseHandle(events
[0]);
2125 events
[1] = g_devices_thread
;
2126 wait
= WaitForMultipleObjects(2, events
, FALSE
, INFINITE
);
2127 CloseHandle(events
[0]);
2128 if(wait
!= WAIT_OBJECT_0
){
2129 if(wait
== 1 + WAIT_OBJECT_0
){
2130 CloseHandle(g_devices_thread
);
2131 g_devices_thread
= NULL
;
2132 g_devices_hwnd
= NULL
;
2134 LeaveCriticalSection(&g_devthread_lock
);
2138 LeaveCriticalSection(&g_devthread_lock
);
2143 /**************************************************************************
2144 * waveOutGetNumDevs [WINMM.@]
2146 UINT WINAPI
waveOutGetNumDevs(void)
2148 if(!WINMM_StartDevicesThread())
2151 TRACE("count: %u\n", g_outmmdevices_count
);
2153 return g_outmmdevices_count
;
2156 /**************************************************************************
2157 * waveOutGetDevCapsA [WINMM.@]
2159 UINT WINAPI
waveOutGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
2165 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2167 if(!WINMM_StartDevicesThread())
2168 return MMSYSERR_ERROR
;
2171 return MMSYSERR_INVALPARAM
;
2173 ret
= waveOutGetDevCapsW(uDeviceID
, &wocW
, sizeof(wocW
));
2175 if (ret
== MMSYSERR_NOERROR
) {
2177 wocA
.wMid
= wocW
.wMid
;
2178 wocA
.wPid
= wocW
.wPid
;
2179 wocA
.vDriverVersion
= wocW
.vDriverVersion
;
2180 WideCharToMultiByte( CP_ACP
, 0, wocW
.szPname
, -1, wocA
.szPname
,
2181 sizeof(wocA
.szPname
), NULL
, NULL
);
2182 wocA
.dwFormats
= wocW
.dwFormats
;
2183 wocA
.wChannels
= wocW
.wChannels
;
2184 wocA
.dwSupport
= wocW
.dwSupport
;
2185 memcpy(lpCaps
, &wocA
, min(uSize
, sizeof(wocA
)));
2190 /**************************************************************************
2191 * waveOutGetDevCapsW [WINMM.@]
2193 UINT WINAPI
waveOutGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
2196 WAVEOUTCAPSW mapper_caps
, *caps
;
2198 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2200 if(!WINMM_StartDevicesThread())
2201 return MMSYSERR_ERROR
;
2203 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2205 if(WINMM_IsMapper(uDeviceID
)){
2206 /* FIXME: Should be localized */
2207 static const WCHAR mapper_pnameW
[] = {'W','i','n','e',' ','S','o','u',
2208 'n','d',' ','M','a','p','p','e','r',0};
2210 mapper_caps
.wMid
= 0xFF;
2211 mapper_caps
.wPid
= 0xFF;
2212 mapper_caps
.vDriverVersion
= 0x00010001;
2213 mapper_caps
.dwFormats
= 0xFFFFFFFF;
2214 mapper_caps
.wReserved1
= 0;
2215 mapper_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
2216 WAVECAPS_SAMPLEACCURATE
;
2217 mapper_caps
.wChannels
= 2;
2218 lstrcpyW(mapper_caps
.szPname
, mapper_pnameW
);
2220 caps
= &mapper_caps
;
2222 if(uDeviceID
>= g_outmmdevices_count
)
2223 return MMSYSERR_BADDEVICEID
;
2225 caps
= &g_out_mmdevices
[uDeviceID
].out_caps
;
2228 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
2230 return MMSYSERR_NOERROR
;
2233 /**************************************************************************
2234 * waveOutGetErrorTextA [WINMM.@]
2235 * waveInGetErrorTextA [WINMM.@]
2237 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2241 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2242 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2245 LPWSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
* sizeof(WCHAR
));
2246 if (!xstr
) ret
= MMSYSERR_NOMEM
;
2249 ret
= waveOutGetErrorTextW(uError
, xstr
, uSize
);
2250 if (ret
== MMSYSERR_NOERROR
)
2251 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
2252 HeapFree(GetProcessHeap(), 0, xstr
);
2258 /**************************************************************************
2259 * waveOutGetErrorTextW [WINMM.@]
2260 * waveInGetErrorTextW [WINMM.@]
2262 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2264 UINT ret
= MMSYSERR_BADERRNUM
;
2266 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2267 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2269 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2270 * a warning for the test was always true */
2271 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
2272 (uError
>= WAVERR_BASE
&& uError
<= WAVERR_LASTERROR
)) {
2273 if (LoadStringW(hWinMM32Instance
,
2274 uError
, lpText
, uSize
) > 0) {
2275 ret
= MMSYSERR_NOERROR
;
2281 /**************************************************************************
2282 * waveOutOpen [WINMM.@]
2283 * All the args/structs have the same layout as the win16 equivalents
2285 MMRESULT WINAPI
waveOutOpen(LPHWAVEOUT lphWaveOut
, UINT uDeviceID
,
2286 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2287 DWORD_PTR dwInstance
, DWORD dwFlags
)
2290 WINMM_OpenInfo info
;
2291 WINMM_CBInfo cb_info
;
2293 TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut
, uDeviceID
, lpFormat
,
2294 dwCallback
, dwInstance
, dwFlags
);
2296 if(!WINMM_StartDevicesThread())
2297 return MMSYSERR_ERROR
;
2299 if(!lphWaveOut
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
2300 return MMSYSERR_INVALPARAM
;
2302 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
2303 if(res
!= MMSYSERR_NOERROR
)
2306 info
.format
= (WAVEFORMATEX
*)lpFormat
;
2307 info
.callback
= dwCallback
;
2308 info
.cb_user
= dwInstance
;
2309 info
.req_device
= uDeviceID
;
2310 info
.flags
= dwFlags
;
2312 res
= SendMessageW(g_devices_hwnd
, WODM_OPEN
, (DWORD_PTR
)&info
, 0);
2313 if(res
!= MMSYSERR_NOERROR
)
2317 *lphWaveOut
= (HWAVEOUT
)info
.handle
;
2319 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2320 cb_info
.callback
= dwCallback
;
2321 cb_info
.user
= dwInstance
;
2322 cb_info
.hwave
= info
.handle
;
2324 WINMM_NotifyClient(&cb_info
, WOM_OPEN
, 0, 0);
2329 /**************************************************************************
2330 * waveOutClose [WINMM.@]
2332 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
2335 WINMM_Device
*device
;
2336 WINMM_CBInfo cb_info
;
2338 TRACE("(%p)\n", hWaveOut
);
2340 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2342 if(!WINMM_ValidateAndLock(device
))
2343 return MMSYSERR_INVALHANDLE
;
2345 cb_info
= device
->cb_info
;
2347 LeaveCriticalSection(&device
->lock
);
2349 res
= SendMessageW(g_devices_hwnd
, WODM_CLOSE
, (WPARAM
)hWaveOut
, 0);
2351 if(res
== MMSYSERR_NOERROR
)
2352 WINMM_NotifyClient(&cb_info
, WOM_CLOSE
, 0, 0);
2357 /**************************************************************************
2358 * waveOutPrepareHeader [WINMM.@]
2360 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
2361 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
2363 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2365 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2366 return MMSYSERR_INVALPARAM
;
2368 if(lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2369 return WAVERR_STILLPLAYING
;
2371 return WINMM_PrepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2374 /**************************************************************************
2375 * waveOutUnprepareHeader [WINMM.@]
2377 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
2378 LPWAVEHDR lpWaveOutHdr
, UINT uSize
)
2380 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2382 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2383 return MMSYSERR_INVALPARAM
;
2385 if(!(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
))
2386 return MMSYSERR_NOERROR
;
2388 if(lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2389 return WAVERR_STILLPLAYING
;
2391 return WINMM_UnprepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2394 /**************************************************************************
2395 * waveOutWrite [WINMM.@]
2397 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, WAVEHDR
*header
, UINT uSize
)
2399 WINMM_Device
*device
;
2402 TRACE("(%p, %p, %u)\n", hWaveOut
, header
, uSize
);
2404 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2406 if(!WINMM_ValidateAndLock(device
))
2407 return MMSYSERR_INVALHANDLE
;
2409 if(!header
->lpData
|| !(header
->dwFlags
& WHDR_PREPARED
)){
2410 LeaveCriticalSection(&device
->lock
);
2411 return WAVERR_UNPREPARED
;
2414 if(header
->dwFlags
& WHDR_INQUEUE
){
2415 LeaveCriticalSection(&device
->lock
);
2416 return WAVERR_STILLPLAYING
;
2419 if(device
->acm_handle
){
2420 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
2423 ash
->cbSrcLength
= header
->dwBufferLength
;
2424 mr
= acmStreamConvert(device
->acm_handle
, ash
, 0);
2425 if(mr
!= MMSYSERR_NOERROR
){
2426 LeaveCriticalSection(&device
->lock
);
2432 device
->last
->lpNext
= header
;
2433 device
->last
= header
;
2434 if(!device
->playing
)
2435 device
->playing
= header
;
2437 device
->playing
= device
->first
= device
->last
= header
;
2438 if(header
->dwFlags
& WHDR_BEGINLOOP
){
2439 device
->loop_counter
= header
->dwLoops
;
2440 device
->loop_start
= header
;
2444 header
->lpNext
= NULL
;
2445 header
->dwFlags
&= ~WHDR_DONE
;
2446 header
->dwFlags
|= WHDR_INQUEUE
;
2448 hr
= WINMM_BeginPlaying(device
);
2450 LeaveCriticalSection(&device
->lock
);
2451 return MMSYSERR_ERROR
;
2454 LeaveCriticalSection(&device
->lock
);
2456 return MMSYSERR_NOERROR
;
2459 /**************************************************************************
2460 * waveOutBreakLoop [WINMM.@]
2462 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
2464 WINMM_Device
*device
;
2466 TRACE("(%p)\n", hWaveOut
);
2468 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2470 if(!WINMM_ValidateAndLock(device
))
2471 return MMSYSERR_INVALHANDLE
;
2473 device
->loop_counter
= 0;
2475 LeaveCriticalSection(&device
->lock
);
2477 return MMSYSERR_NOERROR
;
2480 /**************************************************************************
2481 * waveOutPause [WINMM.@]
2483 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
2485 TRACE("(%p)\n", hWaveOut
);
2487 return WINMM_Pause((HWAVE
)hWaveOut
);
2490 /**************************************************************************
2491 * waveOutReset [WINMM.@]
2493 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
2495 TRACE("(%p)\n", hWaveOut
);
2497 return WINMM_Reset((HWAVE
)hWaveOut
);
2500 /**************************************************************************
2501 * waveOutRestart [WINMM.@]
2503 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
2505 WINMM_Device
*device
;
2508 TRACE("(%p)\n", hWaveOut
);
2510 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2512 if(!WINMM_ValidateAndLock(device
))
2513 return MMSYSERR_INVALHANDLE
;
2515 device
->stopped
= TRUE
;
2517 hr
= WINMM_BeginPlaying(device
);
2519 LeaveCriticalSection(&device
->lock
);
2520 return MMSYSERR_ERROR
;
2523 LeaveCriticalSection(&device
->lock
);
2525 return MMSYSERR_NOERROR
;
2528 /**************************************************************************
2529 * waveOutGetPosition [WINMM.@]
2531 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
2534 TRACE("(%p, %p, %u)\n", hWaveOut
, lpTime
, uSize
);
2536 if(!uSize
|| !lpTime
|| uSize
!= sizeof(MMTIME
))
2537 return MMSYSERR_INVALPARAM
;
2539 return WINMM_GetPosition((HWAVE
)hWaveOut
, lpTime
);
2542 /**************************************************************************
2543 * waveOutGetPitch [WINMM.@]
2545 UINT WINAPI
waveOutGetPitch(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2547 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
2548 return MMSYSERR_NOTSUPPORTED
;
2551 /**************************************************************************
2552 * waveOutSetPitch [WINMM.@]
2554 UINT WINAPI
waveOutSetPitch(HWAVEOUT hWaveOut
, DWORD dw
)
2556 TRACE("(%p, %08x)\n", hWaveOut
, dw
);
2558 return MMSYSERR_NOTSUPPORTED
;
2561 /**************************************************************************
2562 * waveOutGetPlaybackRate [WINMM.@]
2564 UINT WINAPI
waveOutGetPlaybackRate(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2566 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
2568 return MMSYSERR_NOTSUPPORTED
;
2571 /**************************************************************************
2572 * waveOutSetPlaybackRate [WINMM.@]
2574 UINT WINAPI
waveOutSetPlaybackRate(HWAVEOUT hWaveOut
, DWORD dw
)
2576 TRACE("(%p, %08x)\n", hWaveOut
, dw
);
2578 return MMSYSERR_NOTSUPPORTED
;
2581 /**************************************************************************
2582 * waveOutGetVolume [WINMM.@]
2584 UINT WINAPI
waveOutGetVolume(HWAVEOUT hWaveOut
, DWORD
*out
)
2586 WINMM_Device
*device
;
2591 TRACE("(%p, %p)\n", hWaveOut
, out
);
2594 return MMSYSERR_INVALPARAM
;
2596 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2598 if(!WINMM_ValidateAndLock(device
))
2599 return MMSYSERR_INVALHANDLE
;
2601 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
2603 LeaveCriticalSection(&device
->lock
);
2604 ERR("GetChannelCount failed: %08x\n", hr
);
2605 return MMSYSERR_ERROR
;
2608 vols
= HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels
);
2610 LeaveCriticalSection(&device
->lock
);
2611 return MMSYSERR_NOMEM
;
2614 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
2616 LeaveCriticalSection(&device
->lock
);
2617 HeapFree(GetProcessHeap(), 0, vols
);
2618 ERR("GetAllVolumes failed: %08x\n", hr
);
2619 return MMSYSERR_ERROR
;
2622 LeaveCriticalSection(&device
->lock
);
2624 *out
= ((UINT16
)(vols
[0] * (DWORD
)0xFFFF));
2626 *out
|= ((UINT16
)(vols
[1] * (DWORD
)0xFFFF)) << 16;
2628 HeapFree(GetProcessHeap(), 0, vols
);
2630 return MMSYSERR_NOERROR
;
2633 /**************************************************************************
2634 * waveOutSetVolume [WINMM.@]
2636 UINT WINAPI
waveOutSetVolume(HWAVEOUT hWaveOut
, DWORD in
)
2638 WINMM_Device
*device
;
2643 TRACE("(%p, %08x)\n", hWaveOut
, in
);
2645 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2647 if(!WINMM_ValidateAndLock(device
))
2648 return MMSYSERR_INVALHANDLE
;
2650 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
2652 LeaveCriticalSection(&device
->lock
);
2653 ERR("GetChannelCount failed: %08x\n", hr
);
2654 return MMSYSERR_ERROR
;
2657 vols
= HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels
);
2659 LeaveCriticalSection(&device
->lock
);
2660 return MMSYSERR_NOMEM
;
2663 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
2665 LeaveCriticalSection(&device
->lock
);
2666 HeapFree(GetProcessHeap(), 0, vols
);
2667 ERR("GetAllVolumes failed: %08x\n", hr
);
2668 return MMSYSERR_ERROR
;
2671 vols
[0] = (float)((DWORD
)(in
& 0xFFFF) / (float)0xFFFF);
2673 vols
[1] = (float)((DWORD
)(in
>> 16) / (float)0xFFFF);
2675 hr
= IAudioStreamVolume_SetAllVolumes(device
->volume
, channels
, vols
);
2677 LeaveCriticalSection(&device
->lock
);
2678 HeapFree(GetProcessHeap(), 0, vols
);
2679 ERR("SetAllVolumes failed: %08x\n", hr
);
2680 return MMSYSERR_ERROR
;
2683 LeaveCriticalSection(&device
->lock
);
2685 HeapFree(GetProcessHeap(), 0, vols
);
2687 return MMSYSERR_NOERROR
;
2690 /**************************************************************************
2691 * waveOutGetID [WINMM.@]
2693 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
2695 WINMM_Device
*device
;
2699 TRACE("(%p, %p)\n", hWaveOut
, lpuDeviceID
);
2702 return MMSYSERR_INVALPARAM
;
2704 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2705 if(!WINMM_ValidateAndLock(device
))
2706 return MMSYSERR_INVALHANDLE
;
2708 LeaveCriticalSection(&device
->lock
);
2710 WINMM_DecomposeHWAVE((HWAVE
)hWaveOut
, lpuDeviceID
, &is_out
, &dev
, &junk
);
2712 return MMSYSERR_NOERROR
;
2715 static UINT
WINMM_QueryInstanceIDSize(UINT device
, DWORD_PTR
*len
, BOOL is_out
)
2718 WINMM_MMDevice
*devices
;
2720 TRACE("(%u, %p, %d)\n", device
, len
, is_out
);
2723 count
= g_outmmdevices_count
;
2724 devices
= g_out_mmdevices
;
2726 count
= g_inmmdevices_count
;
2727 devices
= g_in_mmdevices
;
2731 return MMSYSERR_INVALHANDLE
;
2733 *len
= (lstrlenW(devices
[device
].dev_id
) + 1) * sizeof(WCHAR
);
2735 return MMSYSERR_NOERROR
;
2738 static UINT
WINMM_QueryInstanceID(UINT device
, WCHAR
*str
, DWORD_PTR len
,
2742 WINMM_MMDevice
*devices
;
2744 TRACE("(%u, %p, %d)\n", device
, str
, is_out
);
2747 count
= g_outmmdevices_count
;
2748 devices
= g_out_mmdevices
;
2750 count
= g_inmmdevices_count
;
2751 devices
= g_in_mmdevices
;
2755 return MMSYSERR_INVALHANDLE
;
2757 id_len
= (lstrlenW(devices
[device
].dev_id
) + 1) * sizeof(WCHAR
);
2759 return MMSYSERR_ERROR
;
2761 memcpy(str
, devices
[device
].dev_id
, id_len
);
2763 return MMSYSERR_NOERROR
;
2766 static UINT
WINMM_DRVMessage(UINT dev
, UINT message
, DWORD_PTR param1
,
2767 DWORD_PTR param2
, BOOL is_out
)
2770 UINT type
= is_out
? MMDRV_WAVEOUT
: MMDRV_WAVEIN
;
2772 TRACE("(%u, %u, %ld, %ld, %d)\n", dev
, message
, param1
, param2
, is_out
);
2774 if((wmld
= MMDRV_Get(ULongToHandle(dev
), type
, FALSE
)) == NULL
){
2775 if((wmld
= MMDRV_Get(ULongToHandle(dev
), type
, TRUE
)) != NULL
)
2776 return MMDRV_PhysicalFeatures(wmld
, message
, param1
, param2
);
2777 return MMSYSERR_INVALHANDLE
;
2780 if(message
< DRVM_IOCTL
||
2781 (message
>= DRVM_IOCTL_LAST
&& message
< DRVM_MAPPER
))
2782 return MMSYSERR_INVALPARAM
;
2784 return MMDRV_Message(wmld
, message
, param1
, param2
);
2787 static UINT
WINMM_FillDSDriverDesc(UINT dev
, DSDRIVERDESC
*desc
, BOOL is_out
)
2792 if(dev
>= g_outmmdevices_count
)
2793 return MMSYSERR_INVALHANDLE
;
2794 name
= g_out_mmdevices
[dev
].out_caps
.szPname
;
2796 if(dev
>= g_inmmdevices_count
)
2797 return MMSYSERR_INVALHANDLE
;
2798 name
= g_in_mmdevices
[dev
].in_caps
.szPname
;
2801 memset(desc
, 0, sizeof(*desc
));
2803 strcpy(desc
->szDesc
, "WinMM: ");
2804 WideCharToMultiByte(CP_ACP
, 0, name
, -1,
2805 desc
->szDesc
+ strlen(desc
->szDesc
),
2806 sizeof(desc
->szDesc
) - strlen(desc
->szDesc
), NULL
, NULL
);
2808 strcpy(desc
->szDrvname
, "winmm.dll");
2810 return MMSYSERR_NOERROR
;
2813 /**************************************************************************
2814 * waveOutMessage [WINMM.@]
2816 UINT WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
2817 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2819 TRACE("(%p, %u, %lx, %lx)\n", hWaveOut
, uMessage
, dwParam1
, dwParam2
);
2822 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
2823 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut
),
2824 (DWORD_PTR
*)dwParam1
, TRUE
);
2825 case DRV_QUERYFUNCTIONINSTANCEID
:
2826 return WINMM_QueryInstanceID(HandleToULong(hWaveOut
),
2827 (WCHAR
*)dwParam1
, (DWORD_PTR
)dwParam2
, TRUE
);
2828 /* TODO: Remove after dsound has been rewritten for mmdevapi */
2829 case DRV_QUERYDSOUNDDESC
:
2830 case DRV_QUERYDSOUNDIFACE
:
2831 if(dwParam2
== DS_HW_ACCEL_FULL
)
2832 return WINMM_DRVMessage(HandleToULong(hWaveOut
), uMessage
,
2834 return WINMM_FillDSDriverDesc(HandleToULong(hWaveOut
),
2835 (DSDRIVERDESC
*)dwParam1
, TRUE
);
2838 return MMSYSERR_NOTSUPPORTED
;
2841 /**************************************************************************
2842 * waveInGetNumDevs [WINMM.@]
2844 UINT WINAPI
waveInGetNumDevs(void)
2846 if(!WINMM_StartDevicesThread())
2849 TRACE("count: %u\n", g_inmmdevices_count
);
2851 return g_inmmdevices_count
;
2854 /**************************************************************************
2855 * waveInGetDevCapsW [WINMM.@]
2857 UINT WINAPI
waveInGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
2859 WAVEINCAPSW mapper_caps
, *caps
;
2861 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2863 if(!WINMM_StartDevicesThread())
2864 return MMSYSERR_ERROR
;
2867 return MMSYSERR_INVALPARAM
;
2869 if(WINMM_IsMapper(uDeviceID
)){
2870 /* FIXME: Should be localized */
2871 static const WCHAR mapper_pnameW
[] = {'W','i','n','e',' ','S','o','u',
2872 'n','d',' ','M','a','p','p','e','r',0};
2874 mapper_caps
.wMid
= 0xFF;
2875 mapper_caps
.wPid
= 0xFF;
2876 mapper_caps
.vDriverVersion
= 0x00010001;
2877 mapper_caps
.dwFormats
= 0xFFFFFFFF;
2878 mapper_caps
.wReserved1
= 0;
2879 mapper_caps
.wChannels
= 2;
2880 lstrcpyW(mapper_caps
.szPname
, mapper_pnameW
);
2882 caps
= &mapper_caps
;
2884 if(uDeviceID
>= g_inmmdevices_count
)
2885 return MMSYSERR_BADDEVICEID
;
2887 caps
= &g_in_mmdevices
[uDeviceID
].in_caps
;
2890 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
2892 return MMSYSERR_NOERROR
;
2895 /**************************************************************************
2896 * waveInGetDevCapsA [WINMM.@]
2898 UINT WINAPI
waveInGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
2903 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2905 if(!WINMM_StartDevicesThread())
2906 return MMSYSERR_ERROR
;
2909 return MMSYSERR_INVALPARAM
;
2911 ret
= waveInGetDevCapsW(uDeviceID
, &wicW
, sizeof(wicW
));
2913 if (ret
== MMSYSERR_NOERROR
) {
2915 wicA
.wMid
= wicW
.wMid
;
2916 wicA
.wPid
= wicW
.wPid
;
2917 wicA
.vDriverVersion
= wicW
.vDriverVersion
;
2918 WideCharToMultiByte( CP_ACP
, 0, wicW
.szPname
, -1, wicA
.szPname
,
2919 sizeof(wicA
.szPname
), NULL
, NULL
);
2920 wicA
.dwFormats
= wicW
.dwFormats
;
2921 wicA
.wChannels
= wicW
.wChannels
;
2922 memcpy(lpCaps
, &wicA
, min(uSize
, sizeof(wicA
)));
2927 /**************************************************************************
2928 * waveInOpen [WINMM.@]
2930 MMRESULT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
2931 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2932 DWORD_PTR dwInstance
, DWORD dwFlags
)
2935 WINMM_OpenInfo info
;
2936 WINMM_CBInfo cb_info
;
2938 TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn
, uDeviceID
, lpFormat
,
2939 dwCallback
, dwInstance
, dwFlags
);
2941 if(!WINMM_StartDevicesThread())
2942 return MMSYSERR_ERROR
;
2944 if(!lphWaveIn
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
2945 return MMSYSERR_INVALPARAM
;
2947 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
2948 if(res
!= MMSYSERR_NOERROR
)
2951 info
.format
= (WAVEFORMATEX
*)lpFormat
;
2952 info
.callback
= dwCallback
;
2953 info
.cb_user
= dwInstance
;
2954 info
.req_device
= uDeviceID
;
2955 info
.flags
= dwFlags
;
2957 res
= SendMessageW(g_devices_hwnd
, WIDM_OPEN
, (DWORD_PTR
)&info
, 0);
2958 if(res
!= MMSYSERR_NOERROR
)
2962 *lphWaveIn
= (HWAVEIN
)info
.handle
;
2964 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2965 cb_info
.callback
= dwCallback
;
2966 cb_info
.user
= dwInstance
;
2967 cb_info
.hwave
= info
.handle
;
2969 WINMM_NotifyClient(&cb_info
, WIM_OPEN
, 0, 0);
2974 /**************************************************************************
2975 * waveInClose [WINMM.@]
2977 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
2979 WINMM_Device
*device
;
2980 WINMM_CBInfo cb_info
;
2983 TRACE("(%p)\n", hWaveIn
);
2985 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
2987 if(!WINMM_ValidateAndLock(device
))
2988 return MMSYSERR_INVALHANDLE
;
2990 cb_info
= device
->cb_info
;
2992 LeaveCriticalSection(&device
->lock
);
2994 res
= SendMessageW(g_devices_hwnd
, WIDM_CLOSE
, (WPARAM
)hWaveIn
, 0);
2996 if(res
== MMSYSERR_NOERROR
)
2997 WINMM_NotifyClient(&cb_info
, WIM_CLOSE
, 0, 0);
3002 /**************************************************************************
3003 * waveInPrepareHeader [WINMM.@]
3005 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3008 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3010 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3011 return MMSYSERR_INVALPARAM
;
3013 if(lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
3014 return WAVERR_STILLPLAYING
;
3016 return WINMM_PrepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3019 /**************************************************************************
3020 * waveInUnprepareHeader [WINMM.@]
3022 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3025 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3027 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3028 return MMSYSERR_INVALPARAM
;
3030 if(!(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
))
3031 return MMSYSERR_NOERROR
;
3033 if(lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
3034 return WAVERR_STILLPLAYING
;
3036 return WINMM_UnprepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3039 /**************************************************************************
3040 * waveInAddBuffer [WINMM.@]
3042 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
, WAVEHDR
*header
, UINT uSize
)
3044 WINMM_Device
*device
;
3046 TRACE("(%p, %p, %u)\n", hWaveIn
, header
, uSize
);
3048 if(!header
|| uSize
< sizeof(WAVEHDR
))
3049 return MMSYSERR_INVALPARAM
;
3051 if(!(header
->dwFlags
& WHDR_PREPARED
))
3052 return WAVERR_UNPREPARED
;
3054 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3056 if(!WINMM_ValidateAndLock(device
))
3057 return MMSYSERR_INVALHANDLE
;
3060 device
->first
= device
->last
= header
;
3062 device
->last
->lpNext
= header
;
3063 device
->last
= header
;
3066 header
->dwBytesRecorded
= 0;
3067 header
->lpNext
= NULL
;
3068 header
->dwFlags
&= ~WHDR_DONE
;
3069 header
->dwFlags
|= WHDR_INQUEUE
;
3071 LeaveCriticalSection(&device
->lock
);
3073 return MMSYSERR_NOERROR
;
3076 /**************************************************************************
3077 * waveInReset [WINMM.@]
3079 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
3081 TRACE("(%p)\n", hWaveIn
);
3083 return WINMM_Reset((HWAVE
)hWaveIn
);
3086 /**************************************************************************
3087 * waveInStart [WINMM.@]
3089 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
3091 WINMM_Device
*device
;
3094 TRACE("(%p)\n", hWaveIn
);
3096 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3098 if(!WINMM_ValidateAndLock(device
))
3099 return MMSYSERR_INVALHANDLE
;
3101 hr
= WINMM_BeginPlaying(device
);
3103 LeaveCriticalSection(&device
->lock
);
3104 return MMSYSERR_ERROR
;
3107 LeaveCriticalSection(&device
->lock
);
3109 return MMSYSERR_NOERROR
;
3112 /**************************************************************************
3113 * waveInStop [WINMM.@]
3115 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
3117 WINMM_CBInfo cb_info
;
3118 WINMM_Device
*device
;
3122 TRACE("(%p)\n", hWaveIn
);
3124 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3126 if(!WINMM_ValidateAndLock(device
))
3127 return MMSYSERR_INVALHANDLE
;
3129 hr
= WINMM_Pause((HWAVE
)hWaveIn
);
3131 LeaveCriticalSection(&device
->lock
);
3132 return MMSYSERR_ERROR
;
3134 device
->stopped
= TRUE
;
3136 buf
= device
->first
;
3137 if(buf
&& buf
->dwBytesRecorded
> 0){
3138 device
->first
= buf
->lpNext
;
3139 buf
->dwFlags
&= ~WHDR_INQUEUE
;
3140 buf
->dwFlags
|= WHDR_DONE
;
3144 cb_info
= device
->cb_info
;
3146 LeaveCriticalSection(&device
->lock
);
3149 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)buf
, 0);
3151 return MMSYSERR_NOERROR
;
3154 /**************************************************************************
3155 * waveInGetPosition [WINMM.@]
3157 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
3160 TRACE("(%p, %p, %u)\n", hWaveIn
, lpTime
, uSize
);
3162 if(!uSize
|| !lpTime
|| uSize
!= sizeof(MMTIME
))
3163 return MMSYSERR_INVALPARAM
;
3165 return WINMM_GetPosition((HWAVE
)hWaveIn
, lpTime
);
3168 /**************************************************************************
3169 * waveInGetID [WINMM.@]
3171 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
3175 WINMM_Device
*device
;
3177 TRACE("(%p, %p)\n", hWaveIn
, lpuDeviceID
);
3180 return MMSYSERR_INVALPARAM
;
3182 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3183 if(!WINMM_ValidateAndLock(device
))
3184 return MMSYSERR_INVALHANDLE
;
3186 LeaveCriticalSection(&device
->lock
);
3188 WINMM_DecomposeHWAVE((HWAVE
)hWaveIn
, lpuDeviceID
, &is_out
, &dev
, &junk
);
3190 return MMSYSERR_NOERROR
;
3193 /**************************************************************************
3194 * waveInMessage [WINMM.@]
3196 UINT WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
3197 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3199 TRACE("(%p, %u, %ld, %ld)\n", hWaveIn
, uMessage
, dwParam1
, dwParam2
);
3202 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
3203 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn
),
3204 (DWORD_PTR
*)dwParam1
, FALSE
);
3205 case DRV_QUERYFUNCTIONINSTANCEID
:
3206 return WINMM_QueryInstanceID(HandleToULong(hWaveIn
),
3207 (WCHAR
*)dwParam1
, (DWORD_PTR
)dwParam2
, FALSE
);
3208 /* TODO: Remove after dsound has been rewritten for mmdevapi */
3209 case DRV_QUERYDSOUNDDESC
:
3210 case DRV_QUERYDSOUNDIFACE
:
3211 if(dwParam2
== DS_HW_ACCEL_FULL
)
3212 return WINMM_DRVMessage(HandleToULong(hWaveIn
), uMessage
,
3213 dwParam1
, 0, FALSE
);
3214 return WINMM_FillDSDriverDesc(HandleToULong(hWaveIn
),
3215 (DSDRIVERDESC
*)dwParam1
, FALSE
);
3218 return MMSYSERR_NOTSUPPORTED
;
3221 UINT WINAPI
mixerGetNumDevs(void)
3225 if(!WINMM_StartDevicesThread())
3228 return g_outmmdevices_count
+ g_inmmdevices_count
;
3231 /**************************************************************************
3232 * mixerGetDevCapsA [WINMM.@]
3234 UINT WINAPI
mixerGetDevCapsA(UINT_PTR uDeviceID
, LPMIXERCAPSA lpCaps
, UINT uSize
)
3239 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3242 return MMSYSERR_INVALPARAM
;
3244 ret
= mixerGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
3246 if (ret
== MMSYSERR_NOERROR
) {
3248 micA
.wMid
= micW
.wMid
;
3249 micA
.wPid
= micW
.wPid
;
3250 micA
.vDriverVersion
= micW
.vDriverVersion
;
3251 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
3252 sizeof(micA
.szPname
), NULL
, NULL
);
3253 micA
.fdwSupport
= micW
.fdwSupport
;
3254 micA
.cDestinations
= micW
.cDestinations
;
3255 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
3260 /**************************************************************************
3261 * mixerGetDevCapsW [WINMM.@]
3263 UINT WINAPI
mixerGetDevCapsW(UINT_PTR uDeviceID
, LPMIXERCAPSW lpCaps
, UINT uSize
)
3265 WINMM_MMDevice
*mmdevice
;
3268 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3270 if(!WINMM_StartDevicesThread())
3271 return MMSYSERR_ERROR
;
3274 return MMSYSERR_INVALPARAM
;
3277 return MMSYSERR_NOERROR
;
3279 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3280 return MMSYSERR_BADDEVICEID
;
3282 if(uDeviceID
< g_outmmdevices_count
){
3283 mmdevice
= &g_out_mmdevices
[uDeviceID
];
3284 memcpy(caps
.szPname
, mmdevice
->out_caps
.szPname
, sizeof(caps
.szPname
));
3286 mmdevice
= &g_in_mmdevices
[uDeviceID
- g_outmmdevices_count
];
3287 memcpy(caps
.szPname
, mmdevice
->in_caps
.szPname
, sizeof(caps
.szPname
));
3292 caps
.vDriverVersion
= 0x00010001;
3293 caps
.fdwSupport
= 0;
3294 caps
.cDestinations
= 1;
3296 memcpy(lpCaps
, &caps
, uSize
);
3298 return MMSYSERR_NOERROR
;
3301 /**************************************************************************
3302 * mixerOpen [WINMM.@]
3304 UINT WINAPI
mixerOpen(LPHMIXER lphMix
, UINT uDeviceID
, DWORD_PTR dwCallback
,
3305 DWORD_PTR dwInstance
, DWORD fdwOpen
)
3307 WINMM_MMDevice
*mmdevice
;
3310 TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix
, uDeviceID
, dwCallback
,
3311 dwInstance
, fdwOpen
);
3313 if(!WINMM_StartDevicesThread())
3314 return MMSYSERR_ERROR
;
3317 return MMSYSERR_INVALPARAM
;
3319 mr
= WINMM_CheckCallback(dwCallback
, fdwOpen
, TRUE
);
3320 if(mr
!= MMSYSERR_NOERROR
)
3323 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3324 return MMSYSERR_BADDEVICEID
;
3326 if(uDeviceID
< g_outmmdevices_count
){
3327 mmdevice
= &g_out_mmdevices
[uDeviceID
];
3328 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
, TRUE
,
3329 mmdevice
->mixer_count
);
3331 mmdevice
= &g_in_mmdevices
[uDeviceID
- g_outmmdevices_count
];
3332 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
- g_outmmdevices_count
,
3333 FALSE
, mmdevice
->mixer_count
);
3336 ++mmdevice
->mixer_count
;
3338 return MMSYSERR_NOERROR
;
3341 /**************************************************************************
3342 * mixerClose [WINMM.@]
3344 UINT WINAPI
mixerClose(HMIXER hMix
)
3346 TRACE("(%p)\n", hMix
);
3348 return MMSYSERR_NOERROR
;
3351 /**************************************************************************
3352 * mixerGetID [WINMM.@]
3354 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
3356 WINMM_MMDevice
*mmdevice
;
3358 TRACE("(%p, %p, %x)\n", hmix
, lpid
, fdwID
);
3360 if(!WINMM_StartDevicesThread())
3361 return MMSYSERR_ERROR
;
3364 return MMSYSERR_INVALPARAM
;
3366 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwID
, lpid
);
3368 return MMSYSERR_INVALHANDLE
;
3370 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3371 *lpid
+= g_outmmdevices_count
;
3373 return MMSYSERR_NOERROR
;
3376 /**************************************************************************
3377 * mixerGetControlDetailsW [WINMM.@]
3379 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdW
,
3382 WINMM_ControlDetails details
;
3384 TRACE("(%p, %p, %x)\n", hmix
, lpmcdW
, fdwDetails
);
3386 if(!WINMM_StartDevicesThread())
3387 return MMSYSERR_ERROR
;
3390 return MMSYSERR_INVALPARAM
;
3392 TRACE("dwControlID: %u\n", lpmcdW
->dwControlID
);
3394 details
.hmix
= hmix
;
3395 details
.details
= lpmcdW
;
3396 details
.flags
= fdwDetails
;
3398 return SendMessageW(g_devices_hwnd
, MXDM_GETCONTROLDETAILS
,
3399 (DWORD_PTR
)&details
, 0);
3402 /**************************************************************************
3403 * mixerGetControlDetailsA [WINMM.@]
3405 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
,
3408 UINT ret
= MMSYSERR_NOTSUPPORTED
;
3410 TRACE("(%p, %p, %08x)\n", hmix
, lpmcdA
, fdwDetails
);
3412 if (lpmcdA
== NULL
|| lpmcdA
->cbStruct
!= sizeof(*lpmcdA
))
3413 return MMSYSERR_INVALPARAM
;
3415 switch (fdwDetails
& MIXER_GETCONTROLDETAILSF_QUERYMASK
) {
3416 case MIXER_GETCONTROLDETAILSF_VALUE
:
3417 /* can safely use A structure as it is, no string inside */
3418 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3420 case MIXER_GETCONTROLDETAILSF_LISTTEXT
:
3422 MIXERCONTROLDETAILS_LISTTEXTA
*pDetailsA
= lpmcdA
->paDetails
;
3423 MIXERCONTROLDETAILS_LISTTEXTW
*pDetailsW
;
3424 int size
= max(1, lpmcdA
->cChannels
) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3427 if (lpmcdA
->u
.cMultipleItems
!= 0) {
3428 size
*= lpmcdA
->u
.cMultipleItems
;
3430 pDetailsW
= HeapAlloc(GetProcessHeap(), 0, size
);
3431 lpmcdA
->paDetails
= pDetailsW
;
3432 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3433 /* set up lpmcd->paDetails */
3434 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3435 /* copy from lpmcd->paDetails back to paDetailsW; */
3436 if (ret
== MMSYSERR_NOERROR
) {
3437 for (i
= 0; i
< lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
; i
++) {
3438 pDetailsA
->dwParam1
= pDetailsW
->dwParam1
;
3439 pDetailsA
->dwParam2
= pDetailsW
->dwParam2
;
3440 WideCharToMultiByte( CP_ACP
, 0, pDetailsW
->szName
, -1,
3442 sizeof(pDetailsA
->szName
), NULL
, NULL
);
3446 pDetailsA
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
3447 pDetailsW
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
3449 HeapFree(GetProcessHeap(), 0, pDetailsW
);
3450 lpmcdA
->paDetails
= pDetailsA
;
3451 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTA
);
3455 ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails
);
3461 /**************************************************************************
3462 * mixerGetLineControlsA [WINMM.@]
3464 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
, LPMIXERLINECONTROLSA lpmlcA
,
3467 MIXERLINECONTROLSW mlcW
;
3471 TRACE("(%p, %p, %x)\n", hmix
, lpmlcA
, fdwControls
);
3473 if (lpmlcA
== NULL
|| lpmlcA
->cbStruct
!= sizeof(*lpmlcA
) ||
3474 lpmlcA
->cbmxctrl
!= sizeof(MIXERCONTROLA
))
3475 return MMSYSERR_INVALPARAM
;
3477 mlcW
.cbStruct
= sizeof(mlcW
);
3478 mlcW
.dwLineID
= lpmlcA
->dwLineID
;
3479 mlcW
.u
.dwControlID
= lpmlcA
->u
.dwControlID
;
3480 mlcW
.u
.dwControlType
= lpmlcA
->u
.dwControlType
;
3482 /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3483 the control count is assumed to be 1 - This is relied upon by a game,
3484 "Dynomite Deluze" */
3485 if (MIXER_GETLINECONTROLSF_ONEBYTYPE
== (fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
)) {
3488 mlcW
.cControls
= lpmlcA
->cControls
;
3490 mlcW
.cbmxctrl
= sizeof(MIXERCONTROLW
);
3491 mlcW
.pamxctrl
= HeapAlloc(GetProcessHeap(), 0,
3492 mlcW
.cControls
* mlcW
.cbmxctrl
);
3494 ret
= mixerGetLineControlsW(hmix
, &mlcW
, fdwControls
);
3496 if (ret
== MMSYSERR_NOERROR
) {
3497 lpmlcA
->dwLineID
= mlcW
.dwLineID
;
3498 lpmlcA
->u
.dwControlID
= mlcW
.u
.dwControlID
;
3499 lpmlcA
->u
.dwControlType
= mlcW
.u
.dwControlType
;
3501 for (i
= 0; i
< mlcW
.cControls
; i
++) {
3502 lpmlcA
->pamxctrl
[i
].cbStruct
= sizeof(MIXERCONTROLA
);
3503 lpmlcA
->pamxctrl
[i
].dwControlID
= mlcW
.pamxctrl
[i
].dwControlID
;
3504 lpmlcA
->pamxctrl
[i
].dwControlType
= mlcW
.pamxctrl
[i
].dwControlType
;
3505 lpmlcA
->pamxctrl
[i
].fdwControl
= mlcW
.pamxctrl
[i
].fdwControl
;
3506 lpmlcA
->pamxctrl
[i
].cMultipleItems
= mlcW
.pamxctrl
[i
].cMultipleItems
;
3507 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szShortName
, -1,
3508 lpmlcA
->pamxctrl
[i
].szShortName
,
3509 sizeof(lpmlcA
->pamxctrl
[i
].szShortName
), NULL
, NULL
);
3510 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szName
, -1,
3511 lpmlcA
->pamxctrl
[i
].szName
,
3512 sizeof(lpmlcA
->pamxctrl
[i
].szName
), NULL
, NULL
);
3513 /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3514 * sizeof(mlcW.pamxctrl[i].Bounds) */
3515 memcpy(&lpmlcA
->pamxctrl
[i
].Bounds
, &mlcW
.pamxctrl
[i
].Bounds
,
3516 sizeof(mlcW
.pamxctrl
[i
].Bounds
));
3517 /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
3518 * sizeof(mlcW.pamxctrl[i].Metrics) */
3519 memcpy(&lpmlcA
->pamxctrl
[i
].Metrics
, &mlcW
.pamxctrl
[i
].Metrics
,
3520 sizeof(mlcW
.pamxctrl
[i
].Metrics
));
3524 HeapFree(GetProcessHeap(), 0, mlcW
.pamxctrl
);
3529 static UINT
WINMM_GetVolumeLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
3530 MIXERCONTROLW
*ctl
, DWORD flags
)
3532 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 0 : 2;
3533 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_VOLUME
;
3534 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
3535 ctl
->cMultipleItems
= 0;
3536 lstrcpyW(ctl
->szShortName
, volumeW
);
3537 lstrcpyW(ctl
->szName
, volumeW
);
3538 ctl
->Bounds
.s1
.dwMinimum
= 0;
3539 ctl
->Bounds
.s1
.dwMaximum
= 0xFFFF;
3540 ctl
->Metrics
.cSteps
= 192;
3542 return MMSYSERR_NOERROR
;
3545 static UINT
WINMM_GetMuteLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
3546 MIXERCONTROLW
*ctl
, DWORD flags
)
3548 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 1 : 3;
3549 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_MUTE
;
3550 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
3551 ctl
->cMultipleItems
= 0;
3552 lstrcpyW(ctl
->szShortName
, muteW
);
3553 lstrcpyW(ctl
->szName
, muteW
);
3554 ctl
->Bounds
.s1
.dwMinimum
= 0;
3555 ctl
->Bounds
.s1
.dwMaximum
= 1;
3556 ctl
->Metrics
.cSteps
= 0;
3558 return MMSYSERR_NOERROR
;
3561 /**************************************************************************
3562 * mixerGetLineControlsW [WINMM.@]
3564 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
, LPMIXERLINECONTROLSW lpmlcW
,
3567 WINMM_MMDevice
*mmdevice
;
3569 TRACE("(%p, %p, %08x)\n", hmix
, lpmlcW
, fdwControls
);
3571 if(!WINMM_StartDevicesThread())
3572 return MMSYSERR_ERROR
;
3574 if(fdwControls
& ~(MIXER_GETLINECONTROLSF_ALL
|
3575 MIXER_GETLINECONTROLSF_ONEBYID
|
3576 MIXER_GETLINECONTROLSF_ONEBYTYPE
|
3577 MIXER_OBJECTF_HMIXER
|
3578 MIXER_OBJECTF_MIXER
)){
3579 WARN("Unknown GetLineControls flag: %x\n", fdwControls
);
3580 return MMSYSERR_INVALFLAG
;
3583 if(!lpmlcW
|| lpmlcW
->cbStruct
< sizeof(*lpmlcW
) || !lpmlcW
->pamxctrl
)
3584 return MMSYSERR_INVALPARAM
;
3586 TRACE("dwLineID: %u\n", lpmlcW
->dwLineID
);
3587 TRACE("dwControl: %x\n", lpmlcW
->u
.dwControlID
);
3588 TRACE("cControls: %u\n", lpmlcW
->cControls
);
3590 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwControls
, NULL
);
3592 return MMSYSERR_INVALHANDLE
;
3594 switch(fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
){
3595 case MIXER_GETLINECONTROLSF_ALL
:
3596 if(lpmlcW
->cControls
!= 2)
3597 return MMSYSERR_INVALPARAM
;
3598 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
3599 return MMSYSERR_INVALPARAM
;
3600 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
3601 return MIXERR_INVALLINE
;
3602 WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
3603 &lpmlcW
->pamxctrl
[0], fdwControls
);
3604 WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
3605 &lpmlcW
->pamxctrl
[1], fdwControls
);
3606 return MMSYSERR_NOERROR
;
3607 case MIXER_GETLINECONTROLSF_ONEBYID
:
3608 if(lpmlcW
->cControls
!= 1)
3609 return MMSYSERR_INVALPARAM
;
3610 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
3611 return MMSYSERR_INVALPARAM
;
3612 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
3613 return MIXERR_INVALLINE
;
3614 if(lpmlcW
->u
.dwControlID
== 0)
3615 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
3616 lpmlcW
->pamxctrl
, fdwControls
);
3617 if(lpmlcW
->u
.dwControlID
== 1)
3618 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
3619 lpmlcW
->pamxctrl
, fdwControls
);
3620 return MMSYSERR_NOTSUPPORTED
;
3621 case MIXER_GETLINECONTROLSF_ONEBYTYPE
:
3622 if(lpmlcW
->cControls
!= 1)
3623 return MMSYSERR_INVALPARAM
;
3624 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
3625 return MMSYSERR_INVALPARAM
;
3626 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
3627 return MIXERR_INVALLINE
;
3628 if(lpmlcW
->u
.dwControlType
== MIXERCONTROL_CONTROLTYPE_VOLUME
)
3629 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
3630 lpmlcW
->pamxctrl
, fdwControls
);
3631 if(lpmlcW
->u
.dwControlType
== MIXERCONTROL_CONTROLTYPE_MUTE
)
3632 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
3633 lpmlcW
->pamxctrl
, fdwControls
);
3634 return MMSYSERR_NOTSUPPORTED
;
3637 return MMSYSERR_NOTSUPPORTED
;
3640 static UINT
WINMM_GetSourceLineInfo(WINMM_MMDevice
*mmdevice
, UINT mmdev_index
,
3641 MIXERLINEW
*info
, DWORD flags
)
3644 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3647 if(info
->dwSource
!= 0)
3648 return MIXERR_INVALLINE
;
3650 info
->dwDestination
= 0;
3652 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
| MIXERLINE_LINEF_SOURCE
;
3653 info
->cConnections
= 0;
3654 info
->cControls
= 2;
3655 /* volume & mute always affect all channels, so claim 1 channel */
3656 info
->cChannels
= 1;
3657 info
->Target
.dwDeviceID
= mmdev_index
;
3658 info
->Target
.wMid
= ~0;
3659 info
->Target
.wPid
= ~0;
3660 info
->Target
.vDriverVersion
= 0;
3662 lstrcpyW(info
->szShortName
, volumeW
);
3663 lstrcpyW(info
->szName
, mastervolumeW
);
3666 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
;
3667 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEOUT
;
3668 memcpy(info
->Target
.szPname
, mmdevice
->out_caps
.szPname
,
3669 sizeof(info
->Target
.szPname
));
3671 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_LINE
;
3672 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
3673 info
->Target
.szPname
[0] = '\0';
3676 return MMSYSERR_NOERROR
;
3679 static UINT
WINMM_GetDestinationLineInfo(WINMM_MMDevice
*mmdevice
,
3680 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
3683 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3686 if(info
->dwDestination
!= 0)
3687 return MIXERR_INVALLINE
;
3689 info
->dwSource
= 0xFFFFFFFF;
3690 info
->dwLineID
= 0xFFFF0000;
3691 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
;
3692 info
->cConnections
= 1;
3693 info
->cControls
= 2;
3695 lstrcpyW(info
->szShortName
, volumeW
);
3696 lstrcpyW(info
->szName
, mastervolumeW
);
3698 info
->Target
.dwDeviceID
= mmdev_index
;
3699 info
->Target
.wMid
= ~0;
3700 info
->Target
.wPid
= ~0;
3701 info
->Target
.vDriverVersion
= 0;
3704 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
;
3705 info
->cChannels
= mmdevice
->out_caps
.wChannels
;
3706 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
3707 info
->Target
.szPname
[0] = '\0';
3709 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_WAVEIN
;
3710 info
->cChannels
= mmdevice
->in_caps
.wChannels
;
3711 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEIN
;
3712 memcpy(info
->Target
.szPname
, mmdevice
->in_caps
.szPname
,
3713 sizeof(info
->Target
.szPname
));
3716 return MMSYSERR_NOERROR
;
3719 static UINT
WINMM_GetComponentTypeLineInfo(WINMM_MMDevice
*mmdevice
,
3720 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
3723 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3726 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_WAVEIN
){
3728 return MIXERR_INVALLINE
;
3729 info
->dwDestination
= 0;
3730 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3733 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
){
3735 return MIXERR_INVALLINE
;
3736 info
->dwDestination
= 0;
3737 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3740 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_LINE
){
3742 return MIXERR_INVALLINE
;
3744 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3747 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
){
3749 return MIXERR_INVALLINE
;
3751 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3754 TRACE("Returning INVALLINE on this component type: %u\n",
3755 info
->dwComponentType
);
3757 return MIXERR_INVALLINE
;
3760 static UINT
WINMM_GetLineIDLineInfo(WINMM_MMDevice
*mmdevice
,
3761 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
3763 if(info
->dwLineID
== 0xFFFF0000){
3764 info
->dwDestination
= 0;
3765 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3768 if(info
->dwLineID
== 0){
3770 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
3773 TRACE("Returning INVALLINE on this dwLineID: %u\n", info
->dwLineID
);
3774 return MIXERR_INVALLINE
;
3777 /**************************************************************************
3778 * mixerGetLineInfoW [WINMM.@]
3780 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpmliW
, DWORD fdwInfo
)
3783 WINMM_MMDevice
*mmdevice
;
3785 TRACE("(%p, %p, %x)\n", hmix
, lpmliW
, fdwInfo
);
3787 if(!WINMM_StartDevicesThread())
3788 return MMSYSERR_ERROR
;
3790 if(!lpmliW
|| lpmliW
->cbStruct
< sizeof(MIXERLINEW
))
3791 return MMSYSERR_INVALPARAM
;
3793 TRACE("dwDestination: %u\n", lpmliW
->dwDestination
);
3794 TRACE("dwSource: %u\n", lpmliW
->dwSource
);
3795 TRACE("dwLineID: %u\n", lpmliW
->dwLineID
);
3796 TRACE("fdwLine: 0x%x\n", lpmliW
->fdwLine
);
3797 TRACE("dwComponentType: 0x%x\n", lpmliW
->dwComponentType
);
3799 if(fdwInfo
& ~(MIXER_GETLINEINFOF_COMPONENTTYPE
|
3800 MIXER_GETLINEINFOF_DESTINATION
|
3801 MIXER_GETLINEINFOF_LINEID
|
3802 MIXER_GETLINEINFOF_SOURCE
|
3803 MIXER_GETLINEINFOF_TARGETTYPE
|
3804 MIXER_OBJECTF_HMIXER
|
3805 MIXER_OBJECTF_MIXER
)){
3806 WARN("Unknown GetLineInfo flag: %x\n", fdwInfo
);
3807 return MMSYSERR_INVALFLAG
;
3810 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwInfo
, &mmdev_index
);
3812 return MMSYSERR_INVALHANDLE
;
3814 switch(fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
){
3815 case MIXER_GETLINEINFOF_DESTINATION
:
3816 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, lpmliW
,
3818 case MIXER_GETLINEINFOF_SOURCE
:
3819 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
3820 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
3821 return WINMM_GetComponentTypeLineInfo(mmdevice
, mmdev_index
, lpmliW
,
3823 case MIXER_GETLINEINFOF_LINEID
:
3824 return WINMM_GetLineIDLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
3825 case MIXER_GETLINEINFOF_TARGETTYPE
:
3826 FIXME("TARGETTYPE flag not implemented!\n");
3827 return MIXERR_INVALLINE
;
3830 TRACE("Returning INVALFLAG on these flags: %lx\n",
3831 fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
);
3832 return MMSYSERR_INVALFLAG
;
3835 /**************************************************************************
3836 * mixerGetLineInfoA [WINMM.@]
3838 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
, LPMIXERLINEA lpmliA
,
3844 TRACE("(%p, %p, %x)\n", hmix
, lpmliA
, fdwInfo
);
3846 if (lpmliA
== NULL
|| lpmliA
->cbStruct
!= sizeof(*lpmliA
))
3847 return MMSYSERR_INVALPARAM
;
3849 mliW
.cbStruct
= sizeof(mliW
);
3850 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
3851 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
3852 mliW
.dwComponentType
= lpmliA
->dwComponentType
;
3854 case MIXER_GETLINEINFOF_DESTINATION
:
3855 mliW
.dwDestination
= lpmliA
->dwDestination
;
3857 case MIXER_GETLINEINFOF_LINEID
:
3858 mliW
.dwLineID
= lpmliA
->dwLineID
;
3860 case MIXER_GETLINEINFOF_SOURCE
:
3861 mliW
.dwDestination
= lpmliA
->dwDestination
;
3862 mliW
.dwSource
= lpmliA
->dwSource
;
3864 case MIXER_GETLINEINFOF_TARGETTYPE
:
3865 mliW
.Target
.dwType
= lpmliA
->Target
.dwType
;
3866 mliW
.Target
.wMid
= lpmliA
->Target
.wMid
;
3867 mliW
.Target
.wPid
= lpmliA
->Target
.wPid
;
3868 mliW
.Target
.vDriverVersion
= lpmliA
->Target
.vDriverVersion
;
3869 MultiByteToWideChar( CP_ACP
, 0, lpmliA
->Target
.szPname
, -1, mliW
.Target
.szPname
, sizeof(mliW
.Target
.szPname
)/sizeof(WCHAR
));
3872 WARN("Unsupported fdwControls=0x%08x\n", fdwInfo
);
3873 return MMSYSERR_INVALFLAG
;
3876 ret
= mixerGetLineInfoW(hmix
, &mliW
, fdwInfo
);
3878 if(ret
== MMSYSERR_NOERROR
)
3880 lpmliA
->dwDestination
= mliW
.dwDestination
;
3881 lpmliA
->dwSource
= mliW
.dwSource
;
3882 lpmliA
->dwLineID
= mliW
.dwLineID
;
3883 lpmliA
->fdwLine
= mliW
.fdwLine
;
3884 lpmliA
->dwUser
= mliW
.dwUser
;
3885 lpmliA
->dwComponentType
= mliW
.dwComponentType
;
3886 lpmliA
->cChannels
= mliW
.cChannels
;
3887 lpmliA
->cConnections
= mliW
.cConnections
;
3888 lpmliA
->cControls
= mliW
.cControls
;
3889 WideCharToMultiByte( CP_ACP
, 0, mliW
.szShortName
, -1, lpmliA
->szShortName
,
3890 sizeof(lpmliA
->szShortName
), NULL
, NULL
);
3891 WideCharToMultiByte( CP_ACP
, 0, mliW
.szName
, -1, lpmliA
->szName
,
3892 sizeof(lpmliA
->szName
), NULL
, NULL
);
3893 lpmliA
->Target
.dwType
= mliW
.Target
.dwType
;
3894 lpmliA
->Target
.dwDeviceID
= mliW
.Target
.dwDeviceID
;
3895 lpmliA
->Target
.wMid
= mliW
.Target
.wMid
;
3896 lpmliA
->Target
.wPid
= mliW
.Target
.wPid
;
3897 lpmliA
->Target
.vDriverVersion
= mliW
.Target
.vDriverVersion
;
3898 WideCharToMultiByte( CP_ACP
, 0, mliW
.Target
.szPname
, -1, lpmliA
->Target
.szPname
,
3899 sizeof(lpmliA
->Target
.szPname
), NULL
, NULL
);
3904 /**************************************************************************
3905 * mixerSetControlDetails [WINMM.@]
3907 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
,
3910 WINMM_ControlDetails details
;
3912 TRACE("(%p, %p, %x)\n", hmix
, lpmcd
, fdwDetails
);
3914 if(!WINMM_StartDevicesThread())
3915 return MMSYSERR_ERROR
;
3917 if((fdwDetails
& MIXER_SETCONTROLDETAILSF_QUERYMASK
) ==
3918 MIXER_SETCONTROLDETAILSF_CUSTOM
)
3919 return MMSYSERR_NOTSUPPORTED
;
3922 return MMSYSERR_INVALPARAM
;
3924 TRACE("dwControlID: %u\n", lpmcd
->dwControlID
);
3926 details
.hmix
= hmix
;
3927 details
.details
= lpmcd
;
3928 details
.flags
= fdwDetails
;
3930 return SendMessageW(g_devices_hwnd
, MXDM_SETCONTROLDETAILS
,
3931 (DWORD_PTR
)&details
, 0);
3934 /**************************************************************************
3935 * mixerMessage [WINMM.@]
3937 DWORD WINAPI
mixerMessage(HMIXER hmix
, UINT uMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3939 TRACE("(%p, %d, %lx, %lx)\n", hmix
, uMsg
, dwParam1
, dwParam2
);
3941 return MMSYSERR_NOTSUPPORTED
;