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