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
42 #include "mmdeviceapi.h"
43 #include "audioclient.h"
44 #include "audiopolicy.h"
46 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
50 /* HWAVE (and HMIXER) format:
52 * XXXX... 1FDD DDDD IIII IIII
53 * X = unused (must be 0)
54 * 1 = the bit is set to 1, to avoid all-zero HWAVEs
55 * F = flow direction (0 = IN, 1 = OUT)
56 * D = index into g_out_mmdevices, or all 1s for the MAPPER device
57 * I = index in the mmdevice's devices array
59 * Two reasons that we don't just use pointers:
60 * - HWAVEs must fit into 16 bits for compatibility with old applications.
61 * - We must be able to identify bad devices without crashing.
64 /* buffer size = 10 * 100000 (100 ns) = 0.1 seconds */
65 #define AC_BUFLEN (10 * 100000)
66 #define MAX_DEVICES 256
67 #define MAPPER_INDEX 0x3F
69 typedef struct _WINMM_CBInfo
{
76 struct _WINMM_MMDevice
;
77 typedef struct _WINMM_MMDevice WINMM_MMDevice
;
79 typedef struct _WINMM_Device
{
88 IAudioRenderClient
*render
;
89 IAudioCaptureClient
*capture
;
91 IAudioStreamVolume
*volume
;
93 WAVEFORMATEX
*orig_fmt
;
94 HACMSTREAM acm_handle
;
95 ACMSTREAMHEADER acm_hdr
;
98 WAVEHDR
*first
, *last
, *playing
, *loop_start
;
102 UINT32 bytes_per_frame
, samples_per_sec
, ofs_bytes
, played_frames
;
103 UINT32 remainder_frames
; /* header chunk frames already played when a device switch occurred */
105 /* stored in frames of sample rate, *not* AC::GetFrequency */
106 UINT64 last_clock_pos
;
109 CRITICAL_SECTION lock
;
111 WINMM_MMDevice
*parent
;
114 struct _WINMM_MMDevice
{
115 WAVEOUTCAPSW out_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
116 WAVEINCAPSW in_caps
; /* must not be modified outside of WINMM_InitMMDevices*/
120 ISimpleAudioVolume
*volume
;
126 /* HMIXER format is the same as the HWAVE format, but the I bits are
127 * replaced by the value of this counter, to keep each HMIXER unique */
130 CRITICAL_SECTION lock
;
132 WINMM_Device
*devices
[MAX_DEVICES
];
135 static WINMM_MMDevice
*g_out_mmdevices
;
136 static WINMM_MMDevice
**g_out_map
;
137 static UINT g_outmmdevices_count
;
138 static WINMM_Device
*g_out_mapper_devices
[MAX_DEVICES
];
140 static WINMM_MMDevice
*g_in_mmdevices
;
141 static WINMM_MMDevice
**g_in_map
;
142 static UINT g_inmmdevices_count
;
143 static WINMM_Device
*g_in_mapper_devices
[MAX_DEVICES
];
145 static IMMDeviceEnumerator
*g_devenum
;
147 static CRITICAL_SECTION g_devthread_lock
;
148 static CRITICAL_SECTION_DEBUG g_devthread_lock_debug
=
150 0, 0, &g_devthread_lock
,
151 { &g_devthread_lock_debug
.ProcessLocksList
, &g_devthread_lock_debug
.ProcessLocksList
},
152 0, 0, { (DWORD_PTR
)(__FILE__
": g_devthread_lock") }
154 static CRITICAL_SECTION g_devthread_lock
= { &g_devthread_lock_debug
, -1, 0, 0, 0, 0 };
155 static LONG g_devthread_token
;
156 static HANDLE g_devices_thread
;
157 static HWND g_devices_hwnd
;
158 static HMODULE g_devthread_module
;
160 static UINT g_devhandle_count
;
161 static HANDLE
*g_device_handles
;
162 static WINMM_Device
**g_handle_devices
;
164 typedef struct _WINMM_OpenInfo
{
167 WAVEFORMATEX
*format
;
174 typedef struct _WINMM_ControlDetails
{
176 MIXERCONTROLDETAILS
*details
;
178 } WINMM_ControlDetails
;
180 typedef struct _WINMM_QueryInterfaceInfo
{
185 } WINMM_QueryInterfaceInfo
;
187 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
);
188 static LRESULT
WOD_Close(HWAVEOUT hwave
);
189 static LRESULT
WID_Open(WINMM_OpenInfo
*info
);
190 static LRESULT
WID_Close(HWAVEIN hwave
);
191 static MMRESULT
WINMM_BeginPlaying(WINMM_Device
*device
);
192 static void WOD_PushData(WINMM_Device
*device
);
194 void WINMM_DeleteWaveform(void)
199 CloseHandle(g_devices_thread
);
201 for(i
= 0; i
< g_outmmdevices_count
; ++i
){
202 WINMM_MMDevice
*mmdevice
= &g_out_mmdevices
[i
];
204 for(j
= 0; j
< MAX_DEVICES
&& mmdevice
->devices
[j
]; ++j
){
205 WINMM_Device
*device
= mmdevice
->devices
[j
];
207 CloseHandle(device
->handle
);
208 device
->lock
.DebugInfo
->Spare
[0] = 0;
209 DeleteCriticalSection(&device
->lock
);
213 ISimpleAudioVolume_Release(mmdevice
->volume
);
214 CoTaskMemFree(mmdevice
->dev_id
);
215 mmdevice
->lock
.DebugInfo
->Spare
[0] = 0;
216 DeleteCriticalSection(&mmdevice
->lock
);
219 for(i
= 0; i
< g_inmmdevices_count
; ++i
){
220 WINMM_MMDevice
*mmdevice
= &g_in_mmdevices
[i
];
222 for(j
= 0; j
< MAX_DEVICES
&& mmdevice
->devices
[j
]; ++j
){
223 WINMM_Device
*device
= mmdevice
->devices
[j
];
225 CloseHandle(device
->handle
);
226 device
->lock
.DebugInfo
->Spare
[0] = 0;
227 DeleteCriticalSection(&device
->lock
);
231 ISimpleAudioVolume_Release(mmdevice
->volume
);
232 CoTaskMemFree(mmdevice
->dev_id
);
233 mmdevice
->lock
.DebugInfo
->Spare
[0] = 0;
234 DeleteCriticalSection(&mmdevice
->lock
);
237 free(g_out_mmdevices
);
238 free(g_in_mmdevices
);
240 free(g_device_handles
);
241 free(g_handle_devices
);
243 DeleteCriticalSection(&g_devthread_lock
);
246 static inline HWAVE
WINMM_MakeHWAVE(UINT mmdevice
, BOOL is_out
, UINT device
)
248 return ULongToHandle((1 << 15) | ((!!is_out
) << 14) |
249 (mmdevice
<< 8) | device
);
252 static inline void WINMM_DecomposeHWAVE(HWAVE hwave
, UINT
*mmdevice_index
,
253 BOOL
*is_out
, UINT
*device_index
, UINT
*junk
)
255 ULONG32 l
= HandleToULong(hwave
);
256 *device_index
= l
& 0xFF;
257 *mmdevice_index
= (l
>> 8) & 0x3F;
258 *is_out
= (l
>> 14) & 0x1;
262 static void WINMM_InitDevice(WINMM_Device
*device
)
264 InitializeCriticalSection(&device
->lock
);
265 device
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": WINMM_Device.lock");
268 static inline WINMM_MMDevice
*read_map(WINMM_MMDevice
**map
, UINT index
)
271 EnterCriticalSection(&g_devthread_lock
);
273 LeaveCriticalSection(&g_devthread_lock
);
277 /* finds the first unused Device, marks it as "open", and returns
278 * a pointer to the device
280 * IMPORTANT: it is the caller's responsibility to release the device's lock
283 static WINMM_Device
*WINMM_FindUnusedDevice(WINMM_Device
**devices
,
284 WINMM_MMDevice
*parent
, UINT internal_index
, BOOL is_out
)
288 for(i
= 0; i
< MAX_DEVICES
; ++i
){
289 WINMM_Device
*device
= devices
[i
];
292 device
= devices
[i
] = calloc(1, sizeof(WINMM_Device
));
296 WINMM_InitDevice(device
);
297 EnterCriticalSection(&device
->lock
);
299 EnterCriticalSection(&device
->lock
);
302 device
->handle
= WINMM_MakeHWAVE(internal_index
, is_out
, i
);
303 device
->parent
= parent
;
309 LeaveCriticalSection(&device
->lock
);
312 TRACE("All devices in use: mmdevice: %u\n", internal_index
);
317 static inline BOOL
WINMM_ValidateAndLock(WINMM_Device
*device
)
322 EnterCriticalSection(&device
->lock
);
325 LeaveCriticalSection(&device
->lock
);
332 static WINMM_Device
*WINMM_GetDeviceFromHWAVE(HWAVE hwave
)
334 WINMM_MMDevice
*mmdevice
;
335 WINMM_Device
*device
;
336 UINT mmdevice_index
, device_index
, junk
;
339 WINMM_DecomposeHWAVE(hwave
, &mmdevice_index
, &is_out
, &device_index
, &junk
);
344 if(mmdevice_index
== MAPPER_INDEX
){
345 EnterCriticalSection(&g_devthread_lock
);
347 device
= g_out_mapper_devices
[device_index
];
349 device
= g_in_mapper_devices
[device_index
];
350 LeaveCriticalSection(&g_devthread_lock
);
354 if(mmdevice_index
>= (is_out
? g_outmmdevices_count
: g_inmmdevices_count
))
358 mmdevice
= &g_out_mmdevices
[mmdevice_index
];
360 mmdevice
= &g_in_mmdevices
[mmdevice_index
];
362 EnterCriticalSection(&mmdevice
->lock
);
364 device
= mmdevice
->devices
[device_index
];
366 LeaveCriticalSection(&mmdevice
->lock
);
371 /* Note: NotifyClient should never be called while holding the device lock
372 * since the client may call wave* functions from within the callback. */
373 static inline void WINMM_NotifyClient(WINMM_CBInfo
*info
, WORD msg
, DWORD_PTR param1
,
376 DriverCallback(info
->callback
, info
->flags
, (HDRVR
)info
->hwave
,
377 msg
, info
->user
, param1
, param2
);
380 static MMRESULT
hr2mmr(HRESULT hr
)
384 case AUDCLNT_E_NOT_STOPPED
:
385 return MMSYSERR_NOERROR
;
386 case AUDCLNT_E_UNSUPPORTED_FORMAT
:
387 return WAVERR_BADFORMAT
;
388 case AUDCLNT_E_DEVICE_IN_USE
:
389 return MMSYSERR_ALLOCATED
;
390 case AUDCLNT_E_ENDPOINT_CREATE_FAILED
:
391 return MMSYSERR_NOTENABLED
;
393 return MMSYSERR_NOMEM
;
396 return MMSYSERR_INVALPARAM
;
397 case AUDCLNT_E_DEVICE_INVALIDATED
: /* DSERR_BUFFERLOST */
399 return FAILED(hr
) ? MMSYSERR_ERROR
: MMSYSERR_NOERROR
;
403 static HRESULT
WINMM_GetFriendlyName(IMMDevice
*device
, WCHAR
*out
,
410 hr
= IMMDevice_OpenPropertyStore(device
, STGM_READ
, &ps
);
414 PropVariantInit(&var
);
416 hr
= IPropertyStore_GetValue(ps
,
417 (PROPERTYKEY
*)&DEVPKEY_Device_FriendlyName
, &var
);
419 IPropertyStore_Release(ps
);
423 lstrcpynW(out
, var
.pwszVal
, outlen
);
425 PropVariantClear(&var
);
427 IPropertyStore_Release(ps
);
432 static HRESULT
WINMM_TestFormat(IAudioClient
*client
, DWORD rate
, DWORD depth
,
435 WAVEFORMATEX fmt
, *junk
;
438 fmt
.wFormatTag
= WAVE_FORMAT_PCM
;
439 fmt
.nChannels
= channels
;
440 fmt
.nSamplesPerSec
= rate
;
441 fmt
.wBitsPerSample
= depth
;
442 fmt
.nBlockAlign
= (channels
* depth
) / 8;
443 fmt
.nAvgBytesPerSec
= rate
* fmt
.nBlockAlign
;
446 hr
= IAudioClient_IsFormatSupported(client
, AUDCLNT_SHAREMODE_SHARED
,
454 static struct _TestFormat
{
459 } formats_to_test
[] = {
460 { WAVE_FORMAT_1M08
, 11025, 8, 1 },
461 { WAVE_FORMAT_1M16
, 11025, 16, 1 },
462 { WAVE_FORMAT_1S08
, 11025, 8, 2 },
463 { WAVE_FORMAT_1S16
, 11025, 16, 2 },
464 { WAVE_FORMAT_2M08
, 22050, 8, 1 },
465 { WAVE_FORMAT_2M16
, 22050, 16, 1 },
466 { WAVE_FORMAT_2S08
, 22050, 8, 2 },
467 { WAVE_FORMAT_2S16
, 22050, 16, 2 },
468 { WAVE_FORMAT_4M08
, 44100, 8, 1 },
469 { WAVE_FORMAT_4M16
, 44100, 16, 1 },
470 { WAVE_FORMAT_4S08
, 44100, 8, 2 },
471 { WAVE_FORMAT_4S16
, 44100, 16, 2 },
472 { WAVE_FORMAT_48M08
, 48000, 8, 1 },
473 { WAVE_FORMAT_48M16
, 48000, 16, 1 },
474 { WAVE_FORMAT_48S08
, 48000, 8, 2 },
475 { WAVE_FORMAT_48S16
, 48000, 16, 2 },
476 { WAVE_FORMAT_96M08
, 96000, 8, 1 },
477 { WAVE_FORMAT_96M16
, 96000, 16, 1 },
478 { WAVE_FORMAT_96S08
, 96000, 8, 2 },
479 { WAVE_FORMAT_96S16
, 96000, 16, 2 },
483 static DWORD
WINMM_GetSupportedFormats(IMMDevice
*device
)
487 struct _TestFormat
*fmt
;
488 IAudioClient
*client
;
490 hr
= IMMDevice_Activate(device
, &IID_IAudioClient
,
491 CLSCTX_INPROC_SERVER
, NULL
, (void**)&client
);
495 for(fmt
= formats_to_test
; fmt
->flag
; ++fmt
){
496 hr
= WINMM_TestFormat(client
, fmt
->rate
, fmt
->depth
, fmt
->channels
);
501 IAudioClient_Release(client
);
506 static HRESULT
WINMM_InitMMDevice(EDataFlow flow
, IMMDevice
*device
,
507 WINMM_MMDevice
*dev
, UINT index
)
511 dev
->dataflow
= flow
;
513 dev
->out_caps
.wMid
= 0xFF;
514 dev
->out_caps
.wPid
= 0xFF;
515 dev
->out_caps
.vDriverVersion
= 0x00010001;
516 dev
->out_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
517 dev
->out_caps
.wReserved1
= 0;
518 dev
->out_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
519 WAVECAPS_SAMPLEACCURATE
;
520 dev
->out_caps
.wChannels
= 2;
521 dev
->out_caps
.szPname
[0] = '\0';
523 hr
= WINMM_GetFriendlyName(device
, dev
->out_caps
.szPname
,
524 sizeof(dev
->out_caps
.szPname
) /
525 sizeof(*dev
->out_caps
.szPname
));
529 dev
->in_caps
.wMid
= 0xFF;
530 dev
->in_caps
.wPid
= 0xFF;
531 dev
->in_caps
.vDriverVersion
= 0x00010001;
532 dev
->in_caps
.dwFormats
= WINMM_GetSupportedFormats(device
);
533 dev
->in_caps
.wReserved1
= 0;
534 dev
->in_caps
.wChannels
= 2;
535 dev
->in_caps
.szPname
[0] = '\0';
537 hr
= WINMM_GetFriendlyName(device
, dev
->in_caps
.szPname
,
538 sizeof(dev
->in_caps
.szPname
) /
539 sizeof(*dev
->in_caps
.szPname
));
544 hr
= IMMDevice_GetId(device
, &dev
->dev_id
);
548 CoCreateGuid(&dev
->session
);
552 InitializeCriticalSection(&dev
->lock
);
553 dev
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": WINMM_Device.lock");
558 static HRESULT
WINMM_EnumDevices(WINMM_MMDevice
**devices
,
559 WINMM_MMDevice
***map
, UINT
*devcount
, EDataFlow flow
,
560 IMMDeviceEnumerator
*devenum
)
562 IMMDeviceCollection
*devcoll
;
565 hr
= IMMDeviceEnumerator_EnumAudioEndpoints(devenum
, flow
,
566 DEVICE_STATE_ACTIVE
, &devcoll
);
570 hr
= IMMDeviceCollection_GetCount(devcoll
, devcount
);
572 IMMDeviceCollection_Release(devcoll
);
578 IMMDevice
*def_dev
= NULL
;
580 *devices
= calloc(*devcount
, sizeof(WINMM_MMDevice
));
582 IMMDeviceCollection_Release(devcoll
);
583 return E_OUTOFMEMORY
;
586 *map
= calloc(*devcount
, sizeof(WINMM_MMDevice
*));
588 IMMDeviceCollection_Release(devcoll
);
590 return E_OUTOFMEMORY
;
593 /* make sure that device 0 is the default device */
594 IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum
,
595 flow
, eConsole
, &def_dev
);
597 for(n
= 0; n
< *devcount
; ++n
){
600 hr
= IMMDeviceCollection_Item(devcoll
, n
, &device
);
602 WINMM_InitMMDevice(flow
, device
, &(*devices
)[n
], n
);
604 if(device
== def_dev
)
605 (*map
)[0] = &(*devices
)[n
];
607 (*map
)[count
] = &(*devices
)[n
];
611 IMMDevice_Release(device
);
615 IMMDevice_Release(def_dev
);
620 IMMDeviceCollection_Release(devcoll
);
625 static HRESULT WINAPI
notif_QueryInterface(IMMNotificationClient
*iface
,
626 const GUID
*riid
, void **obj
)
628 ERR("Unexpected QueryInterface call: %s\n", wine_dbgstr_guid(riid
));
629 return E_NOINTERFACE
;
632 static ULONG WINAPI
notif_AddRef(IMMNotificationClient
*iface
)
637 static ULONG WINAPI
notif_Release(IMMNotificationClient
*iface
)
642 static HRESULT WINAPI
notif_OnDeviceStateChanged(IMMNotificationClient
*iface
,
643 const WCHAR
*device_id
, DWORD new_state
)
645 TRACE("Ignoring OnDeviceStateChanged callback\n");
649 static HRESULT WINAPI
notif_OnDeviceAdded(IMMNotificationClient
*iface
,
650 const WCHAR
*device_id
)
652 TRACE("Ignoring OnDeviceAdded callback\n");
656 static HRESULT WINAPI
notif_OnDeviceRemoved(IMMNotificationClient
*iface
,
657 const WCHAR
*device_id
)
659 TRACE("Ignoring OnDeviceRemoved callback\n");
663 static HRESULT
update_mapping(WINMM_MMDevice
***map
, UINT count
,
664 const WCHAR
*default_id
)
666 WINMM_MMDevice
*prev
;
670 for(i
= 0; i
< count
; ++i
){
673 if(!wcscmp((*map
)[i
]->dev_id
, default_id
)){
674 (*map
)[0] = (*map
)[i
];
685 WARN("Couldn't find new default device! Rearranged map for no reason.\n");
691 static HRESULT
reroute_mapper_device(WINMM_Device
*device
, BOOL is_out
)
697 UINT64 clock_freq
, clock_pos
;
699 TRACE("rerouting device %p\n", device
->handle
);
701 EnterCriticalSection(&device
->lock
);
703 if(!device
->open
|| device
->acm_handle
){
704 /* Windows 7 doesn't re-route ACM devices, so we don't either.
705 * Seems to be because of the data waveXxxPrepareHeader allocates. */
706 LeaveCriticalSection(&device
->lock
);
710 stopped
= device
->stopped
;
713 info
.req_device
= WAVE_MAPPER
;
714 info
.format
= device
->orig_fmt
;
715 info
.callback
= device
->cb_info
.callback
;
716 info
.cb_user
= device
->cb_info
.user
;
717 /* We have to use direct here so that we don't suddenly introduce ACM
718 * into a playing stream that hasn't been Prepared for it */
719 info
.flags
= (device
->cb_info
.flags
<< 16) | WAVE_FORMAT_DIRECT_QUERY
;
723 mr
= WOD_Open(&info
);
725 mr
= WID_Open(&info
);
727 if(mr
!= MMSYSERR_NOERROR
){
728 TRACE("New default device doesn't support this stream: %p\n", device
->handle
);
729 LeaveCriticalSection(&device
->lock
);
733 hr
= IAudioClient_Stop(device
->client
);
735 WARN("Stop failed: %08lx\n", hr
);
737 hr
= IAudioClock_GetFrequency(device
->clock
, &clock_freq
);
739 WARN("GetFrequency failed: %08lx\n", hr
);
740 LeaveCriticalSection(&device
->lock
);
744 hr
= IAudioClock_GetPosition(device
->clock
, &clock_pos
, NULL
);
746 WARN("GetPosition failed: %08lx\n", hr
);
747 LeaveCriticalSection(&device
->lock
);
751 device
->remainder_frames
= MulDiv(clock_pos
, device
->samples_per_sec
, clock_freq
) - device
->last_clock_pos
;
753 info
.handle
= device
->handle
;
754 info
.flags
= (device
->cb_info
.flags
<< 16) | WAVE_FORMAT_DIRECT
;
757 WOD_Close((HWAVEOUT
)device
->handle
);
758 device
->parent
= read_map(g_out_map
, 0);
759 mr
= WOD_Open(&info
);
761 WID_Close((HWAVEIN
)device
->handle
);
762 device
->parent
= read_map(g_in_map
, 0);
763 mr
= WID_Open(&info
);
766 if(mr
!= MMSYSERR_NOERROR
){
767 ERR("Opening new default device failed! %u\n", mr
);
768 LeaveCriticalSection(&device
->lock
);
776 WOD_PushData(device
);
777 WINMM_BeginPlaying(device
);
780 LeaveCriticalSection(&device
->lock
);
785 static HRESULT WINAPI
notif_OnDefaultDeviceChanged(IMMNotificationClient
*iface
,
786 EDataFlow flow
, ERole role
, const WCHAR
*device_id
)
790 TRACE("%u %u %s\n", flow
, role
, wine_dbgstr_w(device_id
));
795 EnterCriticalSection(&g_devthread_lock
);
798 update_mapping(&g_out_map
, g_outmmdevices_count
, device_id
);
800 update_mapping(&g_in_map
, g_inmmdevices_count
, device_id
);
802 for(i
= 0; i
< MAX_DEVICES
&& g_out_mapper_devices
[i
]; ++i
)
803 reroute_mapper_device(g_out_mapper_devices
[i
], TRUE
);
805 for(i
= 0; i
< MAX_DEVICES
&& g_in_mapper_devices
[i
]; ++i
)
806 reroute_mapper_device(g_in_mapper_devices
[i
], FALSE
);
808 LeaveCriticalSection(&g_devthread_lock
);
813 static HRESULT WINAPI
notif_OnPropertyValueChanged(IMMNotificationClient
*iface
,
814 const WCHAR
*device_id
, const PROPERTYKEY key
)
816 TRACE("Ignoring OnPropertyValueChanged callback\n");
820 static IMMNotificationClientVtbl g_notif_vtbl
= {
821 notif_QueryInterface
,
824 notif_OnDeviceStateChanged
,
826 notif_OnDeviceRemoved
,
827 notif_OnDefaultDeviceChanged
,
828 notif_OnPropertyValueChanged
831 static IMMNotificationClient g_notif
= { &g_notif_vtbl
};
833 static HRESULT
WINMM_InitMMDevices(void)
836 IMMDeviceEnumerator
*devenum
= NULL
;
838 if(g_outmmdevices_count
|| g_inmmdevices_count
)
841 init_hr
= CoInitialize(NULL
);
843 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
,
844 CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&devenum
);
848 hr
= IMMDeviceEnumerator_RegisterEndpointNotificationCallback(devenum
, &g_notif
);
850 WARN("RegisterEndpointNotificationCallback failed: %08lx\n", hr
);
852 hr
= WINMM_EnumDevices(&g_out_mmdevices
, &g_out_map
, &g_outmmdevices_count
,
855 g_outmmdevices_count
= 0;
856 g_inmmdevices_count
= 0;
860 hr
= WINMM_EnumDevices(&g_in_mmdevices
, &g_in_map
, &g_inmmdevices_count
,
863 g_inmmdevices_count
= 0;
869 IMMDeviceEnumerator_Release(devenum
);
870 if(SUCCEEDED(init_hr
))
876 static inline BOOL
WINMM_IsMapper(UINT device
)
878 return (device
== WAVE_MAPPER
|| device
== (UINT16
)WAVE_MAPPER
);
881 static MMRESULT
WINMM_TryDeviceMapping(WINMM_Device
*device
, WAVEFORMATEX
*fmt
,
882 WORD channels
, DWORD freq
, DWORD bits_per_samp
, BOOL is_query
, BOOL is_out
)
884 WAVEFORMATEX target
, *closer_fmt
= NULL
;
888 TRACE("format: %u, channels: %u, sample rate: %lu, bit depth: %lu\n",
889 WAVE_FORMAT_PCM
, channels
, freq
, bits_per_samp
);
891 target
.wFormatTag
= WAVE_FORMAT_PCM
;
892 target
.nChannels
= channels
;
893 target
.nSamplesPerSec
= freq
;
894 target
.wBitsPerSample
= bits_per_samp
;
895 target
.nBlockAlign
= (target
.nChannels
* target
.wBitsPerSample
) / 8;
896 target
.nAvgBytesPerSec
= target
.nSamplesPerSec
* target
.nBlockAlign
;
899 hr
= IAudioClient_IsFormatSupported(device
->client
,
900 AUDCLNT_SHAREMODE_SHARED
, &target
, &closer_fmt
);
901 CoTaskMemFree(closer_fmt
);
903 return WAVERR_BADFORMAT
;
905 /* device supports our target format, so see if MSACM can
906 * do the conversion */
908 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, fmt
, &target
, NULL
,
911 mr
= acmStreamOpen(&device
->acm_handle
, NULL
, &target
, fmt
, NULL
,
913 if(mr
!= MMSYSERR_NOERROR
)
916 /* yes it can. initialize the audioclient and return success */
918 acmStreamClose(device
->acm_handle
, 0);
919 device
->acm_handle
= NULL
;
920 return MMSYSERR_NOERROR
;
923 hr
= IAudioClient_Initialize(device
->client
, AUDCLNT_SHAREMODE_SHARED
,
924 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
| AUDCLNT_STREAMFLAGS_NOPERSIST
,
925 AC_BUFLEN
, 0, &target
, &device
->parent
->session
);
927 WARN("Initialize failed: %08lx\n", hr
);
928 acmStreamClose(device
->acm_handle
, 0);
929 device
->acm_handle
= NULL
;
930 return MMSYSERR_ERROR
;
933 device
->bytes_per_frame
= target
.nBlockAlign
;
934 device
->samples_per_sec
= target
.nSamplesPerSec
;
938 return MMSYSERR_NOERROR
;
941 static MMRESULT
WINMM_MapDevice(WINMM_Device
*device
, BOOL is_query
, BOOL is_out
)
944 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)device
->orig_fmt
;
946 TRACE("(%p, %u)\n", device
, is_out
);
948 /* set up the ACM stream */
949 if(device
->orig_fmt
->wFormatTag
!= WAVE_FORMAT_PCM
&&
950 !(device
->orig_fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
951 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))){
952 /* convert to PCM format if it's not already */
953 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
,
954 device
->orig_fmt
->nChannels
, device
->orig_fmt
->nSamplesPerSec
,
955 16, is_query
, is_out
);
956 if(mr
== MMSYSERR_NOERROR
)
959 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
,
960 device
->orig_fmt
->nChannels
, device
->orig_fmt
->nSamplesPerSec
,
961 8, is_query
, is_out
);
962 if(mr
== MMSYSERR_NOERROR
)
967 /* first try just changing bit depth and channels */
968 channels
= device
->orig_fmt
->nChannels
;
969 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
970 device
->orig_fmt
->nSamplesPerSec
, 16, is_query
, is_out
);
971 if(mr
== MMSYSERR_NOERROR
)
973 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
974 device
->orig_fmt
->nSamplesPerSec
, 8, is_query
, is_out
);
975 if(mr
== MMSYSERR_NOERROR
)
978 channels
= (channels
== 2) ? 1 : 2;
979 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
980 device
->orig_fmt
->nSamplesPerSec
, 16, is_query
, is_out
);
981 if(mr
== MMSYSERR_NOERROR
)
983 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
,
984 device
->orig_fmt
->nSamplesPerSec
, 8, is_query
, is_out
);
985 if(mr
== MMSYSERR_NOERROR
)
988 /* that didn't work, so now try different sample rates */
989 channels
= device
->orig_fmt
->nChannels
;
990 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 16, is_query
, is_out
);
991 if(mr
== MMSYSERR_NOERROR
)
993 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 16, is_query
, is_out
);
994 if(mr
== MMSYSERR_NOERROR
)
996 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 16, is_query
, is_out
);
997 if(mr
== MMSYSERR_NOERROR
)
999 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 16, is_query
, is_out
);
1000 if(mr
== MMSYSERR_NOERROR
)
1002 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 16, is_query
, is_out
);
1003 if(mr
== MMSYSERR_NOERROR
)
1006 channels
= (channels
== 2) ? 1 : 2;
1007 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 16, is_query
, is_out
);
1008 if(mr
== MMSYSERR_NOERROR
)
1010 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 16, is_query
, is_out
);
1011 if(mr
== MMSYSERR_NOERROR
)
1013 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 16, is_query
, is_out
);
1014 if(mr
== MMSYSERR_NOERROR
)
1016 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 16, is_query
, is_out
);
1017 if(mr
== MMSYSERR_NOERROR
)
1019 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 16, is_query
, is_out
);
1020 if(mr
== MMSYSERR_NOERROR
)
1023 channels
= device
->orig_fmt
->nChannels
;
1024 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 8, is_query
, is_out
);
1025 if(mr
== MMSYSERR_NOERROR
)
1027 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 8, is_query
, is_out
);
1028 if(mr
== MMSYSERR_NOERROR
)
1030 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 8, is_query
, is_out
);
1031 if(mr
== MMSYSERR_NOERROR
)
1033 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 8, is_query
, is_out
);
1034 if(mr
== MMSYSERR_NOERROR
)
1036 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 8, is_query
, is_out
);
1037 if(mr
== MMSYSERR_NOERROR
)
1040 channels
= (channels
== 2) ? 1 : 2;
1041 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 96000, 8, is_query
, is_out
);
1042 if(mr
== MMSYSERR_NOERROR
)
1044 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 48000, 8, is_query
, is_out
);
1045 if(mr
== MMSYSERR_NOERROR
)
1047 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 44100, 8, is_query
, is_out
);
1048 if(mr
== MMSYSERR_NOERROR
)
1050 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 22050, 8, is_query
, is_out
);
1051 if(mr
== MMSYSERR_NOERROR
)
1053 mr
= WINMM_TryDeviceMapping(device
, device
->orig_fmt
, channels
, 11025, 8, is_query
, is_out
);
1054 if(mr
== MMSYSERR_NOERROR
)
1058 WARN("Unable to find compatible device!\n");
1059 return WAVERR_BADFORMAT
;
1062 static LRESULT
WINMM_OpenDevice(WINMM_Device
*device
, WINMM_OpenInfo
*info
,
1065 LRESULT ret
= MMSYSERR_NOMEM
;
1068 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, device
->parent
->dev_id
,
1071 WARN("Device %s (%s) unavailable: %08lx\n",
1072 wine_dbgstr_w(device
->parent
->dev_id
),
1073 wine_dbgstr_w(device
->parent
->out_caps
.szPname
), hr
);
1074 ret
= MMSYSERR_NODRIVER
;
1078 /* this is where winexyz.drv opens the audio device */
1079 hr
= IMMDevice_Activate(device
->device
, &IID_IAudioClient
,
1080 CLSCTX_INPROC_SERVER
, NULL
, (void**)&device
->client
);
1082 WARN("Activate failed: %08lx\n", hr
);
1084 if(ret
== MMSYSERR_ERROR
)
1085 ret
= MMSYSERR_NOTENABLED
;
1089 if(info
->format
->wFormatTag
== WAVE_FORMAT_PCM
){
1091 if (info
->format
->nSamplesPerSec
== 0)
1093 ret
= MMSYSERR_INVALPARAM
;
1097 /* we aren't guaranteed that the struct in lpFormat is a full
1098 * WAVEFORMATEX struct, which IAC::IsFormatSupported requires */
1099 device
->orig_fmt
= malloc(sizeof(WAVEFORMATEX
));
1100 memcpy(device
->orig_fmt
, info
->format
, sizeof(PCMWAVEFORMAT
));
1101 device
->orig_fmt
->cbSize
= 0;
1102 if(device
->orig_fmt
->wBitsPerSample
% 8 != 0){
1103 WARN("Fixing bad wBitsPerSample (%u)\n", device
->orig_fmt
->wBitsPerSample
);
1104 device
->orig_fmt
->wBitsPerSample
= (device
->orig_fmt
->wBitsPerSample
+ 7) & ~7;
1106 /* winmm ignores broken blockalign and avgbytes */
1107 if(device
->orig_fmt
->nBlockAlign
!= device
->orig_fmt
->nChannels
* device
->orig_fmt
->wBitsPerSample
/8){
1108 WARN("Fixing bad nBlockAlign (%u)\n", device
->orig_fmt
->nBlockAlign
);
1109 device
->orig_fmt
->nBlockAlign
= device
->orig_fmt
->nChannels
* device
->orig_fmt
->wBitsPerSample
/8;
1111 if (device
->orig_fmt
->nAvgBytesPerSec
!= device
->orig_fmt
->nSamplesPerSec
* device
->orig_fmt
->nBlockAlign
) {
1112 WARN("Fixing bad nAvgBytesPerSec (%lu)\n", device
->orig_fmt
->nAvgBytesPerSec
);
1113 device
->orig_fmt
->nAvgBytesPerSec
= device
->orig_fmt
->nSamplesPerSec
* device
->orig_fmt
->nBlockAlign
;
1116 device
->orig_fmt
= malloc(sizeof(WAVEFORMATEX
) + info
->format
->cbSize
);
1117 memcpy(device
->orig_fmt
, info
->format
,
1118 sizeof(WAVEFORMATEX
) + info
->format
->cbSize
);
1121 if(info
->flags
& WAVE_FORMAT_QUERY
){
1122 WAVEFORMATEX
*closer_fmt
= NULL
;
1124 hr
= IAudioClient_IsFormatSupported(device
->client
,
1125 AUDCLNT_SHAREMODE_SHARED
, device
->orig_fmt
, &closer_fmt
);
1126 CoTaskMemFree(closer_fmt
);
1127 if((hr
== S_FALSE
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !(info
->flags
& WAVE_FORMAT_DIRECT
))
1128 ret
= WINMM_MapDevice(device
, TRUE
, is_out
);
1130 ret
= hr
== S_FALSE
? WAVERR_BADFORMAT
: hr2mmr(hr
);
1134 hr
= IAudioClient_Initialize(device
->client
, AUDCLNT_SHAREMODE_SHARED
,
1135 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
| AUDCLNT_STREAMFLAGS_NOPERSIST
,
1136 AC_BUFLEN
, 0, device
->orig_fmt
, &device
->parent
->session
);
1138 if(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
&& !(info
->flags
& WAVE_FORMAT_DIRECT
)){
1139 ret
= WINMM_MapDevice(device
, FALSE
, is_out
);
1140 if(ret
!= MMSYSERR_NOERROR
|| info
->flags
& WAVE_FORMAT_QUERY
)
1143 WARN("Initialize failed: %08lx\n", hr
);
1148 device
->bytes_per_frame
= device
->orig_fmt
->nBlockAlign
;
1149 device
->samples_per_sec
= device
->orig_fmt
->nSamplesPerSec
;
1152 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioClock
,
1153 (void**)&device
->clock
);
1155 WARN("GetService failed: %08lx\n", hr
);
1160 device
->event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1162 WARN("CreateEvent failed: %08lx\n", hr
);
1166 /* As the devices thread is waiting on g_device_handles, it can
1167 * only be modified from within this same thread. */
1168 g_device_handles
= realloc(g_device_handles
,
1169 sizeof(HANDLE
) * (g_devhandle_count
+ 1));
1170 g_handle_devices
= realloc(g_handle_devices
,
1171 sizeof(WINMM_Device
*) * (g_devhandle_count
+ 1));
1172 g_device_handles
[g_devhandle_count
] = device
->event
;
1173 g_handle_devices
[g_devhandle_count
] = device
;
1174 ++g_devhandle_count
;
1177 hr
= IAudioClient_SetEventHandle(device
->client
, device
->event
);
1179 WARN("SetEventHandle failed: %08lx\n", hr
);
1184 device
->played_frames
= 0;
1185 device
->ofs_bytes
= 0;
1186 device
->loop_counter
= 0;
1187 device
->first
= device
->last
= device
->playing
= device
->loop_start
= NULL
;
1190 device
->stopped
= TRUE
;
1191 device
->last_clock_pos
= 0;
1193 device
->cb_info
.flags
= HIWORD(info
->flags
& CALLBACK_TYPEMASK
);
1194 device
->cb_info
.callback
= info
->callback
;
1195 device
->cb_info
.user
= info
->cb_user
;
1196 device
->cb_info
.hwave
= device
->handle
;
1198 info
->handle
= device
->handle
;
1200 return MMSYSERR_NOERROR
;
1204 IAudioClient_Release(device
->client
);
1205 device
->client
= NULL
;
1208 IMMDevice_Release(device
->device
);
1209 device
->device
= NULL
;
1215 static LRESULT
WOD_Open(WINMM_OpenInfo
*info
)
1217 WINMM_Device
*device
;
1218 LRESULT ret
= MMSYSERR_ERROR
;
1221 if(info
->handle
!= 0){
1222 device
= WINMM_GetDeviceFromHWAVE(info
->handle
);
1224 WARN("Unexpected! Invalid info->handle given: %p\n", info
->handle
);
1225 return MMSYSERR_ERROR
;
1228 EnterCriticalSection(&device
->lock
);
1230 device
->open
= TRUE
;
1232 CRITICAL_SECTION
*lock
;
1233 UINT internal_index
;
1234 WINMM_Device
**devices
;
1235 WINMM_MMDevice
*mmdevice
;
1237 if(WINMM_IsMapper(info
->req_device
)){
1238 if (g_outmmdevices_count
== 0)
1239 return MMSYSERR_BADDEVICEID
;
1240 devices
= g_out_mapper_devices
;
1241 mmdevice
= read_map(g_out_map
, 0);
1242 lock
= &g_devthread_lock
;
1243 internal_index
= MAPPER_INDEX
;
1245 if(info
->req_device
>= g_outmmdevices_count
)
1246 return MMSYSERR_BADDEVICEID
;
1248 mmdevice
= read_map(g_out_map
, info
->req_device
);
1250 if(!mmdevice
->out_caps
.szPname
[0])
1251 return MMSYSERR_NOTENABLED
;
1253 devices
= mmdevice
->devices
;
1254 lock
= &mmdevice
->lock
;
1255 internal_index
= mmdevice
->index
;
1258 EnterCriticalSection(lock
);
1260 device
= WINMM_FindUnusedDevice(devices
, mmdevice
,
1261 internal_index
, TRUE
);
1263 LeaveCriticalSection(lock
);
1264 return MMSYSERR_ALLOCATED
;
1267 LeaveCriticalSection(lock
);
1270 ret
= WINMM_OpenDevice(device
, info
, TRUE
);
1271 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
1273 ret
= MMSYSERR_ERROR
;
1275 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioRenderClient
,
1276 (void**)&device
->render
);
1278 ERR("GetService failed: %08lx\n", hr
);
1282 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioStreamVolume
,
1283 (void**)&device
->volume
);
1285 ERR("GetService failed: %08lx\n", hr
);
1289 LeaveCriticalSection(&device
->lock
);
1291 return MMSYSERR_NOERROR
;
1295 IMMDevice_Release(device
->device
);
1296 device
->device
= NULL
;
1299 IAudioClient_Release(device
->client
);
1300 device
->client
= NULL
;
1303 IAudioRenderClient_Release(device
->render
);
1304 device
->render
= NULL
;
1307 IAudioStreamVolume_Release(device
->volume
);
1308 device
->volume
= NULL
;
1311 IAudioClock_Release(device
->clock
);
1312 device
->clock
= NULL
;
1314 device
->open
= FALSE
;
1315 LeaveCriticalSection(&device
->lock
);
1319 static LRESULT
WID_Open(WINMM_OpenInfo
*info
)
1321 WINMM_Device
*device
, **devices
;
1322 WINMM_MMDevice
*mmdevice
;
1323 UINT internal_index
;
1324 CRITICAL_SECTION
*lock
;
1325 LRESULT ret
= MMSYSERR_ERROR
;
1328 if(WINMM_IsMapper(info
->req_device
)){
1329 if (g_inmmdevices_count
== 0)
1330 return MMSYSERR_BADDEVICEID
;
1331 devices
= g_in_mapper_devices
;
1332 mmdevice
= read_map(g_in_map
, 0);
1333 lock
= &g_devthread_lock
;
1334 internal_index
= MAPPER_INDEX
;
1336 if(info
->req_device
>= g_inmmdevices_count
)
1337 return MMSYSERR_BADDEVICEID
;
1339 mmdevice
= read_map(g_in_map
, info
->req_device
);
1341 if(!mmdevice
->in_caps
.szPname
[0])
1342 return MMSYSERR_NOTENABLED
;
1344 devices
= mmdevice
->devices
;
1345 lock
= &mmdevice
->lock
;
1346 internal_index
= mmdevice
->index
;
1349 EnterCriticalSection(lock
);
1351 device
= WINMM_FindUnusedDevice(devices
, mmdevice
, internal_index
, FALSE
);
1353 LeaveCriticalSection(lock
);
1354 return MMSYSERR_ALLOCATED
;
1357 LeaveCriticalSection(lock
);
1359 ret
= WINMM_OpenDevice(device
, info
, FALSE
);
1360 if((info
->flags
& WAVE_FORMAT_QUERY
) || ret
!= MMSYSERR_NOERROR
)
1362 ret
= MMSYSERR_ERROR
;
1364 hr
= IAudioClient_GetService(device
->client
, &IID_IAudioCaptureClient
,
1365 (void**)&device
->capture
);
1367 WARN("GetService failed: %08lx\n", hr
);
1371 LeaveCriticalSection(&device
->lock
);
1373 return MMSYSERR_NOERROR
;
1377 IMMDevice_Release(device
->device
);
1378 device
->device
= NULL
;
1381 IAudioClient_Release(device
->client
);
1382 device
->client
= NULL
;
1384 if(device
->capture
){
1385 IAudioCaptureClient_Release(device
->capture
);
1386 device
->capture
= NULL
;
1389 IAudioClock_Release(device
->clock
);
1390 device
->clock
= NULL
;
1392 device
->open
= FALSE
;
1393 LeaveCriticalSection(&device
->lock
);
1397 static HRESULT
WINMM_CloseDevice(WINMM_Device
*device
)
1399 device
->open
= FALSE
;
1401 if(!device
->stopped
){
1402 IAudioClient_Stop(device
->client
);
1403 device
->stopped
= TRUE
;
1406 if(device
->acm_handle
){
1407 acmStreamClose(device
->acm_handle
, 0);
1408 device
->acm_handle
= NULL
;
1411 IMMDevice_Release(device
->device
);
1412 device
->device
= NULL
;
1414 IAudioClient_Release(device
->client
);
1415 device
->client
= NULL
;
1417 IAudioClock_Release(device
->clock
);
1418 device
->clock
= NULL
;
1420 free(device
->orig_fmt
);
1425 static LRESULT
WOD_Close(HWAVEOUT hwave
)
1427 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1429 TRACE("(%p)\n", hwave
);
1431 if(!WINMM_ValidateAndLock(device
))
1432 return MMSYSERR_INVALHANDLE
;
1434 WINMM_CloseDevice(device
);
1436 IAudioRenderClient_Release(device
->render
);
1437 device
->render
= NULL
;
1439 IAudioStreamVolume_Release(device
->volume
);
1440 device
->volume
= NULL
;
1442 LeaveCriticalSection(&device
->lock
);
1444 return MMSYSERR_NOERROR
;
1447 static LRESULT
WID_Close(HWAVEIN hwave
)
1449 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hwave
);
1451 TRACE("(%p)\n", hwave
);
1453 if(!WINMM_ValidateAndLock(device
))
1454 return MMSYSERR_INVALHANDLE
;
1456 WINMM_CloseDevice(device
);
1458 IAudioCaptureClient_Release(device
->capture
);
1459 device
->capture
= NULL
;
1461 LeaveCriticalSection(&device
->lock
);
1463 return MMSYSERR_NOERROR
;
1466 static DWORD
WINMM_FixedBufferLen(DWORD length
, WINMM_Device
*device
)
1468 return length
- length
% device
->bytes_per_frame
;
1471 static LRESULT
WINMM_PrepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1473 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1475 TRACE("(%p, %p)\n", hwave
, header
);
1477 if(!WINMM_ValidateAndLock(device
))
1478 return MMSYSERR_INVALHANDLE
;
1480 if(device
->render
&& device
->acm_handle
){
1481 ACMSTREAMHEADER
*ash
;
1485 mr
= acmStreamSize(device
->acm_handle
, header
->dwBufferLength
, &size
,
1486 ACM_STREAMSIZEF_SOURCE
);
1487 if(mr
!= MMSYSERR_NOERROR
){
1488 LeaveCriticalSection(&device
->lock
);
1492 ash
= malloc(sizeof(ACMSTREAMHEADER
) + size
);
1494 LeaveCriticalSection(&device
->lock
);
1495 return MMSYSERR_NOMEM
;
1498 ash
->cbStruct
= sizeof(*ash
);
1500 ash
->dwUser
= (DWORD_PTR
)header
;
1501 ash
->pbSrc
= (BYTE
*)header
->lpData
;
1502 ash
->cbSrcLength
= header
->dwBufferLength
;
1503 ash
->dwSrcUser
= header
->dwUser
;
1504 ash
->pbDst
= (BYTE
*)ash
+ sizeof(ACMSTREAMHEADER
);
1505 ash
->cbDstLength
= size
;
1508 mr
= acmStreamPrepareHeader(device
->acm_handle
, ash
, 0);
1509 if(mr
!= MMSYSERR_NOERROR
){
1511 LeaveCriticalSection(&device
->lock
);
1515 header
->reserved
= (DWORD_PTR
)ash
;
1518 LeaveCriticalSection(&device
->lock
);
1520 header
->dwFlags
|= WHDR_PREPARED
;
1521 header
->dwFlags
&= ~(WHDR_DONE
|WHDR_INQUEUE
); /* flags cleared since w2k */
1523 return MMSYSERR_NOERROR
;
1526 static LRESULT
WINMM_UnprepareHeader(HWAVE hwave
, WAVEHDR
*header
)
1528 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1530 TRACE("(%p, %p)\n", hwave
, header
);
1532 if(!WINMM_ValidateAndLock(device
))
1533 return MMSYSERR_INVALHANDLE
;
1535 if(device
->render
&& device
->acm_handle
){
1536 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1538 acmStreamUnprepareHeader(device
->acm_handle
, ash
, 0);
1543 LeaveCriticalSection(&device
->lock
);
1545 header
->dwFlags
&= ~WHDR_PREPARED
;
1547 return MMSYSERR_NOERROR
;
1550 static UINT32
WINMM_HeaderLenBytes(WINMM_Device
*device
, WAVEHDR
*header
)
1552 if(device
->acm_handle
){
1553 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
1554 return WINMM_FixedBufferLen(ash
->cbDstLengthUsed
, device
);
1557 return WINMM_FixedBufferLen(header
->dwBufferLength
, device
);
1560 static UINT32
WINMM_HeaderLenFrames(WINMM_Device
*device
, WAVEHDR
*header
)
1562 return WINMM_HeaderLenBytes(device
, header
) / device
->bytes_per_frame
;
1565 static WAVEHDR
*WOD_MarkDoneHeaders(WINMM_Device
*device
)
1568 WAVEHDR
*first
= device
->first
, *queue
= first
, *last
= NULL
;
1569 UINT64 clock_freq
, clock_pos
, clock_frames
;
1570 UINT32 nloops
, queue_frames
= 0;
1572 hr
= IAudioClock_GetFrequency(device
->clock
, &clock_freq
);
1574 WARN("GetFrequency failed: %08lx\n", hr
);
1578 hr
= IAudioClock_GetPosition(device
->clock
, &clock_pos
, NULL
);
1580 WARN("GetPosition failed: %08lx\n", hr
);
1584 clock_frames
= (clock_pos
* device
->samples_per_sec
) / clock_freq
;
1586 nloops
= device
->loop_counter
;
1588 (queue_frames
+= WINMM_HeaderLenFrames(device
, queue
)) <=
1589 clock_frames
- device
->last_clock_pos
+ device
->remainder_frames
){
1592 device
->last_clock_pos
+= queue_frames
;
1593 device
->remainder_frames
= 0;
1595 queue
= device
->first
= queue
->lpNext
;
1597 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1598 if(queue
->dwFlags
& WHDR_ENDLOOP
)
1601 queue
= queue
->lpNext
;
1602 }else if(queue
->dwFlags
& WHDR_ENDLOOP
){
1603 queue
= device
->loop_start
;
1610 last
->lpNext
= NULL
;
1616 static void WOD_PushData(WINMM_Device
*device
)
1618 WINMM_CBInfo cb_info
;
1620 UINT32 pad
, bufsize
, avail_frames
, queue_frames
, written
, ofs
;
1621 UINT32 queue_bytes
, nloops
;
1623 WAVEHDR
*queue
, *first
= NULL
;
1625 TRACE("(%p)\n", device
->handle
);
1627 EnterCriticalSection(&device
->lock
);
1633 if (device
->stopped
)
1635 device
->stopped
= TRUE
;
1636 device
->last_clock_pos
= 0;
1637 IAudioClient_Stop(device
->client
);
1638 IAudioClient_Reset(device
->client
);
1642 hr
= IAudioClient_GetBufferSize(device
->client
, &bufsize
);
1644 WARN("GetBufferSize failed: %08lx\n", hr
);
1648 hr
= IAudioClient_GetCurrentPadding(device
->client
, &pad
);
1650 WARN("GetCurrentPadding failed: %08lx\n", hr
);
1654 first
= WOD_MarkDoneHeaders(device
);
1656 /* determine which is larger between the available buffer size and
1657 * the amount of data left in the queue */
1658 avail_frames
= bufsize
- pad
;
1660 queue
= device
->playing
;
1661 ofs
= device
->ofs_bytes
;
1664 while(queue
&& queue_frames
< avail_frames
){
1665 queue_bytes
= WINMM_HeaderLenBytes(device
, queue
);
1666 queue_frames
+= (queue_bytes
- ofs
) / device
->bytes_per_frame
;
1669 if(queue
->dwFlags
& WHDR_ENDLOOP
&& nloops
< device
->loop_counter
){
1670 queue
= device
->loop_start
;
1673 queue
= queue
->lpNext
;
1676 if(queue_frames
< avail_frames
)
1677 avail_frames
= queue_frames
;
1678 if(avail_frames
== 0)
1681 hr
= IAudioRenderClient_GetBuffer(device
->render
, avail_frames
, &data
);
1683 WARN("GetBuffer failed: %08lx\n", hr
);
1688 while(device
->playing
&& written
< avail_frames
){
1689 UINT32 copy_frames
, copy_bytes
;
1692 queue
= device
->playing
;
1694 queue_bytes
= WINMM_HeaderLenBytes(device
, queue
);
1695 if(device
->acm_handle
)
1696 queue_data
= ((ACMSTREAMHEADER
*)queue
->reserved
)->pbDst
;
1698 queue_data
= (BYTE
*)queue
->lpData
;
1700 queue_frames
= (queue_bytes
- device
->ofs_bytes
) /
1701 device
->bytes_per_frame
;
1703 copy_frames
= queue_frames
< (avail_frames
- written
) ?
1704 queue_frames
: avail_frames
- written
;
1705 copy_bytes
= copy_frames
* device
->bytes_per_frame
;
1707 memcpy(data
, queue_data
+ device
->ofs_bytes
, copy_bytes
);
1710 written
+= copy_frames
;
1711 device
->ofs_bytes
+= copy_bytes
;
1713 if(device
->ofs_bytes
>= queue_bytes
){
1714 device
->ofs_bytes
= 0;
1716 if(!(queue
->dwFlags
& (WHDR_BEGINLOOP
| WHDR_ENDLOOP
)))
1717 device
->playing
= queue
->lpNext
;
1719 if(queue
->dwFlags
& WHDR_BEGINLOOP
){
1720 device
->loop_start
= device
->playing
;
1721 device
->playing
= queue
->lpNext
;
1722 device
->loop_counter
= queue
->dwLoops
;
1724 if(queue
->dwFlags
& WHDR_ENDLOOP
){
1725 --device
->loop_counter
;
1726 if(device
->loop_counter
)
1727 device
->playing
= device
->loop_start
;
1729 device
->loop_start
= device
->playing
= queue
->lpNext
;
1735 hr
= IAudioRenderClient_ReleaseBuffer(device
->render
, avail_frames
, 0);
1737 WARN("ReleaseBuffer failed: %08lx\n", hr
);
1741 if(device
->orig_fmt
->nSamplesPerSec
!= device
->samples_per_sec
)
1742 device
->played_frames
+= MulDiv(avail_frames
, device
->orig_fmt
->nSamplesPerSec
, device
->samples_per_sec
);
1744 device
->played_frames
+= avail_frames
;
1747 cb_info
= device
->cb_info
;
1749 LeaveCriticalSection(&device
->lock
);
1752 WAVEHDR
*next
= first
->lpNext
;
1753 first
->dwFlags
&= ~WHDR_INQUEUE
;
1754 first
->dwFlags
|= WHDR_DONE
;
1755 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
1760 static void WID_PullACMData(WINMM_Device
*device
)
1770 if(device
->acm_hdr
.cbDstLength
== 0){
1771 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet
,
1772 &flags
, NULL
, NULL
);
1775 WARN("GetBuffer failed: %08lx\n", hr
);
1779 acmStreamSize(device
->acm_handle
, packet
* device
->bytes_per_frame
,
1780 &packet_bytes
, ACM_STREAMSIZEF_SOURCE
);
1782 device
->acm_offs
= 0;
1784 device
->acm_hdr
.cbStruct
= sizeof(device
->acm_hdr
);
1785 device
->acm_hdr
.fdwStatus
= 0;
1786 device
->acm_hdr
.dwUser
= 0;
1787 device
->acm_hdr
.pbSrc
= data
;
1788 device
->acm_hdr
.cbSrcLength
= packet
* device
->bytes_per_frame
;
1789 device
->acm_hdr
.cbSrcLengthUsed
= 0;
1790 device
->acm_hdr
.dwSrcUser
= 0;
1791 device
->acm_hdr
.pbDst
= malloc(packet_bytes
);
1792 device
->acm_hdr
.cbDstLength
= packet_bytes
;
1793 device
->acm_hdr
.cbDstLengthUsed
= 0;
1794 device
->acm_hdr
.dwDstUser
= 0;
1796 mr
= acmStreamPrepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1797 if(mr
!= MMSYSERR_NOERROR
){
1798 WARN("acmStreamPrepareHeader failed: %d\n", mr
);
1802 mr
= acmStreamConvert(device
->acm_handle
, &device
->acm_hdr
, 0);
1803 if(mr
!= MMSYSERR_NOERROR
){
1804 WARN("acmStreamConvert failed: %d\n", mr
);
1808 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet
);
1810 WARN("ReleaseBuffer failed: %08lx\n", hr
);
1812 device
->played_frames
+= packet
;
1815 queue
= device
->first
;
1817 UINT32 to_copy_bytes
;
1819 to_copy_bytes
= min(WINMM_FixedBufferLen(queue
->dwBufferLength
, device
) - queue
->dwBytesRecorded
,
1820 WINMM_FixedBufferLen(device
->acm_hdr
.cbDstLengthUsed
, device
) - device
->acm_offs
);
1822 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
,
1823 device
->acm_hdr
.pbDst
+ device
->acm_offs
, to_copy_bytes
);
1825 queue
->dwBytesRecorded
+= to_copy_bytes
;
1826 device
->acm_offs
+= to_copy_bytes
;
1828 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1829 device
->bytes_per_frame
){
1830 queue
->dwFlags
&= ~WHDR_INQUEUE
;
1831 queue
->dwFlags
|= WHDR_DONE
;
1832 device
->first
= queue
= queue
->lpNext
;
1835 if(device
->acm_offs
>= WINMM_FixedBufferLen(device
->acm_hdr
.cbDstLengthUsed
, device
)){
1836 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1837 free(device
->acm_hdr
.pbDst
);
1838 device
->acm_hdr
.cbDstLength
= 0;
1839 device
->acm_hdr
.cbDstLengthUsed
= 0;
1841 /* done with this ACM Header, so try to pull more data */
1842 WID_PullACMData(device
);
1847 /* out of WAVEHDRs to write into, so toss the rest of this packet */
1848 acmStreamUnprepareHeader(device
->acm_handle
, &device
->acm_hdr
, 0);
1849 free(device
->acm_hdr
.pbDst
);
1850 device
->acm_hdr
.cbDstLength
= 0;
1851 device
->acm_hdr
.cbDstLengthUsed
= 0;
1854 static void WID_PullData(WINMM_Device
*device
)
1856 WINMM_CBInfo cb_info
;
1857 WAVEHDR
*queue
, *first
= NULL
, *last
= NULL
;
1860 TRACE("(%p)\n", device
->handle
);
1862 EnterCriticalSection(&device
->lock
);
1864 if(!device
->device
|| !device
->first
)
1867 first
= device
->first
;
1869 if(device
->acm_handle
){
1870 WID_PullACMData(device
);
1874 while(device
->first
){
1876 UINT32 packet_len
, packet
;
1879 hr
= IAudioCaptureClient_GetBuffer(device
->capture
, &data
, &packet_len
,
1880 &flags
, NULL
, NULL
);
1883 WARN("GetBuffer failed: %08lx\n", hr
);
1884 else /* AUDCLNT_S_BUFFER_EMPTY success code */
1885 IAudioCaptureClient_ReleaseBuffer(device
->capture
, 0);
1889 packet
= packet_len
;
1890 queue
= device
->first
;
1891 while(queue
&& packet
> 0){
1892 UINT32 to_copy_bytes
;
1894 to_copy_bytes
= min(packet
* device
->bytes_per_frame
,
1895 WINMM_FixedBufferLen(queue
->dwBufferLength
, device
) - queue
->dwBytesRecorded
);
1897 memcpy(queue
->lpData
+ queue
->dwBytesRecorded
,
1898 data
+ (packet_len
- packet
) * device
->bytes_per_frame
,
1901 queue
->dwBytesRecorded
+= to_copy_bytes
;
1903 if(queue
->dwBufferLength
- queue
->dwBytesRecorded
<
1904 device
->bytes_per_frame
){
1906 device
->first
= queue
= queue
->lpNext
;
1909 packet
-= to_copy_bytes
/ device
->bytes_per_frame
;
1912 hr
= IAudioCaptureClient_ReleaseBuffer(device
->capture
, packet_len
);
1914 WARN("ReleaseBuffer failed: %08lx\n", hr
);
1917 WARN("losing %u frames\n", packet
);
1918 device
->played_frames
+= packet_len
- packet
;
1922 cb_info
= device
->cb_info
;
1924 LeaveCriticalSection(&device
->lock
);
1927 last
->lpNext
= NULL
;
1929 WAVEHDR
*next
= first
->lpNext
;
1930 first
->dwFlags
&= ~WHDR_INQUEUE
;
1931 first
->dwFlags
|= WHDR_DONE
;
1932 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
1938 static MMRESULT
WINMM_BeginPlaying(WINMM_Device
*device
)
1942 TRACE("(%p)\n", device
->handle
);
1944 if(device
->stopped
){
1945 device
->stopped
= FALSE
;
1947 hr
= IAudioClient_Start(device
->client
);
1948 if(FAILED(hr
) && hr
!= AUDCLNT_E_NOT_STOPPED
){
1949 device
->stopped
= TRUE
;
1950 WARN("Start failed: %08lx\n", hr
);
1951 return MMSYSERR_ERROR
;
1955 return MMSYSERR_NOERROR
;
1958 static LRESULT
WINMM_Pause(WINMM_Device
*device
)
1962 TRACE("(%p)\n", device
->handle
);
1964 hr
= IAudioClient_Stop(device
->client
);
1966 WARN("Stop failed: %08lx\n", hr
);
1967 return MMSYSERR_ERROR
;
1970 device
->stopped
= FALSE
;
1972 return MMSYSERR_NOERROR
;
1975 static LRESULT
WINMM_Reset(HWAVE hwave
)
1977 WINMM_CBInfo cb_info
;
1978 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
1983 TRACE("(%p)\n", hwave
);
1985 if(!WINMM_ValidateAndLock(device
))
1986 return MMSYSERR_INVALHANDLE
;
1988 hr
= IAudioClient_Stop(device
->client
);
1990 LeaveCriticalSection(&device
->lock
);
1991 WARN("Stop failed: %08lx\n", hr
);
1992 return MMSYSERR_ERROR
;
1994 device
->stopped
= TRUE
;
1996 first
= device
->first
;
1997 device
->first
= device
->last
= device
->playing
= NULL
;
1998 device
->ofs_bytes
= 0;
1999 device
->played_frames
= 0;
2000 device
->loop_counter
= 0;
2001 device
->last_clock_pos
= 0;
2002 IAudioClient_Reset(device
->client
);
2004 cb_info
= device
->cb_info
;
2005 is_out
= device
->render
!= NULL
;
2007 LeaveCriticalSection(&device
->lock
);
2010 WAVEHDR
*next
= first
->lpNext
;
2011 first
->dwFlags
&= ~WHDR_INQUEUE
;
2012 first
->dwFlags
|= WHDR_DONE
;
2014 WINMM_NotifyClient(&cb_info
, WOM_DONE
, (DWORD_PTR
)first
, 0);
2016 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)first
, 0);
2020 return MMSYSERR_NOERROR
;
2023 static MMRESULT
WINMM_FramesToMMTime(MMTIME
*time
, UINT32 played_frames
,
2024 UINT32 sample_rate
, UINT32 bytes_per_sec
)
2026 switch(time
->wType
){
2028 time
->u
.sample
= played_frames
;
2029 return MMSYSERR_NOERROR
;
2031 time
->wType
= TIME_BYTES
;
2034 time
->u
.cb
= MulDiv(played_frames
, bytes_per_sec
, sample_rate
);
2035 return MMSYSERR_NOERROR
;
2039 static LRESULT
WINMM_GetPosition(HWAVE hwave
, MMTIME
*time
)
2041 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE(hwave
);
2042 UINT32 played_frames
, sample_rate
, bytes_per_sec
;
2044 TRACE("(%p, %p)\n", hwave
, time
);
2046 if(!WINMM_ValidateAndLock(device
))
2047 return MMSYSERR_INVALHANDLE
;
2049 played_frames
= device
->played_frames
;
2050 sample_rate
= device
->orig_fmt
->nSamplesPerSec
;
2051 bytes_per_sec
= device
->orig_fmt
->nAvgBytesPerSec
;
2053 LeaveCriticalSection(&device
->lock
);
2055 return WINMM_FramesToMMTime(time
, played_frames
, sample_rate
, bytes_per_sec
);
2058 static WINMM_MMDevice
*WINMM_GetMixerMMDevice(HMIXEROBJ hmix
, DWORD flags
,
2061 UINT mmdev
, dev
, junk
, *out
;
2069 switch(flags
& 0xF0000000){
2070 case MIXER_OBJECTF_MIXER
: /* == 0 */
2071 *out
= HandleToULong(hmix
);
2072 if(*out
< g_outmmdevices_count
)
2073 return read_map(g_out_map
, *out
);
2074 if(*out
- g_outmmdevices_count
< g_inmmdevices_count
){
2075 *out
-= g_outmmdevices_count
;
2076 return read_map(g_in_map
, *out
);
2078 /* fall through -- if it's not a valid mixer device, then
2079 * it could be a valid mixer handle. windows seems to do
2081 case MIXER_OBJECTF_HMIXER
:
2082 case MIXER_OBJECTF_HWAVEOUT
:
2083 case MIXER_OBJECTF_HWAVEIN
:
2084 WINMM_DecomposeHWAVE((HWAVE
)hmix
, out
, &is_out
, &dev
, &junk
);
2085 if(junk
!= 0x1 || (is_out
&& *out
>= g_outmmdevices_count
) ||
2086 (!is_out
&& *out
>= g_inmmdevices_count
))
2089 return read_map(g_out_map
, *out
);
2090 return read_map(g_in_map
, *out
);
2091 case MIXER_OBJECTF_WAVEOUT
:
2092 *out
= HandleToULong(hmix
);
2093 if(*out
< g_outmmdevices_count
)
2094 return read_map(g_out_map
, *out
);
2096 case MIXER_OBJECTF_WAVEIN
:
2097 *out
= HandleToULong(hmix
);
2098 if(*out
< g_inmmdevices_count
)
2099 return read_map(g_in_map
, *out
);
2106 static MMRESULT
WINMM_SetupMMDeviceVolume(WINMM_MMDevice
*mmdevice
)
2108 IAudioSessionManager
*sesman
;
2112 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
, &device
);
2114 WARN("Device %s (%s) unavailable: %08lx\n",
2115 wine_dbgstr_w(mmdevice
->dev_id
),
2116 wine_dbgstr_w(mmdevice
->out_caps
.szPname
), hr
);
2117 return MMSYSERR_ERROR
;
2120 hr
= IMMDevice_Activate(device
, &IID_IAudioSessionManager
,
2121 CLSCTX_INPROC_SERVER
, NULL
, (void**)&sesman
);
2123 WARN("Activate failed: %08lx\n", hr
);
2124 IMMDevice_Release(device
);
2125 return MMSYSERR_ERROR
;
2128 IMMDevice_Release(device
);
2130 hr
= IAudioSessionManager_GetSimpleAudioVolume(sesman
, &mmdevice
->session
,
2131 FALSE
, &mmdevice
->volume
);
2132 IAudioSessionManager_Release(sesman
);
2134 WARN("GetSimpleAudioVolume failed: %08lx\n", hr
);
2135 return MMSYSERR_ERROR
;
2138 return MMSYSERR_NOERROR
;
2141 static LRESULT
MXD_GetControlDetails(WINMM_ControlDetails
*details
)
2143 WINMM_MMDevice
*mmdevice
;
2144 MIXERCONTROLDETAILS
*control
= details
->details
;
2147 TRACE("(%p)\n", details
->hmix
);
2149 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
2151 return MMSYSERR_INVALHANDLE
;
2153 EnterCriticalSection(&mmdevice
->lock
);
2155 if(!mmdevice
->volume
){
2158 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
2159 if(mr
!= MMSYSERR_NOERROR
){
2160 LeaveCriticalSection(&mmdevice
->lock
);
2165 if(control
->dwControlID
== 0){
2167 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
2169 if(!control
->paDetails
||
2170 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
2171 LeaveCriticalSection(&mmdevice
->lock
);
2172 return MMSYSERR_INVALPARAM
;
2175 hr
= ISimpleAudioVolume_GetMasterVolume(mmdevice
->volume
, &vol
);
2177 WARN("GetMasterVolume failed: %08lx\n", hr
);
2178 LeaveCriticalSection(&mmdevice
->lock
);
2179 return MMSYSERR_ERROR
;
2182 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
2183 udet
->dwValue
= vol
* ((unsigned int)0xFFFF);
2184 }else if(control
->dwControlID
== 1){
2186 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
2188 if(!control
->paDetails
||
2189 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
2190 LeaveCriticalSection(&mmdevice
->lock
);
2191 return MMSYSERR_INVALPARAM
;
2194 hr
= ISimpleAudioVolume_GetMute(mmdevice
->volume
, &mute
);
2196 WARN("GetMute failed: %08lx\n", hr
);
2197 LeaveCriticalSection(&mmdevice
->lock
);
2198 return MMSYSERR_ERROR
;
2201 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
2202 bdet
->fValue
= mute
;
2203 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
2204 FIXME("What should the sw-side mixer controls map to?\n");
2206 LeaveCriticalSection(&mmdevice
->lock
);
2207 return MIXERR_INVALCONTROL
;
2210 LeaveCriticalSection(&mmdevice
->lock
);
2212 return MMSYSERR_NOERROR
;
2215 static LRESULT
MXD_SetControlDetails(WINMM_ControlDetails
*details
)
2217 WINMM_MMDevice
*mmdevice
;
2218 MIXERCONTROLDETAILS
*control
= details
->details
;
2221 TRACE("(%p)\n", details
->hmix
);
2223 mmdevice
= WINMM_GetMixerMMDevice(details
->hmix
, details
->flags
, NULL
);
2225 return MMSYSERR_INVALHANDLE
;
2227 EnterCriticalSection(&mmdevice
->lock
);
2229 if(!mmdevice
->volume
){
2232 mr
= WINMM_SetupMMDeviceVolume(mmdevice
);
2233 if(mr
!= MMSYSERR_NOERROR
){
2234 LeaveCriticalSection(&mmdevice
->lock
);
2239 if(control
->dwControlID
== 0){
2241 MIXERCONTROLDETAILS_UNSIGNED
*udet
;
2243 if(!control
->paDetails
||
2244 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_UNSIGNED
)){
2245 LeaveCriticalSection(&mmdevice
->lock
);
2246 return MMSYSERR_INVALPARAM
;
2249 udet
= (MIXERCONTROLDETAILS_UNSIGNED
*)control
->paDetails
;
2251 if(udet
->dwValue
> 65535){
2252 LeaveCriticalSection(&mmdevice
->lock
);
2253 return MMSYSERR_INVALPARAM
;
2256 vol
= udet
->dwValue
/ 65535.f
;
2258 hr
= ISimpleAudioVolume_SetMasterVolume(mmdevice
->volume
, vol
, NULL
);
2260 WARN("SetMasterVolume failed: %08lx\n", hr
);
2261 LeaveCriticalSection(&mmdevice
->lock
);
2262 return MMSYSERR_ERROR
;
2264 }else if(control
->dwControlID
== 1){
2266 MIXERCONTROLDETAILS_BOOLEAN
*bdet
;
2268 if(!control
->paDetails
||
2269 control
->cbDetails
< sizeof(MIXERCONTROLDETAILS_BOOLEAN
)){
2270 LeaveCriticalSection(&mmdevice
->lock
);
2271 return MMSYSERR_INVALPARAM
;
2274 bdet
= (MIXERCONTROLDETAILS_BOOLEAN
*)control
->paDetails
;
2275 mute
= bdet
->fValue
;
2277 hr
= ISimpleAudioVolume_SetMute(mmdevice
->volume
, mute
, NULL
);
2279 WARN("SetMute failed: %08lx\n", hr
);
2280 LeaveCriticalSection(&mmdevice
->lock
);
2281 return MMSYSERR_ERROR
;
2283 }else if(control
->dwControlID
== 2 || control
->dwControlID
== 3){
2284 FIXME("What should the sw-side mixer controls map to?\n");
2286 LeaveCriticalSection(&mmdevice
->lock
);
2287 return MIXERR_INVALCONTROL
;
2290 LeaveCriticalSection(&mmdevice
->lock
);
2292 return MMSYSERR_NOERROR
;
2295 static LRESULT
DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo
*info
)
2297 WINMM_MMDevice
*mmdevice
;
2304 static const PROPERTYKEY deviceinterface_key
= {
2305 {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
2308 if(WINMM_IsMapper(info
->index
)){
2310 if(*info
->len_bytes
< sizeof(WCHAR
))
2311 return MMSYSERR_INVALPARAM
;
2314 *info
->len_bytes
= sizeof(WCHAR
);
2315 return MMSYSERR_NOERROR
;
2319 if(info
->index
>= g_outmmdevices_count
)
2320 return MMSYSERR_INVALHANDLE
;
2322 mmdevice
= &g_out_mmdevices
[info
->index
];
2324 if(info
->index
>= g_inmmdevices_count
)
2325 return MMSYSERR_INVALHANDLE
;
2327 mmdevice
= &g_in_mmdevices
[info
->index
];
2330 hr
= IMMDeviceEnumerator_GetDevice(g_devenum
, mmdevice
->dev_id
,
2333 WARN("Device %s unavailable: %08lx\n", wine_dbgstr_w(mmdevice
->dev_id
), hr
);
2334 return MMSYSERR_ERROR
;
2337 hr
= IMMDevice_OpenPropertyStore(device
, STGM_READ
, &ps
);
2339 WARN("OpenPropertyStore failed: %08lx\n", hr
);
2340 IMMDevice_Release(device
);
2341 return MMSYSERR_ERROR
;
2344 PropVariantInit(&pv
);
2345 hr
= IPropertyStore_GetValue(ps
, &deviceinterface_key
, &pv
);
2347 WARN("GetValue failed: %08lx\n", hr
);
2348 IPropertyStore_Release(ps
);
2349 IMMDevice_Release(device
);
2350 return MMSYSERR_ERROR
;
2352 if(pv
.vt
!= VT_LPWSTR
){
2353 WARN("Got unexpected property type: %u\n", pv
.vt
);
2354 PropVariantClear(&pv
);
2355 IPropertyStore_Release(ps
);
2356 IMMDevice_Release(device
);
2357 return MMSYSERR_ERROR
;
2360 len_bytes
= (lstrlenW(pv
.pwszVal
) + 1) * sizeof(WCHAR
);
2363 if(len_bytes
> *info
->len_bytes
){
2364 PropVariantClear(&pv
);
2365 IPropertyStore_Release(ps
);
2366 IMMDevice_Release(device
);
2367 return MMSYSERR_INVALPARAM
;
2370 memcpy(info
->str
, pv
.pwszVal
, len_bytes
);
2372 *info
->len_bytes
= len_bytes
;
2374 PropVariantClear(&pv
);
2375 IPropertyStore_Release(ps
);
2376 IMMDevice_Release(device
);
2378 return MMSYSERR_NOERROR
;
2381 static LRESULT CALLBACK
WINMM_DevicesMsgProc(HWND hwnd
, UINT msg
, WPARAM wparam
,
2386 return WOD_Open((WINMM_OpenInfo
*)wparam
);
2388 return WOD_Close((HWAVEOUT
)wparam
);
2390 return WID_Open((WINMM_OpenInfo
*)wparam
);
2392 return WID_Close((HWAVEIN
)wparam
);
2393 case MXDM_GETCONTROLDETAILS
:
2394 return MXD_GetControlDetails((WINMM_ControlDetails
*)wparam
);
2395 case MXDM_SETCONTROLDETAILS
:
2396 return MXD_SetControlDetails((WINMM_ControlDetails
*)wparam
);
2397 case DRV_QUERYDEVICEINTERFACESIZE
:
2398 case DRV_QUERYDEVICEINTERFACE
:
2399 return DRV_QueryDeviceInterface((WINMM_QueryInterfaceInfo
*)wparam
);
2401 return DefWindowProcW(hwnd
, msg
, wparam
, lparam
);
2404 static BOOL
WINMM_DevicesThreadDone(void)
2408 EnterCriticalSection(&g_devthread_lock
);
2410 if(g_devthread_token
> 0){
2411 LeaveCriticalSection(&g_devthread_lock
);
2415 for(i
= 0; i
< g_devhandle_count
; ++i
){
2416 if(g_handle_devices
[i
]->open
){
2417 LeaveCriticalSection(&g_devthread_lock
);
2422 DestroyWindow(g_devices_hwnd
);
2423 g_devices_hwnd
= NULL
;
2424 IMMDeviceEnumerator_Release(g_devenum
);
2428 LeaveCriticalSection(&g_devthread_lock
);
2433 static DWORD WINAPI
WINMM_DevicesThreadProc(void *arg
)
2438 hr
= CoInitializeEx(NULL
, COINIT_MULTITHREADED
);
2440 WARN("CoInitializeEx failed: %08lx\n", hr
);
2441 FreeLibraryAndExitThread(g_devthread_module
, 1);
2444 hr
= WINMM_InitMMDevices();
2447 FreeLibraryAndExitThread(g_devthread_module
, 1);
2450 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
,
2451 CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&g_devenum
);
2453 WARN("CoCreateInstance failed: %08lx\n", hr
);
2455 FreeLibraryAndExitThread(g_devthread_module
, 1);
2458 g_devices_hwnd
= CreateWindowW(L
"Message", NULL
, 0, 0, 0, 0, 0,
2459 HWND_MESSAGE
, NULL
, NULL
, NULL
);
2460 if(!g_devices_hwnd
){
2461 WARN("CreateWindow failed: %ld\n", GetLastError());
2463 FreeLibraryAndExitThread(g_devthread_module
, 1);
2466 SetWindowLongPtrW(g_devices_hwnd
, GWLP_WNDPROC
,
2467 (LONG_PTR
)WINMM_DevicesMsgProc
);
2469 /* inform caller that the thread is ready to process messages */
2471 evt
= NULL
; /* do not use after this point */
2475 wait
= MsgWaitForMultipleObjects(g_devhandle_count
, g_device_handles
,
2476 FALSE
, INFINITE
, QS_ALLINPUT
);
2477 if(wait
== g_devhandle_count
+ WAIT_OBJECT_0
){
2479 if(PeekMessageW(&msg
, g_devices_hwnd
, 0, 0, PM_REMOVE
))
2480 WARN("Unexpected message: 0x%x\n", msg
.message
);
2483 }else if(wait
< g_devhandle_count
+ WAIT_OBJECT_0
){
2484 WINMM_Device
*device
= g_handle_devices
[wait
- WAIT_OBJECT_0
];
2486 WOD_PushData(device
);
2488 WID_PullData(device
);
2490 WARN("Unexpected MsgWait result 0x%lx, GLE: %ld\n", wait
,
2492 if(WINMM_DevicesThreadDone()){
2493 TRACE("Quitting devices thread\n");
2494 FreeLibraryAndExitThread(g_devthread_module
, 0);
2498 FreeLibraryAndExitThread(g_devthread_module
, 0);
2501 /* on success, increments g_devthread_token to prevent
2502 * device thread shutdown. caller must decrement. */
2503 static BOOL
WINMM_StartDevicesThread(void)
2508 EnterCriticalSection(&g_devthread_lock
);
2511 wait
= WaitForSingleObject(g_devices_thread
, 0);
2512 if(wait
== WAIT_TIMEOUT
){
2513 /* thread still running */
2514 InterlockedIncrement(&g_devthread_token
);
2515 LeaveCriticalSection(&g_devthread_lock
);
2518 if(wait
!= WAIT_OBJECT_0
){
2520 LeaveCriticalSection(&g_devthread_lock
);
2523 TRACE("Devices thread left dangling message window?\n");
2524 g_devices_hwnd
= NULL
;
2525 CloseHandle(g_devices_thread
);
2526 g_devices_thread
= NULL
;
2527 }else if(g_devices_thread
){
2528 WaitForSingleObject(g_devices_thread
, INFINITE
);
2529 CloseHandle(g_devices_thread
);
2530 g_devices_thread
= NULL
;
2533 TRACE("Starting up devices thread\n");
2535 /* The devices thread holds a reference to the winmm module
2536 * to prevent it from unloading while it's running. */
2537 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
2538 (const WCHAR
*)WINMM_StartDevicesThread
, &g_devthread_module
);
2540 events
[0] = CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2542 g_devices_thread
= CreateThread(NULL
, 0, WINMM_DevicesThreadProc
,
2543 events
[0], 0, NULL
);
2544 if(!g_devices_thread
){
2545 LeaveCriticalSection(&g_devthread_lock
);
2546 CloseHandle(events
[0]);
2547 FreeLibrary(g_devthread_module
);
2551 events
[1] = g_devices_thread
;
2552 wait
= WaitForMultipleObjects(2, events
, FALSE
, INFINITE
);
2553 CloseHandle(events
[0]);
2554 if(wait
!= WAIT_OBJECT_0
){
2555 if(wait
== 1 + WAIT_OBJECT_0
){
2556 CloseHandle(g_devices_thread
);
2557 g_devices_thread
= NULL
;
2558 g_devices_hwnd
= NULL
;
2560 LeaveCriticalSection(&g_devthread_lock
);
2564 InterlockedIncrement(&g_devthread_token
);
2566 LeaveCriticalSection(&g_devthread_lock
);
2571 /**************************************************************************
2572 * waveOutGetNumDevs [WINMM.@]
2574 UINT WINAPI
waveOutGetNumDevs(void)
2576 HRESULT hr
= WINMM_InitMMDevices();
2580 TRACE("count: %u\n", g_outmmdevices_count
);
2582 return g_outmmdevices_count
;
2585 /**************************************************************************
2586 * waveOutGetDevCapsA [WINMM.@]
2588 UINT WINAPI
waveOutGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
2594 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2597 return MMSYSERR_INVALPARAM
;
2599 ret
= waveOutGetDevCapsW(uDeviceID
, &wocW
, sizeof(wocW
));
2601 if (ret
== MMSYSERR_NOERROR
) {
2603 wocA
.wMid
= wocW
.wMid
;
2604 wocA
.wPid
= wocW
.wPid
;
2605 wocA
.vDriverVersion
= wocW
.vDriverVersion
;
2606 WideCharToMultiByte( CP_ACP
, 0, wocW
.szPname
, -1, wocA
.szPname
,
2607 sizeof(wocA
.szPname
), NULL
, NULL
);
2608 wocA
.dwFormats
= wocW
.dwFormats
;
2609 wocA
.wChannels
= wocW
.wChannels
;
2610 wocA
.dwSupport
= wocW
.dwSupport
;
2611 wocA
.wReserved1
= wocW
.wReserved1
;
2612 memcpy(lpCaps
, &wocA
, min(uSize
, sizeof(wocA
)));
2617 /**************************************************************************
2618 * waveOutGetDevCapsW [WINMM.@]
2620 UINT WINAPI
waveOutGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
2623 WAVEOUTCAPSW mapper_caps
, *caps
;
2626 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
2628 hr
= WINMM_InitMMDevices();
2630 return MMSYSERR_NODRIVER
;
2632 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2634 if(WINMM_IsMapper(uDeviceID
)){
2635 mapper_caps
.wMid
= 0xFF;
2636 mapper_caps
.wPid
= 0xFF;
2637 mapper_caps
.vDriverVersion
= 0x00010001;
2638 mapper_caps
.dwFormats
= 0xFFFFFFFF;
2639 mapper_caps
.wReserved1
= 0;
2640 mapper_caps
.dwSupport
= WAVECAPS_LRVOLUME
| WAVECAPS_VOLUME
|
2641 WAVECAPS_SAMPLEACCURATE
;
2642 mapper_caps
.wChannels
= 2;
2643 LoadStringW(hWinMM32Instance
, IDS_MAPPER_NAME
, mapper_caps
.szPname
, MAXPNAMELEN
);
2645 caps
= &mapper_caps
;
2647 if(uDeviceID
>= g_outmmdevices_count
){
2648 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)uDeviceID
);
2650 if(!WINMM_ValidateAndLock(device
))
2651 return MMSYSERR_BADDEVICEID
;
2653 caps
= &device
->parent
->out_caps
;
2655 LeaveCriticalSection(&device
->lock
);
2657 caps
= &read_map(g_out_map
, uDeviceID
)->out_caps
;
2661 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
2663 return MMSYSERR_NOERROR
;
2666 /**************************************************************************
2667 * waveOutGetErrorTextA [WINMM.@]
2668 * waveInGetErrorTextA [WINMM.@]
2670 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2674 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2675 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2678 WCHAR
*xstr
= malloc(uSize
* sizeof(WCHAR
));
2679 if (!xstr
) ret
= MMSYSERR_NOMEM
;
2682 ret
= waveOutGetErrorTextW(uError
, xstr
, uSize
);
2683 if (ret
== MMSYSERR_NOERROR
)
2684 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
2691 /**************************************************************************
2692 * waveOutGetErrorTextW [WINMM.@]
2693 * waveInGetErrorTextW [WINMM.@]
2695 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2697 UINT ret
= MMSYSERR_BADERRNUM
;
2699 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2700 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2702 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2703 * a warning for the test was always true */
2704 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
2705 (uError
>= WAVERR_BASE
&& uError
<= WAVERR_LASTERROR
)) {
2706 if (LoadStringW(hWinMM32Instance
,
2707 uError
, lpText
, uSize
) > 0) {
2708 ret
= MMSYSERR_NOERROR
;
2714 /**************************************************************************
2715 * waveOutOpen [WINMM.@]
2716 * All the args/structs have the same layout as the win16 equivalents
2718 MMRESULT WINAPI
waveOutOpen(LPHWAVEOUT lphWaveOut
, UINT uDeviceID
,
2719 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2720 DWORD_PTR dwInstance
, DWORD dwFlags
)
2723 WINMM_OpenInfo info
;
2724 WINMM_CBInfo cb_info
;
2726 TRACE("(%p, %u, %p, %Ix, %Ix, %08lx)\n", lphWaveOut
, uDeviceID
, lpFormat
,
2727 dwCallback
, dwInstance
, dwFlags
);
2729 if(!lphWaveOut
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
2730 return MMSYSERR_INVALPARAM
;
2732 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
2733 if(res
!= MMSYSERR_NOERROR
)
2736 if(!WINMM_StartDevicesThread())
2737 return MMSYSERR_NODRIVER
;
2740 info
.format
= (WAVEFORMATEX
*)lpFormat
;
2741 info
.callback
= dwCallback
;
2742 info
.cb_user
= dwInstance
;
2743 info
.req_device
= uDeviceID
;
2744 info
.flags
= dwFlags
;
2747 res
= SendMessageW(g_devices_hwnd
, WODM_OPEN
, (DWORD_PTR
)&info
, 0);
2748 InterlockedDecrement(&g_devthread_token
);
2749 if(res
!= MMSYSERR_NOERROR
|| (dwFlags
& WAVE_FORMAT_QUERY
))
2753 *lphWaveOut
= (HWAVEOUT
)info
.handle
;
2755 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2756 cb_info
.callback
= dwCallback
;
2757 cb_info
.user
= dwInstance
;
2758 cb_info
.hwave
= info
.handle
;
2760 WINMM_NotifyClient(&cb_info
, WOM_OPEN
, 0, 0);
2765 /**************************************************************************
2766 * waveOutClose [WINMM.@]
2768 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
2771 WINMM_Device
*device
;
2772 WINMM_CBInfo cb_info
;
2774 TRACE("(%p)\n", hWaveOut
);
2776 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2778 if(!WINMM_ValidateAndLock(device
))
2779 return MMSYSERR_INVALHANDLE
;
2781 cb_info
= device
->cb_info
;
2783 LeaveCriticalSection(&device
->lock
);
2785 res
= SendMessageW(g_devices_hwnd
, WODM_CLOSE
, (WPARAM
)hWaveOut
, 0);
2787 if(res
== MMSYSERR_NOERROR
)
2788 WINMM_NotifyClient(&cb_info
, WOM_CLOSE
, 0, 0);
2793 /**************************************************************************
2794 * waveOutPrepareHeader [WINMM.@]
2796 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
2797 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
2799 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2801 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2802 return MMSYSERR_INVALPARAM
;
2804 if(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
)
2805 return MMSYSERR_NOERROR
;
2807 return WINMM_PrepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2810 /**************************************************************************
2811 * waveOutUnprepareHeader [WINMM.@]
2813 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
2814 LPWAVEHDR lpWaveOutHdr
, UINT uSize
)
2816 TRACE("(%p, %p, %u)\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2818 if(!lpWaveOutHdr
|| uSize
< sizeof(WAVEHDR
))
2819 return MMSYSERR_INVALPARAM
;
2821 if(lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2822 return WAVERR_STILLPLAYING
;
2824 if(!(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
))
2825 return MMSYSERR_NOERROR
;
2827 return WINMM_UnprepareHeader((HWAVE
)hWaveOut
, lpWaveOutHdr
);
2830 /**************************************************************************
2831 * waveOutWrite [WINMM.@]
2833 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, WAVEHDR
*header
, UINT uSize
)
2835 WINMM_Device
*device
;
2838 TRACE("(%p, %p, %u)\n", hWaveOut
, header
, uSize
);
2840 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2842 if(!WINMM_ValidateAndLock(device
))
2843 return MMSYSERR_INVALHANDLE
;
2845 if(!header
->lpData
|| !(header
->dwFlags
& WHDR_PREPARED
)){
2846 LeaveCriticalSection(&device
->lock
);
2847 return WAVERR_UNPREPARED
;
2850 if(header
->dwFlags
& WHDR_INQUEUE
){
2851 LeaveCriticalSection(&device
->lock
);
2852 return WAVERR_STILLPLAYING
;
2855 TRACE("dwBufferLength: %lu\n", header
->dwBufferLength
);
2857 if(device
->acm_handle
){
2858 ACMSTREAMHEADER
*ash
= (ACMSTREAMHEADER
*)header
->reserved
;
2860 ash
->cbSrcLength
= header
->dwBufferLength
;
2861 mr
= acmStreamConvert(device
->acm_handle
, ash
, 0);
2862 if(mr
!= MMSYSERR_NOERROR
){
2863 LeaveCriticalSection(&device
->lock
);
2869 device
->last
->lpNext
= header
;
2870 device
->last
= header
;
2871 if(!device
->playing
)
2872 device
->playing
= header
;
2874 device
->playing
= device
->first
= device
->last
= header
;
2875 if(header
->dwFlags
& WHDR_BEGINLOOP
){
2876 device
->loop_counter
= header
->dwLoops
;
2877 device
->loop_start
= header
;
2881 header
->lpNext
= NULL
;
2882 header
->dwFlags
&= ~WHDR_DONE
;
2883 header
->dwFlags
|= WHDR_INQUEUE
;
2886 WOD_PushData(device
);
2888 mr
= WINMM_BeginPlaying(device
);
2890 LeaveCriticalSection(&device
->lock
);
2895 /**************************************************************************
2896 * waveOutBreakLoop [WINMM.@]
2898 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
2900 WINMM_Device
*device
;
2902 TRACE("(%p)\n", hWaveOut
);
2904 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2906 if(!WINMM_ValidateAndLock(device
))
2907 return MMSYSERR_INVALHANDLE
;
2909 device
->loop_counter
= 0;
2911 LeaveCriticalSection(&device
->lock
);
2913 return MMSYSERR_NOERROR
;
2916 /**************************************************************************
2917 * waveOutPause [WINMM.@]
2919 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
2921 WINMM_Device
*device
;
2924 TRACE("(%p)\n", hWaveOut
);
2926 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2928 if(!WINMM_ValidateAndLock(device
))
2929 return MMSYSERR_INVALHANDLE
;
2931 mr
= WINMM_Pause(device
);
2933 LeaveCriticalSection(&device
->lock
);
2938 /**************************************************************************
2939 * waveOutReset [WINMM.@]
2941 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
2943 TRACE("(%p)\n", hWaveOut
);
2945 return WINMM_Reset((HWAVE
)hWaveOut
);
2948 /**************************************************************************
2949 * waveOutRestart [WINMM.@]
2951 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
2953 WINMM_Device
*device
;
2956 TRACE("(%p)\n", hWaveOut
);
2958 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
2960 if(!WINMM_ValidateAndLock(device
))
2961 return MMSYSERR_INVALHANDLE
;
2963 device
->stopped
= TRUE
;
2966 WOD_PushData(device
);
2968 mr
= WINMM_BeginPlaying(device
);
2970 LeaveCriticalSection(&device
->lock
);
2975 /**************************************************************************
2976 * waveOutGetPosition [WINMM.@]
2978 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
2981 TRACE("(%p, %p, %u)\n", hWaveOut
, lpTime
, uSize
);
2983 if(!uSize
|| !lpTime
)
2984 return MMSYSERR_INVALPARAM
;
2986 if(uSize
< sizeof(MMTIME
))
2987 return MMSYSERR_ERROR
;
2989 return WINMM_GetPosition((HWAVE
)hWaveOut
, lpTime
);
2992 /**************************************************************************
2993 * waveOutGetPitch [WINMM.@]
2995 UINT WINAPI
waveOutGetPitch(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2997 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
2998 return MMSYSERR_NOTSUPPORTED
;
3001 /**************************************************************************
3002 * waveOutSetPitch [WINMM.@]
3004 UINT WINAPI
waveOutSetPitch(HWAVEOUT hWaveOut
, DWORD dw
)
3006 TRACE("(%p, %08lx)\n", hWaveOut
, dw
);
3008 return MMSYSERR_NOTSUPPORTED
;
3011 /**************************************************************************
3012 * waveOutGetPlaybackRate [WINMM.@]
3014 UINT WINAPI
waveOutGetPlaybackRate(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
3016 TRACE("(%p, %p)\n", hWaveOut
, lpdw
);
3018 return MMSYSERR_NOTSUPPORTED
;
3021 /**************************************************************************
3022 * waveOutSetPlaybackRate [WINMM.@]
3024 UINT WINAPI
waveOutSetPlaybackRate(HWAVEOUT hWaveOut
, DWORD dw
)
3026 TRACE("(%p, %08lx)\n", hWaveOut
, dw
);
3028 return MMSYSERR_NOTSUPPORTED
;
3031 /**************************************************************************
3032 * waveOutGetVolume [WINMM.@]
3034 UINT WINAPI
waveOutGetVolume(HWAVEOUT hWaveOut
, DWORD
*out
)
3036 WINMM_Device
*device
;
3041 TRACE("(%p, %p)\n", hWaveOut
, out
);
3044 return MMSYSERR_INVALPARAM
;
3046 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3048 if(!WINMM_ValidateAndLock(device
))
3049 return MMSYSERR_INVALHANDLE
;
3051 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
3053 LeaveCriticalSection(&device
->lock
);
3054 WARN("GetChannelCount failed: %08lx\n", hr
);
3055 return MMSYSERR_ERROR
;
3058 vols
= malloc(sizeof(float) * channels
);
3060 LeaveCriticalSection(&device
->lock
);
3061 return MMSYSERR_NOMEM
;
3064 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
3066 LeaveCriticalSection(&device
->lock
);
3068 WARN("GetAllVolumes failed: %08lx\n", hr
);
3069 return MMSYSERR_ERROR
;
3072 LeaveCriticalSection(&device
->lock
);
3074 *out
= ((UINT16
)(vols
[0] * (DWORD
)0xFFFF));
3076 *out
|= ((UINT16
)(vols
[1] * (DWORD
)0xFFFF)) << 16;
3080 return MMSYSERR_NOERROR
;
3083 /**************************************************************************
3084 * waveOutSetVolume [WINMM.@]
3086 UINT WINAPI
waveOutSetVolume(HWAVEOUT hWaveOut
, DWORD in
)
3088 WINMM_Device
*device
;
3093 TRACE("(%p, %08lx)\n", hWaveOut
, in
);
3095 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3097 if(!WINMM_ValidateAndLock(device
))
3098 return MMSYSERR_INVALHANDLE
;
3100 hr
= IAudioStreamVolume_GetChannelCount(device
->volume
, &channels
);
3102 LeaveCriticalSection(&device
->lock
);
3103 WARN("GetChannelCount failed: %08lx\n", hr
);
3104 return MMSYSERR_ERROR
;
3107 vols
= malloc(sizeof(float) * channels
);
3109 LeaveCriticalSection(&device
->lock
);
3110 return MMSYSERR_NOMEM
;
3113 hr
= IAudioStreamVolume_GetAllVolumes(device
->volume
, channels
, vols
);
3115 LeaveCriticalSection(&device
->lock
);
3117 WARN("GetAllVolumes failed: %08lx\n", hr
);
3118 return MMSYSERR_ERROR
;
3121 vols
[0] = (float)((in
& 0xFFFF) / (float)0xFFFF);
3123 vols
[1] = (float)((in
>> 16) / (float)0xFFFF);
3125 hr
= IAudioStreamVolume_SetAllVolumes(device
->volume
, channels
, vols
);
3127 LeaveCriticalSection(&device
->lock
);
3129 WARN("SetAllVolumes failed: %08lx\n", hr
);
3130 return MMSYSERR_ERROR
;
3133 LeaveCriticalSection(&device
->lock
);
3137 return MMSYSERR_NOERROR
;
3140 /**************************************************************************
3141 * waveOutGetID [WINMM.@]
3143 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
3145 WINMM_Device
*device
;
3149 TRACE("(%p, %p)\n", hWaveOut
, lpuDeviceID
);
3152 return MMSYSERR_INVALPARAM
;
3154 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveOut
);
3155 if(!WINMM_ValidateAndLock(device
))
3156 return MMSYSERR_INVALHANDLE
;
3158 LeaveCriticalSection(&device
->lock
);
3160 WINMM_DecomposeHWAVE((HWAVE
)hWaveOut
, lpuDeviceID
, &is_out
, &dev
, &junk
);
3162 return MMSYSERR_NOERROR
;
3165 static UINT
WINMM_QueryInstanceIDSize(UINT device
, DWORD_PTR
*len
, BOOL is_out
)
3168 WINMM_MMDevice
**devices
;
3170 TRACE("(%u, %p, %d)\n", device
, len
, is_out
);
3173 count
= g_outmmdevices_count
;
3174 devices
= g_out_map
;
3176 count
= g_inmmdevices_count
;
3181 return MMSYSERR_INVALHANDLE
;
3183 EnterCriticalSection(&g_devthread_lock
);
3184 *len
= (lstrlenW(devices
[device
]->dev_id
) + 1) * sizeof(WCHAR
);
3185 LeaveCriticalSection(&g_devthread_lock
);
3187 return MMSYSERR_NOERROR
;
3190 static UINT
WINMM_QueryInstanceID(UINT device
, WCHAR
*str
, DWORD_PTR len
,
3194 WINMM_MMDevice
**devices
;
3196 TRACE("(%u, %p, %d)\n", device
, str
, is_out
);
3199 count
= g_outmmdevices_count
;
3200 devices
= g_out_map
;
3202 count
= g_inmmdevices_count
;
3207 return MMSYSERR_INVALHANDLE
;
3209 EnterCriticalSection(&g_devthread_lock
);
3210 id_len
= (lstrlenW(devices
[device
]->dev_id
) + 1) * sizeof(WCHAR
);
3212 LeaveCriticalSection(&g_devthread_lock
);
3213 return MMSYSERR_ERROR
;
3216 memcpy(str
, devices
[device
]->dev_id
, id_len
);
3217 LeaveCriticalSection(&g_devthread_lock
);
3219 return MMSYSERR_NOERROR
;
3222 static UINT
get_device_interface(UINT msg
, BOOL is_out
, UINT index
, WCHAR
*out
, ULONG
*out_len
)
3224 WINMM_QueryInterfaceInfo info
;
3227 if(!WINMM_StartDevicesThread())
3228 return MMSYSERR_NODRIVER
;
3230 info
.is_out
= is_out
;
3233 info
.len_bytes
= out_len
;
3235 ret
= SendMessageW(g_devices_hwnd
, msg
, (DWORD_PTR
)&info
, 0);
3236 InterlockedDecrement(&g_devthread_token
);
3240 /**************************************************************************
3241 * waveOutMessage [WINMM.@]
3243 UINT WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
3244 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3246 TRACE("(%p, %u, %Ix, %Ix)\n", hWaveOut
, uMessage
, dwParam1
, dwParam2
);
3249 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
3250 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut
),
3251 (DWORD_PTR
*)dwParam1
, TRUE
);
3252 case DRV_QUERYFUNCTIONINSTANCEID
:
3253 return WINMM_QueryInstanceID(HandleToULong(hWaveOut
), (WCHAR
*)dwParam1
, dwParam2
, TRUE
);
3254 case DRV_QUERYDEVICEINTERFACESIZE
:
3255 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE
, TRUE
, HandleToULong(hWaveOut
),
3256 NULL
, (ULONG
*)dwParam1
);
3257 case DRV_QUERYDEVICEINTERFACE
:
3259 ULONG size
= dwParam2
;
3260 return get_device_interface(DRV_QUERYDEVICEINTERFACE
, TRUE
, HandleToULong(hWaveOut
),
3261 (WCHAR
*)dwParam1
, &size
);
3263 case DRV_QUERYMAPPABLE
:
3264 return MMSYSERR_NOERROR
;
3265 case DRVM_MAPPER_PREFERRED_GET
:
3266 if(!dwParam1
|| !dwParam2
)
3267 return MMSYSERR_INVALPARAM
;
3269 if(g_outmmdevices_count
> 0)
3270 /* Device 0 is always the default device */
3271 *(DWORD
*)dwParam1
= 0;
3273 *(DWORD
*)dwParam1
= -1;
3276 *(DWORD
*)dwParam2
= 0;
3278 return MMSYSERR_NOERROR
;
3281 TRACE("Message not supported: %u\n", uMessage
);
3283 return MMSYSERR_NOTSUPPORTED
;
3286 /**************************************************************************
3287 * waveInGetNumDevs [WINMM.@]
3289 UINT WINAPI
waveInGetNumDevs(void)
3291 HRESULT hr
= WINMM_InitMMDevices();
3295 TRACE("count: %u\n", g_inmmdevices_count
);
3297 return g_inmmdevices_count
;
3300 /**************************************************************************
3301 * waveInGetDevCapsW [WINMM.@]
3303 UINT WINAPI
waveInGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
3305 WAVEINCAPSW mapper_caps
, *caps
;
3308 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3310 hr
= WINMM_InitMMDevices();
3312 return MMSYSERR_NODRIVER
;
3315 return MMSYSERR_INVALPARAM
;
3317 if(WINMM_IsMapper(uDeviceID
)){
3318 mapper_caps
.wMid
= 0xFF;
3319 mapper_caps
.wPid
= 0xFF;
3320 mapper_caps
.vDriverVersion
= 0x00010001;
3321 mapper_caps
.dwFormats
= 0xFFFFFFFF;
3322 mapper_caps
.wReserved1
= 0;
3323 mapper_caps
.wChannels
= 2;
3324 LoadStringW(hWinMM32Instance
, IDS_MAPPER_NAME
, mapper_caps
.szPname
, MAXPNAMELEN
);
3326 caps
= &mapper_caps
;
3328 if(uDeviceID
>= g_inmmdevices_count
){
3329 WINMM_Device
*device
= WINMM_GetDeviceFromHWAVE((HWAVE
)uDeviceID
);
3331 if(!WINMM_ValidateAndLock(device
))
3332 return MMSYSERR_BADDEVICEID
;
3334 caps
= &device
->parent
->in_caps
;
3336 LeaveCriticalSection(&device
->lock
);
3338 caps
= &read_map(g_in_map
, uDeviceID
)->in_caps
;
3342 memcpy(lpCaps
, caps
, min(uSize
, sizeof(*lpCaps
)));
3344 return MMSYSERR_NOERROR
;
3347 /**************************************************************************
3348 * waveInGetDevCapsA [WINMM.@]
3350 UINT WINAPI
waveInGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
3355 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3358 return MMSYSERR_INVALPARAM
;
3360 ret
= waveInGetDevCapsW(uDeviceID
, &wicW
, sizeof(wicW
));
3362 if (ret
== MMSYSERR_NOERROR
) {
3364 wicA
.wMid
= wicW
.wMid
;
3365 wicA
.wPid
= wicW
.wPid
;
3366 wicA
.vDriverVersion
= wicW
.vDriverVersion
;
3367 WideCharToMultiByte( CP_ACP
, 0, wicW
.szPname
, -1, wicA
.szPname
,
3368 sizeof(wicA
.szPname
), NULL
, NULL
);
3369 wicA
.dwFormats
= wicW
.dwFormats
;
3370 wicA
.wChannels
= wicW
.wChannels
;
3371 wicA
.wReserved1
= wicW
.wReserved1
;
3372 memcpy(lpCaps
, &wicA
, min(uSize
, sizeof(wicA
)));
3377 /**************************************************************************
3378 * waveInOpen [WINMM.@]
3380 MMRESULT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
3381 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
3382 DWORD_PTR dwInstance
, DWORD dwFlags
)
3385 WINMM_OpenInfo info
;
3386 WINMM_CBInfo cb_info
;
3388 TRACE("(%p, %x, %p, %Ix, %Ix, %08lx)\n", lphWaveIn
, uDeviceID
, lpFormat
,
3389 dwCallback
, dwInstance
, dwFlags
);
3391 if(!lphWaveIn
&& !(dwFlags
& WAVE_FORMAT_QUERY
))
3392 return MMSYSERR_INVALPARAM
;
3394 res
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
3395 if(res
!= MMSYSERR_NOERROR
)
3398 if(!WINMM_StartDevicesThread())
3399 return MMSYSERR_NODRIVER
;
3402 info
.format
= (WAVEFORMATEX
*)lpFormat
;
3403 info
.callback
= dwCallback
;
3404 info
.cb_user
= dwInstance
;
3405 info
.req_device
= uDeviceID
;
3406 info
.flags
= dwFlags
;
3409 res
= SendMessageW(g_devices_hwnd
, WIDM_OPEN
, (DWORD_PTR
)&info
, 0);
3410 InterlockedDecrement(&g_devthread_token
);
3411 if(res
!= MMSYSERR_NOERROR
|| (dwFlags
& WAVE_FORMAT_QUERY
))
3415 *lphWaveIn
= (HWAVEIN
)info
.handle
;
3417 cb_info
.flags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
3418 cb_info
.callback
= dwCallback
;
3419 cb_info
.user
= dwInstance
;
3420 cb_info
.hwave
= info
.handle
;
3422 WINMM_NotifyClient(&cb_info
, WIM_OPEN
, 0, 0);
3427 /**************************************************************************
3428 * waveInClose [WINMM.@]
3430 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
3432 WINMM_Device
*device
;
3433 WINMM_CBInfo cb_info
;
3436 TRACE("(%p)\n", hWaveIn
);
3438 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3440 if(!WINMM_ValidateAndLock(device
))
3441 return MMSYSERR_INVALHANDLE
;
3443 cb_info
= device
->cb_info
;
3445 LeaveCriticalSection(&device
->lock
);
3447 res
= SendMessageW(g_devices_hwnd
, WIDM_CLOSE
, (WPARAM
)hWaveIn
, 0);
3449 if(res
== MMSYSERR_NOERROR
)
3450 WINMM_NotifyClient(&cb_info
, WIM_CLOSE
, 0, 0);
3455 /**************************************************************************
3456 * waveInPrepareHeader [WINMM.@]
3458 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3461 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3463 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3464 return MMSYSERR_INVALPARAM
;
3466 if(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
)
3467 return MMSYSERR_NOERROR
;
3469 return WINMM_PrepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3472 /**************************************************************************
3473 * waveInUnprepareHeader [WINMM.@]
3475 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
3478 TRACE("(%p, %p, %u)\n", hWaveIn
, lpWaveInHdr
, uSize
);
3480 if(!lpWaveInHdr
|| uSize
< sizeof(WAVEHDR
))
3481 return MMSYSERR_INVALPARAM
;
3483 if(lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
3484 return WAVERR_STILLPLAYING
;
3486 if(!(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
))
3487 return MMSYSERR_NOERROR
;
3489 return WINMM_UnprepareHeader((HWAVE
)hWaveIn
, lpWaveInHdr
);
3492 /**************************************************************************
3493 * waveInAddBuffer [WINMM.@]
3495 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
, WAVEHDR
*header
, UINT uSize
)
3497 WINMM_Device
*device
;
3499 TRACE("(%p, %p, %u)\n", hWaveIn
, header
, uSize
);
3501 if(!header
|| uSize
< sizeof(WAVEHDR
))
3502 return MMSYSERR_INVALPARAM
;
3504 if(!(header
->dwFlags
& WHDR_PREPARED
))
3505 return WAVERR_UNPREPARED
;
3507 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3509 if(!WINMM_ValidateAndLock(device
))
3510 return MMSYSERR_INVALHANDLE
;
3513 device
->first
= device
->last
= header
;
3515 device
->last
->lpNext
= header
;
3516 device
->last
= header
;
3519 header
->dwBytesRecorded
= 0;
3520 header
->lpNext
= NULL
;
3521 header
->dwFlags
&= ~WHDR_DONE
;
3522 header
->dwFlags
|= WHDR_INQUEUE
;
3524 LeaveCriticalSection(&device
->lock
);
3526 return MMSYSERR_NOERROR
;
3529 /**************************************************************************
3530 * waveInReset [WINMM.@]
3532 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
3534 TRACE("(%p)\n", hWaveIn
);
3536 return WINMM_Reset((HWAVE
)hWaveIn
);
3539 /**************************************************************************
3540 * waveInStart [WINMM.@]
3542 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
3544 WINMM_Device
*device
;
3547 TRACE("(%p)\n", hWaveIn
);
3549 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3551 if(!WINMM_ValidateAndLock(device
))
3552 return MMSYSERR_INVALHANDLE
;
3554 mr
= WINMM_BeginPlaying(device
);
3556 LeaveCriticalSection(&device
->lock
);
3561 /**************************************************************************
3562 * waveInStop [WINMM.@]
3564 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
3566 WINMM_CBInfo cb_info
;
3567 WINMM_Device
*device
;
3571 TRACE("(%p)\n", hWaveIn
);
3573 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3575 if(!WINMM_ValidateAndLock(device
))
3576 return MMSYSERR_INVALHANDLE
;
3578 hr
= WINMM_Pause(device
);
3580 LeaveCriticalSection(&device
->lock
);
3581 return MMSYSERR_ERROR
;
3583 device
->stopped
= TRUE
;
3585 buf
= device
->first
;
3586 if(buf
&& buf
->dwBytesRecorded
> 0){
3587 device
->first
= buf
->lpNext
;
3591 cb_info
= device
->cb_info
;
3593 LeaveCriticalSection(&device
->lock
);
3596 buf
->dwFlags
&= ~WHDR_INQUEUE
;
3597 buf
->dwFlags
|= WHDR_DONE
;
3598 WINMM_NotifyClient(&cb_info
, WIM_DATA
, (DWORD_PTR
)buf
, 0);
3601 return MMSYSERR_NOERROR
;
3604 /**************************************************************************
3605 * waveInGetPosition [WINMM.@]
3607 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
3610 TRACE("(%p, %p, %u)\n", hWaveIn
, lpTime
, uSize
);
3612 if(!uSize
|| !lpTime
)
3613 return MMSYSERR_INVALPARAM
;
3615 if(uSize
< sizeof(MMTIME
))
3616 return MMSYSERR_ERROR
;
3618 return WINMM_GetPosition((HWAVE
)hWaveIn
, lpTime
);
3621 /**************************************************************************
3622 * waveInGetID [WINMM.@]
3624 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
3628 WINMM_Device
*device
;
3630 TRACE("(%p, %p)\n", hWaveIn
, lpuDeviceID
);
3633 return MMSYSERR_INVALPARAM
;
3635 device
= WINMM_GetDeviceFromHWAVE((HWAVE
)hWaveIn
);
3636 if(!WINMM_ValidateAndLock(device
))
3637 return MMSYSERR_INVALHANDLE
;
3639 LeaveCriticalSection(&device
->lock
);
3641 WINMM_DecomposeHWAVE((HWAVE
)hWaveIn
, lpuDeviceID
, &is_out
, &dev
, &junk
);
3643 return MMSYSERR_NOERROR
;
3646 /**************************************************************************
3647 * waveInMessage [WINMM.@]
3649 UINT WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
3650 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3652 TRACE("(%p, %u, %Id, %Id)\n", hWaveIn
, uMessage
, dwParam1
, dwParam2
);
3655 case DRV_QUERYFUNCTIONINSTANCEIDSIZE
:
3656 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn
),
3657 (DWORD_PTR
*)dwParam1
, FALSE
);
3658 case DRV_QUERYFUNCTIONINSTANCEID
:
3659 return WINMM_QueryInstanceID(HandleToULong(hWaveIn
), (WCHAR
*)dwParam1
, dwParam2
, FALSE
);
3660 case DRV_QUERYDEVICEINTERFACESIZE
:
3661 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE
, FALSE
, HandleToULong(hWaveIn
),
3662 NULL
, (ULONG
*)dwParam1
);
3663 case DRV_QUERYDEVICEINTERFACE
:
3665 ULONG size
= dwParam2
;
3666 return get_device_interface(DRV_QUERYDEVICEINTERFACE
, FALSE
, HandleToULong(hWaveIn
),
3667 (WCHAR
*)dwParam1
, &size
);
3669 case DRV_QUERYMAPPABLE
:
3670 return MMSYSERR_NOERROR
;
3671 case DRVM_MAPPER_PREFERRED_GET
:
3672 if(!dwParam1
|| !dwParam2
)
3673 return MMSYSERR_INVALPARAM
;
3675 if(g_inmmdevices_count
> 0)
3676 /* Device 0 is always the default device */
3677 *(DWORD
*)dwParam1
= 0;
3679 *(DWORD
*)dwParam1
= -1;
3682 *(DWORD
*)dwParam2
= 0;
3684 return MMSYSERR_NOERROR
;
3687 TRACE("Message not supported: %u\n", uMessage
);
3689 return MMSYSERR_NOTSUPPORTED
;
3692 UINT WINAPI
mixerGetNumDevs(void)
3698 hr
= WINMM_InitMMDevices();
3702 return g_outmmdevices_count
+ g_inmmdevices_count
;
3705 /**************************************************************************
3706 * mixerGetDevCapsA [WINMM.@]
3708 UINT WINAPI
mixerGetDevCapsA(UINT_PTR uDeviceID
, LPMIXERCAPSA lpCaps
, UINT uSize
)
3713 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3716 return MMSYSERR_INVALPARAM
;
3718 ret
= mixerGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
3720 if (ret
== MMSYSERR_NOERROR
) {
3722 micA
.wMid
= micW
.wMid
;
3723 micA
.wPid
= micW
.wPid
;
3724 micA
.vDriverVersion
= micW
.vDriverVersion
;
3725 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
3726 sizeof(micA
.szPname
), NULL
, NULL
);
3727 micA
.fdwSupport
= micW
.fdwSupport
;
3728 micA
.cDestinations
= micW
.cDestinations
;
3729 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
3734 /**************************************************************************
3735 * mixerGetDevCapsW [WINMM.@]
3737 UINT WINAPI
mixerGetDevCapsW(UINT_PTR uDeviceID
, LPMIXERCAPSW lpCaps
, UINT uSize
)
3739 WINMM_MMDevice
*mmdevice
;
3743 TRACE("(%Iu, %p, %u)\n", uDeviceID
, lpCaps
, uSize
);
3745 hr
= WINMM_InitMMDevices();
3747 return MMSYSERR_NODRIVER
;
3750 return MMSYSERR_INVALPARAM
;
3753 return MMSYSERR_NOERROR
;
3755 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3756 mmdevice
= WINMM_GetMixerMMDevice((HMIXEROBJ
)uDeviceID
,
3757 MIXER_OBJECTF_MIXER
, NULL
);
3758 else if(uDeviceID
< g_outmmdevices_count
)
3759 mmdevice
= read_map(g_out_map
, uDeviceID
);
3761 mmdevice
= read_map(g_in_map
, uDeviceID
- g_outmmdevices_count
);
3764 return MMSYSERR_BADDEVICEID
;
3766 if(mmdevice
->dataflow
== eRender
)
3767 memcpy(caps
.szPname
, mmdevice
->out_caps
.szPname
, sizeof(caps
.szPname
));
3769 memcpy(caps
.szPname
, mmdevice
->in_caps
.szPname
, sizeof(caps
.szPname
));
3773 caps
.vDriverVersion
= 0x00010001;
3774 caps
.fdwSupport
= 0;
3775 caps
.cDestinations
= 1;
3777 memcpy(lpCaps
, &caps
, uSize
);
3779 return MMSYSERR_NOERROR
;
3782 /**************************************************************************
3783 * mixerOpen [WINMM.@]
3785 UINT WINAPI
mixerOpen(LPHMIXER lphMix
, UINT uDeviceID
, DWORD_PTR dwCallback
,
3786 DWORD_PTR dwInstance
, DWORD fdwOpen
)
3788 WINMM_MMDevice
*mmdevice
;
3792 TRACE("(%p, %d, %Ix, %Ix, %lx)\n", lphMix
, uDeviceID
, dwCallback
,
3793 dwInstance
, fdwOpen
);
3795 hr
= WINMM_InitMMDevices();
3797 return MMSYSERR_NODRIVER
;
3800 return MMSYSERR_INVALPARAM
;
3802 mr
= WINMM_CheckCallback(dwCallback
, fdwOpen
, TRUE
);
3803 if(mr
!= MMSYSERR_NOERROR
)
3806 if(uDeviceID
>= g_outmmdevices_count
+ g_inmmdevices_count
)
3807 return MMSYSERR_BADDEVICEID
;
3809 if(uDeviceID
< g_outmmdevices_count
){
3810 mmdevice
= read_map(g_out_map
, uDeviceID
);
3811 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
, TRUE
,
3812 mmdevice
->mixer_count
);
3814 mmdevice
= read_map(g_in_map
, uDeviceID
- g_outmmdevices_count
);
3815 *lphMix
= (HMIXER
)WINMM_MakeHWAVE(uDeviceID
- g_outmmdevices_count
,
3816 FALSE
, mmdevice
->mixer_count
);
3819 ++mmdevice
->mixer_count
;
3821 return MMSYSERR_NOERROR
;
3824 /**************************************************************************
3825 * mixerClose [WINMM.@]
3827 UINT WINAPI
mixerClose(HMIXER hMix
)
3829 TRACE("(%p)\n", hMix
);
3831 return MMSYSERR_NOERROR
;
3834 /**************************************************************************
3835 * mixerGetID [WINMM.@]
3837 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
3839 WINMM_MMDevice
*mmdevice
;
3842 TRACE("(%p, %p, %lx)\n", hmix
, lpid
, fdwID
);
3844 hr
= WINMM_InitMMDevices();
3846 return MMSYSERR_NODRIVER
;
3849 return MMSYSERR_INVALPARAM
;
3851 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwID
, lpid
);
3853 return MMSYSERR_INVALHANDLE
;
3855 if(mmdevice
->in_caps
.szPname
[0] != '\0')
3856 *lpid
+= g_outmmdevices_count
;
3858 return MMSYSERR_NOERROR
;
3861 /**************************************************************************
3862 * mixerGetControlDetailsW [WINMM.@]
3864 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdW
,
3867 WINMM_ControlDetails details
;
3869 TRACE("(%p, %p, %lx)\n", hmix
, lpmcdW
, fdwDetails
);
3871 if(!WINMM_StartDevicesThread())
3872 return MMSYSERR_NODRIVER
;
3874 if(!lpmcdW
|| !lpmcdW
->paDetails
)
3875 return MMSYSERR_INVALPARAM
;
3877 TRACE("dwControlID: %lu\n", lpmcdW
->dwControlID
);
3879 details
.hmix
= hmix
;
3880 details
.details
= lpmcdW
;
3881 details
.flags
= fdwDetails
;
3883 return SendMessageW(g_devices_hwnd
, MXDM_GETCONTROLDETAILS
,
3884 (DWORD_PTR
)&details
, 0);
3887 /**************************************************************************
3888 * mixerGetControlDetailsA [WINMM.@]
3890 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
,
3893 UINT ret
= MMSYSERR_NOTSUPPORTED
;
3895 TRACE("(%p, %p, %08lx)\n", hmix
, lpmcdA
, fdwDetails
);
3897 if (lpmcdA
== NULL
|| lpmcdA
->cbStruct
!= sizeof(*lpmcdA
))
3898 return MMSYSERR_INVALPARAM
;
3900 switch (fdwDetails
& MIXER_GETCONTROLDETAILSF_QUERYMASK
) {
3901 case MIXER_GETCONTROLDETAILSF_VALUE
:
3902 /* can safely use A structure as it is, no string inside */
3903 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3905 case MIXER_GETCONTROLDETAILSF_LISTTEXT
:
3907 MIXERCONTROLDETAILS_LISTTEXTA
*pDetailsA
= lpmcdA
->paDetails
;
3908 MIXERCONTROLDETAILS_LISTTEXTW
*pDetailsW
;
3909 int size
= max(1, lpmcdA
->cChannels
) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3912 if (lpmcdA
->cMultipleItems
!= 0) {
3913 size
*= lpmcdA
->cMultipleItems
;
3915 pDetailsW
= malloc(size
);
3916 lpmcdA
->paDetails
= pDetailsW
;
3917 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
3918 /* set up lpmcd->paDetails */
3919 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
3920 /* copy from lpmcd->paDetails back to paDetailsW; */
3921 if (ret
== MMSYSERR_NOERROR
) {
3922 for (i
= 0; i
< lpmcdA
->cMultipleItems
* lpmcdA
->cChannels
; i
++) {
3923 pDetailsA
->dwParam1
= pDetailsW
->dwParam1
;
3924 pDetailsA
->dwParam2
= pDetailsW
->dwParam2
;
3925 WideCharToMultiByte( CP_ACP
, 0, pDetailsW
->szName
, -1,
3927 sizeof(pDetailsA
->szName
), NULL
, NULL
);
3931 pDetailsA
-= lpmcdA
->cMultipleItems
* lpmcdA
->cChannels
;
3932 pDetailsW
-= lpmcdA
->cMultipleItems
* lpmcdA
->cChannels
;
3935 lpmcdA
->paDetails
= pDetailsA
;
3936 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTA
);
3940 WARN("Unsupported fdwDetails=0x%08lx\n", fdwDetails
);
3946 /**************************************************************************
3947 * mixerGetLineControlsA [WINMM.@]
3949 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
, LPMIXERLINECONTROLSA lpmlcA
,
3952 MIXERLINECONTROLSW mlcW
;
3956 TRACE("(%p, %p, %lx)\n", hmix
, lpmlcA
, fdwControls
);
3958 if (lpmlcA
== NULL
|| lpmlcA
->cbStruct
!= sizeof(*lpmlcA
) ||
3959 lpmlcA
->cbmxctrl
!= sizeof(MIXERCONTROLA
))
3960 return MMSYSERR_INVALPARAM
;
3962 mlcW
.cbStruct
= sizeof(mlcW
);
3963 mlcW
.dwLineID
= lpmlcA
->dwLineID
;
3964 mlcW
.dwControlID
= lpmlcA
->dwControlID
;
3965 mlcW
.dwControlType
= lpmlcA
->dwControlType
;
3967 /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3968 the control count is assumed to be 1 - This is relied upon by a game,
3969 "Dynomite Deluze" */
3970 if (MIXER_GETLINECONTROLSF_ONEBYTYPE
== (fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
)) {
3973 mlcW
.cControls
= lpmlcA
->cControls
;
3975 mlcW
.cbmxctrl
= sizeof(MIXERCONTROLW
);
3976 mlcW
.pamxctrl
= malloc(mlcW
.cControls
* mlcW
.cbmxctrl
);
3978 ret
= mixerGetLineControlsW(hmix
, &mlcW
, fdwControls
);
3980 if (ret
== MMSYSERR_NOERROR
) {
3981 lpmlcA
->dwLineID
= mlcW
.dwLineID
;
3982 lpmlcA
->dwControlID
= mlcW
.dwControlID
;
3983 lpmlcA
->dwControlType
= mlcW
.dwControlType
;
3985 for (i
= 0; i
< mlcW
.cControls
; i
++) {
3986 lpmlcA
->pamxctrl
[i
].cbStruct
= sizeof(MIXERCONTROLA
);
3987 lpmlcA
->pamxctrl
[i
].dwControlID
= mlcW
.pamxctrl
[i
].dwControlID
;
3988 lpmlcA
->pamxctrl
[i
].dwControlType
= mlcW
.pamxctrl
[i
].dwControlType
;
3989 lpmlcA
->pamxctrl
[i
].fdwControl
= mlcW
.pamxctrl
[i
].fdwControl
;
3990 lpmlcA
->pamxctrl
[i
].cMultipleItems
= mlcW
.pamxctrl
[i
].cMultipleItems
;
3991 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szShortName
, -1,
3992 lpmlcA
->pamxctrl
[i
].szShortName
,
3993 sizeof(lpmlcA
->pamxctrl
[i
].szShortName
), NULL
, NULL
);
3994 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szName
, -1,
3995 lpmlcA
->pamxctrl
[i
].szName
,
3996 sizeof(lpmlcA
->pamxctrl
[i
].szName
), NULL
, NULL
);
3997 /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3998 * sizeof(mlcW.pamxctrl[i].Bounds) */
3999 memcpy(&lpmlcA
->pamxctrl
[i
].Bounds
, &mlcW
.pamxctrl
[i
].Bounds
,
4000 sizeof(mlcW
.pamxctrl
[i
].Bounds
));
4001 /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
4002 * sizeof(mlcW.pamxctrl[i].Metrics) */
4003 memcpy(&lpmlcA
->pamxctrl
[i
].Metrics
, &mlcW
.pamxctrl
[i
].Metrics
,
4004 sizeof(mlcW
.pamxctrl
[i
].Metrics
));
4008 free(mlcW
.pamxctrl
);
4013 static UINT
WINMM_GetVolumeLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
4014 MIXERCONTROLW
*ctl
, DWORD flags
)
4016 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 0 : 2;
4017 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_VOLUME
;
4018 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
4019 ctl
->cMultipleItems
= 0;
4020 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, ctl
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4021 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, ctl
->szName
, MIXER_LONG_NAME_CHARS
);
4022 ctl
->Bounds
.dwMinimum
= 0;
4023 ctl
->Bounds
.dwMaximum
= 0xFFFF;
4024 ctl
->Metrics
.cSteps
= 192;
4026 return MMSYSERR_NOERROR
;
4029 static UINT
WINMM_GetMuteLineControl(WINMM_MMDevice
*mmdevice
, DWORD line
,
4030 MIXERCONTROLW
*ctl
, DWORD flags
)
4032 ctl
->dwControlID
= (line
== 0xFFFF0000) ? 1 : 3;
4033 ctl
->dwControlType
= MIXERCONTROL_CONTROLTYPE_MUTE
;
4034 ctl
->fdwControl
= MIXERCONTROL_CONTROLF_UNIFORM
;
4035 ctl
->cMultipleItems
= 0;
4036 LoadStringW(hWinMM32Instance
, IDS_MUTE
, ctl
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4037 LoadStringW(hWinMM32Instance
, IDS_MUTE
, ctl
->szName
, MIXER_LONG_NAME_CHARS
);
4038 ctl
->Bounds
.dwMinimum
= 0;
4039 ctl
->Bounds
.dwMaximum
= 1;
4040 ctl
->Metrics
.cSteps
= 0;
4042 return MMSYSERR_NOERROR
;
4045 /**************************************************************************
4046 * mixerGetLineControlsW [WINMM.@]
4048 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
, LPMIXERLINECONTROLSW lpmlcW
,
4051 WINMM_MMDevice
*mmdevice
;
4054 TRACE("(%p, %p, %08lx)\n", hmix
, lpmlcW
, fdwControls
);
4056 hr
= WINMM_InitMMDevices();
4058 return MMSYSERR_NODRIVER
;
4060 if(fdwControls
& ~(MIXER_GETLINECONTROLSF_ALL
|
4061 MIXER_GETLINECONTROLSF_ONEBYID
|
4062 MIXER_GETLINECONTROLSF_ONEBYTYPE
|
4063 MIXER_OBJECTF_HMIXER
|
4064 MIXER_OBJECTF_MIXER
)){
4065 WARN("Unknown GetLineControls flag: %lx\n", fdwControls
);
4066 return MMSYSERR_INVALFLAG
;
4069 if(!lpmlcW
|| lpmlcW
->cbStruct
< sizeof(*lpmlcW
) || !lpmlcW
->pamxctrl
)
4070 return MMSYSERR_INVALPARAM
;
4072 TRACE("dwLineID: %lu\n", lpmlcW
->dwLineID
);
4073 TRACE("dwControl: %lx\n", lpmlcW
->dwControlID
);
4074 TRACE("cControls: %lu\n", lpmlcW
->cControls
);
4076 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwControls
, NULL
);
4078 return MMSYSERR_INVALHANDLE
;
4080 switch(fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
){
4081 case MIXER_GETLINECONTROLSF_ALL
:
4082 if(lpmlcW
->cControls
!= 2)
4083 return MMSYSERR_INVALPARAM
;
4084 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4085 return MMSYSERR_INVALPARAM
;
4086 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4087 return MIXERR_INVALLINE
;
4088 WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4089 &lpmlcW
->pamxctrl
[0], fdwControls
);
4090 WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4091 &lpmlcW
->pamxctrl
[1], fdwControls
);
4092 return MMSYSERR_NOERROR
;
4093 case MIXER_GETLINECONTROLSF_ONEBYID
:
4094 if(lpmlcW
->cControls
!= 1)
4095 return MMSYSERR_INVALPARAM
;
4096 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4097 return MMSYSERR_INVALPARAM
;
4098 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4099 return MIXERR_INVALLINE
;
4100 if(lpmlcW
->dwControlID
== 0)
4101 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4102 lpmlcW
->pamxctrl
, fdwControls
);
4103 if(lpmlcW
->dwControlID
== 1)
4104 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4105 lpmlcW
->pamxctrl
, fdwControls
);
4106 return MMSYSERR_NOTSUPPORTED
;
4107 case MIXER_GETLINECONTROLSF_ONEBYTYPE
:
4108 if(lpmlcW
->cControls
!= 1)
4109 return MMSYSERR_INVALPARAM
;
4110 if(lpmlcW
->cbmxctrl
< sizeof(MIXERCONTROLW
))
4111 return MMSYSERR_INVALPARAM
;
4112 if(lpmlcW
->dwLineID
!= 0 && lpmlcW
->dwLineID
!= 0xFFFF0000)
4113 return MIXERR_INVALLINE
;
4114 if(lpmlcW
->dwControlType
== MIXERCONTROL_CONTROLTYPE_VOLUME
)
4115 return WINMM_GetVolumeLineControl(mmdevice
, lpmlcW
->dwLineID
,
4116 lpmlcW
->pamxctrl
, fdwControls
);
4117 if(lpmlcW
->dwControlType
== MIXERCONTROL_CONTROLTYPE_MUTE
)
4118 return WINMM_GetMuteLineControl(mmdevice
, lpmlcW
->dwLineID
,
4119 lpmlcW
->pamxctrl
, fdwControls
);
4120 return MMSYSERR_NOTSUPPORTED
;
4123 return MMSYSERR_NOTSUPPORTED
;
4126 static UINT
WINMM_GetSourceLineInfo(WINMM_MMDevice
*mmdevice
, UINT mmdev_index
,
4127 MIXERLINEW
*info
, DWORD flags
)
4130 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4133 if(info
->dwSource
!= 0)
4134 return MIXERR_INVALLINE
;
4136 info
->dwDestination
= 0;
4138 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
| MIXERLINE_LINEF_SOURCE
;
4139 info
->cConnections
= 0;
4140 info
->cControls
= 2;
4141 /* volume & mute always affect all channels, so claim 1 channel */
4142 info
->cChannels
= 1;
4143 info
->Target
.dwDeviceID
= mmdev_index
;
4144 info
->Target
.wMid
= ~0;
4145 info
->Target
.wPid
= ~0;
4146 info
->Target
.vDriverVersion
= 0;
4148 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, info
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4149 LoadStringW(hWinMM32Instance
, IDS_MASTER_VOLUME
, info
->szName
, MIXER_LONG_NAME_CHARS
);
4152 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
;
4153 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEOUT
;
4154 memcpy(info
->Target
.szPname
, mmdevice
->out_caps
.szPname
,
4155 sizeof(info
->Target
.szPname
));
4157 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE
;
4158 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
4159 info
->Target
.szPname
[0] = '\0';
4162 return MMSYSERR_NOERROR
;
4165 static UINT
WINMM_GetDestinationLineInfo(WINMM_MMDevice
*mmdevice
,
4166 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4169 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4172 if(info
->dwDestination
!= 0)
4173 return MIXERR_INVALLINE
;
4175 info
->dwSource
= 0xFFFFFFFF;
4176 info
->dwLineID
= 0xFFFF0000;
4177 info
->fdwLine
= MIXERLINE_LINEF_ACTIVE
;
4178 info
->cConnections
= 1;
4179 info
->cControls
= 2;
4181 LoadStringW(hWinMM32Instance
, IDS_VOLUME
, info
->szShortName
, MIXER_SHORT_NAME_CHARS
);
4182 LoadStringW(hWinMM32Instance
, IDS_MASTER_VOLUME
, info
->szName
, MIXER_LONG_NAME_CHARS
);
4184 info
->Target
.dwDeviceID
= mmdev_index
;
4185 info
->Target
.wMid
= ~0;
4186 info
->Target
.wPid
= ~0;
4187 info
->Target
.vDriverVersion
= 0;
4190 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
;
4191 info
->cChannels
= mmdevice
->out_caps
.wChannels
;
4192 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_UNDEFINED
;
4193 info
->Target
.szPname
[0] = '\0';
4195 info
->dwComponentType
= MIXERLINE_COMPONENTTYPE_DST_WAVEIN
;
4196 info
->cChannels
= mmdevice
->in_caps
.wChannels
;
4197 info
->Target
.dwType
= MIXERLINE_TARGETTYPE_WAVEIN
;
4198 memcpy(info
->Target
.szPname
, mmdevice
->in_caps
.szPname
,
4199 sizeof(info
->Target
.szPname
));
4202 return MMSYSERR_NOERROR
;
4205 static UINT
WINMM_GetComponentTypeLineInfo(WINMM_MMDevice
*mmdevice
,
4206 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4209 if(mmdevice
->in_caps
.szPname
[0] != '\0')
4212 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_WAVEIN
){
4214 return MIXERR_INVALLINE
;
4215 info
->dwDestination
= 0;
4216 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4219 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_DST_SPEAKERS
){
4221 return MIXERR_INVALLINE
;
4222 info
->dwDestination
= 0;
4223 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4226 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE
){
4228 return MIXERR_INVALLINE
;
4230 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4233 if(info
->dwComponentType
== MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT
){
4235 return MIXERR_INVALLINE
;
4237 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4240 TRACE("Returning INVALLINE on this component type: %lu\n",
4241 info
->dwComponentType
);
4243 return MIXERR_INVALLINE
;
4246 static UINT
WINMM_GetLineIDLineInfo(WINMM_MMDevice
*mmdevice
,
4247 UINT mmdev_index
, MIXERLINEW
*info
, DWORD flags
)
4249 if(info
->dwLineID
== 0xFFFF0000){
4250 info
->dwDestination
= 0;
4251 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4254 if(info
->dwLineID
== 0){
4256 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, info
, flags
);
4259 TRACE("Returning INVALLINE on this dwLineID: %lu\n", info
->dwLineID
);
4260 return MIXERR_INVALLINE
;
4263 /**************************************************************************
4264 * mixerGetLineInfoW [WINMM.@]
4266 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpmliW
, DWORD fdwInfo
)
4269 WINMM_MMDevice
*mmdevice
;
4272 TRACE("(%p, %p, %lx)\n", hmix
, lpmliW
, fdwInfo
);
4274 hr
= WINMM_InitMMDevices();
4276 return MMSYSERR_NODRIVER
;
4278 if(!lpmliW
|| lpmliW
->cbStruct
< sizeof(MIXERLINEW
))
4279 return MMSYSERR_INVALPARAM
;
4281 TRACE("dwDestination: %lu\n", lpmliW
->dwDestination
);
4282 TRACE("dwSource: %lu\n", lpmliW
->dwSource
);
4283 TRACE("dwLineID: %lu\n", lpmliW
->dwLineID
);
4284 TRACE("fdwLine: 0x%lx\n", lpmliW
->fdwLine
);
4285 TRACE("dwComponentType: 0x%lx\n", lpmliW
->dwComponentType
);
4287 if(fdwInfo
& ~(MIXER_GETLINEINFOF_COMPONENTTYPE
|
4288 MIXER_GETLINEINFOF_DESTINATION
|
4289 MIXER_GETLINEINFOF_LINEID
|
4290 MIXER_GETLINEINFOF_SOURCE
|
4291 MIXER_GETLINEINFOF_TARGETTYPE
|
4292 MIXER_OBJECTF_HMIXER
|
4293 MIXER_OBJECTF_MIXER
)){
4294 WARN("Unknown GetLineInfo flag: %lx\n", fdwInfo
);
4295 return MMSYSERR_INVALFLAG
;
4298 mmdevice
= WINMM_GetMixerMMDevice(hmix
, fdwInfo
, &mmdev_index
);
4300 return MMSYSERR_INVALHANDLE
;
4304 switch(fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
){
4305 case MIXER_GETLINEINFOF_DESTINATION
:
4306 return WINMM_GetDestinationLineInfo(mmdevice
, mmdev_index
, lpmliW
,
4308 case MIXER_GETLINEINFOF_SOURCE
:
4309 return WINMM_GetSourceLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
4310 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
4311 return WINMM_GetComponentTypeLineInfo(mmdevice
, mmdev_index
, lpmliW
,
4313 case MIXER_GETLINEINFOF_LINEID
:
4314 return WINMM_GetLineIDLineInfo(mmdevice
, mmdev_index
, lpmliW
, fdwInfo
);
4315 case MIXER_GETLINEINFOF_TARGETTYPE
:
4316 FIXME("TARGETTYPE flag not implemented!\n");
4317 return MIXERR_INVALLINE
;
4320 TRACE("Returning INVALFLAG on these flags: %lx\n", fdwInfo
);
4321 return MMSYSERR_INVALFLAG
;
4324 /**************************************************************************
4325 * mixerGetLineInfoA [WINMM.@]
4327 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
, LPMIXERLINEA lpmliA
,
4333 TRACE("(%p, %p, %lx)\n", hmix
, lpmliA
, fdwInfo
);
4335 if (lpmliA
== NULL
|| lpmliA
->cbStruct
!= sizeof(*lpmliA
))
4336 return MMSYSERR_INVALPARAM
;
4338 mliW
.cbStruct
= sizeof(mliW
);
4339 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
4340 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
4341 mliW
.dwComponentType
= lpmliA
->dwComponentType
;
4343 case MIXER_GETLINEINFOF_DESTINATION
:
4344 mliW
.dwDestination
= lpmliA
->dwDestination
;
4346 case MIXER_GETLINEINFOF_LINEID
:
4347 mliW
.dwLineID
= lpmliA
->dwLineID
;
4349 case MIXER_GETLINEINFOF_SOURCE
:
4350 mliW
.dwDestination
= lpmliA
->dwDestination
;
4351 mliW
.dwSource
= lpmliA
->dwSource
;
4353 case MIXER_GETLINEINFOF_TARGETTYPE
:
4354 mliW
.Target
.dwType
= lpmliA
->Target
.dwType
;
4355 mliW
.Target
.wMid
= lpmliA
->Target
.wMid
;
4356 mliW
.Target
.wPid
= lpmliA
->Target
.wPid
;
4357 mliW
.Target
.vDriverVersion
= lpmliA
->Target
.vDriverVersion
;
4358 MultiByteToWideChar(CP_ACP
, 0, lpmliA
->Target
.szPname
, -1, mliW
.Target
.szPname
, ARRAY_SIZE(mliW
.Target
.szPname
));
4361 WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo
);
4362 return MMSYSERR_INVALFLAG
;
4365 ret
= mixerGetLineInfoW(hmix
, &mliW
, fdwInfo
);
4367 if(ret
== MMSYSERR_NOERROR
)
4369 lpmliA
->dwDestination
= mliW
.dwDestination
;
4370 lpmliA
->dwSource
= mliW
.dwSource
;
4371 lpmliA
->dwLineID
= mliW
.dwLineID
;
4372 lpmliA
->fdwLine
= mliW
.fdwLine
;
4373 lpmliA
->dwUser
= mliW
.dwUser
;
4374 lpmliA
->dwComponentType
= mliW
.dwComponentType
;
4375 lpmliA
->cChannels
= mliW
.cChannels
;
4376 lpmliA
->cConnections
= mliW
.cConnections
;
4377 lpmliA
->cControls
= mliW
.cControls
;
4378 WideCharToMultiByte( CP_ACP
, 0, mliW
.szShortName
, -1, lpmliA
->szShortName
,
4379 sizeof(lpmliA
->szShortName
), NULL
, NULL
);
4380 WideCharToMultiByte( CP_ACP
, 0, mliW
.szName
, -1, lpmliA
->szName
,
4381 sizeof(lpmliA
->szName
), NULL
, NULL
);
4382 lpmliA
->Target
.dwType
= mliW
.Target
.dwType
;
4383 lpmliA
->Target
.dwDeviceID
= mliW
.Target
.dwDeviceID
;
4384 lpmliA
->Target
.wMid
= mliW
.Target
.wMid
;
4385 lpmliA
->Target
.wPid
= mliW
.Target
.wPid
;
4386 lpmliA
->Target
.vDriverVersion
= mliW
.Target
.vDriverVersion
;
4387 WideCharToMultiByte( CP_ACP
, 0, mliW
.Target
.szPname
, -1, lpmliA
->Target
.szPname
,
4388 sizeof(lpmliA
->Target
.szPname
), NULL
, NULL
);
4393 /**************************************************************************
4394 * mixerSetControlDetails [WINMM.@]
4396 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
,
4399 WINMM_ControlDetails details
;
4402 TRACE("(%p, %p, %lx)\n", hmix
, lpmcd
, fdwDetails
);
4404 if((fdwDetails
& MIXER_SETCONTROLDETAILSF_QUERYMASK
) ==
4405 MIXER_SETCONTROLDETAILSF_CUSTOM
)
4406 return MMSYSERR_NOTSUPPORTED
;
4409 return MMSYSERR_INVALPARAM
;
4411 if(!WINMM_StartDevicesThread())
4412 return MMSYSERR_NODRIVER
;
4414 TRACE("dwControlID: %lu\n", lpmcd
->dwControlID
);
4416 details
.hmix
= hmix
;
4417 details
.details
= lpmcd
;
4418 details
.flags
= fdwDetails
;
4420 ret
= SendMessageW(g_devices_hwnd
, MXDM_SETCONTROLDETAILS
,
4421 (DWORD_PTR
)&details
, 0);
4422 InterlockedDecrement(&g_devthread_token
);
4426 /**************************************************************************
4427 * mixerMessage [WINMM.@]
4429 DWORD WINAPI
mixerMessage(HMIXER hmix
, UINT uMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
4431 TRACE("(%p, %d, %Ix, %Ix)\n", hmix
, uMsg
, dwParam1
, dwParam2
);
4433 return MMSYSERR_NOTSUPPORTED
;