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