source: trunk/src/winmm/mixer.cpp@ 21916

Last change on this file since 21916 was 21916, checked in by dmik, 14 years ago

Merge branch gcc-kmk to trunk.
File size: 75.2 KB
Line 
1/* $Id: mixer.cpp,v 1.26 2002-07-12 08:12:29 sandervl Exp $ */
2
3/*
4 * Mixer functions
5 *
6 * Copyright 2002 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * TODO: Mixer notification
9 *
10 * NOTE: Not really flexible (capabilities, > 1 audio card)
11 *
12 * Some portions borrowed from Wine (X11): (dll\winmm\mmsystem.c)
13 * (mixerGetLineControlsW/mixerGetControlDetailsW)
14 * Copyright 1993 Martin Ayotte
15 * Eric POUECH
16 *
17 * Project Odin Software License can be found in LICENSE.TXT
18 *
19 */
20
21/****************************************************************************
22 * Includes *
23 ****************************************************************************/
24
25#define NONAMELESSUNION
26#define NONAMELESSSTRUCT
27
28#include <os2win.h>
29#include <string.h>
30#include <dbglog.h>
31#include <mmsystem.h>
32#include <winnls.h>
33
34#include "waveoutdart.h"
35#include "winmm.h"
36#include "initterm.h"
37#include "mixer.h"
38#include "mixeros2.h"
39
40#define DBG_LOCALLOG DBG_mixer
41#include "dbglocal.h"
42
43static MIXERCONTROLA *mixerAddControl(DWORD dwControl, MIXLINE *pSrcLine);
44static MIXLINE *mixerAddSource(MIXLINE *pDestLine, DWORD dwSource);
45static MIXLINE *mixerAddDestination(DWORD dwDest);
46
47//array of destination mixer lines
48static MIXLINE mixerDest[MAX_MIXER_DESTINATIONS] = {0};
49//array of source mixer lines
50static MIXLINE mixerSource[MAX_MIXER_SOURCES] = {0};
51//array of all mixer lines
52static MIXLINE *pmixerLines[MAX_MIXER_LINES] = {NULL};
53//array of all mixer controls
54static MIXCONTROL mixerControls[MAX_MIXER_CONTROLS] = {0};
55
56static int nrDestinations = 0;
57static int nrSources = 0;
58static int nrControls = 0;
59static int nrLines = 0;
60
61/******************************************************************************/
62/******************************************************************************/
63MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
64{
65 DWORD lineID, controlType;
66 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
67
68 if((fdwDetails & 0xF0000000)== MIXER_OBJECTF_HMIXER) {
69 if(!pMixInfo) {
70 return MMSYSERR_INVALHANDLE;
71 }
72 }
73 else
74 if((fdwDetails & 0xF0000000) == MIXER_OBJECTF_MIXER) {
75 if(!HIWORD(hmxobj) && hmxobj > 0) {
76 return MMSYSERR_NODRIVER;
77 }
78 }
79
80 if(lpmcd == NULL || lpmcd->cbStruct != sizeof(MIXERCONTROLDETAILS)) {
81 dprintf(("ERROR: invalid pointer or structure size %d (%d)", (lpmcd) ? lpmcd->cbStruct : 0, sizeof(MIXERCONTROLDETAILS)));
82 return MMSYSERR_INVALPARAM;
83 }
84 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
85 case MIXER_GETCONTROLDETAILSF_VALUE:
86 dprintf(("MIXER_GETCONTROLDETAILSF_VALUE %d (internal id %d)", lpmcd->dwControlID, mixerControls[lpmcd->dwControlID].id));
87 if(lpmcd->dwControlID >= nrControls) {
88 dprintf(("invalid control %d", lpmcd->dwControlID));
89 return MIXERR_INVALCONTROL;
90 }
91 if(lpmcd->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
92 dprintf(("not enough room in buffer (%d)", lpmcd->cbDetails));
93 return MMSYSERR_INVALPARAM;
94 }
95 switch(mixerControls[lpmcd->dwControlID].ctrl.dwControlType) {
96 case MIXERCONTROL_CONTROLTYPE_MUX:
97 {
98 MIXERCONTROLDETAILS_BOOLEAN *pDetails = (MIXERCONTROLDETAILS_BOOLEAN *)lpmcd->paDetails;
99 DWORD dwRecSrc;
100
101 dprintf(("MIXERCONTROL_CONTROLTYPE_MUX"));
102 if(lpmcd->cChannels != 1) {//only accepts 1 in win2k
103 dprintf(("invalid number of channels %d", lpmcd->cChannels));
104 return MMSYSERR_INVALPARAM;
105 }
106 //this is also checked in win2k
107 if(lpmcd->u.cMultipleItems != mixerControls[lpmcd->dwControlID].ctrl.cMultipleItems) {
108 dprintf(("invalid cMultipleItems %d", lpmcd->u.cMultipleItems));
109 return MMSYSERR_INVALPARAM;
110 }
111
112 if(mixerControls[lpmcd->dwControlID].id != MIX_CTRL_MUX_IN_W_SRC) {
113 dprintf(("oh, oh. not wavein mux"));
114 DebugInt3();
115 return MMSYSERR_INVALPARAM;
116 }
117
118 if(OSLibMixGetRecSource(&dwRecSrc) == FALSE) {
119 dprintf(("OSLibMixGetRecSource failed!!"));
120 return MIXERR_INVALCONTROL;
121 }
122 //clear the array
123 memset(pDetails, 0, sizeof(MIXERCONTROLDETAILS_BOOLEAN)*lpmcd->u.cMultipleItems);
124 //mark recording source
125 for(int i=0;i<nrDestinations;i++) {
126 if(mixerDest[i].id == MIXER_DEST_WAVEIN) {
127 for(int j=0;j<mixerDest[i].cConnections;j++) {
128 dprintf(("wavein source %s %d (id %d)", pmixerLines[mixerDest[i].Connections[j]]->line.szName, pmixerLines[mixerDest[i].Connections[j]]->id, mixerDest[i].Connections[j]));
129 if(pmixerLines[mixerDest[i].Connections[j]]->id == dwRecSrc) {
130 pDetails[j].fValue = 1;
131 return MMSYSERR_NOERROR;
132 }
133 }
134 }
135 }
136 dprintf(("recording source %d not found!!", dwRecSrc));
137 break;
138 }
139
140 case MIXERCONTROL_CONTROLTYPE_VOLUME: //unsigned
141 {
142 MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
143 DWORD dwVolLeft, dwVolRight;
144
145 dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
146 if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwVolLeft, &dwVolRight) == FALSE) {
147 dprintf(("OSLibMixGetVolume failed!!"));
148 return MIXERR_INVALCONTROL;
149 }
150 pDetails->dwValue = dwVolLeft;
151 dprintf(("%s Left volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwVolLeft));
152 if(lpmcd->cChannels == 2) {
153 dprintf(("%s Right volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwVolRight));
154 pDetails += 1;
155 pDetails->dwValue = dwVolRight;
156 }
157 //todo > 2 channels
158 return MMSYSERR_NOERROR;
159 }
160
161 case MIXERCONTROL_CONTROLTYPE_MUTE: //assuming boolean
162 {
163 MIXERCONTROLDETAILS_BOOLEAN *pDetails = (MIXERCONTROLDETAILS_BOOLEAN *)lpmcd->paDetails;
164 BOOL fMute;
165
166 dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
167 if(OSLibMixGetMute(mixerControls[lpmcd->dwControlID].id, &fMute) == FALSE) {
168 dprintf(("OSLibMixGetVolume failed!!"));
169 return MIXERR_INVALCONTROL;
170 }
171 pDetails->fValue = fMute;
172 dprintf(("%s Left mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, fMute));
173 if(lpmcd->cChannels == 2) {
174 dprintf(("%s Right mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, fMute));
175 pDetails += 1;
176 pDetails->fValue = fMute;
177 }
178 //todo > 2 channels (usually only 1 channel is requested though)
179 return MMSYSERR_NOERROR;
180 }
181
182 case MIXERCONTROL_CONTROLTYPE_FADER:
183 {
184 MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
185 DWORD dwLevelL;
186
187 dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
188
189 if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwLevelL, NULL) == FALSE) {
190 dprintf(("OSLibMixGetVolume failed!!"));
191 return MIXERR_INVALCONTROL;
192 }
193 pDetails->dwValue = dwLevelL;
194#ifdef DEBUG
195 if(mixerControls[lpmcd->dwControlID].id == MIX_CTRL_OUT_L_3DCENTER) {
196 dprintf(("3D center %d", dwLevelL));
197 }
198 else dprintf(("3D depth %d", dwLevelL));
199#endif
200 if(lpmcd->cChannels == 2) {
201 pDetails += 1;
202 pDetails->dwValue = dwLevelL;
203 }
204 //todo > 2 channels (??)
205 return MMSYSERR_NOERROR;
206 }
207
208 case MIXERCONTROL_CONTROLTYPE_BASS:
209 case MIXERCONTROL_CONTROLTYPE_TREBLE:
210 {
211 MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
212 DWORD dwLevelL;
213
214#ifdef DEBUG
215 switch(fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
216 case MIXERCONTROL_CONTROLTYPE_TREBLE:
217 dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
218 break;
219 case MIXERCONTROL_CONTROLTYPE_BASS:
220 dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
221 break;
222 }
223#endif
224
225 if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwLevelL, NULL) == FALSE) {
226 dprintf(("OSLibMixGetVolume failed!!"));
227 return MIXERR_INVALCONTROL;
228 }
229 pDetails->dwValue = dwLevelL;
230 dprintf(("%s %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwLevelL));
231 if(lpmcd->cChannels == 2) {
232 pDetails += 1;
233 pDetails->dwValue = dwLevelL;
234 }
235 return MMSYSERR_NOERROR;
236 }
237
238#ifdef DEBUG
239 case MIXERCONTROL_CONTROLTYPE_MIXER:
240 dprintf(("MIXERCONTROL_CONTROLTYPE_MIXER"));
241 break;
242 case MIXERCONTROL_CONTROLTYPE_CUSTOM:
243 dprintf(("MIXERCONTROL_CONTROLTYPE_CUSTOM"));
244 break;
245 case MIXERCONTROL_CONTROLTYPE_BOOLEANMETER:
246 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEANMETER"));
247 break;
248 case MIXERCONTROL_CONTROLTYPE_SIGNEDMETER:
249 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNEDMETER"));
250 break;
251 case MIXERCONTROL_CONTROLTYPE_PEAKMETER:
252 dprintf(("MIXERCONTROL_CONTROLTYPE_PEAKMETER"));
253 break;
254 case MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER:
255 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER"));
256 break;
257 case MIXERCONTROL_CONTROLTYPE_BOOLEAN:
258 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEAN"));
259 break;
260 case MIXERCONTROL_CONTROLTYPE_ONOFF:
261 dprintf(("MIXERCONTROL_CONTROLTYPE_ONOFF"));
262 break;
263 case MIXERCONTROL_CONTROLTYPE_MONO:
264 dprintf(("MIXERCONTROL_CONTROLTYPE_MONO"));
265 break;
266 case MIXERCONTROL_CONTROLTYPE_LOUDNESS:
267 dprintf(("MIXERCONTROL_CONTROLTYPE_LOUDNESS"));
268 break;
269 case MIXERCONTROL_CONTROLTYPE_STEREOENH:
270 dprintf(("MIXERCONTROL_CONTROLTYPE_STEREOENH"));
271 break;
272 case MIXERCONTROL_CONTROLTYPE_BUTTON:
273 dprintf(("MIXERCONTROL_CONTROLTYPE_BUTTON"));
274 break;
275 case MIXERCONTROL_CONTROLTYPE_DECIBELS:
276 dprintf(("MIXERCONTROL_CONTROLTYPE_DECIBELS"));
277 break;
278 case MIXERCONTROL_CONTROLTYPE_SIGNED:
279 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNED"));
280 break;
281 case MIXERCONTROL_CONTROLTYPE_UNSIGNED:
282 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNED"));
283 break;
284 case MIXERCONTROL_CONTROLTYPE_PERCENT:
285 dprintf(("MIXERCONTROL_CONTROLTYPE_PERCENT"));
286 break;
287 case MIXERCONTROL_CONTROLTYPE_SLIDER:
288 dprintf(("MIXERCONTROL_CONTROLTYPE_SLIDER"));
289 break;
290 case MIXERCONTROL_CONTROLTYPE_PAN:
291 dprintf(("MIXERCONTROL_CONTROLTYPE_PAN"));
292 break;
293 case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN:
294 dprintf(("MIXERCONTROL_CONTROLTYPE_QSOUNDPAN"));
295 break;
296 case MIXERCONTROL_CONTROLTYPE_EQUALIZER:
297 dprintf(("MIXERCONTROL_CONTROLTYPE_EQUALIZER"));
298 break;
299 case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
300 dprintf(("MIXERCONTROL_CONTROLTYPE_SINGLESELECT"));
301 break;
302 case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
303 dprintf(("MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT"));
304 break;
305 case MIXERCONTROL_CONTROLTYPE_MICROTIME:
306 dprintf(("MIXERCONTROL_CONTROLTYPE_MICROTIME"));
307 break;
308 case MIXERCONTROL_CONTROLTYPE_MILLITIME:
309 dprintf(("MIXERCONTROL_CONTROLTYPE_MILLITIME"));
310 break;
311#endif
312 default:
313 DebugInt3();
314 return MIXERR_INVALCONTROL;
315 }
316 return MIXERR_INVALCONTROL;
317
318 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
319 dprintf(("MIXER_GETCONTROLDETAILSF_LISTTEXT %d", lpmcd->dwControlID));
320 if(lpmcd->dwControlID >= nrControls) {
321 dprintf(("invalid control %d", lpmcd->dwControlID));
322 return MIXERR_INVALCONTROL;
323 }
324 switch(mixerControls[lpmcd->dwControlID].ctrl.dwControlType) {
325 case MIXERCONTROL_CONTROLTYPE_MUX:
326 {
327 MIXERCONTROLDETAILS_LISTTEXTA *pDetails = (MIXERCONTROLDETAILS_LISTTEXTA *)lpmcd->paDetails;
328 if(lpmcd->cChannels != 1) {//only accepts 1 in win2k
329 dprintf(("invalid number of channels %d", lpmcd->cChannels));
330 return MMSYSERR_INVALPARAM;
331 }
332 //this is also checked in win2k
333 if(lpmcd->u.cMultipleItems != mixerControls[lpmcd->dwControlID].ctrl.cMultipleItems) {
334 dprintf(("invalid cMultipleItems %d", lpmcd->u.cMultipleItems));
335 return MMSYSERR_INVALPARAM;
336 }
337 //fails otherwise in win2k
338 if(lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS_LISTTEXTA)) {
339 dprintf(("invalid buffer size %d; should be %d", lpmcd->cbDetails, sizeof(MIXERCONTROLDETAILS_LISTTEXTA)));
340 return MMSYSERR_INVALPARAM;
341 }
342 if(mixerControls[lpmcd->dwControlID].id != MIX_CTRL_MUX_IN_W_SRC) {
343 dprintf(("oh, oh. not wavein mux"));
344 DebugInt3();
345 return MMSYSERR_INVALPARAM;
346 }
347 //clear the array
348 memset(pDetails, 0, sizeof(MIXERCONTROLDETAILS_LISTTEXTA)*lpmcd->u.cMultipleItems);
349 //set mux source details
350 for(int i=0;i<nrDestinations;i++) {
351 if(mixerDest[i].id == MIXER_DEST_WAVEIN) {
352 for(int j=0;j<mixerDest[i].cConnections;j++) {
353 dprintf(("wavein source %s %d (%s)", pmixerLines[mixerDest[i].Connections[j]]->line.szName, pmixerLines[mixerDest[i].Connections[j]]->id, pmixerLines[mixerDest[i].Connections[j]]->line.szName));
354 pDetails->dwParam1 = pmixerLines[mixerDest[i].Connections[j]]->line.dwLineID;
355 pDetails->dwParam2 = 0;
356 strncpy(pDetails->szName, pmixerLines[mixerDest[i].Connections[j]]->line.szName, sizeof(pDetails->szName));
357 pDetails++;
358 }
359 return MMSYSERR_NOERROR;
360 }
361 }
362 DebugInt3();
363 return MMSYSERR_INVALPARAM;
364 }
365 case MIXERCONTROL_CONTROLTYPE_EQUALIZER:
366 case MIXERCONTROL_CONTROLTYPE_MIXER:
367 case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
368 case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
369 dprintf(("Only implemented for mux controls"));
370 return MIXERR_INVALCONTROL;
371
372 default:
373 dprintf(("Only implemented for multiple item controls"));
374 return MIXERR_INVALCONTROL;
375 }
376
377 default:
378 dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
379 break;
380 }
381 return MMSYSERR_NOERROR;
382}
383/******************************************************************************/
384/******************************************************************************/
385MMRESULT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
386{
387 DWORD ret = MMSYSERR_NOTENABLED;
388
389 if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
390 return MMSYSERR_INVALPARAM;
391
392 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
393 case MIXER_GETCONTROLDETAILSF_VALUE:
394 /* can safely use W structure as it is, no string inside */
395 ret = mixerGetControlDetailsA(hmxobj, lpmcd, fdwDetails);
396 break;
397
398 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
399 {
400 MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW = (MIXERCONTROLDETAILS_LISTTEXTW *)lpmcd->paDetails;
401 MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA;
402 int size = max(1, lpmcd->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
403 int i;
404
405 if (lpmcd->u.cMultipleItems != 0) {
406 size *= lpmcd->u.cMultipleItems;
407 }
408 pDetailsA = (MIXERCONTROLDETAILS_LISTTEXTA *)HeapAlloc(GetProcessHeap(), 0, size);
409 lpmcd->paDetails = pDetailsA;
410 lpmcd->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
411 /* set up lpmcd->paDetails */
412 ret = mixerGetControlDetailsA(hmxobj, lpmcd, fdwDetails);
413 /* copy from lpmcd->paDetails back to paDetailsW; */
414 if(ret == MMSYSERR_NOERROR) {
415 for(i=0;i<lpmcd->u.cMultipleItems*lpmcd->cChannels;i++) {
416 pDetailsW->dwParam1 = pDetailsA->dwParam1;
417 pDetailsW->dwParam2 = pDetailsA->dwParam2;
418 MultiByteToWideChar( CP_ACP, 0, pDetailsA->szName, -1,
419 pDetailsW->szName,
420 sizeof(pDetailsW->szName)/sizeof(WCHAR) );
421 pDetailsA++;
422 pDetailsW++;
423 }
424 pDetailsA -= lpmcd->u.cMultipleItems*lpmcd->cChannels;
425 pDetailsW -= lpmcd->u.cMultipleItems*lpmcd->cChannels;
426 }
427 HeapFree(GetProcessHeap(), 0, pDetailsA);
428 lpmcd->paDetails = pDetailsW;
429 lpmcd->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
430 break;
431 }
432 default:
433 dprintf(("Unsupported fdwDetails=0x%08lx\n", fdwDetails));
434 break;
435 }
436
437 return ret;
438}
439/******************************************************************************/
440/******************************************************************************/
441MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
442{
443 DWORD ret = MMSYSERR_NOTSUPPORTED;
444 DWORD lineID, controlType;
445 int val;
446 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
447
448 if((fdwDetails & 0xF0000000) == MIXER_OBJECTF_HMIXER) {
449 if(!pMixInfo) {
450 return MMSYSERR_INVALHANDLE;
451 }
452 }
453 else
454 if((fdwDetails & 0xF0000000) == MIXER_OBJECTF_MIXER) {
455 if(!HIWORD(hmxobj) && hmxobj > 0) {
456 return MMSYSERR_NODRIVER;
457 }
458 }
459 if(lpmcd == NULL || lpmcd->cbStruct != sizeof(MIXERCONTROLDETAILS)) {
460 dprintf(("ERROR: invalid pointer or structure size %x %d", lpmcd, lpmcd->cbStruct));
461 return MMSYSERR_INVALPARAM;
462 }
463
464 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
465 case MIXER_GETCONTROLDETAILSF_VALUE:
466 dprintf(("MIXER_GETCONTROLDETAILSF_VALUE %d (internal id %d)", lpmcd->dwControlID, mixerControls[lpmcd->dwControlID].id));
467 if(lpmcd->dwControlID >= nrControls) {
468 dprintf(("invalid control %d", lpmcd->dwControlID));
469 return MIXERR_INVALCONTROL;
470 }
471 if(lpmcd->cbDetails < sizeof(MIXERCONTROLDETAILS_UNSIGNED)) {
472 dprintf(("not enough room in buffer (%d)", lpmcd->cbDetails));
473 return MMSYSERR_INVALPARAM;
474 }
475 switch(mixerControls[lpmcd->dwControlID].ctrl.dwControlType) {
476 case MIXERCONTROL_CONTROLTYPE_MUX:
477 {
478 MIXERCONTROLDETAILS_BOOLEAN *pDetails = (MIXERCONTROLDETAILS_BOOLEAN *)lpmcd->paDetails;
479 DWORD dwRecSrc;
480
481 dprintf(("MIXERCONTROL_CONTROLTYPE_MUX"));
482 if(lpmcd->cChannels != 1) {//only accepts 1 in win2k
483 dprintf(("invalid number of channels %d", lpmcd->cChannels));
484 return MMSYSERR_INVALPARAM;
485 }
486 //this is also checked in win2k
487 if(lpmcd->u.cMultipleItems != mixerControls[lpmcd->dwControlID].ctrl.cMultipleItems) {
488 dprintf(("invalid cMultipleItems %d", lpmcd->u.cMultipleItems));
489 return MMSYSERR_INVALPARAM;
490 }
491
492 if(mixerControls[lpmcd->dwControlID].id != MIX_CTRL_MUX_IN_W_SRC) {
493 dprintf(("oh, oh. not wavein mux"));
494 DebugInt3();
495 return MMSYSERR_INVALPARAM;
496 }
497 //select recording source
498 for(int i=0;i<nrDestinations;i++) {
499 if(mixerDest[i].id == MIXER_DEST_WAVEIN)
500 {
501 for(int j=0;j<mixerDest[i].cConnections;j++) {
502 dprintf(("wavein source %s %d (id %d)", pmixerLines[mixerDest[i].Connections[j]]->line.szName, pmixerLines[mixerDest[i].Connections[j]]->id, mixerDest[i].Connections[j]));
503 if(pDetails[j].fValue)
504 {
505 if(OSLibMixSetRecSource(pmixerLines[mixerDest[i].Connections[j]]->id) == FALSE) {
506 dprintf(("OSLibMixGetRecSource failed!!"));
507 return MIXERR_INVALCONTROL;
508 }
509 goto success;
510 }
511 }
512 }
513 }
514 dprintf(("recording source %d not found!!", dwRecSrc));
515 break;
516 }
517
518 case MIXERCONTROL_CONTROLTYPE_VOLUME: //unsigned
519 {
520 MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
521 DWORD dwVolumeL, dwVolumeR;
522
523 dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
524 dwVolumeL = pDetails->dwValue;
525
526 dprintf(("%s Left volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
527 if(lpmcd->cChannels == 2) {
528 pDetails += 1;
529 dprintf(("%s Right volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
530 dwVolumeR = pDetails->dwValue;
531 }
532 else dwVolumeR = dwVolumeL;
533 //todo > 2 channels
534
535 if(OSLibMixSetVolume(mixerControls[lpmcd->dwControlID].id, dwVolumeL, dwVolumeR) == FALSE) {
536 return MMSYSERR_INVALPARAM;
537 }
538 mixerControls[lpmcd->dwControlID].val[0].dwValue = dwVolumeL;
539 mixerControls[lpmcd->dwControlID].val[1].dwValue = dwVolumeR;
540 goto success;
541 }
542
543 case MIXERCONTROL_CONTROLTYPE_MUTE: //assuming boolean
544 {
545 MIXERCONTROLDETAILS_BOOLEAN *pDetails = (MIXERCONTROLDETAILS_BOOLEAN *)lpmcd->paDetails;
546 BOOL fMute;
547
548 dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
549 dprintf(("%s Left mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->fValue));
550 fMute = pDetails->fValue;
551 if(lpmcd->cChannels == 2) {
552 pDetails += 1;
553 dprintf(("%s Right mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->fValue));
554 }
555 //todo > 2 channels (usually only 1 channel is requested though)
556
557 if(OSLibMixSetMute(mixerControls[lpmcd->dwControlID].id, fMute) == FALSE) {
558 return MMSYSERR_INVALPARAM;
559 }
560 mixerControls[lpmcd->dwControlID].val[0].dwValue = fMute;
561 goto success;
562 }
563
564 case MIXERCONTROL_CONTROLTYPE_BASS:
565 case MIXERCONTROL_CONTROLTYPE_TREBLE:
566 case MIXERCONTROL_CONTROLTYPE_FADER:
567 {
568 MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
569 DWORD dwLevel;
570
571#ifdef DEBUG
572 switch(fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
573 case MIXERCONTROL_CONTROLTYPE_TREBLE:
574 dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
575 break;
576 case MIXERCONTROL_CONTROLTYPE_BASS:
577 dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
578 break;
579 case MIXERCONTROL_CONTROLTYPE_FADER:
580 dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
581 break;
582 }
583#endif
584 dprintf(("%s %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
585 dwLevel = pDetails->dwValue;
586 if(OSLibMixSetVolume(mixerControls[lpmcd->dwControlID].id, dwLevel, dwLevel) == FALSE) {
587 return MMSYSERR_INVALPARAM;
588 }
589 mixerControls[lpmcd->dwControlID].val[0].dwValue = dwLevel;
590 goto success;
591 }
592
593#ifdef DEBUG
594 case MIXERCONTROL_CONTROLTYPE_MIXER:
595 dprintf(("MIXERCONTROL_CONTROLTYPE_MIXER"));
596 break;
597 case MIXERCONTROL_CONTROLTYPE_CUSTOM:
598 dprintf(("MIXERCONTROL_CONTROLTYPE_CUSTOM"));
599 break;
600 case MIXERCONTROL_CONTROLTYPE_BOOLEANMETER:
601 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEANMETER"));
602 break;
603 case MIXERCONTROL_CONTROLTYPE_SIGNEDMETER:
604 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNEDMETER"));
605 break;
606 case MIXERCONTROL_CONTROLTYPE_PEAKMETER:
607 dprintf(("MIXERCONTROL_CONTROLTYPE_PEAKMETER"));
608 break;
609 case MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER:
610 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER"));
611 break;
612 case MIXERCONTROL_CONTROLTYPE_BOOLEAN:
613 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEAN"));
614 break;
615 case MIXERCONTROL_CONTROLTYPE_ONOFF:
616 dprintf(("MIXERCONTROL_CONTROLTYPE_ONOFF"));
617 break;
618 case MIXERCONTROL_CONTROLTYPE_MONO:
619 dprintf(("MIXERCONTROL_CONTROLTYPE_MONO"));
620 break;
621 case MIXERCONTROL_CONTROLTYPE_LOUDNESS:
622 dprintf(("MIXERCONTROL_CONTROLTYPE_LOUDNESS"));
623 break;
624 case MIXERCONTROL_CONTROLTYPE_STEREOENH:
625 dprintf(("MIXERCONTROL_CONTROLTYPE_STEREOENH"));
626 break;
627 case MIXERCONTROL_CONTROLTYPE_BUTTON:
628 dprintf(("MIXERCONTROL_CONTROLTYPE_BUTTON"));
629 break;
630 case MIXERCONTROL_CONTROLTYPE_DECIBELS:
631 dprintf(("MIXERCONTROL_CONTROLTYPE_DECIBELS"));
632 break;
633 case MIXERCONTROL_CONTROLTYPE_SIGNED:
634 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNED"));
635 break;
636 case MIXERCONTROL_CONTROLTYPE_UNSIGNED:
637 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNED"));
638 break;
639 case MIXERCONTROL_CONTROLTYPE_PERCENT:
640 dprintf(("MIXERCONTROL_CONTROLTYPE_PERCENT"));
641 break;
642 case MIXERCONTROL_CONTROLTYPE_SLIDER:
643 dprintf(("MIXERCONTROL_CONTROLTYPE_SLIDER"));
644 break;
645 case MIXERCONTROL_CONTROLTYPE_PAN:
646 dprintf(("MIXERCONTROL_CONTROLTYPE_PAN"));
647 break;
648 case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN:
649 dprintf(("MIXERCONTROL_CONTROLTYPE_QSOUNDPAN"));
650 break;
651 case MIXERCONTROL_CONTROLTYPE_EQUALIZER:
652 dprintf(("MIXERCONTROL_CONTROLTYPE_EQUALIZER"));
653 break;
654 case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
655 dprintf(("MIXERCONTROL_CONTROLTYPE_SINGLESELECT"));
656 break;
657 case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
658 dprintf(("MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT"));
659 break;
660 case MIXERCONTROL_CONTROLTYPE_MICROTIME:
661 dprintf(("MIXERCONTROL_CONTROLTYPE_MICROTIME"));
662 break;
663 case MIXERCONTROL_CONTROLTYPE_MILLITIME:
664 dprintf(("MIXERCONTROL_CONTROLTYPE_MILLITIME"));
665 break;
666#endif
667 default:
668 DebugInt3();
669 return MIXERR_INVALCONTROL;
670 }
671 return MIXERR_INVALCONTROL;
672 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
673 dprintf(("MIXER_GETCONTROLDETAILSF_LISTTEXT"));
674 break;
675 default:
676 dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
677 break;
678 }
679 return MMSYSERR_NOTSUPPORTED;
680
681success:
682 if(pMixInfo->dwFlags & CALLBACK_WINDOW && pMixInfo->dwCallback) {
683 dprintf(("Notify window %x of control change", pMixInfo->dwCallback));
684 PostMessageA((HWND)pMixInfo->dwCallback, MM_MIXM_CONTROL_CHANGE, (WPARAM)hmxobj, (LPARAM)lpmcd->dwControlID);
685 }
686 return MMSYSERR_NOERROR;
687}
688/******************************************************************************/
689/******************************************************************************/
690MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
691{
692 DWORD dwRet = MMSYSERR_NOERROR;
693 DWORD lineID, controlType;
694 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
695
696 if((fdwControls & 0xF0000000) == MIXER_OBJECTF_HMIXER) {
697 if(!pMixInfo) {
698 return MMSYSERR_INVALHANDLE;
699 }
700 }
701 else
702 if((fdwControls & 0xF0000000) == MIXER_OBJECTF_MIXER) {
703 if(!HIWORD(hmxobj) && hmxobj > 0) {
704 return MMSYSERR_NODRIVER;
705 }
706 }
707
708 if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
709
710 if (lpMlc->cbStruct < sizeof(*lpMlc) || lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
711 return MMSYSERR_INVALPARAM;
712
713 switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)
714 {
715 case MIXER_GETLINECONTROLSF_ALL:
716 {
717 MIXERLINEA *pLine;
718 MIXERCONTROLA *pCtrl;
719
720 dprintf(("MIXER_GETLINECONTROLSF_ALL for line %d", lpMlc->dwLineID));
721 if(lpMlc->dwLineID >= nrLines) {
722 dprintf(("ERROR: Invalid line %d", lpMlc->dwLineID));
723 return MIXERR_INVALLINE;
724 }
725 pLine = &pmixerLines[lpMlc->dwLineID]->line;
726 if(lpMlc->cControls != pLine->cControls) {
727 dprintf(("ERROR: invalid nr of controls %d or structure size %d (%d) (ptr %x)", lpMlc->cControls, lpMlc->cbmxctrl, pLine->cControls*sizeof(MIXERCONTROLA), lpMlc->pamxctrl));
728 return MMSYSERR_INVALPARAM;
729 }
730 for(int i=0;i<lpMlc->cControls;i++) {
731 pCtrl = lpMlc->pamxctrl+i;
732 memcpy(pCtrl, &mixerControls[pmixerLines[lpMlc->dwLineID]->Controls[i]].ctrl, sizeof(MIXERCONTROLA));
733 dprintf(("found control %s (%s) control id %d", pCtrl->szName, pCtrl->szShortName, pCtrl->dwControlID));
734 }
735 break;
736 }
737
738 case MIXER_GETLINECONTROLSF_ONEBYID:
739 {
740 dprintf(("MIXER_GETLINECONTROLSF_ONEBYID %x", lpMlc->u.dwControlID));
741 if(lpMlc->cControls != 1 || lpMlc->cbmxctrl != sizeof(MIXERCONTROLA)) {
742 dprintf(("invalid parameters"));
743 return MMSYSERR_INVALPARAM;
744 }
745 if(lpMlc->u.dwControlID >= nrControls) {
746 dprintf(("invalid control"));
747 return MIXERR_INVALCONTROL;
748 }
749 //find line associated with this control
750 lpMlc->dwLineID = -1;
751 int i;
752 for(i=0;i<nrLines;i++) {
753 for(int j=0;j<pmixerLines[i]->cControls;j++) {
754 if(pmixerLines[i]->Controls[j] == lpMlc->u.dwControlID) {
755 lpMlc->dwLineID = i;
756 break;
757 }
758 else
759 if(pmixerLines[i]->Controls[j] == -1) {
760 break;
761 }
762 }
763 if(lpMlc->dwLineID != -1) {
764 break;
765 }
766 }
767 if(i == MAX_MIXER_LINES) {
768 dprintf(("Associated line for control %d NOT FOUND", lpMlc->u.dwControlID));
769 return MIXERR_INVALCONTROL;
770 }
771 memcpy(lpMlc->pamxctrl, &mixerControls[lpMlc->u.dwControlID].ctrl, sizeof(MIXERCONTROLA));
772
773 dprintf(("found control %s (%s) associated line %d", lpMlc->pamxctrl->szName, lpMlc->pamxctrl->szShortName, lpMlc->dwLineID));
774 break;
775 }
776
777 case MIXER_GETLINECONTROLSF_ONEBYTYPE:
778 {
779 dprintf(("MIXER_GETLINECONTROLSF_ONEBYTYPE %x %d", lpMlc->u.dwControlType, lpMlc->dwLineID));
780 if(lpMlc->dwLineID >= nrLines) {
781 dprintf(("ERROR: Invalid line %d", lpMlc->dwLineID));
782 return MIXERR_INVALLINE;
783 }
784#ifdef DEBUG
785 switch (lpMlc->u.dwControlType) {
786 case MIXERCONTROL_CONTROLTYPE_CUSTOM:
787 dprintf(("MIXERCONTROL_CONTROLTYPE_CUSTOM"));
788 break;
789 case MIXERCONTROL_CONTROLTYPE_BOOLEANMETER:
790 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEANMETER"));
791 break;
792 case MIXERCONTROL_CONTROLTYPE_SIGNEDMETER:
793 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNEDMETER"));
794 break;
795 case MIXERCONTROL_CONTROLTYPE_PEAKMETER:
796 dprintf(("MIXERCONTROL_CONTROLTYPE_PEAKMETER"));
797 break;
798 case MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER:
799 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER"));
800 break;
801 case MIXERCONTROL_CONTROLTYPE_BOOLEAN:
802 dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEAN"));
803 break;
804 case MIXERCONTROL_CONTROLTYPE_ONOFF:
805 dprintf(("MIXERCONTROL_CONTROLTYPE_ONOFF"));
806 break;
807 case MIXERCONTROL_CONTROLTYPE_MUTE:
808 dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
809 break;
810 case MIXERCONTROL_CONTROLTYPE_MONO:
811 dprintf(("MIXERCONTROL_CONTROLTYPE_MONO"));
812 break;
813 case MIXERCONTROL_CONTROLTYPE_LOUDNESS:
814 dprintf(("MIXERCONTROL_CONTROLTYPE_LOUDNESS"));
815 break;
816 case MIXERCONTROL_CONTROLTYPE_STEREOENH:
817 dprintf(("MIXERCONTROL_CONTROLTYPE_STEREOENH"));
818 break;
819 case MIXERCONTROL_CONTROLTYPE_BUTTON:
820 dprintf(("MIXERCONTROL_CONTROLTYPE_BUTTON"));
821 break;
822 case MIXERCONTROL_CONTROLTYPE_DECIBELS:
823 dprintf(("MIXERCONTROL_CONTROLTYPE_DECIBELS"));
824 break;
825 case MIXERCONTROL_CONTROLTYPE_SIGNED:
826 dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNED"));
827 break;
828 case MIXERCONTROL_CONTROLTYPE_UNSIGNED:
829 dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNED"));
830 break;
831 case MIXERCONTROL_CONTROLTYPE_PERCENT:
832 dprintf(("MIXERCONTROL_CONTROLTYPE_PERCENT"));
833 break;
834 case MIXERCONTROL_CONTROLTYPE_SLIDER:
835 dprintf(("MIXERCONTROL_CONTROLTYPE_SLIDER"));
836 break;
837 case MIXERCONTROL_CONTROLTYPE_PAN:
838 dprintf(("MIXERCONTROL_CONTROLTYPE_PAN"));
839 break;
840 case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN:
841 dprintf(("MIXERCONTROL_CONTROLTYPE_QSOUNDPAN"));
842 break;
843 case MIXERCONTROL_CONTROLTYPE_FADER:
844 dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
845 break;
846 case MIXERCONTROL_CONTROLTYPE_VOLUME:
847 dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
848 break;
849 case MIXERCONTROL_CONTROLTYPE_BASS:
850 dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
851 break;
852 case MIXERCONTROL_CONTROLTYPE_TREBLE:
853 dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
854 break;
855 case MIXERCONTROL_CONTROLTYPE_EQUALIZER:
856 dprintf(("MIXERCONTROL_CONTROLTYPE_EQUALIZER"));
857 break;
858 case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
859 dprintf(("MIXERCONTROL_CONTROLTYPE_SINGLESELECT"));
860 break;
861 case MIXERCONTROL_CONTROLTYPE_MUX:
862 dprintf(("MIXERCONTROL_CONTROLTYPE_MUX"));
863 break;
864 case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
865 dprintf(("MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT"));
866 break;
867 case MIXERCONTROL_CONTROLTYPE_MIXER:
868 dprintf(("MIXERCONTROL_CONTROLTYPE_MIXER"));
869 break;
870 case MIXERCONTROL_CONTROLTYPE_MICROTIME:
871 dprintf(("MIXERCONTROL_CONTROLTYPE_MICROTIME"));
872 break;
873 case MIXERCONTROL_CONTROLTYPE_MILLITIME:
874 dprintf(("MIXERCONTROL_CONTROLTYPE_MILLITIME"));
875 break;
876 default:
877 return MMSYSERR_INVALPARAM;
878 }
879#endif
880 int idx;
881
882 for(int i=0;i<pmixerLines[lpMlc->dwLineID]->cControls;i++) {
883 idx = pmixerLines[lpMlc->dwLineID]->Controls[i];
884 if(mixerControls[idx].ctrl.dwControlType == lpMlc->u.dwControlType) {
885 memcpy(lpMlc->pamxctrl, &mixerControls[idx].ctrl, sizeof(MIXERCONTROLA));
886 dprintf(("found control %s (%s) control id %d", lpMlc->pamxctrl->szName, lpMlc->pamxctrl->szShortName, lpMlc->pamxctrl->dwControlID));
887 return MMSYSERR_NOERROR;
888 }
889
890 }
891 return MIXERR_INVALLINE; //returned by win2k when type not found
892 }
893 default:
894 dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
895 dwRet = MMSYSERR_INVALPARAM;
896 break;
897 }
898
899 return dwRet;
900}
901/******************************************************************************/
902/******************************************************************************/
903MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW lpmlcW, DWORD fdwControls)
904{
905 MIXERLINECONTROLSA mlcA;
906 DWORD ret;
907 int i;
908
909 if (lpmlcW == NULL || lpmlcW->cbStruct != sizeof(*lpmlcW) || lpmlcW->cbmxctrl != sizeof(MIXERCONTROLW))
910 return MMSYSERR_INVALPARAM;
911
912 mlcA.cbStruct = sizeof(mlcA);
913 mlcA.dwLineID = lpmlcW->dwLineID;
914 mlcA.u.dwControlID = lpmlcW->u.dwControlID;
915 mlcA.u.dwControlType = lpmlcW->u.dwControlType;
916 mlcA.cControls = lpmlcW->cControls;
917 mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
918 mlcA.pamxctrl = (MIXERCONTROLA *)HeapAlloc(GetProcessHeap(), 0, mlcA.cControls * mlcA.cbmxctrl);
919
920 ret = mixerGetLineControlsA(hmxobj, &mlcA, fdwControls);
921
922 if (ret == MMSYSERR_NOERROR) {
923 lpmlcW->dwLineID = mlcA.dwLineID;
924 lpmlcW->u.dwControlID = mlcA.u.dwControlID;
925 lpmlcW->u.dwControlType = mlcA.u.dwControlType;
926 lpmlcW->cControls = mlcA.cControls;
927
928 for (i = 0; i < mlcA.cControls; i++) {
929 lpmlcW->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLW);
930 lpmlcW->pamxctrl[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
931 lpmlcW->pamxctrl[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
932 lpmlcW->pamxctrl[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
933 lpmlcW->pamxctrl[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
934 MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szShortName, -1,
935 lpmlcW->pamxctrl[i].szShortName,
936 sizeof(lpmlcW->pamxctrl[i].szShortName)/sizeof(WCHAR) );
937 MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szName, -1,
938 lpmlcW->pamxctrl[i].szName,
939 sizeof(lpmlcW->pamxctrl[i].szName)/sizeof(WCHAR) );
940 /* sizeof(lpmlcW->pamxctrl[i].Bounds) ==
941 * sizeof(mlcA.pamxctrl[i].Bounds) */
942 memcpy(&lpmlcW->pamxctrl[i].Bounds, &mlcA.pamxctrl[i].Bounds,
943 sizeof(mlcA.pamxctrl[i].Bounds));
944 /* sizeof(lpmlcW->pamxctrl[i].Metrics) ==
945 * sizeof(mlcA.pamxctrl[i].Metrics) */
946 memcpy(&lpmlcW->pamxctrl[i].Metrics, &mlcA.pamxctrl[i].Metrics,
947 sizeof(mlcA.pamxctrl[i].Metrics));
948 }
949 }
950
951 HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
952 return ret;
953}
954/******************************************************************************/
955/******************************************************************************/
956MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA lpMl, DWORD fdwInfo)
957{
958 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
959
960 if((fdwInfo & 0xF0000000) == MIXER_OBJECTF_HMIXER) {
961 if(!pMixInfo) {
962 return MMSYSERR_INVALHANDLE;
963 }
964 }
965 else
966 if((fdwInfo & 0xF0000000) == MIXER_OBJECTF_MIXER) {
967 if(!HIWORD(hmxobj) && hmxobj > 0) {
968 return MMSYSERR_NODRIVER;
969 }
970 }
971
972 if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl)) {
973 dprintf(("ERROR: mixerGetLineInfoA: invalid paramter!!"));
974 return MMSYSERR_INVALPARAM;
975 }
976
977 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
978 {
979 case MIXER_GETLINEINFOF_DESTINATION:
980 dprintf(("MIXER_GETLINEINFOF_DESTINATION %d", lpMl->dwDestination));
981 if(lpMl->dwDestination >= nrDestinations) {
982 dprintf(("ERROR: Invalid destination %d", lpMl->dwDestination));
983 return MMSYSERR_INVALPARAM;
984 }
985 memcpy(lpMl, &mixerDest[lpMl->dwDestination].line, sizeof(MIXERLINEA));
986 dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
987 break;
988
989 case MIXER_GETLINEINFOF_LINEID:
990 dprintf(("MIXER_GETLINEINFOF_LINEID %d", lpMl->dwLineID));
991 if(lpMl->dwLineID >= nrLines) {
992 dprintf(("ERROR: Invalid line %d", lpMl->dwLineID));
993 return MIXERR_INVALLINE;
994 }
995 memcpy(lpMl, &pmixerLines[lpMl->dwLineID]->line, sizeof(MIXERLINEA));
996 dprintf(("found line %s (%s) connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->cConnections, lpMl->cControls));
997 break;
998
999 case MIXER_GETLINEINFOF_SOURCE:
1000 dprintf(("MIXER_GETLINEINFOF_SOURCE %d %d", lpMl->dwDestination, lpMl->dwSource));
1001 if(lpMl->dwDestination >= nrDestinations) {
1002 dprintf(("ERROR: Invalid destination %d", lpMl->dwDestination));
1003 return MIXERR_INVALLINE;
1004 }
1005 if(lpMl->dwSource >= MIXER_SRC_MAX) {
1006 dprintf(("ERROR: Invalid source %d", lpMl->dwSource));
1007 return MIXERR_INVALLINE;
1008 }
1009 if(mixerDest[lpMl->dwDestination].Connections[lpMl->dwSource] == -1) {
1010 dprintf(("ERROR: Invalid destination/source combo (%d,%d)", lpMl->dwDestination, lpMl->dwSource));
1011 return MIXERR_INVALLINE;
1012 }
1013 memcpy(lpMl, &pmixerLines[mixerDest[lpMl->dwDestination].Connections[lpMl->dwSource]]->line, sizeof(MIXERLINEA));
1014 dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1015 break;
1016
1017 case MIXER_GETLINEINFOF_COMPONENTTYPE:
1018 {
1019 dprintf(("MIXER_GETLINEINFOF_COMPONENTTYPE"));
1020#ifdef DEBUG
1021 switch (lpMl->dwComponentType)
1022 {
1023 case MIXERLINE_COMPONENTTYPE_DST_UNDEFINED:
1024 dprintf(("MIXERLINE_COMPONENTTYPE_DST_UNDEFINED"));
1025 break;
1026 case MIXERLINE_COMPONENTTYPE_DST_DIGITAL:
1027 dprintf(("MIXERLINE_COMPONENTTYPE_DST_DIGITAL"));
1028 break;
1029 case MIXERLINE_COMPONENTTYPE_DST_LINE:
1030 dprintf(("MIXERLINE_COMPONENTTYPE_DST_LINE"));
1031 break;
1032 case MIXERLINE_COMPONENTTYPE_DST_MONITOR:
1033 dprintf(("MIXERLINE_COMPONENTTYPE_DST_MONITOR"));
1034 break;
1035 case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
1036 dprintf(("MIXERLINE_COMPONENTTYPE_DST_SPEAKERS"));
1037 break;
1038 case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES:
1039 dprintf(("MIXERLINE_COMPONENTTYPE_DST_HEADPHONES"));
1040 break;
1041 case MIXERLINE_COMPONENTTYPE_DST_TELEPHONE:
1042 dprintf(("MIXERLINE_COMPONENTTYPE_DST_TELEPHONE"));
1043 break;
1044 case MIXERLINE_COMPONENTTYPE_DST_WAVEIN:
1045 dprintf(("MIXERLINE_COMPONENTTYPE_DST_WAVEIN"));
1046 break;
1047 case MIXERLINE_COMPONENTTYPE_DST_VOICEIN:
1048 dprintf(("MIXERLINE_COMPONENTTYPE_DST_VOICEIN"));
1049 break;
1050 case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED:
1051 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED"));
1052 break;
1053 case MIXERLINE_COMPONENTTYPE_SRC_DIGITAL:
1054 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_DIGITAL"));
1055 break;
1056 case MIXERLINE_COMPONENTTYPE_SRC_LINE:
1057 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_LINE"));
1058 break;
1059 case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE:
1060 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE"));
1061 break;
1062 case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER:
1063 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER"));
1064 break;
1065 case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC:
1066 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC"));
1067 break;
1068 case MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE:
1069 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE"));
1070 break;
1071 case MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER:
1072 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER"));
1073 break;
1074 case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
1075 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT"));
1076 break;
1077 case MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY:
1078 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY"));
1079 break;
1080 case MIXERLINE_COMPONENTTYPE_SRC_ANALOG:
1081 dprintf(("MIXERLINE_COMPONENTTYPE_SRC_ANALOG"));
1082 break;
1083 default:
1084 dprintf(("Unhandled component type (%08lx)\n", lpMl->dwComponentType));
1085 return MMSYSERR_INVALPARAM;
1086 }
1087#endif
1088 //search all lines (src & dest) for one with specified type
1089 int i;
1090 for(i=0;i<nrLines;i++) {
1091 if(pmixerLines[i]->line.dwComponentType == lpMl->dwComponentType) {
1092 break;
1093 }
1094 }
1095 if(i == nrLines) {
1096 dprintf(("Component type %d not found!!", lpMl->dwComponentType));
1097 return MIXERR_INVALLINE;
1098 }
1099 memcpy(lpMl, &pmixerLines[i]->line, sizeof(MIXERLINEA));
1100 dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1101 break;
1102 }
1103 case MIXER_GETLINEINFOF_TARGETTYPE:
1104 {
1105 dprintf(("MIXER_GETLINEINFOF_TARGETTYPE %x", lpMl->Target.dwType));
1106#ifdef DEBUG
1107 switch(lpMl->Target.dwType) {
1108 case MIXERLINE_TARGETTYPE_UNDEFINED:
1109 dprintf(("MIXERLINE_TARGETTYPE_UNDEFINED"));
1110 break;
1111 case MIXERLINE_TARGETTYPE_WAVEOUT:
1112 dprintf(("MIXERLINE_TARGETTYPE_WAVEOUT"));
1113 break;
1114 case MIXERLINE_TARGETTYPE_WAVEIN:
1115 dprintf(("MIXERLINE_TARGETTYPE_WAVEIN"));
1116 break;
1117 case MIXERLINE_TARGETTYPE_MIDIOUT:
1118 dprintf(("MIXERLINE_TARGETTYPE_MIDIOUT"));
1119 break;
1120 case MIXERLINE_TARGETTYPE_MIDIIN:
1121 dprintf(("MIXERLINE_TARGETTYPE_MIDIIN"));
1122 break;
1123 case MIXERLINE_TARGETTYPE_AUX:
1124 dprintf(("MIXERLINE_TARGETTYPE_AUX"));
1125 break;
1126 default:
1127 dprintf(("Unhandled target type (%08lx)\n", lpMl->Target.dwType));
1128 return MMSYSERR_INVALPARAM;
1129 }
1130#endif
1131 //search all lines (src & dest) for one with specified type
1132 //TODO: Should we compare mid, pid & pddname too? (must be initialized according to MSDN)
1133 // (see below; unicode version doesn't copy pddname; change if these checks are required)
1134 int i;
1135 for(int i=0;i<nrLines;i++) {
1136 if(pmixerLines[i]->line.Target.dwType == lpMl->Target.dwType) {
1137 break;
1138 }
1139 }
1140 if(i == nrLines) {
1141 dprintf(("Component type %d not found!!", lpMl->Target.dwType));
1142 return MIXERR_INVALLINE;
1143 }
1144 memcpy(lpMl, &pmixerLines[i]->line, sizeof(MIXERLINEA));
1145 dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1146 break;
1147 }
1148 default:
1149 dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
1150 return MMSYSERR_INVALPARAM;
1151 break;
1152 }
1153 return MMSYSERR_NOERROR;
1154}
1155/******************************************************************************/
1156/******************************************************************************/
1157MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
1158{
1159 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
1160 MIXERLINEA line;
1161 MMRESULT result;
1162
1163 line.cbStruct = sizeof(MIXERLINEA);
1164 line.cChannels = pmxl->cChannels;
1165 line.cConnections = pmxl->cConnections;
1166 line.cControls = pmxl->cControls;
1167 line.dwComponentType = pmxl->dwComponentType;
1168 line.dwDestination = pmxl->dwDestination;
1169 line.dwLineID = pmxl->dwLineID;
1170 line.dwSource = pmxl->dwSource;
1171 line.dwUser = pmxl->dwUser;
1172 line.fdwLine = pmxl->fdwLine;
1173 line.szName[0] = 0;
1174 line.szShortName[0] = 0;
1175 line.Target.dwDeviceID = pmxl->Target.dwDeviceID;
1176 line.Target.dwType = pmxl->Target.dwType;
1177 line.Target.vDriverVersion = pmxl->Target.vDriverVersion;
1178 line.Target.wMid = pmxl->Target.wMid;
1179 line.Target.wPid = pmxl->Target.wPid;
1180 //TODO: need to copy this?? (MIXER_GETLINEINFOF_TARGETTYPE)
1181 line.Target.szPname[0] = 0;
1182
1183 result = mixerGetLineInfoA(hmxobj, &line, fdwInfo);
1184 if(result != MMSYSERR_NOERROR) {
1185 return result;
1186 }
1187 pmxl->cbStruct = sizeof(MIXERLINEA);
1188 pmxl->cChannels = line.cChannels;
1189 pmxl->cConnections = line.cConnections;
1190 pmxl->cControls = line.cControls;
1191 pmxl->dwComponentType = line.dwComponentType;
1192 pmxl->dwDestination = line.dwDestination;
1193 pmxl->dwLineID = line.dwLineID;
1194 pmxl->dwSource = line.dwSource;
1195 pmxl->dwUser = line.dwUser;
1196 pmxl->fdwLine = line.fdwLine;
1197 MultiByteToWideChar(CP_ACP, 0, line.szName, -1, pmxl->szName, sizeof(line.szName));
1198 MultiByteToWideChar(CP_ACP, 0, line.szShortName, -1, pmxl->szShortName, sizeof(line.szShortName));
1199 pmxl->Target.dwDeviceID = line.Target.dwDeviceID;
1200 pmxl->Target.dwType = line.Target.dwType;
1201 pmxl->Target.vDriverVersion = line.Target.vDriverVersion;
1202 pmxl->Target.wMid = line.Target.wMid;
1203 pmxl->Target.wPid = line.Target.wPid;
1204 pmxl->Target.szPname[0] = 0;
1205 MultiByteToWideChar(CP_ACP, 0, line.Target.szPname, -1, pmxl->Target.szPname, sizeof(line.Target.szPname));
1206 return MMSYSERR_NOERROR;
1207}
1208/******************************************************************************/
1209/******************************************************************************/
1210MMRESULT WINAPI mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
1211{
1212 dprintf(("WINMM:mixerMessage - NOT IMPLEMENTED" ));
1213 return MMSYSERR_NOTSUPPORTED;
1214}
1215/******************************************************************************/
1216/******************************************************************************/
1217UINT WINAPI mixerGetNumDevs()
1218{
1219 if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
1220 return 0;
1221 }
1222 return 1;
1223}
1224/******************************************************************************/
1225/******************************************************************************/
1226MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
1227{
1228 if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
1229 return MMSYSERR_BADDEVICEID;
1230 }
1231
1232 // According to MSDN, uMxId may be a handle returned by mixerOpen() so we
1233 // must accept this situation. Note that since we don't actually track
1234 // the created handles and that we provide only one mixer anyway
1235 // (see mixerGetNumDevs()), we have to accept any uMxId value here...
1236#if 0
1237 if(uMxId > 0) {
1238 return MMSYSERR_BADDEVICEID;
1239 }
1240#endif
1241
1242 //According to MSDN, nothing is copied when cbmxcaps is zero
1243 if(cbmxcaps >= sizeof(MIXERCAPSA)) {
1244 pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1245 pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1246 pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1247 strncpy( pmxcaps->szPname, WINMM_MIXERSTRING_A, sizeof(pmxcaps->szPname)); /* product name */
1248
1249 pmxcaps->fdwSupport = 0; //no mixer flags exist
1250 pmxcaps->cDestinations = nrDestinations;
1251 dprintf(("mixerGetDevCapsA: cDestinations %d", pmxcaps->cDestinations));
1252 }
1253
1254 return MMSYSERR_NOERROR;
1255}
1256/******************************************************************************/
1257/******************************************************************************/
1258MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
1259{
1260 if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
1261 return MMSYSERR_BADDEVICEID;
1262 }
1263
1264 // According to MSDN, uMxId may be a handle returned by mixerOpen() so we
1265 // must accept this situation. Note that since we don't actually track
1266 // the created handles and that we provide only one mixer anyway
1267 // (see mixerGetNumDevs()), we have to accept any uMxId value here...
1268#if 0
1269 if(uMxId > 0) {
1270 return MMSYSERR_BADDEVICEID;
1271 }
1272#endif
1273
1274 //According to MSDN, nothing is copied when cbmxcaps is zero
1275 if(cbmxcaps >= sizeof(MIXERCAPSW)) {
1276 pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1277 pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1278 pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1279 lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
1280
1281 pmxcaps->fdwSupport = 0; //no mixer flags exist
1282 pmxcaps->cDestinations = nrDestinations;
1283 dprintf(("mixerGetDevCapsW: cDestinations %d", pmxcaps->cDestinations));
1284 }
1285
1286 return MMSYSERR_NOERROR;
1287}
1288/******************************************************************************/
1289/******************************************************************************/
1290MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
1291{
1292 switch(fdwId) {
1293 case MIXER_OBJECTF_MIXER:
1294 {
1295 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
1296 if(!pMixInfo) {
1297 if(puMxId) {
1298 *puMxId = -1;
1299 }
1300 return MMSYSERR_INVALHANDLE;
1301 }
1302 if(puMxId) {
1303 *puMxId = pMixInfo->uDeviceID;
1304 }
1305 break;
1306 }
1307
1308 case MIXER_OBJECTF_HMIXER:
1309 case MIXER_OBJECTF_WAVEOUT:
1310 case MIXER_OBJECTF_HWAVEOUT:
1311 case MIXER_OBJECTF_WAVEIN:
1312 case MIXER_OBJECTF_HWAVEIN:
1313 case MIXER_OBJECTF_MIDIOUT:
1314 case MIXER_OBJECTF_HMIDIOUT:
1315 case MIXER_OBJECTF_MIDIIN:
1316 case MIXER_OBJECTF_HMIDIIN:
1317 case MIXER_OBJECTF_AUX:
1318 //TODO: assume default mixer
1319 if(puMxId) {
1320 *puMxId = 0;
1321 }
1322 break;
1323 default:
1324 if(puMxId) {
1325 *puMxId = -1;
1326 }
1327 return MMSYSERR_INVALPARAM;
1328 }
1329 return MMSYSERR_NOERROR;
1330}
1331/******************************************************************************/
1332/******************************************************************************/
1333MMRESULT WINAPI mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance,
1334 DWORD fdwOpen)
1335{
1336 DEVICE_STRUCT *pMixInfo;
1337
1338 if (mixerGetNumDevs() <= uMxId) {
1339 if(phmx) *phmx = 0;
1340 return MMSYSERR_NODRIVER;
1341 }
1342
1343 pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
1344 if(pMixInfo == NULL) {
1345 return MMSYSERR_NODRIVER;
1346 }
1347 pMixInfo->dwCallback = dwCallback;
1348 pMixInfo->dwDriverInstance = dwInstance;
1349 pMixInfo->dwFlags = fdwOpen;
1350 pMixInfo->uDeviceID = uMxId;
1351 pMixInfo->type = WINMM_MIXER;
1352 if(phmx)
1353 *phmx = (HMIXER)pMixInfo;
1354
1355 return MMSYSERR_NOERROR;
1356}
1357/******************************************************************************/
1358/******************************************************************************/
1359MMRESULT WINAPI mixerClose(HMIXER hmx)
1360{
1361 if(hmx) {
1362 free((void *)hmx);
1363 }
1364 return MMSYSERR_NOERROR;
1365}
1366/******************************************************************************/
1367/******************************************************************************/
1368BOOL mixerInit()
1369{
1370 MIXLINE *pDestLine;
1371 MIXERCONTROLA *pWaveInMux;
1372
1373 if(!fMMPMAvailable) return TRUE;
1374
1375 memset(mixerDest, 0, sizeof(mixerDest));
1376 int i;
1377 for(i=0;i<MIXER_DEST_MAX;i++) {
1378 memset(mixerDest[i].Connections, -1, sizeof(mixerDest[i].Connections));
1379 memset(mixerDest[i].Controls, -1, sizeof(mixerDest[i].Controls));
1380 }
1381 memset(mixerSource, 0, sizeof(mixerSource));
1382 for(i=0;i<MIXER_SRC_MAX;i++) {
1383 memset(mixerSource[i].Connections, -1, sizeof(mixerSource[i].Connections));
1384 memset(mixerSource[i].Controls, -1, sizeof(mixerSource[i].Controls));
1385 mixerSource[i].id = -1;
1386 }
1387 if(OSLibMixerOpen() == FALSE) {
1388 //Line out destination
1389 pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1390 mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1391 mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1392
1393 //WaveIn destination
1394 pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1395 pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1396 mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pDestLine);
1397 mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pDestLine);
1398 pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1399 return TRUE;
1400 }
1401
1402 //Line out destination
1403 pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1404
1405 mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1406 mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1407
1408 if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DCENTER)) {
1409 mixerAddControl(MIX_CTRL_OUT_L_3DCENTER, pDestLine);
1410 }
1411 if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DDEPTH)) {
1412 mixerAddControl(MIX_CTRL_OUT_L_3DDEPTH, pDestLine);
1413 }
1414 if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_TREBLE)) {
1415 mixerAddControl(MIX_CTRL_OUT_L_TREBLE, pDestLine);
1416 }
1417 if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_BASS)) {
1418 mixerAddControl(MIX_CTRL_OUT_L_BASS, pDestLine);
1419 }
1420
1421 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PCM)) {
1422 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PCM);
1423 mixerAddControl(MIX_CTRL_VOL_IN_L_PCM, pLine);
1424 mixerAddControl(MIX_CTRL_MUTE_IN_L_PCM, pLine);
1425 }
1426 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_WAVETABLE)) {
1427 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_WAVETABLE);
1428 mixerAddControl(MIX_CTRL_VOL_IN_L_WAVETABLE, pLine);
1429 mixerAddControl(MIX_CTRL_MUTE_IN_L_WAVETABLE, pLine);
1430 }
1431 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIDI)) {
1432 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIDI);
1433 mixerAddControl(MIX_CTRL_VOL_IN_L_MIDI, pLine);
1434 mixerAddControl(MIX_CTRL_MUTE_IN_L_MIDI, pLine);
1435 }
1436 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIC)) {
1437 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIC);
1438 mixerAddControl(MIX_CTRL_VOL_IN_L_MIC, pLine);
1439 mixerAddControl(MIX_CTRL_MUTE_IN_L_MIC, pLine);
1440 if(OSLibMixIsControlPresent(MIX_CTRL_BOOST_IN_L_MIC)) {
1441 mixerAddControl(MIX_CTRL_BOOST_IN_L_MIC, pLine);
1442 }
1443 }
1444 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_LINE)) {
1445 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_LINE);
1446 mixerAddControl(MIX_CTRL_VOL_IN_L_LINE, pLine);
1447 mixerAddControl(MIX_CTRL_MUTE_IN_L_LINE, pLine);
1448 }
1449 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_CD)) {
1450 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_CD);
1451 mixerAddControl(MIX_CTRL_VOL_IN_L_CD, pLine);
1452 mixerAddControl(MIX_CTRL_MUTE_IN_L_CD, pLine);
1453 }
1454 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_AUX)) {
1455 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_AUX);
1456 mixerAddControl(MIX_CTRL_VOL_IN_L_AUX, pLine);
1457 mixerAddControl(MIX_CTRL_MUTE_IN_L_AUX, pLine);
1458 }
1459 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_SPDIF)) {
1460 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_SPDIF);
1461 mixerAddControl(MIX_CTRL_VOL_IN_L_SPDIF, pLine);
1462 mixerAddControl(MIX_CTRL_MUTE_IN_L_SPDIF, pLine);
1463 }
1464 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MONO)) {
1465 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MONOIN);
1466 mixerAddControl(MIX_CTRL_VOL_IN_L_MONO, pLine);
1467 mixerAddControl(MIX_CTRL_MUTE_IN_L_MONO, pLine);
1468 }
1469 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PHONE)) {
1470 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PHONE);
1471 mixerAddControl(MIX_CTRL_VOL_IN_L_PHONE, pLine);
1472 mixerAddControl(MIX_CTRL_MUTE_IN_L_PHONE, pLine);
1473 }
1474 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_VIDEO)) {
1475 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_VIDEO);
1476 mixerAddControl(MIX_CTRL_VOL_IN_L_VIDEO, pLine);
1477 mixerAddControl(MIX_CTRL_MUTE_IN_L_VIDEO, pLine);
1478 }
1479
1480 //Wave In Destination
1481 if(OSLibMixIsControlPresent(MIX_CTRL_MUX_IN_W_SRC)) {
1482 pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1483 pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1484
1485 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIC)) {
1486 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIC);
1487 mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pLine);
1488 }
1489 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_LINE)) {
1490 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_LINE);
1491 mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pLine);
1492 }
1493 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_CD)) {
1494 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_CD);
1495 mixerAddControl(MIX_CTRL_VOL_IN_W_CD, pLine);
1496 }
1497 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_AUX)) {
1498 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_AUX);
1499 mixerAddControl(MIX_CTRL_VOL_IN_W_AUX, pLine);
1500 }
1501 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PCM)) {
1502 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PCM);
1503 mixerAddControl(MIX_CTRL_VOL_IN_W_PCM, pLine);
1504 }
1505 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_WAVETABLE)) {
1506 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_WAVETABLE);
1507 mixerAddControl(MIX_CTRL_VOL_IN_W_WAVETABLE, pLine);
1508 }
1509 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIDI)) {
1510 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIDI);
1511 mixerAddControl(MIX_CTRL_VOL_IN_W_MIDI, pLine);
1512 }
1513 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOIN)) {
1514 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOIN);
1515 mixerAddControl(MIX_CTRL_VOL_IN_W_MONO, pLine);
1516 }
1517 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PHONE)) {
1518 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PHONE);
1519 mixerAddControl(MIX_CTRL_VOL_IN_W_PHONE, pLine);
1520 }
1521 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_SPDIF)) {
1522 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_SPDIF);
1523 mixerAddControl(MIX_CTRL_VOL_IN_W_SPDIF, pLine);
1524 }
1525 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_VIDEO)) {
1526 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_VIDEO);
1527 mixerAddControl(MIX_CTRL_VOL_IN_W_VIDEO, pLine);
1528 }
1529 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_STEREOMIX)) {
1530 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_STEREOMIX);
1531 mixerAddControl(MIX_CTRL_VOL_IN_W_STEREOMIX, pLine);
1532 }
1533 if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOMIX)) {
1534 MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOMIX);
1535 mixerAddControl(MIX_CTRL_VOL_IN_W_MONOMIX, pLine);
1536 }
1537 pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1538 pWaveInMux->Bounds.s.lMinimum = 0;
1539 pWaveInMux->Bounds.s.lMaximum = pDestLine->line.cConnections;
1540 pWaveInMux->Metrics.cSteps = pDestLine->line.cConnections;
1541 }
1542
1543 //SPDIF destination
1544 if(OSLibMixIsControlPresent(MIX_CTRL_VOL_OUT_SPDIF)) {
1545 pDestLine = mixerAddDestination(MIXER_DEST_SPDIFOUT);
1546 mixerAddControl(MIX_CTRL_VOL_OUT_SPDIF, pDestLine);
1547 mixerAddControl(MIX_CTRL_MUTE_OUT_SPDIF, pDestLine);
1548 }
1549
1550 return TRUE;
1551}
1552/******************************************************************************/
1553/******************************************************************************/
1554void mixerExit()
1555{
1556 if(fMMPMAvailable == FALSE) return;
1557
1558 OSLibMixerClose();
1559}
1560/******************************************************************************/
1561/******************************************************************************/
1562static MIXLINE *mixerAddSource(MIXLINE *pDestLine, DWORD dwSource)
1563{
1564 MIXLINE *pSource = &mixerSource[nrSources];
1565 MIXERLINEA *pline = &pSource->line;
1566
1567 if(nrSources >= MAX_MIXER_SOURCES) {
1568 dprintf(("ERROR: mixerAddSource: out of room!!!"));
1569 DebugInt3();
1570 return NULL;
1571 }
1572
1573 memset(pline, 0, sizeof(MIXERLINEA));
1574
1575 pline->cbStruct = sizeof(MIXERLINEA);
1576 pline->cConnections = 0;
1577 pline->cControls = 0;
1578 pline->dwDestination = 0;
1579 pline->fdwLine = MIXERLINE_LINEF_SOURCE;
1580 pline->Target.dwDeviceID = 0;
1581 pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1582 pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1583 pline->dwSource = nrSources;
1584 OSLibMixGetLineCaps(dwSource, &pline->cChannels);
1585 nrSources++;
1586
1587 switch(dwSource) {
1588 case MIXER_SRC_IN_L_MONOIN:
1589 case MIXER_SRC_IN_W_MONOIN:
1590 case MIXER_SRC_IN_L_PHONE:
1591 case MIXER_SRC_IN_W_PHONE:
1592 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE;
1593 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1594 break;
1595
1596 case MIXER_SRC_IN_L_MIC:
1597 case MIXER_SRC_IN_W_MIC:
1598 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
1599 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1600 break;
1601
1602 case MIXER_SRC_IN_L_LINE:
1603 case MIXER_SRC_IN_W_LINE:
1604 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
1605 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1606 break;
1607
1608 case MIXER_SRC_IN_L_CD:
1609 case MIXER_SRC_IN_W_CD:
1610 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
1611 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1612 break;
1613
1614 case MIXER_SRC_IN_L_SPDIF:
1615 case MIXER_SRC_IN_W_SPDIF:
1616 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_DIGITAL;
1617 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1618 break;
1619
1620 case MIXER_SRC_IN_L_VIDEO:
1621 case MIXER_SRC_IN_W_VIDEO:
1622 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
1623 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1624 break;
1625
1626 case MIXER_SRC_IN_L_AUX:
1627 case MIXER_SRC_IN_W_AUX:
1628 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY;
1629 pline->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
1630 break;
1631
1632 case MIXER_SRC_IN_L_PCM:
1633 case MIXER_SRC_IN_W_PCM:
1634 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
1635 pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
1636 break;
1637
1638 case MIXER_SRC_IN_L_WAVETABLE:
1639 case MIXER_SRC_IN_W_WAVETABLE:
1640 case MIXER_SRC_IN_L_MIDI:
1641 case MIXER_SRC_IN_W_MIDI:
1642 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
1643 pline->Target.dwType = MIXERLINE_TARGETTYPE_MIDIOUT;
1644 break;
1645
1646 default:
1647 DebugInt3();
1648 return NULL;
1649 }
1650 strncpy(pline->szShortName, szSourceName[dwSource][0], sizeof(pline->szShortName));
1651 strncpy(pline->szName, szSourceName[dwSource][1], sizeof(pline->szName));
1652 strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1653
1654 //add to array of mixer line pointers
1655 pline->dwLineID = nrLines;
1656 pmixerLines[nrLines] = pSource;
1657 nrLines++;
1658
1659 //store line id in source to line mapping array
1660 pSource->id = dwSource;
1661
1662 //increase nr of inputs at destination line
1663 pDestLine->line.cConnections++;
1664 pDestLine->Connections[pDestLine->cConnections] = pline->dwLineID;
1665 pDestLine->cConnections++;
1666
1667 dprintf(("Adding Source %s (%s) with destination %s (%d -> %d)", pline->szName, pline->szShortName, pDestLine->line.szName, dwSource, pline->dwLineID));
1668
1669 return pSource;
1670}
1671/******************************************************************************/
1672/******************************************************************************/
1673static MIXLINE *mixerAddDestination(DWORD dwDest)
1674{
1675 MIXLINE *pDest = &mixerDest[nrDestinations];
1676 MIXERLINEA *pline = &pDest->line;
1677
1678 if(nrDestinations >= MAX_MIXER_DESTINATIONS) {
1679 dprintf(("ERROR: mixerAddDestination: out of room!!!"));
1680 DebugInt3();
1681 return NULL;
1682 }
1683 memset(pline, 0, sizeof(MIXERLINEA));
1684 pline->cbStruct = sizeof(MIXERLINEA);
1685 pline->cConnections = 0;
1686 pline->cControls = 0;
1687 pline->dwSource = (DWORD)-1;
1688 pline->dwDestination = nrDestinations;
1689
1690 switch(dwDest) {
1691 case MIXER_DEST_LINEOUT:
1692 pline->cChannels = 2;
1693 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
1694 pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1695 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1696 break;
1697
1698 case MIXER_DEST_SPDIFOUT:
1699 pline->cChannels = 2;
1700 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_DIGITAL;
1701 pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1702 pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1703 break;
1704
1705 case MIXER_DEST_WAVEIN:
1706 pline->cChannels = 2;
1707 pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
1708 pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1709 pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
1710 break;
1711
1712 default:
1713 DebugInt3();
1714 return NULL;
1715 }
1716 strncpy(pline->szShortName, szDestName[dwDest][0], sizeof(pline->szShortName));
1717 strncpy(pline->szName, szDestName[dwDest][1], sizeof(pline->szName));
1718 strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1719 pline->Target.dwDeviceID = 0;
1720 pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1721 pline->Target.wPid = WINMM_MIXER_CAPS_WPID;
1722 pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1723
1724 dprintf(("Adding destination %s (%s) connections %d controls %d", pline->szName, pline->szShortName, pline->cConnections, pline->cControls));
1725 nrDestinations++;
1726
1727 pline->dwLineID = nrLines;
1728 pmixerLines[nrLines] = pDest;
1729 nrLines++;
1730
1731 //save internal id
1732 pDest->id = dwDest;
1733 return pDest;
1734}
1735/******************************************************************************/
1736/******************************************************************************/
1737static MIXERCONTROLA * mixerAddControl(DWORD dwControl, MIXLINE *pSrcLine)
1738{
1739 MIXCONTROL *pmixctrl = &mixerControls[nrControls];
1740 MIXERCONTROLA *pctrl = &pmixctrl->ctrl;
1741
1742 if(nrControls >= MAX_MIXER_CONTROLS) {
1743 dprintf(("ERROR: mixerAddControl: out of room!!!"));
1744 DebugInt3();
1745 return NULL;
1746 }
1747
1748 memset(pctrl, 0, sizeof(MIXERCONTROLA));
1749 pctrl->cbStruct = sizeof(MIXERCONTROLA);
1750 pctrl->cMultipleItems = 0;
1751 pctrl->dwControlID = nrControls;
1752 pctrl->fdwControl = 0;
1753 switch(dwControl) {
1754 case MIX_CTRL_MUX_IN_W_SRC:
1755 pctrl->fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE | MIXERCONTROL_CONTROLF_UNIFORM;
1756 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;
1757 pctrl->Bounds.s.lMinimum = 0;
1758 pctrl->Bounds.s.lMaximum = 1;
1759 pctrl->Metrics.cSteps = 1;
1760 pctrl->cMultipleItems = 0; //to be filled in later (see caller)
1761 break;
1762
1763 case MIX_CTRL_VOL_OUT_LINE:
1764 case MIX_CTRL_VOL_IN_L_MONO:
1765 case MIX_CTRL_VOL_IN_L_PHONE:
1766 case MIX_CTRL_VOL_IN_L_MIC:
1767 case MIX_CTRL_VOL_IN_L_LINE:
1768 case MIX_CTRL_VOL_IN_L_CD:
1769 case MIX_CTRL_VOL_IN_L_SPDIF:
1770 case MIX_CTRL_VOL_IN_L_VIDEO:
1771 case MIX_CTRL_VOL_IN_L_AUX:
1772 case MIX_CTRL_VOL_IN_L_PCM:
1773 case MIX_CTRL_VOL_IN_L_WAVETABLE:
1774 case MIX_CTRL_VOL_IN_L_MIDI:
1775 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1776 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1777 break;
1778
1779 case MIX_CTRL_VOL_IN_W_MONO:
1780 case MIX_CTRL_VOL_IN_W_PHONE:
1781 case MIX_CTRL_VOL_IN_W_MIC:
1782 case MIX_CTRL_VOL_IN_W_LINE:
1783 case MIX_CTRL_VOL_IN_W_CD:
1784 case MIX_CTRL_VOL_IN_W_SPDIF:
1785 case MIX_CTRL_VOL_IN_W_VIDEO:
1786 case MIX_CTRL_VOL_IN_W_AUX:
1787 case MIX_CTRL_VOL_IN_W_PCM:
1788 case MIX_CTRL_VOL_IN_W_WAVETABLE:
1789 case MIX_CTRL_VOL_IN_W_MIDI:
1790 case MIX_CTRL_VOL_IN_W_STEREOMIX:
1791 case MIX_CTRL_VOL_IN_W_MONOMIX:
1792 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1793 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1794 break;
1795
1796 case MIX_CTRL_MUTE_OUT_LINE:
1797 case MIX_CTRL_MUTE_IN_L_MONO:
1798 case MIX_CTRL_MUTE_IN_L_PHONE:
1799 case MIX_CTRL_MUTE_IN_L_MIC:
1800 case MIX_CTRL_MUTE_IN_L_LINE:
1801 case MIX_CTRL_MUTE_IN_L_CD:
1802 case MIX_CTRL_MUTE_IN_L_SPDIF:
1803 case MIX_CTRL_MUTE_IN_L_VIDEO:
1804 case MIX_CTRL_MUTE_IN_L_AUX:
1805 case MIX_CTRL_MUTE_IN_L_PCM:
1806 pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1807 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1808 pctrl->Bounds.s.lMinimum = 0;
1809 pctrl->Bounds.s.lMaximum = 1;
1810 pctrl->Metrics.cSteps = 0;
1811 break;
1812
1813 case MIX_CTRL_VOL_OUT_SPDIF:
1814 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1815 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1816 break;
1817
1818 case MIX_CTRL_MUTE_OUT_SPDIF:
1819 pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1820 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1821 pctrl->Bounds.s.lMinimum = 0;
1822 pctrl->Bounds.s.lMaximum = 1;
1823 pctrl->Metrics.cSteps = 0;
1824 break;
1825
1826 case MIX_CTRL_BOOST_IN_L_MIC:
1827 pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1828 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_ONOFF;
1829 pctrl->Bounds.s.lMinimum = 0;
1830 pctrl->Bounds.s.lMaximum = 1;
1831 pctrl->Metrics.cSteps = 0;
1832 break;
1833
1834 case MIX_CTRL_OUT_L_3DDEPTH:
1835 pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1836 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1837 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1838 break;
1839
1840 case MIX_CTRL_OUT_L_3DCENTER:
1841 pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1842 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1843 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1844 break;
1845
1846 case MIX_CTRL_OUT_L_TREBLE:
1847 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_TREBLE;
1848 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1849 break;
1850
1851 case MIX_CTRL_OUT_L_BASS:
1852 pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_BASS;
1853 OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1854 break;
1855
1856 default:
1857 DebugInt3();
1858 return FALSE;
1859 }
1860
1861 //add control to list of controls associated with source line
1862 pSrcLine->Controls[pSrcLine->cControls] = pctrl->dwControlID;
1863 pSrcLine->line.cControls++;
1864 pSrcLine->cControls++;
1865
1866 strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
1867 strncpy(pctrl->szName, szCtrlName[dwControl][1], sizeof(pctrl->szName));
1868
1869 //save internal id
1870 pmixctrl->id = dwControl;
1871 nrControls++;
1872 dprintf(("Adding control %s (%s)", pctrl->szName, pctrl->szShortName));
1873 return pctrl;
1874}
1875/******************************************************************************/
1876/******************************************************************************/
1877
Note: See TracBrowser for help on using the repository browser.