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