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