?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winealsa.drv: Rewrite channel counting for additional readability and circumvention...
[wine.git] / dlls / wineoss.drv / mixer.c
blob9b6dacc1ede07d653efebfd057a7861ae9d06f9a
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * Sample MIXER Wine Driver for Linux
5 *
6 * Copyright 1997 Marcus Meissner
7 * 1999,2001 Eric Pouech
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 /* TODO:
25 * + implement notification mechanism when state of mixer's controls
26 */
27
28 #include "config.h"
29 #include "wine/port.h"
30
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <string.h>
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38 #include <fcntl.h>
39 #include <errno.h>
40 #include <assert.h>
41 #ifdef HAVE_SYS_IOCTL_H
42 # include <sys/ioctl.h>
43 #endif
44
45 #define NONAMELESSUNION
46 #define NONAMELESSSTRUCT
47 #include "windef.h"
48 #include "winbase.h"
49 #include "winnls.h"
50 #include "mmddk.h"
51 #include "oss.h"
52 #include "wine/unicode.h"
53 #include "wine/debug.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(mixer);
56
57 #ifdef HAVE_OSS
58
59 #define MAX_MIXERDRV (6)
60
61 #define WINE_MIXER_MANUF_ID 0xAA
62 #define WINE_MIXER_PRODUCT_ID 0x55
63 #define WINE_MIXER_VERSION 0x0100
64 #define WINE_MIXER_NAME "WINE OSS Mixer"
65
66 #define WINE_CHN_MASK(_x) (1L << (_x))
67 #define WINE_CHN_SUPPORTS(_c, _x) ((_c) & WINE_CHN_MASK(_x))
68 /* Bass and Treble are no longer in the mask as Windows does not handle them */
69 #define WINE_MIXER_MASK_SPEAKER (WINE_CHN_MASK(SOUND_MIXER_SYNTH) | \
70 WINE_CHN_MASK(SOUND_MIXER_PCM) | \
71 WINE_CHN_MASK(SOUND_MIXER_LINE) | \
72 WINE_CHN_MASK(SOUND_MIXER_MIC) | \
73 WINE_CHN_MASK(SOUND_MIXER_CD) )
74
75 #define WINE_MIXER_MASK_RECORD (WINE_CHN_MASK(SOUND_MIXER_SYNTH) | \
76 WINE_CHN_MASK(SOUND_MIXER_LINE) | \
77 WINE_CHN_MASK(SOUND_MIXER_MIC) | \
78 WINE_CHN_MASK(SOUND_MIXER_IMIX) )
79
80 /* FIXME: the two following string arrays should be moved to a resource file in a string table */
81 /* if it's done, better use a struct to hold labels, name, and muted channel volume cache */
82 static const char * const MIX_Labels[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_LABELS;
83 static const char * const MIX_Names [SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
84
85 struct mixerCtrl
86 {
87 DWORD dwLineID;
88 MIXERCONTROLW ctrl;
89 };
90
91 struct mixer
92 {
93 char* name;
94 char* dev_name;
95 int volume[SOUND_MIXER_NRDEVICES];
96 int devMask;
97 int stereoMask;
98 int recMask;
99 BOOL singleRecChannel;
100 struct mixerCtrl* ctrl;
101 int numCtrl;
102 };
103
104 #define LINEID_DST 0xFFFF
105 #define LINEID_SPEAKER 0x0000
106 #define LINEID_RECORD 0x0001
107
108 static int MIX_NumMixers;
109 static struct mixer MIX_Mixers[MAX_MIXERDRV];
110
111 /**************************************************************************
112 */
113
114 static const char * getMessage(UINT uMsg)
115 {
116 #define MSG_TO_STR(x) case x: return #x;
117 switch (uMsg) {
118 MSG_TO_STR(DRVM_INIT);
119 MSG_TO_STR(DRVM_EXIT);
120 MSG_TO_STR(DRVM_ENABLE);
121 MSG_TO_STR(DRVM_DISABLE);
122 MSG_TO_STR(MXDM_GETDEVCAPS);
123 MSG_TO_STR(MXDM_GETLINEINFO);
124 MSG_TO_STR(MXDM_GETNUMDEVS);
125 MSG_TO_STR(MXDM_OPEN);
126 MSG_TO_STR(MXDM_CLOSE);
127 MSG_TO_STR(MXDM_GETLINECONTROLS);
128 MSG_TO_STR(MXDM_GETCONTROLDETAILS);
129 MSG_TO_STR(MXDM_SETCONTROLDETAILS);
130 }
131 #undef MSG_TO_STR
132 return wine_dbg_sprintf("UNKNOWN(%08x)", uMsg);
133 }
134
135 static const char * getIoctlCommand(int command)
136 {
137 #define IOCTL_TO_STR(x) case x: return #x;
138 switch (command) {
139 IOCTL_TO_STR(SOUND_MIXER_VOLUME);
140 IOCTL_TO_STR(SOUND_MIXER_BASS);
141 IOCTL_TO_STR(SOUND_MIXER_TREBLE);
142 IOCTL_TO_STR(SOUND_MIXER_SYNTH);
143 IOCTL_TO_STR(SOUND_MIXER_PCM);
144 IOCTL_TO_STR(SOUND_MIXER_SPEAKER);
145 IOCTL_TO_STR(SOUND_MIXER_LINE);
146 IOCTL_TO_STR(SOUND_MIXER_MIC);
147 IOCTL_TO_STR(SOUND_MIXER_CD);
148 IOCTL_TO_STR(SOUND_MIXER_IMIX);
149 IOCTL_TO_STR(SOUND_MIXER_ALTPCM);
150 IOCTL_TO_STR(SOUND_MIXER_RECLEV);
151 IOCTL_TO_STR(SOUND_MIXER_IGAIN);
152 IOCTL_TO_STR(SOUND_MIXER_OGAIN);
153 IOCTL_TO_STR(SOUND_MIXER_LINE1);
154 IOCTL_TO_STR(SOUND_MIXER_LINE2);
155 IOCTL_TO_STR(SOUND_MIXER_LINE3);
156 IOCTL_TO_STR(SOUND_MIXER_DIGITAL1);
157 IOCTL_TO_STR(SOUND_MIXER_DIGITAL2);
158 IOCTL_TO_STR(SOUND_MIXER_DIGITAL3);
159 #ifdef SOUND_MIXER_PHONEIN
160 IOCTL_TO_STR(SOUND_MIXER_PHONEIN);
161 #endif
162 #ifdef SOUND_MIXER_PHONEOUT
163 IOCTL_TO_STR(SOUND_MIXER_PHONEOUT);
164 #endif
165 IOCTL_TO_STR(SOUND_MIXER_VIDEO);
166 IOCTL_TO_STR(SOUND_MIXER_RADIO);
167 #ifdef SOUND_MIXER_MONITOR
168 IOCTL_TO_STR(SOUND_MIXER_MONITOR);
169 #endif
170 }
171 #undef IOCTL_TO_STR
172 return wine_dbg_sprintf("UNKNOWN(%08x)", command);
173 }
174
175 static const char * getControlType(DWORD dwControlType)
176 {
177 #define TYPE_TO_STR(x) case x: return #x
178 switch (dwControlType) {
179 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_CUSTOM);
180 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEANMETER);
181 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER);
182 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PEAKMETER);
183 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER);
184 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEAN);
185 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_ONOFF);
186 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUTE);
187 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MONO);
188 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_LOUDNESS);
189 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_STEREOENH);
190 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS_BOOST);
191 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BUTTON);
192 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_DECIBELS);
193 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNED);
194 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNED);
195 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PERCENT);
196 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SLIDER);
197 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PAN);
198 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_QSOUNDPAN);
199 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_FADER);
200 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_VOLUME);
201 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS);
202 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_TREBLE);
203 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_EQUALIZER);
204 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SINGLESELECT);
205 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUX);
206 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT);
207 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MIXER);
208 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MICROTIME);
209 TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MILLITIME);
210 }
211 #undef TYPE_TO_STR
212 return wine_dbg_sprintf("UNKNOWN(%08x)", dwControlType);
213 }
214
215 static const char * getComponentType(DWORD dwComponentType)
216 {
217 #define TYPE_TO_STR(x) case x: return #x;
218 switch (dwComponentType) {
219 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_UNDEFINED);
220 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_DIGITAL);
221 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_LINE);
222 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_MONITOR);
223 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_SPEAKERS);
224 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_HEADPHONES);
225 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_TELEPHONE);
226 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_WAVEIN);
227 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_DST_VOICEIN);
228 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED);
229 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_DIGITAL);
230 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_LINE);
231 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE);
232 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER);
233 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC);
234 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE);
235 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER);
236 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT);
237 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY);
238 TYPE_TO_STR(MIXERLINE_COMPONENTTYPE_SRC_ANALOG);
239 }
240 #undef TYPE_TO_STR
241 return wine_dbg_sprintf("UNKNOWN(%08x)", dwComponentType);
242 }
243
244 static const char * getTargetType(DWORD dwType)
245 {
246 #define TYPE_TO_STR(x) case x: return #x;
247 switch (dwType) {
248 TYPE_TO_STR(MIXERLINE_TARGETTYPE_UNDEFINED);
249 TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEOUT);
250 TYPE_TO_STR(MIXERLINE_TARGETTYPE_WAVEIN);
251 TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIOUT);
252 TYPE_TO_STR(MIXERLINE_TARGETTYPE_MIDIIN);
253 TYPE_TO_STR(MIXERLINE_TARGETTYPE_AUX);
254 }
255 #undef TYPE_TO_STR
256 return wine_dbg_sprintf("UNKNOWN(%08x)", dwType);
257 }
258
259 static const WCHAR sz_short_volume [] = {'V','o','l',0};
260 static const WCHAR sz_long_volume [] = {'V','o','l','u','m','e',0};
261 static const WCHAR sz_shrtlng_mute [] = {'M','u','t','e',0};
262 static const WCHAR sz_shrtlng_mixer[] = {'M','i','x','e','r',0};
263
264 /**************************************************************************
265 * MIX_FillLineControls [internal]
266 */
267 static void MIX_FillLineControls(struct mixer* mix, int c, DWORD lineID,
268 DWORD dwControlType)
269 {
270 struct mixerCtrl* mc = &mix->ctrl[c];
271 int j;
272
273 TRACE("(%p, %d, %08x, %s)\n", mix, c, lineID,
274 getControlType(dwControlType));
275
276 mc->dwLineID = lineID;
277 mc->ctrl.cbStruct = sizeof(MIXERCONTROLW);
278 mc->ctrl.dwControlID = c + 1;
279 mc->ctrl.dwControlType = dwControlType;
280
281 switch (dwControlType)
282 {
283 case MIXERCONTROL_CONTROLTYPE_VOLUME:
284 mc->ctrl.fdwControl = 0;
285 mc->ctrl.cMultipleItems = 0;
286 strcpyW(mc->ctrl.szShortName, sz_short_volume);
287 strcpyW(mc->ctrl.szName, sz_long_volume);
288 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
289 /* CONTROLTYPE_VOLUME uses the MIXER_CONTROLDETAILS_UNSIGNED struct,
290 * [0, 100] is the range supported by OSS
291 * whatever the min and max values are they must match
292 * conversions done in (Get|Set)ControlDetails to stay in [0, 100] range
293 */
294 mc->ctrl.Bounds.s1.dwMinimum = 0;
295 mc->ctrl.Bounds.s1.dwMaximum = 65535;
296 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
297 mc->ctrl.Metrics.cSteps = 656;
298 break;
299 case MIXERCONTROL_CONTROLTYPE_MUTE:
300 case MIXERCONTROL_CONTROLTYPE_ONOFF:
301 mc->ctrl.fdwControl = 0;
302 mc->ctrl.cMultipleItems = 0;
303 strcpyW(mc->ctrl.szShortName, sz_shrtlng_mute);
304 strcpyW(mc->ctrl.szName, sz_shrtlng_mute);
305 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
306 mc->ctrl.Bounds.s1.dwMinimum = 0;
307 mc->ctrl.Bounds.s1.dwMaximum = 1;
308 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
309 break;
310 case MIXERCONTROL_CONTROLTYPE_MUX:
311 case MIXERCONTROL_CONTROLTYPE_MIXER:
312 mc->ctrl.fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE;
313 mc->ctrl.cMultipleItems = 0;
314 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
315 if (WINE_CHN_SUPPORTS(mix->recMask, j))
316 mc->ctrl.cMultipleItems++;
317 strcpyW(mc->ctrl.szShortName, sz_shrtlng_mixer);
318 strcpyW(mc->ctrl.szName, sz_shrtlng_mixer);
319 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
320 mc->ctrl.Bounds.s1.dwMaximum = mc->ctrl.cMultipleItems - 1;
321 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
322 mc->ctrl.Metrics.cSteps = mc->ctrl.cMultipleItems;
323 break;
324
325 default:
326 FIXME("Internal error: unknown type: %08x\n", dwControlType);
327 }
328 TRACE("ctrl[%2d]: typ=%08x lin=%08x\n", c + 1, dwControlType, lineID);
329 }
330
331 /******************************************************************
332 * MIX_GetMixer
333 *
334 *
335 */
336 static struct mixer* MIX_Get(WORD wDevID)
337 {
338 TRACE("(%04x)\n", wDevID);
339
340 if (wDevID >= MIX_NumMixers || MIX_Mixers[wDevID].dev_name == NULL)
341 return NULL;
342
343 return &MIX_Mixers[wDevID];
344 }
345
346 /**************************************************************************
347 * MIX_Open [internal]
348 */
349 static DWORD MIX_Open(WORD wDevID, LPMIXEROPENDESC lpMod, DWORD flags)
350 {
351 int mixer, i, j;
352 unsigned caps;
353 struct mixer* mix;
354 DWORD ret = MMSYSERR_NOERROR;
355
356 TRACE("(%04X, %p, %u);\n", wDevID, lpMod, flags);
357
358 /* as we partly init the mixer with MIX_Open, we can allow null open decs
359 * EPP if (lpMod == NULL) return MMSYSERR_INVALPARAM;
360 * anyway, it seems that WINMM/MMSYSTEM doesn't always open the mixer
361 * device before sending messages to it... it seems to be linked to all
362 * the equivalent of mixer identification
363 * (with a reference to a wave, midi.. handle
364 */
365 if ((mix = MIX_Get(wDevID)) == NULL) {
366 WARN("bad device ID: %04X\n", wDevID);
367 return MMSYSERR_BADDEVICEID;
368 }
369
370 if ((mixer = open(mix->dev_name, O_RDWR)) < 0)
371 {
372 ERR("open(%s, O_RDWR) failed (%s)\n",
373 mix->dev_name, strerror(errno));
374
375 if (errno == ENODEV || errno == ENXIO)
376 {
377 /* no driver present */
378 WARN("no driver\n");
379 return MMSYSERR_NODRIVER;
380 }
381 return MMSYSERR_ERROR;
382 }
383
384 if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &mix->devMask) == -1)
385 {
386 ERR("ioctl(%s, SOUND_MIXER_DEVMASK) failed (%s)\n",
387 mix->dev_name, strerror(errno));
388 ret = MMSYSERR_ERROR;
389 goto error;
390 }
391
392 mix->devMask &= WINE_MIXER_MASK_SPEAKER;
393 if (mix->devMask == 0)
394 {
395 WARN("no driver\n");
396 ret = MMSYSERR_NODRIVER;
397 goto error;
398 }
399
400 if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &mix->stereoMask) == -1)
401 {
402 ERR("ioctl(%s, SOUND_MIXER_STEREODEVS) failed (%s)\n",
403 mix->dev_name, strerror(errno));
404 ret = MMSYSERR_ERROR;
405 goto error;
406 }
407 mix->stereoMask &= WINE_MIXER_MASK_SPEAKER;
408
409 if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &mix->recMask) == -1)
410 {
411 ERR("ioctl(%s, SOUND_MIXER_RECMASK) failed (%s)\n",
412 mix->dev_name, strerror(errno));
413 ret = MMSYSERR_ERROR;
414 goto error;
415 }
416 mix->recMask &= WINE_MIXER_MASK_RECORD;
417 /* FIXME: we may need to support both rec lev & igain */
418 if (!WINE_CHN_SUPPORTS(mix->recMask, SOUND_MIXER_RECLEV))
419 {
420 WARN("The sound card doesn't support rec level\n");
421 if (WINE_CHN_SUPPORTS(mix->recMask, SOUND_MIXER_IGAIN))
422 WARN("but it does support IGain, please report\n");
423 }
424 if (ioctl(mixer, SOUND_MIXER_READ_CAPS, &caps) == -1)
425 {
426 ERR("ioctl(%s, SOUND_MIXER_READ_CAPS) failed (%s)\n",
427 mix->dev_name, strerror(errno));
428 ret = MMSYSERR_ERROR;
429 goto error;
430 }
431 mix->singleRecChannel = caps & SOUND_CAP_EXCL_INPUT;
432 TRACE("dev=%04x rec=%04x stereo=%04x %s\n",
433 mix->devMask, mix->recMask, mix->stereoMask,
434 mix->singleRecChannel ? "single" : "multiple");
435 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
436 {
437 mix->volume[i] = -1;
438 }
439 mix->numCtrl = 4; /* dst lines... vol&mute on speakers, vol&onoff on rec */
440 /* FIXME: do we always have RECLEV on all cards ??? */
441 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
442 {
443 if (WINE_CHN_SUPPORTS(mix->devMask, i))
444 mix->numCtrl += 2; /* volume & mute */
445 if (WINE_CHN_SUPPORTS(mix->recMask, i))
446 mix->numCtrl += 2; /* volume & onoff */
447
448 }
449 if (!(mix->ctrl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
450 sizeof(mix->ctrl[0]) * mix->numCtrl)))
451 {
452 ret = MMSYSERR_NOMEM;
453 goto error;
454 }
455
456 j = 0;
457 MIX_FillLineControls(mix, j++, MAKELONG(0, LINEID_DST),
458 MIXERCONTROL_CONTROLTYPE_VOLUME);
459 MIX_FillLineControls(mix, j++, MAKELONG(0, LINEID_DST),
460 MIXERCONTROL_CONTROLTYPE_MUTE);
461 MIX_FillLineControls(mix, j++, MAKELONG(1, LINEID_DST),
462 mix->singleRecChannel ?
463 MIXERCONTROL_CONTROLTYPE_MUX :
464 MIXERCONTROL_CONTROLTYPE_MIXER);
465 MIX_FillLineControls(mix, j++, MAKELONG(1, LINEID_DST),
466 MIXERCONTROL_CONTROLTYPE_MUTE/*EPP*/);
467 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
468 {
469 if (WINE_CHN_SUPPORTS(mix->devMask, i))
470 {
471 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_SPEAKER, i),
472 MIXERCONTROL_CONTROLTYPE_VOLUME);
473 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_SPEAKER, i),
474 MIXERCONTROL_CONTROLTYPE_MUTE);
475 }
476 }
477 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
478 {
479 if (WINE_CHN_SUPPORTS(mix->recMask, i))
480 {
481 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_RECORD, i),
482 MIXERCONTROL_CONTROLTYPE_VOLUME);
483 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_RECORD, i),
484 MIXERCONTROL_CONTROLTYPE_MUTE/*EPP*/);
485 }
486 }
487 assert(j == mix->numCtrl);
488 error:
489 close(mixer);
490 return ret;
491 }
492
493 /**************************************************************************
494 * MIX_GetVal [internal]
495 */
496 static BOOL MIX_GetVal(struct mixer* mix, int chn, int* val)
497 {
498 int mixer;
499 BOOL ret = FALSE;
500
501 TRACE("(%p, %s, %p\n", mix, getIoctlCommand(chn), val);
502
503 if ((mixer = open(mix->dev_name, O_RDWR)) < 0) {
504 /* FIXME: ENXIO => no mixer installed */
505 WARN("mixer device not available !\n");
506 } else {
507 if (ioctl(mixer, MIXER_READ(chn), val) >= 0) {
508 TRACE("Reading %04x for %s\n", *val, getIoctlCommand(chn));
509 ret = TRUE;
510 } else {
511 ERR("ioctl(%s, MIXER_READ(%s)) failed (%s)\n",
512 mix->dev_name, getIoctlCommand(chn), strerror(errno));
513 }
514 close(mixer);
515 }
516 return ret;
517 }
518
519 /**************************************************************************
520 * MIX_SetVal [internal]
521 */
522 static BOOL MIX_SetVal(struct mixer* mix, int chn, int val)
523 {
524 int mixer;
525 BOOL ret = FALSE;
526
527 TRACE("(%p, %s, %x)\n", mix, getIoctlCommand(chn), val);
528
529 if ((mixer = open(mix->dev_name, O_RDWR)) < 0) {
530 /* FIXME: ENXIO => no mixer installed */
531 WARN("mixer device not available !\n");
532 } else {
533 if (ioctl(mixer, MIXER_WRITE(chn), &val) >= 0) {
534 TRACE("Set %s to %04x\n", getIoctlCommand(chn), val);
535 ret = TRUE;
536 } else {
537 ERR("ioctl(%s, MIXER_WRITE(%s)) failed (%s)\n",
538 mix->dev_name, getIoctlCommand(chn), strerror(errno));
539 }
540 close(mixer);
541 }
542 return ret;
543 }
544
545 /******************************************************************
546 * MIX_GetRecSrc
547 *
548 *
549 */
550 static BOOL MIX_GetRecSrc(struct mixer* mix, unsigned* mask)
551 {
552 int mixer;
553 BOOL ret = FALSE;
554
555 TRACE("(%p, %p)\n", mix, mask);
556
557 if ((mixer = open(mix->dev_name, O_RDWR)) >= 0) {
558 if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &mask) >= 0) {
559 ret = TRUE;
560 } else {
561 ERR("ioctl(%s, SOUND_MIXER_READ_RECSRC) failed (%s)\n",
562 mix->dev_name, strerror(errno));
563 }
564 close(mixer);
565 }
566 return ret;
567 }
568
569 /******************************************************************
570 * MIX_SetRecSrc
571 *
572 *
573 */
574 static BOOL MIX_SetRecSrc(struct mixer* mix, unsigned mask)
575 {
576 int mixer;
577 BOOL ret = FALSE;
578
579 TRACE("(%p, %08x)\n", mix, mask);
580
581 if ((mixer = open(mix->dev_name, O_RDWR)) >= 0) {
582 if (ioctl(mixer, SOUND_MIXER_WRITE_RECSRC, &mask) >= 0) {
583 ret = TRUE;
584 } else {
585 ERR("ioctl(%s, SOUND_MIXER_WRITE_RECSRC) failed (%s)\n",
586 mix->dev_name, strerror(errno));
587 }
588 close(mixer);
589 }
590 return ret;
591 }
592
593 /**************************************************************************
594 * MIX_GetDevCaps [internal]
595 */
596 static DWORD MIX_GetDevCaps(WORD wDevID, LPMIXERCAPSW lpCaps, DWORD dwSize)
597 {
598 struct mixer* mix;
599 MIXERCAPSW capsW;
600 const char* name;
601
602 TRACE("(%04X, %p, %u);\n", wDevID, lpCaps, dwSize);
603
604 if (lpCaps == NULL) {
605 WARN("invalid parameter: lpCaps == NULL\n");
606 return MMSYSERR_INVALPARAM;
607 }
608
609 if ((mix = MIX_Get(wDevID)) == NULL) {
610 WARN("bad device ID: %04X\n", wDevID);
611 return MMSYSERR_BADDEVICEID;
612 }
613
614 capsW.wMid = WINE_MIXER_MANUF_ID;
615 capsW.wPid = WINE_MIXER_PRODUCT_ID;
616 capsW.vDriverVersion = WINE_MIXER_VERSION;
617 if (!(name = mix->name)) name = WINE_MIXER_NAME;
618 MultiByteToWideChar(CP_UNIXCP, 0, name, -1, capsW.szPname, sizeof(capsW.szPname) / sizeof(WCHAR));
619 capsW.cDestinations = 2; /* speakers & record */
620 capsW.fdwSupport = 0; /* No bits defined yet */
621
622 memcpy(lpCaps, &capsW, min(dwSize, sizeof(capsW)));
623
624 return MMSYSERR_NOERROR;
625 }
626
627 /**************************************************************************
628 * MIX_GetLineInfoDst [internal]
629 */
630 static DWORD MIX_GetLineInfoDst(struct mixer* mix, LPMIXERLINEW lpMl,
631 DWORD dst)
632 {
633 unsigned mask;
634 int j;
635
636 TRACE("(%p, %p, %08x)\n", mix, lpMl, dst);
637
638 lpMl->dwDestination = dst;
639 switch (dst)
640 {
641 case LINEID_SPEAKER:
642 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
643 mask = mix->devMask;
644 j = SOUND_MIXER_VOLUME;
645 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
646 break;
647 case LINEID_RECORD:
648 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
649 mask = mix->recMask;
650 j = SOUND_MIXER_RECLEV;
651 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
652 break;
653 default:
654 FIXME("shouldn't happen\n");
655 return MMSYSERR_ERROR;
656 }
657 lpMl->dwSource = 0xFFFFFFFF;
658 MultiByteToWideChar(CP_UNIXCP, 0, MIX_Labels[j], -1, lpMl->szShortName, sizeof(lpMl->szShortName) / sizeof(WCHAR));
659 MultiByteToWideChar(CP_UNIXCP, 0, MIX_Names[j], -1, lpMl->szName, sizeof(lpMl->szName) / sizeof(WCHAR));
660
661 /* we have all connections found in the MIX_DevMask */
662 lpMl->cConnections = 0;
663 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
664 if (WINE_CHN_SUPPORTS(mask, j))
665 lpMl->cConnections++;
666 lpMl->cChannels = 1;
667 if (WINE_CHN_SUPPORTS(mix->stereoMask, lpMl->dwLineID))
668 lpMl->cChannels++;
669 lpMl->dwLineID = MAKELONG(dst, LINEID_DST);
670 lpMl->cControls = 0;
671 for (j = 0; j < mix->numCtrl; j++)
672 if (mix->ctrl[j].dwLineID == lpMl->dwLineID)
673 lpMl->cControls++;
674
675 return MMSYSERR_NOERROR;
676 }
677
678 /**************************************************************************
679 * MIX_GetLineInfoSrc [internal]
680 */
681 static DWORD MIX_GetLineInfoSrc(struct mixer* mix, LPMIXERLINEW lpMl,
682 DWORD idx, DWORD dst)
683 {
684 int i, j;
685 unsigned mask = (dst) ? mix->recMask : mix->devMask;
686
687 TRACE("(%p, %p, %d, %08x)\n", mix, lpMl, idx, dst);
688
689 MultiByteToWideChar(CP_UNIXCP, 0, MIX_Labels[idx], -1, lpMl->szShortName, sizeof(lpMl->szShortName) / sizeof(WCHAR));
690 MultiByteToWideChar(CP_UNIXCP, 0, MIX_Names[idx], -1, lpMl->szName, sizeof(lpMl->szName) / sizeof(WCHAR));
691 lpMl->dwLineID = MAKELONG(dst, idx);
692 lpMl->dwDestination = dst;
693 lpMl->cConnections = 1;
694 lpMl->cControls = 0;
695 for (i = 0; i < mix->numCtrl; i++)
696 if (mix->ctrl[i].dwLineID == lpMl->dwLineID)
697 lpMl->cControls++;
698
699 switch (idx)
700 {
701 case SOUND_MIXER_SYNTH:
702 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
703 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
704 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_MIDIOUT;
705 break;
706 case SOUND_MIXER_CD:
707 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
708 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
709 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
710 break;
711 case SOUND_MIXER_LINE:
712 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
713 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
714 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
715 break;
716 case SOUND_MIXER_MIC:
717 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
718 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
719 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
720 break;
721 case SOUND_MIXER_PCM:
722 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
723 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
724 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
725 break;
726 case SOUND_MIXER_IMIX:
727 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
728 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
729 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
730 break;
731 default:
732 WARN("Index %d not handled.\n", idx);
733 return MIXERR_INVALLINE;
734 }
735 lpMl->cChannels = 1;
736 if (dst == 0 && WINE_CHN_SUPPORTS(mix->stereoMask, idx))
737 lpMl->cChannels++;
738 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
739 {
740 if (WINE_CHN_SUPPORTS(mask, j))
741 {
742 if (j == idx) break;
743 i++;
744 }
745 }
746 lpMl->dwSource = i;
747 return MMSYSERR_NOERROR;
748 }
749
750 /******************************************************************
751 * MIX_CheckLine
752 */
753 static BOOL MIX_CheckLine(DWORD lineID)
754 {
755 TRACE("(%08x)\n",lineID);
756
757 return ((HIWORD(lineID) < SOUND_MIXER_NRDEVICES && LOWORD(lineID) < 2) ||
758 (HIWORD(lineID) == LINEID_DST &&
759 LOWORD(lineID) < SOUND_MIXER_NRDEVICES));
760 }
761
762 /**************************************************************************
763 * MIX_GetLineInfo [internal]
764 */
765 static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEW lpMl, DWORD fdwInfo)
766 {
767 int i, j;
768 DWORD ret = MMSYSERR_NOERROR;
769 unsigned mask;
770 struct mixer* mix;
771
772 TRACE("(%04X, %p, %u);\n", wDevID, lpMl, fdwInfo);
773
774 if (lpMl == NULL) {
775 WARN("invalid parameter: lpMl = NULL\n");
776 return MMSYSERR_INVALPARAM;
777 }
778
779 if (lpMl->cbStruct != sizeof(*lpMl)) {
780 WARN("invalid parameter: lpMl->cbStruct = %d\n",
781 lpMl->cbStruct);
782 return MMSYSERR_INVALPARAM;
783 }
784
785 if ((mix = MIX_Get(wDevID)) == NULL) {
786 WARN("bad device ID: %04X\n", wDevID);
787 return MMSYSERR_BADDEVICEID;
788 }
789
790 /* FIXME: set all the variables correctly... the lines below
791 * are very wrong...
792 */
793 lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
794 lpMl->dwUser = 0;
795
796 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
797 {
798 case MIXER_GETLINEINFOF_DESTINATION:
799 TRACE("MIXER_GETLINEINFOF_DESTINATION (%08x)\n", lpMl->dwDestination);
800 if (lpMl->dwDestination >= 2) {
801 WARN("invalid parameter: lpMl->dwDestination = %d >= 2\n",
802 lpMl->dwDestination);
803 return MMSYSERR_INVALPARAM;
804 }
805 ret = MIX_GetLineInfoDst(mix, lpMl, lpMl->dwDestination);
806 if (ret != MMSYSERR_NOERROR) {
807 WARN("error\n");
808 return ret;
809 }
810 break;
811 case MIXER_GETLINEINFOF_SOURCE:
812 TRACE("MIXER_GETLINEINFOF_SOURCE (%08x), dst=%08x\n", lpMl->dwSource,
813 lpMl->dwDestination);
814 switch (lpMl->dwDestination)
815 {
816 case LINEID_SPEAKER: mask = mix->devMask; break;
817 case LINEID_RECORD: mask = mix->recMask; break;
818 default:
819 WARN("invalid parameter\n");
820 return MMSYSERR_INVALPARAM;
821 }
822 i = lpMl->dwSource;
823 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
824 {
825 if (WINE_CHN_SUPPORTS(mask, j) && (i-- == 0))
826 break;
827 }
828 if (j >= SOUND_MIXER_NRDEVICES) {
829 WARN("invalid line\n");
830 return MIXERR_INVALLINE;
831 }
832 ret = MIX_GetLineInfoSrc(mix, lpMl, j, lpMl->dwDestination);
833 if (ret != MMSYSERR_NOERROR) {
834 WARN("error\n");
835 return ret;
836 }
837 break;
838 case MIXER_GETLINEINFOF_LINEID:
839 TRACE("MIXER_GETLINEINFOF_LINEID (%08x)\n", lpMl->dwLineID);
840
841 if (!MIX_CheckLine(lpMl->dwLineID)) {
842 WARN("invalid line\n");
843 return MIXERR_INVALLINE;
844 }
845 if (HIWORD(lpMl->dwLineID) == LINEID_DST)
846 ret = MIX_GetLineInfoDst(mix, lpMl, LOWORD(lpMl->dwLineID));
847 else
848 ret = MIX_GetLineInfoSrc(mix, lpMl, HIWORD(lpMl->dwLineID),
849 LOWORD(lpMl->dwLineID));
850 if (ret != MMSYSERR_NOERROR) {
851 WARN("error\n");
852 return ret;
853 }
854 break;
855 case MIXER_GETLINEINFOF_COMPONENTTYPE:
856 TRACE("MIXER_GETLINEINFOF_COMPONENTTYPE (%s)\n",
857 getComponentType(lpMl->dwComponentType));
858 switch (lpMl->dwComponentType)
859 {
860 case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES:
861 case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
862 ret = MIX_GetLineInfoDst(mix, lpMl, LINEID_SPEAKER);
863 break;
864 case MIXERLINE_COMPONENTTYPE_DST_LINE:
865 case MIXERLINE_COMPONENTTYPE_DST_VOICEIN:
866 case MIXERLINE_COMPONENTTYPE_DST_WAVEIN:
867 ret = MIX_GetLineInfoDst(mix, lpMl, LINEID_RECORD);
868 break;
869 case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER:
870 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_SYNTH, 0);
871 break;
872 case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC:
873 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_CD, 0);
874 break;
875 case MIXERLINE_COMPONENTTYPE_SRC_LINE:
876 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_LINE, 0);
877 break;
878 case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE:
879 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_MIC, 1);
880 break;
881 case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
882 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_PCM, 0);
883 break;
884 case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED:
885 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_IMIX, 1);
886 break;
887 default:
888 FIXME("Unhandled component type (%s)\n",
889 getComponentType(lpMl->dwComponentType));
890 return MMSYSERR_INVALPARAM;
891 }
892 break;
893 case MIXER_GETLINEINFOF_TARGETTYPE:
894 FIXME("MIXER_GETLINEINFOF_TARGETTYPE not implemented yet.\n");
895 TRACE("MIXER_GETLINEINFOF_TARGETTYPE (%s)\n",
896 getTargetType(lpMl->Target.dwType));
897 switch (lpMl->Target.dwType) {
898 case MIXERLINE_TARGETTYPE_UNDEFINED:
899 case MIXERLINE_TARGETTYPE_WAVEOUT:
900 case MIXERLINE_TARGETTYPE_WAVEIN:
901 case MIXERLINE_TARGETTYPE_MIDIOUT:
902 case MIXERLINE_TARGETTYPE_MIDIIN:
903 case MIXERLINE_TARGETTYPE_AUX:
904 default:
905 FIXME("Unhandled target type (%s)\n",
906 getTargetType(lpMl->Target.dwType));
907 return MMSYSERR_INVALPARAM;
908 }
909 break;
910 default:
911 WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
912 break;
913 }
914
915 if ((fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) != MIXER_GETLINEINFOF_TARGETTYPE) {
916 const char* name;
917 lpMl->Target.dwDeviceID = 0xFFFFFFFF;
918 lpMl->Target.wMid = WINE_MIXER_MANUF_ID;
919 lpMl->Target.wPid = WINE_MIXER_PRODUCT_ID;
920 lpMl->Target.vDriverVersion = WINE_MIXER_VERSION;
921 if (!(name = mix->name)) name = WINE_MIXER_NAME;
922 MultiByteToWideChar(CP_UNIXCP, 0, name, -1, lpMl->Target.szPname, sizeof(lpMl->Target.szPname) / sizeof(WCHAR));
923 }
924
925 return ret;
926 }
927
928 /******************************************************************
929 * MIX_CheckControl
930 *
931 */
932 static BOOL MIX_CheckControl(struct mixer* mix, DWORD ctrlID)
933 {
934 TRACE("(%p, %08x)\n", mix, ctrlID);
935
936 return (ctrlID >= 1 && ctrlID <= mix->numCtrl);
937 }
938
939 /**************************************************************************
940 * MIX_GetLineControls [internal]
941 */
942 static DWORD MIX_GetLineControls(WORD wDevID, LPMIXERLINECONTROLSW lpMlc,
943 DWORD flags)
944 {
945 DWORD dwRet = MMSYSERR_NOERROR;
946 struct mixer* mix;
947
948 TRACE("(%04X, %p, %u);\n", wDevID, lpMlc, flags);
949
950 if (lpMlc == NULL) {
951 WARN("invalid parameter: lpMlc == NULL\n");
952 return MMSYSERR_INVALPARAM;
953 }
954
955 if (lpMlc->cbStruct < sizeof(*lpMlc)) {
956 WARN("invalid parameter: lpMlc->cbStruct = %d\n",
957 lpMlc->cbStruct);
958 return MMSYSERR_INVALPARAM;
959 }
960
961 if (lpMlc->cbmxctrl < sizeof(MIXERCONTROLW)) {
962 WARN("invalid parameter: lpMlc->cbmxctrl = %d\n",
963 lpMlc->cbmxctrl);
964 return MMSYSERR_INVALPARAM;
965 }
966
967 if ((mix = MIX_Get(wDevID)) == NULL) {
968 WARN("bad device ID: %04X\n", wDevID);
969 return MMSYSERR_BADDEVICEID;
970 }
971
972 switch (flags & MIXER_GETLINECONTROLSF_QUERYMASK)
973 {
974 case MIXER_GETLINECONTROLSF_ALL:
975 {
976 int i, j;
977
978 TRACE("line=%08x MIXER_GETLINECONTROLSF_ALL (%d)\n",
979 lpMlc->dwLineID, lpMlc->cControls);
980
981 for (i = j = 0; i < mix->numCtrl; i++)
982 {
983 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID)
984 j++;
985 }
986
987 if (!j || lpMlc->cControls != j) {
988 WARN("invalid parameter\n");
989 dwRet = MMSYSERR_INVALPARAM;
990 } else if (!MIX_CheckLine(lpMlc->dwLineID)) {
991 WARN("invalid line\n");
992 dwRet = MIXERR_INVALLINE;
993 } else {
994 for (i = j = 0; i < mix->numCtrl; i++)
995 {
996 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID)
997 {
998 TRACE("[%d] => [%2d]: typ=%08x\n", j, i + 1,
999 mix->ctrl[i].ctrl.dwControlType);
1000 lpMlc->pamxctrl[j++] = mix->ctrl[i].ctrl;
1001 }
1002 }
1003 }
1004 }
1005 break;
1006 case MIXER_GETLINECONTROLSF_ONEBYID:
1007 TRACE("line=%08x MIXER_GETLINECONTROLSF_ONEBYID (%x)\n",
1008 lpMlc->dwLineID, lpMlc->u.dwControlID);
1009
1010 if (!MIX_CheckControl(mix, lpMlc->u.dwControlID) ||
1011 mix->ctrl[lpMlc->u.dwControlID - 1].dwLineID != lpMlc->dwLineID) {
1012 WARN("invalid parameter\n");
1013 dwRet = MMSYSERR_INVALPARAM;
1014 } else
1015 lpMlc->pamxctrl[0] = mix->ctrl[lpMlc->u.dwControlID - 1].ctrl;
1016 break;
1017 case MIXER_GETLINECONTROLSF_ONEBYTYPE:
1018 TRACE("line=%08x MIXER_GETLINECONTROLSF_ONEBYTYPE (%s)\n",
1019 lpMlc->dwLineID, getControlType(lpMlc->u.dwControlType));
1020 if (!MIX_CheckLine(lpMlc->dwLineID)) {
1021 WARN("invalid line\n");
1022 dwRet = MIXERR_INVALLINE;
1023 } else {
1024 int i;
1025 DWORD ct = lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK;
1026 for (i = 0; i < mix->numCtrl; i++) {
1027 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID &&
1028 ct == (mix->ctrl[i].ctrl.dwControlType &
1029 MIXERCONTROL_CT_CLASS_MASK)) {
1030 lpMlc->pamxctrl[0] = mix->ctrl[i].ctrl;
1031 break;
1032 }
1033 }
1034
1035 if (i == mix->numCtrl) {
1036 WARN("invalid parameter: control not found\n");
1037 dwRet = MMSYSERR_INVALPARAM;
1038 }
1039 }
1040 break;
1041 default:
1042 ERR("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
1043 dwRet = MMSYSERR_INVALPARAM;
1044 }
1045
1046 return dwRet;
1047 }
1048
1049 /**************************************************************************
1050 * MIX_GetControlDetails [internal]
1051 */
1052 static DWORD MIX_GetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd,
1053 DWORD fdwDetails)
1054 {
1055 DWORD ret = MMSYSERR_NOTSUPPORTED;
1056 DWORD chnl;
1057 struct mixer* mix;
1058
1059 TRACE("(%04X, %p, %u);\n", wDevID, lpmcd, fdwDetails);
1060
1061 if (lpmcd == NULL) {
1062 WARN("invalid parameter: lpmcd == NULL\n");
1063 return MMSYSERR_INVALPARAM;
1064 }
1065
1066 if ((mix = MIX_Get(wDevID)) == NULL) {
1067 WARN("bad device ID: %04X\n", wDevID);
1068 return MMSYSERR_BADDEVICEID;
1069 }
1070
1071 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK)
1072 {
1073 case MIXER_GETCONTROLDETAILSF_VALUE:
1074 TRACE("MIXER_GETCONTROLDETAILSF_VALUE (%08x)\n", lpmcd->dwControlID);
1075 if (MIX_CheckControl(mix, lpmcd->dwControlID))
1076 {
1077 DWORD c = lpmcd->dwControlID - 1;
1078 chnl = HIWORD(mix->ctrl[c].dwLineID);
1079 if (chnl == LINEID_DST)
1080 chnl = LOWORD(mix->ctrl[c].dwLineID) ? SOUND_MIXER_RECLEV :
1081 SOUND_MIXER_VOLUME;
1082 switch (mix->ctrl[c].ctrl.dwControlType)
1083 {
1084 case MIXERCONTROL_CONTROLTYPE_VOLUME:
1085 {
1086 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
1087 int val;
1088
1089 if (lpmcd->cbDetails !=
1090 sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
1091 WARN("invalid parameter: cbDetails = %d\n",
1092 lpmcd->cbDetails);
1093 return MMSYSERR_INVALPARAM;
1094 }
1095
1096 TRACE("%s MIXERCONTROLDETAILS_UNSIGNED[%u]\n",
1097 getControlType(mix->ctrl[c].ctrl.dwControlType),
1098 lpmcd->cChannels);
1099
1100 mcdu = lpmcd->paDetails;
1101
1102 /* return value is 00RL (4 bytes)... */
1103 if ((val = mix->volume[chnl]) == -1 &&
1104 !MIX_GetVal(mix, chnl, &val)) {
1105 WARN("invalid parameter\n");
1106 return MMSYSERR_INVALPARAM;
1107 }
1108
1109 switch (lpmcd->cChannels)
1110 {
1111 case 1:
1112 /* mono... so R = L */
1113 mcdu->dwValue = ((LOBYTE(LOWORD(val)) * 65536.0) / 100.0) + 0.5;
1114 TRACE("Reading RL = %d\n", mcdu->dwValue);
1115 break;
1116 case 2:
1117 /* stereo, left is paDetails[0] */
1118 mcdu->dwValue = ((LOBYTE(LOWORD(val)) * 65536.0) / 100.0) + 0.5;
1119 TRACE("Reading L = %d\n", mcdu->dwValue);
1120 mcdu++;
1121 mcdu->dwValue = ((HIBYTE(LOWORD(val)) * 65536.0) / 100.0) + 0.5;
1122 TRACE("Reading R = %d\n", mcdu->dwValue);
1123 break;
1124 default:
1125 WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
1126 return MMSYSERR_INVALPARAM;
1127 }
1128 TRACE("=> %08x\n", mcdu->dwValue);
1129 }
1130 break;
1131 case MIXERCONTROL_CONTROLTYPE_MUTE:
1132 case MIXERCONTROL_CONTROLTYPE_ONOFF:
1133 {
1134 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
1135
1136 if (lpmcd->cbDetails !=
1137 sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
1138 WARN("invalid parameter: cbDetails = %d\n",
1139 lpmcd->cbDetails);
1140 return MMSYSERR_INVALPARAM;
1141 }
1142
1143 TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n",
1144 getControlType(mix->ctrl[c].ctrl.dwControlType),
1145 lpmcd->cChannels);
1146
1147 /* we mute both channels at the same time */
1148 mcdb = lpmcd->paDetails;
1149 mcdb->fValue = (mix->volume[chnl] != -1);
1150 TRACE("=> %s\n", mcdb->fValue ? "on" : "off");
1151 }
1152 break;
1153 case MIXERCONTROL_CONTROLTYPE_MIXER:
1154 case MIXERCONTROL_CONTROLTYPE_MUX:
1155 {
1156 unsigned mask;
1157
1158 if (lpmcd->cbDetails !=
1159 sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
1160 WARN("invalid parameter: cbDetails = %d\n",
1161 lpmcd->cbDetails);
1162 return MMSYSERR_INVALPARAM;
1163 }
1164
1165 TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n",
1166 getControlType(mix->ctrl[c].ctrl.dwControlType),
1167 lpmcd->cChannels);
1168
1169 if (!MIX_GetRecSrc(mix, &mask))
1170 {
1171 /* FIXME: ENXIO => no mixer installed */
1172 WARN("mixer device not available !\n");
1173 ret = MMSYSERR_ERROR;
1174 }
1175 else
1176 {
1177 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
1178 int i, j;
1179
1180 /* we mute both channels at the same time */
1181 mcdb = lpmcd->paDetails;
1182
1183 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
1184 {
1185 if (WINE_CHN_SUPPORTS(mix->recMask, j))
1186 {
1187 if (i >= lpmcd->u.cMultipleItems)
1188 return MMSYSERR_INVALPARAM;
1189 mcdb[i++].fValue = WINE_CHN_SUPPORTS(mask, j);
1190 }
1191 }
1192 }
1193 }
1194 break;
1195 default:
1196 WARN("%s Unsupported\n",
1197 getControlType(mix->ctrl[c].ctrl.dwControlType));
1198 }
1199 ret = MMSYSERR_NOERROR;
1200 }
1201 else
1202 {
1203 WARN("invalid parameter\n");
1204 ret = MMSYSERR_INVALPARAM;
1205 }
1206 break;
1207 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
1208 TRACE("MIXER_GETCONTROLDETAILSF_LISTTEXT (%08x)\n",
1209 lpmcd->dwControlID);
1210
1211 ret = MMSYSERR_INVALPARAM;
1212 if (MIX_CheckControl(mix, lpmcd->dwControlID))
1213 {
1214 DWORD c = lpmcd->dwControlID - 1;
1215
1216 if (mix->ctrl[c].ctrl.dwControlType == MIXERCONTROL_CONTROLTYPE_MUX ||
1217 mix->ctrl[c].ctrl.dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER)
1218 {
1219 LPMIXERCONTROLDETAILS_LISTTEXTW mcdlt;
1220 int i, j;
1221
1222 mcdlt = lpmcd->paDetails;
1223 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
1224 {
1225 if (WINE_CHN_SUPPORTS(mix->recMask, j))
1226 {
1227 mcdlt[i].dwParam1 = MAKELONG(LINEID_RECORD, j);
1228 mcdlt[i].dwParam2 = 0;
1229 MultiByteToWideChar(CP_UNIXCP, 0, MIX_Names[j], -1,
1230 mcdlt[i].szName, sizeof(mcdlt[i]) / sizeof(WCHAR));
1231 i++;
1232 }
1233 }
1234 if (i != lpmcd->u.cMultipleItems) FIXME("bad count\n");
1235 ret = MMSYSERR_NOERROR;
1236 }
1237 }
1238 break;
1239 default:
1240 WARN("Unknown flag (%08lx)\n",
1241 fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
1242 }
1243 return ret;
1244 }
1245
1246 /**************************************************************************
1247 * MIX_SetControlDetails [internal]
1248 */
1249 static DWORD MIX_SetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd,
1250 DWORD fdwDetails)
1251 {
1252 DWORD ret = MMSYSERR_NOTSUPPORTED;
1253 DWORD c, chnl;
1254 int val;
1255 struct mixer* mix;
1256
1257 TRACE("(%04X, %p, %u);\n", wDevID, lpmcd, fdwDetails);
1258
1259 if (lpmcd == NULL) {
1260 TRACE("invalid parameter: lpmcd == NULL\n");
1261 return MMSYSERR_INVALPARAM;
1262 }
1263
1264 if ((mix = MIX_Get(wDevID)) == NULL) {
1265 WARN("bad device ID: %04X\n", wDevID);
1266 return MMSYSERR_BADDEVICEID;
1267 }
1268
1269 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK)
1270 {
1271 case MIXER_GETCONTROLDETAILSF_VALUE:
1272 TRACE("MIXER_GETCONTROLDETAILSF_VALUE (%08x)\n", lpmcd->dwControlID);
1273 if (MIX_CheckControl(mix, lpmcd->dwControlID))
1274 {
1275 c = lpmcd->dwControlID - 1;
1276
1277 TRACE("dwLineID=%08x\n",mix->ctrl[c].dwLineID);
1278
1279 chnl = HIWORD(mix->ctrl[c].dwLineID);
1280 if (chnl == LINEID_DST)
1281 chnl = LOWORD(mix->ctrl[c].dwLineID) ?
1282 SOUND_MIXER_RECLEV : SOUND_MIXER_VOLUME;
1283
1284 switch (mix->ctrl[c].ctrl.dwControlType)
1285 {
1286 case MIXERCONTROL_CONTROLTYPE_VOLUME:
1287 {
1288 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
1289
1290 if (lpmcd->cbDetails !=
1291 sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
1292 WARN("invalid parameter: cbDetails = %d\n",
1293 lpmcd->cbDetails);
1294 return MMSYSERR_INVALPARAM;
1295 }
1296
1297 TRACE("%s MIXERCONTROLDETAILS_UNSIGNED[%u]\n",
1298 getControlType(mix->ctrl[c].ctrl.dwControlType),
1299 lpmcd->cChannels);
1300
1301 mcdu = lpmcd->paDetails;
1302 /* val should contain 00RL */
1303 switch (lpmcd->cChannels)
1304 {
1305 case 1:
1306 /* mono... so R = L */
1307 TRACE("Setting RL to %d\n", mcdu->dwValue);
1308 val = 0x101 * ((mcdu->dwValue * 100) >> 16);
1309 break;
1310 case 2:
1311 /* stereo, left is paDetails[0] */
1312 TRACE("Setting L to %d\n", mcdu->dwValue);
1313 val = ((mcdu->dwValue * 100.0) / 65536.0) + 0.5;
1314 mcdu++;
1315 TRACE("Setting R to %d\n", mcdu->dwValue);
1316 val += (int)(((mcdu->dwValue * 100) / 65536.0) + 0.5) << 8;
1317 break;
1318 default:
1319 WARN("Unsupported cChannels (%d)\n", lpmcd->cChannels);
1320 return MMSYSERR_INVALPARAM;
1321 }
1322
1323 if (mix->volume[chnl] == -1)
1324 {
1325 if (!MIX_SetVal(mix, chnl, val)) {
1326 WARN("invalid parameter\n");
1327 return MMSYSERR_INVALPARAM;
1328 }
1329 }
1330 else
1331 {
1332 mix->volume[chnl] = val;
1333 }
1334 }
1335 ret = MMSYSERR_NOERROR;
1336 break;
1337 case MIXERCONTROL_CONTROLTYPE_MUTE:
1338 case MIXERCONTROL_CONTROLTYPE_ONOFF:
1339 {
1340 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
1341
1342 if (lpmcd->cbDetails !=
1343 sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
1344 WARN("invalid parameter: cbDetails = %d\n",
1345 lpmcd->cbDetails);
1346 return MMSYSERR_INVALPARAM;
1347 }
1348
1349 TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n",
1350 getControlType(mix->ctrl[c].ctrl.dwControlType),
1351 lpmcd->cChannels);
1352
1353 mcdb = lpmcd->paDetails;
1354 if (mcdb->fValue)
1355 {
1356 /* save the volume and then set it to 0 */
1357 if (!MIX_GetVal(mix, chnl, &mix->volume[chnl]) ||
1358 !MIX_SetVal(mix, chnl, 0)) {
1359 WARN("invalid parameter\n");
1360 return MMSYSERR_INVALPARAM;
1361 }
1362 }
1363 else
1364 {
1365 if (mix->volume[chnl] == -1)
1366 {
1367 ret = MMSYSERR_NOERROR;
1368 break;
1369 }
1370 if (!MIX_SetVal(mix, chnl, mix->volume[chnl])) {
1371 WARN("invalid parameter\n");
1372 return MMSYSERR_INVALPARAM;
1373 }
1374 mix->volume[chnl] = -1;
1375 }
1376 }
1377 ret = MMSYSERR_NOERROR;
1378 break;
1379 case MIXERCONTROL_CONTROLTYPE_MIXER:
1380 case MIXERCONTROL_CONTROLTYPE_MUX:
1381 {
1382 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
1383 unsigned mask;
1384 int i, j;
1385
1386 if (lpmcd->cbDetails !=
1387 sizeof(MIXERCONTROLDETAILS_BOOLEAN)) {
1388 WARN("invalid parameter: cbDetails = %d\n",
1389 lpmcd->cbDetails);
1390 return MMSYSERR_INVALPARAM;
1391 }
1392
1393 TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n",
1394 getControlType(mix->ctrl[c].ctrl.dwControlType),
1395 lpmcd->cChannels);
1396
1397 /* we mute both channels at the same time */
1398 mcdb = lpmcd->paDetails;
1399 mask = 0;
1400 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
1401 {
1402 if (WINE_CHN_SUPPORTS(mix->recMask, j) &&
1403 mcdb[i++].fValue)
1404 {
1405 /* a mux can only select one line at a time... */
1406 if (mix->singleRecChannel && mask != 0)
1407 {
1408 FIXME("!!!\n");
1409 return MMSYSERR_INVALPARAM;
1410 }
1411 mask |= WINE_CHN_MASK(j);
1412 }
1413 }
1414 if (i != lpmcd->u.cMultipleItems)
1415 FIXME("bad count\n");
1416 TRACE("writing %04x as rec src\n", mask);
1417 if (!MIX_SetRecSrc(mix, mask))
1418 ERR("Can't write new mixer settings\n");
1419 else
1420 ret = MMSYSERR_NOERROR;
1421 }
1422 break;
1423 }
1424 }
1425 break;
1426 default:
1427 WARN("Unknown SetControlDetails flag (%08lx)\n",
1428 fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
1429 }
1430 return ret;
1431 }
1432
1433 /**************************************************************************
1434 * MIX_Init [internal]
1435 */
1436 static LRESULT OSS_MixerInit(void)
1437 {
1438 int i, mixer;
1439
1440 TRACE("()\n");
1441
1442 MIX_NumMixers = 0;
1443
1444 for (i = 0; i < MAX_MIXERDRV; i++) {
1445 char name[32];
1446
1447 if (i == 0)
1448 sprintf(name, "/dev/mixer");
1449 else
1450 sprintf(name, "/dev/mixer%d", i);
1451
1452 if ((mixer = open(name, O_RDWR)) >= 0) {
1453 #ifdef SOUND_MIXER_INFO
1454 mixer_info info;
1455 if (ioctl(mixer, SOUND_MIXER_INFO, &info) >= 0) {
1456 MIX_Mixers[MIX_NumMixers].name = HeapAlloc(GetProcessHeap(),0,strlen(info.name) + 1);
1457 strcpy(MIX_Mixers[MIX_NumMixers].name, info.name);
1458 } else {
1459 /* FreeBSD up to at least 5.2 provides this ioctl, but does not
1460 * implement it properly, and there are probably similar issues
1461 * on other platforms, so we warn but try to go ahead.
1462 */
1463 WARN("%s: cannot read SOUND_MIXER_INFO!\n", name);
1464 }
1465 #endif
1466 close(mixer);
1467
1468 MIX_Mixers[MIX_NumMixers].dev_name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
1469 strcpy(MIX_Mixers[MIX_NumMixers].dev_name, name);
1470 MIX_NumMixers++;
1471 MIX_Open(MIX_NumMixers - 1, NULL, 0); /* FIXME */
1472 } else {
1473 WARN("couldn't open %s\n", name);
1474 }
1475 }
1476
1477 if (MIX_NumMixers == 0) {
1478 WARN("no driver\n");
1479 return MMSYSERR_NODRIVER;
1480 }
1481
1482 return MMSYSERR_NOERROR;
1483 }
1484
1485 /**************************************************************************
1486 * MIX_Exit [internal]
1487 */
1488 static LRESULT OSS_MixerExit(void)
1489 {
1490 int i;
1491
1492 TRACE("()\n");
1493
1494 for (i = 0; i < MIX_NumMixers; i++) {
1495 HeapFree(GetProcessHeap(),0,MIX_Mixers[i].name);
1496 HeapFree(GetProcessHeap(),0,MIX_Mixers[i].dev_name);
1497 }
1498
1499 return MMSYSERR_NOERROR;
1500 }
1501
1502 /**************************************************************************
1503 * MIX_GetNumDevs [internal]
1504 */
1505 static DWORD MIX_GetNumDevs(void)
1506 {
1507 TRACE("()\n");
1508
1509 return MIX_NumMixers;
1510 }
1511
1512 #endif /* HAVE_OSS */
1513
1514 /**************************************************************************
1515 * mxdMessage (WINEOSS.3)
1516 */
1517 DWORD WINAPI OSS_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
1518 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1519 {
1520 #ifdef HAVE_OSS
1521 TRACE("(%04X, %s, %08lX, %08lX, %08lX);\n", wDevID, getMessage(wMsg),
1522 dwUser, dwParam1, dwParam2);
1523
1524 switch (wMsg)
1525 {
1526 case DRVM_INIT:
1527 return OSS_MixerInit();
1528 case DRVM_EXIT:
1529 return OSS_MixerExit();
1530 case DRVM_ENABLE:
1531 case DRVM_DISABLE:
1532 /* FIXME: Pretend this is supported */
1533 return 0;
1534 case MXDM_GETDEVCAPS:
1535 return MIX_GetDevCaps(wDevID, (LPMIXERCAPSW)dwParam1, dwParam2);
1536 case MXDM_GETLINEINFO:
1537 return MIX_GetLineInfo(wDevID, (LPMIXERLINEW)dwParam1, dwParam2);
1538 case MXDM_GETNUMDEVS:
1539 return MIX_GetNumDevs();
1540 case MXDM_OPEN:
1541 return MMSYSERR_NOERROR;
1542 /* MIX_Open(wDevID, (LPMIXEROPENDESC)dwParam1, dwParam2); */
1543 case MXDM_CLOSE:
1544 return MMSYSERR_NOERROR;
1545 case MXDM_GETLINECONTROLS:
1546 return MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSW)dwParam1, dwParam2);
1547 case MXDM_GETCONTROLDETAILS:
1548 return MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
1549 case MXDM_SETCONTROLDETAILS:
1550 return MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
1551 default:
1552 WARN("unknown message %d!\n", wMsg);
1553 return MMSYSERR_NOTSUPPORTED;
1554 }
1555 #else
1556 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n", wDevID, wMsg,
1557 dwUser, dwParam1, dwParam2);
1558
1559 return MMSYSERR_NOTENABLED;
1560 #endif
1561 }
Windows API implementation