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