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
44 #include "mmdeviceapi.h"
45 #include "audioclient.h"
46 #include "audiopolicy.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
52 /* HWAVE (and HMIXER) format:
54 * XXXX... 1FDD DDDD IIII IIII
55 * X = unused (must be 0)
56 * 1 = the bit is set to 1, to avoid all-zero HWAVEs
57 * F = flow direction (0 = IN, 1 = OUT)
58 * D = index into g_out_mmdevices, or all 1s for the MAPPER device
59 * I = index in the mmdevice's devices array
61 * Two reasons that we don't just use pointers:
62 * - HWAVEs must fit into 16 bits for compatibility with old applications.
63 * - We must be able to identify bad devices without crashing.
66 /* buffer size = 10 * 100000 (100 ns) = 0.1 seconds */
67 #define AC_BUFLEN (10 * 100000)
68 #define MAX_DEVICES 256
69 #define MAPPER_INDEX 0x3F
71 typedef struct _WINMM_CBInfo
{
78 struct _WINMM_MMDevice
;
79 typedef struct _WINMM_MMDevice WINMM_MMDevice
;
81 typedef struct _WINMM_Device
{
90 IAudioRenderClient
*render
;
91 IAudioCaptureClient
*capture
;
93 IAudioStreamVolume
*volume
;
95 WAVEFORMATEX
*orig_fmt
;
96 HACMSTREAM acm_handle
;
97 ACMSTREAMHEADER acm_hdr
;
100 WAVEHDR
*first
, *last
, *playing
, *loop_start
;
104 UINT32 bytes_per_frame
, samples_per_sec
, ofs_bytes
, played_frames
;
105 UINT32 remainder_frames
; /* header chunk frames already played when a device switch occurred */
107 /* stored in frames of sample rate, *not* AC::GetFrequency */
108 UINT64 last_clock_pos
;
111 CRITICAL_SECTION lock
;
113 WINMM_MMDevice
*parent
;
116 struct _WINMM_MMDevice
{
117 WAVEOUTCAPSW out_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
118 WAVEINCAPSW in_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
122 ISimpleAudioVolume
*volume
;
128 /* HMIXER format is the same as the HWAVE format, but the I bits are
129 * replaced by the value of this counter, to keep each HMIXER unique */
132 CRITICAL_SECTION lock
;
134 WINMM_Device
*devices
[MAX_DEVICES
];
137 static WINMM_MMDevice
*g_out_mmdevices
;
138 static WINMM_MMDevice
**g_out_map
;
139 static UINT g_outmmdevices_count
;
140 static WINMM_Device
*g_out_mapper_devices
[MAX_DEVICES
];
142 static WINMM_MMDevice
*g_in_mmdevices
;
143 static WINMM_MMDevice
**g_in_map
;
144 static UINT g_inmmdevices_count
;
145 static WINMM_Device
*g_in_mapper_devices
[MAX_DEVICES
];
147 static IMMDeviceEnumerator
*g_devenum
;
149 static CRITICAL_SECTION g_devthread_lock
;
150 static CRITICAL_SECTION_DEBUG g_devthread_lock_debug
=
152 0, 0, &g_devthread_lock
,
153 { &g_devthread_lock_debug
.ProcessLocksList
, &g_devthread_lock_debug
.ProcessLocksList
},
154 0, 0, { (DWORD_PTR
)(__FILE__
": g_devthread_lock") }
156 static CRITICAL_SECTION g_devthread_lock
= { &g_devthread_lock_debug
, -1, 0, 0, 0, 0 };
157 static LONG g_devthread_token
;
158 static HANDLE g_devices_thread
;
159 static HWND g_devices_hwnd
;
160 static HMODULE g_devthread_module
;
162 static UINT g_devhandle_count
;
163 static HANDLE
*g_device_handles
;
164 static WINMM_Device
**g_handle_devices
;
166 typedef struct _WINMM_OpenInfo
{
169 WAVEFORMATEX
*format
;
176 typedef struct _WINMM_ControlDetails
{
178 MIXERCONTROLDETAILS
*details
;
180 } WINMM_ControlDetails
;
182 typedef struct _WINMM_QueryInterfaceInfo
{
187 } WINMM_QueryInterfaceInfo
;
189 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
);
190 static LRESULT
WOD_Close(HWAVEOUT hwave
);
191 static LRESULT
WID_Open(WINMM_OpenInfo
*info
);
192 static LRESULT
WID_Close(HWAVEIN hwave
);
193 static MMRESULT
WINMM_BeginPlaying(WINMM_Device
*device
);
195 void WINMM_DeleteWaveform(void)
200 CloseHandle(g_devices_thread
);
202 for(i
= 0; i
< g_outmmdevices_count
; ++i
){
203 WINMM_MMDevice
*mmdevice
= &g_out_mmdevices
[i
];
205 for(j
= 0; j
< MAX_DEVICES
&& mmdevice
->devices
[j
]; ++j
){
206 WINMM_Device
*device
= mmdevice
->devices
[j
];
208 CloseHandle(device
->handle
);
209 device
->lock
.DebugInfo
->Spare
[0] = 0;
210 DeleteCriticalSection(&device
->lock
);
214 ISimpleAudioVolume_Release(mmdevice
->volume
);
215 CoTaskMemFree(mmdevice
->dev_id
);
216 mmdevice
->lock
.DebugInfo
->Spare
[0] = 0;
217 DeleteCriticalSection(&mmdevice
->lock
);
220 for(i
= 0; i
< g_inmmdevices_count
; ++i
){
221 WINMM_MMDevice
*mmdevice
= &g_in_mmdevices
[i
];
223 for(j
= 0; j
< MAX_DEVICES
&& mmdevice
->devices
[j
]; ++j
){
224 WINMM_Device
*device
= mmdevice
->devices
[j
];
226 CloseHandle(device
->handle
);
227 device
->lock
.DebugInfo
->Spare
[0] = 0;
228 DeleteCriticalSection(&device
->lock
);
232 ISimpleAudioVolume_Release(mmdevice
->volume
);
233 CoTaskMemFree(mmdevice
->dev_id
);
234 mmdevice
->lock
.DebugInfo
->Spare
[0] = 0;
235 DeleteCriticalSection(&mmdevice
->lock
);
238 HeapFree(GetProcessHeap(), 0, g_out_mmdevices
);
239 HeapFree(GetProcessHeap(), 0, g_in_mmdevices
);
241 HeapFree(GetProcessHeap(), 0, g_device_handles
);
242 HeapFree(GetProcessHeap(), 0, g_handle_devices
);
244 DeleteCriticalSection(&g_devthread_lock
);
247 static inline HWAVE
WINMM_MakeHWAVE(UINT mmdevice
, BOOL is_out
, UINT device
)
249 return ULongToHandle((1 << 15) | ((!!is_out
) << 14) |
250 (mmdevice
<< 8) | device
);
253 static inline void WINMM_DecomposeHWAVE(HWAVE hwave
, UINT
*mmdevice_index
,
254 BOOL
*is_out
, UINT
*device_index
, UINT
*junk
)
256 ULONG32 l
= HandleToULong(hwave
);
257 *device_index
= l
& 0xFF;
258 *mmdevice_index
= (l
>> 8) & 0x3F;
259 *is_out
= (l
>> 14) & 0x1;
263 static void WINMM_InitDevice(WINMM_Device
*device
)
265 InitializeCriticalSection(&device
->lock
);
266 device
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": WINMM_Device.lock");
269 static inline WINMM_MMDevice
*read_map(WINMM_MMDevice
**map
, UINT index
)
272 EnterCriticalSection(&g_devthread_lock
);
274 LeaveCriticalSection(&g_devthread_lock
);
278 /* finds the first unused Device, marks it as "open", and returns
279 * a pointer to the device
281 * IMPORTANT: it is the caller's responsibility to release the device's lock
284 static WINMM_Device
*WINMM_FindUnusedDevice(WINMM_Device
**devices
,
285 WINMM_MMDevice
*parent
, UINT internal_index
, BOOL is_out
)
289 for(i
= 0; i
< MAX_DEVICES
; ++i
){
290 WINMM_Device
*device
= devices
[i
];
293 device
= devices
[i
] = HeapAlloc(GetProcessHeap(),
294 HEAP_ZERO_MEMORY
, sizeof(WINMM_Device
));
298 WINMM_InitDevice(device
);
299 EnterCriticalSection(&device
->lock
);
301 EnterCriticalSection(&device
->lock
);
304 device
->handle
= WINMM_MakeHWAVE(internal_index
, is_out
, i
);
305 device
->parent
= parent
;
311 LeaveCriticalSection(&device
->lock
);
314 TRACE("All devices in use: mmdevice: %u\n", internal_index
);
319 static inline BOOL
WINMM_ValidateAndLock(WINMM_Device
*device
)
324 EnterCriticalSection(&device
->lock
);
327 LeaveCriticalSection(&device
->lock
);
334 static WINMM_Device
*WINMM_GetDeviceFromHWAVE(HWAVE hwave
)
336 WINMM_MMDevice
*mmdevice
;
337 WINMM_Device
*device
;
338 UINT mmdevice_index
, device_index
, junk
;
341 WINMM_DecomposeHWAVE(hwave
, &mmdevice_index
, &is_out
, &device_index
, &junk
);
346 if(mmdevice_index
== MAPPER_INDEX
){
347 EnterCriticalSection(&g_devthread_lock
);
349 device
= g_out_mapper_devices
[device_index
];
351 device
= g_in_mapper_devices
[device_index
];
352 LeaveCriticalSection(&g_devthread_lock
);
356 if(mmdevice_index
>= (is_out
? g_outmmdevices_count
: g_inmmdevices_count
))
360 mmdevice
= &g_out_mmdevices
[mmdevice_index
];
362 mmdevice
= &g_in_mmdevices
[mmdevice_index
];
364 EnterCriticalSection(&mmdevice
->lock
);
366 device
= mmdevice
->devices
[device_index
];
368 LeaveCriticalSection(&mmdevice
->lock
);
373 /* Note: NotifyClient should never be called while holding the device lock
374 * since the client may call wave* functions from within the callback. */
375 static inline void WINMM_NotifyClient(WINMM_CBInfo
*info
, WORD msg
, DWORD_PTR param1
,
378 DriverCallback(info
->callback
, info
->flags
, (HDRVR
)info
->hwave
,
379 msg
, info
->user
, param1
, param2
);
382 static MMRESULT
hr2mmr(HRESULT hr
)
386 case AUDCLNT_E_NOT_STOPPED
:
387 return MMSYSERR_NOERROR
;
388 case AUDCLNT_E_UNSUPPORTED_FORMAT
:
389 return WAVERR_BADFORMAT
;
390 case AUDCLNT_E_DEVICE_IN_USE
:
391 return MMSYSERR_ALLOCATED
;
392 case AUDCLNT_E_ENDPOINT_CREATE_FAILED
:
393 return MMSYSERR_NOTENABLED
;
395 return MMSYSERR_NOMEM
;
398 return MMSYSERR_INVALPARAM
;
399 case AUDCLNT_E_DEVICE_INVALIDATED
: /* DSERR_BUFFERLOST */
401 return FAILED(hr
) ? MMSYSERR_ERROR
: MMSYSERR_NOERROR
;
405 static HRESULT
WINMM_GetFriendlyName(IMMDevice
*device
, WCHAR
*out
,
412 hr
= IMMDevice_OpenPropertyStore(device
, STGM_READ
, &ps
);
416 PropVariantInit(&var
);
418 hr
= IPropertyStore_GetValue(ps
,
419 (PROPERTYKEY
*)&DEVPKEY_Device_FriendlyName
, &var
);
421 IPropertyStore_Release(ps
);
425 lstrcpynW(out
, var
.u
.pwszVal
, outlen
);
427 PropVariantClear(&var
);
429 IPropertyStore_Release(ps
);
434 static HRESULT
WINMM_TestFormat(IAudioClient
*client
, DWORD rate
, DWORD depth
,
437 WAVEFORMATEX fmt
, *junk
;
440 fmt
.wFormatTag
= WAVE_FORMAT_PCM
;
441 fmt
.nChannels
= channels
;
442 fmt
.nSamplesPerSec
= rate
;
443 fmt
.wBitsPerSample
= depth
;
444 fmt
.nBlockAlign
= (channels
* depth
) / 8;
445 fmt
.nAvgBytesPerSec
= rate
* fmt
.nBlockAlign
;
448 hr
= IAudioClient_IsFormatSupported(client
, AUDCLNT_SHAREMODE_SHARED
,
456 static struct _TestFormat
{
461 } formats_to_test
[] = {
462 { WAVE_FORMAT_1M08
, 11025, 8, 1 },
463 { WAVE_FORMAT_1M16
, 11025, 16, 1 },
464 { WAVE_FORMAT_1S08
, 11025, 8, 2 },
465 { WAVE_FORMAT_1S16
, 11025, 16, 2 },
466 { WAVE_FORMAT_2M08
, 22050, 8, 1 },
467 { WAVE_FORMAT_2M16
, 22050, 16, 1 },
468 { WAVE_FORMAT_2S08
, 22050, 8, 2 },
469 { WAVE_FORMAT_2S16
, 22050, 16, 2 },
470 { WAVE_FORMAT_4M08
, 44100, 8, 1 },
471 { WAVE_FORMAT_4M16
, 44100, 16, 1 },
472 { WAVE_FORMAT_4S08
, 44100, 8, 2 },
473 { WAVE_FORMAT_4S16
, 44100, 16, 2 },
474 { WAVE_FORMAT_48M08
, 48000, 8, 1 },
475 { WAVE_FORMAT_48M16
, 48000, 16, 1 },
476 { WAVE_FORMAT_48S08
, 48000, 8, 2 },
477 { WAVE_FORMAT_48S16
, 48000, 16, 2 },
478 { WAVE_FORMAT_96M08
, 96000, 8, 1 },
479 { WAVE_FORMAT_96M16
, 96000, 16, 1 },
480 { WAVE_FORMAT_96S08
, 96000, 8, 2 },
481 { WAVE_FORMAT_96S16
, 96000, 16, 2 },
485 static DWORD
WINMM_GetSupportedFormats(IMMDevice
*device
)
489 struct _TestFormat
*fmt
;
490 IAudioClient
*client
;
492 hr
= IMMDevice_Activate(device
, &IID_IAudioClient
,
493 CLSCTX_INPROC_SERVER
, NULL
, (void**)&client
);
497 for(fmt
= formats_to_test
; fmt
->flag
; ++fmt
){
498 hr
= WINMM_TestFormat(client
, fmt
->rate
, fmt
->depth
, fmt
->channels
);
503 IAudioClient_Release(client
);
508 static HRESULT
WINMM_InitMMDevice(EDataFlow flow
, IMMDevice
*device
,
509 WINMM_MMDevice
*dev
, UINT index
)
513 dev
->dataflow
= flow
;
515 dev
->out_caps
.wMid
= 0xFF;
516 dev
->out_caps
.wPid
= 0xFF;
517 dev
->out_caps
.vDriverVersion
= 0x00010001;
518 dev
->out_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
519 dev
->out_caps
.wReserved1
= 0;
520 dev
->out_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
521 WAVECAPS_SAMPLEACCURATE
;
522 dev
->out_caps
.wChannels
= 2;
523 dev
->out_caps
.szPname
[0] = '\0';
525 hr
= WINMM_GetFriendlyName(device
, dev
->out_caps
.szPname
,
526 sizeof(dev
->out_caps
.szPname
) /
527 sizeof(*dev
->out_caps
.szPname
));
531 dev
->in_caps
.wMid
= 0xFF;
532 dev
->in_caps
.wPid
= 0xFF;
533 dev
->in_caps
.vDriverVersion
= 0x00010001;
534 dev
->in_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
535 dev
->in_caps
.wReserved1
= 0;
536 dev
->in_caps
.wChannels
= 2;
537 dev
->in_caps
.szPname
[0] = '\0';
539 hr
= WINMM_GetFriendlyName(device
, dev
->in_caps
.szPname
,
540 sizeof(dev
->in_caps
.szPname
) /
541 sizeof(*dev
->in_caps
.szPname
));
546 hr
= IMMDevice_GetId(device
, &dev
->dev_id
);
550 CoCreateGuid(&dev
->session
);
554 InitializeCriticalSection(&dev
->lock
);
555 dev
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": WINMM_Device.lock");
560 static HRESULT
WINMM_EnumDevices(WINMM_MMDevice
**devices
,
561 WINMM_MMDevice
***map
, UINT
*devcount
, EDataFlow flow
,
562 IMMDeviceEnumerator
*devenum
)
564 IMMDeviceCollection
*devcoll
;
567 hr
= IMMDeviceEnumerator_EnumAudioEndpoints(devenum
, flow
,
568 DEVICE_STATE_ACTIVE
, &devcoll
);
572 hr
= IMMDeviceCollection_GetCount(devcoll
, devcount
);
574 IMMDeviceCollection_Release(devcoll
);
580 IMMDevice
*def_dev
= NULL
;
582 *devices
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
583 sizeof(WINMM_MMDevice
) * (*devcount
));
585 IMMDeviceCollection_Release(devcoll
);
586 return E_OUTOFMEMORY
;
589 *map
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
590 sizeof(WINMM_MMDevice
*) * (*devcount
));
592 IMMDeviceCollection_Release(devcoll
);
593 HeapFree(GetProcessHeap(), 0, *devices
);
594 return E_OUTOFMEMORY
;
597 /* make sure that device 0 is the default device */
598 IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum
,
599 flow
, eConsole
, &def_dev
);
601 for(n
= 0; n
< *devcount
; ++n
){
604 hr
= IMMDeviceCollection_Item(devcoll
, n
, &device
);
606 WINMM_InitMMDevice(flow
, device
, &(*devices
)[n
], n
);
608 if(device
== def_dev
)
609 (*map
)[0] = &(*devices
)[n
];
611 (*map
)[count
] = &(*devices
)[n
];
615 IMMDevice_Release(device
);
619 IMMDevice_Release(def_dev
);
624 IMMDeviceCollection_Release(devcoll
);
629 static HRESULT WINAPI
notif_QueryInterface(IMMNotificationClient
*iface
,
630 const GUID
*riid
, void **obj
)
632 ERR("Unexpected QueryInterface call: %s\n", wine_dbgstr_guid(riid
));
633 return E_NOINTERFACE
;
636 static ULONG WINAPI
notif_AddRef(IMMNotificationClient
*iface
)
641 static ULONG WINAPI
notif_Release(IMMNotificationClient
*iface
)
646 static HRESULT WINAPI
notif_OnDeviceStateChanged(IMMNotificationClient
*iface
,
647 const WCHAR
*device_id
, DWORD new_state
)
649 TRACE("Ignoring OnDeviceStateChanged callback\n");
653 static HRESULT WINAPI
notif_OnDeviceAdded(IMMNotificationClient
*iface
,
654 const WCHAR
*device_id
)
656 TRACE("Ignoring OnDeviceAdded callback\n");
660 static HRESULT WINAPI
notif_OnDeviceRemoved(IMMNotificationClient
*iface
,
661 const WCHAR
*device_id
)
663 TRACE("Ignoring OnDeviceRemoved callback\n");
667 static HRESULT
update_mapping(WINMM_MMDevice
***map
, UINT count
,
668 const WCHAR
*default_id
)
670 WINMM_MMDevice
*prev
;
674 for(i
= 0; i
< count
; ++i
){
677 if(!lstrcmpW((*map
)[i
]->dev_id
, default_id
)){
678 (*map
)[0] = (*map
)[i
];
689 WARN("Couldn't find new default device! Rearranged map for no reason.\n");
695 static HRESULT
reroute_mapper_device(WINMM_Device
*device
, BOOL is_out
)
701 UINT64 clock_freq
, clock_pos
;
703 TRACE("rerouting device %p\n", device
->handle
);
705 EnterCriticalSection(&device
->lock
);
707 if(!device
->open
|| device
->acm_handle
){
708 /* Windows 7 doesn't re-route ACM devices, so we don't either.
709 * Seems to be because of the data waveXxxPrepareHeader allocates. */
710 LeaveCriticalSection(&device
->lock
);
714 stopped
= device
->stopped
;
717 info
.req_device
= WAVE_MAPPER
;
718 info
.format
= device
->orig_fmt
;
719 info
.callback
= device
->cb_info
.callback
;
720 info
.cb_user
= device
->cb_info
.user
;
721 /* We have to use direct here so that we don't suddenly introduce ACM
722 * into a playing stream that hasn't been Prepared for it */
723 info
.flags
= (device
->cb_info
.flags
<< 16) | WAVE_FORMAT_DIRECT_QUERY
;
727 mr
= WOD_Open(&info
);
729 mr
= WID_Open(&info
);
731 if(mr
!= MMSYSERR_NOERROR
){
732 TRACE("New default device doesn't support this stream: %p\n", device
->handle
);
733 LeaveCriticalSection(&device
->lock
);
737 hr
= IAudioClient_Stop(device
->client
);
739 WARN("Stop failed: %08x\n", hr
);
741 hr
= IAudioClock_GetFrequency(device
->clock
, &clock_freq
);
743 WARN("GetFrequency failed: %08x\n", hr
);
744 LeaveCriticalSection(&device
->lock
);
748 hr
= IAudioClock_GetPosition(device
->clock
, &clock_pos
, NULL
);
750 WARN("GetPosition failed: %08x\n", hr
);
751 LeaveCriticalSection(&device
->lock
);
755 device
->remainder_frames
= MulDiv(clock_pos
, device
->samples_per_sec
, clock_freq
) - device
->last_clock_pos
;
757 info
.handle
= device
->handle
;
758 info
.flags
= (device
->cb_info
.flags
<< 16) | WAVE_FORMAT_DIRECT
;
761 WOD_Close((HWAVEOUT
)device
->handle
);
762 device
->parent
= read_map(g_out_map
, 0);
763 mr
= WOD_Open(&info
);
765 WID_Close((HWAVEIN
)device
->handle
);
766 device
->parent
= read_map(g_in_map
, 0);
767 mr
= WID_Open(&info
);
770 if(mr
!= MMSYSERR_NOERROR
){
771 ERR("Opening new default device failed! %u\n", mr
);
772 LeaveCriticalSection(&device
->lock
);
776 HeapFree(GetProcessHeap(), 0, info
.format
);
779 WINMM_BeginPlaying(device
);
781 LeaveCriticalSection(&device
->lock
);
786 static HRESULT WINAPI
notif_OnDefaultDeviceChanged(IMMNotificationClient
*iface
,
787 EDataFlow flow
, ERole role
, const WCHAR
*device_id
)
791 TRACE("%u %u %s\n", flow
, role
, wine_dbgstr_w(device_id
));
796 EnterCriticalSection(&g_devthread_lock
);
799 update_mapping(&g_out_map
, g_outmmdevices_count
, device_id
);
801 update_mapping(&g_in_map
, g_inmmdevices_count
, device_id
);
803 for(i
= 0; i
< MAX_DEVICES
&& g_out_mapper_devices
[i
]; ++i
)
804 reroute_mapper_device(g_out_mapper_devices
[i
], TRUE
);
806 for(i
= 0; i
< MAX_DEVICES
&& g_in_mapper_devices
[i
]; ++i
)
807 reroute_mapper_device(g_in_mapper_devices
[i
], FALSE
);
809 LeaveCriticalSection(&g_devthread_lock
);
814 static HRESULT WINAPI
notif_OnPropertyValueChanged(IMMNotificationClient
*iface
,
815 const WCHAR
*device_id
, const PROPERTYKEY key
)
817 TRACE("Ignoring OnPropertyValueChanged callback\n");
821 static IMMNotificationClientVtbl g_notif_vtbl
= {
822 notif_QueryInterface
,
825 notif_OnDeviceStateChanged
,
827 notif_OnDeviceRemoved
,
828 notif_OnDefaultDeviceChanged
,
829 notif_OnPropertyValueChanged
832 static IMMNotificationClient g_notif
= { &g_notif_vtbl
};
834 static HRESULT
WINMM_InitMMDevices(void)
837 IMMDeviceEnumerator
*devenum
= NULL
;
839 if(g_outmmdevices_count
|| g_inmmdevices_count
)
842 init_hr
= CoInitialize(NULL
);
844 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
,
845 CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&devenum
);
849 hr
= IMMDeviceEnumerator_RegisterEndpointNotificationCallback(devenum
, &g_notif
);
851 WARN("RegisterEndpointNotificationCallback failed: %08x\n", hr
);
853 hr
= WINMM_EnumDevices(&g_out_mmdevices
, &g_out_map
, &g_outmmdevices_count
,
856 g_outmmdevices_count
= 0;
857 g_inmmdevices_count
= 0;
861 hr
= WINMM_EnumDevices(&g_in_mmdevices
, &g_in_map
, &g_inmmdevices_count
,
864 g_inmmdevices_count
= 0;
870 IMMDeviceEnumerator_Release(devenum
);
871 if(SUCCEEDED(init_hr
))
877 static inline BOOL
WINMM_IsMapper(UINT device
)
879 return (device
== WAVE_MAPPER
|| device
== (UINT16
)WAVE_MAPPER
);
882 static MMRESULT
WINMM_TryDeviceMapping(WINMM_Device
*device
, WAVEFORMATEX
*fmt
,
883 WORD channels
, DWORD freq
, DWORD bits_per_samp
, BOOL is_query
, BOOL is_out
)
885 WAVEFORMATEX target
, *closer_fmt
= NULL
;
889 TRACE("format: %u, channels: %u, sample rate: %u, bit depth: %u\n",
890 WAVE_FORMAT_PCM
, channels
, freq
, bits_per_samp
);
892 target
.wFormatTag
= WAVE_FORMAT_PCM
;
893 target
.nChannels
= channels
;
894 target
.nSamplesPerSec
= freq
;
895 target
.wBitsPerSample
= bits_per_samp
;
896 target
.nBlockAlign
= (target
.nChannels
* target
.wBitsPerSample
) / 8;
897 target
.nAvgBytesPerSec
= target
.nSamplesPerSec
* target
.nBlockAlign
;
900 hr
= IAudioClient_IsFormatSupported(device
->client
,
901 AUDCLNT_SHAREMODE_SHARED
, &target
, &closer_fmt
);
902 CoTaskMemFree(closer_fmt
);
904 return WAVERR_BADFORMAT
;
906 /* device supports our target format, so see if MSACM can
907 * do the conversion */
909 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, fmt
, &target
, NULL
,
912 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, &target
, fmt
, NULL
,
914 if(mr
!= MMSYSERR_NOERROR
)
917 /* yes it can. initialize the audioclient and return success */
919 acmStreamClose(device
->acm_handle
, 0);
920 device
->acm_handle
= NULL
;
921 return MMSYSERR_NOERROR
;
924 hr
= IAudioClient_Initialize(device
->client
, AUDCLNT_SHAREMODE_SHARED
,
925 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
| AUDCLNT_STREAMFLAGS_NOPERSIST
,
926 AC_BUFLEN
, 0, &target
, &device
->parent
->session
);
928 WARN("Initialize failed: %08x\n", hr
);
929 acmStreamClose(device
->acm_handle
, 0);
930 device
->acm_handle
= NULL
;
931 return MMSYSERR_ERROR
;
934 device
->bytes_per_frame
= target
.nBlockAlign
;
935 device
->samples_per_sec
= target
.nSamplesPerSec
;
939 return MMSYSERR_NOERROR
;
942 static MMRESULT
WINMM_MapDevice(WINMM_Device
*device
, BOOL is_query
, BOOL is_out
)
945 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)device
->orig_fmt
;
947 TRACE("(%p, %u)\n", device
, is_out
);
949 /* set up the ACM stream */
950 if(device
->orig_fmt
->wFormatTag
!= WAVE_FORMAT_PCM
&&
951 !(device
->orig_fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
952 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))){
953 /* convert to PCM format if it's not already */
954 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
,
955 device
->orig_fmt
->nChannels
, device
->orig_fmt
->nSamplesPerSec
,
956 16, is_query
, is_out
);
957 if(mr
== MMSYSERR_NOERROR
)
960 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
,
961 device
->orig_fmt
->nChannels
, device
->orig_fmt
->nSamplesPerSec
,
962 8, is_query
, is_out
);
963 if(mr
== MMSYSERR_NOERROR
)
968 /* first try just changing bit depth and channels */
969 channels
= device
->orig_fmt
->nChannels
;
970 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
971 device
->orig_fmt
->nSamplesPerSec
, 16, is_query
, is_out
);
972 if(mr
== MMSYSERR_NOERROR
)
974 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
975 device
->orig_fmt
->nSamplesPerSec
, 8, is_query
, is_out
);
976 if(mr
== MMSYSERR_NOERROR
)
979 channels
= (channels
== 2) ? 1 : 2;
980 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
981 device
->orig_fmt
->nSamplesPerSec
, 16, is_query
, is_out
);
982 if(mr
== MMSYSERR_NOERROR
)
984 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
985 device
->orig_fmt
->nSamplesPerSec
, 8, is_query
, is_out
);
986 if(mr
== MMSYSERR_NOERROR
)
989 /* that didn't work, so now try different sample rates */
990 channels
= device
->orig_fmt
->nChannels
;
991 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 16, is_query
, is_out
);
992 if(mr
== MMSYSERR_NOERROR
)
994 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 16, is_query
, is_out
);
995 if(mr
== MMSYSERR_NOERROR
)
997 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 16, is_query
, is_out
);
998 if(mr
== MMSYSERR_NOERROR
)
1000 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 16, is_query
, is_out
);
1001 if(mr
== MMSYSERR_NOERROR
)
1003 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 16, is_query
, is_out
);
1004 if(mr
== MMSYSERR_NOERROR
)
1007 channels
= (channels
== 2) ? 1 : 2;
1008 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 16, is_query
, is_out
);
1009 if(mr
== MMSYSERR_NOERROR
)
1011 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 16, is_query
, is_out
);
1012 if(mr
== MMSYSERR_NOERROR
)
1014 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 16, is_query
, is_out
);
1015 if(mr
== MMSYSERR_NOERROR
)
1017 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 16, is_query
, is_out
);
1018 if(mr
== MMSYSERR_NOERROR
)
1020 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 16, is_query
, is_out
);
1021 if(mr
== MMSYSERR_NOERROR
)
1024 channels
= device
->orig_fmt
->nChannels
;
1025 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 8, is_query
, is_out
);
1026 if(mr
== MMSYSERR_NOERROR
)
1028 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 8, is_query
, is_out
);
1029 if(mr
== MMSYSERR_NOERROR
)
1031 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 8, is_query
, is_out
);
1032 if(mr
== MMSYSERR_NOERROR
)
1034 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 8, is_query
, is_out
);
1035 if(mr
== MMSYSERR_NOERROR
)
1037 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 8, is_query
, is_out
);
1038 if(mr
== MMSYSERR_NOERROR
)
1041 channels
= (channels
== 2) ? 1 : 2;
1042 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 8, is_query
, is_out
);
1043 if(mr
== MMSYSERR_NOERROR
)
1045 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 8, is_query
, is_out
);
1046 if(mr
== MMSYSERR_NOERROR
)
1048 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 8, is_query
, is_out
);
1049 if(mr
== MMSYSERR_NOERROR
)
1051 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 8, is_query
, is_out
);
1052 if(mr
== MMSYSERR_NOERROR
)
1054 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 8, is_query
, is_out
);
1055 if(mr
== MMSYSERR_NOERROR
)
1059 WARN("Unable to find compatible device!\n");
1060 return WAVERR_BADFORMAT
;
1063 static LRESULT
WINMM_OpenDevice(WINMM_Device
*device
, WINMM_OpenInfo
*info
,
1066 LRESULT ret
= MMSYSERR_NOMEM
;
1069 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, device
->parent
->dev_id
,
1072 WARN("Device %s (%s) unavailable: %08x\n",
1073 wine_dbgstr_w(device
->parent
->dev_id
),
1074 wine_dbgstr_w(device
->parent
->out_caps
.szPname
), hr
);
1075 ret
= MMSYSERR_NODRIVER
;
1079 /* this is where winexyz.drv opens the audio device */
1080 hr
= IMMDevice_Activate(device
->device
, &IID_IAudioClient
,
1081 CLSCTX_INPROC_SERVER
, NULL
, (void**)&device
->client
);
1083 WARN("Activate failed: %08x\n", hr
);
1085 if(ret
== MMSYSERR_ERROR
)
1086 ret
= MMSYSERR_NOTENABLED
;
1090 if(info
->format
->wFormatTag
== WAVE_FORMAT_PCM
){
1092 if (info
->format
->nSamplesPerSec
== 0)
1094 ret
= MMSYSERR_INVALPARAM
;
1098 /* we aren't guaranteed that the struct in lpFormat is a full
1099 * WAVEFORMATEX struct, which IAC::IsFormatSupported requires */
1100 device
->orig_fmt
= HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEX
));
1101 memcpy(device
->orig_fmt
, info
->format
, sizeof(PCMWAVEFORMAT
));
1102 device
->orig_fmt
->cbSize
= 0;
1103 if(device
->orig_fmt
->wBitsPerSample
% 8 != 0){
1104 WARN("Fixing bad wBitsPerSample (%u)\n", device
->orig_fmt
->wBitsPerSample
);
1105 device
->orig_fmt
->wBitsPerSample
= (device
->orig_fmt
->wBitsPerSample
+ 7) & ~7;
1107 /* winmm ignores broken blockalign and avgbytes */
1108 if(device
->orig_fmt
->nBlockAlign
!= device
->orig_fmt
->nChannels
* device
->orig_fmt
->wBitsPerSample
/8){
1109 WARN("Fixing bad nBlockAlign (%u)\n", device
->orig_fmt
->nBlockAlign
);
1110 device
->orig_fmt
->nBlockAlign
= device
->orig_fmt
->nChannels
* device
->orig_fmt
->wBitsPerSample
/8;
1112 if (device
->orig_fmt
->nAvgBytesPerSec
!= device
->orig_fmt
->nSamplesPerSec
* device
->orig_fmt
->nBlockAlign
) {
1113 WARN("Fixing bad nAvgBytesPerSec (%u)\n", device
->orig_fmt
->nAvgBytesPerSec
);
1114 device
->orig_fmt
->nAvgBytesPerSec
= device
->orig_fmt
->nSamplesPerSec
* device
->orig_fmt
->nBlockAlign
;
1117 device
->orig_fmt
= HeapAlloc(GetProcessHeap(), 0,
1118 sizeof(WAVEFORMATEX
) + info
->format
->cbSize
);
1119 memcpy(device
->orig_fmt
, info
->format
,
1120 sizeof(WAVEFORMATEX
) + info
->format
->cbSize
);
1123 if(info
->flags
& WAVE_FORMAT_QUERY
){
1124 WAVEFORMATEX
*closer_fmt
= NULL
;
1126 hr
= IAudioClient_IsFormatSupported(device
->client
,
1127 AUDCLNT_SHAREMODE_SHARED
, device
->orig_fmt
, &closer_fmt
);
1128 CoTaskMemFree(closer_fmt
);
1129 if((hr
== S_FALSE
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !(info
->flags
& WAVE_FORMAT_DIRECT
))
1130 ret
= WINMM_MapDevice(device
, TRUE
, is_out
);
1132 ret
= hr
== S_FALSE
? WAVERR_BADFORMAT
: hr2mmr(hr
);
1136 hr
= IAudioClient_Initialize(device
->client
, AUDCLNT_SHAREMODE_SHARED
,
1137 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
| AUDCLNT_STREAMFLAGS_NOPERSIST
,
1138 AC_BUFLEN
, 0, device
->orig_fmt
, &device
->parent
->session
);
1140 if(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
&& !(info
->flags
& WAVE_FORMAT_DIRECT
)){
1141 ret
= WINMM_MapDevice(device
, FALSE
, is_out
);
1142 if(ret
!= MMSYSERR_NOERROR
|| info
->flags
& WAVE_FORMAT_QUERY
)
1145 WARN("Initialize failed: %08x\n", hr
);
1150 device
->bytes_per_frame
= device
->orig_fmt
->nBlockAlign
;
1151 device
->samples_per_sec
= device
->orig_fmt
->nSamplesPerSec
;
1154 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioClock
,
1155 (void**)&device
->clock
);
1157 WARN("GetService failed: %08x\n", hr
);
1162 device
->event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1164 WARN("CreateEvent failed: %08x\n", hr
);
1168 /* As the devices thread is waiting on g_device_handles, it can
1169 * only be modified from within this same thread. */
1170 if(g_device_handles
){
1171 g_device_handles
= HeapReAlloc(GetProcessHeap(), 0, g_device_handles
,
1172 sizeof(HANDLE
) * (g_devhandle_count
+ 1));
1173 g_handle_devices
= HeapReAlloc(GetProcessHeap(), 0, g_handle_devices
,
1174 sizeof(WINMM_Device
*) * (g_devhandle_count
+ 1));
1176 g_device_handles
= HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE
));
1177 g_handle_devices
= HeapAlloc(GetProcessHeap(), 0,
1178 sizeof(WINMM_Device
*));
1180 g_device_handles
[g_devhandle_count
] = device
->event
;
1181 g_handle_devices
[g_devhandle_count
] = device
;
1182 ++g_devhandle_count
;
1185 hr
= IAudioClient_SetEventHandle(device
->client
, device
->event
);
1187 WARN("SetEventHandle failed: %08x\n", hr
);
1192 device
->played_frames
= 0;
1193 device
->ofs_bytes
= 0;
1194 device
->loop_counter
= 0;
1195 device
->first
= device
->last
= device
->playing
= device
->loop_start
= NULL
;
1198 device
->stopped
= TRUE
;
1199 device
->last_clock_pos
= 0;
1201 device
->cb_info
.flags
= HIWORD(info
->flags
& CALLBACK_TYPEMASK
);
1202 device
->cb_info
.callback
= info
->callback
;
1203 device
->cb_info
.user
= info
->cb_user
;
1204 device
->cb_info
.hwave
= device
->handle
;
1206 info
->handle
= device
->handle
;
1208 return MMSYSERR_NOERROR
;
1212 IAudioClient_Release(device
->client
);
1213 device
->client
= NULL
;
1216 IMMDevice_Release(device
->device
);
1217 device
->device
= NULL
;
1223 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
)
1225 WINMM_Device
*device
;
1226 LRESULT ret
= MMSYSERR_ERROR
;
1229 if(info
->handle
!= 0){
1230 device
= WINMM_GetDeviceFromHWAVE(info
->handle
);
1232 WARN("Unexpected! Invalid info->handle given: %p\n", info
->handle
);
1233 return MMSYSERR_ERROR
;
1236 EnterCriticalSection(&device
->lock
);
1238 device
->open
= TRUE
;
1240 CRITICAL_SECTION
*lock
;
1241 UINT internal_index
;
1242 WINMM_Device
**devices
;
1243 WINMM_MMDevice
*mmdevice
;
1245 if(WINMM_IsMapper(info
->req_device
)){
1246 if (g_outmmdevices_count
== 0)
1247 return MMSYSERR_BADDEVICEID
;
1248 devices
= g_out_mapper_devices
;
1249 mmdevice
= read_map(g_out_map
, 0);
1250 lock
= &g_devthread_lock
;
1251 internal_index
= MAPPER_INDEX
;
1253 if(info
->req_device
>= g_outmmdevices_count
)
1254 return MMSYSERR_BADDEVICEID
;
1256 mmdevice
= read_map(g_out_map
, info
->req_device
);
1258 if(!mmdevice
->out_caps
.szPname
[0])
1259 return MMSYSERR_NOTENABLED
;
1261 devices
= mmdevice
->devices
;
1262 lock
= &mmdevice
->lock
;
1263 internal_index
= mmdevice
->index
;
1266 EnterCriticalSection(lock
);
1268 device
= WINMM_FindUnusedDevice(devices
, mmdevice
,
1269 internal_index
, TRUE
);
1271 LeaveCriticalSection(lock
);
1272 return MMSYSERR_ALLOCATED
;
1275 LeaveCriticalSection(lock
);
1278 ret
= WINMM_OpenDevice(device
, info
, TRUE
);
1279 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
1281 ret
= MMSYSERR_ERROR
;
1283 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioRenderClient
,
1284 (void**)&device
->render
);
1286 ERR("GetService failed: %08x\n", hr
);
1290 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioStreamVolume
,
1291 (void**)&device
->volume
);
1293 ERR("GetService failed: %08x\n", hr
);
1297 LeaveCriticalSection(&device
->lock
);
1299 return MMSYSERR_NOERROR
;
1303 IMMDevice_Release(device
->device
);
1304 device
->device
= NULL
;
1307 IAudioClient_Release(device
->client
);
1308 device
->client
= NULL
;
1311 IAudioRenderClient_Release(device
->render
);
1312 device
->render
= NULL
;
1315 IAudioStreamVolume_Release(device
->volume
);
1316 device
->volume
= NULL
;
1319 IAudioClock_Release(device
->clock
);
1320 device
->clock
= NULL
;
1322 device
->open
= FALSE
;
1323 LeaveCriticalSection(&device
->lock
);
1327 static LRESULT
WID_Open(WINMM_OpenInfo
*info
)
1329 WINMM_Device
*device
, **devices
;
1330 WINMM_MMDevice
*mmdevice
;
1331 UINT internal_index
;
1332 CRITICAL_SECTION
*lock
;
1333 LRESULT ret
= MMSYSERR_ERROR
;
1336 if(WINMM_IsMapper(info
->req_device
)){
1337 if (g_inmmdevices_count
== 0)
1338 return MMSYSERR_BADDEVICEID
;
1339 devices
= g_in_mapper_devices
;
1340 mmdevice
= read_map(g_in_map
, 0);
1341 lock
= &g_devthread_lock
;
1342 internal_index
= MAPPER_INDEX
;
1344 if(info
->req_device
>= g_inmmdevices_count
)
1345 return MMSYSERR_BADDEVICEID
;
1347 mmdevice
= read_map(g_in_map
, info
->req_device
);
1349 if(!mmdevice
->in_caps
.szPname
[0])
1350 return MMSYSERR_NOTENABLED
;
1352 devices
= mmdevice
->devices
;
1353 lock
= &mmdevice
->lock
;
1354 internal_index
= mmdevice
->index
;
1357 EnterCriticalSection(lock
);
1359 device
= WINMM_FindUnusedDevice(devices
, mmdevice
, internal_index
, FALSE
);
1361 LeaveCriticalSection(lock
);
1362 return MMSYSERR_ALLOCATED
;
1365 LeaveCriticalSection(lock
);
1367 ret
= WINMM_OpenDevice(device
, info
, FALSE
);
1368 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
1370 ret
= MMSYSERR_ERROR
;
1372 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioCaptureClient
,
1373 (void**)&device
->capture
);
1375 WARN("GetService failed: %08x\n", hr
);
1379 LeaveCriticalSection(&device
->lock
);
1381 return MMSYSERR_NOERROR
;
1385 IMMDevice_Release(device
->device
);
1386 device
->device
= NULL
;
1389 IAudioClient_Release(device
->client
);
1390 device
->client
= NULL
;
1392 if(device
->capture
){
1393 IAudioCaptureClient_Release(device
->capture
);
1394 device
->capture
= NULL
;
1397 IAudioClock_Release(device
->clock
);
1398 device
->clock
= NULL
;
1400 device
->open
= FALSE
;
1401 LeaveCriticalSection(&device
->lock
);
1405 static HRESULT
WINMM_CloseDevice(WINMM_Device
*device
)
1407 device
->open
= FALSE
;
1409 if(!device
->stopped
){
1410 IAudioClient_Stop(device
->client
);
1411 device
->stopped
= TRUE
;
1414 if(device
->acm_handle
){
1415 acmStreamClose(device
->acm_handle
, 0);
1416 device
->acm_handle
= NULL
;
1419 IMMDevice_Release(device
->device
);
1420 device
->device
= NULL
;
1422 IAudioClient_Release(device
->client
);
1423 device
->client
= NULL
;
1425 IAudioClock_Release(device
->clock
);
1426 device
->clock
= NULL
;
1428 HeapFree(GetProcessHeap(), 0, device
->orig_fmt
);
1433 static LRESULT
WOD_Close(HWAVEOUT hwave
)
1435 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1437 TRACE("(%p)\n", hwave
);
1439 if(!WINMM_ValidateAndLock(device
))
1440 return MMSYSERR_INVALHANDLE
;
1442 WINMM_CloseDevice(device
);
1444 IAudioRenderClient_Release(device
->render
);
1445 device
->render
= NULL
;
1447 IAudioStreamVolume_Release(device
->volume
);
1448 device
->volume
= NULL
;
1450 LeaveCriticalSection(&device
->lock
);
1452 return MMSYSERR_NOERROR
;
1455 static LRESULT
WID_Close(HWAVEIN hwave
)
1457 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1459 TRACE("(%p)\n", hwave
);
1461 if(!WINMM_ValidateAndLock(device
))
1462 return MMSYSERR_INVALHANDLE
;
1464 WINMM_CloseDevice(device
);
1466 IAudioCaptureClient_Release(device
->capture
);
1467 device
->capture
= NULL
;
1469 LeaveCriticalSection(&device
->lock
);
1471 return MMSYSERR_NOERROR
;
1474 static DWORD
WINMM_FixedBufferLen(DWORD length
, WINMM_Device
*device
)
1476 return length
- length
% device
->bytes_per_frame
;
1479 static LRESULT
WINMM_PrepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1481 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1483 TRACE("(%p, %p)\n", hwave
, header
);
1485 if(!WINMM_ValidateAndLock(device
))
1486 return MMSYSERR_INVALHANDLE
;
1488 if(device
->render
&& device
->acm_handle
){
1489 ACMSTREAMHEADER
*ash
;
1493 mr
= acmStreamSize(device
->acm_handle
, header
->dwBufferLength
, &size
,
1494 ACM_STREAMSIZEF_SOURCE
);
1495 if(mr
!= MMSYSERR_NOERROR
){
1496 LeaveCriticalSection(&device
->lock
);
1500 ash
= HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER
) + size
);
1502 LeaveCriticalSection(&device
->lock
);
1503 return MMSYSERR_NOMEM
;
1506 ash
->cbStruct
= sizeof(*ash
);
1508 ash
->dwUser
= (DWORD_PTR
)header
;
1509 ash
->pbSrc
= (BYTE
*)header
->lpData
;
1510 ash
->cbSrcLength
= header
->dwBufferLength
;
1511 ash
->dwSrcUser
= header
->dwUser
;
1512 ash
->pbDst
= (BYTE
*)ash
+ sizeof(ACMSTREAMHEADER
);
1513 ash
->cbDstLength
= size
;
1516 mr
= acmStreamPrepareHeader(device
->acm_handle
, ash
, 0);
1517 if(mr
!= MMSYSERR_NOERROR
){
1518 HeapFree(GetProcessHeap(), 0, ash
);
1519 LeaveCriticalSection(&device
->lock
);
1523 header
->reserved
= (DWORD_PTR
)ash
;
1526 LeaveCriticalSection(&device
->lock
);
1528 header
->dwFlags
|= WHDR_PREPARED
;
1529 header
->dwFlags
&= ~(WHDR_DONE
|WHDR_INQUEUE
); /* flags cleared since w2k */
1531 return MMSYSERR_NOERROR
;
1534 static LRESULT
WINMM_UnprepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1536 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1538 TRACE("(%p, %p)\n", hwave
, header
);
1540 if(!WINMM_ValidateAndLock(device
))
1541 return MMSYSERR_INVALHANDLE
;
1543 if(device
->render
&& device
->acm_handle
){
1544 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1546 acmStreamUnprepareHeader(device
->acm_handle
, ash
, 0);
1548 HeapFree(GetProcessHeap(), 0, ash
);
1551 LeaveCriticalSection(&device
->lock
);
1553 header
->dwFlags
&= ~WHDR_PREPARED
;
1555 return MMSYSERR_NOERROR
;
1558 static UINT32
WINMM_HeaderLenBytes(WINMM_Device
*device
, WAVEHDR
*header
)
1560 if(device
->acm_handle
){
1561 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1562 return WINMM_FixedBufferLen(ash
->cbDstLengthUsed
, device
);
1565 return WINMM_FixedBufferLen(header
->dwBufferLength
, device
);
1568 static UINT32
WINMM_HeaderLenFrames(WINMM_Device
*device
, WAVEHDR
*header
)
1570 return WINMM_HeaderLenBytes(device
, header
) / device
->bytes_per_frame
;
1573 static WAVEHDR
*WOD_MarkDoneHeaders(WINMM_Device
*device
)
1576 WAVEHDR
*first
= device
->first
, *queue
= first
, *last
= NULL
;
1577 UINT64 clock_freq
, clock_pos
, clock_frames
;
1578 UINT32 nloops
, queue_frames
= 0;
1580 hr
= IAudioClock_GetFrequency(device
->clock
, &clock_freq
);
1582 WARN("GetFrequency failed: %08x\n", hr
);
1586 hr
= IAudioClock_GetPosition(device
->clock
, &clock_pos
, NULL
);
1588 WARN("GetPosition failed: %08x\n", hr
);
1592 clock_frames
= (clock_pos
* device
->samples_per_sec
) / clock_freq
;
1594 nloops
= device
->loop_counter
;
1596 (queue_frames
+= WINMM_HeaderLenFrames(device
, queue
)) <=
1597 clock_frames
- device
->last_clock_pos
+ device
->remainder_frames
){
1600 device
->last_clock_pos
+= queue_frames
;
1601 device
->remainder_frames
= 0;
1603 queue
= device
->first
= queue
->lpNext
;
1605 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1606 if(queue
->dwFlags
& WHDR_ENDLOOP
)
1609 queue
= queue
->lpNext
;
1610 }else if(queue
->dwFlags
& WHDR_ENDLOOP
){
1611 queue
= device
->loop_start
;
1618 last
->lpNext
= NULL
;
1624 static void WOD_PushData(WINMM_Device
*device
)
1626 WINMM_CBInfo cb_info
;
1628 UINT32 pad
, bufsize
, avail_frames
, queue_frames
, written
, ofs
;
1629 UINT32 queue_bytes
, nloops
;
1631 WAVEHDR
*queue
, *first
= NULL
;
1633 TRACE("(%p)\n", device
->handle
);
1635 EnterCriticalSection(&device
->lock
);
1641 if (device
->stopped
)
1643 device
->stopped
= TRUE
;
1644 device
->last_clock_pos
= 0;
1645 IAudioClient_Stop(device
->client
);
1646 IAudioClient_Reset(device
->client
);
1650 hr
= IAudioClient_GetBufferSize(device
->client
, &bufsize
);
1652 WARN("GetBufferSize failed: %08x\n", hr
);
1656 hr
= IAudioClient_GetCurrentPadding(device
->client
, &pad
);
1658 WARN("GetCurrentPadding failed: %08x\n", hr
);
1662 first
= WOD_MarkDoneHeaders(device
);
1664 /* determine which is larger between the available buffer size and
1665 * the amount of data left in the queue */
1666 avail_frames
= bufsize
- pad
;
1668 queue
= device
->playing
;
1669 ofs
= device
->ofs_bytes
;
1672 while(queue
&& queue_frames
< avail_frames
){
1673 queue_bytes
= WINMM_HeaderLenBytes(device
, queue
);
1674 queue_frames
+= (queue_bytes
- ofs
) / device
->bytes_per_frame
;
1677 if(queue
->dwFlags
& WHDR_ENDLOOP
&& nloops
< device
->loop_counter
){
1678 queue
= device
->loop_start
;
1681 queue
= queue
->lpNext
;
1684 if(queue_frames
< avail_frames
)
1685 avail_frames
= queue_frames
;
1686 if(avail_frames
== 0)
1689 hr
= IAudioRenderClient_GetBuffer(device
->render
, avail_frames
, &data
);
1691 WARN("GetBuffer failed: %08x\n", hr
);
1696 while(device
->playing
&& written
< avail_frames
){
1697 UINT32 copy_frames
, copy_bytes
;
1700 queue
= device
->playing
;
1702 queue_bytes
= WINMM_HeaderLenBytes(device
, queue
);
1703 if(device
->acm_handle
)
1704 queue_data
= ((ACMSTREAMHEADER
*)queue
->reserved
)->pbDst
;
1706 queue_data
= (BYTE
*)queue
->lpData
;
1708 queue_frames
= (queue_bytes
- device
->ofs_bytes
) /
1709 device
->bytes_per_frame
;
1711 copy_frames
= queue_frames
< (avail_frames
- written
) ?
1712 queue_frames
: avail_frames
- written
;
1713 copy_bytes
= copy_frames
* device
->bytes_per_frame
;
1715 memcpy(data
, queue_data
+ device
->ofs_bytes
, copy_bytes
);
1718 written
+= copy_frames
;
1719 device
->ofs_bytes
+= copy_bytes
;
1721 if(device
->ofs_bytes
>= queue_bytes
){
1722 device
->ofs_bytes
= 0;
1724 if(!(queue
->dwFlags
& (WHDR_BEGINLOOP
| WHDR_ENDLOOP
)))
1725 device
->playing
= queue
->lpNext
;
1727 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1728 device
->loop_start
= device
->playing
;
1729 device
->playing
= queue
->lpNext
;
1730 device
->loop_counter
= queue
->dwLoops
;
1732 if(queue
->dwFlags
& WHDR_ENDLOOP
){
1733 --device
->loop_counter
;
1734 if(device
->loop_counter
)
1735 device
->playing
= device
->loop_start
;
1737 device
->loop_start
= device
->playing
= queue
->lpNext
;
1743 hr
= IAudioRenderClient_ReleaseBuffer(device
->render
, avail_frames
, 0);
1745 WARN("ReleaseBuffer failed: %08x\n", hr
);
1749 if(device
->orig_fmt
->nSamplesPerSec
!= device
->samples_per_sec
)
1750 device
->played_frames
+= MulDiv(avail_frames
, device
->orig_fmt
->nSamplesPerSec
, device
->samples_per_sec
);
1752 device
->played_frames
+= avail_frames
;
1755 cb_info
= device
->cb_info
;
1757 LeaveCriticalSection(&device
->lock
);
1760 WAVEHDR
*next
= first
->lpNext
;
1761 first
->dwFlags
&= ~WHDR_INQUEUE
;
1762 first
->dwFlags
|= WHDR_DONE
;
1763 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
1768 static void WID_PullACMData(WINMM_Device
*device
)
1770 UINT32 packet
, packet_bytes
;
1777 if(device
->acm_hdr
.cbDstLength
== 0){
1778 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet
,
1779 &flags
, NULL
, NULL
);
1782 WARN("GetBuffer failed: %08x\n", hr
);
1786 acmStreamSize(device
->acm_handle
, packet
* device
->bytes_per_frame
,
1787 &packet_bytes
, ACM_STREAMSIZEF_SOURCE
);
1789 device
->acm_offs
= 0;
1791 device
->acm_hdr
.cbStruct
= sizeof(device
->acm_hdr
);
1792 device
->acm_hdr
.fdwStatus
= 0;
1793 device
->acm_hdr
.dwUser
= 0;
1794 device
->acm_hdr
.pbSrc
= data
;
1795 device
->acm_hdr
.cbSrcLength
= packet
* device
->bytes_per_frame
;
1796 device
->acm_hdr
.cbSrcLengthUsed
= 0;
1797 device
->acm_hdr
.dwSrcUser
= 0;
1798 device
->acm_hdr
.pbDst
= HeapAlloc(GetProcessHeap(), 0, packet_bytes
);
1799 device
->acm_hdr
.cbDstLength
= packet_bytes
;
1800 device
->acm_hdr
.cbDstLengthUsed
= 0;
1801 device
->acm_hdr
.dwDstUser
= 0;
1803 mr
= acmStreamPrepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1804 if(mr
!= MMSYSERR_NOERROR
){
1805 WARN("acmStreamPrepareHeader failed: %d\n", mr
);
1809 mr
= acmStreamConvert(device
->acm_handle
, &device
->acm_hdr
, 0);
1810 if(mr
!= MMSYSERR_NOERROR
){
1811 WARN("acmStreamConvert failed: %d\n", mr
);
1815 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet
);
1817 WARN("ReleaseBuffer failed: %08x\n", hr
);
1819 device
->played_frames
+= packet
;
1822 queue
= device
->first
;
1824 UINT32 to_copy_bytes
;
1826 to_copy_bytes
= min(WINMM_FixedBufferLen(queue
->dwBufferLength
, device
) - queue
->dwBytesRecorded
,
1827 WINMM_FixedBufferLen(device
->acm_hdr
.cbDstLengthUsed
, device
) - device
->acm_offs
);
1829 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
,
1830 device
->acm_hdr
.pbDst
+ device
->acm_offs
, to_copy_bytes
);
1832 queue
->dwBytesRecorded
+= to_copy_bytes
;
1833 device
->acm_offs
+= to_copy_bytes
;
1835 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1836 device
->bytes_per_frame
){
1837 queue
->dwFlags
&= ~WHDR_INQUEUE
;
1838 queue
->dwFlags
|= WHDR_DONE
;
1839 device
->first
= queue
= queue
->lpNext
;
1842 if(device
->acm_offs
>= WINMM_FixedBufferLen(device
->acm_hdr
.cbDstLengthUsed
, device
)){
1843 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1844 HeapFree(GetProcessHeap(), 0, device
->acm_hdr
.pbDst
);
1845 device
->acm_hdr
.cbDstLength
= 0;
1846 device
->acm_hdr
.cbDstLengthUsed
= 0;
1848 /* done with this ACM Header, so try to pull more data */
1849 WID_PullACMData(device
);
1854 /* out of WAVEHDRs to write into, so toss the rest of this packet */
1855 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1856 HeapFree(GetProcessHeap(), 0, device
->acm_hdr
.pbDst
);
1857 device
->acm_hdr
.cbDstLength
= 0;
1858 device
->acm_hdr
.cbDstLengthUsed
= 0;
1861 static void WID_PullData(WINMM_Device
*device
)
1863 WINMM_CBInfo cb_info
;
1864 WAVEHDR
*queue
, *first
= NULL
, *last
= NULL
;
1867 TRACE("(%p)\n", device
->handle
);
1869 EnterCriticalSection(&device
->lock
);
1871 if(!device
->device
|| !device
->first
)
1874 first
= device
->first
;
1876 if(device
->acm_handle
){
1877 WID_PullACMData(device
);
1881 while(device
->first
){
1883 UINT32 packet_len
, packet
;
1886 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet_len
,
1887 &flags
, NULL
, NULL
);
1890 WARN("GetBuffer failed: %08x\n", hr
);
1891 else /* AUDCLNT_S_BUFFER_EMPTY success code */
1892 IAudioCaptureClient_ReleaseBuffer(device
->capture
, 0);
1896 packet
= packet_len
;
1897 queue
= device
->first
;
1898 while(queue
&& packet
> 0){
1899 UINT32 to_copy_bytes
;
1901 to_copy_bytes
= min(packet
* device
->bytes_per_frame
,
1902 WINMM_FixedBufferLen(queue
->dwBufferLength
, device
) - queue
->dwBytesRecorded
);
1904 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
,
1905 data
+ (packet_len
- packet
) * device
->bytes_per_frame
,
1908 queue
->dwBytesRecorded
+= to_copy_bytes
;
1910 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1911 device
->bytes_per_frame
){
1913 device
->first
= queue
= queue
->lpNext
;
1916 packet
-= to_copy_bytes
/ device
->bytes_per_frame
;
1919 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet_len
);
1921 WARN("ReleaseBuffer failed: %08x\n", hr
);
1924 WARN("losing %u frames\n", packet
);
1925 device
->played_frames
+= packet_len
- packet
;
1929 cb_info
= device
->cb_info
;
1931 LeaveCriticalSection(&device
->lock
);
1934 last
->lpNext
= NULL
;
1936 WAVEHDR
*next
= first
->lpNext
;
1937 first
->dwFlags
&= ~WHDR_INQUEUE
;
1938 first
->dwFlags
|= WHDR_DONE
;
1939 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
1945 static MMRESULT
WINMM_BeginPlaying(WINMM_Device
*device
)
1949 TRACE("(%p)\n", device
->handle
);
1952 /* prebuffer data before starting */
1953 WOD_PushData(device
);
1955 if(device
->stopped
){
1956 device
->stopped
= FALSE
;
1958 hr
= IAudioClient_Start(device
->client
);
1959 if(FAILED(hr
) && hr
!= AUDCLNT_E_NOT_STOPPED
){
1960 device
->stopped
= TRUE
;
1961 WARN("Start failed: %08x\n", hr
);
1962 return MMSYSERR_ERROR
;
1966 return MMSYSERR_NOERROR
;
1969 static LRESULT
WINMM_Pause(HWAVE hwave
)
1971 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1974 TRACE("(%p)\n", hwave
);
1976 if(!WINMM_ValidateAndLock(device
))
1977 return MMSYSERR_INVALHANDLE
;
1979 hr
= IAudioClient_Stop(device
->client
);
1981 LeaveCriticalSection(&device
->lock
);
1982 WARN("Stop failed: %08x\n", hr
);
1983 return MMSYSERR_ERROR
;
1986 device
->stopped
= FALSE
;
1988 LeaveCriticalSection(&device
->lock
);
1990 return MMSYSERR_NOERROR
;
1993 static LRESULT
WINMM_Reset(HWAVE hwave
)
1995 WINMM_CBInfo cb_info
;
1996 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
2001 TRACE("(%p)\n", hwave
);
2003 if(!WINMM_ValidateAndLock(device
))
2004 return MMSYSERR_INVALHANDLE
;
2006 hr
= IAudioClient_Stop(device
->client
);
2008 LeaveCriticalSection(&device
->lock
);
2009 WARN("Stop failed: %08x\n", hr
);
2010 return MMSYSERR_ERROR
;
2012 device
->stopped
= TRUE
;
2014 first
= device
->first
;
2015 device
->first
= device
->last
= device
->playing
= NULL
;
2016 device
->ofs_bytes
= 0;
2017 device
->played_frames
= 0;
2018 device
->loop_counter
= 0;
2019 device
->last_clock_pos
= 0;
2020 IAudioClient_Reset(device
->client
);
2022 cb_info
= device
->cb_info
;
2023 is_out
= device
->render
!= NULL
;
2025 LeaveCriticalSection(&device
->lock
);
2028 WAVEHDR
*next
= first
->lpNext
;
2029 first
->dwFlags
&= ~WHDR_INQUEUE
;
2030 first
->dwFlags
|= WHDR_DONE
;
2032 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
2034 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
2038 return MMSYSERR_NOERROR
;
2041 static MMRESULT
WINMM_FramesToMMTime(MMTIME
*time
, UINT32 played_frames
,
2042 UINT32 sample_rate
, UINT32 bytes_per_sec
)
2044 switch(time
->wType
){
2046 time
->u
.sample
= played_frames
;
2047 return MMSYSERR_NOERROR
;
2049 time
->u
.ms
= (UINT64
)played_frames
* 1000 / sample_rate
;
2050 return MMSYSERR_NOERROR
;
2052 time
->u
.smpte
.fps
= 30;
2053 played_frames
+= sample_rate
/ time
->u
.smpte
.fps
- 1; /* round up */
2054 time
->u
.smpte
.frame
= (played_frames
% sample_rate
) * time
->u
.smpte
.fps
/ sample_rate
;
2055 played_frames
/= sample_rate
; /* yields seconds */
2056 time
->u
.smpte
.sec
= played_frames
% 60;
2057 played_frames
/= 60;
2058 time
->u
.smpte
.min
= played_frames
% 60;
2059 time
->u
.smpte
.hour
= played_frames
/ 60;
2060 return MMSYSERR_NOERROR
;
2062 time
->wType
= TIME_BYTES
;
2065 time
->u
.cb
= MulDiv(played_frames
, bytes_per_sec
, sample_rate
);
2066 return MMSYSERR_NOERROR
;
2070 static LRESULT
WINMM_GetPosition(HWAVE hwave
, MMTIME
*time
)
2072 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
2073 UINT32 played_frames
, sample_rate
, bytes_per_sec
;
2075 TRACE("(%p, %p)\n", hwave
, time
);
2077 if(!WINMM_ValidateAndLock(device
))
2078 return MMSYSERR_INVALHANDLE
;
2080 played_frames
= device
->played_frames
;
2081 sample_rate
= device
->orig_fmt
->nSamplesPerSec
;
2082 bytes_per_sec
= device
->orig_fmt
->nAvgBytesPerSec
;
2084 LeaveCriticalSection(&device
->lock
);
2086 return WINMM_FramesToMMTime(time
, played_frames
, sample_rate
, bytes_per_sec
);
2089 static WINMM_MMDevice
*WINMM_GetMixerMMDevice(HMIXEROBJ hmix
, DWORD flags
,
2092 UINT mmdev
, dev
, junk
, *out
;
2100 switch(flags
& 0xF0000000){
2101 case MIXER_OBJECTF_MIXER
: /* == 0 */
2102 *out
= HandleToULong(hmix
);
2103 if(*out
< g_outmmdevices_count
)
2104 return read_map(g_out_map
, *out
);
2105 if(*out
- g_outmmdevices_count
< g_inmmdevices_count
){
2106 *out
-= g_outmmdevices_count
;
2107 return read_map(g_in_map
, *out
);
2109 /* fall through -- if it's not a valid mixer device, then
2110 * it could be a valid mixer handle. windows seems to do
2112 case MIXER_OBJECTF_HMIXER
:
2113 case MIXER_OBJECTF_HWAVEOUT
:
2114 case MIXER_OBJECTF_HWAVEIN
:
2115 WINMM_DecomposeHWAVE((HWAVE
)hmix
, out
, &is_out
, &dev
, &junk
);
2116 if(junk
!= 0x1 || (is_out
&& *out
>= g_outmmdevices_count
) ||
2117 (!is_out
&& *out
>= g_inmmdevices_count
))
2120 return read_map(g_out_map
, *out
);
2121 return read_map(g_in_map
, *out
);
2122 case MIXER_OBJECTF_WAVEOUT
:
2123 *out
= HandleToULong(hmix
);
2124 if(*out
< g_outmmdevices_count
)
2125 return read_map(g_out_map
, *out
);
2127 case MIXER_OBJECTF_WAVEIN
:
2128 *out
= HandleToULong(hmix
);
2129 if(*out
< g_inmmdevices_count
)
2130 return read_map(g_in_map
, *out
);
2137 static MMRESULT
WINMM_SetupMMDeviceVolume(WINMM_MMDevice
*mmdevice
)
2139 IAudioSessionManager
*sesman
;
2143 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
, &device
);
2145 WARN("Device %s (%s) unavailable: %08x\n",
2146 wine_dbgstr_w(mmdevice
->dev_id
),
2147 wine_dbgstr_w(mmdevice
->out_caps
.szPname
), hr
);
2148 return MMSYSERR_ERROR
;
2151 hr
= IMMDevice_Activate(device
, &IID_IAudioSessionManager
,
2152 CLSCTX_INPROC_SERVER
, NULL
, (void**)&sesman
);
2154 WARN("Activate failed: %08x\n", hr
);
2155 IMMDevice_Release(device
);
2156 return MMSYSERR_ERROR
;
2159 IMMDevice_Release(device
);
2161 hr
= IAudioSessionManager_GetSimpleAudioVolume(sesman
, &mmdevice
->session
,
2162 FALSE
, &mmdevice
->volume
);
2163 IAudioSessionManager_Release(sesman
);
2165 WARN("GetSimpleAudioVolume failed: %08x\n", hr
);
2166 return MMSYSERR_ERROR
;
2169 return MMSYSERR_NOERROR
;
2172 static LRESULT
MXD_GetControlDetails(WINMM_ControlDetails
*details
)
2174 WINMM_MMDevice
*mmdevice
;
2175 MIXERCONTROLDETAILS
*control
= details
->details
;
2178 TRACE("(%p)\n", details
->hmix
);
2180 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
2182 return MMSYSERR_INVALHANDLE
;
2184 EnterCriticalSection(&mmdevice
->lock
);
2186 if(!mmdevice
->volume
){
2189 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
2190 if(mr
!= MMSYSERR_NOERROR
){
2191 LeaveCriticalSection(&mmdevice
->lock
);
2196 if(control
->dwControlID
== 0){
2198 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
2200 if(!control
->paDetails
||
2201 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
2202 LeaveCriticalSection(&mmdevice
->lock
);
2203 return MMSYSERR_INVALPARAM
;
2206 hr
= ISimpleAudioVolume_GetMasterVolume(mmdevice
->volume
, &vol
);
2208 WARN("GetMasterVolume failed: %08x\n", hr
);
2209 LeaveCriticalSection(&mmdevice
->lock
);
2210 return MMSYSERR_ERROR
;
2213 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
2214 udet
->dwValue
= vol
* ((unsigned int)0xFFFF);
2215 }else if(control
->dwControlID
== 1){
2217 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
2219 if(!control
->paDetails
||
2220 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
2221 LeaveCriticalSection(&mmdevice
->lock
);
2222 return MMSYSERR_INVALPARAM
;
2225 hr
= ISimpleAudioVolume_GetMute(mmdevice
->volume
, &mute
);
2227 WARN("GetMute failed: %08x\n", hr
);
2228 LeaveCriticalSection(&mmdevice
->lock
);
2229 return MMSYSERR_ERROR
;
2232 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
2233 bdet
->fValue
= mute
;
2234 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
2235 FIXME("What should the sw-side mixer controls map to?\n");
2237 LeaveCriticalSection(&mmdevice
->lock
);
2238 return MIXERR_INVALCONTROL
;
2241 LeaveCriticalSection(&mmdevice
->lock
);
2243 return MMSYSERR_NOERROR
;
2246 static LRESULT
MXD_SetControlDetails(WINMM_ControlDetails
*details
)
2248 WINMM_MMDevice
*mmdevice
;
2249 MIXERCONTROLDETAILS
*control
= details
->details
;
2252 TRACE("(%p)\n", details
->hmix
);
2254 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
2256 return MMSYSERR_INVALHANDLE
;
2258 EnterCriticalSection(&mmdevice
->lock
);
2260 if(!mmdevice
->volume
){
2263 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
2264 if(mr
!= MMSYSERR_NOERROR
){
2265 LeaveCriticalSection(&mmdevice
->lock
);
2270 if(control
->dwControlID
== 0){
2272 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
2274 if(!control
->paDetails
||
2275 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
2276 LeaveCriticalSection(&mmdevice
->lock
);
2277 return MMSYSERR_INVALPARAM
;
2280 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
2282 if(udet
->dwValue
> 65535){
2283 LeaveCriticalSection(&mmdevice
->lock
);
2284 return MMSYSERR_INVALPARAM
;
2287 vol
= udet
->dwValue
/ 65535.f
;
2289 hr
= ISimpleAudioVolume_SetMasterVolume(mmdevice
->volume
, vol
, NULL
);
2291 WARN("SetMasterVolume failed: %08x\n", hr
);
2292 LeaveCriticalSection(&mmdevice
->lock
);
2293 return MMSYSERR_ERROR
;
2295 }else if(control
->dwControlID
== 1){
2297 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
2299 if(!control
->paDetails
||
2300 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
2301 LeaveCriticalSection(&mmdevice
->lock
);
2302 return MMSYSERR_INVALPARAM
;
2305 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
2306 mute
= bdet
->fValue
;
2308 hr
= ISimpleAudioVolume_SetMute(mmdevice
->volume
, mute
, NULL
);
2310 WARN("SetMute failed: %08x\n", hr
);
2311 LeaveCriticalSection(&mmdevice
->lock
);
2312 return MMSYSERR_ERROR
;
2314 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
2315 FIXME("What should the sw-side mixer controls map to?\n");
2317 LeaveCriticalSection(&mmdevice
->lock
);
2318 return MIXERR_INVALCONTROL
;
2321 LeaveCriticalSection(&mmdevice
->lock
);
2323 return MMSYSERR_NOERROR
;
2326 static LRESULT
DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo
*info
)
2328 WINMM_MMDevice
*mmdevice
;
2335 static const PROPERTYKEY deviceinterface_key
= {
2336 {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
2339 if(WINMM_IsMapper(info
->index
)){
2341 if(*info
->len_bytes
< sizeof(WCHAR
))
2342 return MMSYSERR_INVALPARAM
;
2345 *info
->len_bytes
= sizeof(WCHAR
);
2346 return MMSYSERR_NOERROR
;
2350 if(info
->index
>= g_outmmdevices_count
)
2351 return MMSYSERR_INVALHANDLE
;
2353 mmdevice
= &g_out_mmdevices
[info
->index
];
2355 if(info
->index
>= g_inmmdevices_count
)
2356 return MMSYSERR_INVALHANDLE
;
2358 mmdevice
= &g_in_mmdevices
[info
->index
];
2361 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
,
2364 WARN("Device %s unavailable: %08x\n", wine_dbgstr_w(mmdevice
->dev_id
), hr
);
2365 return MMSYSERR_ERROR
;
2368 hr
= IMMDevice_OpenPropertyStore(device
, STGM_READ
, &ps
);
2370 WARN("OpenPropertyStore failed: %08x\n", hr
);
2371 IMMDevice_Release(device
);
2372 return MMSYSERR_ERROR
;
2375 PropVariantInit(&pv
);
2376 hr
= IPropertyStore_GetValue(ps
, &deviceinterface_key
, &pv
);
2378 WARN("GetValue failed: %08x\n", hr
);
2379 IPropertyStore_Release(ps
);
2380 IMMDevice_Release(device
);
2381 return MMSYSERR_ERROR
;
2383 if(pv
.vt
!= VT_LPWSTR
){
2384 WARN("Got unexpected property type: %u\n", pv
.vt
);
2385 PropVariantClear(&pv
);
2386 IPropertyStore_Release(ps
);
2387 IMMDevice_Release(device
);
2388 return MMSYSERR_ERROR
;
2391 len_bytes
= (lstrlenW(pv
.u
.pwszVal
) + 1) * sizeof(WCHAR
);
2394 if(len_bytes
> *info
->len_bytes
){
2395 PropVariantClear(&pv
);
2396 IPropertyStore_Release(ps
);
2397 IMMDevice_Release(device
);
2398 return MMSYSERR_INVALPARAM
;
2401 memcpy(info
->str
, pv
.u
.pwszVal
, len_bytes
);
2403 *info
->len_bytes
= len_bytes
;
2405 PropVariantClear(&pv
);
2406 IPropertyStore_Release(ps
);
2407 IMMDevice_Release(device
);
2409 return MMSYSERR_NOERROR
;
2412 static LRESULT CALLBACK
WINMM_DevicesMsgProc(HWND hwnd
, UINT msg
, WPARAM wparam
,
2417 return WOD_Open((WINMM_OpenInfo
*)wparam
);
2419 return WOD_Close((HWAVEOUT
)wparam
);
2421 return WID_Open((WINMM_OpenInfo
*)wparam
);
2423 return WID_Close((HWAVEIN
)wparam
);
2424 case MXDM_GETCONTROLDETAILS
:
2425 return MXD_GetControlDetails((WINMM_ControlDetails
*)wparam
);
2426 case MXDM_SETCONTROLDETAILS
:
2427 return MXD_SetControlDetails((WINMM_ControlDetails
*)wparam
);
2428 case DRV_QUERYDEVICEINTERFACESIZE
:
2429 case DRV_QUERYDEVICEINTERFACE
:
2430 return DRV_QueryDeviceInterface((WINMM_QueryInterfaceInfo
*)wparam
);
2432 return DefWindowProcW(hwnd
, msg
, wparam
, lparam
);
2435 static BOOL
WINMM_DevicesThreadDone(void)
2439 EnterCriticalSection(&g_devthread_lock
);
2441 if(g_devthread_token
> 0){
2442 LeaveCriticalSection(&g_devthread_lock
);
2446 for(i
= 0; i
< g_devhandle_count
; ++i
){
2447 if(g_handle_devices
[i
]->open
){
2448 LeaveCriticalSection(&g_devthread_lock
);
2453 DestroyWindow(g_devices_hwnd
);
2454 g_devices_hwnd
= NULL
;
2455 IMMDeviceEnumerator_Release(g_devenum
);
2459 LeaveCriticalSection(&g_devthread_lock
);
2464 static DWORD WINAPI
WINMM_DevicesThreadProc(void *arg
)
2468 static const WCHAR messageW
[] = {'M','e','s','s','a','g','e',0};
2470 hr
= CoInitializeEx(NULL
, COINIT_MULTITHREADED
);
2472 WARN("CoInitializeEx failed: %08x\n", hr
);
2473 FreeLibraryAndExitThread(g_devthread_module
, 1);
2476 hr
= WINMM_InitMMDevices();
2479 FreeLibraryAndExitThread(g_devthread_module
, 1);
2482 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
,
2483 CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&g_devenum
);
2485 WARN("CoCreateInstance failed: %08x\n", hr
);
2487 FreeLibraryAndExitThread(g_devthread_module
, 1);
2490 g_devices_hwnd
= CreateWindowW(messageW
, NULL
, 0, 0, 0, 0, 0,
2491 HWND_MESSAGE
, NULL
, NULL
, NULL
);
2492 if(!g_devices_hwnd
){
2493 WARN("CreateWindow failed: %d\n", GetLastError());
2495 FreeLibraryAndExitThread(g_devthread_module
, 1);
2498 SetWindowLongPtrW(g_devices_hwnd
, GWLP_WNDPROC
,
2499 (LONG_PTR
)WINMM_DevicesMsgProc
);
2501 /* inform caller that the thread is ready to process messages */
2503 evt
= NULL
; /* do not use after this point */
2507 wait
= MsgWaitForMultipleObjects(g_devhandle_count
, g_device_handles
,
2508 FALSE
, INFINITE
, QS_ALLINPUT
);
2509 if(wait
== g_devhandle_count
+ WAIT_OBJECT_0
){
2511 if(PeekMessageW(&msg
, g_devices_hwnd
, 0, 0, PM_REMOVE
))
2512 WARN("Unexpected message: 0x%x\n", msg
.message
);
2515 }else if(wait
< g_devhandle_count
+ WAIT_OBJECT_0
){
2516 WINMM_Device
*device
= g_handle_devices
[wait
- WAIT_OBJECT_0
];
2518 WOD_PushData(device
);
2520 WID_PullData(device
);
2522 WARN("Unexpected MsgWait result 0x%x, GLE: %d\n", wait
,
2524 if(WINMM_DevicesThreadDone()){
2525 TRACE("Quitting devices thread\n");
2526 FreeLibraryAndExitThread(g_devthread_module
, 0);
2530 FreeLibraryAndExitThread(g_devthread_module
, 0);
2533 /* on success, increments g_devthread_token to prevent
2534 * device thread shutdown. caller must decrement. */
2535 static BOOL
WINMM_StartDevicesThread(void)
2540 EnterCriticalSection(&g_devthread_lock
);
2543 wait
= WaitForSingleObject(g_devices_thread
, 0);
2544 if(wait
== WAIT_TIMEOUT
){
2545 /* thread still running */
2546 InterlockedIncrement(&g_devthread_token
);
2547 LeaveCriticalSection(&g_devthread_lock
);
2550 if(wait
!= WAIT_OBJECT_0
){
2552 LeaveCriticalSection(&g_devthread_lock
);
2555 TRACE("Devices thread left dangling message window?\n");
2556 g_devices_hwnd
= NULL
;
2557 CloseHandle(g_devices_thread
);
2558 g_devices_thread
= NULL
;
2559 }else if(g_devices_thread
){
2560 WaitForSingleObject(g_devices_thread
, INFINITE
);
2561 CloseHandle(g_devices_thread
);
2562 g_devices_thread
= NULL
;
2565 TRACE("Starting up devices thread\n");
2567 /* The devices thread holds a reference to the winmm module
2568 * to prevent it from unloading while it's running. */
2569 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
2570 (const WCHAR
*)WINMM_StartDevicesThread
, &g_devthread_module
);
2572 events
[0] = CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2574 g_devices_thread
= CreateThread(NULL
, 0, WINMM_DevicesThreadProc
,
2575 events
[0], 0, NULL
);
2576 if(!g_devices_thread
){
2577 LeaveCriticalSection(&g_devthread_lock
);
2578 CloseHandle(events
[0]);
2579 FreeLibrary(g_devthread_module
);
2583 events
[1] = g_devices_thread
;
2584 wait
= WaitForMultipleObjects(2, events
, FALSE
, INFINITE
);
2585 CloseHandle(events
[0]);
2586 if(wait
!= WAIT_OBJECT_0
){
2587 if(wait
== 1 + WAIT_OBJECT_0
){
2588 CloseHandle(g_devices_thread
);
2589 g_devices_thread
= NULL
;
2590 g_devices_hwnd
= NULL
;
2592 LeaveCriticalSection(&g_devthread_lock
);
2596 InterlockedIncrement(&g_devthread_token
);
2598 LeaveCriticalSection(&g_devthread_lock
);
2603 /**************************************************************************
2604 * waveOutGetNumDevs [WINMM.@]
2606 UINT WINAPI
waveOutGetNumDevs(void)
2608 HRESULT hr
= WINMM_InitMMDevices();
2612 TRACE("count: %u\n", g_outmmdevices_count
);
2614 return g_outmmdevices_count
;
2617 /**************************************************************************
2618 * waveOutGetDevCapsA [WINMM.@]
2620 UINT WINAPI
waveOutGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
2626 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2629 return MMSYSERR_INVALPARAM
;
2631 ret
= waveOutGetDevCapsW(uDeviceID
, &wocW
, sizeof(wocW
));
2633 if (ret
== MMSYSERR_NOERROR
) {
2635 wocA
.wMid
= wocW
.wMid
;
2636 wocA
.wPid
= wocW
.wPid
;
2637 wocA
.vDriverVersion
= wocW
.vDriverVersion
;
2638 WideCharToMultiByte( CP_ACP
, 0, wocW
.szPname
, -1, wocA
.szPname
,
2639 sizeof(wocA
.szPname
), NULL
, NULL
);
2640 wocA
.dwFormats
= wocW
.dwFormats
;
2641 wocA
.wChannels
= wocW
.wChannels
;
2642 wocA
.dwSupport
= wocW
.dwSupport
;
2643 wocA
.wReserved1
= wocW
.wReserved1
;
2644 memcpy(lpCaps
, &wocA
, min(uSize
, sizeof(wocA
)));
2649 /**************************************************************************
2650 * waveOutGetDevCapsW [WINMM.@]
2652 UINT WINAPI
waveOutGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
2655 WAVEOUTCAPSW mapper_caps
, *caps
;
2658 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2660 hr
= WINMM_InitMMDevices();
2662 return MMSYSERR_NODRIVER
;
2664 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2666 if(WINMM_IsMapper(uDeviceID
)){
2667 mapper_caps
.wMid
= 0xFF;
2668 mapper_caps
.wPid
= 0xFF;
2669 mapper_caps
.vDriverVersion
= 0x00010001;
2670 mapper_caps
.dwFormats
= 0xFFFFFFFF;
2671 mapper_caps
.wReserved1
= 0;
2672 mapper_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
2673 WAVECAPS_SAMPLEACCURATE
;
2674 mapper_caps
.wChannels
= 2;
2675 LoadStringW(hWinMM32Instance
, IDS_MAPPER_NAME
, mapper_caps
.szPname
, MAXPNAMELEN
);
2677 caps
= &mapper_caps
;
2679 if(uDeviceID
>= g_outmmdevices_count
)
2680 return MMSYSERR_BADDEVICEID
;
2682 caps
= &read_map(g_out_map
, uDeviceID
)->out_caps
;
2685 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
2687 return MMSYSERR_NOERROR
;
2690 /**************************************************************************
2691 * waveOutGetErrorTextA [WINMM.@]
2692 * waveInGetErrorTextA [WINMM.@]
2694 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2698 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2699 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2702 LPWSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
* sizeof(WCHAR
));
2703 if (!xstr
) ret
= MMSYSERR_NOMEM
;
2706 ret
= waveOutGetErrorTextW(uError
, xstr
, uSize
);
2707 if (ret
== MMSYSERR_NOERROR
)
2708 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
2709 HeapFree(GetProcessHeap(), 0, xstr
);
2715 /**************************************************************************
2716 * waveOutGetErrorTextW [WINMM.@]
2717 * waveInGetErrorTextW [WINMM.@]
2719 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2721 UINT ret
= MMSYSERR_BADERRNUM
;
2723 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2724 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2726 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2727 * a warning for the test was always true */
2728 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
2729 (uError
>= WAVERR_BASE
&& uError
<= WAVERR_LASTERROR
)) {
2730 if (LoadStringW(hWinMM32Instance
,
2731 uError
, lpText
, uSize
) > 0) {
2732 ret
= MMSYSERR_NOERROR
;
2738 /**************************************************************************
2739 * waveOutOpen [WINMM.@]
2740 * All the args/structs have the same layout as the win16 equivalents
2742 MMRESULT WINAPI
waveOutOpen(LPHWAVEOUT lphWaveOut
, UINT uDeviceID
,
2743 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2744 DWORD_PTR dwInstance
, DWORD dwFlags
)
2747 WINMM_OpenInfo info
;
2748 WINMM_CBInfo cb_info
;
2750 TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut
, uDeviceID
, lpFormat
,
2751 dwCallback
, dwInstance
, dwFlags
);
2753 if(!lphWaveOut
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
2754 return MMSYSERR_INVALPARAM
;
2756 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
2757 if(res
!= MMSYSERR_NOERROR
)
2760 if(!WINMM_StartDevicesThread())
2761 return MMSYSERR_NODRIVER
;
2764 info
.format
= (WAVEFORMATEX
*)lpFormat
;
2765 info
.callback
= dwCallback
;
2766 info
.cb_user
= dwInstance
;
2767 info
.req_device
= uDeviceID
;
2768 info
.flags
= dwFlags
;
2771 res
= SendMessageW(g_devices_hwnd
, WODM_OPEN
, (DWORD_PTR
)&info
, 0);
2772 InterlockedDecrement(&g_devthread_token
);
2773 if(res
!= MMSYSERR_NOERROR
|| (dwFlags
& WAVE_FORMAT_QUERY
))
2777 *lphWaveOut
= (HWAVEOUT
)info
.handle
;
2779 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2780 cb_info
.callback
= dwCallback
;
2781 cb_info
.user
= dwInstance
;
2782 cb_info
.hwave
= info
.handle
;
2784 WINMM_NotifyClient(&cb_info
, WOM_OPEN
, 0, 0);
2789 /**************************************************************************
2790 * waveOutClose [WINMM.@]
2792 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
2795 WINMM_Device
*device
;
2796 WINMM_CBInfo cb_info
;
2798 TRACE("(%p)\n", hWaveOut
);
2800 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2802 if(!WINMM_ValidateAndLock(device
))
2803 return MMSYSERR_INVALHANDLE
;
2805 cb_info
= device
->cb_info
;
2807 LeaveCriticalSection(&device
->lock
);
2809 res
= SendMessageW(g_devices_hwnd
, WODM_CLOSE
, (WPARAM
)hWaveOut
, 0);
2811 if(res
== MMSYSERR_NOERROR
)
2812 WINMM_NotifyClient(&cb_info
, WOM_CLOSE
, 0, 0);
2817 /**************************************************************************
2818 * waveOutPrepareHeader [WINMM.@]
2820 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
2821 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
2823 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2825 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2826 return MMSYSERR_INVALPARAM
;
2828 if(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
)
2829 return MMSYSERR_NOERROR
;
2831 return WINMM_PrepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2834 /**************************************************************************
2835 * waveOutUnprepareHeader [WINMM.@]
2837 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
2838 LPWAVEHDR lpWaveOutHdr
, UINT uSize
)
2840 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2842 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2843 return MMSYSERR_INVALPARAM
;
2845 if(lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2846 return WAVERR_STILLPLAYING
;
2848 if(!(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
))
2849 return MMSYSERR_NOERROR
;
2851 return WINMM_UnprepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2854 /**************************************************************************
2855 * waveOutWrite [WINMM.@]
2857 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, WAVEHDR
*header
, UINT uSize
)
2859 WINMM_Device
*device
;
2862 TRACE("(%p, %p, %u)\n", hWaveOut
, header
, uSize
);
2864 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2866 if(!WINMM_ValidateAndLock(device
))
2867 return MMSYSERR_INVALHANDLE
;
2869 if(!header
->lpData
|| !(header
->dwFlags
& WHDR_PREPARED
)){
2870 LeaveCriticalSection(&device
->lock
);
2871 return WAVERR_UNPREPARED
;
2874 if(header
->dwFlags
& WHDR_INQUEUE
){
2875 LeaveCriticalSection(&device
->lock
);
2876 return WAVERR_STILLPLAYING
;
2879 TRACE("dwBufferLength: %u\n", header
->dwBufferLength
);
2881 if(device
->acm_handle
){
2882 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
2884 ash
->cbSrcLength
= header
->dwBufferLength
;
2885 mr
= acmStreamConvert(device
->acm_handle
, ash
, 0);
2886 if(mr
!= MMSYSERR_NOERROR
){
2887 LeaveCriticalSection(&device
->lock
);
2893 device
->last
->lpNext
= header
;
2894 device
->last
= header
;
2895 if(!device
->playing
)
2896 device
->playing
= header
;
2898 device
->playing
= device
->first
= device
->last
= header
;
2899 if(header
->dwFlags
& WHDR_BEGINLOOP
){
2900 device
->loop_counter
= header
->dwLoops
;
2901 device
->loop_start
= header
;
2905 header
->lpNext
= NULL
;
2906 header
->dwFlags
&= ~WHDR_DONE
;
2907 header
->dwFlags
|= WHDR_INQUEUE
;
2909 mr
= WINMM_BeginPlaying(device
);
2911 LeaveCriticalSection(&device
->lock
);
2916 /**************************************************************************
2917 * waveOutBreakLoop [WINMM.@]
2919 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
2921 WINMM_Device
*device
;
2923 TRACE("(%p)\n", hWaveOut
);
2925 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2927 if(!WINMM_ValidateAndLock(device
))
2928 return MMSYSERR_INVALHANDLE
;
2930 device
->loop_counter
= 0;
2932 LeaveCriticalSection(&device
->lock
);
2934 return MMSYSERR_NOERROR
;
2937 /**************************************************************************
2938 * waveOutPause [WINMM.@]
2940 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
2942 TRACE("(%p)\n", hWaveOut
);
2944 return WINMM_Pause((HWAVE
)hWaveOut
);
2947 /**************************************************************************
2948 * waveOutReset [WINMM.@]
2950 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
2952 TRACE("(%p)\n", hWaveOut
);
2954 return WINMM_Reset((HWAVE
)hWaveOut
);
2957 /**************************************************************************
2958 * waveOutRestart [WINMM.@]
2960 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
2962 WINMM_Device
*device
;
2965 TRACE("(%p)\n", hWaveOut
);
2967 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2969 if(!WINMM_ValidateAndLock(device
))
2970 return MMSYSERR_INVALHANDLE
;
2972 device
->stopped
= TRUE
;
2974 mr
= WINMM_BeginPlaying(device
);
2976 LeaveCriticalSection(&device
->lock
);
2981 /**************************************************************************
2982 * waveOutGetPosition [WINMM.@]
2984 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
2987 TRACE("(%p, %p, %u)\n", hWaveOut
, lpTime
, uSize
);
2989 if(!uSize
|| !lpTime
)
2990 return MMSYSERR_INVALPARAM
;
2992 if(uSize
< sizeof(MMTIME
))
2993 return MMSYSERR_ERROR
;
2995 return WINMM_GetPosition((HWAVE
)hWaveOut
, lpTime
);
2998 /**************************************************************************
2999 * waveOutGetPitch [WINMM.@]
3001 UINT WINAPI
waveOutGetPitch(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
3003 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
3004 return MMSYSERR_NOTSUPPORTED
;
3007 /**************************************************************************
3008 * waveOutSetPitch [WINMM.@]
3010 UINT WINAPI
waveOutSetPitch(HWAVEOUT hWaveOut
, DWORD dw
)
3012 TRACE("(%p, %08x)\n", hWaveOut
, dw
);
3014 return MMSYSERR_NOTSUPPORTED
;
3017 /**************************************************************************
3018 * waveOutGetPlaybackRate [WINMM.@]
3020 UINT WINAPI
waveOutGetPlaybackRate(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
3022 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
3024 return MMSYSERR_NOTSUPPORTED
;
3027 /**************************************************************************
3028 * waveOutSetPlaybackRate [WINMM.@]
3030 UINT WINAPI
waveOutSetPlaybackRate(HWAVEOUT hWaveOut
, DWORD dw
)
3032 TRACE("(%p, %08x)\n", hWaveOut
, dw
);
3034 return MMSYSERR_NOTSUPPORTED
;
3037 /**************************************************************************
3038 * waveOutGetVolume [WINMM.@]
3040 UINT WINAPI
waveOutGetVolume(HWAVEOUT hWaveOut
, DWORD
*out
)
3042 WINMM_Device
*device
;
3047 TRACE("(%p, %p)\n", hWaveOut
, out
);
3050 return MMSYSERR_INVALPARAM
;
3052 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3054 if(!WINMM_ValidateAndLock(device
))
3055 return MMSYSERR_INVALHANDLE
;
3057 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
3059 LeaveCriticalSection(&device
->lock
);
3060 WARN("GetChannelCount failed: %08x\n", hr
);
3061 return MMSYSERR_ERROR
;
3064 vols
= HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels
);
3066 LeaveCriticalSection(&device
->lock
);
3067 return MMSYSERR_NOMEM
;
3070 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
3072 LeaveCriticalSection(&device
->lock
);
3073 HeapFree(GetProcessHeap(), 0, vols
);
3074 WARN("GetAllVolumes failed: %08x\n", hr
);
3075 return MMSYSERR_ERROR
;
3078 LeaveCriticalSection(&device
->lock
);
3080 *out
= ((UINT16
)(vols
[0] * (DWORD
)0xFFFF));
3082 *out
|= ((UINT16
)(vols
[1] * (DWORD
)0xFFFF)) << 16;
3084 HeapFree(GetProcessHeap(), 0, vols
);
3086 return MMSYSERR_NOERROR
;
3089 /**************************************************************************
3090 * waveOutSetVolume [WINMM.@]
3092 UINT WINAPI
waveOutSetVolume(HWAVEOUT hWaveOut
, DWORD in
)
3094 WINMM_Device
*device
;
3099 TRACE("(%p, %08x)\n", hWaveOut
, in
);
3101 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3103 if(!WINMM_ValidateAndLock(device
))
3104 return MMSYSERR_INVALHANDLE
;
3106 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
3108 LeaveCriticalSection(&device
->lock
);
3109 WARN("GetChannelCount failed: %08x\n", hr
);
3110 return MMSYSERR_ERROR
;
3113 vols
= HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels
);
3115 LeaveCriticalSection(&device
->lock
);
3116 return MMSYSERR_NOMEM
;
3119 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
3121 LeaveCriticalSection(&device
->lock
);
3122 HeapFree(GetProcessHeap(), 0, vols
);
3123 WARN("GetAllVolumes failed: %08x\n", hr
);
3124 return MMSYSERR_ERROR
;
3127 vols
[0] = (float)((DWORD
)(in
& 0xFFFF) / (float)0xFFFF);
3129 vols
[1] = (float)((DWORD
)(in
>> 16) / (float)0xFFFF);
3131 hr
= IAudioStreamVolume_SetAllVolumes(device
->volume
, channels
, vols
);
3133 LeaveCriticalSection(&device
->lock
);
3134 HeapFree(GetProcessHeap(), 0, vols
);
3135 WARN("SetAllVolumes failed: %08x\n", hr
);
3136 return MMSYSERR_ERROR
;
3139 LeaveCriticalSection(&device
->lock
);
3141 HeapFree(GetProcessHeap(), 0, vols
);
3143 return MMSYSERR_NOERROR
;
3146 /**************************************************************************
3147 * waveOutGetID [WINMM.@]
3149 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
3151 WINMM_Device
*device
;
3155 TRACE("(%p, %p)\n", hWaveOut
, lpuDeviceID
);
3158 return MMSYSERR_INVALPARAM
;
3160 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3161 if(!WINMM_ValidateAndLock(device
))
3162 return MMSYSERR_INVALHANDLE
;
3164 LeaveCriticalSection(&device
->lock
);
3166 WINMM_DecomposeHWAVE((HWAVE
)hWaveOut
, lpuDeviceID
, &is_out
, &dev
, &junk
);
3168 return MMSYSERR_NOERROR
;
3171 static UINT
WINMM_QueryInstanceIDSize(UINT device
, DWORD_PTR
*len
, BOOL is_out
)
3174 WINMM_MMDevice
**devices
;
3176 TRACE("(%u, %p, %d)\n", device
, len
, is_out
);
3179 count
= g_outmmdevices_count
;
3180 devices
= g_out_map
;
3182 count
= g_inmmdevices_count
;
3187 return MMSYSERR_INVALHANDLE
;
3189 EnterCriticalSection(&g_devthread_lock
);
3190 *len
= (lstrlenW(devices
[device
]->dev_id
) + 1) * sizeof(WCHAR
);
3191 LeaveCriticalSection(&g_devthread_lock
);
3193 return MMSYSERR_NOERROR
;
3196 static UINT
WINMM_QueryInstanceID(UINT device
, WCHAR
*str
, DWORD_PTR len
,
3200 WINMM_MMDevice
**devices
;
3202 TRACE("(%u, %p, %d)\n", device
, str
, is_out
);
3205 count
= g_outmmdevices_count
;
3206 devices
= g_out_map
;
3208 count
= g_inmmdevices_count
;
3213 return MMSYSERR_INVALHANDLE
;
3215 EnterCriticalSection(&g_devthread_lock
);
3216 id_len
= (lstrlenW(devices
[device
]->dev_id
) + 1) * sizeof(WCHAR
);
3218 LeaveCriticalSection(&g_devthread_lock
);
3219 return MMSYSERR_ERROR
;
3222 memcpy(str
, devices
[device
]->dev_id
, id_len
);
3223 LeaveCriticalSection(&g_devthread_lock
);
3225 return MMSYSERR_NOERROR
;
3228 static UINT
get_device_interface(UINT msg
, BOOL is_out
, UINT index
, WCHAR
*out
, ULONG
*out_len
)
3230 WINMM_QueryInterfaceInfo info
;
3233 if(!WINMM_StartDevicesThread())
3234 return MMSYSERR_NODRIVER
;
3236 info
.is_out
= is_out
;
3239 info
.len_bytes
= out_len
;
3241 ret
= SendMessageW(g_devices_hwnd
, msg
, (DWORD_PTR
)&info
, 0);
3242 InterlockedDecrement(&g_devthread_token
);
3246 /**************************************************************************
3247 * waveOutMessage [WINMM.@]
3249 UINT WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
3250 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3252 TRACE("(%p, %u, %lx, %lx)\n", hWaveOut
, uMessage
, dwParam1
, dwParam2
);
3255 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
3256 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut
),
3257 (DWORD_PTR
*)dwParam1
, TRUE
);
3258 case DRV_QUERYFUNCTIONINSTANCEID
:
3259 return WINMM_QueryInstanceID(HandleToULong(hWaveOut
), (WCHAR
*)dwParam1
, dwParam2
, TRUE
);
3260 case DRV_QUERYDEVICEINTERFACESIZE
:
3261 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE
, TRUE
, HandleToULong(hWaveOut
),
3262 NULL
, (ULONG
*)dwParam1
);
3263 case DRV_QUERYDEVICEINTERFACE
:
3265 ULONG size
= dwParam2
;
3266 return get_device_interface(DRV_QUERYDEVICEINTERFACE
, TRUE
, HandleToULong(hWaveOut
),
3267 (WCHAR
*)dwParam1
, &size
);
3269 case DRV_QUERYMAPPABLE
:
3270 return MMSYSERR_NOERROR
;
3271 case DRVM_MAPPER_PREFERRED_GET
:
3272 if(!dwParam1
|| !dwParam2
)
3273 return MMSYSERR_INVALPARAM
;
3275 if(g_outmmdevices_count
> 0)
3276 /* Device 0 is always the default device */
3277 *(DWORD
*)dwParam1
= 0;
3279 *(DWORD
*)dwParam1
= -1;
3282 *(DWORD
*)dwParam2
= 0;
3284 return MMSYSERR_NOERROR
;
3287 TRACE("Message not supported: %u\n", uMessage
);
3289 return MMSYSERR_NOTSUPPORTED
;
3292 /**************************************************************************
3293 * waveInGetNumDevs [WINMM.@]
3295 UINT WINAPI
waveInGetNumDevs(void)
3297 HRESULT hr
= WINMM_InitMMDevices();
3301 TRACE("count: %u\n", g_inmmdevices_count
);
3303 return g_inmmdevices_count
;
3306 /**************************************************************************
3307 * waveInGetDevCapsW [WINMM.@]
3309 UINT WINAPI
waveInGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
3311 WAVEINCAPSW mapper_caps
, *caps
;
3314 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3316 hr
= WINMM_InitMMDevices();
3318 return MMSYSERR_NODRIVER
;
3321 return MMSYSERR_INVALPARAM
;
3323 if(WINMM_IsMapper(uDeviceID
)){
3324 mapper_caps
.wMid
= 0xFF;
3325 mapper_caps
.wPid
= 0xFF;
3326 mapper_caps
.vDriverVersion
= 0x00010001;
3327 mapper_caps
.dwFormats
= 0xFFFFFFFF;
3328 mapper_caps
.wReserved1
= 0;
3329 mapper_caps
.wChannels
= 2;
3330 LoadStringW(hWinMM32Instance
, IDS_MAPPER_NAME
, mapper_caps
.szPname
, MAXPNAMELEN
);
3332 caps
= &mapper_caps
;
3334 if(uDeviceID
>= g_inmmdevices_count
)
3335 return MMSYSERR_BADDEVICEID
;
3337 caps
= &read_map(g_in_map
, uDeviceID
)->in_caps
;
3340 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
3342 return MMSYSERR_NOERROR
;
3345 /**************************************************************************
3346 * waveInGetDevCapsA [WINMM.@]
3348 UINT WINAPI
waveInGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
3353 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3356 return MMSYSERR_INVALPARAM
;
3358 ret
= waveInGetDevCapsW(uDeviceID
, &wicW
, sizeof(wicW
));
3360 if (ret
== MMSYSERR_NOERROR
) {
3362 wicA
.wMid
= wicW
.wMid
;
3363 wicA
.wPid
= wicW
.wPid
;
3364 wicA
.vDriverVersion
= wicW
.vDriverVersion
;
3365 WideCharToMultiByte( CP_ACP
, 0, wicW
.szPname
, -1, wicA
.szPname
,
3366 sizeof(wicA
.szPname
), NULL
, NULL
);
3367 wicA
.dwFormats
= wicW
.dwFormats
;
3368 wicA
.wChannels
= wicW
.wChannels
;
3369 wicA
.wReserved1
= wicW
.wReserved1
;
3370 memcpy(lpCaps
, &wicA
, min(uSize
, sizeof(wicA
)));
3375 /**************************************************************************
3376 * waveInOpen [WINMM.@]
3378 MMRESULT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
3379 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
3380 DWORD_PTR dwInstance
, DWORD dwFlags
)
3383 WINMM_OpenInfo info
;
3384 WINMM_CBInfo cb_info
;
3386 TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn
, uDeviceID
, lpFormat
,
3387 dwCallback
, dwInstance
, dwFlags
);
3389 if(!lphWaveIn
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
3390 return MMSYSERR_INVALPARAM
;
3392 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
3393 if(res
!= MMSYSERR_NOERROR
)
3396 if(!WINMM_StartDevicesThread())
3397 return MMSYSERR_NODRIVER
;
3400 info
.format
= (WAVEFORMATEX
*)lpFormat
;
3401 info
.callback
= dwCallback
;
3402 info
.cb_user
= dwInstance
;
3403 info
.req_device
= uDeviceID
;
3404 info
.flags
= dwFlags
;
3407 res
= SendMessageW(g_devices_hwnd
, WIDM_OPEN
, (DWORD_PTR
)&info
, 0);
3408 InterlockedDecrement(&g_devthread_token
);
3409 if(res
!= MMSYSERR_NOERROR
|| (dwFlags
& WAVE_FORMAT_QUERY
))
3413 *lphWaveIn
= (HWAVEIN
)info
.handle
;
3415 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
3416 cb_info
.callback
= dwCallback
;
3417 cb_info
.user
= dwInstance
;
3418 cb_info
.hwave
= info
.handle
;
3420 WINMM_NotifyClient(&cb_info
, WIM_OPEN
, 0, 0);
3425 /**************************************************************************
3426 * waveInClose [WINMM.@]
3428 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
3430 WINMM_Device
*device
;
3431 WINMM_CBInfo cb_info
;
3434 TRACE("(%p)\n", hWaveIn
);
3436 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3438 if(!WINMM_ValidateAndLock(device
))
3439 return MMSYSERR_INVALHANDLE
;
3441 cb_info
= device
->cb_info
;
3443 LeaveCriticalSection(&device
->lock
);
3445 res
= SendMessageW(g_devices_hwnd
, WIDM_CLOSE
, (WPARAM
)hWaveIn
, 0);
3447 if(res
== MMSYSERR_NOERROR
)
3448 WINMM_NotifyClient(&cb_info
, WIM_CLOSE
, 0, 0);
3453 /**************************************************************************
3454 * waveInPrepareHeader [WINMM.@]
3456 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3459 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3461 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3462 return MMSYSERR_INVALPARAM
;
3464 if(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
)
3465 return MMSYSERR_NOERROR
;
3467 return WINMM_PrepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3470 /**************************************************************************
3471 * waveInUnprepareHeader [WINMM.@]
3473 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3476 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3478 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3479 return MMSYSERR_INVALPARAM
;
3481 if(lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
3482 return WAVERR_STILLPLAYING
;
3484 if(!(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
))
3485 return MMSYSERR_NOERROR
;
3487 return WINMM_UnprepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3490 /**************************************************************************
3491 * waveInAddBuffer [WINMM.@]
3493 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
, WAVEHDR
*header
, UINT uSize
)
3495 WINMM_Device
*device
;
3497 TRACE("(%p, %p, %u)\n", hWaveIn
, header
, uSize
);
3499 if(!header
|| uSize
< sizeof(WAVEHDR
))
3500 return MMSYSERR_INVALPARAM
;
3502 if(!(header
->dwFlags
& WHDR_PREPARED
))
3503 return WAVERR_UNPREPARED
;
3505 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3507 if(!WINMM_ValidateAndLock(device
))
3508 return MMSYSERR_INVALHANDLE
;
3511 device
->first
= device
->last
= header
;
3513 device
->last
->lpNext
= header
;
3514 device
->last
= header
;
3517 header
->dwBytesRecorded
= 0;
3518 header
->lpNext
= NULL
;
3519 header
->dwFlags
&= ~WHDR_DONE
;
3520 header
->dwFlags
|= WHDR_INQUEUE
;
3522 LeaveCriticalSection(&device
->lock
);
3524 return MMSYSERR_NOERROR
;
3527 /**************************************************************************
3528 * waveInReset [WINMM.@]
3530 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
3532 TRACE("(%p)\n", hWaveIn
);
3534 return WINMM_Reset((HWAVE
)hWaveIn
);
3537 /**************************************************************************
3538 * waveInStart [WINMM.@]
3540 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
3542 WINMM_Device
*device
;
3545 TRACE("(%p)\n", hWaveIn
);
3547 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3549 if(!WINMM_ValidateAndLock(device
))
3550 return MMSYSERR_INVALHANDLE
;
3552 mr
= WINMM_BeginPlaying(device
);
3554 LeaveCriticalSection(&device
->lock
);
3559 /**************************************************************************
3560 * waveInStop [WINMM.@]
3562 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
3564 WINMM_CBInfo cb_info
;
3565 WINMM_Device
*device
;
3569 TRACE("(%p)\n", hWaveIn
);
3571 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3573 if(!WINMM_ValidateAndLock(device
))
3574 return MMSYSERR_INVALHANDLE
;
3576 hr
= WINMM_Pause((HWAVE
)hWaveIn
);
3578 LeaveCriticalSection(&device
->lock
);
3579 return MMSYSERR_ERROR
;
3581 device
->stopped
= TRUE
;
3583 buf
= device
->first
;
3584 if(buf
&& buf
->dwBytesRecorded
> 0){
3585 device
->first
= buf
->lpNext
;
3589 cb_info
= device
->cb_info
;
3591 LeaveCriticalSection(&device
->lock
);
3594 buf
->dwFlags
&= ~WHDR_INQUEUE
;
3595 buf
->dwFlags
|= WHDR_DONE
;
3596 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)buf
, 0);
3599 return MMSYSERR_NOERROR
;
3602 /**************************************************************************
3603 * waveInGetPosition [WINMM.@]
3605 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
3608 TRACE("(%p, %p, %u)\n", hWaveIn
, lpTime
, uSize
);
3610 if(!uSize
|| !lpTime
)
3611 return MMSYSERR_INVALPARAM
;
3613 if(uSize
< sizeof(MMTIME
))
3614 return MMSYSERR_ERROR
;
3616 return WINMM_GetPosition((HWAVE
)hWaveIn
, lpTime
);
3619 /**************************************************************************
3620 * waveInGetID [WINMM.@]
3622 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
3626 WINMM_Device
*device
;
3628 TRACE("(%p, %p)\n", hWaveIn
, lpuDeviceID
);
3631 return MMSYSERR_INVALPARAM
;
3633 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3634 if(!WINMM_ValidateAndLock(device
))
3635 return MMSYSERR_INVALHANDLE
;
3637 LeaveCriticalSection(&device
->lock
);
3639 WINMM_DecomposeHWAVE((HWAVE
)hWaveIn
, lpuDeviceID
, &is_out
, &dev
, &junk
);
3641 return MMSYSERR_NOERROR
;
3644 /**************************************************************************
3645 * waveInMessage [WINMM.@]
3647 UINT WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
3648 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3650 TRACE("(%p, %u, %ld, %ld)\n", hWaveIn
, uMessage
, dwParam1
, dwParam2
);
3653 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
3654 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn
),
3655 (DWORD_PTR
*)dwParam1
, FALSE
);
3656 case DRV_QUERYFUNCTIONINSTANCEID
:
3657 return WINMM_QueryInstanceID(HandleToULong(hWaveIn
), (WCHAR
*)dwParam1
, dwParam2
, FALSE
);
3658 case DRV_QUERYDEVICEINTERFACESIZE
:
3659 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE
, FALSE
, HandleToULong(hWaveIn
),
3660 NULL
, (ULONG
*)dwParam1
);
3661 case DRV_QUERYDEVICEINTERFACE
:
3663 ULONG size
= dwParam2
;
3664 return get_device_interface(DRV_QUERYDEVICEINTERFACE
, FALSE
, HandleToULong(hWaveIn
),
3665 (WCHAR
*)dwParam1
, &size
);
3667 case DRV_QUERYMAPPABLE
:
3668 return MMSYSERR_NOERROR
;
3669 case DRVM_MAPPER_PREFERRED_GET
:
3670 if(!dwParam1
|| !dwParam2
)
3671 return MMSYSERR_INVALPARAM
;
3673 if(g_inmmdevices_count
> 0)
3674 /* Device 0 is always the default device */
3675 *(DWORD
*)dwParam1
= 0;
3677 *(DWORD
*)dwParam1
= -1;
3680 *(DWORD
*)dwParam2
= 0;
3682 return MMSYSERR_NOERROR
;
3685 TRACE("Message not supported: %u\n", uMessage
);
3687 return MMSYSERR_NOTSUPPORTED
;
3690 UINT WINAPI
mixerGetNumDevs(void)
3696 hr
= WINMM_InitMMDevices();
3700 return g_outmmdevices_count
+ g_inmmdevices_count
;
3703 /**************************************************************************
3704 * mixerGetDevCapsA [WINMM.@]
3706 UINT WINAPI
mixerGetDevCapsA(UINT_PTR uDeviceID
, LPMIXERCAPSA lpCaps
, UINT uSize
)
3711 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3714 return MMSYSERR_INVALPARAM
;
3716 ret
= mixerGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
3718 if (ret
== MMSYSERR_NOERROR
) {
3720 micA
.wMid
= micW
.wMid
;
3721 micA
.wPid
= micW
.wPid
;
3722 micA
.vDriverVersion
= micW
.vDriverVersion
;
3723 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
3724 sizeof(micA
.szPname
), NULL
, NULL
);
3725 micA
.fdwSupport
= micW
.fdwSupport
;
3726 micA
.cDestinations
= micW
.cDestinations
;
3727 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
3732 /**************************************************************************
3733 * mixerGetDevCapsW [WINMM.@]
3735 UINT WINAPI
mixerGetDevCapsW(UINT_PTR uDeviceID
, LPMIXERCAPSW lpCaps
, UINT uSize
)
3737 WINMM_MMDevice
*mmdevice
;
3741 TRACE("(%lu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3743 hr
= WINMM_InitMMDevices();
3745 return MMSYSERR_NODRIVER
;
3748 return MMSYSERR_INVALPARAM
;
3751 return MMSYSERR_NOERROR
;
3753 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3754 mmdevice
= WINMM_GetMixerMMDevice((HMIXEROBJ
)uDeviceID
,
3755 MIXER_OBJECTF_MIXER
, NULL
);
3756 else if(uDeviceID
< g_outmmdevices_count
)
3757 mmdevice
= read_map(g_out_map
, uDeviceID
);
3759 mmdevice
= read_map(g_in_map
, uDeviceID
- g_outmmdevices_count
);
3762 return MMSYSERR_BADDEVICEID
;
3764 if(mmdevice
->dataflow
== eRender
)
3765 memcpy(caps
.szPname
, mmdevice
->out_caps
.szPname
, sizeof(caps
.szPname
));
3767 memcpy(caps
.szPname
, mmdevice
->in_caps
.szPname
, sizeof(caps
.szPname
));
3771 caps
.vDriverVersion
= 0x00010001;
3772 caps
.fdwSupport
= 0;
3773 caps
.cDestinations
= 1;
3775 memcpy(lpCaps
, &caps
, uSize
);
3777 return MMSYSERR_NOERROR
;
3780 /**************************************************************************
3781 * mixerOpen [WINMM.@]
3783 UINT WINAPI
mixerOpen(LPHMIXER lphMix
, UINT uDeviceID
, DWORD_PTR dwCallback
,
3784 DWORD_PTR dwInstance
, DWORD fdwOpen
)
3786 WINMM_MMDevice
*mmdevice
;
3790 TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix
, uDeviceID
, dwCallback
,
3791 dwInstance
, fdwOpen
);
3793 hr
= WINMM_InitMMDevices();
3795 return MMSYSERR_NODRIVER
;
3798 return MMSYSERR_INVALPARAM
;
3800 mr
= WINMM_CheckCallback(dwCallback
, fdwOpen
, TRUE
);
3801 if(mr
!= MMSYSERR_NOERROR
)
3804 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3805 return MMSYSERR_BADDEVICEID
;
3807 if(uDeviceID
< g_outmmdevices_count
){
3808 mmdevice
= read_map(g_out_map
, uDeviceID
);
3809 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
, TRUE
,
3810 mmdevice
->mixer_count
);
3812 mmdevice
= read_map(g_in_map
, uDeviceID
- g_outmmdevices_count
);
3813 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
- g_outmmdevices_count
,
3814 FALSE
, mmdevice
->mixer_count
);
3817 ++mmdevice
->mixer_count
;
3819 return MMSYSERR_NOERROR
;
3822 /**************************************************************************
3823 * mixerClose [WINMM.@]
3825 UINT WINAPI
mixerClose(HMIXER hMix
)
3827 TRACE("(%p)\n", hMix
);
3829 return MMSYSERR_NOERROR
;
3832 /**************************************************************************
3833 * mixerGetID [WINMM.@]
3835 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
3837 WINMM_MMDevice
*mmdevice
;
3840 TRACE("(%p, %p, %x)\n", hmix
, lpid
, fdwID
);
3842 hr
= WINMM_InitMMDevices();
3844 return MMSYSERR_NODRIVER
;
3847 return MMSYSERR_INVALPARAM
;
3849 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwID
, lpid
);
3851 return MMSYSERR_INVALHANDLE
;
3853 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3854 *lpid
+= g_outmmdevices_count
;
3856 return MMSYSERR_NOERROR
;
3859 /**************************************************************************
3860 * mixerGetControlDetailsW [WINMM.@]
3862 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdW
,
3865 WINMM_ControlDetails details
;
3867 TRACE("(%p, %p, %x)\n", hmix
, lpmcdW
, fdwDetails
);
3869 if(!WINMM_StartDevicesThread())
3870 return MMSYSERR_NODRIVER
;
3872 if(!lpmcdW
|| !lpmcdW
->paDetails
)
3873 return MMSYSERR_INVALPARAM
;
3875 TRACE("dwControlID: %u\n", lpmcdW
->dwControlID
);
3877 details
.hmix
= hmix
;
3878 details
.details
= lpmcdW
;
3879 details
.flags
= fdwDetails
;
3881 return SendMessageW(g_devices_hwnd
, MXDM_GETCONTROLDETAILS
,
3882 (DWORD_PTR
)&details
, 0);
3885 /**************************************************************************
3886 * mixerGetControlDetailsA [WINMM.@]
3888 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
,
3891 UINT ret
= MMSYSERR_NOTSUPPORTED
;
3893 TRACE("(%p, %p, %08x)\n", hmix
, lpmcdA
, fdwDetails
);
3895 if (lpmcdA
== NULL
|| lpmcdA
->cbStruct
!= sizeof(*lpmcdA
))
3896 return MMSYSERR_INVALPARAM
;
3898 switch (fdwDetails
& MIXER_GETCONTROLDETAILSF_QUERYMASK
) {
3899 case MIXER_GETCONTROLDETAILSF_VALUE
:
3900 /* can safely use A structure as it is, no string inside */
3901 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3903 case MIXER_GETCONTROLDETAILSF_LISTTEXT
:
3905 MIXERCONTROLDETAILS_LISTTEXTA
*pDetailsA
= lpmcdA
->paDetails
;
3906 MIXERCONTROLDETAILS_LISTTEXTW
*pDetailsW
;
3907 int size
= max(1, lpmcdA
->cChannels
) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3910 if (lpmcdA
->u
.cMultipleItems
!= 0) {
3911 size
*= lpmcdA
->u
.cMultipleItems
;
3913 pDetailsW
= HeapAlloc(GetProcessHeap(), 0, size
);
3914 lpmcdA
->paDetails
= pDetailsW
;
3915 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3916 /* set up lpmcd->paDetails */
3917 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3918 /* copy from lpmcd->paDetails back to paDetailsW; */
3919 if (ret
== MMSYSERR_NOERROR
) {
3920 for (i
= 0; i
< lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
; i
++) {
3921 pDetailsA
->dwParam1
= pDetailsW
->dwParam1
;
3922 pDetailsA
->dwParam2
= pDetailsW
->dwParam2
;
3923 WideCharToMultiByte( CP_ACP
, 0, pDetailsW
->szName
, -1,
3925 sizeof(pDetailsA
->szName
), NULL
, NULL
);
3929 pDetailsA
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
3930 pDetailsW
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
3932 HeapFree(GetProcessHeap(), 0, pDetailsW
);
3933 lpmcdA
->paDetails
= pDetailsA
;
3934 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTA
);
3938 WARN("Unsupported fdwDetails=0x%08x\n", fdwDetails
);
3944 /**************************************************************************
3945 * mixerGetLineControlsA [WINMM.@]
3947 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
, LPMIXERLINECONTROLSA lpmlcA
,
3950 MIXERLINECONTROLSW mlcW
;
3954 TRACE("(%p, %p, %x)\n", hmix
, lpmlcA
, fdwControls
);
3956 if (lpmlcA
== NULL
|| lpmlcA
->cbStruct
!= sizeof(*lpmlcA
) ||
3957 lpmlcA
->cbmxctrl
!= sizeof(MIXERCONTROLA
))
3958 return MMSYSERR_INVALPARAM
;
3960 mlcW
.cbStruct
= sizeof(mlcW
);
3961 mlcW
.dwLineID
= lpmlcA
->dwLineID
;
3962 mlcW
.u
.dwControlID
= lpmlcA
->u
.dwControlID
;
3963 mlcW
.u
.dwControlType
= lpmlcA
->u
.dwControlType
;
3965 /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3966 the control count is assumed to be 1 - This is relied upon by a game,
3967 "Dynomite Deluze" */
3968 if (MIXER_GETLINECONTROLSF_ONEBYTYPE
== (fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
)) {
3971 mlcW
.cControls
= lpmlcA
->cControls
;
3973 mlcW
.cbmxctrl
= sizeof(MIXERCONTROLW
);
3974 mlcW
.pamxctrl
= HeapAlloc(GetProcessHeap(), 0,
3975 mlcW
.cControls
* mlcW
.cbmxctrl
);
3977 ret
= mixerGetLineControlsW(hmix
, &mlcW
, fdwControls
);
3979 if (ret
== MMSYSERR_NOERROR
) {
3980 lpmlcA
->dwLineID
= mlcW
.dwLineID
;
3981 lpmlcA
->u
.dwControlID
= mlcW
.u
.dwControlID
;
3982 lpmlcA
->u
.dwControlType
= mlcW
.u
.dwControlType
;
3984 for (i
= 0; i
< mlcW
.cControls
; i
++) {
3985 lpmlcA
->pamxctrl
[i
].cbStruct
= sizeof(MIXERCONTROLA
);
3986 lpmlcA
->pamxctrl
[i
].dwControlID
= mlcW
.pamxctrl
[i
].dwControlID
;
3987 lpmlcA
->pamxctrl
[i
].dwControlType
= mlcW
.pamxctrl
[i
].dwControlType
;
3988 lpmlcA
->pamxctrl
[i
].fdwControl
= mlcW
.pamxctrl
[i
].fdwControl
;
3989 lpmlcA
->pamxctrl
[i
].cMultipleItems
= mlcW
.pamxctrl
[i
].cMultipleItems
;
3990 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szShortName
, -1,
3991 lpmlcA
->pamxctrl
[i
].szShortName
,
3992 sizeof(lpmlcA
->pamxctrl
[i
].szShortName
), NULL
, NULL
);
3993 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szName
, -1,
3994 lpmlcA
->pamxctrl
[i
].szName
,
3995 sizeof(lpmlcA
->pamxctrl
[i
].szName
), NULL
, NULL
);
3996 /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3997 * sizeof(mlcW.pamxctrl[i].Bounds) */
3998 memcpy(&lpmlcA
->pamxctrl
[i
].Bounds
, &mlcW
.pamxctrl
[i
].Bounds
,
3999 sizeof(mlcW
.pamxctrl
[i
].Bounds
));
4000 /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
4001 * sizeof(mlcW.pamxctrl[i].Metrics) */
4002 memcpy(&lpmlcA
->pamxctrl
[i
].Metrics
, &mlcW
.pamxctrl
[i
].Metrics
,
4003 sizeof(mlcW
.pamxctrl
[i
].Metrics
));
4007 HeapFree(GetProcessHeap(), 0, mlcW
.pamxctrl
);
4012 static UINT
WINMM_GetVolumeLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
4013 MIXERCONTROLW
*ctl
, DWORD flags
)
4015 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 0 : 2;
4016 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_VOLUME
;
4017 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
4018 ctl
->cMultipleItems
= 0;
4019 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, ctl
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4020 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, ctl
->szName
, MIXER_LONG_NAME_CHARS
);
4021 ctl
->Bounds
.s1
.dwMinimum
= 0;
4022 ctl
->Bounds
.s1
.dwMaximum
= 0xFFFF;
4023 ctl
->Metrics
.cSteps
= 192;
4025 return MMSYSERR_NOERROR
;
4028 static UINT
WINMM_GetMuteLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
4029 MIXERCONTROLW
*ctl
, DWORD flags
)
4031 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 1 : 3;
4032 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_MUTE
;
4033 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
4034 ctl
->cMultipleItems
= 0;
4035 LoadStringW(hWinMM32Instance
, IDS_MUTE
, ctl
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4036 LoadStringW(hWinMM32Instance
, IDS_MUTE
, ctl
->szName
, MIXER_LONG_NAME_CHARS
);
4037 ctl
->Bounds
.s1
.dwMinimum
= 0;
4038 ctl
->Bounds
.s1
.dwMaximum
= 1;
4039 ctl
->Metrics
.cSteps
= 0;
4041 return MMSYSERR_NOERROR
;
4044 /**************************************************************************
4045 * mixerGetLineControlsW [WINMM.@]
4047 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
, LPMIXERLINECONTROLSW lpmlcW
,
4050 WINMM_MMDevice
*mmdevice
;
4053 TRACE("(%p, %p, %08x)\n", hmix
, lpmlcW
, fdwControls
);
4055 hr
= WINMM_InitMMDevices();
4057 return MMSYSERR_NODRIVER
;
4059 if(fdwControls
& ~(MIXER_GETLINECONTROLSF_ALL
|
4060 MIXER_GETLINECONTROLSF_ONEBYID
|
4061 MIXER_GETLINECONTROLSF_ONEBYTYPE
|
4062 MIXER_OBJECTF_HMIXER
|
4063 MIXER_OBJECTF_MIXER
)){
4064 WARN("Unknown GetLineControls flag: %x\n", fdwControls
);
4065 return MMSYSERR_INVALFLAG
;
4068 if(!lpmlcW
|| lpmlcW
->cbStruct
< sizeof(*lpmlcW
) || !lpmlcW
->pamxctrl
)
4069 return MMSYSERR_INVALPARAM
;
4071 TRACE("dwLineID: %u\n", lpmlcW
->dwLineID
);
4072 TRACE("dwControl: %x\n", lpmlcW
->u
.dwControlID
);
4073 TRACE("cControls: %u\n", lpmlcW
->cControls
);
4075 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwControls
, NULL
);
4077 return MMSYSERR_INVALHANDLE
;
4079 switch(fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
){
4080 case MIXER_GETLINECONTROLSF_ALL
:
4081 if(lpmlcW
->cControls
!= 2)
4082 return MMSYSERR_INVALPARAM
;
4083 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4084 return MMSYSERR_INVALPARAM
;
4085 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4086 return MIXERR_INVALLINE
;
4087 WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4088 &lpmlcW
->pamxctrl
[0], fdwControls
);
4089 WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4090 &lpmlcW
->pamxctrl
[1], fdwControls
);
4091 return MMSYSERR_NOERROR
;
4092 case MIXER_GETLINECONTROLSF_ONEBYID
:
4093 if(lpmlcW
->cControls
!= 1)
4094 return MMSYSERR_INVALPARAM
;
4095 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4096 return MMSYSERR_INVALPARAM
;
4097 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4098 return MIXERR_INVALLINE
;
4099 if(lpmlcW
->u
.dwControlID
== 0)
4100 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4101 lpmlcW
->pamxctrl
, fdwControls
);
4102 if(lpmlcW
->u
.dwControlID
== 1)
4103 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4104 lpmlcW
->pamxctrl
, fdwControls
);
4105 return MMSYSERR_NOTSUPPORTED
;
4106 case MIXER_GETLINECONTROLSF_ONEBYTYPE
:
4107 if(lpmlcW
->cControls
!= 1)
4108 return MMSYSERR_INVALPARAM
;
4109 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4110 return MMSYSERR_INVALPARAM
;
4111 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4112 return MIXERR_INVALLINE
;
4113 if(lpmlcW
->u
.dwControlType
== MIXERCONTROL_CONTROLTYPE_VOLUME
)
4114 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4115 lpmlcW
->pamxctrl
, fdwControls
);
4116 if(lpmlcW
->u
.dwControlType
== MIXERCONTROL_CONTROLTYPE_MUTE
)
4117 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4118 lpmlcW
->pamxctrl
, fdwControls
);
4119 return MMSYSERR_NOTSUPPORTED
;
4122 return MMSYSERR_NOTSUPPORTED
;
4125 static UINT
WINMM_GetSourceLineInfo(WINMM_MMDevice
*mmdevice
, UINT mmdev_index
,
4126 MIXERLINEW
*info
, DWORD flags
)
4129 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4132 if(info
->dwSource
!= 0)
4133 return MIXERR_INVALLINE
;
4135 info
->dwDestination
= 0;
4137 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
| MIXERLINE_LINEF_SOURCE
;
4138 info
->cConnections
= 0;
4139 info
->cControls
= 2;
4140 /* volume & mute always affect all channels, so claim 1 channel */
4141 info
->cChannels
= 1;
4142 info
->Target
.dwDeviceID
= mmdev_index
;
4143 info
->Target
.wMid
= ~0;
4144 info
->Target
.wPid
= ~0;
4145 info
->Target
.vDriverVersion
= 0;
4147 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, info
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4148 LoadStringW(hWinMM32Instance
, IDS_MASTER_VOLUME
, info
->szName
, MIXER_LONG_NAME_CHARS
);
4151 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
;
4152 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEOUT
;
4153 memcpy(info
->Target
.szPname
, mmdevice
->out_caps
.szPname
,
4154 sizeof(info
->Target
.szPname
));
4156 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE
;
4157 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
4158 info
->Target
.szPname
[0] = '\0';
4161 return MMSYSERR_NOERROR
;
4164 static UINT
WINMM_GetDestinationLineInfo(WINMM_MMDevice
*mmdevice
,
4165 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4168 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4171 if(info
->dwDestination
!= 0)
4172 return MIXERR_INVALLINE
;
4174 info
->dwSource
= 0xFFFFFFFF;
4175 info
->dwLineID
= 0xFFFF0000;
4176 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
;
4177 info
->cConnections
= 1;
4178 info
->cControls
= 2;
4180 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, info
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4181 LoadStringW(hWinMM32Instance
, IDS_MASTER_VOLUME
, info
->szName
, MIXER_LONG_NAME_CHARS
);
4183 info
->Target
.dwDeviceID
= mmdev_index
;
4184 info
->Target
.wMid
= ~0;
4185 info
->Target
.wPid
= ~0;
4186 info
->Target
.vDriverVersion
= 0;
4189 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
;
4190 info
->cChannels
= mmdevice
->out_caps
.wChannels
;
4191 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
4192 info
->Target
.szPname
[0] = '\0';
4194 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_WAVEIN
;
4195 info
->cChannels
= mmdevice
->in_caps
.wChannels
;
4196 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEIN
;
4197 memcpy(info
->Target
.szPname
, mmdevice
->in_caps
.szPname
,
4198 sizeof(info
->Target
.szPname
));
4201 return MMSYSERR_NOERROR
;
4204 static UINT
WINMM_GetComponentTypeLineInfo(WINMM_MMDevice
*mmdevice
,
4205 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4208 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4211 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_WAVEIN
){
4213 return MIXERR_INVALLINE
;
4214 info
->dwDestination
= 0;
4215 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4218 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
){
4220 return MIXERR_INVALLINE
;
4221 info
->dwDestination
= 0;
4222 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4225 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE
){
4227 return MIXERR_INVALLINE
;
4229 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4232 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
){
4234 return MIXERR_INVALLINE
;
4236 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4239 TRACE("Returning INVALLINE on this component type: %u\n",
4240 info
->dwComponentType
);
4242 return MIXERR_INVALLINE
;
4245 static UINT
WINMM_GetLineIDLineInfo(WINMM_MMDevice
*mmdevice
,
4246 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4248 if(info
->dwLineID
== 0xFFFF0000){
4249 info
->dwDestination
= 0;
4250 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4253 if(info
->dwLineID
== 0){
4255 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4258 TRACE("Returning INVALLINE on this dwLineID: %u\n", info
->dwLineID
);
4259 return MIXERR_INVALLINE
;
4262 /**************************************************************************
4263 * mixerGetLineInfoW [WINMM.@]
4265 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpmliW
, DWORD fdwInfo
)
4268 WINMM_MMDevice
*mmdevice
;
4271 TRACE("(%p, %p, %x)\n", hmix
, lpmliW
, fdwInfo
);
4273 hr
= WINMM_InitMMDevices();
4275 return MMSYSERR_NODRIVER
;
4277 if(!lpmliW
|| lpmliW
->cbStruct
< sizeof(MIXERLINEW
))
4278 return MMSYSERR_INVALPARAM
;
4280 TRACE("dwDestination: %u\n", lpmliW
->dwDestination
);
4281 TRACE("dwSource: %u\n", lpmliW
->dwSource
);
4282 TRACE("dwLineID: %u\n", lpmliW
->dwLineID
);
4283 TRACE("fdwLine: 0x%x\n", lpmliW
->fdwLine
);
4284 TRACE("dwComponentType: 0x%x\n", lpmliW
->dwComponentType
);
4286 if(fdwInfo
& ~(MIXER_GETLINEINFOF_COMPONENTTYPE
|
4287 MIXER_GETLINEINFOF_DESTINATION
|
4288 MIXER_GETLINEINFOF_LINEID
|
4289 MIXER_GETLINEINFOF_SOURCE
|
4290 MIXER_GETLINEINFOF_TARGETTYPE
|
4291 MIXER_OBJECTF_HMIXER
|
4292 MIXER_OBJECTF_MIXER
)){
4293 WARN("Unknown GetLineInfo flag: %x\n", fdwInfo
);
4294 return MMSYSERR_INVALFLAG
;
4297 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwInfo
, &mmdev_index
);
4299 return MMSYSERR_INVALHANDLE
;
4303 switch(fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
){
4304 case MIXER_GETLINEINFOF_DESTINATION
:
4305 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, lpmliW
,
4307 case MIXER_GETLINEINFOF_SOURCE
:
4308 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
4309 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
4310 return WINMM_GetComponentTypeLineInfo(mmdevice
, mmdev_index
, lpmliW
,
4312 case MIXER_GETLINEINFOF_LINEID
:
4313 return WINMM_GetLineIDLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
4314 case MIXER_GETLINEINFOF_TARGETTYPE
:
4315 FIXME("TARGETTYPE flag not implemented!\n");
4316 return MIXERR_INVALLINE
;
4319 TRACE("Returning INVALFLAG on these flags: %x\n", fdwInfo
);
4320 return MMSYSERR_INVALFLAG
;
4323 /**************************************************************************
4324 * mixerGetLineInfoA [WINMM.@]
4326 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
, LPMIXERLINEA lpmliA
,
4332 TRACE("(%p, %p, %x)\n", hmix
, lpmliA
, fdwInfo
);
4334 if (lpmliA
== NULL
|| lpmliA
->cbStruct
!= sizeof(*lpmliA
))
4335 return MMSYSERR_INVALPARAM
;
4337 mliW
.cbStruct
= sizeof(mliW
);
4338 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
4339 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
4340 mliW
.dwComponentType
= lpmliA
->dwComponentType
;
4342 case MIXER_GETLINEINFOF_DESTINATION
:
4343 mliW
.dwDestination
= lpmliA
->dwDestination
;
4345 case MIXER_GETLINEINFOF_LINEID
:
4346 mliW
.dwLineID
= lpmliA
->dwLineID
;
4348 case MIXER_GETLINEINFOF_SOURCE
:
4349 mliW
.dwDestination
= lpmliA
->dwDestination
;
4350 mliW
.dwSource
= lpmliA
->dwSource
;
4352 case MIXER_GETLINEINFOF_TARGETTYPE
:
4353 mliW
.Target
.dwType
= lpmliA
->Target
.dwType
;
4354 mliW
.Target
.wMid
= lpmliA
->Target
.wMid
;
4355 mliW
.Target
.wPid
= lpmliA
->Target
.wPid
;
4356 mliW
.Target
.vDriverVersion
= lpmliA
->Target
.vDriverVersion
;
4357 MultiByteToWideChar(CP_ACP
, 0, lpmliA
->Target
.szPname
, -1, mliW
.Target
.szPname
, ARRAY_SIZE(mliW
.Target
.szPname
));
4360 WARN("Unsupported fdwControls=0x%08x\n", fdwInfo
);
4361 return MMSYSERR_INVALFLAG
;
4364 ret
= mixerGetLineInfoW(hmix
, &mliW
, fdwInfo
);
4366 if(ret
== MMSYSERR_NOERROR
)
4368 lpmliA
->dwDestination
= mliW
.dwDestination
;
4369 lpmliA
->dwSource
= mliW
.dwSource
;
4370 lpmliA
->dwLineID
= mliW
.dwLineID
;
4371 lpmliA
->fdwLine
= mliW
.fdwLine
;
4372 lpmliA
->dwUser
= mliW
.dwUser
;
4373 lpmliA
->dwComponentType
= mliW
.dwComponentType
;
4374 lpmliA
->cChannels
= mliW
.cChannels
;
4375 lpmliA
->cConnections
= mliW
.cConnections
;
4376 lpmliA
->cControls
= mliW
.cControls
;
4377 WideCharToMultiByte( CP_ACP
, 0, mliW
.szShortName
, -1, lpmliA
->szShortName
,
4378 sizeof(lpmliA
->szShortName
), NULL
, NULL
);
4379 WideCharToMultiByte( CP_ACP
, 0, mliW
.szName
, -1, lpmliA
->szName
,
4380 sizeof(lpmliA
->szName
), NULL
, NULL
);
4381 lpmliA
->Target
.dwType
= mliW
.Target
.dwType
;
4382 lpmliA
->Target
.dwDeviceID
= mliW
.Target
.dwDeviceID
;
4383 lpmliA
->Target
.wMid
= mliW
.Target
.wMid
;
4384 lpmliA
->Target
.wPid
= mliW
.Target
.wPid
;
4385 lpmliA
->Target
.vDriverVersion
= mliW
.Target
.vDriverVersion
;
4386 WideCharToMultiByte( CP_ACP
, 0, mliW
.Target
.szPname
, -1, lpmliA
->Target
.szPname
,
4387 sizeof(lpmliA
->Target
.szPname
), NULL
, NULL
);
4392 /**************************************************************************
4393 * mixerSetControlDetails [WINMM.@]
4395 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
,
4398 WINMM_ControlDetails details
;
4401 TRACE("(%p, %p, %x)\n", hmix
, lpmcd
, fdwDetails
);
4403 if((fdwDetails
& MIXER_SETCONTROLDETAILSF_QUERYMASK
) ==
4404 MIXER_SETCONTROLDETAILSF_CUSTOM
)
4405 return MMSYSERR_NOTSUPPORTED
;
4408 return MMSYSERR_INVALPARAM
;
4410 if(!WINMM_StartDevicesThread())
4411 return MMSYSERR_NODRIVER
;
4413 TRACE("dwControlID: %u\n", lpmcd
->dwControlID
);
4415 details
.hmix
= hmix
;
4416 details
.details
= lpmcd
;
4417 details
.flags
= fdwDetails
;
4419 ret
= SendMessageW(g_devices_hwnd
, MXDM_SETCONTROLDETAILS
,
4420 (DWORD_PTR
)&details
, 0);
4421 InterlockedDecrement(&g_devthread_token
);
4425 /**************************************************************************
4426 * mixerMessage [WINMM.@]
4428 DWORD WINAPI
mixerMessage(HMIXER hmix
, UINT uMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
4430 TRACE("(%p, %d, %lx, %lx)\n", hmix
, uMsg
, dwParam1
, dwParam2
);
4432 return MMSYSERR_NOTSUPPORTED
;