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