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