msxml3/tests: Remove redundant NULL check before SysFreeString (smatch).
[wine] / dlls / winecoreaudio.drv / mixer.c
1 /*
2  * Sample MIXER Wine Driver for Mac OS X (based on OSS mixer)
3  *
4  * Copyright    1997 Marcus Meissner
5  *              1999,2001 Eric Pouech
6  *              2006,2007 Emmanuel Maillard
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <string.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36 #include "windef.h"
37 #include "winbase.h"
38 #include "winnls.h"
39 #include "mmddk.h"
40 #include "coreaudio.h"
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(mixer);
45
46 #if defined(HAVE_COREAUDIO_COREAUDIO_H)
47 #include <CoreAudio/CoreAudio.h>
48 #include <CoreFoundation/CoreFoundation.h>
49
50 #define WINE_MIXER_NAME "CoreAudio Mixer"
51
52 #define InputDevice (1 << 0)
53 #define OutputDevice (1 << 1)
54
55 #define IsInput(dir) ((dir) & InputDevice)
56 #define IsOutput(dir) ((dir) & OutputDevice)
57
58 #define ControlsPerLine 2 /* number of control per line : volume & (mute | onoff) */
59
60 #define IDControlVolume 0
61 #define IDControlMute 1
62
63 typedef struct tagMixerLine
64 {
65     char *name;
66     int direction;
67     int numChannels;
68     int componentType;
69     AudioDeviceID deviceID;
70 } MixerLine;
71
72 typedef struct tagMixerCtrl
73 {
74     DWORD dwLineID;
75     MIXERCONTROLW ctrl;
76 } MixerCtrl;
77
78 typedef struct tagCoreAudio_Mixer
79 {
80     MIXERCAPSW caps;
81
82     MixerCtrl *mixerCtrls;
83     MixerLine *lines;
84     DWORD numCtrl;
85 } CoreAudio_Mixer;
86
87 static CoreAudio_Mixer mixer;
88 static int numMixers = 1;
89
90 /**************************************************************************
91 */
92
93 static const char * getMessage(UINT uMsg)
94 {
95 #define MSG_TO_STR(x) case x: return #x;
96     switch (uMsg) {
97         MSG_TO_STR(DRVM_INIT);
98         MSG_TO_STR(DRVM_EXIT);
99         MSG_TO_STR(DRVM_ENABLE);
100         MSG_TO_STR(DRVM_DISABLE);
101         MSG_TO_STR(MXDM_GETDEVCAPS);
102         MSG_TO_STR(MXDM_GETLINEINFO);
103         MSG_TO_STR(MXDM_GETNUMDEVS);
104         MSG_TO_STR(MXDM_OPEN);
105         MSG_TO_STR(MXDM_CLOSE);
106         MSG_TO_STR(MXDM_GETLINECONTROLS);
107         MSG_TO_STR(MXDM_GETCONTROLDETAILS);
108         MSG_TO_STR(MXDM_SETCONTROLDETAILS);
109     }
110 #undef MSG_TO_STR
111     return wine_dbg_sprintf("UNKNOWN(%08x)", uMsg);
112 }
113
114 static const char * getControlType(DWORD dwControlType)
115 {
116 #define TYPE_TO_STR(x) case x: return #x;
117     switch (dwControlType) {
118         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_CUSTOM);
119         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEANMETER);
120         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER);
121         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PEAKMETER);
122         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER);
123         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEAN);
124         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_ONOFF);
125         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUTE);
126         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MONO);
127         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_LOUDNESS);
128         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_STEREOENH);
129         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS_BOOST);
130         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BUTTON);
131         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_DECIBELS);
132         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNED);
133         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNED);
134         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PERCENT);
135         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SLIDER);
136         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PAN);
137         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_QSOUNDPAN);
138         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_FADER);
139         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_VOLUME);
140         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS);
141         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_TREBLE);
142         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_EQUALIZER);
143         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SINGLESELECT);
144         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUX);
145         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT);
146         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MIXER);
147         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MICROTIME);
148         TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MILLITIME);
149     }
150 #undef TYPE_TO_STR
151     return wine_dbg_sprintf("UNKNOWN(%08x)", dwControlType);
152 }
153
154 static const char * getComponentType(DWORD dwComponentType)
155 {
156 #define TYPE_TO_STR(x) case x: return #x;
157     switch (dwComponentType) {
158         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_UNDEFINED);
159         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_DIGITAL);
160         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_LINE);
161         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_MONITOR);
162         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_SPEAKERS);
163         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_HEADPHONES);
164         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_TELEPHONE);
165         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_WAVEIN);
166         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_VOICEIN);
167         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED);
168         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_DIGITAL);
169         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_LINE);
170         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE);
171         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER);
172         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC);
173         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE);
174         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER);
175         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT);
176         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY);
177         TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_ANALOG);
178     }
179 #undef TYPE_TO_STR
180     return wine_dbg_sprintf("UNKNOWN(%08x)", dwComponentType);
181 }
182
183 static const char * getTargetType(DWORD dwType)
184 {
185 #define TYPE_TO_STR(x) case x: return #x;
186     switch (dwType) {
187         TYPE_TO_STR(MIXERLINE_TARGETTYPE_UNDEFINED);
188         TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEOUT);
189         TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEIN);
190         TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIOUT);
191         TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIIN);
192         TYPE_TO_STR(MIXERLINE_TARGETTYPE_AUX);
193     }
194 #undef TYPE_TO_STR
195     return wine_dbg_sprintf("UNKNOWN(%08x)", dwType);
196 }
197
198 /* FIXME is there a better way ? */
199 static DWORD DeviceComponentType(char *name)
200 {
201     if (strcmp(name, "Built-in Microphone") == 0)
202         return MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
203
204     if (strcmp(name, "Built-in Line Input") == 0)
205         return MIXERLINE_COMPONENTTYPE_SRC_LINE;
206
207     if (strcmp(name, "Built-in Output") == 0)
208         return MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
209
210     return MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
211 }
212
213 static BOOL DeviceHasMute(AudioDeviceID deviceID, Boolean isInput)
214 {
215     Boolean writable = false;
216     OSStatus err = noErr;
217     err = AudioDeviceGetPropertyInfo(deviceID, 0, isInput, kAudioDevicePropertyMute, NULL, NULL);
218     if (err == noErr)
219     {
220         /* check if we can set it */
221         err = AudioDeviceGetPropertyInfo(deviceID, 0, isInput, kAudioDevicePropertyMute, NULL, &writable);
222         if (err == noErr)
223             return writable;
224     }
225     return FALSE;
226 }
227
228 /*
229  * Getters
230  */
231 static BOOL MIX_LineGetVolume(DWORD lineID, DWORD channels, Float32 *left, Float32 *right)
232 {
233     MixerLine *line = &mixer.lines[lineID];
234     UInt32 size = sizeof(Float32);
235     OSStatus err = noErr;
236     *left = *right = 0.0;
237
238     err = AudioDeviceGetProperty(line->deviceID, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, &size, left);
239     if (err != noErr)
240         return FALSE;
241
242     if (channels == 2)
243     {
244         size = sizeof(Float32);
245         err = AudioDeviceGetProperty(line->deviceID, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, &size, right);
246         if (err != noErr)
247             return FALSE;
248     }
249
250     TRACE("lineID %d channels %d return left %f right %f\n", lineID, channels, *left, *right);
251     return (err == noErr);
252 }
253
254 static BOOL MIX_LineGetMute(DWORD lineID, BOOL *muted)
255 {
256     MixerLine *line = &mixer.lines[lineID];
257     UInt32 size = sizeof(UInt32);
258     UInt32 val = 0;
259     OSStatus err = noErr;
260     err = AudioDeviceGetProperty(line->deviceID, 0, IsInput(line->direction), kAudioDevicePropertyMute, &size, &val);
261     *muted = val;
262
263     return (err == noErr);
264 }
265
266 /*
267  * Setters
268  */
269 static BOOL MIX_LineSetVolume(DWORD lineID, DWORD channels, Float32 left, Float32 right)
270 {
271     MixerLine *line = &mixer.lines[lineID];
272     UInt32 size = sizeof(Float32);
273     OSStatus err = noErr;
274     TRACE("lineID %d channels %d left %f right %f\n", lineID, channels, left, right);
275
276     if (channels == 2)
277     {
278         err = AudioDeviceSetProperty(line->deviceID, NULL, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
279         if (err != noErr)
280             return FALSE;
281
282         err = AudioDeviceSetProperty(line->deviceID, NULL, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &right);
283     }
284     else
285     {
286         /*
287             FIXME Using master channel failed ?? return kAudioHardwareUnknownPropertyError
288             err = AudioDeviceSetProperty(line->deviceID, NULL, 0, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
289         */
290         right = left;
291         err = AudioDeviceSetProperty(line->deviceID, NULL, 1, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &left);
292         if (err != noErr)
293             return FALSE;
294         err = AudioDeviceSetProperty(line->deviceID, NULL, 2, IsInput(line->direction), kAudioDevicePropertyVolumeScalar, size, &right);
295     }
296     return (err == noErr);
297 }
298
299 static BOOL MIX_LineSetMute(DWORD lineID, BOOL mute)
300 {
301     MixerLine *line = &mixer.lines[lineID];
302     UInt32 val = mute;
303     UInt32 size = sizeof(UInt32);
304     OSStatus err = noErr;
305
306     err = AudioDeviceSetProperty(line->deviceID, 0, 0, IsInput(line->direction), kAudioDevicePropertyMute, size, &val);
307     return (err == noErr);
308 }
309
310 static void MIX_FillControls(void)
311 {
312     int i;
313     int ctrl = 0;
314     MixerLine *line;
315     for (i = 0; i < mixer.caps.cDestinations; i++)
316     {
317         line = &mixer.lines[i];
318         mixer.mixerCtrls[ctrl].dwLineID = i;
319         mixer.mixerCtrls[ctrl].ctrl.cbStruct = sizeof(MIXERCONTROLW);
320         mixer.mixerCtrls[ctrl].ctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
321         mixer.mixerCtrls[ctrl].ctrl.dwControlID = ctrl;
322         mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMinimum = 0;
323         mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMaximum = 65535;
324         mixer.mixerCtrls[ctrl].ctrl.Metrics.cSteps = 656;
325         ctrl++;
326
327         mixer.mixerCtrls[ctrl].dwLineID = i;
328         if ( !DeviceHasMute(line->deviceID, IsInput(line->direction)) )
329             mixer.mixerCtrls[ctrl].ctrl.fdwControl |= MIXERCONTROL_CONTROLF_DISABLED;
330
331         mixer.mixerCtrls[ctrl].ctrl.cbStruct = sizeof(MIXERCONTROLW);
332         mixer.mixerCtrls[ctrl].ctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
333         mixer.mixerCtrls[ctrl].ctrl.dwControlID = ctrl;
334         mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMinimum = 0;
335         mixer.mixerCtrls[ctrl].ctrl.Bounds.s1.dwMaximum = 1;
336         ctrl++;
337     }
338     assert(ctrl == mixer.numCtrl);
339 }
340
341 /**************************************************************************
342 *                               CoreAudio_MixerInit
343 */
344 LONG CoreAudio_MixerInit(void)
345 {
346     OSStatus status;
347     UInt32 propertySize;
348     AudioDeviceID *deviceArray = NULL;
349     char name[MAXPNAMELEN];
350     int i;
351     int numLines;
352
353     AudioStreamBasicDescription streamDescription;
354
355     /* Find number of lines */
356     status = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
357     if (status)
358     {
359         ERR("AudioHardwareGetPropertyInfo for kAudioHardwarePropertyDevices return %s\n", wine_dbgstr_fourcc(status));
360         return DRV_FAILURE;
361     }
362
363     numLines = propertySize / sizeof(AudioDeviceID);
364
365     mixer.mixerCtrls = NULL;
366     mixer.lines = NULL;
367     mixer.numCtrl = 0;
368
369     mixer.caps.cDestinations = numLines;
370     mixer.caps.wMid = 0xAA;
371     mixer.caps.wPid = 0x55;
372     mixer.caps.vDriverVersion = 0x0100;
373
374     MultiByteToWideChar(CP_ACP, 0, WINE_MIXER_NAME, -1, mixer.caps.szPname, sizeof(mixer.caps.szPname) / sizeof(WCHAR));
375
376     mixer.caps.fdwSupport = 0; /* No bits defined yet */
377
378     mixer.lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MixerLine) * numLines);
379     if (!mixer.lines)
380         goto error;
381
382     deviceArray = HeapAlloc(GetProcessHeap(), 0, sizeof(AudioDeviceID) * numLines);
383
384     propertySize = sizeof(AudioDeviceID) * numLines;
385     status = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, deviceArray);
386     if (status)
387     {
388         ERR("AudioHardwareGetProperty for kAudioHardwarePropertyDevices return %s\n", wine_dbgstr_fourcc(status));
389         goto error;
390     }
391
392     for (i = 0; i < numLines; i++)
393     {
394         Boolean write;
395         MixerLine *line = &mixer.lines[i];
396
397         line->deviceID = deviceArray[i];
398
399         propertySize = MAXPNAMELEN;
400         status = AudioDeviceGetProperty(line->deviceID, 0 , FALSE, kAudioDevicePropertyDeviceName, &propertySize, name);
401         if (status) {
402             ERR("AudioHardwareGetProperty for kAudioDevicePropertyDeviceName return %s\n", wine_dbgstr_fourcc(status));
403             goto error;
404         }
405
406         line->name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlen(name) + 1);
407         if (!line->name)
408             goto error;
409
410         memcpy(line->name, name, strlen(name));
411
412         line->componentType = DeviceComponentType(line->name);
413
414         /* check for directions */
415         /* Output ? */
416         propertySize = sizeof(UInt32);
417         status = AudioDeviceGetPropertyInfo(line->deviceID, 0, FALSE, kAudioDevicePropertyStreams, &propertySize, &write );
418         if (status) {
419             ERR("AudioDeviceGetPropertyInfo for kAudioDevicePropertyDataSource return %s\n", wine_dbgstr_fourcc(status));
420             goto error;
421         }
422
423         if ( (propertySize / sizeof(AudioStreamID)) != 0)
424         {
425             line->direction |= OutputDevice;
426
427             /* Check the number of channel for the stream */
428             propertySize = sizeof(streamDescription);
429             status = AudioDeviceGetProperty(line->deviceID, 0, FALSE , kAudioDevicePropertyStreamFormat, &propertySize, &streamDescription);
430             if (status != noErr) {
431                 ERR("AudioHardwareGetProperty for kAudioDevicePropertyStreamFormat return %s\n", wine_dbgstr_fourcc(status));
432                 goto error;
433             }
434             line->numChannels = streamDescription.mChannelsPerFrame;
435         }
436         else
437         {
438             /* Input ? */
439             propertySize = sizeof(UInt32);
440             status = AudioDeviceGetPropertyInfo(line->deviceID, 0, TRUE, kAudioDevicePropertyStreams, &propertySize, &write );
441             if (status) {
442                 ERR("AudioDeviceGetPropertyInfo for kAudioDevicePropertyStreams return %s\n", wine_dbgstr_fourcc(status));
443                 goto error;
444             }
445             if ( (propertySize / sizeof(AudioStreamID)) != 0)
446             {
447                 line->direction |= InputDevice;
448
449                 /* Check the number of channel for the stream */
450                 propertySize = sizeof(streamDescription);
451                 status = AudioDeviceGetProperty(line->deviceID, 0, TRUE, kAudioDevicePropertyStreamFormat, &propertySize, &streamDescription);
452                 if (status != noErr) {
453                     ERR("AudioHardwareGetProperty for kAudioDevicePropertyStreamFormat return %s\n", wine_dbgstr_fourcc(status));
454                     goto error;
455                 }
456                 line->numChannels = streamDescription.mChannelsPerFrame;
457             }
458         }
459
460         mixer.numCtrl += ControlsPerLine; /* volume & (mute | onoff) */
461     }
462     mixer.mixerCtrls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MixerCtrl) * mixer.numCtrl);
463     if (!mixer.mixerCtrls)
464         goto error;
465
466     MIX_FillControls();
467
468     HeapFree(GetProcessHeap(), 0, deviceArray);
469     return DRV_SUCCESS;
470
471 error:
472     if (mixer.lines)
473     {
474         int i;
475         for (i = 0; i < mixer.caps.cDestinations; i++)
476         {
477             HeapFree(GetProcessHeap(), 0, mixer.lines[i].name);
478         }
479         HeapFree(GetProcessHeap(), 0, mixer.lines);
480     }
481     HeapFree(GetProcessHeap(), 0, deviceArray);
482     if (mixer.mixerCtrls)
483         HeapFree(GetProcessHeap(), 0, mixer.mixerCtrls);
484     return DRV_FAILURE;
485 }
486
487 /**************************************************************************
488 *                               CoreAudio_MixerRelease
489 */
490 void CoreAudio_MixerRelease(void)
491 {
492     TRACE("()\n");
493
494     if (mixer.lines)
495     {
496         int i;
497         for (i = 0; i < mixer.caps.cDestinations; i++)
498         {
499             HeapFree(GetProcessHeap(), 0, mixer.lines[i].name);
500         }
501         HeapFree(GetProcessHeap(), 0, mixer.lines);
502     }
503     if (mixer.mixerCtrls)
504         HeapFree(GetProcessHeap(), 0, mixer.mixerCtrls);
505 }
506
507 /**************************************************************************
508 *                               MIX_Open                        [internal]
509 */
510 static DWORD MIX_Open(WORD wDevID, LPMIXEROPENDESC lpMod, DWORD_PTR flags)
511 {
512     TRACE("wDevID=%d lpMod=%p dwSize=%08lx\n", wDevID, lpMod, flags);
513     if (lpMod == NULL) {
514         WARN("invalid parameter: lpMod == NULL\n");
515         return MMSYSERR_INVALPARAM;
516     }
517
518     if (wDevID >= numMixers) {
519         WARN("bad device ID: %04X\n", wDevID);
520         return MMSYSERR_BADDEVICEID;
521     }
522     return MMSYSERR_NOERROR;
523 }
524
525 /**************************************************************************
526 *                               MIX_GetNumDevs                  [internal]
527 */
528 static DWORD MIX_GetNumDevs(void)
529 {
530     TRACE("()\n");
531     return numMixers;
532 }
533
534 static DWORD MIX_GetDevCaps(WORD wDevID, LPMIXERCAPSW lpCaps, DWORD_PTR dwSize)
535 {
536     TRACE("wDevID=%d lpCaps=%p\n", wDevID, lpCaps);
537
538     if (lpCaps == NULL) {
539         WARN("Invalid Parameter\n");
540         return MMSYSERR_INVALPARAM;
541     }
542
543     if (wDevID >= numMixers) {
544         WARN("bad device ID : %d\n", wDevID);
545         return MMSYSERR_BADDEVICEID;
546     }
547     memcpy(lpCaps, &mixer.caps, min(dwSize, sizeof(*lpCaps)));
548     return MMSYSERR_NOERROR;
549 }
550
551 /**************************************************************************
552 *                               MIX_GetLineInfo                 [internal]
553 */
554 static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEW lpMl, DWORD_PTR fdwInfo)
555 {
556     int i;
557     DWORD ret = MMSYSERR_ERROR;
558     MixerLine *line = NULL;
559
560     TRACE("%04X, %p, %08lx\n", wDevID, lpMl, fdwInfo);
561
562     if (lpMl == NULL) {
563         WARN("invalid parameter: lpMl = NULL\n");
564         return MMSYSERR_INVALPARAM;
565     }
566
567     if (lpMl->cbStruct != sizeof(*lpMl)) {
568         WARN("invalid parameter: lpMl->cbStruct\n");
569         return MMSYSERR_INVALPARAM;
570     }
571
572     if (wDevID >= numMixers) {
573         WARN("bad device ID: %04X\n", wDevID);
574         return MMSYSERR_BADDEVICEID;
575     }
576
577     /* FIXME: set all the variables correctly... the lines below
578         * are very wrong...
579         */
580     lpMl->dwUser = 0;
581
582     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
583     {
584         case MIXER_GETLINEINFOF_DESTINATION:
585             TRACE("MIXER_GETLINEINFOF_DESTINATION %d\n", lpMl->dwDestination);
586             if ( (lpMl->dwDestination >= 0) && (lpMl->dwDestination < mixer.caps.cDestinations) )
587             {
588                 lpMl->dwLineID = lpMl->dwDestination;
589                 line = &mixer.lines[lpMl->dwDestination];
590             }
591             else ret = MIXERR_INVALLINE;
592             break;
593         case MIXER_GETLINEINFOF_COMPONENTTYPE:
594             TRACE("MIXER_GETLINEINFOF_COMPONENTTYPE %s\n", getComponentType(lpMl->dwComponentType));
595             for (i = 0; i < mixer.caps.cDestinations; i++)
596             {
597                 if (mixer.lines[i].componentType == lpMl->dwComponentType)
598                 {
599                     lpMl->dwDestination = lpMl->dwLineID = i;
600                     line = &mixer.lines[i];
601                     break;
602                 }
603             }
604             if (line == NULL)
605             {
606                 WARN("can't find component type %s\n", getComponentType(lpMl->dwComponentType));
607                 ret = MIXERR_INVALVALUE;
608             }
609             break;
610         case MIXER_GETLINEINFOF_SOURCE:
611             FIXME("MIXER_GETLINEINFOF_SOURCE %d dst=%d\n", lpMl->dwSource, lpMl->dwDestination);
612             break;
613         case MIXER_GETLINEINFOF_LINEID:
614             TRACE("MIXER_GETLINEINFOF_LINEID %d\n", lpMl->dwLineID);
615             if ( (lpMl->dwLineID >= 0) && (lpMl->dwLineID < mixer.caps.cDestinations) )
616             {
617                 lpMl->dwDestination = lpMl->dwLineID;
618                 line = &mixer.lines[lpMl->dwLineID];
619             }
620             else ret = MIXERR_INVALLINE;
621             break;
622         case MIXER_GETLINEINFOF_TARGETTYPE:
623             FIXME("MIXER_GETLINEINFOF_TARGETTYPE (%s)\n", getTargetType(lpMl->Target.dwType));
624             switch (lpMl->Target.dwType) {
625                 case MIXERLINE_TARGETTYPE_UNDEFINED:
626                 case MIXERLINE_TARGETTYPE_WAVEOUT:
627                 case MIXERLINE_TARGETTYPE_WAVEIN:
628                 case MIXERLINE_TARGETTYPE_MIDIOUT:
629                 case MIXERLINE_TARGETTYPE_MIDIIN:
630                 case MIXERLINE_TARGETTYPE_AUX:
631                 default:
632                     FIXME("Unhandled target type (%s)\n",
633                           getTargetType(lpMl->Target.dwType));
634                     return MMSYSERR_INVALPARAM;
635             }
636                 break;
637         default:
638             WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
639             break;
640     }
641
642     if (line)
643     {
644         lpMl->dwComponentType = line->componentType;
645         lpMl->cChannels = line->numChannels;
646         lpMl->cControls = ControlsPerLine;
647
648         /* FIXME check there with CoreAudio */
649         lpMl->cConnections = 1;
650         lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
651
652         MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szShortName, sizeof(lpMl->szShortName) / sizeof(WCHAR));
653         MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szName, sizeof(lpMl->szName) / sizeof(WCHAR));
654
655         if ( IsInput(line->direction) )
656             lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
657         else
658             lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
659
660         lpMl->Target.dwDeviceID = line->deviceID;
661         lpMl->Target.wMid = mixer.caps.wMid;
662         lpMl->Target.wPid = mixer.caps.wPid;
663         lpMl->Target.vDriverVersion = mixer.caps.vDriverVersion;
664
665         MultiByteToWideChar(CP_ACP, 0, WINE_MIXER_NAME, -1, lpMl->Target.szPname, sizeof(lpMl->Target.szPname) / sizeof(WCHAR));
666         ret = MMSYSERR_NOERROR;
667     }
668     return ret;
669 }
670
671 /**************************************************************************
672 *                               MIX_GetLineControls             [internal]
673 */
674 static DWORD MIX_GetLineControls(WORD wDevID, LPMIXERLINECONTROLSW lpMlc, DWORD_PTR flags)
675 {
676     DWORD ret = MMSYSERR_NOTENABLED;
677     int ctrl = 0;
678     TRACE("%04X, %p, %08lX\n", wDevID, lpMlc, flags);
679
680     if (lpMlc == NULL) {
681         WARN("invalid parameter: lpMlc == NULL\n");
682         return MMSYSERR_INVALPARAM;
683     }
684
685     if (lpMlc->cbStruct < sizeof(*lpMlc)) {
686         WARN("invalid parameter: lpMlc->cbStruct = %d\n", lpMlc->cbStruct);
687         return MMSYSERR_INVALPARAM;
688     }
689
690     if (lpMlc->cbmxctrl < sizeof(MIXERCONTROLW)) {
691         WARN("invalid parameter: lpMlc->cbmxctrl = %d\n", lpMlc->cbmxctrl);
692         return MMSYSERR_INVALPARAM;
693     }
694
695     if (wDevID >= numMixers) {
696         WARN("bad device ID: %04X\n", wDevID);
697         return MMSYSERR_BADDEVICEID;
698     }
699
700     switch (flags & MIXER_GETLINECONTROLSF_QUERYMASK)
701     {
702         case MIXER_GETLINECONTROLSF_ALL:
703             FIXME("dwLineID=%d MIXER_GETLINECONTROLSF_ALL (%d)\n", lpMlc->dwLineID, lpMlc->cControls);
704             if (lpMlc->cControls != ControlsPerLine)
705             {
706                 WARN("invalid parameter lpMlc->cControls %d\n", lpMlc->cControls);
707                 ret = MMSYSERR_INVALPARAM;
708             }
709             else
710             {
711                 if ( (lpMlc->dwLineID >= 0) && (lpMlc->dwLineID < mixer.caps.cDestinations) )
712                 {
713                     int i;
714                     for (i = 0; i < lpMlc->cControls; i++)
715                     {
716                         lpMlc->pamxctrl[i] = mixer.mixerCtrls[lpMlc->dwLineID * i].ctrl;
717                     }
718                     ret = MMSYSERR_NOERROR;
719                 }
720                 else ret = MIXERR_INVALLINE;
721             }
722             break;
723         case MIXER_GETLINECONTROLSF_ONEBYID:
724             TRACE("dwLineID=%d MIXER_GETLINECONTROLSF_ONEBYID (%d)\n", lpMlc->dwLineID, lpMlc->u.dwControlID);
725             if ( lpMlc->u.dwControlID >= 0 && lpMlc->u.dwControlID < mixer.numCtrl )
726             {
727                 lpMlc->pamxctrl[0] = mixer.mixerCtrls[lpMlc->u.dwControlID].ctrl;
728                 ret = MMSYSERR_NOERROR;
729             }
730             else ret = MIXERR_INVALVALUE;
731             break;
732         case MIXER_GETLINECONTROLSF_ONEBYTYPE:
733             TRACE("dwLineID=%d MIXER_GETLINECONTROLSF_ONEBYTYPE (%s)\n", lpMlc->dwLineID, getControlType(lpMlc->u.dwControlType));
734             if ( (lpMlc->dwLineID < 0) || (lpMlc->dwLineID >= mixer.caps.cDestinations) )
735             {
736                 ret = MIXERR_INVALLINE;
737                 break;
738             }
739             if (lpMlc->u.dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
740             {
741                 ctrl = (lpMlc->dwLineID * ControlsPerLine) + IDControlVolume;
742                 lpMlc->pamxctrl[0] = mixer.mixerCtrls[ctrl].ctrl;
743                 ret = MMSYSERR_NOERROR;
744             }
745             else
746                 if (lpMlc->u.dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
747                 {
748                     ctrl = (lpMlc->dwLineID * ControlsPerLine) + IDControlMute;
749                     lpMlc->pamxctrl[0] = mixer.mixerCtrls[ctrl].ctrl;
750                     ret = MMSYSERR_NOERROR;
751                 }
752                 break;
753         default:
754             ERR("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
755             ret = MMSYSERR_INVALPARAM;
756     }
757
758     return ret;
759 }
760
761 /**************************************************************************
762  *                              MIX_GetControlDetails           [internal]
763  */
764 static DWORD MIX_GetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD_PTR fdwDetails)
765 {
766     DWORD ret = MMSYSERR_NOTSUPPORTED;
767     DWORD dwControlType;
768
769     TRACE("%04X, %p, %08lx\n", wDevID, lpmcd, fdwDetails);
770
771     if (lpmcd == NULL) {
772         TRACE("invalid parameter: lpmcd == NULL\n");
773         return MMSYSERR_INVALPARAM;
774     }
775
776     if (wDevID >= numMixers) {
777         WARN("bad device ID: %04X\n", wDevID);
778         return MMSYSERR_BADDEVICEID;
779     }
780
781     if ( (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) != MIXER_GETCONTROLDETAILSF_VALUE )
782     {
783         WARN("Unknown/unimplement GetControlDetails flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
784         return MMSYSERR_NOTSUPPORTED;
785     }
786
787     if ( lpmcd->dwControlID < 0 || lpmcd->dwControlID >= mixer.numCtrl )
788     {
789         WARN("bad control ID: %d\n", lpmcd->dwControlID);
790         return MIXERR_INVALVALUE;
791     }
792
793     TRACE("MIXER_GETCONTROLDETAILSF_VALUE %d\n", lpmcd->dwControlID);
794
795     dwControlType = mixer.mixerCtrls[lpmcd->dwControlID].ctrl.dwControlType;
796     switch (dwControlType)
797     {
798         case MIXERCONTROL_CONTROLTYPE_VOLUME:
799             FIXME("controlType : %s channels %d\n", getControlType(dwControlType), lpmcd->cChannels);
800             {
801                 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
802                 Float32 left, right;
803
804                 if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
805                     WARN("invalid parameter: lpmcd->cbDetails == %d\n", lpmcd->cbDetails);
806                     return MMSYSERR_INVALPARAM;
807                 }
808
809                 if ( MIX_LineGetVolume(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, lpmcd->cChannels, &left, &right) )
810                 {
811                     mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
812
813                     switch (lpmcd->cChannels)
814                     {
815                         case 1:
816                             /* mono... so R = L */
817                             mcdu->dwValue = left * 65535;
818                             TRACE("Reading RL = %d\n", mcdu->dwValue);
819                             break;
820                         case 2:
821                             /* stereo, left is paDetails[0] */
822                             mcdu->dwValue = left * 65535;
823                             TRACE("Reading L = %d\n", mcdu->dwValue);
824                             mcdu++;
825                             mcdu->dwValue = right * 65535;
826                             TRACE("Reading R = %d\n", mcdu->dwValue);
827                             break;
828                         default:
829                             WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
830                             return MMSYSERR_INVALPARAM;
831                     }
832                     TRACE("=> %08x\n", mcdu->dwValue);
833                     ret = MMSYSERR_NOERROR;
834                 }
835             }
836             break;
837         case MIXERCONTROL_CONTROLTYPE_MUTE:
838         case MIXERCONTROL_CONTROLTYPE_ONOFF:
839             FIXME("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(dwControlType), lpmcd->cChannels);
840             {
841                 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
842                 BOOL muted;
843                 if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
844                     WARN("invalid parameter: lpmcd->cbDetails = %d\n", lpmcd->cbDetails);
845                     return MMSYSERR_INVALPARAM;
846                 }
847                 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
848
849                 if ( MIX_LineGetMute(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, &muted) )
850                 {
851                     mcdb->fValue = muted;
852                     TRACE("=> %s\n", mcdb->fValue ? "on" : "off");
853                     ret = MMSYSERR_NOERROR;
854                 }
855             }
856             break;
857         case MIXERCONTROL_CONTROLTYPE_MIXER:
858         case MIXERCONTROL_CONTROLTYPE_MUX:
859         default:
860             FIXME("controlType : %s\n", getControlType(dwControlType));
861             break;
862     }
863     return ret;
864 }
865
866 /**************************************************************************
867 *                               MIX_SetControlDetails           [internal]
868 */
869 static DWORD MIX_SetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD_PTR fdwDetails)
870 {
871     DWORD ret = MMSYSERR_NOTSUPPORTED;
872     DWORD dwControlType;
873
874     TRACE("%04X, %p, %08lx\n", wDevID, lpmcd, fdwDetails);
875
876     if (lpmcd == NULL) {
877         TRACE("invalid parameter: lpmcd == NULL\n");
878         return MMSYSERR_INVALPARAM;
879     }
880
881     if (wDevID >= numMixers) {
882         WARN("bad device ID: %04X\n", wDevID);
883         return MMSYSERR_BADDEVICEID;
884     }
885
886     if ( (fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) != MIXER_GETCONTROLDETAILSF_VALUE )
887     {
888         WARN("Unknown SetControlDetails flag (%08lx)\n", fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK);
889         return MMSYSERR_NOTSUPPORTED;
890     }
891
892     TRACE("MIXER_SETCONTROLDETAILSF_VALUE dwControlID=%d\n", lpmcd->dwControlID);
893     dwControlType = mixer.mixerCtrls[lpmcd->dwControlID].ctrl.dwControlType;
894     switch (dwControlType)
895     {
896         case MIXERCONTROL_CONTROLTYPE_VOLUME:
897             FIXME("controlType : %s\n", getControlType(dwControlType));
898             {
899                 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
900                 Float32 left, right = 0;
901
902                 if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
903                     WARN("invalid parameter: lpmcd->cbDetails == %d\n", lpmcd->cbDetails);
904                     return MMSYSERR_INVALPARAM;
905                 }
906
907                 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
908
909                 switch (lpmcd->cChannels)
910                 {
911                     case 1:
912                         /* mono... so R = L */
913                         TRACE("Setting RL to %d\n", mcdu->dwValue);
914                         left = (Float32) mcdu->dwValue / 65535.0;
915                         break;
916                     case 2:
917                         /* stereo, left is paDetails[0] */
918                         TRACE("Setting L to %d\n", mcdu->dwValue);
919                         left = (Float32) mcdu->dwValue / 65535.0;
920                         mcdu++;
921                         TRACE("Setting R to %d\n", mcdu->dwValue);
922                         right = (Float32) mcdu->dwValue / 65535.0;
923                         break;
924                     default:
925                         WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
926                         return MMSYSERR_INVALPARAM;
927                 }
928                 if ( MIX_LineSetVolume(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, lpmcd->cChannels, left, right) )
929                     ret = MMSYSERR_NOERROR;
930             }
931             break;
932         case MIXERCONTROL_CONTROLTYPE_MUTE:
933         case MIXERCONTROL_CONTROLTYPE_ONOFF:
934             TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(dwControlType), lpmcd->cChannels);
935             {
936                 LPMIXERCONTROLDETAILS_BOOLEAN   mcdb;
937
938                 if (lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
939                     WARN("invalid parameter: cbDetails\n");
940                     return MMSYSERR_INVALPARAM;
941                 }
942                 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
943                 if ( MIX_LineSetMute(mixer.mixerCtrls[lpmcd->dwControlID].dwLineID, mcdb->fValue) )
944                     ret = MMSYSERR_NOERROR;
945             }
946             break;
947         case MIXERCONTROL_CONTROLTYPE_MIXER:
948         case MIXERCONTROL_CONTROLTYPE_MUX:
949         default:
950             FIXME("controlType : %s\n", getControlType(dwControlType));
951             ret = MMSYSERR_NOTSUPPORTED;
952             break;
953     }
954     return ret;
955 }
956
957 /**************************************************************************
958 *                               mxdMessage
959 */
960 DWORD WINAPI CoreAudio_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
961                                   DWORD_PTR dwParam1, DWORD_PTR dwParam2)
962 {
963     TRACE("(%04X, %s, %08lX, %08lX, %08lX);\n", wDevID, getMessage(wMsg),
964           dwUser, dwParam1, dwParam2);
965
966     switch (wMsg)
967     {
968         case DRVM_INIT:
969         case DRVM_EXIT:
970         case DRVM_ENABLE:
971         case DRVM_DISABLE:
972             /* FIXME: Pretend this is supported */
973             return 0;
974         case MXDM_OPEN:
975             return MIX_Open(wDevID, (LPMIXEROPENDESC)dwParam1, dwParam2);
976         case MXDM_CLOSE:
977             return MMSYSERR_NOERROR;
978         case MXDM_GETNUMDEVS:
979             return MIX_GetNumDevs();
980         case MXDM_GETDEVCAPS:
981             return MIX_GetDevCaps(wDevID, (LPMIXERCAPSW)dwParam1, dwParam2);
982         case MXDM_GETLINEINFO:
983             return MIX_GetLineInfo(wDevID, (LPMIXERLINEW)dwParam1, dwParam2);
984         case MXDM_GETLINECONTROLS:
985             return MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSW)dwParam1, dwParam2);
986         case MXDM_GETCONTROLDETAILS:
987             return MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
988         case MXDM_SETCONTROLDETAILS:
989             return MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
990         default:
991             WARN("unknown message %d!\n", wMsg);
992             return MMSYSERR_NOTSUPPORTED;
993     }
994 }
995
996 #else
997
998 DWORD WINAPI CoreAudio_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
999                                   DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1000 {
1001     TRACE("(%04X, %04x, %08lX, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
1002     return MMSYSERR_NOTENABLED;
1003 }
1004 #endif /* HAVE_COREAUDIO_COREAUDIO_H */