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