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