?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 1.6-rc2.
[wine/testsucceed.git] / dlls / winmm / waveform.c
blob76d624a58ea4f680411d0657d77a0e52f046b594
1 /*
2 * Copyright 1993 Martin Ayotte
3 * 1998-2002 Eric Pouech
4 * 2011 Andrew Eikum for CodeWeavers
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <string.h>
24
25 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
27 #define COBJMACROS
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "mmsystem.h"
32 #include "mmreg.h"
33 #include "msacm.h"
34 #include "winuser.h"
35 #include "winnls.h"
36 #include "winternl.h"
37
38 #include "winemm.h"
39
40 #include "ole2.h"
41 #include "initguid.h"
42 #include "devpkey.h"
43 #include "mmdeviceapi.h"
44 #include "audioclient.h"
45 #include "audiopolicy.h"
46
47 #include "wine/debug.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
50
51 /* FIXME: Should be localized */
52 static const WCHAR volumeW[] = {'V','o','l','u','m','e',0};
53 static const WCHAR mastervolumeW[] = {'M','a','s','t','e','r',' ','V','o','l',
54 'u','m','e',0};
55 static const WCHAR muteW[] = {'M','u','t','e',0};
56
57 /* HWAVE (and HMIXER) format:
58 *
59 * XXXX... 1FDD DDDD IIII IIII
60 * X = unused (must be 0)
61 * 1 = the bit is set to 1, to avoid all-zero HWAVEs
62 * F = flow direction (0 = IN, 1 = OUT)
63 * D = index into g_out_mmdevices, or all 1s for the MAPPER device
64 * I = index in the mmdevice's devices array
65 *
66 * Two reasons that we don't just use pointers:
67 * - HWAVEs must fit into 16 bits for compatibility with old applications.
68 * - We must be able to identify bad devices without crashing.
69 */
70
71 /* buffer size = 10 * 100000 (100 ns) = 0.1 seconds */
72 #define AC_BUFLEN (10 * 100000)
73 #define MAX_DEVICES 256
74 #define MAPPER_INDEX 0x3F
75
76 typedef struct _WINMM_CBInfo {
77 DWORD_PTR callback;
78 DWORD_PTR user;
79 DWORD flags;
80 HWAVE hwave;
81 } WINMM_CBInfo;
82
83 struct _WINMM_MMDevice;
84 typedef struct _WINMM_MMDevice WINMM_MMDevice;
85
86 typedef struct _WINMM_Device {
87 WINMM_CBInfo cb_info;
88
89 HWAVE handle;
90
91 BOOL open;
92
93 IMMDevice *device;
94 IAudioClient *client;
95 IAudioRenderClient *render;
96 IAudioCaptureClient *capture;
97 IAudioClock *clock;
98 IAudioStreamVolume *volume;
99
100 WAVEFORMATEX *orig_fmt;
101 HACMSTREAM acm_handle;
102 ACMSTREAMHEADER acm_hdr;
103 UINT32 acm_offs;
104
105 WAVEHDR *first, *last, *playing, *loop_start;
106
107 BOOL stopped;
108 DWORD loop_counter;
109 UINT32 bytes_per_frame, samples_per_sec, ofs_bytes, played_frames;
110 UINT32 remainder_frames; /* header chunk frames already played when a device switch occurred */
111
112 /* stored in frames of sample rate, *not* AC::GetFrequency */
113 UINT64 last_clock_pos;
114
115 HANDLE event;
116 CRITICAL_SECTION lock;
117
118 WINMM_MMDevice *parent;
119 } WINMM_Device;
120
121 struct _WINMM_MMDevice {
122 WAVEOUTCAPSW out_caps; /* must not be modified outside of WINMM_InitMMDevices*/
123 WAVEINCAPSW in_caps; /* must not be modified outside of WINMM_InitMMDevices*/
124 WCHAR *dev_id;
125
126 ISimpleAudioVolume *volume;
127
128 GUID session;
129
130 UINT index;
131
132 /* HMIXER format is the same as the HWAVE format, but the I bits are
133 * replaced by the value of this counter, to keep each HMIXER unique */
134 UINT mixer_count;
135
136 CRITICAL_SECTION lock;
137
138 WINMM_Device *devices[MAX_DEVICES];
139 };
140
141 static WINMM_MMDevice *g_out_mmdevices;
142 static WINMM_MMDevice **g_out_map;
143 static UINT g_outmmdevices_count;
144 static WINMM_Device *g_out_mapper_devices[MAX_DEVICES];
145
146 static WINMM_MMDevice *g_in_mmdevices;
147 static WINMM_MMDevice **g_in_map;
148 static UINT g_inmmdevices_count;
149 static WINMM_Device *g_in_mapper_devices[MAX_DEVICES];
150
151 static IMMDeviceEnumerator *g_devenum;
152
153 static CRITICAL_SECTION g_devthread_lock;
154 static CRITICAL_SECTION_DEBUG g_devthread_lock_debug =
155 {
156 0, 0, &g_devthread_lock,
157 { &g_devthread_lock_debug.ProcessLocksList, &g_devthread_lock_debug.ProcessLocksList },
158 0, 0, { (DWORD_PTR)(__FILE__ ": g_devthread_lock") }
159 };
160 static CRITICAL_SECTION g_devthread_lock = { &g_devthread_lock_debug, -1, 0, 0, 0, 0 };
161 static LONG g_devthread_token;
162 static HANDLE g_devices_thread;
163 static HWND g_devices_hwnd;
164 static HMODULE g_devthread_module;
165
166 static UINT g_devhandle_count;
167 static HANDLE *g_device_handles;
168 static WINMM_Device **g_handle_devices;
169
170 typedef struct _WINMM_OpenInfo {
171 HWAVE handle;
172 UINT req_device;
173 WAVEFORMATEX *format;
174 DWORD_PTR callback;
175 DWORD_PTR cb_user;
176 DWORD flags;
177 BOOL reset;
178 } WINMM_OpenInfo;
179
180 typedef struct _WINMM_ControlDetails {
181 HMIXEROBJ hmix;
182 MIXERCONTROLDETAILS *details;
183 DWORD flags;
184 } WINMM_ControlDetails;
185
186 typedef struct _WINMM_QueryInterfaceInfo {
187 BOOL is_out;
188 UINT index;
189 WCHAR *str;
190 UINT *len_bytes;
191 } WINMM_QueryInterfaceInfo;
192
193 static LRESULT WOD_Open(WINMM_OpenInfo *info);
194 static LRESULT WOD_Close(HWAVEOUT hwave);
195 static LRESULT WID_Open(WINMM_OpenInfo *info);
196 static LRESULT WID_Close(HWAVEIN hwave);
197 static MMRESULT WINMM_BeginPlaying(WINMM_Device *device);
198
199 void WINMM_DeleteWaveform(void)
200 {
201 UINT i, j;
202
203 if(g_devices_thread)
204 CloseHandle(g_devices_thread);
205
206 for(i = 0; i < g_outmmdevices_count; ++i){
207 WINMM_MMDevice *mmdevice = &g_out_mmdevices[i];
208
209 for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
210 WINMM_Device *device = mmdevice->devices[j];
211 if(device->handle)
212 CloseHandle(device->handle);
213 DeleteCriticalSection(&device->lock);
214 }
215
216 if(mmdevice->volume)
217 ISimpleAudioVolume_Release(mmdevice->volume);
218 CoTaskMemFree(mmdevice->dev_id);
219 DeleteCriticalSection(&mmdevice->lock);
220 }
221
222 for(i = 0; i < g_inmmdevices_count; ++i){
223 WINMM_MMDevice *mmdevice = &g_in_mmdevices[i];
224
225 for(j = 0; j < MAX_DEVICES && mmdevice->devices[j]; ++j){
226 WINMM_Device *device = mmdevice->devices[j];
227 if(device->handle)
228 CloseHandle(device->handle);
229 DeleteCriticalSection(&device->lock);
230 }
231
232 if(mmdevice->volume)
233 ISimpleAudioVolume_Release(mmdevice->volume);
234 CoTaskMemFree(mmdevice->dev_id);
235 DeleteCriticalSection(&mmdevice->lock);
236 }
237
238 HeapFree(GetProcessHeap(), 0, g_out_mmdevices);
239 HeapFree(GetProcessHeap(), 0, g_in_mmdevices);
240
241 HeapFree(GetProcessHeap(), 0, g_device_handles);
242 HeapFree(GetProcessHeap(), 0, g_handle_devices);
243
244 DeleteCriticalSection(&g_devthread_lock);
245 }
246
247 static inline HWAVE WINMM_MakeHWAVE(UINT mmdevice, BOOL is_out, UINT device)
248 {
249 return ULongToHandle((1 << 15) | ((!!is_out) << 14) |
250 (mmdevice << 8) | device);
251 }
252
253 static inline void WINMM_DecomposeHWAVE(HWAVE hwave, UINT *mmdevice_index,
254 BOOL *is_out, UINT *device_index, UINT *junk)
255 {
256 ULONG32 l = HandleToULong(hwave);
257 *device_index = l & 0xFF;
258 *mmdevice_index = (l >> 8) & 0x3F;
259 *is_out = (l >> 14) & 0x1;
260 *junk = l >> 15;
261 }
262
263 static void WINMM_InitDevice(WINMM_Device *device)
264 {
265 InitializeCriticalSection(&device->lock);
266 device->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINMM_Device.lock");
267 }
268
269 static inline WINMM_MMDevice *read_map(WINMM_MMDevice **map, UINT index)
270 {
271 WINMM_MMDevice *ret;
272 EnterCriticalSection(&g_devthread_lock);
273 ret = map[index];
274 LeaveCriticalSection(&g_devthread_lock);
275 return ret;
276 }
277
278 /* finds the first unused Device, marks it as "open", and returns
279 * a pointer to the device
280 *
281 * IMPORTANT: it is the caller's responsibility to release the device's lock
282 * on success
283 */
284 static WINMM_Device *WINMM_FindUnusedDevice(WINMM_Device **devices,
285 WINMM_MMDevice *parent, UINT internal_index, BOOL is_out)
286 {
287 UINT i;
288
289 for(i = 0; i < MAX_DEVICES; ++i){
290 WINMM_Device *device = devices[i];
291
292 if(!device){
293 device = devices[i] = HeapAlloc(GetProcessHeap(),
294 HEAP_ZERO_MEMORY, sizeof(WINMM_Device));
295 if(!device)
296 return NULL;
297
298 WINMM_InitDevice(device);
299 EnterCriticalSection(&device->lock);
300 }else
301 EnterCriticalSection(&device->lock);
302
303 if(!device->open){
304 device->handle = WINMM_MakeHWAVE(internal_index, is_out, i);
305 device->parent = parent;
306 device->open = TRUE;
307
308 return device;
309 }
310
311 LeaveCriticalSection(&device->lock);
312 }
313
314 TRACE("All devices in use: mmdevice: %u\n", internal_index);
315
316 return NULL;
317 }
318
319 static inline BOOL WINMM_ValidateAndLock(WINMM_Device *device)
320 {
321 if(!device)
322 return FALSE;
323
324 EnterCriticalSection(&device->lock);
325
326 if(!device->open){
327 LeaveCriticalSection(&device->lock);
328 return FALSE;
329 }
330
331 return TRUE;
332 }
333
334 static WINMM_Device *WINMM_GetDeviceFromHWAVE(HWAVE hwave)
335 {
336 WINMM_MMDevice *mmdevice;
337 WINMM_Device *device;
338 UINT mmdevice_index, device_index, junk;
339 BOOL is_out;
340
341 WINMM_DecomposeHWAVE(hwave, &mmdevice_index, &is_out, &device_index, &junk);
342
343 if(junk != 0x1)
344 return NULL;
345
346 if(mmdevice_index == MAPPER_INDEX){
347 EnterCriticalSection(&g_devthread_lock);
348 if(is_out)
349 device = g_out_mapper_devices[device_index];
350 else
351 device = g_in_mapper_devices[device_index];
352 LeaveCriticalSection(&g_devthread_lock);
353 return device;
354 }
355
356 if(mmdevice_index >= (is_out ? g_outmmdevices_count : g_inmmdevices_count))
357 return NULL;
358
359 if(is_out)
360 mmdevice = &g_out_mmdevices[mmdevice_index];
361 else
362 mmdevice = &g_in_mmdevices[mmdevice_index];
363
364 EnterCriticalSection(&mmdevice->lock);
365
366 device = mmdevice->devices[device_index];
367
368 LeaveCriticalSection(&mmdevice->lock);
369
370 return device;
371 }
372
373 /* Note: NotifyClient should never be called while holding the device lock
374 * since the client may call wave* functions from within the callback. */
375 static inline void WINMM_NotifyClient(WINMM_CBInfo *info, WORD msg, DWORD_PTR param1,
376 DWORD_PTR param2)
377 {
378 DriverCallback(info->callback, info->flags, (HDRVR)info->hwave,
379 msg, info->user, param1, param2);
380 }
381
382 static MMRESULT hr2mmr(HRESULT hr)
383 {
384 switch(hr){
385 case S_OK:
386 case AUDCLNT_E_NOT_STOPPED:
387 return MMSYSERR_NOERROR;
388 case AUDCLNT_E_UNSUPPORTED_FORMAT:
389 return WAVERR_BADFORMAT;
390 case AUDCLNT_E_DEVICE_IN_USE:
391 return MMSYSERR_ALLOCATED;
392 case AUDCLNT_E_ENDPOINT_CREATE_FAILED:
393 return MMSYSERR_NOTENABLED;
394 case E_OUTOFMEMORY:
395 return MMSYSERR_NOMEM;
396 case E_POINTER:
397 case E_INVALIDARG:
398 return MMSYSERR_INVALPARAM;
399 case AUDCLNT_E_DEVICE_INVALIDATED: /* DSERR_BUFFERLOST */
400 default:
401 return FAILED(hr) ? MMSYSERR_ERROR : MMSYSERR_NOERROR;
402 }
403 }
404
405 static HRESULT WINMM_GetFriendlyName(IMMDevice *device, WCHAR *out,
406 UINT outlen)
407 {
408 IPropertyStore *ps;
409 PROPVARIANT var;
410 HRESULT hr;
411
412 hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
413 if(FAILED(hr))
414 return hr;
415
416 PropVariantInit(&var);
417
418 hr = IPropertyStore_GetValue(ps,
419 (PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &var);
420 if(FAILED(hr)){
421 IPropertyStore_Release(ps);
422 return hr;
423 }
424
425 lstrcpynW(out, var.u.pwszVal, outlen);
426
427 PropVariantClear(&var);
428
429 IPropertyStore_Release(ps);
430
431 return S_OK;
432 }
433
434 static HRESULT WINMM_TestFormat(IAudioClient *client, DWORD rate, DWORD depth,
435 WORD channels)
436 {
437 WAVEFORMATEX fmt, *junk;
438 HRESULT hr;
439
440 fmt.wFormatTag = WAVE_FORMAT_PCM;
441 fmt.nChannels = channels;
442 fmt.nSamplesPerSec = rate;
443 fmt.wBitsPerSample = depth;
444 fmt.nBlockAlign = (channels * depth) / 8;
445 fmt.nAvgBytesPerSec = rate * fmt.nBlockAlign;
446 fmt.cbSize = 0;
447
448 hr = IAudioClient_IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED,
449 &fmt, &junk);
450 if(SUCCEEDED(hr))
451 CoTaskMemFree(junk);
452
453 return hr;
454 }
455
456 static struct _TestFormat {
457 DWORD flag;
458 DWORD rate;
459 DWORD depth;
460 WORD channels;
461 } formats_to_test[] = {
462 { WAVE_FORMAT_1M08, 11025, 8, 1 },
463 { WAVE_FORMAT_1M16, 11025, 16, 1 },
464 { WAVE_FORMAT_1S08, 11025, 8, 2 },
465 { WAVE_FORMAT_1S16, 11025, 16, 2 },
466 { WAVE_FORMAT_2M08, 22050, 8, 1 },
467 { WAVE_FORMAT_2M16, 22050, 16, 1 },
468 { WAVE_FORMAT_2S08, 22050, 8, 2 },
469 { WAVE_FORMAT_2S16, 22050, 16, 2 },
470 { WAVE_FORMAT_4M08, 44100, 8, 1 },
471 { WAVE_FORMAT_4M16, 44100, 16, 1 },
472 { WAVE_FORMAT_4S08, 44100, 8, 2 },
473 { WAVE_FORMAT_4S16, 44100, 16, 2 },
474 { WAVE_FORMAT_48M08, 48000, 8, 1 },
475 { WAVE_FORMAT_48M16, 48000, 16, 1 },
476 { WAVE_FORMAT_48S08, 48000, 8, 2 },
477 { WAVE_FORMAT_48S16, 48000, 16, 2 },
478 { WAVE_FORMAT_96M08, 96000, 8, 1 },
479 { WAVE_FORMAT_96M16, 96000, 16, 1 },
480 { WAVE_FORMAT_96S08, 96000, 8, 2 },
481 { WAVE_FORMAT_96S16, 96000, 16, 2 },
482 {0}
483 };
484
485 static DWORD WINMM_GetSupportedFormats(IMMDevice *device)
486 {
487 DWORD flags = 0;
488 HRESULT hr;
489 struct _TestFormat *fmt;
490 IAudioClient *client;
491
492 hr = IMMDevice_Activate(device, &IID_IAudioClient,
493 CLSCTX_INPROC_SERVER, NULL, (void**)&client);
494 if(FAILED(hr))
495 return 0;
496
497 for(fmt = formats_to_test; fmt->flag; ++fmt){
498 hr = WINMM_TestFormat(client, fmt->rate, fmt->depth, fmt->channels);
499 if(hr == S_OK)
500 flags |= fmt->flag;
501 }
502
503 IAudioClient_Release(client);
504
505 return flags;
506 }
507
508 static HRESULT WINMM_InitMMDevice(EDataFlow flow, IMMDevice *device,
509 WINMM_MMDevice *dev, UINT index)
510 {
511 HRESULT hr;
512
513 if(flow == eRender){
514 dev->out_caps.wMid = 0xFF;
515 dev->out_caps.wPid = 0xFF;
516 dev->out_caps.vDriverVersion = 0x00010001;
517 dev->out_caps.dwFormats = WINMM_GetSupportedFormats(device);
518 dev->out_caps.wReserved1 = 0;
519 dev->out_caps.dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME |
520 WAVECAPS_SAMPLEACCURATE;
521 dev->out_caps.wChannels = 2;
522 dev->out_caps.szPname[0] = '\0';
523
524 hr = WINMM_GetFriendlyName(device, dev->out_caps.szPname,
525 sizeof(dev->out_caps.szPname) /
526 sizeof(*dev->out_caps.szPname));
527 if(FAILED(hr))
528 return hr;
529 }else{
530 dev->in_caps.wMid = 0xFF;
531 dev->in_caps.wPid = 0xFF;
532 dev->in_caps.vDriverVersion = 0x00010001;
533 dev->in_caps.dwFormats = WINMM_GetSupportedFormats(device);
534 dev->in_caps.wReserved1 = 0;
535 dev->in_caps.wChannels = 2;
536 dev->in_caps.szPname[0] = '\0';
537
538 hr = WINMM_GetFriendlyName(device, dev->in_caps.szPname,
539 sizeof(dev->in_caps.szPname) /
540 sizeof(*dev->in_caps.szPname));
541 if(FAILED(hr))
542 return hr;
543 }
544
545 hr = IMMDevice_GetId(device, &dev->dev_id);
546 if(FAILED(hr))
547 return hr;
548
549 CoCreateGuid(&dev->session);
550
551 dev->index = index;
552
553 InitializeCriticalSection(&dev->lock);
554 dev->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINMM_Device.lock");
555
556 return S_OK;
557 }
558
559 static HRESULT WINMM_EnumDevices(WINMM_MMDevice **devices,
560 WINMM_MMDevice ***map, UINT *devcount, EDataFlow flow,
561 IMMDeviceEnumerator *devenum)
562 {
563 IMMDeviceCollection *devcoll;
564 HRESULT hr;
565
566 hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,
567 DEVICE_STATE_ACTIVE, &devcoll);
568 if(FAILED(hr))
569 return hr;
570
571 hr = IMMDeviceCollection_GetCount(devcoll, devcount);
572 if(FAILED(hr)){
573 IMMDeviceCollection_Release(devcoll);
574 return hr;
575 }
576
577 if(*devcount > 0){
578 UINT n, count = 1;
579 IMMDevice *def_dev = NULL;
580
581 *devices = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
582 sizeof(WINMM_MMDevice) * (*devcount));
583 if(!*devices){
584 IMMDeviceCollection_Release(devcoll);
585 return E_OUTOFMEMORY;
586 }
587
588 *map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
589 sizeof(WINMM_MMDevice *) * (*devcount));
590 if(!*map){
591 IMMDeviceCollection_Release(devcoll);
592 HeapFree(GetProcessHeap(), 0, *devices);
593 return E_OUTOFMEMORY;
594 }
595
596 /* make sure that device 0 is the default device */
597 IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum,
598 flow, eConsole, &def_dev);
599
600 for(n = 0; n < *devcount; ++n){
601 IMMDevice *device;
602
603 hr = IMMDeviceCollection_Item(devcoll, n, &device);
604 if(SUCCEEDED(hr)){
605 WINMM_InitMMDevice(flow, device, &(*devices)[n], n);
606
607 if(device == def_dev)
608 (*map)[0] = &(*devices)[n];
609 else{
610 (*map)[count] = &(*devices)[n];
611 ++count;
612 }
613
614 IMMDevice_Release(device);
615 }
616 }
617
618 IMMDevice_Release(def_dev);
619
620 *devcount = count;
621 }
622
623 IMMDeviceCollection_Release(devcoll);
624
625 return S_OK;
626 }
627
628 static HRESULT WINAPI notif_QueryInterface(IMMNotificationClient *iface,
629 const GUID *riid, void **obj)
630 {
631 ERR("Unexpected QueryInterface call: %s\n", wine_dbgstr_guid(riid));
632 return E_NOINTERFACE;
633 }
634
635 static ULONG WINAPI notif_AddRef(IMMNotificationClient *iface)
636 {
637 return 2;
638 }
639
640 static ULONG WINAPI notif_Release(IMMNotificationClient *iface)
641 {
642 return 1;
643 }
644
645 static HRESULT WINAPI notif_OnDeviceStateChanged(IMMNotificationClient *iface,
646 const WCHAR *device_id, DWORD new_state)
647 {
648 TRACE("Ignoring OnDeviceStateChanged callback\n");
649 return S_OK;
650 }
651
652 static HRESULT WINAPI notif_OnDeviceAdded(IMMNotificationClient *iface,
653 const WCHAR *device_id)
654 {
655 TRACE("Ignoring OnDeviceAdded callback\n");
656 return S_OK;
657 }
658
659 static HRESULT WINAPI notif_OnDeviceRemoved(IMMNotificationClient *iface,
660 const WCHAR *device_id)
661 {
662 TRACE("Ignoring OnDeviceRemoved callback\n");
663 return S_OK;
664 }
665
666 static HRESULT update_mapping(WINMM_MMDevice ***map, UINT count,
667 const WCHAR *default_id)
668 {
669 WINMM_MMDevice *prev;
670 UINT i;
671
672 prev = (*map)[0];
673 for(i = 0; i < count; ++i){
674 WINMM_MMDevice *tmp;
675
676 if(!lstrcmpW((*map)[i]->dev_id, default_id)){
677 (*map)[0] = (*map)[i];
678 (*map)[i] = prev;
679
680 return S_OK;
681 }
682
683 tmp = (*map)[i];
684 (*map)[i] = prev;
685 prev = tmp;
686 }
687
688 WARN("Couldn't find new default device! Rearranged map for no reason.\n");
689 (*map)[0] = prev;
690
691 return S_FALSE;
692 }
693
694 static HRESULT reroute_mapper_device(WINMM_Device *device, BOOL is_out)
695 {
696 WINMM_OpenInfo info;
697 BOOL stopped;
698 MMRESULT mr;
699 HRESULT hr;
700 UINT64 clock_freq, clock_pos;
701
702 TRACE("rerouting device %p\n", device->handle);
703
704 EnterCriticalSection(&device->lock);
705
706 if(!device->open || device->acm_handle){
707 /* Windows 7 doesn't re-route ACM devices, so we don't either.
708 * Seems to be because of the data waveXxxPrepareHeader allocates. */
709 LeaveCriticalSection(&device->lock);
710 return S_FALSE;
711 }
712
713 stopped = device->stopped;
714
715 info.handle = 0;
716 info.req_device = WAVE_MAPPER;
717 info.format = device->orig_fmt;
718 info.callback = device->cb_info.callback;
719 info.cb_user = device->cb_info.user;
720 /* We have to use direct here so that we don't suddenly introduce ACM
721 * into a playing stream that hasn't been Prepared for it */
722 info.flags = (device->cb_info.flags << 16) | WAVE_FORMAT_DIRECT_QUERY;
723 info.reset = FALSE;
724
725 if(is_out)
726 mr = WOD_Open(&info);
727 else
728 mr = WID_Open(&info);
729
730 if(mr != MMSYSERR_NOERROR){
731 TRACE("New default device doesn't support this stream: %p\n", device->handle);
732 LeaveCriticalSection(&device->lock);
733 return S_FALSE;
734 }
735
736 hr = IAudioClient_Stop(device->client);
737 if(FAILED(hr))
738 WARN("Stop failed: %08x\n", hr);
739
740 hr = IAudioClock_GetFrequency(device->clock, &clock_freq);
741 if(FAILED(hr)){
742 WARN("GetFrequency failed: %08x\n", hr);
743 LeaveCriticalSection(&device->lock);
744 return hr;
745 }
746
747 hr = IAudioClock_GetPosition(device->clock, &clock_pos, NULL);
748 if(FAILED(hr)){
749 WARN("GetPosition failed: %08x\n", hr);
750 LeaveCriticalSection(&device->lock);
751 return hr;
752 }
753
754 device->remainder_frames = MulDiv(clock_pos, device->samples_per_sec, clock_freq) - device->last_clock_pos;
755
756 info.handle = device->handle;
757 info.flags = (device->cb_info.flags << 16) | WAVE_FORMAT_DIRECT;
758
759 if(is_out){
760 WOD_Close((HWAVEOUT)device->handle);
761 device->parent = read_map(g_out_map, 0);
762 mr = WOD_Open(&info);
763 }else{
764 WID_Close((HWAVEIN)device->handle);
765 device->parent = read_map(g_in_map, 0);
766 mr = WID_Open(&info);
767 }
768
769 if(mr != MMSYSERR_NOERROR){
770 ERR("Opening new default device failed! %u\n", mr);
771 LeaveCriticalSection(&device->lock);
772 return E_FAIL;
773 }
774
775 HeapFree(GetProcessHeap(), 0, info.format);
776
777 if(!stopped)
778 WINMM_BeginPlaying(device);
779
780 LeaveCriticalSection(&device->lock);
781
782 return S_OK;
783 }
784
785 static HRESULT WINAPI notif_OnDefaultDeviceChanged(IMMNotificationClient *iface,
786 EDataFlow flow, ERole role, const WCHAR *device_id)
787 {
788 UINT i;
789
790 TRACE("%u %u %s\n", flow, role, wine_dbgstr_w(device_id));
791
792 if(role != eConsole)
793 return S_OK;
794
795 EnterCriticalSection(&g_devthread_lock);
796
797 if(flow == eRender)
798 update_mapping(&g_out_map, g_outmmdevices_count, device_id);
799 else
800 update_mapping(&g_in_map, g_inmmdevices_count, device_id);
801
802 for(i = 0; i < MAX_DEVICES && g_out_mapper_devices[i]; ++i)
803 reroute_mapper_device(g_out_mapper_devices[i], TRUE);
804
805 for(i = 0; i < MAX_DEVICES && g_in_mapper_devices[i]; ++i)
806 reroute_mapper_device(g_in_mapper_devices[i], FALSE);
807
808 LeaveCriticalSection(&g_devthread_lock);
809
810 return S_OK;
811 }
812
813 static HRESULT WINAPI notif_OnPropertyValueChanged(IMMNotificationClient *iface,
814 const WCHAR *device_id, const PROPERTYKEY key)
815 {
816 TRACE("Ignoring OnPropertyValueChanged callback\n");
817 return S_OK;
818 }
819
820 static IMMNotificationClientVtbl g_notif_vtbl = {
821 notif_QueryInterface,
822 notif_AddRef,
823 notif_Release,
824 notif_OnDeviceStateChanged,
825 notif_OnDeviceAdded,
826 notif_OnDeviceRemoved,
827 notif_OnDefaultDeviceChanged,
828 notif_OnPropertyValueChanged
829 };
830
831 static IMMNotificationClient g_notif = { &g_notif_vtbl };
832
833 static HRESULT WINMM_InitMMDevices(void)
834 {
835 HRESULT hr, init_hr;
836 IMMDeviceEnumerator *devenum = NULL;
837
838 if(g_outmmdevices_count || g_inmmdevices_count)
839 return S_FALSE;
840
841 init_hr = CoInitialize(NULL);
842
843 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
844 CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
845 if(FAILED(hr))
846 goto exit;
847
848 hr = IMMDeviceEnumerator_RegisterEndpointNotificationCallback(devenum, &g_notif);
849 if(FAILED(hr))
850 WARN("RegisterEndpointNotificationCallback failed: %08x\n", hr);
851
852 hr = WINMM_EnumDevices(&g_out_mmdevices, &g_out_map, &g_outmmdevices_count,
853 eRender, devenum);
854 if(FAILED(hr)){
855 g_outmmdevices_count = 0;
856 g_inmmdevices_count = 0;
857 goto exit;
858 }
859
860 hr = WINMM_EnumDevices(&g_in_mmdevices, &g_in_map, &g_inmmdevices_count,
861 eCapture, devenum);
862 if(FAILED(hr)){
863 g_inmmdevices_count = 0;
864 goto exit;
865 }
866
867 exit:
868 if(devenum)
869 IMMDeviceEnumerator_Release(devenum);
870 if(SUCCEEDED(init_hr))
871 CoUninitialize();
872
873 return hr;
874 }
875
876 static inline BOOL WINMM_IsMapper(UINT device)
877 {
878 return (device == WAVE_MAPPER || device == (UINT16)WAVE_MAPPER);
879 }
880
881 static MMRESULT WINMM_TryDeviceMapping(WINMM_Device *device, WAVEFORMATEX *fmt,
882 WORD channels, DWORD freq, DWORD bits_per_samp, BOOL is_out)
883 {
884 WAVEFORMATEX target, *closer_fmt = NULL;
885 HRESULT hr;
886 MMRESULT mr;
887
888 TRACE("format: %u, channels: %u, sample rate: %u, bit depth: %u\n",
889 WAVE_FORMAT_PCM, channels, freq, bits_per_samp);
890
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;
897 target.cbSize = 0;
898
899 hr = IAudioClient_IsFormatSupported(device->client,
900 AUDCLNT_SHAREMODE_SHARED, &target, &closer_fmt);
901 if(closer_fmt)
902 CoTaskMemFree(closer_fmt);
903 if(hr != S_OK)
904 return WAVERR_BADFORMAT;
905
906 /* device supports our target format, so see if MSACM can
907 * do the conversion */
908 if(is_out)
909 mr = acmStreamOpen(&device->acm_handle, NULL, fmt, &target, NULL,
910 0, 0, 0);
911 else
912 mr = acmStreamOpen(&device->acm_handle, NULL, &target, fmt, NULL,
913 0, 0, 0);
914 if(mr != MMSYSERR_NOERROR)
915 return mr;
916
917 /* yes it can. initialize the audioclient and return success */
918 hr = IAudioClient_Initialize(device->client, AUDCLNT_SHAREMODE_SHARED,
919 AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
920 AC_BUFLEN, 0, &target, &device->parent->session);
921 if(hr != S_OK){
922 WARN("Initialize failed: %08x\n", hr);
923 acmStreamClose(device->acm_handle, 0);
924 device->acm_handle = NULL;
925 return MMSYSERR_ERROR;
926 }
927
928 device->bytes_per_frame = target.nBlockAlign;
929 device->samples_per_sec = target.nSamplesPerSec;
930
931 TRACE("Success!\n");
932
933 return MMSYSERR_NOERROR;
934 }
935
936 static MMRESULT WINMM_MapDevice(WINMM_Device *device, BOOL is_out)
937 {
938 MMRESULT mr;
939 WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)device->orig_fmt;
940
941 TRACE("(%p, %u)\n", device, is_out);
942
943 /* set up the ACM stream */
944 if(device->orig_fmt->wFormatTag != WAVE_FORMAT_PCM &&
945 !(device->orig_fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
946 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
947 /* convert to PCM format if it's not already */
948 mr = WINMM_TryDeviceMapping(device, device->orig_fmt,
949 device->orig_fmt->nChannels, device->orig_fmt->nSamplesPerSec,
950 16, is_out);
951 if(mr == MMSYSERR_NOERROR)
952 return mr;
953
954 mr = WINMM_TryDeviceMapping(device, device->orig_fmt,
955 device->orig_fmt->nChannels, device->orig_fmt->nSamplesPerSec,
956 8, is_out);
957 if(mr == MMSYSERR_NOERROR)
958 return mr;
959 }else{
960 WORD channels;
961
962 /* first try just changing bit depth and channels */
963 channels = device->orig_fmt->nChannels;
964 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels,
965 device->orig_fmt->nSamplesPerSec, 16, is_out);
966 if(mr == MMSYSERR_NOERROR)
967 return mr;
968 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels,
969 device->orig_fmt->nSamplesPerSec, 8, is_out);
970 if(mr == MMSYSERR_NOERROR)
971 return mr;
972
973 channels = (channels == 2) ? 1 : 2;
974 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels,
975 device->orig_fmt->nSamplesPerSec, 16, is_out);
976 if(mr == MMSYSERR_NOERROR)
977 return mr;
978 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels,
979 device->orig_fmt->nSamplesPerSec, 8, is_out);
980 if(mr == MMSYSERR_NOERROR)
981 return mr;
982
983 /* that didn't work, so now try different sample rates */
984 channels = device->orig_fmt->nChannels;
985 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 96000, 16, is_out);
986 if(mr == MMSYSERR_NOERROR)
987 return mr;
988 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 48000, 16, is_out);
989 if(mr == MMSYSERR_NOERROR)
990 return mr;
991 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 44100, 16, is_out);
992 if(mr == MMSYSERR_NOERROR)
993 return mr;
994 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 22050, 16, is_out);
995 if(mr == MMSYSERR_NOERROR)
996 return mr;
997 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 11025, 16, is_out);
998 if(mr == MMSYSERR_NOERROR)
999 return mr;
1000
1001 channels = (channels == 2) ? 1 : 2;
1002 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 96000, 16, is_out);
1003 if(mr == MMSYSERR_NOERROR)
1004 return mr;
1005 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 48000, 16, is_out);
1006 if(mr == MMSYSERR_NOERROR)
1007 return mr;
1008 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 44100, 16, is_out);
1009 if(mr == MMSYSERR_NOERROR)
1010 return mr;
1011 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 22050, 16, is_out);
1012 if(mr == MMSYSERR_NOERROR)
1013 return mr;
1014 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 11025, 16, is_out);
1015 if(mr == MMSYSERR_NOERROR)
1016 return mr;
1017
1018 channels = device->orig_fmt->nChannels;
1019 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 96000, 8, is_out);
1020 if(mr == MMSYSERR_NOERROR)
1021 return mr;
1022 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 48000, 8, is_out);
1023 if(mr == MMSYSERR_NOERROR)
1024 return mr;
1025 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 44100, 8, is_out);
1026 if(mr == MMSYSERR_NOERROR)
1027 return mr;
1028 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 22050, 8, is_out);
1029 if(mr == MMSYSERR_NOERROR)
1030 return mr;
1031 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 11025, 8, is_out);
1032 if(mr == MMSYSERR_NOERROR)
1033 return mr;
1034
1035 channels = (channels == 2) ? 1 : 2;
1036 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 96000, 8, is_out);
1037 if(mr == MMSYSERR_NOERROR)
1038 return mr;
1039 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 48000, 8, is_out);
1040 if(mr == MMSYSERR_NOERROR)
1041 return mr;
1042 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 44100, 8, is_out);
1043 if(mr == MMSYSERR_NOERROR)
1044 return mr;
1045 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 22050, 8, is_out);
1046 if(mr == MMSYSERR_NOERROR)
1047 return mr;
1048 mr = WINMM_TryDeviceMapping(device, device->orig_fmt, channels, 11025, 8, is_out);
1049 if(mr == MMSYSERR_NOERROR)
1050 return mr;
1051 }
1052
1053 WARN("Unable to find compatible device!\n");
1054 return WAVERR_BADFORMAT;
1055 }
1056
1057 static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
1058 BOOL is_out)
1059 {
1060 LRESULT ret = MMSYSERR_NOMEM;
1061 HRESULT hr;
1062
1063 hr = IMMDeviceEnumerator_GetDevice(g_devenum, device->parent->dev_id,
1064 &device->device);
1065 if(FAILED(hr)){
1066 WARN("Device %s (%s) unavailable: %08x\n",
1067 wine_dbgstr_w(device->parent->dev_id),
1068 wine_dbgstr_w(device->parent->out_caps.szPname), hr);
1069 ret = MMSYSERR_NODRIVER;
1070 goto error;
1071 }
1072
1073 /* this is where winexyz.drv opens the audio device */
1074 hr = IMMDevice_Activate(device->device, &IID_IAudioClient,
1075 CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
1076 if(FAILED(hr)){
1077 WARN("Activate failed: %08x\n", hr);
1078 ret = hr2mmr(hr);
1079 if(ret == MMSYSERR_ERROR)
1080 ret = MMSYSERR_NOTENABLED;
1081 goto error;
1082 }
1083
1084 if(info->format->wFormatTag == WAVE_FORMAT_PCM){
1085 /* we aren't guaranteed that the struct in lpFormat is a full
1086 * WAVEFORMATEX struct, which IAC::IsFormatSupported requires */
1087 device->orig_fmt = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEX));
1088 memcpy(device->orig_fmt, info->format, sizeof(PCMWAVEFORMAT));
1089 device->orig_fmt->cbSize = 0;
1090 if(device->orig_fmt->wBitsPerSample % 8 != 0){
1091 WARN("Fixing bad wBitsPerSample (%u)\n", device->orig_fmt->wBitsPerSample);
1092 device->orig_fmt->wBitsPerSample = (device->orig_fmt->wBitsPerSample + 7) & ~7;
1093 }
1094 /* winmm ignores broken blockalign and avgbytes */
1095 if(device->orig_fmt->nBlockAlign != device->orig_fmt->nChannels * device->orig_fmt->wBitsPerSample/8){
1096 WARN("Fixing bad nBlockAlign (%u)\n", device->orig_fmt->nBlockAlign);
1097 device->orig_fmt->nBlockAlign = device->orig_fmt->nChannels * device->orig_fmt->wBitsPerSample/8;
1098 }
1099 if (device->orig_fmt->nAvgBytesPerSec != device->orig_fmt->nSamplesPerSec * device->orig_fmt->nBlockAlign) {
1100 WARN("Fixing bad nAvgBytesPerSec (%u)\n", device->orig_fmt->nAvgBytesPerSec);
1101 device->orig_fmt->nAvgBytesPerSec = device->orig_fmt->nSamplesPerSec * device->orig_fmt->nBlockAlign;
1102 }
1103 }else{
1104 device->orig_fmt = HeapAlloc(GetProcessHeap(), 0,
1105 sizeof(WAVEFORMATEX) + info->format->cbSize);
1106 memcpy(device->orig_fmt, info->format,
1107 sizeof(WAVEFORMATEX) + info->format->cbSize);
1108 }
1109
1110 if(info->flags & WAVE_FORMAT_QUERY){
1111 WAVEFORMATEX *closer_fmt = NULL;
1112
1113 hr = IAudioClient_IsFormatSupported(device->client,
1114 AUDCLNT_SHAREMODE_SHARED, device->orig_fmt, &closer_fmt);
1115 if(closer_fmt)
1116 CoTaskMemFree(closer_fmt);
1117 ret = hr == S_FALSE ? WAVERR_BADFORMAT : hr2mmr(hr);
1118 goto error;
1119 }
1120
1121 hr = IAudioClient_Initialize(device->client, AUDCLNT_SHAREMODE_SHARED,
1122 AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
1123 AC_BUFLEN, 0, device->orig_fmt, &device->parent->session);
1124 if(FAILED(hr)){
1125 if(hr == AUDCLNT_E_UNSUPPORTED_FORMAT && !(info->flags & WAVE_FORMAT_DIRECT)){
1126 ret = WINMM_MapDevice(device, is_out);
1127 if(ret != MMSYSERR_NOERROR || info->flags & WAVE_FORMAT_QUERY)
1128 goto error;
1129 }else{
1130 WARN("Initialize failed: %08x\n", hr);
1131 ret = hr2mmr(hr);
1132 goto error;
1133 }
1134 }else{
1135 device->bytes_per_frame = device->orig_fmt->nBlockAlign;
1136 device->samples_per_sec = device->orig_fmt->nSamplesPerSec;
1137 }
1138
1139 hr = IAudioClient_GetService(device->client, &IID_IAudioClock,
1140 (void**)&device->clock);
1141 if(FAILED(hr)){
1142 WARN("GetService failed: %08x\n", hr);
1143 goto error;
1144 }
1145
1146 if(!device->event){
1147 device->event = CreateEventW(NULL, FALSE, FALSE, NULL);
1148 if(!device->event){
1149 WARN("CreateEvent failed: %08x\n", hr);
1150 goto error;
1151 }
1152
1153 /* As the devices thread is waiting on g_device_handles, it can
1154 * only be modified from within this same thread. */
1155 if(g_device_handles){
1156 g_device_handles = HeapReAlloc(GetProcessHeap(), 0, g_device_handles,
1157 sizeof(HANDLE) * (g_devhandle_count + 1));
1158 g_handle_devices = HeapReAlloc(GetProcessHeap(), 0, g_handle_devices,
1159 sizeof(WINMM_Device *) * (g_devhandle_count + 1));
1160 }else{
1161 g_device_handles = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE));
1162 g_handle_devices = HeapAlloc(GetProcessHeap(), 0,
1163 sizeof(WINMM_Device *));
1164 }
1165 g_device_handles[g_devhandle_count] = device->event;
1166 g_handle_devices[g_devhandle_count] = device;
1167 ++g_devhandle_count;
1168 }
1169
1170 hr = IAudioClient_SetEventHandle(device->client, device->event);
1171 if(FAILED(hr)){
1172 WARN("SetEventHandle failed: %08x\n", hr);
1173 goto error;
1174 }
1175
1176 if(info->reset){
1177 device->played_frames = 0;
1178 device->ofs_bytes = 0;
1179 device->loop_counter = 0;
1180 device->first = device->last = device->playing = device->loop_start = NULL;
1181 }
1182
1183 device->stopped = TRUE;
1184 device->last_clock_pos = 0;
1185
1186 device->cb_info.flags = HIWORD(info->flags & CALLBACK_TYPEMASK);
1187 device->cb_info.callback = info->callback;
1188 device->cb_info.user = info->cb_user;
1189 device->cb_info.hwave = device->handle;
1190
1191 info->handle = device->handle;
1192
1193 return MMSYSERR_NOERROR;
1194
1195 error:
1196 if(device->client){
1197 IAudioClient_Release(device->client);
1198 device->client = NULL;
1199 }
1200 if(device->device){
1201 IMMDevice_Release(device->device);
1202 device->device = NULL;
1203 }
1204
1205 return ret;
1206 }
1207
1208 static LRESULT WOD_Open(WINMM_OpenInfo *info)
1209 {
1210 WINMM_Device *device;
1211 LRESULT ret = MMSYSERR_ERROR;
1212 HRESULT hr;
1213
1214 if(info->handle != 0){
1215 device = WINMM_GetDeviceFromHWAVE(info->handle);
1216 if(!device){
1217 WARN("Unexpected! Invalid info->handle given: %p\n", info->handle);
1218 return MMSYSERR_ERROR;
1219 }
1220
1221 EnterCriticalSection(&device->lock);
1222
1223 device->open = TRUE;
1224 }else{
1225 CRITICAL_SECTION *lock;
1226 UINT internal_index;
1227 WINMM_Device **devices;
1228 WINMM_MMDevice *mmdevice;
1229
1230 if(WINMM_IsMapper(info->req_device)){
1231 devices = g_out_mapper_devices;
1232 mmdevice = read_map(g_out_map, 0);
1233 lock = &g_devthread_lock;
1234 internal_index = MAPPER_INDEX;
1235 }else{
1236 if(info->req_device >= g_outmmdevices_count)
1237 return MMSYSERR_BADDEVICEID;
1238
1239 mmdevice = read_map(g_out_map, info->req_device);
1240
1241 if(!mmdevice->out_caps.szPname[0])
1242 return MMSYSERR_NOTENABLED;
1243
1244 devices = mmdevice->devices;
1245 lock = &mmdevice->lock;
1246 internal_index = mmdevice->index;
1247 }
1248
1249 EnterCriticalSection(lock);
1250
1251 device = WINMM_FindUnusedDevice(devices, mmdevice,
1252 internal_index, TRUE);
1253 if(!device){
1254 LeaveCriticalSection(lock);
1255 return MMSYSERR_ALLOCATED;
1256 }
1257
1258 LeaveCriticalSection(lock);
1259 }
1260
1261 ret = WINMM_OpenDevice(device, info, TRUE);
1262 if((info->flags & WAVE_FORMAT_QUERY) || ret != MMSYSERR_NOERROR)
1263 goto error;
1264 ret = MMSYSERR_ERROR;
1265
1266 hr = IAudioClient_GetService(device->client, &IID_IAudioRenderClient,
1267 (void**)&device->render);
1268 if(FAILED(hr)){
1269 ERR("GetService failed: %08x\n", hr);
1270 goto error;
1271 }
1272
1273 hr = IAudioClient_GetService(device->client, &IID_IAudioStreamVolume,
1274 (void**)&device->volume);
1275 if(FAILED(hr)){
1276 ERR("GetService failed: %08x\n", hr);
1277 goto error;
1278 }
1279
1280 LeaveCriticalSection(&device->lock);
1281
1282 return MMSYSERR_NOERROR;
1283
1284 error:
1285 if(device->device){
1286 IMMDevice_Release(device->device);
1287 device->device = NULL;
1288 }
1289 if(device->client){
1290 IAudioClient_Release(device->client);
1291 device->client = NULL;
1292 }
1293 if(device->render){
1294 IAudioRenderClient_Release(device->render);
1295 device->render = NULL;
1296 }
1297 if(device->volume){
1298 IAudioStreamVolume_Release(device->volume);
1299 device->volume = NULL;
1300 }
1301 if(device->clock){
1302 IAudioClock_Release(device->clock);
1303 device->clock = NULL;
1304 }
1305 device->open = FALSE;
1306 LeaveCriticalSection(&device->lock);
1307 return ret;
1308 }
1309
1310 static LRESULT WID_Open(WINMM_OpenInfo *info)
1311 {
1312 WINMM_Device *device, **devices;
1313 WINMM_MMDevice *mmdevice;
1314 UINT internal_index;
1315 CRITICAL_SECTION *lock;
1316 LRESULT ret = MMSYSERR_ERROR;
1317 HRESULT hr;
1318
1319 if(WINMM_IsMapper(info->req_device)){
1320 devices = g_in_mapper_devices;
1321 mmdevice = read_map(g_in_map, 0);
1322 lock = &g_devthread_lock;
1323 internal_index = MAPPER_INDEX;
1324 }else{
1325 if(info->req_device >= g_inmmdevices_count)
1326 return MMSYSERR_BADDEVICEID;
1327
1328 mmdevice = read_map(g_in_map, info->req_device);
1329
1330 if(!mmdevice->in_caps.szPname[0])
1331 return MMSYSERR_NOTENABLED;
1332
1333 devices = mmdevice->devices;
1334 lock = &mmdevice->lock;
1335 internal_index = mmdevice->index;
1336 }
1337
1338 EnterCriticalSection(lock);
1339
1340 device = WINMM_FindUnusedDevice(devices, mmdevice, internal_index, FALSE);
1341 if(!device){
1342 LeaveCriticalSection(lock);
1343 return MMSYSERR_ALLOCATED;
1344 }
1345
1346 LeaveCriticalSection(lock);
1347
1348 ret = WINMM_OpenDevice(device, info, FALSE);
1349 if((info->flags & WAVE_FORMAT_QUERY) || ret != MMSYSERR_NOERROR)
1350 goto error;
1351 ret = MMSYSERR_ERROR;
1352
1353 hr = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
1354 (void**)&device->capture);
1355 if(FAILED(hr)){
1356 WARN("GetService failed: %08x\n", hr);
1357 goto error;
1358 }
1359
1360 LeaveCriticalSection(&device->lock);
1361
1362 return MMSYSERR_NOERROR;
1363
1364 error:
1365 if(device->device){
1366 IMMDevice_Release(device->device);
1367 device->device = NULL;
1368 }
1369 if(device->client){
1370 IAudioClient_Release(device->client);
1371 device->client = NULL;
1372 }
1373 if(device->capture){
1374 IAudioCaptureClient_Release(device->capture);
1375 device->capture = NULL;
1376 }
1377 if(device->clock){
1378 IAudioClock_Release(device->clock);
1379 device->clock = NULL;
1380 }
1381 device->open = FALSE;
1382 LeaveCriticalSection(&device->lock);
1383 return ret;
1384 }
1385
1386 static HRESULT WINMM_CloseDevice(WINMM_Device *device)
1387 {
1388 device->open = FALSE;
1389
1390 if(!device->stopped){
1391 IAudioClient_Stop(device->client);
1392 device->stopped = TRUE;
1393 }
1394
1395 if(device->acm_handle){
1396 acmStreamClose(device->acm_handle, 0);
1397 device->acm_handle = NULL;
1398 }
1399
1400 IMMDevice_Release(device->device);
1401 device->device = NULL;
1402
1403 IAudioClient_Release(device->client);
1404 device->client = NULL;
1405
1406 IAudioClock_Release(device->clock);
1407 device->clock = NULL;
1408
1409 return S_OK;
1410 }
1411
1412 static LRESULT WOD_Close(HWAVEOUT hwave)
1413 {
1414 WINMM_Device *device = WINMM_GetDeviceFromHWAVE((HWAVE)hwave);
1415
1416 TRACE("(%p)\n", hwave);
1417
1418 if(!WINMM_ValidateAndLock(device))
1419 return MMSYSERR_INVALHANDLE;
1420
1421 WINMM_CloseDevice(device);
1422
1423 IAudioRenderClient_Release(device->render);
1424 device->render = NULL;
1425
1426 IAudioStreamVolume_Release(device->volume);
1427 device->volume = NULL;
1428
1429 LeaveCriticalSection(&device->lock);
1430
1431 return MMSYSERR_NOERROR;
1432 }
1433
1434 static LRESULT WID_Close(HWAVEIN hwave)
1435 {
1436 WINMM_Device *device = WINMM_GetDeviceFromHWAVE((HWAVE)hwave);
1437
1438 TRACE("(%p)\n", hwave);
1439
1440 if(!WINMM_ValidateAndLock(device))
1441 return MMSYSERR_INVALHANDLE;
1442
1443 WINMM_CloseDevice(device);
1444
1445 IAudioCaptureClient_Release(device->capture);
1446 device->capture = NULL;
1447
1448 LeaveCriticalSection(&device->lock);
1449
1450 return MMSYSERR_NOERROR;
1451 }
1452
1453 static DWORD WINMM_FixedBufferLen(DWORD length, WINMM_Device *device)
1454 {
1455 return length - length % device->bytes_per_frame;
1456 }
1457
1458 static LRESULT WINMM_PrepareHeader(HWAVE hwave, WAVEHDR *header)
1459 {
1460 WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1461
1462 TRACE("(%p, %p)\n", hwave, header);
1463
1464 if(!WINMM_ValidateAndLock(device))
1465 return MMSYSERR_INVALHANDLE;
1466
1467 if(device->render && device->acm_handle){
1468 ACMSTREAMHEADER *ash;
1469 DWORD size;
1470 MMRESULT mr;
1471
1472 mr = acmStreamSize(device->acm_handle, header->dwBufferLength, &size,
1473 ACM_STREAMSIZEF_SOURCE);
1474 if(mr != MMSYSERR_NOERROR){
1475 LeaveCriticalSection(&device->lock);
1476 return mr;
1477 }
1478
1479 ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + size);
1480 if(!ash){
1481 LeaveCriticalSection(&device->lock);
1482 return MMSYSERR_NOMEM;
1483 }
1484
1485 ash->cbStruct = sizeof(*ash);
1486 ash->fdwStatus = 0;
1487 ash->dwUser = (DWORD_PTR)header;
1488 ash->pbSrc = (BYTE*)header->lpData;
1489 ash->cbSrcLength = header->dwBufferLength;
1490 ash->dwSrcUser = header->dwUser;
1491 ash->pbDst = (BYTE*)ash + sizeof(ACMSTREAMHEADER);
1492 ash->cbDstLength = size;
1493 ash->dwDstUser = 0;
1494
1495 mr = acmStreamPrepareHeader(device->acm_handle, ash, 0);
1496 if(mr != MMSYSERR_NOERROR){
1497 HeapFree(GetProcessHeap(), 0, ash);
1498 LeaveCriticalSection(&device->lock);
1499 return mr;
1500 }
1501
1502 header->reserved = (DWORD_PTR)ash;
1503 }
1504
1505 LeaveCriticalSection(&device->lock);
1506
1507 header->dwFlags |= WHDR_PREPARED;
1508 header->dwFlags &= ~(WHDR_DONE|WHDR_INQUEUE); /* flags cleared since w2k */
1509
1510 return MMSYSERR_NOERROR;
1511 }
1512
1513 static LRESULT WINMM_UnprepareHeader(HWAVE hwave, WAVEHDR *header)
1514 {
1515 WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1516
1517 TRACE("(%p, %p)\n", hwave, header);
1518
1519 if(!WINMM_ValidateAndLock(device))
1520 return MMSYSERR_INVALHANDLE;
1521
1522 if(device->render && device->acm_handle){
1523 ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
1524
1525 acmStreamUnprepareHeader(device->acm_handle, ash, 0);
1526
1527 HeapFree(GetProcessHeap(), 0, ash);
1528 }
1529
1530 LeaveCriticalSection(&device->lock);
1531
1532 header->dwFlags &= ~WHDR_PREPARED;
1533
1534 return MMSYSERR_NOERROR;
1535 }
1536
1537 static UINT32 WINMM_HeaderLenBytes(WINMM_Device *device, WAVEHDR *header)
1538 {
1539 if(device->acm_handle){
1540 ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
1541 return WINMM_FixedBufferLen(ash->cbDstLengthUsed, device);
1542 }
1543
1544 return WINMM_FixedBufferLen(header->dwBufferLength, device);
1545 }
1546
1547 static UINT32 WINMM_HeaderLenFrames(WINMM_Device *device, WAVEHDR *header)
1548 {
1549 return WINMM_HeaderLenBytes(device, header) / device->bytes_per_frame;
1550 }
1551
1552 static WAVEHDR *WOD_MarkDoneHeaders(WINMM_Device *device)
1553 {
1554 HRESULT hr;
1555 WAVEHDR *first = device->first, *queue = first, *last = NULL;
1556 UINT64 clock_freq, clock_pos, clock_frames;
1557 UINT32 nloops, queue_frames = 0;
1558
1559 hr = IAudioClock_GetFrequency(device->clock, &clock_freq);
1560 if(FAILED(hr)){
1561 WARN("GetFrequency failed: %08x\n", hr);
1562 return NULL;
1563 }
1564
1565 hr = IAudioClock_GetPosition(device->clock, &clock_pos, NULL);
1566 if(FAILED(hr)){
1567 WARN("GetPosition failed: %08x\n", hr);
1568 return NULL;
1569 }
1570
1571 clock_frames = (clock_pos * device->samples_per_sec) / clock_freq;
1572
1573 nloops = device->loop_counter;
1574 while(queue &&
1575 (queue_frames += WINMM_HeaderLenFrames(device, queue)) <=
1576 clock_frames - device->last_clock_pos + device->remainder_frames){
1577 if(!nloops){
1578 last = queue;
1579 device->last_clock_pos += queue_frames;
1580 device->remainder_frames = 0;
1581 queue_frames = 0;
1582 queue = device->first = queue->lpNext;
1583 }else{
1584 if(queue->dwFlags & WHDR_BEGINLOOP){
1585 if(queue->dwFlags & WHDR_ENDLOOP)
1586 --nloops;
1587 else
1588 queue = queue->lpNext;
1589 }else if(queue->dwFlags & WHDR_ENDLOOP){
1590 queue = device->loop_start;
1591 --nloops;
1592 }
1593 }
1594 }
1595
1596 if(last){
1597 last->lpNext = NULL;
1598 return first;
1599 }else
1600 return NULL;
1601 }
1602
1603 static void WOD_PushData(WINMM_Device *device)
1604 {
1605 WINMM_CBInfo cb_info;
1606 HRESULT hr;
1607 UINT32 pad, bufsize, avail_frames, queue_frames, written, ofs;
1608 UINT32 queue_bytes, nloops;
1609 BYTE *data;
1610 WAVEHDR *queue, *first = NULL;
1611
1612 TRACE("(%p)\n", device->handle);
1613
1614 EnterCriticalSection(&device->lock);
1615
1616 if(!device->device)
1617 goto exit;
1618
1619 if(!device->first){
1620 if (device->stopped)
1621 goto exit;
1622 device->stopped = TRUE;
1623 device->last_clock_pos = 0;
1624 IAudioClient_Stop(device->client);
1625 IAudioClient_Reset(device->client);
1626 goto exit;
1627 }
1628
1629 hr = IAudioClient_GetBufferSize(device->client, &bufsize);
1630 if(FAILED(hr)){
1631 WARN("GetBufferSize failed: %08x\n", hr);
1632 goto exit;
1633 }
1634
1635 hr = IAudioClient_GetCurrentPadding(device->client, &pad);
1636 if(FAILED(hr)){
1637 WARN("GetCurrentPadding failed: %08x\n", hr);
1638 goto exit;
1639 }
1640
1641 first = WOD_MarkDoneHeaders(device);
1642
1643 /* determine which is larger between the available buffer size and
1644 * the amount of data left in the queue */
1645 avail_frames = bufsize - pad;
1646
1647 queue = device->playing;
1648 ofs = device->ofs_bytes;
1649 queue_frames = 0;
1650 nloops = 0;
1651 while(queue && queue_frames < avail_frames){
1652 queue_bytes = WINMM_HeaderLenBytes(device, queue);
1653 queue_frames += (queue_bytes - ofs) / device->bytes_per_frame;
1654 ofs = 0;
1655
1656 if(queue->dwFlags & WHDR_ENDLOOP && nloops < device->loop_counter){
1657 queue = device->loop_start;
1658 ++nloops;
1659 }else
1660 queue = queue->lpNext;
1661 }
1662
1663 if(queue_frames < avail_frames)
1664 avail_frames = queue_frames;
1665 if(avail_frames == 0)
1666 goto exit;
1667
1668 hr = IAudioRenderClient_GetBuffer(device->render, avail_frames, &data);
1669 if(FAILED(hr)){
1670 WARN("GetBuffer failed: %08x\n", hr);
1671 goto exit;
1672 }
1673
1674 written = 0;
1675 while(device->playing && written < avail_frames){
1676 UINT32 copy_frames, copy_bytes;
1677 BYTE *queue_data;
1678
1679 queue = device->playing;
1680
1681 queue_bytes = WINMM_HeaderLenBytes(device, queue);
1682 if(device->acm_handle)
1683 queue_data = ((ACMSTREAMHEADER*)queue->reserved)->pbDst;
1684 else
1685 queue_data = (BYTE*)queue->lpData;
1686
1687 queue_frames = (queue_bytes - device->ofs_bytes) /
1688 device->bytes_per_frame;
1689
1690 copy_frames = queue_frames < (avail_frames - written) ?
1691 queue_frames : avail_frames - written;
1692 copy_bytes = copy_frames * device->bytes_per_frame;
1693
1694 memcpy(data, queue_data + device->ofs_bytes, copy_bytes);
1695
1696 data += copy_bytes;
1697 written += copy_frames;
1698 device->ofs_bytes += copy_bytes;
1699
1700 if(device->ofs_bytes >= queue_bytes){
1701 device->ofs_bytes = 0;
1702
1703 if(!(queue->dwFlags & (WHDR_BEGINLOOP | WHDR_ENDLOOP)))
1704 device->playing = queue->lpNext;
1705 else{
1706 if(queue->dwFlags & WHDR_BEGINLOOP){
1707 device->loop_start = device->playing;
1708 device->playing = queue->lpNext;
1709 device->loop_counter = queue->dwLoops;
1710 }
1711 if(queue->dwFlags & WHDR_ENDLOOP){
1712 --device->loop_counter;
1713 if(device->loop_counter)
1714 device->playing = device->loop_start;
1715 else
1716 device->loop_start = device->playing = queue->lpNext;
1717 }
1718 }
1719 }
1720 }
1721
1722 hr = IAudioRenderClient_ReleaseBuffer(device->render, avail_frames, 0);
1723 if(FAILED(hr)){
1724 WARN("ReleaseBuffer failed: %08x\n", hr);
1725 goto exit;
1726 }
1727
1728 if(device->orig_fmt->nSamplesPerSec != device->samples_per_sec)
1729 device->played_frames += MulDiv(avail_frames, device->orig_fmt->nSamplesPerSec, device->samples_per_sec);
1730 else
1731 device->played_frames += avail_frames;
1732
1733 exit:
1734 cb_info = device->cb_info;
1735
1736 LeaveCriticalSection(&device->lock);
1737
1738 while(first){
1739 WAVEHDR *next = first->lpNext;
1740 first->dwFlags &= ~WHDR_INQUEUE;
1741 first->dwFlags |= WHDR_DONE;
1742 WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
1743 first = next;
1744 }
1745 }
1746
1747 static void WID_PullACMData(WINMM_Device *device)
1748 {
1749 UINT32 packet, packet_bytes;
1750 DWORD flags;
1751 BYTE *data;
1752 WAVEHDR *queue;
1753 HRESULT hr;
1754 MMRESULT mr;
1755
1756 if(device->acm_hdr.cbDstLength == 0){
1757 hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet,
1758 &flags, NULL, NULL);
1759 if(hr != S_OK){
1760 if(FAILED(hr))
1761 WARN("GetBuffer failed: %08x\n", hr);
1762 return;
1763 }
1764
1765 acmStreamSize(device->acm_handle, packet * device->bytes_per_frame,
1766 &packet_bytes, ACM_STREAMSIZEF_SOURCE);
1767
1768 device->acm_offs = 0;
1769
1770 device->acm_hdr.cbStruct = sizeof(device->acm_hdr);
1771 device->acm_hdr.fdwStatus = 0;
1772 device->acm_hdr.dwUser = 0;
1773 device->acm_hdr.pbSrc = data;
1774 device->acm_hdr.cbSrcLength = packet * device->bytes_per_frame;
1775 device->acm_hdr.cbSrcLengthUsed = 0;
1776 device->acm_hdr.dwSrcUser = 0;
1777 device->acm_hdr.pbDst = HeapAlloc(GetProcessHeap(), 0, packet_bytes);
1778 device->acm_hdr.cbDstLength = packet_bytes;
1779 device->acm_hdr.cbDstLengthUsed = 0;
1780 device->acm_hdr.dwDstUser = 0;
1781
1782 mr = acmStreamPrepareHeader(device->acm_handle, &device->acm_hdr, 0);
1783 if(mr != MMSYSERR_NOERROR){
1784 WARN("acmStreamPrepareHeader failed: %d\n", mr);
1785 return;
1786 }
1787
1788 mr = acmStreamConvert(device->acm_handle, &device->acm_hdr, 0);
1789 if(mr != MMSYSERR_NOERROR){
1790 WARN("acmStreamConvert failed: %d\n", mr);
1791 return;
1792 }
1793
1794 hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet);
1795 if(FAILED(hr))
1796 WARN("ReleaseBuffer failed: %08x\n", hr);
1797
1798 device->played_frames += packet;
1799 }
1800
1801 queue = device->first;
1802 while(queue){
1803 UINT32 to_copy_bytes;
1804
1805 to_copy_bytes = min(WINMM_FixedBufferLen(queue->dwBufferLength, device) - queue->dwBytesRecorded,
1806 WINMM_FixedBufferLen(device->acm_hdr.cbDstLengthUsed, device) - device->acm_offs);
1807
1808 memcpy(queue->lpData + queue->dwBytesRecorded,
1809 device->acm_hdr.pbDst + device->acm_offs, to_copy_bytes);
1810
1811 queue->dwBytesRecorded += to_copy_bytes;
1812 device->acm_offs += to_copy_bytes;
1813
1814 if(queue->dwBufferLength - queue->dwBytesRecorded <
1815 device->bytes_per_frame){
1816 queue->dwFlags &= ~WHDR_INQUEUE;
1817 queue->dwFlags |= WHDR_DONE;
1818 device->first = queue = queue->lpNext;
1819 }
1820
1821 if(device->acm_offs >= WINMM_FixedBufferLen(device->acm_hdr.cbDstLengthUsed, device)){
1822 acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1823 HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1824 device->acm_hdr.cbDstLength = 0;
1825 device->acm_hdr.cbDstLengthUsed = 0;
1826
1827 /* done with this ACM Header, so try to pull more data */
1828 WID_PullACMData(device);
1829 return;
1830 }
1831 }
1832
1833 /* out of WAVEHDRs to write into, so toss the rest of this packet */
1834 acmStreamUnprepareHeader(device->acm_handle, &device->acm_hdr, 0);
1835 HeapFree(GetProcessHeap(), 0, device->acm_hdr.pbDst);
1836 device->acm_hdr.cbDstLength = 0;
1837 device->acm_hdr.cbDstLengthUsed = 0;
1838 }
1839
1840 static void WID_PullData(WINMM_Device *device)
1841 {
1842 WINMM_CBInfo cb_info;
1843 WAVEHDR *queue, *first = NULL, *last = NULL;
1844 HRESULT hr;
1845
1846 TRACE("(%p)\n", device->handle);
1847
1848 EnterCriticalSection(&device->lock);
1849
1850 if(!device->device || !device->first)
1851 goto exit;
1852
1853 first = device->first;
1854
1855 if(device->acm_handle){
1856 WID_PullACMData(device);
1857 goto exit;
1858 }
1859
1860 while(device->first){
1861 BYTE *data;
1862 UINT32 packet_len, packet;
1863 DWORD flags;
1864
1865 hr = IAudioCaptureClient_GetBuffer(device->capture, &data, &packet_len,
1866 &flags, NULL, NULL);
1867 if(hr != S_OK){
1868 if(FAILED(hr))
1869 WARN("GetBuffer failed: %08x\n", hr);
1870 else /* AUDCLNT_S_BUFFER_EMPTY success code */
1871 IAudioCaptureClient_ReleaseBuffer(device->capture, 0);
1872 goto exit;
1873 }
1874
1875 packet = packet_len;
1876 queue = device->first;
1877 while(queue && packet > 0){
1878 UINT32 to_copy_bytes;
1879
1880 to_copy_bytes = min(packet * device->bytes_per_frame,
1881 WINMM_FixedBufferLen(queue->dwBufferLength, device) - queue->dwBytesRecorded);
1882
1883 memcpy(queue->lpData + queue->dwBytesRecorded,
1884 data + (packet_len - packet) * device->bytes_per_frame,
1885 to_copy_bytes);
1886
1887 queue->dwBytesRecorded += to_copy_bytes;
1888
1889 if(queue->dwBufferLength - queue->dwBytesRecorded <
1890 device->bytes_per_frame){
1891 last = queue;
1892 device->first = queue = queue->lpNext;
1893 }
1894
1895 packet -= to_copy_bytes / device->bytes_per_frame;
1896 }
1897
1898 hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet_len);
1899 if(FAILED(hr))
1900 WARN("ReleaseBuffer failed: %08x\n", hr);
1901
1902 if(packet > 0)
1903 WARN("losing %u frames\n", packet);
1904 device->played_frames += packet_len;
1905 }
1906
1907 exit:
1908 cb_info = device->cb_info;
1909
1910 LeaveCriticalSection(&device->lock);
1911
1912 if(last){
1913 last->lpNext = NULL;
1914 while(first){
1915 WAVEHDR *next = first->lpNext;
1916 first->dwFlags &= ~WHDR_INQUEUE;
1917 first->dwFlags |= WHDR_DONE;
1918 WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
1919 first = next;
1920 }
1921 }
1922 }
1923
1924 static MMRESULT WINMM_BeginPlaying(WINMM_Device *device)
1925 {
1926 HRESULT hr;
1927
1928 TRACE("(%p)\n", device->handle);
1929
1930 if(device->render)
1931 /* prebuffer data before starting */
1932 WOD_PushData(device);
1933
1934 if(device->stopped){
1935 device->stopped = FALSE;
1936
1937 hr = IAudioClient_Start(device->client);
1938 if(FAILED(hr) && hr != AUDCLNT_E_NOT_STOPPED){
1939 device->stopped = TRUE;
1940 WARN("Start failed: %08x\n", hr);
1941 return MMSYSERR_ERROR;
1942 }
1943 }
1944
1945 return MMSYSERR_NOERROR;
1946 }
1947
1948 static LRESULT WINMM_Pause(HWAVE hwave)
1949 {
1950 WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1951 HRESULT hr;
1952
1953 TRACE("(%p)\n", hwave);
1954
1955 if(!WINMM_ValidateAndLock(device))
1956 return MMSYSERR_INVALHANDLE;
1957
1958 hr = IAudioClient_Stop(device->client);
1959 if(FAILED(hr)){
1960 LeaveCriticalSection(&device->lock);
1961 WARN("Stop failed: %08x\n", hr);
1962 return MMSYSERR_ERROR;
1963 }
1964
1965 device->stopped = FALSE;
1966
1967 LeaveCriticalSection(&device->lock);
1968
1969 return MMSYSERR_NOERROR;
1970 }
1971
1972 static LRESULT WINMM_Reset(HWAVE hwave)
1973 {
1974 WINMM_CBInfo cb_info;
1975 WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
1976 BOOL is_out;
1977 WAVEHDR *first;
1978 HRESULT hr;
1979
1980 TRACE("(%p)\n", hwave);
1981
1982 if(!WINMM_ValidateAndLock(device))
1983 return MMSYSERR_INVALHANDLE;
1984
1985 hr = IAudioClient_Stop(device->client);
1986 if(FAILED(hr)){
1987 LeaveCriticalSection(&device->lock);
1988 WARN("Stop failed: %08x\n", hr);
1989 return MMSYSERR_ERROR;
1990 }
1991 device->stopped = TRUE;
1992
1993 first = device->first;
1994 device->first = device->last = device->playing = NULL;
1995 device->ofs_bytes = 0;
1996 device->played_frames = 0;
1997 device->loop_counter = 0;
1998 device->last_clock_pos = 0;
1999 IAudioClient_Reset(device->client);
2000
2001 cb_info = device->cb_info;
2002 is_out = device->render != NULL;
2003
2004 LeaveCriticalSection(&device->lock);
2005
2006 while(first){
2007 WAVEHDR *next = first->lpNext;
2008 first->dwFlags &= ~WHDR_INQUEUE;
2009 first->dwFlags |= WHDR_DONE;
2010 if(is_out)
2011 WINMM_NotifyClient(&cb_info, WOM_DONE, (DWORD_PTR)first, 0);
2012 else
2013 WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)first, 0);
2014 first = next;
2015 }
2016
2017 return MMSYSERR_NOERROR;
2018 }
2019
2020 static MMRESULT WINMM_FramesToMMTime(MMTIME *time, UINT32 played_frames,
2021 UINT32 sample_rate, UINT32 bytes_per_sec)
2022 {
2023 switch(time->wType){
2024 case TIME_SAMPLES:
2025 time->u.sample = played_frames;
2026 return MMSYSERR_NOERROR;
2027 case TIME_MS:
2028 time->u.ms = (UINT64)played_frames * 1000 / sample_rate;
2029 return MMSYSERR_NOERROR;
2030 case TIME_SMPTE:
2031 time->u.smpte.fps = 30;
2032 played_frames += sample_rate / time->u.smpte.fps - 1; /* round up */
2033 time->u.smpte.frame = (played_frames % sample_rate) * time->u.smpte.fps / sample_rate;
2034 played_frames /= sample_rate; /* yields seconds */
2035 time->u.smpte.sec = played_frames % 60;
2036 played_frames /= 60;
2037 time->u.smpte.min = played_frames % 60;
2038 time->u.smpte.hour= played_frames / 60;
2039 return MMSYSERR_NOERROR;
2040 default:
2041 time->wType = TIME_BYTES;
2042 /* fall through */
2043 case TIME_BYTES:
2044 time->u.cb = MulDiv(played_frames, bytes_per_sec, sample_rate);
2045 return MMSYSERR_NOERROR;
2046 }
2047 }
2048
2049 static LRESULT WINMM_GetPosition(HWAVE hwave, MMTIME *time)
2050 {
2051 WINMM_Device *device = WINMM_GetDeviceFromHWAVE(hwave);
2052 UINT32 played_frames, sample_rate, bytes_per_sec;
2053
2054 TRACE("(%p, %p)\n", hwave, time);
2055
2056 if(!WINMM_ValidateAndLock(device))
2057 return MMSYSERR_INVALHANDLE;
2058
2059 played_frames = device->played_frames;
2060 sample_rate = device->orig_fmt->nSamplesPerSec;
2061 bytes_per_sec = device->orig_fmt->nAvgBytesPerSec;
2062
2063 LeaveCriticalSection(&device->lock);
2064
2065 return WINMM_FramesToMMTime(time, played_frames, sample_rate, bytes_per_sec);
2066 }
2067
2068 static WINMM_MMDevice *WINMM_GetMixerMMDevice(HMIXEROBJ hmix, DWORD flags,
2069 UINT *mmdev_index)
2070 {
2071 UINT mmdev, dev, junk, *out;
2072 BOOL is_out;
2073
2074 if(!mmdev_index)
2075 out = &mmdev;
2076 else
2077 out = mmdev_index;
2078
2079 switch(flags & 0xF0000000){
2080 case MIXER_OBJECTF_MIXER: /* == 0 */
2081 *out = HandleToULong(hmix);
2082 if(*out < g_outmmdevices_count)
2083 return read_map(g_out_map, *out);
2084 if(*out - g_outmmdevices_count < g_inmmdevices_count){
2085 *out -= g_outmmdevices_count;
2086 return read_map(g_in_map, *out);
2087 }
2088 /* fall through -- if it's not a valid mixer device, then
2089 * it could be a valid mixer handle. windows seems to do
2090 * this as well. */
2091 case MIXER_OBJECTF_HMIXER:
2092 case MIXER_OBJECTF_HWAVEOUT:
2093 case MIXER_OBJECTF_HWAVEIN:
2094 WINMM_DecomposeHWAVE((HWAVE)hmix, out, &is_out, &dev, &junk);
2095 if(junk != 0x1 || (is_out && *out >= g_outmmdevices_count) ||
2096 (!is_out && *out >= g_inmmdevices_count))
2097 return NULL;
2098 if(is_out)
2099 return read_map(g_out_map, *out);
2100 return read_map(g_in_map, *out);
2101 case MIXER_OBJECTF_WAVEOUT:
2102 *out = HandleToULong(hmix);
2103 if(*out < g_outmmdevices_count)
2104 return read_map(g_out_map, *out);
2105 return NULL;
2106 case MIXER_OBJECTF_WAVEIN:
2107 *out = HandleToULong(hmix);
2108 if(*out < g_inmmdevices_count)
2109 return read_map(g_in_map, *out);
2110 return NULL;
2111 }
2112
2113 return NULL;
2114 }
2115
2116 static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
2117 {
2118 IAudioSessionManager *sesman;
2119 IMMDevice *device;
2120 HRESULT hr;
2121
2122 hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id, &device);
2123 if(FAILED(hr)){
2124 WARN("Device %s (%s) unavailable: %08x\n",
2125 wine_dbgstr_w(mmdevice->dev_id),
2126 wine_dbgstr_w(mmdevice->out_caps.szPname), hr);
2127 return MMSYSERR_ERROR;
2128 }
2129
2130 hr = IMMDevice_Activate(device, &IID_IAudioSessionManager,
2131 CLSCTX_INPROC_SERVER, NULL, (void**)&sesman);
2132 if(FAILED(hr)){
2133 WARN("Activate failed: %08x\n", hr);
2134 IMMDevice_Release(device);
2135 return MMSYSERR_ERROR;
2136 }
2137
2138 IMMDevice_Release(device);
2139
2140 hr = IAudioSessionManager_GetSimpleAudioVolume(sesman, &mmdevice->session,
2141 FALSE, &mmdevice->volume);
2142 IAudioSessionManager_Release(sesman);
2143 if(FAILED(hr)){
2144 WARN("GetSimpleAudioVolume failed: %08x\n", hr);
2145 return MMSYSERR_ERROR;
2146 }
2147
2148 return MMSYSERR_NOERROR;
2149 }
2150
2151 static LRESULT MXD_GetControlDetails(WINMM_ControlDetails *details)
2152 {
2153 WINMM_MMDevice *mmdevice;
2154 MIXERCONTROLDETAILS *control = details->details;
2155 HRESULT hr;
2156
2157 TRACE("(%p)\n", details->hmix);
2158
2159 mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
2160 if(!mmdevice)
2161 return MMSYSERR_INVALHANDLE;
2162
2163 EnterCriticalSection(&mmdevice->lock);
2164
2165 if(!mmdevice->volume){
2166 MMRESULT mr;
2167
2168 mr = WINMM_SetupMMDeviceVolume(mmdevice);
2169 if(mr != MMSYSERR_NOERROR){
2170 LeaveCriticalSection(&mmdevice->lock);
2171 return mr;
2172 }
2173 }
2174
2175 if(control->dwControlID == 0){
2176 float vol;
2177 MIXERCONTROLDETAILS_UNSIGNED *udet;
2178
2179 if(!control->paDetails ||
2180 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
2181 LeaveCriticalSection(&mmdevice->lock);
2182 return MMSYSERR_INVALPARAM;
2183 }
2184
2185 hr = ISimpleAudioVolume_GetMasterVolume(mmdevice->volume, &vol);
2186 if(FAILED(hr)){
2187 WARN("GetMasterVolume failed: %08x\n", hr);
2188 LeaveCriticalSection(&mmdevice->lock);
2189 return MMSYSERR_ERROR;
2190 }
2191
2192 udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
2193 udet->dwValue = vol * ((unsigned int)0xFFFF);
2194 }else if(control->dwControlID == 1){
2195 BOOL mute;
2196 MIXERCONTROLDETAILS_BOOLEAN *bdet;
2197
2198 if(!control->paDetails ||
2199 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
2200 LeaveCriticalSection(&mmdevice->lock);
2201 return MMSYSERR_INVALPARAM;
2202 }
2203
2204 hr = ISimpleAudioVolume_GetMute(mmdevice->volume, &mute);
2205 if(FAILED(hr)){
2206 WARN("GetMute failed: %08x\n", hr);
2207 LeaveCriticalSection(&mmdevice->lock);
2208 return MMSYSERR_ERROR;
2209 }
2210
2211 bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
2212 bdet->fValue = mute;
2213 }else if(control->dwControlID == 2 || control->dwControlID == 3){
2214 FIXME("What should the sw-side mixer controls map to?\n");
2215 }else{
2216 LeaveCriticalSection(&mmdevice->lock);
2217 return MIXERR_INVALCONTROL;
2218 }
2219
2220 LeaveCriticalSection(&mmdevice->lock);
2221
2222 return MMSYSERR_NOERROR;
2223 }
2224
2225 static LRESULT MXD_SetControlDetails(WINMM_ControlDetails *details)
2226 {
2227 WINMM_MMDevice *mmdevice;
2228 MIXERCONTROLDETAILS *control = details->details;
2229 HRESULT hr;
2230
2231 TRACE("(%p)\n", details->hmix);
2232
2233 mmdevice = WINMM_GetMixerMMDevice(details->hmix, details->flags, NULL);
2234 if(!mmdevice)
2235 return MMSYSERR_INVALHANDLE;
2236
2237 EnterCriticalSection(&mmdevice->lock);
2238
2239 if(!mmdevice->volume){
2240 MMRESULT mr;
2241
2242 mr = WINMM_SetupMMDeviceVolume(mmdevice);
2243 if(mr != MMSYSERR_NOERROR){
2244 LeaveCriticalSection(&mmdevice->lock);
2245 return mr;
2246 }
2247 }
2248
2249 if(control->dwControlID == 0){
2250 float vol;
2251 MIXERCONTROLDETAILS_UNSIGNED *udet;
2252
2253 if(!control->paDetails ||
2254 control->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)){
2255 LeaveCriticalSection(&mmdevice->lock);
2256 return MMSYSERR_INVALPARAM;
2257 }
2258
2259 udet = (MIXERCONTROLDETAILS_UNSIGNED*)control->paDetails;
2260
2261 if(udet->dwValue > 65535){
2262 LeaveCriticalSection(&mmdevice->lock);
2263 return MMSYSERR_INVALPARAM;
2264 }
2265
2266 vol = udet->dwValue / 65535.f;
2267
2268 hr = ISimpleAudioVolume_SetMasterVolume(mmdevice->volume, vol, NULL);
2269 if(FAILED(hr)){
2270 WARN("SetMasterVolume failed: %08x\n", hr);
2271 LeaveCriticalSection(&mmdevice->lock);
2272 return MMSYSERR_ERROR;
2273 }
2274 }else if(control->dwControlID == 1){
2275 BOOL mute;
2276 MIXERCONTROLDETAILS_BOOLEAN *bdet;
2277
2278 if(!control->paDetails ||
2279 control->cbDetails < sizeof(MIXERCONTROLDETAILS_BOOLEAN)){
2280 LeaveCriticalSection(&mmdevice->lock);
2281 return MMSYSERR_INVALPARAM;
2282 }
2283
2284 bdet = (MIXERCONTROLDETAILS_BOOLEAN*)control->paDetails;
2285 mute = bdet->fValue;
2286
2287 hr = ISimpleAudioVolume_SetMute(mmdevice->volume, mute, NULL);
2288 if(FAILED(hr)){
2289 WARN("SetMute failed: %08x\n", hr);
2290 LeaveCriticalSection(&mmdevice->lock);
2291 return MMSYSERR_ERROR;
2292 }
2293 }else if(control->dwControlID == 2 || control->dwControlID == 3){
2294 FIXME("What should the sw-side mixer controls map to?\n");
2295 }else{
2296 LeaveCriticalSection(&mmdevice->lock);
2297 return MIXERR_INVALCONTROL;
2298 }
2299
2300 LeaveCriticalSection(&mmdevice->lock);
2301
2302 return MMSYSERR_NOERROR;
2303 }
2304
2305 static LRESULT DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo *info)
2306 {
2307 WINMM_MMDevice *mmdevice;
2308 IMMDevice *device;
2309 IPropertyStore *ps;
2310 PROPVARIANT pv;
2311 DWORD len_bytes;
2312 HRESULT hr;
2313
2314 static const PROPERTYKEY deviceinterface_key = {
2315 {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
2316 };
2317
2318 if(WINMM_IsMapper(info->index)){
2319 if(info->str){
2320 if(*info->len_bytes < sizeof(WCHAR))
2321 return MMSYSERR_INVALPARAM;
2322 *info->str = 0;
2323 }else
2324 *info->len_bytes = sizeof(WCHAR);
2325 return MMSYSERR_NOERROR;
2326 }
2327
2328 if(info->is_out){
2329 if(info->index >= g_outmmdevices_count)
2330 return MMSYSERR_INVALHANDLE;
2331
2332 mmdevice = &g_out_mmdevices[info->index];
2333 }else{
2334 if(info->index >= g_inmmdevices_count)
2335 return MMSYSERR_INVALHANDLE;
2336
2337 mmdevice = &g_in_mmdevices[info->index];
2338 }
2339
2340 hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id,
2341 &device);
2342 if(FAILED(hr)){
2343 WARN("Device %s unavailable: %08x\n", wine_dbgstr_w(mmdevice->dev_id), hr);
2344 return MMSYSERR_ERROR;
2345 }
2346
2347 hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
2348 if(FAILED(hr)){
2349 WARN("OpenPropertyStore failed: %08x\n", hr);
2350 IMMDevice_Release(device);
2351 return MMSYSERR_ERROR;
2352 }
2353
2354 PropVariantInit(&pv);
2355 hr = IPropertyStore_GetValue(ps, &deviceinterface_key, &pv);
2356 if(FAILED(hr)){
2357 WARN("GetValue failed: %08x\n", hr);
2358 IPropertyStore_Release(ps);
2359 IMMDevice_Release(device);
2360 return MMSYSERR_ERROR;
2361 }
2362 if(pv.vt != VT_LPWSTR){
2363 WARN("Got unexpected property type: %u\n", pv.vt);
2364 PropVariantClear(&pv);
2365 IPropertyStore_Release(ps);
2366 IMMDevice_Release(device);
2367 return MMSYSERR_ERROR;
2368 }
2369
2370 len_bytes = (lstrlenW(pv.u.pwszVal) + 1) * sizeof(WCHAR);
2371
2372 if(info->str){
2373 if(len_bytes > *info->len_bytes){
2374 PropVariantClear(&pv);
2375 IPropertyStore_Release(ps);
2376 IMMDevice_Release(device);
2377 return MMSYSERR_INVALPARAM;
2378 }
2379
2380 memcpy(info->str, pv.u.pwszVal, len_bytes);
2381 }else
2382 *info->len_bytes = len_bytes;
2383
2384 PropVariantClear(&pv);
2385 IPropertyStore_Release(ps);
2386 IMMDevice_Release(device);
2387
2388 return MMSYSERR_NOERROR;
2389 }
2390
2391 static LRESULT CALLBACK WINMM_DevicesMsgProc(HWND hwnd, UINT msg, WPARAM wparam,
2392 LPARAM lparam)
2393 {
2394 switch(msg){
2395 case WODM_OPEN:
2396 return WOD_Open((WINMM_OpenInfo*)wparam);
2397 case WODM_CLOSE:
2398 return WOD_Close((HWAVEOUT)wparam);
2399 case WIDM_OPEN:
2400 return WID_Open((WINMM_OpenInfo*)wparam);
2401 case WIDM_CLOSE:
2402 return WID_Close((HWAVEIN)wparam);
2403 case MXDM_GETCONTROLDETAILS:
2404 return MXD_GetControlDetails((WINMM_ControlDetails*)wparam);
2405 case MXDM_SETCONTROLDETAILS:
2406 return MXD_SetControlDetails((WINMM_ControlDetails*)wparam);
2407 case DRV_QUERYDEVICEINTERFACESIZE:
2408 case DRV_QUERYDEVICEINTERFACE:
2409 return DRV_QueryDeviceInterface((WINMM_QueryInterfaceInfo*)wparam);
2410 }
2411 return DefWindowProcW(hwnd, msg, wparam, lparam);
2412 }
2413
2414 static BOOL WINMM_DevicesThreadDone(void)
2415 {
2416 UINT i;
2417
2418 EnterCriticalSection(&g_devthread_lock);
2419
2420 if(g_devthread_token > 0){
2421 LeaveCriticalSection(&g_devthread_lock);
2422 return FALSE;
2423 }
2424
2425 for(i = 0; i < g_devhandle_count; ++i){
2426 if(g_handle_devices[i]->open){
2427 LeaveCriticalSection(&g_devthread_lock);
2428 return FALSE;
2429 }
2430 }
2431
2432 DestroyWindow(g_devices_hwnd);
2433 g_devices_hwnd = NULL;
2434 IMMDeviceEnumerator_Release(g_devenum);
2435 g_devenum = NULL;
2436 CoUninitialize();
2437
2438 LeaveCriticalSection(&g_devthread_lock);
2439
2440 return TRUE;
2441 }
2442
2443 static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
2444 {
2445 HANDLE evt = arg;
2446 HRESULT hr;
2447 static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
2448
2449 hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
2450 if(FAILED(hr)){
2451 WARN("CoInitializeEx failed: %08x\n", hr);
2452 FreeLibraryAndExitThread(g_devthread_module, 1);
2453 }
2454
2455 hr = WINMM_InitMMDevices();
2456 if(FAILED(hr)){
2457 CoUninitialize();
2458 FreeLibraryAndExitThread(g_devthread_module, 1);
2459 }
2460
2461 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
2462 CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&g_devenum);
2463 if(FAILED(hr)){
2464 WARN("CoCreateInstance failed: %08x\n", hr);
2465 CoUninitialize();
2466 FreeLibraryAndExitThread(g_devthread_module, 1);
2467 }
2468
2469 g_devices_hwnd = CreateWindowW(messageW, NULL, 0, 0, 0, 0, 0,
2470 HWND_MESSAGE, NULL, NULL, NULL);
2471 if(!g_devices_hwnd){
2472 WARN("CreateWindow failed: %d\n", GetLastError());
2473 CoUninitialize();
2474 FreeLibraryAndExitThread(g_devthread_module, 1);
2475 }
2476
2477 SetWindowLongPtrW(g_devices_hwnd, GWLP_WNDPROC,
2478 (LONG_PTR)WINMM_DevicesMsgProc);
2479
2480 /* inform caller that the thread is ready to process messages */
2481 SetEvent(evt);
2482 evt = NULL; /* do not use after this point */
2483
2484 while(1){
2485 DWORD wait;
2486 wait = MsgWaitForMultipleObjects(g_devhandle_count, g_device_handles,
2487 FALSE, INFINITE, QS_ALLINPUT);
2488 if(wait == g_devhandle_count + WAIT_OBJECT_0){
2489 MSG msg;
2490 if(PeekMessageW(&msg, g_devices_hwnd, 0, 0, PM_REMOVE))
2491 WARN("Unexpected message: 0x%x\n", msg.message);
2492 if(!g_devices_hwnd)
2493 break;
2494 }else if(wait < g_devhandle_count + WAIT_OBJECT_0){
2495 WINMM_Device *device = g_handle_devices[wait - WAIT_OBJECT_0];
2496 if(device->render)
2497 WOD_PushData(device);
2498 else
2499 WID_PullData(device);
2500 }else
2501 WARN("Unexpected MsgWait result 0x%x, GLE: %d\n", wait,
2502 GetLastError());
2503 if(WINMM_DevicesThreadDone()){
2504 TRACE("Quitting devices thread\n");
2505 FreeLibraryAndExitThread(g_devthread_module, 0);
2506 }
2507 }
2508
2509 FreeLibraryAndExitThread(g_devthread_module, 0);
2510 }
2511
2512 /* on success, increments g_devthread_token to prevent
2513 * device thread shutdown. caller must decrement. */
2514 static BOOL WINMM_StartDevicesThread(void)
2515 {
2516 HANDLE events[2];
2517 DWORD wait;
2518
2519 EnterCriticalSection(&g_devthread_lock);
2520
2521 if(g_devices_hwnd){
2522 wait = WaitForSingleObject(g_devices_thread, 0);
2523 if(wait == WAIT_TIMEOUT){
2524 /* thread still running */
2525 InterlockedIncrement(&g_devthread_token);
2526 LeaveCriticalSection(&g_devthread_lock);
2527 return TRUE;
2528 }
2529 if(wait != WAIT_OBJECT_0){
2530 /* error */
2531 LeaveCriticalSection(&g_devthread_lock);
2532 return FALSE;
2533 }
2534 TRACE("Devices thread left dangling message window?\n");
2535 g_devices_hwnd = NULL;
2536 CloseHandle(g_devices_thread);
2537 g_devices_thread = NULL;
2538 }else if(g_devices_thread){
2539 WaitForSingleObject(g_devices_thread, INFINITE);
2540 CloseHandle(g_devices_thread);
2541 g_devices_thread = NULL;
2542 }
2543
2544 TRACE("Starting up devices thread\n");
2545
2546 /* The devices thread holds a reference to the winmm module
2547 * to prevent it from unloading while it's running. */
2548 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
2549 (const WCHAR *)WINMM_StartDevicesThread, &g_devthread_module);
2550
2551 events[0] = CreateEventW(NULL, FALSE, FALSE, NULL);
2552
2553 g_devices_thread = CreateThread(NULL, 0, WINMM_DevicesThreadProc,
2554 events[0], 0, NULL);
2555 if(!g_devices_thread){
2556 LeaveCriticalSection(&g_devthread_lock);
2557 CloseHandle(events[0]);
2558 FreeLibrary(g_devthread_module);
2559 return FALSE;
2560 }
2561
2562 events[1] = g_devices_thread;
2563 wait = WaitForMultipleObjects(2, events, FALSE, INFINITE);
2564 CloseHandle(events[0]);
2565 if(wait != WAIT_OBJECT_0){
2566 if(wait == 1 + WAIT_OBJECT_0){
2567 CloseHandle(g_devices_thread);
2568 g_devices_thread = NULL;
2569 g_devices_hwnd = NULL;
2570 }
2571 LeaveCriticalSection(&g_devthread_lock);
2572 return FALSE;
2573 }
2574
2575 InterlockedIncrement(&g_devthread_token);
2576
2577 LeaveCriticalSection(&g_devthread_lock);
2578
2579 return TRUE;
2580 }
2581
2582 /**************************************************************************
2583 * waveOutGetNumDevs [WINMM.@]
2584 */
2585 UINT WINAPI waveOutGetNumDevs(void)
2586 {
2587 HRESULT hr = WINMM_InitMMDevices();
2588 if(FAILED(hr))
2589 return 0;
2590
2591 TRACE("count: %u\n", g_outmmdevices_count);
2592
2593 return g_outmmdevices_count;
2594 }
2595
2596 /**************************************************************************
2597 * waveOutGetDevCapsA [WINMM.@]
2598 */
2599 UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
2600 UINT uSize)
2601 {
2602 WAVEOUTCAPSW wocW;
2603 UINT ret;
2604
2605 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2606
2607 if(!lpCaps)
2608 return MMSYSERR_INVALPARAM;
2609
2610 ret = waveOutGetDevCapsW(uDeviceID, &wocW, sizeof(wocW));
2611
2612 if (ret == MMSYSERR_NOERROR) {
2613 WAVEOUTCAPSA wocA;
2614 wocA.wMid = wocW.wMid;
2615 wocA.wPid = wocW.wPid;
2616 wocA.vDriverVersion = wocW.vDriverVersion;
2617 WideCharToMultiByte( CP_ACP, 0, wocW.szPname, -1, wocA.szPname,
2618 sizeof(wocA.szPname), NULL, NULL );
2619 wocA.dwFormats = wocW.dwFormats;
2620 wocA.wChannels = wocW.wChannels;
2621 wocA.dwSupport = wocW.dwSupport;
2622 memcpy(lpCaps, &wocA, min(uSize, sizeof(wocA)));
2623 }
2624 return ret;
2625 }
2626
2627 /**************************************************************************
2628 * waveOutGetDevCapsW [WINMM.@]
2629 */
2630 UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
2631 UINT uSize)
2632 {
2633 WAVEOUTCAPSW mapper_caps, *caps;
2634 HRESULT hr;
2635
2636 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
2637
2638 hr = WINMM_InitMMDevices();
2639 if(FAILED(hr))
2640 return MMSYSERR_NODRIVER;
2641
2642 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2643
2644 if(WINMM_IsMapper(uDeviceID)){
2645 /* FIXME: Should be localized */
2646 static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
2647 'n','d',' ','M','a','p','p','e','r',0};
2648
2649 mapper_caps.wMid = 0xFF;
2650 mapper_caps.wPid = 0xFF;
2651 mapper_caps.vDriverVersion = 0x00010001;
2652 mapper_caps.dwFormats = 0xFFFFFFFF;
2653 mapper_caps.wReserved1 = 0;
2654 mapper_caps.dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME |
2655 WAVECAPS_SAMPLEACCURATE;
2656 mapper_caps.wChannels = 2;
2657 lstrcpyW(mapper_caps.szPname, mapper_pnameW);
2658
2659 caps = &mapper_caps;
2660 }else{
2661 if(uDeviceID >= g_outmmdevices_count)
2662 return MMSYSERR_BADDEVICEID;
2663
2664 caps = &read_map(g_out_map, uDeviceID)->out_caps;
2665 }
2666
2667 memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
2668
2669 return MMSYSERR_NOERROR;
2670 }
2671
2672 /**************************************************************************
2673 * waveOutGetErrorTextA [WINMM.@]
2674 * waveInGetErrorTextA [WINMM.@]
2675 */
2676 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2677 {
2678 UINT ret;
2679
2680 if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2681 else if (uSize == 0) ret = MMSYSERR_NOERROR;
2682 else
2683 {
2684 LPWSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
2685 if (!xstr) ret = MMSYSERR_NOMEM;
2686 else
2687 {
2688 ret = waveOutGetErrorTextW(uError, xstr, uSize);
2689 if (ret == MMSYSERR_NOERROR)
2690 WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL);
2691 HeapFree(GetProcessHeap(), 0, xstr);
2692 }
2693 }
2694 return ret;
2695 }
2696
2697 /**************************************************************************
2698 * waveOutGetErrorTextW [WINMM.@]
2699 * waveInGetErrorTextW [WINMM.@]
2700 */
2701 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2702 {
2703 UINT ret = MMSYSERR_BADERRNUM;
2704
2705 if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
2706 else if (uSize == 0) ret = MMSYSERR_NOERROR;
2707 else if (
2708 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2709 * a warning for the test was always true */
2710 (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
2711 (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) {
2712 if (LoadStringW(hWinMM32Instance,
2713 uError, lpText, uSize) > 0) {
2714 ret = MMSYSERR_NOERROR;
2715 }
2716 }
2717 return ret;
2718 }
2719
2720 /**************************************************************************
2721 * waveOutOpen [WINMM.@]
2722 * All the args/structs have the same layout as the win16 equivalents
2723 */
2724 MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
2725 LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2726 DWORD_PTR dwInstance, DWORD dwFlags)
2727 {
2728 LRESULT res;
2729 WINMM_OpenInfo info;
2730 WINMM_CBInfo cb_info;
2731
2732 TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut, uDeviceID, lpFormat,
2733 dwCallback, dwInstance, dwFlags);
2734
2735 if(!lphWaveOut && !(dwFlags & WAVE_FORMAT_QUERY))
2736 return MMSYSERR_INVALPARAM;
2737
2738 res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
2739 if(res != MMSYSERR_NOERROR)
2740 return res;
2741
2742 if(!WINMM_StartDevicesThread())
2743 return MMSYSERR_NODRIVER;
2744
2745 info.handle = 0;
2746 info.format = (WAVEFORMATEX*)lpFormat;
2747 info.callback = dwCallback;
2748 info.cb_user = dwInstance;
2749 info.req_device = uDeviceID;
2750 info.flags = dwFlags;
2751 info.reset = TRUE;
2752
2753 res = SendMessageW(g_devices_hwnd, WODM_OPEN, (DWORD_PTR)&info, 0);
2754 InterlockedDecrement(&g_devthread_token);
2755 if(res != MMSYSERR_NOERROR || (dwFlags & WAVE_FORMAT_QUERY))
2756 return res;
2757
2758 if(lphWaveOut)
2759 *lphWaveOut = (HWAVEOUT)info.handle;
2760
2761 cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2762 cb_info.callback = dwCallback;
2763 cb_info.user = dwInstance;
2764 cb_info.hwave = info.handle;
2765
2766 WINMM_NotifyClient(&cb_info, WOM_OPEN, 0, 0);
2767
2768 return res;
2769 }
2770
2771 /**************************************************************************
2772 * waveOutClose [WINMM.@]
2773 */
2774 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
2775 {
2776 UINT res;
2777 WINMM_Device *device;
2778 WINMM_CBInfo cb_info;
2779
2780 TRACE("(%p)\n", hWaveOut);
2781
2782 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2783
2784 if(!WINMM_ValidateAndLock(device))
2785 return MMSYSERR_INVALHANDLE;
2786
2787 cb_info = device->cb_info;
2788
2789 LeaveCriticalSection(&device->lock);
2790
2791 res = SendMessageW(g_devices_hwnd, WODM_CLOSE, (WPARAM)hWaveOut, 0);
2792
2793 if(res == MMSYSERR_NOERROR)
2794 WINMM_NotifyClient(&cb_info, WOM_CLOSE, 0, 0);
2795
2796 return res;
2797 }
2798
2799 /**************************************************************************
2800 * waveOutPrepareHeader [WINMM.@]
2801 */
2802 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
2803 WAVEHDR* lpWaveOutHdr, UINT uSize)
2804 {
2805 TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2806
2807 if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2808 return MMSYSERR_INVALPARAM;
2809
2810 if(lpWaveOutHdr->dwFlags & WHDR_PREPARED)
2811 return MMSYSERR_NOERROR;
2812
2813 return WINMM_PrepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2814 }
2815
2816 /**************************************************************************
2817 * waveOutUnprepareHeader [WINMM.@]
2818 */
2819 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
2820 LPWAVEHDR lpWaveOutHdr, UINT uSize)
2821 {
2822 TRACE("(%p, %p, %u)\n", hWaveOut, lpWaveOutHdr, uSize);
2823
2824 if(!lpWaveOutHdr || uSize < sizeof(WAVEHDR))
2825 return MMSYSERR_INVALPARAM;
2826
2827 if(lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2828 return WAVERR_STILLPLAYING;
2829
2830 if(!(lpWaveOutHdr->dwFlags & WHDR_PREPARED))
2831 return MMSYSERR_NOERROR;
2832
2833 return WINMM_UnprepareHeader((HWAVE)hWaveOut, lpWaveOutHdr);
2834 }
2835
2836 /**************************************************************************
2837 * waveOutWrite [WINMM.@]
2838 */
2839 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR *header, UINT uSize)
2840 {
2841 WINMM_Device *device;
2842 MMRESULT mr;
2843
2844 TRACE("(%p, %p, %u)\n", hWaveOut, header, uSize);
2845
2846 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2847
2848 if(!WINMM_ValidateAndLock(device))
2849 return MMSYSERR_INVALHANDLE;
2850
2851 if(!header->lpData || !(header->dwFlags & WHDR_PREPARED)){
2852 LeaveCriticalSection(&device->lock);
2853 return WAVERR_UNPREPARED;
2854 }
2855
2856 if(header->dwFlags & WHDR_INQUEUE){
2857 LeaveCriticalSection(&device->lock);
2858 return WAVERR_STILLPLAYING;
2859 }
2860
2861 TRACE("dwBufferLength: %u\n", header->dwBufferLength);
2862
2863 if(device->acm_handle){
2864 ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
2865
2866 ash->cbSrcLength = header->dwBufferLength;
2867 mr = acmStreamConvert(device->acm_handle, ash, 0);
2868 if(mr != MMSYSERR_NOERROR){
2869 LeaveCriticalSection(&device->lock);
2870 return mr;
2871 }
2872 }
2873
2874 if(device->first){
2875 device->last->lpNext = header;
2876 device->last = header;
2877 if(!device->playing)
2878 device->playing = header;
2879 }else{
2880 device->playing = device->first = device->last = header;
2881 if(header->dwFlags & WHDR_BEGINLOOP){
2882 device->loop_counter = header->dwLoops;
2883 device->loop_start = header;
2884 }
2885 }
2886
2887 header->lpNext = NULL;
2888 header->dwFlags &= ~WHDR_DONE;
2889 header->dwFlags |= WHDR_INQUEUE;
2890
2891 mr = WINMM_BeginPlaying(device);
2892
2893 LeaveCriticalSection(&device->lock);
2894
2895 return mr;
2896 }
2897
2898 /**************************************************************************
2899 * waveOutBreakLoop [WINMM.@]
2900 */
2901 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
2902 {
2903 WINMM_Device *device;
2904
2905 TRACE("(%p)\n", hWaveOut);
2906
2907 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2908
2909 if(!WINMM_ValidateAndLock(device))
2910 return MMSYSERR_INVALHANDLE;
2911
2912 device->loop_counter = 0;
2913
2914 LeaveCriticalSection(&device->lock);
2915
2916 return MMSYSERR_NOERROR;
2917 }
2918
2919 /**************************************************************************
2920 * waveOutPause [WINMM.@]
2921 */
2922 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
2923 {
2924 TRACE("(%p)\n", hWaveOut);
2925
2926 return WINMM_Pause((HWAVE)hWaveOut);
2927 }
2928
2929 /**************************************************************************
2930 * waveOutReset [WINMM.@]
2931 */
2932 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
2933 {
2934 TRACE("(%p)\n", hWaveOut);
2935
2936 return WINMM_Reset((HWAVE)hWaveOut);
2937 }
2938
2939 /**************************************************************************
2940 * waveOutRestart [WINMM.@]
2941 */
2942 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
2943 {
2944 WINMM_Device *device;
2945 MMRESULT mr;
2946
2947 TRACE("(%p)\n", hWaveOut);
2948
2949 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
2950
2951 if(!WINMM_ValidateAndLock(device))
2952 return MMSYSERR_INVALHANDLE;
2953
2954 device->stopped = TRUE;
2955
2956 mr = WINMM_BeginPlaying(device);
2957
2958 LeaveCriticalSection(&device->lock);
2959
2960 return mr;
2961 }
2962
2963 /**************************************************************************
2964 * waveOutGetPosition [WINMM.@]
2965 */
2966 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
2967 UINT uSize)
2968 {
2969 TRACE("(%p, %p, %u)\n", hWaveOut, lpTime, uSize);
2970
2971 if(!uSize || !lpTime || uSize != sizeof(MMTIME))
2972 return MMSYSERR_INVALPARAM;
2973
2974 return WINMM_GetPosition((HWAVE)hWaveOut, lpTime);
2975 }
2976
2977 /**************************************************************************
2978 * waveOutGetPitch [WINMM.@]
2979 */
2980 UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
2981 {
2982 TRACE("(%p, %p)\n", hWaveOut, lpdw);
2983 return MMSYSERR_NOTSUPPORTED;
2984 }
2985
2986 /**************************************************************************
2987 * waveOutSetPitch [WINMM.@]
2988 */
2989 UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
2990 {
2991 TRACE("(%p, %08x)\n", hWaveOut, dw);
2992
2993 return MMSYSERR_NOTSUPPORTED;
2994 }
2995
2996 /**************************************************************************
2997 * waveOutGetPlaybackRate [WINMM.@]
2998 */
2999 UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
3000 {
3001 TRACE("(%p, %p)\n", hWaveOut, lpdw);
3002
3003 return MMSYSERR_NOTSUPPORTED;
3004 }
3005
3006 /**************************************************************************
3007 * waveOutSetPlaybackRate [WINMM.@]
3008 */
3009 UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
3010 {
3011 TRACE("(%p, %08x)\n", hWaveOut, dw);
3012
3013 return MMSYSERR_NOTSUPPORTED;
3014 }
3015
3016 /**************************************************************************
3017 * waveOutGetVolume [WINMM.@]
3018 */
3019 UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, DWORD *out)
3020 {
3021 WINMM_Device *device;
3022 UINT32 channels;
3023 float *vols;
3024 HRESULT hr;
3025
3026 TRACE("(%p, %p)\n", hWaveOut, out);
3027
3028 if(!out)
3029 return MMSYSERR_INVALPARAM;
3030
3031 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
3032
3033 if(!WINMM_ValidateAndLock(device))
3034 return MMSYSERR_INVALHANDLE;
3035
3036 hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
3037 if(FAILED(hr)){
3038 LeaveCriticalSection(&device->lock);
3039 WARN("GetChannelCount failed: %08x\n", hr);
3040 return MMSYSERR_ERROR;
3041 }
3042
3043 vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
3044 if(!vols){
3045 LeaveCriticalSection(&device->lock);
3046 return MMSYSERR_NOMEM;
3047 }
3048
3049 hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
3050 if(FAILED(hr)){
3051 LeaveCriticalSection(&device->lock);
3052 HeapFree(GetProcessHeap(), 0, vols);
3053 WARN("GetAllVolumes failed: %08x\n", hr);
3054 return MMSYSERR_ERROR;
3055 }
3056
3057 LeaveCriticalSection(&device->lock);
3058
3059 *out = ((UINT16)(vols[0] * (DWORD)0xFFFF));
3060 if(channels > 1)
3061 *out |= ((UINT16)(vols[1] * (DWORD)0xFFFF)) << 16;
3062
3063 HeapFree(GetProcessHeap(), 0, vols);
3064
3065 return MMSYSERR_NOERROR;
3066 }
3067
3068 /**************************************************************************
3069 * waveOutSetVolume [WINMM.@]
3070 */
3071 UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
3072 {
3073 WINMM_Device *device;
3074 UINT32 channels;
3075 float *vols;
3076 HRESULT hr;
3077
3078 TRACE("(%p, %08x)\n", hWaveOut, in);
3079
3080 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
3081
3082 if(!WINMM_ValidateAndLock(device))
3083 return MMSYSERR_INVALHANDLE;
3084
3085 hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
3086 if(FAILED(hr)){
3087 LeaveCriticalSection(&device->lock);
3088 WARN("GetChannelCount failed: %08x\n", hr);
3089 return MMSYSERR_ERROR;
3090 }
3091
3092 vols = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * channels);
3093 if(!vols){
3094 LeaveCriticalSection(&device->lock);
3095 return MMSYSERR_NOMEM;
3096 }
3097
3098 hr = IAudioStreamVolume_GetAllVolumes(device->volume, channels, vols);
3099 if(FAILED(hr)){
3100 LeaveCriticalSection(&device->lock);
3101 HeapFree(GetProcessHeap(), 0, vols);
3102 WARN("GetAllVolumes failed: %08x\n", hr);
3103 return MMSYSERR_ERROR;
3104 }
3105
3106 vols[0] = (float)((DWORD)(in & 0xFFFF) / (float)0xFFFF);
3107 if(channels > 1)
3108 vols[1] = (float)((DWORD)(in >> 16) / (float)0xFFFF);
3109
3110 hr = IAudioStreamVolume_SetAllVolumes(device->volume, channels, vols);
3111 if(FAILED(hr)){
3112 LeaveCriticalSection(&device->lock);
3113 HeapFree(GetProcessHeap(), 0, vols);
3114 WARN("SetAllVolumes failed: %08x\n", hr);
3115 return MMSYSERR_ERROR;
3116 }
3117
3118 LeaveCriticalSection(&device->lock);
3119
3120 HeapFree(GetProcessHeap(), 0, vols);
3121
3122 return MMSYSERR_NOERROR;
3123 }
3124
3125 /**************************************************************************
3126 * waveOutGetID [WINMM.@]
3127 */
3128 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
3129 {
3130 WINMM_Device *device;
3131 UINT dev, junk;
3132 BOOL is_out;
3133
3134 TRACE("(%p, %p)\n", hWaveOut, lpuDeviceID);
3135
3136 if(!lpuDeviceID)
3137 return MMSYSERR_INVALPARAM;
3138
3139 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
3140 if(!WINMM_ValidateAndLock(device))
3141 return MMSYSERR_INVALHANDLE;
3142
3143 LeaveCriticalSection(&device->lock);
3144
3145 WINMM_DecomposeHWAVE((HWAVE)hWaveOut, lpuDeviceID, &is_out, &dev, &junk);
3146
3147 return MMSYSERR_NOERROR;
3148 }
3149
3150 static UINT WINMM_QueryInstanceIDSize(UINT device, DWORD_PTR *len, BOOL is_out)
3151 {
3152 UINT count;
3153 WINMM_MMDevice **devices;
3154
3155 TRACE("(%u, %p, %d)\n", device, len, is_out);
3156
3157 if(is_out){
3158 count = g_outmmdevices_count;
3159 devices = g_out_map;
3160 }else{
3161 count = g_inmmdevices_count;
3162 devices = g_in_map;
3163 }
3164
3165 if(device >= count)
3166 return MMSYSERR_INVALHANDLE;
3167
3168 EnterCriticalSection(&g_devthread_lock);
3169 *len = (lstrlenW(devices[device]->dev_id) + 1) * sizeof(WCHAR);
3170 LeaveCriticalSection(&g_devthread_lock);
3171
3172 return MMSYSERR_NOERROR;
3173 }
3174
3175 static UINT WINMM_QueryInstanceID(UINT device, WCHAR *str, DWORD_PTR len,
3176 BOOL is_out)
3177 {
3178 UINT count, id_len;
3179 WINMM_MMDevice **devices;
3180
3181 TRACE("(%u, %p, %d)\n", device, str, is_out);
3182
3183 if(is_out){
3184 count = g_outmmdevices_count;
3185 devices = g_out_map;
3186 }else{
3187 count = g_inmmdevices_count;
3188 devices = g_in_map;
3189 }
3190
3191 if(device >= count)
3192 return MMSYSERR_INVALHANDLE;
3193
3194 EnterCriticalSection(&g_devthread_lock);
3195 id_len = (lstrlenW(devices[device]->dev_id) + 1) * sizeof(WCHAR);
3196 if(len < id_len){
3197 LeaveCriticalSection(&g_devthread_lock);
3198 return MMSYSERR_ERROR;
3199 }
3200
3201 memcpy(str, devices[device]->dev_id, id_len);
3202 LeaveCriticalSection(&g_devthread_lock);
3203
3204 return MMSYSERR_NOERROR;
3205 }
3206
3207 static UINT get_device_interface(UINT msg, BOOL is_out, UINT index, WCHAR *out, ULONG *out_len)
3208 {
3209 WINMM_QueryInterfaceInfo info;
3210 UINT ret;
3211
3212 if(!WINMM_StartDevicesThread())
3213 return MMSYSERR_NODRIVER;
3214
3215 info.is_out = is_out;
3216 info.index = index;
3217 info.str = out;
3218 info.len_bytes = out_len;
3219
3220 ret = SendMessageW(g_devices_hwnd, msg, (DWORD_PTR)&info, 0);
3221 InterlockedDecrement(&g_devthread_token);
3222 return ret;
3223 }
3224
3225 /**************************************************************************
3226 * waveOutMessage [WINMM.@]
3227 */
3228 UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
3229 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3230 {
3231 TRACE("(%p, %u, %lx, %lx)\n", hWaveOut, uMessage, dwParam1, dwParam2);
3232
3233 switch(uMessage){
3234 case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
3235 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveOut),
3236 (DWORD_PTR*)dwParam1, TRUE);
3237 case DRV_QUERYFUNCTIONINSTANCEID:
3238 return WINMM_QueryInstanceID(HandleToULong(hWaveOut), (WCHAR*)dwParam1, dwParam2, TRUE);
3239 case DRV_QUERYDEVICEINTERFACESIZE:
3240 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE, TRUE, HandleToULong(hWaveOut),
3241 NULL, (ULONG*)dwParam1);
3242 case DRV_QUERYDEVICEINTERFACE:
3243 {
3244 ULONG size = dwParam2;
3245 return get_device_interface(DRV_QUERYDEVICEINTERFACE, TRUE, HandleToULong(hWaveOut),
3246 (WCHAR*)dwParam1, &size);
3247 }
3248 case DRV_QUERYMAPPABLE:
3249 return MMSYSERR_NOERROR;
3250 case DRVM_MAPPER_PREFERRED_GET:
3251 if(dwParam1) {
3252 if(g_outmmdevices_count > 0)
3253 /* Device 0 is always the default device */
3254 *(DWORD *)dwParam1 = 0;
3255 else
3256 *(DWORD *)dwParam1 = -1;
3257 }
3258
3259 if(dwParam2)
3260 /* Status flags */
3261 *(DWORD *)dwParam2 = 0;
3262
3263 return MMSYSERR_NOERROR;
3264 }
3265
3266 TRACE("Message not supported: %u\n", uMessage);
3267
3268 return MMSYSERR_NOTSUPPORTED;
3269 }
3270
3271 /**************************************************************************
3272 * waveInGetNumDevs [WINMM.@]
3273 */
3274 UINT WINAPI waveInGetNumDevs(void)
3275 {
3276 HRESULT hr = WINMM_InitMMDevices();
3277 if(FAILED(hr))
3278 return 0;
3279
3280 TRACE("count: %u\n", g_inmmdevices_count);
3281
3282 return g_inmmdevices_count;
3283 }
3284
3285 /**************************************************************************
3286 * waveInGetDevCapsW [WINMM.@]
3287 */
3288 UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
3289 {
3290 WAVEINCAPSW mapper_caps, *caps;
3291 HRESULT hr;
3292
3293 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3294
3295 hr = WINMM_InitMMDevices();
3296 if(FAILED(hr))
3297 return MMSYSERR_NODRIVER;
3298
3299 if(!lpCaps)
3300 return MMSYSERR_INVALPARAM;
3301
3302 if(WINMM_IsMapper(uDeviceID)){
3303 /* FIXME: Should be localized */
3304 static const WCHAR mapper_pnameW[] = {'W','i','n','e',' ','S','o','u',
3305 'n','d',' ','M','a','p','p','e','r',0};
3306
3307 mapper_caps.wMid = 0xFF;
3308 mapper_caps.wPid = 0xFF;
3309 mapper_caps.vDriverVersion = 0x00010001;
3310 mapper_caps.dwFormats = 0xFFFFFFFF;
3311 mapper_caps.wReserved1 = 0;
3312 mapper_caps.wChannels = 2;
3313 lstrcpyW(mapper_caps.szPname, mapper_pnameW);
3314
3315 caps = &mapper_caps;
3316 }else{
3317 if(uDeviceID >= g_inmmdevices_count)
3318 return MMSYSERR_BADDEVICEID;
3319
3320 caps = &read_map(g_in_map, uDeviceID)->in_caps;
3321 }
3322
3323 memcpy(lpCaps, caps, min(uSize, sizeof(*lpCaps)));
3324
3325 return MMSYSERR_NOERROR;
3326 }
3327
3328 /**************************************************************************
3329 * waveInGetDevCapsA [WINMM.@]
3330 */
3331 UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
3332 {
3333 UINT ret;
3334 WAVEINCAPSW wicW;
3335
3336 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3337
3338 if(!lpCaps)
3339 return MMSYSERR_INVALPARAM;
3340
3341 ret = waveInGetDevCapsW(uDeviceID, &wicW, sizeof(wicW));
3342
3343 if (ret == MMSYSERR_NOERROR) {
3344 WAVEINCAPSA wicA;
3345 wicA.wMid = wicW.wMid;
3346 wicA.wPid = wicW.wPid;
3347 wicA.vDriverVersion = wicW.vDriverVersion;
3348 WideCharToMultiByte( CP_ACP, 0, wicW.szPname, -1, wicA.szPname,
3349 sizeof(wicA.szPname), NULL, NULL );
3350 wicA.dwFormats = wicW.dwFormats;
3351 wicA.wChannels = wicW.wChannels;
3352 memcpy(lpCaps, &wicA, min(uSize, sizeof(wicA)));
3353 }
3354 return ret;
3355 }
3356
3357 /**************************************************************************
3358 * waveInOpen [WINMM.@]
3359 */
3360 MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
3361 LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
3362 DWORD_PTR dwInstance, DWORD dwFlags)
3363 {
3364 LRESULT res;
3365 WINMM_OpenInfo info;
3366 WINMM_CBInfo cb_info;
3367
3368 TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn, uDeviceID, lpFormat,
3369 dwCallback, dwInstance, dwFlags);
3370
3371 if(!lphWaveIn && !(dwFlags & WAVE_FORMAT_QUERY))
3372 return MMSYSERR_INVALPARAM;
3373
3374 res = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
3375 if(res != MMSYSERR_NOERROR)
3376 return res;
3377
3378 if(!WINMM_StartDevicesThread())
3379 return MMSYSERR_NODRIVER;
3380
3381 info.handle = 0;
3382 info.format = (WAVEFORMATEX*)lpFormat;
3383 info.callback = dwCallback;
3384 info.cb_user = dwInstance;
3385 info.req_device = uDeviceID;
3386 info.flags = dwFlags;
3387 info.reset = TRUE;
3388
3389 res = SendMessageW(g_devices_hwnd, WIDM_OPEN, (DWORD_PTR)&info, 0);
3390 InterlockedDecrement(&g_devthread_token);
3391 if(res != MMSYSERR_NOERROR || (dwFlags & WAVE_FORMAT_QUERY))
3392 return res;
3393
3394 if(lphWaveIn)
3395 *lphWaveIn = (HWAVEIN)info.handle;
3396
3397 cb_info.flags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
3398 cb_info.callback = dwCallback;
3399 cb_info.user = dwInstance;
3400 cb_info.hwave = info.handle;
3401
3402 WINMM_NotifyClient(&cb_info, WIM_OPEN, 0, 0);
3403
3404 return res;
3405 }
3406
3407 /**************************************************************************
3408 * waveInClose [WINMM.@]
3409 */
3410 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
3411 {
3412 WINMM_Device *device;
3413 WINMM_CBInfo cb_info;
3414 UINT res;
3415
3416 TRACE("(%p)\n", hWaveIn);
3417
3418 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3419
3420 if(!WINMM_ValidateAndLock(device))
3421 return MMSYSERR_INVALHANDLE;
3422
3423 cb_info = device->cb_info;
3424
3425 LeaveCriticalSection(&device->lock);
3426
3427 res = SendMessageW(g_devices_hwnd, WIDM_CLOSE, (WPARAM)hWaveIn, 0);
3428
3429 if(res == MMSYSERR_NOERROR)
3430 WINMM_NotifyClient(&cb_info, WIM_CLOSE, 0, 0);
3431
3432 return res;
3433 }
3434
3435 /**************************************************************************
3436 * waveInPrepareHeader [WINMM.@]
3437 */
3438 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3439 UINT uSize)
3440 {
3441 TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
3442
3443 if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
3444 return MMSYSERR_INVALPARAM;
3445
3446 if(lpWaveInHdr->dwFlags & WHDR_PREPARED)
3447 return MMSYSERR_NOERROR;
3448
3449 return WINMM_PrepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
3450 }
3451
3452 /**************************************************************************
3453 * waveInUnprepareHeader [WINMM.@]
3454 */
3455 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3456 UINT uSize)
3457 {
3458 TRACE("(%p, %p, %u)\n", hWaveIn, lpWaveInHdr, uSize);
3459
3460 if(!lpWaveInHdr || uSize < sizeof(WAVEHDR))
3461 return MMSYSERR_INVALPARAM;
3462
3463 if(lpWaveInHdr->dwFlags & WHDR_INQUEUE)
3464 return WAVERR_STILLPLAYING;
3465
3466 if(!(lpWaveInHdr->dwFlags & WHDR_PREPARED))
3467 return MMSYSERR_NOERROR;
3468
3469 return WINMM_UnprepareHeader((HWAVE)hWaveIn, lpWaveInHdr);
3470 }
3471
3472 /**************************************************************************
3473 * waveInAddBuffer [WINMM.@]
3474 */
3475 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn, WAVEHDR *header, UINT uSize)
3476 {
3477 WINMM_Device *device;
3478
3479 TRACE("(%p, %p, %u)\n", hWaveIn, header, uSize);
3480
3481 if(!header || uSize < sizeof(WAVEHDR))
3482 return MMSYSERR_INVALPARAM;
3483
3484 if(!(header->dwFlags & WHDR_PREPARED))
3485 return WAVERR_UNPREPARED;
3486
3487 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3488
3489 if(!WINMM_ValidateAndLock(device))
3490 return MMSYSERR_INVALHANDLE;
3491
3492 if(!device->first)
3493 device->first = device->last = header;
3494 else{
3495 device->last->lpNext = header;
3496 device->last = header;
3497 }
3498
3499 header->dwBytesRecorded = 0;
3500 header->lpNext = NULL;
3501 header->dwFlags &= ~WHDR_DONE;
3502 header->dwFlags |= WHDR_INQUEUE;
3503
3504 LeaveCriticalSection(&device->lock);
3505
3506 return MMSYSERR_NOERROR;
3507 }
3508
3509 /**************************************************************************
3510 * waveInReset [WINMM.@]
3511 */
3512 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
3513 {
3514 TRACE("(%p)\n", hWaveIn);
3515
3516 return WINMM_Reset((HWAVE)hWaveIn);
3517 }
3518
3519 /**************************************************************************
3520 * waveInStart [WINMM.@]
3521 */
3522 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
3523 {
3524 WINMM_Device *device;
3525 MMRESULT mr;
3526
3527 TRACE("(%p)\n", hWaveIn);
3528
3529 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3530
3531 if(!WINMM_ValidateAndLock(device))
3532 return MMSYSERR_INVALHANDLE;
3533
3534 mr = WINMM_BeginPlaying(device);
3535
3536 LeaveCriticalSection(&device->lock);
3537
3538 return mr;
3539 }
3540
3541 /**************************************************************************
3542 * waveInStop [WINMM.@]
3543 */
3544 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
3545 {
3546 WINMM_CBInfo cb_info;
3547 WINMM_Device *device;
3548 WAVEHDR *buf;
3549 HRESULT hr;
3550
3551 TRACE("(%p)\n", hWaveIn);
3552
3553 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3554
3555 if(!WINMM_ValidateAndLock(device))
3556 return MMSYSERR_INVALHANDLE;
3557
3558 hr = WINMM_Pause((HWAVE)hWaveIn);
3559 if(FAILED(hr)){
3560 LeaveCriticalSection(&device->lock);
3561 return MMSYSERR_ERROR;
3562 }
3563 device->stopped = TRUE;
3564
3565 buf = device->first;
3566 if(buf && buf->dwBytesRecorded > 0){
3567 device->first = buf->lpNext;
3568 }else
3569 buf = NULL;
3570
3571 cb_info = device->cb_info;
3572
3573 LeaveCriticalSection(&device->lock);
3574
3575 if(buf){
3576 buf->dwFlags &= ~WHDR_INQUEUE;
3577 buf->dwFlags |= WHDR_DONE;
3578 WINMM_NotifyClient(&cb_info, WIM_DATA, (DWORD_PTR)buf, 0);
3579 }
3580
3581 return MMSYSERR_NOERROR;
3582 }
3583
3584 /**************************************************************************
3585 * waveInGetPosition [WINMM.@]
3586 */
3587 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
3588 UINT uSize)
3589 {
3590 TRACE("(%p, %p, %u)\n", hWaveIn, lpTime, uSize);
3591
3592 if(!uSize || !lpTime || uSize != sizeof(MMTIME))
3593 return MMSYSERR_INVALPARAM;
3594
3595 return WINMM_GetPosition((HWAVE)hWaveIn, lpTime);
3596 }
3597
3598 /**************************************************************************
3599 * waveInGetID [WINMM.@]
3600 */
3601 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
3602 {
3603 UINT dev, junk;
3604 BOOL is_out;
3605 WINMM_Device *device;
3606
3607 TRACE("(%p, %p)\n", hWaveIn, lpuDeviceID);
3608
3609 if(!lpuDeviceID)
3610 return MMSYSERR_INVALPARAM;
3611
3612 device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveIn);
3613 if(!WINMM_ValidateAndLock(device))
3614 return MMSYSERR_INVALHANDLE;
3615
3616 LeaveCriticalSection(&device->lock);
3617
3618 WINMM_DecomposeHWAVE((HWAVE)hWaveIn, lpuDeviceID, &is_out, &dev, &junk);
3619
3620 return MMSYSERR_NOERROR;
3621 }
3622
3623 /**************************************************************************
3624 * waveInMessage [WINMM.@]
3625 */
3626 UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
3627 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3628 {
3629 TRACE("(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
3630
3631 switch(uMessage){
3632 case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
3633 return WINMM_QueryInstanceIDSize(HandleToULong(hWaveIn),
3634 (DWORD_PTR*)dwParam1, FALSE);
3635 case DRV_QUERYFUNCTIONINSTANCEID:
3636 return WINMM_QueryInstanceID(HandleToULong(hWaveIn), (WCHAR*)dwParam1, dwParam2, FALSE);
3637 case DRV_QUERYDEVICEINTERFACESIZE:
3638 return get_device_interface(DRV_QUERYDEVICEINTERFACESIZE, FALSE, HandleToULong(hWaveIn),
3639 NULL, (ULONG*)dwParam1);
3640 case DRV_QUERYDEVICEINTERFACE:
3641 {
3642 ULONG size = dwParam2;
3643 return get_device_interface(DRV_QUERYDEVICEINTERFACE, FALSE, HandleToULong(hWaveIn),
3644 (WCHAR*)dwParam1, &size);
3645 }
3646 case DRV_QUERYMAPPABLE:
3647 return MMSYSERR_NOERROR;
3648 case DRVM_MAPPER_PREFERRED_GET:
3649 if(dwParam1) {
3650 if(g_inmmdevices_count > 0)
3651 /* Device 0 is always the default device */
3652 *(DWORD *)dwParam1 = 0;
3653 else
3654 *(DWORD *)dwParam1 = -1;
3655 }
3656
3657 if(dwParam2)
3658 /* Status flags */
3659 *(DWORD *)dwParam2 = 0;
3660
3661 return MMSYSERR_NOERROR;
3662 }
3663
3664 TRACE("Message not supported: %u\n", uMessage);
3665
3666 return MMSYSERR_NOTSUPPORTED;
3667 }
3668
3669 UINT WINAPI mixerGetNumDevs(void)
3670 {
3671 HRESULT hr;
3672
3673 TRACE("\n");
3674
3675 hr = WINMM_InitMMDevices();
3676 if(FAILED(hr))
3677 return 0;
3678
3679 return g_outmmdevices_count + g_inmmdevices_count;
3680 }
3681
3682 /**************************************************************************
3683 * mixerGetDevCapsA [WINMM.@]
3684 */
3685 UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
3686 {
3687 MIXERCAPSW micW;
3688 UINT ret;
3689
3690 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3691
3692 if(!lpCaps)
3693 return MMSYSERR_INVALPARAM;
3694
3695 ret = mixerGetDevCapsW(uDeviceID, &micW, sizeof(micW));
3696
3697 if (ret == MMSYSERR_NOERROR) {
3698 MIXERCAPSA micA;
3699 micA.wMid = micW.wMid;
3700 micA.wPid = micW.wPid;
3701 micA.vDriverVersion = micW.vDriverVersion;
3702 WideCharToMultiByte( CP_ACP, 0, micW.szPname, -1, micA.szPname,
3703 sizeof(micA.szPname), NULL, NULL );
3704 micA.fdwSupport = micW.fdwSupport;
3705 micA.cDestinations = micW.cDestinations;
3706 memcpy(lpCaps, &micA, min(uSize, sizeof(micA)));
3707 }
3708 return ret;
3709 }
3710
3711 /**************************************************************************
3712 * mixerGetDevCapsW [WINMM.@]
3713 */
3714 UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
3715 {
3716 WINMM_MMDevice *mmdevice;
3717 MIXERCAPSW caps;
3718 HRESULT hr;
3719
3720 TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
3721
3722 hr = WINMM_InitMMDevices();
3723 if(FAILED(hr))
3724 return MMSYSERR_NODRIVER;
3725
3726 if(!lpCaps)
3727 return MMSYSERR_INVALPARAM;
3728
3729 if(!uSize)
3730 return MMSYSERR_NOERROR;
3731
3732 if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3733 return MMSYSERR_BADDEVICEID;
3734
3735 if(uDeviceID < g_outmmdevices_count){
3736 mmdevice = read_map(g_out_map, uDeviceID);
3737 memcpy(caps.szPname, mmdevice->out_caps.szPname, sizeof(caps.szPname));
3738 }else{
3739 mmdevice = read_map(g_in_map, uDeviceID - g_outmmdevices_count);
3740 memcpy(caps.szPname, mmdevice->in_caps.szPname, sizeof(caps.szPname));
3741 }
3742
3743 caps.wMid = 0xFF;
3744 caps.wPid = 0xFF;
3745 caps.vDriverVersion = 0x00010001;
3746 caps.fdwSupport = 0;
3747 caps.cDestinations = 1;
3748
3749 memcpy(lpCaps, &caps, uSize);
3750
3751 return MMSYSERR_NOERROR;
3752 }
3753
3754 /**************************************************************************
3755 * mixerOpen [WINMM.@]
3756 */
3757 UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
3758 DWORD_PTR dwInstance, DWORD fdwOpen)
3759 {
3760 WINMM_MMDevice *mmdevice;
3761 MMRESULT mr;
3762 HRESULT hr;
3763
3764 TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix, uDeviceID, dwCallback,
3765 dwInstance, fdwOpen);
3766
3767 hr = WINMM_InitMMDevices();
3768 if(FAILED(hr))
3769 return MMSYSERR_NODRIVER;
3770
3771 if(!lphMix)
3772 return MMSYSERR_INVALPARAM;
3773
3774 mr = WINMM_CheckCallback(dwCallback, fdwOpen, TRUE);
3775 if(mr != MMSYSERR_NOERROR)
3776 return mr;
3777
3778 if(uDeviceID >= g_outmmdevices_count + g_inmmdevices_count)
3779 return MMSYSERR_BADDEVICEID;
3780
3781 if(uDeviceID < g_outmmdevices_count){
3782 mmdevice = read_map(g_out_map, uDeviceID);
3783 *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID, TRUE,
3784 mmdevice->mixer_count);
3785 }else{
3786 mmdevice = read_map(g_in_map, uDeviceID - g_outmmdevices_count);
3787 *lphMix = (HMIXER)WINMM_MakeHWAVE(uDeviceID - g_outmmdevices_count,
3788 FALSE, mmdevice->mixer_count);
3789 }
3790
3791 ++mmdevice->mixer_count;
3792
3793 return MMSYSERR_NOERROR;
3794 }
3795
3796 /**************************************************************************
3797 * mixerClose [WINMM.@]
3798 */
3799 UINT WINAPI mixerClose(HMIXER hMix)
3800 {
3801 TRACE("(%p)\n", hMix);
3802
3803 return MMSYSERR_NOERROR;
3804 }
3805
3806 /**************************************************************************
3807 * mixerGetID [WINMM.@]
3808 */
3809 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
3810 {
3811 WINMM_MMDevice *mmdevice;
3812 HRESULT hr;
3813
3814 TRACE("(%p, %p, %x)\n", hmix, lpid, fdwID);
3815
3816 hr = WINMM_InitMMDevices();
3817 if(FAILED(hr))
3818 return MMSYSERR_NODRIVER;
3819
3820 if(!lpid)
3821 return MMSYSERR_INVALPARAM;
3822
3823 mmdevice = WINMM_GetMixerMMDevice(hmix, fdwID, lpid);
3824 if(!mmdevice)
3825 return MMSYSERR_INVALHANDLE;
3826
3827 if(mmdevice->in_caps.szPname[0] != '\0')
3828 *lpid += g_outmmdevices_count;
3829
3830 return MMSYSERR_NOERROR;
3831 }
3832
3833 /**************************************************************************
3834 * mixerGetControlDetailsW [WINMM.@]
3835 */
3836 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW,
3837 DWORD fdwDetails)
3838 {
3839 WINMM_ControlDetails details;
3840 HRESULT hr;
3841
3842 TRACE("(%p, %p, %x)\n", hmix, lpmcdW, fdwDetails);
3843
3844 hr = WINMM_InitMMDevices();
3845 if(FAILED(hr))
3846 return MMSYSERR_NODRIVER;
3847
3848 if(!lpmcdW)
3849 return MMSYSERR_INVALPARAM;
3850
3851 TRACE("dwControlID: %u\n", lpmcdW->dwControlID);
3852
3853 details.hmix = hmix;
3854 details.details = lpmcdW;
3855 details.flags = fdwDetails;
3856
3857 return SendMessageW(g_devices_hwnd, MXDM_GETCONTROLDETAILS,
3858 (DWORD_PTR)&details, 0);
3859 }
3860
3861 /**************************************************************************
3862 * mixerGetControlDetailsA [WINMM.@]
3863 */
3864 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
3865 DWORD fdwDetails)
3866 {
3867 UINT ret = MMSYSERR_NOTSUPPORTED;
3868
3869 TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
3870
3871 if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
3872 return MMSYSERR_INVALPARAM;
3873
3874 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
3875 case MIXER_GETCONTROLDETAILSF_VALUE:
3876 /* can safely use A structure as it is, no string inside */
3877 ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3878 break;
3879 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
3880 {
3881 MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = lpmcdA->paDetails;
3882 MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW;
3883 int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3884 unsigned int i;
3885
3886 if (lpmcdA->u.cMultipleItems != 0) {
3887 size *= lpmcdA->u.cMultipleItems;
3888 }
3889 pDetailsW = HeapAlloc(GetProcessHeap(), 0, size);
3890 lpmcdA->paDetails = pDetailsW;
3891 lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
3892 /* set up lpmcd->paDetails */
3893 ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
3894 /* copy from lpmcd->paDetails back to paDetailsW; */
3895 if (ret == MMSYSERR_NOERROR) {
3896 for (i = 0; i < lpmcdA->u.cMultipleItems * lpmcdA->cChannels; i++) {
3897 pDetailsA->dwParam1 = pDetailsW->dwParam1;
3898 pDetailsA->dwParam2 = pDetailsW->dwParam2;
3899 WideCharToMultiByte( CP_ACP, 0, pDetailsW->szName, -1,
3900 pDetailsA->szName,
3901 sizeof(pDetailsA->szName), NULL, NULL );
3902 pDetailsA++;
3903 pDetailsW++;
3904 }
3905 pDetailsA -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3906 pDetailsW -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
3907 }
3908 HeapFree(GetProcessHeap(), 0, pDetailsW);
3909 lpmcdA->paDetails = pDetailsA;
3910 lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
3911 }
3912 break;
3913 default:
3914 WARN("Unsupported fdwDetails=0x%08x\n", fdwDetails);
3915 }
3916
3917 return ret;
3918 }
3919
3920 /**************************************************************************
3921 * mixerGetLineControlsA [WINMM.@]
3922 */
3923 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
3924 DWORD fdwControls)
3925 {
3926 MIXERLINECONTROLSW mlcW;
3927 DWORD ret;
3928 unsigned int i;
3929
3930 TRACE("(%p, %p, %x)\n", hmix, lpmlcA, fdwControls);
3931
3932 if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
3933 lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
3934 return MMSYSERR_INVALPARAM;
3935
3936 mlcW.cbStruct = sizeof(mlcW);
3937 mlcW.dwLineID = lpmlcA->dwLineID;
3938 mlcW.u.dwControlID = lpmlcA->u.dwControlID;
3939 mlcW.u.dwControlType = lpmlcA->u.dwControlType;
3940
3941 /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
3942 the control count is assumed to be 1 - This is relied upon by a game,
3943 "Dynomite Deluze" */
3944 if (MIXER_GETLINECONTROLSF_ONEBYTYPE == (fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)) {
3945 mlcW.cControls = 1;
3946 } else {
3947 mlcW.cControls = lpmlcA->cControls;
3948 }
3949 mlcW.cbmxctrl = sizeof(MIXERCONTROLW);
3950 mlcW.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
3951 mlcW.cControls * mlcW.cbmxctrl);
3952
3953 ret = mixerGetLineControlsW(hmix, &mlcW, fdwControls);
3954
3955 if (ret == MMSYSERR_NOERROR) {
3956 lpmlcA->dwLineID = mlcW.dwLineID;
3957 lpmlcA->u.dwControlID = mlcW.u.dwControlID;
3958 lpmlcA->u.dwControlType = mlcW.u.dwControlType;
3959
3960 for (i = 0; i < mlcW.cControls; i++) {
3961 lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA);
3962 lpmlcA->pamxctrl[i].dwControlID = mlcW.pamxctrl[i].dwControlID;
3963 lpmlcA->pamxctrl[i].dwControlType = mlcW.pamxctrl[i].dwControlType;
3964 lpmlcA->pamxctrl[i].fdwControl = mlcW.pamxctrl[i].fdwControl;
3965 lpmlcA->pamxctrl[i].cMultipleItems = mlcW.pamxctrl[i].cMultipleItems;
3966 WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szShortName, -1,
3967 lpmlcA->pamxctrl[i].szShortName,
3968 sizeof(lpmlcA->pamxctrl[i].szShortName), NULL, NULL );
3969 WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szName, -1,
3970 lpmlcA->pamxctrl[i].szName,
3971 sizeof(lpmlcA->pamxctrl[i].szName), NULL, NULL );
3972 /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
3973 * sizeof(mlcW.pamxctrl[i].Bounds) */
3974 memcpy(&lpmlcA->pamxctrl[i].Bounds, &mlcW.pamxctrl[i].Bounds,
3975 sizeof(mlcW.pamxctrl[i].Bounds));
3976 /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
3977 * sizeof(mlcW.pamxctrl[i].Metrics) */
3978 memcpy(&lpmlcA->pamxctrl[i].Metrics, &mlcW.pamxctrl[i].Metrics,
3979 sizeof(mlcW.pamxctrl[i].Metrics));
3980 }
3981 }
3982
3983 HeapFree(GetProcessHeap(), 0, mlcW.pamxctrl);
3984
3985 return ret;
3986 }
3987
3988 static UINT WINMM_GetVolumeLineControl(WINMM_MMDevice *mmdevice, DWORD line,
3989 MIXERCONTROLW *ctl, DWORD flags)
3990 {
3991 ctl->dwControlID = (line == 0xFFFF0000) ? 0 : 2;
3992 ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
3993 ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
3994 ctl->cMultipleItems = 0;
3995 lstrcpyW(ctl->szShortName, volumeW);
3996 lstrcpyW(ctl->szName, volumeW);
3997 ctl->Bounds.s1.dwMinimum = 0;
3998 ctl->Bounds.s1.dwMaximum = 0xFFFF;
3999 ctl->Metrics.cSteps = 192;
4000
4001 return MMSYSERR_NOERROR;
4002 }
4003
4004 static UINT WINMM_GetMuteLineControl(WINMM_MMDevice *mmdevice, DWORD line,
4005 MIXERCONTROLW *ctl, DWORD flags)
4006 {
4007 ctl->dwControlID = (line == 0xFFFF0000) ? 1 : 3;
4008 ctl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
4009 ctl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
4010 ctl->cMultipleItems = 0;
4011 lstrcpyW(ctl->szShortName, muteW);
4012 lstrcpyW(ctl->szName, muteW);
4013 ctl->Bounds.s1.dwMinimum = 0;
4014 ctl->Bounds.s1.dwMaximum = 1;
4015 ctl->Metrics.cSteps = 0;
4016
4017 return MMSYSERR_NOERROR;
4018 }
4019
4020 /**************************************************************************
4021 * mixerGetLineControlsW [WINMM.@]
4022 */
4023 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
4024 DWORD fdwControls)
4025 {
4026 WINMM_MMDevice *mmdevice;
4027 HRESULT hr;
4028
4029 TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
4030
4031 hr = WINMM_InitMMDevices();
4032 if(FAILED(hr))
4033 return MMSYSERR_NODRIVER;
4034
4035 if(fdwControls & ~(MIXER_GETLINECONTROLSF_ALL |
4036 MIXER_GETLINECONTROLSF_ONEBYID |
4037 MIXER_GETLINECONTROLSF_ONEBYTYPE |
4038 MIXER_OBJECTF_HMIXER |
4039 MIXER_OBJECTF_MIXER)){
4040 WARN("Unknown GetLineControls flag: %x\n", fdwControls);
4041 return MMSYSERR_INVALFLAG;
4042 }
4043
4044 if(!lpmlcW || lpmlcW->cbStruct < sizeof(*lpmlcW) || !lpmlcW->pamxctrl)
4045 return MMSYSERR_INVALPARAM;
4046
4047 TRACE("dwLineID: %u\n", lpmlcW->dwLineID);
4048 TRACE("dwControl: %x\n", lpmlcW->u.dwControlID);
4049 TRACE("cControls: %u\n", lpmlcW->cControls);
4050
4051 mmdevice = WINMM_GetMixerMMDevice(hmix, fdwControls, NULL);
4052 if(!mmdevice)
4053 return MMSYSERR_INVALHANDLE;
4054
4055 switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK){
4056 case MIXER_GETLINECONTROLSF_ALL:
4057 if(lpmlcW->cControls != 2)
4058 return MMSYSERR_INVALPARAM;
4059 if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
4060 return MMSYSERR_INVALPARAM;
4061 if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
4062 return MIXERR_INVALLINE;
4063 WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
4064 &lpmlcW->pamxctrl[0], fdwControls);
4065 WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
4066 &lpmlcW->pamxctrl[1], fdwControls);
4067 return MMSYSERR_NOERROR;
4068 case MIXER_GETLINECONTROLSF_ONEBYID:
4069 if(lpmlcW->cControls != 1)
4070 return MMSYSERR_INVALPARAM;
4071 if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
4072 return MMSYSERR_INVALPARAM;
4073 if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
4074 return MIXERR_INVALLINE;
4075 if(lpmlcW->u.dwControlID == 0)
4076 return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
4077 lpmlcW->pamxctrl, fdwControls);
4078 if(lpmlcW->u.dwControlID == 1)
4079 return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
4080 lpmlcW->pamxctrl, fdwControls);
4081 return MMSYSERR_NOTSUPPORTED;
4082 case MIXER_GETLINECONTROLSF_ONEBYTYPE:
4083 if(lpmlcW->cControls != 1)
4084 return MMSYSERR_INVALPARAM;
4085 if(lpmlcW->cbmxctrl < sizeof(MIXERCONTROLW))
4086 return MMSYSERR_INVALPARAM;
4087 if(lpmlcW->dwLineID != 0 && lpmlcW->dwLineID != 0xFFFF0000)
4088 return MIXERR_INVALLINE;
4089 if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
4090 return WINMM_GetVolumeLineControl(mmdevice, lpmlcW->dwLineID,
4091 lpmlcW->pamxctrl, fdwControls);
4092 if(lpmlcW->u.dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
4093 return WINMM_GetMuteLineControl(mmdevice, lpmlcW->dwLineID,
4094 lpmlcW->pamxctrl, fdwControls);
4095 return MMSYSERR_NOTSUPPORTED;
4096 }
4097
4098 return MMSYSERR_NOTSUPPORTED;
4099 }
4100
4101 static UINT WINMM_GetSourceLineInfo(WINMM_MMDevice *mmdevice, UINT mmdev_index,
4102 MIXERLINEW *info, DWORD flags)
4103 {
4104 BOOL is_out = TRUE;
4105 if(mmdevice->in_caps.szPname[0] != '\0')
4106 is_out = FALSE;
4107
4108 if(info->dwSource != 0)
4109 return MIXERR_INVALLINE;
4110
4111 info->dwDestination = 0;
4112 info->dwLineID = 0;
4113 info->fdwLine = MIXERLINE_LINEF_ACTIVE | MIXERLINE_LINEF_SOURCE;
4114 info->cConnections = 0;
4115 info->cControls = 2;
4116 /* volume & mute always affect all channels, so claim 1 channel */
4117 info->cChannels = 1;
4118 info->Target.dwDeviceID = mmdev_index;
4119 info->Target.wMid = ~0;
4120 info->Target.wPid = ~0;
4121 info->Target.vDriverVersion = 0;
4122
4123 lstrcpyW(info->szShortName, volumeW);
4124 lstrcpyW(info->szName, mastervolumeW);
4125
4126 if(is_out){
4127 info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
4128 info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
4129 memcpy(info->Target.szPname, mmdevice->out_caps.szPname,
4130 sizeof(info->Target.szPname));
4131 }else{
4132 info->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
4133 info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
4134 info->Target.szPname[0] = '\0';
4135 }
4136
4137 return MMSYSERR_NOERROR;
4138 }
4139
4140 static UINT WINMM_GetDestinationLineInfo(WINMM_MMDevice *mmdevice,
4141 UINT mmdev_index, MIXERLINEW *info, DWORD flags)
4142 {
4143 BOOL is_out = TRUE;
4144 if(mmdevice->in_caps.szPname[0] != '\0')
4145 is_out = FALSE;
4146
4147 if(info->dwDestination != 0)
4148 return MIXERR_INVALLINE;
4149
4150 info->dwSource = 0xFFFFFFFF;
4151 info->dwLineID = 0xFFFF0000;
4152 info->fdwLine = MIXERLINE_LINEF_ACTIVE;
4153 info->cConnections = 1;
4154 info->cControls = 2;
4155
4156 lstrcpyW(info->szShortName, volumeW);
4157 lstrcpyW(info->szName, mastervolumeW);
4158
4159 info->Target.dwDeviceID = mmdev_index;
4160 info->Target.wMid = ~0;
4161 info->Target.wPid = ~0;
4162 info->Target.vDriverVersion = 0;
4163
4164 if(is_out){
4165 info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
4166 info->cChannels = mmdevice->out_caps.wChannels;
4167 info->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
4168 info->Target.szPname[0] = '\0';
4169 }else{
4170 info->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
4171 info->cChannels = mmdevice->in_caps.wChannels;
4172 info->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
4173 memcpy(info->Target.szPname, mmdevice->in_caps.szPname,
4174 sizeof(info->Target.szPname));
4175 }
4176
4177 return MMSYSERR_NOERROR;
4178 }
4179
4180 static UINT WINMM_GetComponentTypeLineInfo(WINMM_MMDevice *mmdevice,
4181 UINT mmdev_index, MIXERLINEW *info, DWORD flags)
4182 {
4183 BOOL is_out = TRUE;
4184 if(mmdevice->in_caps.szPname[0] != '\0')
4185 is_out = FALSE;
4186
4187 if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN){
4188 if(is_out)
4189 return MIXERR_INVALLINE;
4190 info->dwDestination = 0;
4191 return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
4192 }
4193
4194 if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_DST_SPEAKERS){
4195 if(!is_out)
4196 return MIXERR_INVALLINE;
4197 info->dwDestination = 0;
4198 return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
4199 }
4200
4201 if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE){
4202 if(is_out)
4203 return MIXERR_INVALLINE;
4204 info->dwSource = 0;
4205 return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
4206 }
4207
4208 if(info->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT){
4209 if(!is_out)
4210 return MIXERR_INVALLINE;
4211 info->dwSource = 0;
4212 return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
4213 }
4214
4215 TRACE("Returning INVALLINE on this component type: %u\n",
4216 info->dwComponentType);
4217
4218 return MIXERR_INVALLINE;
4219 }
4220
4221 static UINT WINMM_GetLineIDLineInfo(WINMM_MMDevice *mmdevice,
4222 UINT mmdev_index, MIXERLINEW *info, DWORD flags)
4223 {
4224 if(info->dwLineID == 0xFFFF0000){
4225 info->dwDestination = 0;
4226 return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, info, flags);
4227 }
4228
4229 if(info->dwLineID == 0){
4230 info->dwSource = 0;
4231 return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
4232 }
4233
4234 TRACE("Returning INVALLINE on this dwLineID: %u\n", info->dwLineID);
4235 return MIXERR_INVALLINE;
4236 }
4237
4238 /**************************************************************************
4239 * mixerGetLineInfoW [WINMM.@]
4240 */
4241 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo)
4242 {
4243 UINT mmdev_index;
4244 WINMM_MMDevice *mmdevice;
4245 HRESULT hr;
4246
4247 TRACE("(%p, %p, %x)\n", hmix, lpmliW, fdwInfo);
4248
4249 hr = WINMM_InitMMDevices();
4250 if(FAILED(hr))
4251 return MMSYSERR_NODRIVER;
4252
4253 if(!lpmliW || lpmliW->cbStruct < sizeof(MIXERLINEW))
4254 return MMSYSERR_INVALPARAM;
4255
4256 TRACE("dwDestination: %u\n", lpmliW->dwDestination);
4257 TRACE("dwSource: %u\n", lpmliW->dwSource);
4258 TRACE("dwLineID: %u\n", lpmliW->dwLineID);
4259 TRACE("fdwLine: 0x%x\n", lpmliW->fdwLine);
4260 TRACE("dwComponentType: 0x%x\n", lpmliW->dwComponentType);
4261
4262 if(fdwInfo & ~(MIXER_GETLINEINFOF_COMPONENTTYPE |
4263 MIXER_GETLINEINFOF_DESTINATION |
4264 MIXER_GETLINEINFOF_LINEID |
4265 MIXER_GETLINEINFOF_SOURCE |
4266 MIXER_GETLINEINFOF_TARGETTYPE |
4267 MIXER_OBJECTF_HMIXER |
4268 MIXER_OBJECTF_MIXER)){
4269 WARN("Unknown GetLineInfo flag: %x\n", fdwInfo);
4270 return MMSYSERR_INVALFLAG;
4271 }
4272
4273 mmdevice = WINMM_GetMixerMMDevice(hmix, fdwInfo, &mmdev_index);
4274 if(!mmdevice)
4275 return MMSYSERR_INVALHANDLE;
4276
4277 switch(fdwInfo & MIXER_GETLINEINFOF_QUERYMASK){
4278 case MIXER_GETLINEINFOF_DESTINATION:
4279 return WINMM_GetDestinationLineInfo(mmdevice, mmdev_index, lpmliW,
4280 fdwInfo);
4281 case MIXER_GETLINEINFOF_SOURCE:
4282 return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
4283 case MIXER_GETLINEINFOF_COMPONENTTYPE:
4284 return WINMM_GetComponentTypeLineInfo(mmdevice, mmdev_index, lpmliW,
4285 fdwInfo);
4286 case MIXER_GETLINEINFOF_LINEID:
4287 return WINMM_GetLineIDLineInfo(mmdevice, mmdev_index, lpmliW, fdwInfo);
4288 case MIXER_GETLINEINFOF_TARGETTYPE:
4289 FIXME("TARGETTYPE flag not implemented!\n");
4290 return MIXERR_INVALLINE;
4291 }
4292
4293 TRACE("Returning INVALFLAG on these flags: %x\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
4294 return MMSYSERR_INVALFLAG;
4295 }
4296
4297 /**************************************************************************
4298 * mixerGetLineInfoA [WINMM.@]
4299 */
4300 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
4301 DWORD fdwInfo)
4302 {
4303 MIXERLINEW mliW;
4304 UINT ret;
4305
4306 TRACE("(%p, %p, %x)\n", hmix, lpmliA, fdwInfo);
4307
4308 if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
4309 return MMSYSERR_INVALPARAM;
4310
4311 mliW.cbStruct = sizeof(mliW);
4312 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
4313 case MIXER_GETLINEINFOF_COMPONENTTYPE:
4314 mliW.dwComponentType = lpmliA->dwComponentType;
4315 break;
4316 case MIXER_GETLINEINFOF_DESTINATION:
4317 mliW.dwDestination = lpmliA->dwDestination;
4318 break;
4319 case MIXER_GETLINEINFOF_LINEID:
4320 mliW.dwLineID = lpmliA->dwLineID;
4321 break;
4322 case MIXER_GETLINEINFOF_SOURCE:
4323 mliW.dwDestination = lpmliA->dwDestination;
4324 mliW.dwSource = lpmliA->dwSource;
4325 break;
4326 case MIXER_GETLINEINFOF_TARGETTYPE:
4327 mliW.Target.dwType = lpmliA->Target.dwType;
4328 mliW.Target.wMid = lpmliA->Target.wMid;
4329 mliW.Target.wPid = lpmliA->Target.wPid;
4330 mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion;
4331 MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR));
4332 break;
4333 default:
4334 WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
4335 return MMSYSERR_INVALFLAG;
4336 }
4337
4338 ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo);
4339
4340 if(ret == MMSYSERR_NOERROR)
4341 {
4342 lpmliA->dwDestination = mliW.dwDestination;
4343 lpmliA->dwSource = mliW.dwSource;
4344 lpmliA->dwLineID = mliW.dwLineID;
4345 lpmliA->fdwLine = mliW.fdwLine;
4346 lpmliA->dwUser = mliW.dwUser;
4347 lpmliA->dwComponentType = mliW.dwComponentType;
4348 lpmliA->cChannels = mliW.cChannels;
4349 lpmliA->cConnections = mliW.cConnections;
4350 lpmliA->cControls = mliW.cControls;
4351 WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
4352 sizeof(lpmliA->szShortName), NULL, NULL);
4353 WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
4354 sizeof(lpmliA->szName), NULL, NULL );
4355 lpmliA->Target.dwType = mliW.Target.dwType;
4356 lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
4357 lpmliA->Target.wMid = mliW.Target.wMid;
4358 lpmliA->Target.wPid = mliW.Target.wPid;
4359 lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
4360 WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
4361 sizeof(lpmliA->Target.szPname), NULL, NULL );
4362 }
4363 return ret;
4364 }
4365
4366 /**************************************************************************
4367 * mixerSetControlDetails [WINMM.@]
4368 */
4369 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
4370 DWORD fdwDetails)
4371 {
4372 WINMM_ControlDetails details;
4373 UINT ret;
4374
4375 TRACE("(%p, %p, %x)\n", hmix, lpmcd, fdwDetails);
4376
4377 if((fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) ==
4378 MIXER_SETCONTROLDETAILSF_CUSTOM)
4379 return MMSYSERR_NOTSUPPORTED;
4380
4381 if(!lpmcd)
4382 return MMSYSERR_INVALPARAM;
4383
4384 if(!WINMM_StartDevicesThread())
4385 return MMSYSERR_NODRIVER;
4386
4387 TRACE("dwControlID: %u\n", lpmcd->dwControlID);
4388
4389 details.hmix = hmix;
4390 details.details = lpmcd;
4391 details.flags = fdwDetails;
4392
4393 ret = SendMessageW(g_devices_hwnd, MXDM_SETCONTROLDETAILS,
4394 (DWORD_PTR)&details, 0);
4395 InterlockedDecrement(&g_devthread_token);
4396 return ret;
4397 }
4398
4399 /**************************************************************************
4400 * mixerMessage [WINMM.@]
4401 */
4402 DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
4403 {
4404 TRACE("(%p, %d, %lx, %lx)\n", hmix, uMsg, dwParam1, dwParam2);
4405
4406 return MMSYSERR_NOTSUPPORTED;
4407 }
Quick hack tree for wine patches julliard doesn't want to commit