?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20030408.
[wine/gsoc-2012-control.git] / dlls / winmm / wineoss / mixer.c
blob685e8a6f47321168a1fda5ce97fa792a0043b354
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 <stdio.h>
28 #include <string.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <fcntl.h>
33 #include <errno.h>
34 #include <assert.h>
35 #ifdef HAVE_SYS_IOCTL_H
36 # include <sys/ioctl.h>
37 #endif
38
39 #define NONAMELESSUNION
40 #define NONAMELESSSTRUCT
41 #include "windef.h"
42 #include "mmddk.h"
43 #include "oss.h"
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(mmaux);
47
48 #ifdef HAVE_OSS
49
50 #define WINE_MIXER_MANUF_ID 0xAA
51 #define WINE_MIXER_PRODUCT_ID 0x55
52 #define WINE_MIXER_VERSION 0x0100
53 #define WINE_MIXER_NAME "WINE OSS Mixer"
54
55 #define WINE_CHN_MASK(_x) (1L << (_x))
56 #define WINE_CHN_SUPPORTS(_c, _x) ((_c) & WINE_CHN_MASK(_x))
57 /* Bass and Treble are no longer in the mask as Windows does not handle them */
58 #define WINE_MIXER_MASK_SPEAKER (WINE_CHN_MASK(SOUND_MIXER_SYNTH) | \
59 WINE_CHN_MASK(SOUND_MIXER_PCM) | \
60 WINE_CHN_MASK(SOUND_MIXER_LINE) | \
61 WINE_CHN_MASK(SOUND_MIXER_MIC) | \
62 WINE_CHN_MASK(SOUND_MIXER_CD) )
63
64 #define WINE_MIXER_MASK_RECORD (WINE_CHN_MASK(SOUND_MIXER_SYNTH) | \
65 WINE_CHN_MASK(SOUND_MIXER_LINE) | \
66 WINE_CHN_MASK(SOUND_MIXER_MIC) | \
67 WINE_CHN_MASK(SOUND_MIXER_IMIX) )
68
69 /* FIXME: the two following string arrays should be moved to a resource file in a string table */
70 /* if it's done, better use a struct to hold labels, name, and muted channel volume cache */
71 static char* MIX_Labels[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_LABELS;
72 static char* MIX_Names [SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
73
74 struct mixerCtrl
75 {
76 DWORD dwLineID;
77 MIXERCONTROLA ctrl;
78 };
79
80 struct mixer
81 {
82 const char* name;
83 int volume[SOUND_MIXER_NRDEVICES];
84 int devMask;
85 int stereoMask;
86 int recMask;
87 BOOL singleRecChannel;
88 struct mixerCtrl* ctrl;
89 int numCtrl;
90 };
91
92 #define LINEID_DST 0xFFFF
93 #define LINEID_SPEAKER 0x0000
94 #define LINEID_RECORD 0x0001
95
96 static int MIX_NumMixers;
97 static struct mixer MIX_Mixers[1];
98
99 /**************************************************************************
100 * MIX_FillLineControls [internal]
101 */
102 static void MIX_FillLineControls(struct mixer* mix, int c, DWORD lineID, DWORD dwType)
103 {
104 struct mixerCtrl* mc = &mix->ctrl[c];
105 int j;
106
107 mc->dwLineID = lineID;
108 mc->ctrl.cbStruct = sizeof(MIXERCONTROLA);
109 mc->ctrl.dwControlID = c + 1;
110 mc->ctrl.dwControlType = dwType;
111
112 switch (dwType)
113 {
114 case MIXERCONTROL_CONTROLTYPE_VOLUME:
115 mc->ctrl.fdwControl = 0;
116 mc->ctrl.cMultipleItems = 0;
117 lstrcpynA(mc->ctrl.szShortName, "Vol", MIXER_SHORT_NAME_CHARS);
118 lstrcpynA(mc->ctrl.szName, "Volume", MIXER_LONG_NAME_CHARS);
119 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
120 /* CONTROLTYPE_VOLUME uses the MIXER_CONTROLDETAILS_UNSIGNED struct,
121 * [0, 100] is the range supported by OSS
122 * whatever the min and max values are they must match
123 * conversions done in (Get|Set)ControlDetails to stay in [0, 100] range
124 */
125 mc->ctrl.Bounds.s1.dwMinimum = 0;
126 mc->ctrl.Bounds.s1.dwMaximum = 65535;
127 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
128 break;
129 case MIXERCONTROL_CONTROLTYPE_MUTE:
130 case MIXERCONTROL_CONTROLTYPE_ONOFF:
131 mc->ctrl.fdwControl = 0;
132 mc->ctrl.cMultipleItems = 0;
133 lstrcpynA(mc->ctrl.szShortName, "Mute", MIXER_SHORT_NAME_CHARS);
134 lstrcpynA(mc->ctrl.szName, "Mute", MIXER_LONG_NAME_CHARS);
135 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
136 mc->ctrl.Bounds.s1.dwMinimum = 0;
137 mc->ctrl.Bounds.s1.dwMaximum = 1;
138 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
139 break;
140 case MIXERCONTROL_CONTROLTYPE_MUX:
141 case MIXERCONTROL_CONTROLTYPE_MIXER:
142 mc->ctrl.fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE;
143 mc->ctrl.cMultipleItems = 0;
144 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
145 if (WINE_CHN_SUPPORTS(mix->recMask, j))
146 mc->ctrl.cMultipleItems++;
147 lstrcpynA(mc->ctrl.szShortName, "Mixer", MIXER_SHORT_NAME_CHARS);
148 lstrcpynA(mc->ctrl.szName, "Mixer", MIXER_LONG_NAME_CHARS);
149 memset(&mc->ctrl.Bounds, 0, sizeof(mc->ctrl.Bounds));
150 memset(&mc->ctrl.Metrics, 0, sizeof(mc->ctrl.Metrics));
151 break;
152
153 default:
154 FIXME("Internal error: unknown type: %08lx\n", dwType);
155 }
156 TRACE("ctrl[%2d]: typ=%08lx lin=%08lx\n", c + 1, dwType, lineID);
157 }
158
159 /******************************************************************
160 * MIX_GetMixer
161 *
162 *
163 */
164 static struct mixer* MIX_Get(WORD wDevID)
165 {
166 if (wDevID >= MIX_NumMixers || MIX_Mixers[wDevID].name == NULL) return NULL;
167 return &MIX_Mixers[wDevID];
168 }
169
170 /**************************************************************************
171 * MIX_Open [internal]
172 */
173 static DWORD MIX_Open(WORD wDevID, LPMIXEROPENDESC lpMod, DWORD flags)
174 {
175 int mixer, i, j;
176 unsigned caps;
177 struct mixer* mix;
178 DWORD ret = MMSYSERR_NOERROR;
179
180 TRACE("(%04X, %p, %lu);\n", wDevID, lpMod, flags);
181
182 /* as we partly init the mixer with MIX_Open, we can allow null open decs */
183 /* EPP if (lpMod == NULL) return MMSYSERR_INVALPARAM; */
184 /* anyway, it seems that WINMM/MMSYSTEM doesn't always open the mixer device before sending
185 * messages to it... it seems to be linked to all the equivalent of mixer identification
186 * (with a reference to a wave, midi.. handle
187 */
188 if (!(mix = MIX_Get(wDevID))) return MMSYSERR_BADDEVICEID;
189
190 if ((mixer = open(mix->name, O_RDWR)) < 0)
191 {
192 if (errno == ENODEV || errno == ENXIO)
193 {
194 /* no driver present */
195 return MMSYSERR_NODRIVER;
196 }
197 return MMSYSERR_ERROR;
198 }
199
200 if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &mix->devMask) == -1)
201 {
202 perror("ioctl mixer SOUND_MIXER_DEVMASK");
203 ret = MMSYSERR_ERROR;
204 goto error;
205 }
206 mix->devMask &= WINE_MIXER_MASK_SPEAKER;
207 if (mix->devMask == 0)
208 {
209 ret = MMSYSERR_NODRIVER;
210 goto error;
211 }
212
213 if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &mix->stereoMask) == -1)
214 {
215 perror("ioctl mixer SOUND_MIXER_STEREODEVS");
216 ret = MMSYSERR_ERROR;
217 goto error;
218 }
219 mix->stereoMask &= WINE_MIXER_MASK_SPEAKER;
220
221 if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &mix->recMask) == -1)
222 {
223 perror("ioctl mixer SOUND_MIXER_RECMASK");
224 ret = MMSYSERR_ERROR;
225 goto error;
226 }
227 mix->recMask &= WINE_MIXER_MASK_RECORD;
228 /* FIXME: we may need to support both rec lev & igain */
229 if (!WINE_CHN_SUPPORTS(mix->recMask, SOUND_MIXER_RECLEV))
230 {
231 WARN("The sound card doesn't support rec level\n");
232 if (WINE_CHN_SUPPORTS(mix->recMask, SOUND_MIXER_IGAIN))
233 WARN("but it does support IGain, please report\n");
234 }
235 if (ioctl(mixer, SOUND_MIXER_READ_CAPS, &caps) == -1)
236 {
237 perror("ioctl mixer SOUND_MIXER_READ_CAPS");
238 ret = MMSYSERR_ERROR;
239 goto error;
240 }
241 mix->singleRecChannel = caps & SOUND_CAP_EXCL_INPUT;
242 TRACE("dev=%04x rec=%04x stereo=%04x %s\n",
243 mix->devMask, mix->recMask, mix->stereoMask,
244 mix->singleRecChannel ? "single" : "multiple");
245 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
246 {
247 mix->volume[i] = -1;
248 }
249 mix->numCtrl = 4; /* dst lines... vol&mute on speakers, vol&onoff on rec */
250 /* FIXME: do we always have RECLEV on all cards ??? */
251 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
252 {
253 if (WINE_CHN_SUPPORTS(mix->devMask, i))
254 mix->numCtrl += 2; /* volume & mute */
255 if (WINE_CHN_SUPPORTS(mix->recMask, i))
256 mix->numCtrl += 2; /* volume & onoff */
257
258 }
259 if (!(mix->ctrl = HeapAlloc(GetProcessHeap(), 0, sizeof(mix->ctrl[0]) * mix->numCtrl)))
260 {
261 ret = MMSYSERR_NOMEM;
262 goto error;
263 }
264
265 j = 0;
266 MIX_FillLineControls(mix, j++, MAKELONG(0, LINEID_DST), MIXERCONTROL_CONTROLTYPE_VOLUME);
267 MIX_FillLineControls(mix, j++, MAKELONG(0, LINEID_DST), MIXERCONTROL_CONTROLTYPE_MUTE);
268 MIX_FillLineControls(mix, j++, MAKELONG(1, LINEID_DST),
269 mix->singleRecChannel ?
270 MIXERCONTROL_CONTROLTYPE_MUX : MIXERCONTROL_CONTROLTYPE_MIXER);
271 MIX_FillLineControls(mix, j++, MAKELONG(1, LINEID_DST), MIXERCONTROL_CONTROLTYPE_MUTE/*EPP*/);
272 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
273 {
274 if (WINE_CHN_SUPPORTS(mix->devMask, i))
275 {
276 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_SPEAKER, i),
277 MIXERCONTROL_CONTROLTYPE_VOLUME);
278 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_SPEAKER, i),
279 MIXERCONTROL_CONTROLTYPE_MUTE);
280 }
281 }
282 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
283 {
284 if (WINE_CHN_SUPPORTS(mix->recMask, i))
285 {
286 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_RECORD, i),
287 MIXERCONTROL_CONTROLTYPE_VOLUME);
288 MIX_FillLineControls(mix, j++, MAKELONG(LINEID_RECORD, i),
289 MIXERCONTROL_CONTROLTYPE_MUTE/*EPP*/);
290 }
291 }
292 assert(j == mix->numCtrl);
293 error:
294 close(mixer);
295 return ret;
296 }
297
298 /**************************************************************************
299 * MIX_GetVal [internal]
300 */
301 static BOOL MIX_GetVal(struct mixer* mix, int chn, int* val)
302 {
303 int mixer;
304 BOOL ret = FALSE;
305
306 if ((mixer = open(mix->name, O_RDWR)) < 0)
307 {
308 /* FIXME: ENXIO => no mixer installed */
309 WARN("mixer device not available !\n");
310 }
311 else
312 {
313 if (ioctl(mixer, MIXER_READ(chn), val) >= 0)
314 {
315 TRACE("Reading volume %x on %d\n", *val, chn);
316 ret = TRUE;
317 }
318 close(mixer);
319 }
320 return ret;
321 }
322
323 /**************************************************************************
324 * MIX_SetVal [internal]
325 */
326 static BOOL MIX_SetVal(struct mixer* mix, int chn, int val)
327 {
328 int mixer;
329 BOOL ret = FALSE;
330
331 TRACE("Writing volume %x on %d\n", val, chn);
332
333 if ((mixer = open(mix->name, O_RDWR)) < 0)
334 {
335 /* FIXME: ENXIO => no mixer installed */
336 WARN("mixer device not available !\n");
337 }
338 else
339 {
340 if (ioctl(mixer, MIXER_WRITE(chn), &val) >= 0)
341 {
342 ret = TRUE;
343 }
344 close(mixer);
345 }
346 return ret;
347 }
348
349 /******************************************************************
350 * MIX_GetRecSrc
351 *
352 *
353 */
354 static BOOL MIX_GetRecSrc(struct mixer* mix, unsigned* mask)
355 {
356 int mixer;
357 BOOL ret = FALSE;
358
359 if ((mixer = open(mix->name, O_RDWR)) >= 0)
360 {
361 if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &mask) >= 0) ret = TRUE;
362 close(mixer);
363 }
364 return ret;
365 }
366
367 /******************************************************************
368 * MIX_SetRecSrc
369 *
370 *
371 */
372 static BOOL MIX_SetRecSrc(struct mixer* mix, unsigned mask)
373 {
374 int mixer;
375 BOOL ret = FALSE;
376
377 if ((mixer = open(mix->name, O_RDWR)) >= 0)
378 {
379 if (ioctl(mixer, SOUND_MIXER_WRITE_RECSRC, &mask) < 0)
380 {
381 ERR("Can't write new mixer settings\n");
382 }
383 else
384 ret = TRUE;
385 close(mixer);
386 }
387 return ret;
388 }
389
390 /**************************************************************************
391 * MIX_GetDevCaps [internal]
392 */
393 static DWORD MIX_GetDevCaps(WORD wDevID, LPMIXERCAPSA lpCaps, DWORD dwSize)
394 {
395 struct mixer* mix;
396
397 TRACE("(%04X, %p, %lu);\n", wDevID, lpCaps, dwSize);
398
399 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
400 if (!(mix = MIX_Get(wDevID))) return MMSYSERR_BADDEVICEID;
401
402 lpCaps->wMid = WINE_MIXER_MANUF_ID;
403 lpCaps->wPid = WINE_MIXER_PRODUCT_ID;
404 lpCaps->vDriverVersion = WINE_MIXER_VERSION;
405 strcpy(lpCaps->szPname, WINE_MIXER_NAME);
406
407 lpCaps->cDestinations = 2; /* speakers & record */
408 lpCaps->fdwSupport = 0; /* No bits defined yet */
409
410 return MMSYSERR_NOERROR;
411 }
412
413 /**************************************************************************
414 * MIX_GetLineInfoDst [internal]
415 */
416 static DWORD MIX_GetLineInfoDst(struct mixer* mix, LPMIXERLINEA lpMl, DWORD dst)
417 {
418 unsigned mask;
419 int j;
420
421 lpMl->dwDestination = dst;
422 switch (dst)
423 {
424 case 0:
425 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
426 mask = mix->devMask;
427 j = SOUND_MIXER_VOLUME;
428 break;
429 case 1:
430 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
431 mask = mix->recMask;
432 j = SOUND_MIXER_RECLEV;
433 break;
434 default:
435 FIXME("shouldn't happen\n");
436 return MMSYSERR_ERROR;
437 }
438 lpMl->dwSource = 0xFFFFFFFF;
439 lstrcpynA(lpMl->szShortName, MIX_Labels[j], MIXER_SHORT_NAME_CHARS);
440 lstrcpynA(lpMl->szName, MIX_Names[j], MIXER_LONG_NAME_CHARS);
441
442 /* we have all connections found in the MIX_DevMask */
443 lpMl->cConnections = 0;
444 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
445 if (WINE_CHN_SUPPORTS(mask, j))
446 lpMl->cConnections++;
447 lpMl->cChannels = 1;
448 if (WINE_CHN_SUPPORTS(mix->stereoMask, lpMl->dwLineID))
449 lpMl->cChannels++;
450 lpMl->dwLineID = MAKELONG(dst, LINEID_DST);
451 lpMl->cControls = 0;
452 for (j = 0; j < mix->numCtrl; j++)
453 if (mix->ctrl[j].dwLineID == lpMl->dwLineID)
454 lpMl->cControls++;
455
456 return MMSYSERR_NOERROR;
457 }
458
459 /**************************************************************************
460 * MIX_GetLineInfoSrc [internal]
461 */
462 static DWORD MIX_GetLineInfoSrc(struct mixer* mix, LPMIXERLINEA lpMl, DWORD idx, DWORD dst)
463 {
464 int i, j;
465 unsigned mask = (dst) ? mix->recMask : mix->devMask;
466
467 strcpy(lpMl->szShortName, MIX_Labels[idx]);
468 strcpy(lpMl->szName, MIX_Names[idx]);
469 lpMl->dwLineID = MAKELONG(dst, idx);
470 lpMl->dwDestination = dst;
471 lpMl->cConnections = 1;
472 lpMl->cControls = 0;
473 for (i = 0; i < mix->numCtrl; i++)
474 if (mix->ctrl[i].dwLineID == lpMl->dwLineID)
475 lpMl->cControls++;
476
477 switch (idx)
478 {
479 case SOUND_MIXER_SYNTH:
480 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
481 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
482 break;
483 case SOUND_MIXER_CD:
484 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
485 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
486 break;
487 case SOUND_MIXER_LINE:
488 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
489 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
490 break;
491 case SOUND_MIXER_MIC:
492 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
493 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
494 break;
495 case SOUND_MIXER_PCM:
496 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
497 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
498 break;
499 case SOUND_MIXER_IMIX:
500 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
501 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
502 break;
503 default:
504 WARN("Index %ld not handled.\n", idx);
505 return MIXERR_INVALLINE;
506 }
507 lpMl->cChannels = 1;
508 if (dst == 0 && WINE_CHN_SUPPORTS(mix->stereoMask, idx))
509 lpMl->cChannels++;
510 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
511 {
512 if (WINE_CHN_SUPPORTS(mask, j))
513 {
514 if (j == idx) break;
515 i++;
516 }
517 }
518 lpMl->dwSource = i;
519 return MMSYSERR_NOERROR;
520 }
521
522 /******************************************************************
523 * MIX_CheckLine
524 */
525 static BOOL MIX_CheckLine(DWORD lineID)
526 {
527 return ((HIWORD(lineID) < SOUND_MIXER_NRDEVICES && LOWORD(lineID) < 2) ||
528 (HIWORD(lineID) == LINEID_DST && LOWORD(lineID) < SOUND_MIXER_NRDEVICES));
529 }
530
531 /**************************************************************************
532 * MIX_GetLineInfo [internal]
533 */
534 static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEA lpMl, DWORD fdwInfo)
535 {
536 int i, j;
537 DWORD ret = MMSYSERR_NOERROR;
538 unsigned mask;
539 struct mixer* mix;
540
541 TRACE("(%04X, %p, %lu);\n", wDevID, lpMl, fdwInfo);
542
543 if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl))
544 return MMSYSERR_INVALPARAM;
545 if ((mix = MIX_Get(wDevID)) == NULL) return MMSYSERR_BADDEVICEID;
546
547 /* FIXME: set all the variables correctly... the lines below
548 * are very wrong...
549 */
550 lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
551 lpMl->dwUser = 0;
552
553 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
554 {
555 case MIXER_GETLINEINFOF_DESTINATION:
556 TRACE("DESTINATION (%08lx)\n", lpMl->dwDestination);
557 if (lpMl->dwDestination >= 2)
558 return MMSYSERR_INVALPARAM;
559 if ((ret = MIX_GetLineInfoDst(mix, lpMl, lpMl->dwDestination)) != MMSYSERR_NOERROR)
560 return ret;
561 break;
562 case MIXER_GETLINEINFOF_SOURCE:
563 TRACE("SOURCE (%08lx), dst=%08lx\n", lpMl->dwSource, lpMl->dwDestination);
564 switch (lpMl->dwDestination)
565 {
566 case 0: mask = mix->devMask; break;
567 case 1: mask = mix->recMask; break;
568 default: return MMSYSERR_INVALPARAM;
569 }
570 i = lpMl->dwSource;
571 for (j = 0; j < SOUND_MIXER_NRDEVICES; j++)
572 {
573 if (WINE_CHN_SUPPORTS(mask, j) && (i-- == 0))
574 break;
575 }
576 if (j >= SOUND_MIXER_NRDEVICES)
577 return MIXERR_INVALLINE;
578 if ((ret = MIX_GetLineInfoSrc(mix, lpMl, j, lpMl->dwDestination)) != MMSYSERR_NOERROR)
579 return ret;
580 break;
581 case MIXER_GETLINEINFOF_LINEID:
582 TRACE("LINEID (%08lx)\n", lpMl->dwLineID);
583
584 if (!MIX_CheckLine(lpMl->dwLineID))
585 return MIXERR_INVALLINE;
586 if (HIWORD(lpMl->dwLineID) == LINEID_DST)
587 ret = MIX_GetLineInfoDst(mix, lpMl, LOWORD(lpMl->dwLineID));
588 else
589 ret = MIX_GetLineInfoSrc(mix, lpMl, HIWORD(lpMl->dwLineID), LOWORD(lpMl->dwLineID));
590 if (ret != MMSYSERR_NOERROR)
591 return ret;
592 break;
593 case MIXER_GETLINEINFOF_COMPONENTTYPE:
594 TRACE("COMPONENT TYPE (%08lx)\n", lpMl->dwComponentType);
595 switch (lpMl->dwComponentType)
596 {
597 case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
598 ret = MIX_GetLineInfoDst(mix, lpMl, 0);
599 break;
600 case MIXERLINE_COMPONENTTYPE_DST_WAVEIN:
601 ret = MIX_GetLineInfoDst(mix, lpMl, 1);
602 break;
603 case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER:
604 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_SYNTH, 0);
605 break;
606 case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC:
607 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_CD, 0);
608 break;
609 case MIXERLINE_COMPONENTTYPE_SRC_LINE:
610 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_LINE, 0);
611 break;
612 case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE:
613 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_MIC, 1);
614 break;
615 case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
616 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_PCM, 0);
617 break;
618 case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED:
619 ret = MIX_GetLineInfoSrc(mix, lpMl, SOUND_MIXER_IMIX, 1);
620 break;
621 default:
622 FIXME("Unhandled component type (%08lx)\n", lpMl->dwComponentType);
623 return MMSYSERR_INVALPARAM;
624 }
625 break;
626 case MIXER_GETLINEINFOF_TARGETTYPE:
627 FIXME("_TARGETTYPE not implemented yet.\n");
628 break;
629 default:
630 WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
631 break;
632 }
633
634 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_AUX; /* FIXME */
635 lpMl->Target.dwDeviceID = 0xFFFFFFFF;
636 lpMl->Target.wMid = WINE_MIXER_MANUF_ID;
637 lpMl->Target.wPid = WINE_MIXER_PRODUCT_ID;
638 lpMl->Target.vDriverVersion = WINE_MIXER_VERSION;
639 strcpy(lpMl->Target.szPname, WINE_MIXER_NAME);
640
641 return ret;
642 }
643
644 /******************************************************************
645 * MIX_CheckControl
646 *
647 */
648 static BOOL MIX_CheckControl(struct mixer* mix, DWORD ctrlID)
649 {
650 return (ctrlID >= 1 && ctrlID <= mix->numCtrl);
651 }
652
653 /**************************************************************************
654 * MIX_GetLineControls [internal]
655 */
656 static DWORD MIX_GetLineControls(WORD wDevID, LPMIXERLINECONTROLSA lpMlc, DWORD flags)
657 {
658 DWORD dwRet = MMSYSERR_NOERROR;
659 struct mixer* mix;
660
661 TRACE("(%04X, %p, %lu);\n", wDevID, lpMlc, flags);
662
663 if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
664 if (lpMlc->cbStruct < sizeof(*lpMlc) ||
665 lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
666 return MMSYSERR_INVALPARAM;
667 if ((mix = MIX_Get(wDevID)) == NULL) return MMSYSERR_BADDEVICEID;
668
669 switch (flags & MIXER_GETLINECONTROLSF_QUERYMASK)
670 {
671 case MIXER_GETLINECONTROLSF_ALL:
672 {
673 int i, j;
674
675 TRACE("line=%08lx GLCF_ALL (%ld)\n", lpMlc->dwLineID, lpMlc->cControls);
676
677 for (i = j = 0; i < mix->numCtrl; i++)
678 {
679 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID)
680 j++;
681 }
682 if (!j || lpMlc->cControls != j) dwRet = MMSYSERR_INVALPARAM;
683 else if (!MIX_CheckLine(lpMlc->dwLineID)) dwRet = MIXERR_INVALLINE;
684 else
685 {
686 for (i = j = 0; i < mix->numCtrl; i++)
687 {
688 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID)
689 {
690 TRACE("[%d] => [%2d]: typ=%08lx\n", j, i + 1, mix->ctrl[i].ctrl.dwControlType);
691 lpMlc->pamxctrl[j++] = mix->ctrl[i].ctrl;
692 }
693 }
694 }
695 }
696 break;
697 case MIXER_GETLINECONTROLSF_ONEBYID:
698 TRACE("line=%08lx GLCF_ONEBYID (%lx)\n", lpMlc->dwLineID, lpMlc->u.dwControlID);
699
700 if (!MIX_CheckControl(mix, lpMlc->u.dwControlID) ||
701 mix->ctrl[lpMlc->u.dwControlID - 1].dwLineID != lpMlc->dwLineID)
702 dwRet = MMSYSERR_INVALPARAM;
703 else
704 lpMlc->pamxctrl[0] = mix->ctrl[lpMlc->u.dwControlID - 1].ctrl;
705 break;
706 case MIXER_GETLINECONTROLSF_ONEBYTYPE:
707 TRACE("line=%08lx GLCF_ONEBYTYPE (%lx)\n", lpMlc->dwLineID, lpMlc->u.dwControlType);
708 if (!MIX_CheckLine(lpMlc->dwLineID)) dwRet = MIXERR_INVALLINE;
709 else
710 {
711 int i;
712 DWORD ct = lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK;
713
714 for (i = 0; i < mix->numCtrl; i++)
715 {
716 if (mix->ctrl[i].dwLineID == lpMlc->dwLineID &&
717 ct == (mix->ctrl[i].ctrl.dwControlType & MIXERCONTROL_CT_CLASS_MASK))
718 {
719 lpMlc->pamxctrl[0] = mix->ctrl[i].ctrl;
720 break;
721 }
722 }
723 if (i == mix->numCtrl) dwRet = MMSYSERR_INVALPARAM;
724 }
725 break;
726 default:
727 ERR("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
728 dwRet = MMSYSERR_INVALPARAM;
729 }
730
731 return dwRet;
732 }
733
734 /**************************************************************************
735 * MIX_GetControlDetails [internal]
736 */
737 static DWORD MIX_GetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
738 {
739 DWORD ret = MMSYSERR_NOTSUPPORTED;
740 DWORD c, chnl;
741 struct mixer* mix;
742
743 TRACE("(%04X, %p, %lu);\n", wDevID, lpmcd, fdwDetails);
744
745 if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
746 if ((mix = MIX_Get(wDevID)) == NULL) return MMSYSERR_BADDEVICEID;
747
748 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK)
749 {
750 case MIXER_GETCONTROLDETAILSF_VALUE:
751 TRACE("GCD VALUE (%08lx)\n", lpmcd->dwControlID);
752 if (MIX_CheckControl(mix, lpmcd->dwControlID))
753 {
754 c = lpmcd->dwControlID - 1;
755 chnl = HIWORD(mix->ctrl[c].dwLineID);
756 if (chnl == LINEID_DST)
757 chnl = LOWORD(mix->ctrl[c].dwLineID) ? SOUND_MIXER_RECLEV : SOUND_MIXER_VOLUME;
758 switch (mix->ctrl[c].ctrl.dwControlType)
759 {
760 case MIXERCONTROL_CONTROLTYPE_VOLUME:
761 {
762 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
763 int val;
764
765 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_UNSIGNED), lpmcd->cbDetails);
766 /* return value is 00RL (4 bytes)... */
767 if ((val = mix->volume[chnl]) == -1 && !MIX_GetVal(mix, chnl, &val))
768 return MMSYSERR_INVALPARAM;
769
770 switch (lpmcd->cChannels)
771 {
772 case 1:
773 /* mono... so R = L */
774 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
775 mcdu->dwValue = (LOBYTE(LOWORD(val)) * 65536L) / 100;
776 break;
777 case 2:
778 /* stereo, left is paDetails[0] */
779 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
780 mcdu->dwValue = (LOBYTE(LOWORD(val)) * 65536L) / 100;
781 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
782 mcdu->dwValue = (HIBYTE(LOWORD(val)) * 65536L) / 100;
783 break;
784 default:
785 WARN("Unknown cChannels (%ld)\n", lpmcd->cChannels);
786 return MMSYSERR_INVALPARAM;
787 }
788 TRACE("=> %08lx\n", mcdu->dwValue);
789 }
790 break;
791 case MIXERCONTROL_CONTROLTYPE_MUTE:
792 case MIXERCONTROL_CONTROLTYPE_ONOFF:
793 {
794 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
795
796 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_BOOLEAN), lpmcd->cbDetails);
797 /* we mute both channels at the same time */
798 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
799 mcdb->fValue = (mix->volume[chnl] != -1);
800 TRACE("=> %s\n", mcdb->fValue ? "on" : "off");
801 }
802 break;
803 case MIXERCONTROL_CONTROLTYPE_MIXER:
804 case MIXERCONTROL_CONTROLTYPE_MUX:
805 {
806 unsigned mask;
807
808 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_BOOLEAN), lpmcd->cbDetails);
809 if (!MIX_GetRecSrc(mix, &mask))
810 {
811 /* FIXME: ENXIO => no mixer installed */
812 WARN("mixer device not available !\n");
813 ret = MMSYSERR_ERROR;
814 }
815 else
816 {
817 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
818 int i, j;
819
820 /* we mute both channels at the same time */
821 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
822
823 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
824 {
825 if (WINE_CHN_SUPPORTS(mix->recMask, j))
826 {
827 if (i >= lpmcd->u.cMultipleItems)
828 return MMSYSERR_INVALPARAM;
829 mcdb[i++].fValue = WINE_CHN_SUPPORTS(mask, j);
830 }
831 }
832 }
833 }
834 break;
835 default:
836 WARN("Unsupported\n");
837 }
838 ret = MMSYSERR_NOERROR;
839 }
840 else
841 {
842 ret = MMSYSERR_INVALPARAM;
843 }
844 break;
845 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
846 TRACE("LIST TEXT (%08lx)\n", lpmcd->dwControlID);
847
848 ret = MMSYSERR_INVALPARAM;
849 if (MIX_CheckControl(mix, lpmcd->dwControlID))
850 {
851 int c = lpmcd->dwControlID - 1;
852
853 if (mix->ctrl[c].ctrl.dwControlType == MIXERCONTROL_CONTROLTYPE_MUX ||
854 mix->ctrl[c].ctrl.dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER)
855 {
856 LPMIXERCONTROLDETAILS_LISTTEXTA mcdlt;
857 int i, j;
858
859 mcdlt = (LPMIXERCONTROLDETAILS_LISTTEXTA)lpmcd->paDetails;
860 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
861 {
862 if (WINE_CHN_SUPPORTS(mix->recMask, j))
863 {
864 mcdlt[i].dwParam1 = MAKELONG(LINEID_RECORD, j);
865 mcdlt[i].dwParam2 = 0;
866 strcpy(mcdlt[i].szName, MIX_Names[j]);
867 i++;
868 }
869 }
870 if (i != lpmcd->u.cMultipleItems) FIXME("bad count\n");
871 ret = MMSYSERR_NOERROR;
872 }
873 }
874 break;
875 default:
876 WARN("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
877 }
878 return ret;
879 }
880
881 /**************************************************************************
882 * MIX_SetControlDetails [internal]
883 */
884 static DWORD MIX_SetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
885 {
886 DWORD ret = MMSYSERR_NOTSUPPORTED;
887 DWORD c, chnl;
888 int val;
889 struct mixer* mix;
890
891 TRACE("(%04X, %p, %lu);\n", wDevID, lpmcd, fdwDetails);
892
893 if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
894 if ((mix = MIX_Get(wDevID)) == NULL) return MMSYSERR_BADDEVICEID;
895
896 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK)
897 {
898 case MIXER_GETCONTROLDETAILSF_VALUE:
899 TRACE("GCD VALUE (%08lx)\n", lpmcd->dwControlID);
900 if (MIX_CheckControl(mix, lpmcd->dwControlID))
901 {
902 c = lpmcd->dwControlID - 1;
903 chnl = HIWORD(mix->ctrl[c].dwLineID);
904 if (chnl == LINEID_DST)
905 chnl = LOWORD(mix->ctrl[c].dwLineID) ? SOUND_MIXER_RECLEV : SOUND_MIXER_VOLUME;
906
907 switch (mix->ctrl[c].ctrl.dwControlType)
908 {
909 case MIXERCONTROL_CONTROLTYPE_VOLUME:
910 {
911 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
912
913 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_UNSIGNED), lpmcd->cbDetails);
914 /* val should contain 00RL */
915 switch (lpmcd->cChannels)
916 {
917 case 1:
918 /* mono... so R = L */
919 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
920 TRACE("Setting RL to %08ld\n", mcdu->dwValue);
921 val = 0x101 * ((mcdu->dwValue * 100) >> 16);
922 break;
923 case 2:
924 /* stereo, left is paDetails[0] */
925 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
926 TRACE("Setting L to %08ld\n", mcdu->dwValue);
927 val = ((mcdu->dwValue * 100) >> 16);
928 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
929 TRACE("Setting R to %08ld\n", mcdu->dwValue);
930 val += ((mcdu->dwValue * 100) >> 16) << 8;
931 break;
932 default:
933 WARN("Unknown cChannels (%ld)\n", lpmcd->cChannels);
934 return MMSYSERR_INVALPARAM;
935 }
936
937 if (mix->volume[chnl] == -1)
938 {
939 if (!MIX_SetVal(mix, chnl, val))
940 return MMSYSERR_INVALPARAM;
941 }
942 else
943 {
944 mix->volume[chnl] = val;
945 }
946 }
947 ret = MMSYSERR_NOERROR;
948 break;
949 case MIXERCONTROL_CONTROLTYPE_MUTE:
950 case MIXERCONTROL_CONTROLTYPE_ONOFF:
951 {
952 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
953
954 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_BOOLEAN), lpmcd->cbDetails);
955 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
956 if (mcdb->fValue)
957 {
958 if (!MIX_GetVal(mix, chnl, &mix->volume[chnl]) || !MIX_SetVal(mix, chnl, 0))
959 return MMSYSERR_INVALPARAM;
960 }
961 else
962 {
963 if (mix->volume[chnl] == -1)
964 {
965 ret = MMSYSERR_NOERROR;
966 break;
967 }
968 if (!MIX_SetVal(mix, chnl, mix->volume[chnl]))
969 return MMSYSERR_INVALPARAM;
970 mix->volume[chnl] = -1;
971 }
972 }
973 ret = MMSYSERR_NOERROR;
974 break;
975 case MIXERCONTROL_CONTROLTYPE_MIXER:
976 case MIXERCONTROL_CONTROLTYPE_MUX:
977 {
978 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
979 unsigned mask;
980 int i, j;
981
982 TRACE(" <> %u %lu\n", sizeof(MIXERCONTROLDETAILS_BOOLEAN), lpmcd->cbDetails);
983 /* we mute both channels at the same time */
984 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
985 mask = 0;
986 for (i = j = 0; j < SOUND_MIXER_NRDEVICES; j++)
987 {
988 if (WINE_CHN_SUPPORTS(mix->recMask, j) && mcdb[i++].fValue)
989 {
990 /* a mux can only select one line at a time... */
991 if (mix->singleRecChannel && mask != 0)
992 {
993 FIXME("!!!\n");
994 return MMSYSERR_INVALPARAM;
995 }
996 mask |= WINE_CHN_MASK(j);
997 }
998 }
999 if (i != lpmcd->u.cMultipleItems) FIXME("bad count\n");
1000 TRACE("writing %04x as rec src\n", mask);
1001 if (!MIX_SetRecSrc(mix, mask))
1002 ERR("Can't write new mixer settings\n");
1003 else
1004 ret = MMSYSERR_NOERROR;
1005 }
1006 break;
1007 }
1008 }
1009 break;
1010 default:
1011 WARN("Unknown SetControlDetails flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
1012 }
1013 return ret;
1014 }
1015
1016 /**************************************************************************
1017 * MIX_Init [internal]
1018 */
1019 static DWORD MIX_Init(void)
1020 {
1021 int mixer;
1022
1023 #define MIXER_DEV "/dev/mixer"
1024 if ((mixer = open(MIXER_DEV, O_RDWR)) < 0)
1025 {
1026 if (errno == ENODEV || errno == ENXIO)
1027 {
1028 /* no driver present */
1029 return MMSYSERR_NODRIVER;
1030 }
1031 MIX_NumMixers = 0;
1032 return MMSYSERR_ERROR;
1033 }
1034 close(mixer);
1035 MIX_NumMixers = 1;
1036 MIX_Mixers[0].name = MIXER_DEV;
1037 MIX_Open(0, NULL, 0); /* FIXME */
1038 #undef MIXER_DEV
1039 return MMSYSERR_NOERROR;
1040 }
1041
1042 /**************************************************************************
1043 * MIX_GetNumDevs [internal]
1044 */
1045 static DWORD MIX_GetNumDevs(void)
1046 {
1047 return MIX_NumMixers;
1048 }
1049
1050 #endif /* HAVE_OSS */
1051
1052 /**************************************************************************
1053 * mxdMessage (WINEOSS.3)
1054 */
1055 DWORD WINAPI OSS_mxdMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1056 DWORD dwParam1, DWORD dwParam2)
1057 {
1058 /* TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2); */
1059
1060 #ifdef HAVE_OSS
1061 switch (wMsg)
1062 {
1063 case DRVM_INIT:
1064 return MIX_Init();
1065 case DRVM_EXIT:
1066 case DRVM_ENABLE:
1067 case DRVM_DISABLE:
1068 /* FIXME: Pretend this is supported */
1069 return 0;
1070 case MXDM_GETDEVCAPS:
1071 return MIX_GetDevCaps(wDevID, (LPMIXERCAPSA)dwParam1, dwParam2);
1072 case MXDM_GETLINEINFO:
1073 return MIX_GetLineInfo(wDevID, (LPMIXERLINEA)dwParam1, dwParam2);
1074 case MXDM_GETNUMDEVS:
1075 return MIX_GetNumDevs();
1076 case MXDM_OPEN:
1077 return MMSYSERR_NOERROR;
1078 /* MIX_Open(wDevID, (LPMIXEROPENDESC)dwParam1, dwParam2); */
1079 case MXDM_CLOSE:
1080 return MMSYSERR_NOERROR;
1081 case MXDM_GETLINECONTROLS:
1082 return MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSA)dwParam1, dwParam2);
1083 case MXDM_GETCONTROLDETAILS:
1084 return MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
1085 case MXDM_SETCONTROLDETAILS:
1086 return MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
1087 default:
1088 WARN("unknown message %d!\n", wMsg);
1089 return MMSYSERR_NOTSUPPORTED;
1090 }
1091 #else
1092 return MMSYSERR_NOTENABLED;
1093 #endif
1094 }
GSOC 2012 project to enhance the control panel