Context Navigation

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

Visit:

Last change on this file since 8530 was 8530, checked in by sandervl, 23 years ago
mixer fixes
File size: 74.6 KB

Line
1	/* $Id: mixer.cpp,v 1.25 2002-05-30 14:31:07 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 "initwinmm.h"
37	#include "mixer.h"
38	#include "mixeros2.h"
39
40	#define DBG_LOCALLOG DBG_mixer
41	#include "dbglocal.h"
42
43	static MIXERCONTROLA mixerAddControl(DWORD dwControl, MIXLINE pSrcLine);
44	static MIXLINE mixerAddSource(MIXLINE pDestLine, DWORD dwSource);
45	static MIXLINE *mixerAddDestination(DWORD dwDest);
46
47	//array of destination mixer lines
48	static MIXLINE mixerDest[MAX_MIXER_DESTINATIONS] = {0};
49	//array of source mixer lines
50	static MIXLINE mixerSource[MAX_MIXER_SOURCES] = {0};
51	//array of all mixer lines
52	static MIXLINE *pmixerLines[MAX_MIXER_LINES] = {NULL};
53	//array of all mixer controls
54	static MIXCONTROL mixerControls[MAX_MIXER_CONTROLS] = {0};
55
56	static int nrDestinations = 0;
57	static int nrSources = 0;
58	static int nrControls = 0;
59	static int nrLines = 0;
60
61	/******************************************************************************/
62	/******************************************************************************/
63	MMRESULT 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	/******************************************************************************/
385	MMRESULT 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	/******************************************************************************/
441	MMRESULT 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	return MMSYSERR_NOERROR;
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	return MMSYSERR_NOERROR;
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	return MMSYSERR_NOERROR;
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	return MMSYSERR_NOERROR;
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	}
681	/******************************************************************************/
682	/******************************************************************************/
683	MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
684	{
685	DWORD dwRet = MMSYSERR_NOERROR;
686	DWORD lineID, controlType;
687	DEVICE_STRUCT pMixInfo = (DEVICE_STRUCT )hmxobj;
688
689	if((fdwControls & 0xF0000000) == MIXER_OBJECTF_HMIXER) {
690	if(!pMixInfo) {
691	return MMSYSERR_INVALHANDLE;
692	}
693	}
694	else
695	if((fdwControls & 0xF0000000) == MIXER_OBJECTF_MIXER) {
696	if(!HIWORD(hmxobj) && hmxobj > 0) {
697	return MMSYSERR_NODRIVER;
698	}
699	}
700
701	if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
702
703	if (lpMlc->cbStruct < sizeof(*lpMlc) \|\| lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
704	return MMSYSERR_INVALPARAM;
705
706	switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)
707	{
708	case MIXER_GETLINECONTROLSF_ALL:
709	{
710	MIXERLINEA *pLine;
711	MIXERCONTROLA *pCtrl;
712
713	dprintf(("MIXER_GETLINECONTROLSF_ALL for line %d", lpMlc->dwLineID));
714	if(lpMlc->dwLineID >= nrLines) {
715	dprintf(("ERROR: Invalid line %d", lpMlc->dwLineID));
716	return MIXERR_INVALLINE;
717	}
718	pLine = &pmixerLines[lpMlc->dwLineID]->line;
719	if(lpMlc->cControls != pLine->cControls) {
720	dprintf(("ERROR: invalid nr of controls %d or structure size %d (%d) (ptr %x)", lpMlc->cControls, lpMlc->cbmxctrl, pLine->cControls*sizeof(MIXERCONTROLA), lpMlc->pamxctrl));
721	return MMSYSERR_INVALPARAM;
722	}
723	for(int i=0;i<lpMlc->cControls;i++) {
724	pCtrl = lpMlc->pamxctrl+i;
725	memcpy(pCtrl, &mixerControls[pmixerLines[lpMlc->dwLineID]->Controls[i]].ctrl, sizeof(MIXERCONTROLA));
726	dprintf(("found control %s (%s) control id %d", pCtrl->szName, pCtrl->szShortName, pCtrl->dwControlID));
727	}
728	break;
729	}
730
731	case MIXER_GETLINECONTROLSF_ONEBYID:
732	{
733	dprintf(("MIXER_GETLINECONTROLSF_ONEBYID %x", lpMlc->u.dwControlID));
734	if(lpMlc->cControls != 1 \|\| lpMlc->cbmxctrl != sizeof(MIXERCONTROLA)) {
735	dprintf(("invalid parameters"));
736	return MMSYSERR_INVALPARAM;
737	}
738	if(lpMlc->u.dwControlID >= nrControls) {
739	dprintf(("invalid control"));
740	return MIXERR_INVALCONTROL;
741	}
742	//find line associated with this control
743	lpMlc->dwLineID = -1;
744	for(int i=0;i<nrLines;i++) {
745	for(int j=0;j<pmixerLines[i]->cControls;j++) {
746	if(pmixerLines[i]->Controls[j] == lpMlc->u.dwControlID) {
747	lpMlc->dwLineID = i;
748	break;
749	}
750	else
751	if(pmixerLines[i]->Controls[j] == -1) {
752	break;
753	}
754	}
755	if(lpMlc->dwLineID != -1) {
756	break;
757	}
758	}
759	if(i == MAX_MIXER_LINES) {
760	dprintf(("Associated line for control %d NOT FOUND", lpMlc->u.dwControlID));
761	return MIXERR_INVALCONTROL;
762	}
763	memcpy(lpMlc->pamxctrl, &mixerControls[lpMlc->u.dwControlID].ctrl, sizeof(MIXERCONTROLA));
764
765	dprintf(("found control %s (%s) associated line %d", lpMlc->pamxctrl->szName, lpMlc->pamxctrl->szShortName, lpMlc->dwLineID));
766	break;
767	}
768
769	case MIXER_GETLINECONTROLSF_ONEBYTYPE:
770	{
771	dprintf(("MIXER_GETLINECONTROLSF_ONEBYTYPE %x %d", lpMlc->u.dwControlType, lpMlc->dwLineID));
772	if(lpMlc->dwLineID >= nrLines) {
773	dprintf(("ERROR: Invalid line %d", lpMlc->dwLineID));
774	return MIXERR_INVALLINE;
775	}
776	#ifdef DEBUG
777	switch (lpMlc->u.dwControlType) {
778	case MIXERCONTROL_CONTROLTYPE_CUSTOM:
779	dprintf(("MIXERCONTROL_CONTROLTYPE_CUSTOM"));
780	break;
781	case MIXERCONTROL_CONTROLTYPE_BOOLEANMETER:
782	dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEANMETER"));
783	break;
784	case MIXERCONTROL_CONTROLTYPE_SIGNEDMETER:
785	dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNEDMETER"));
786	break;
787	case MIXERCONTROL_CONTROLTYPE_PEAKMETER:
788	dprintf(("MIXERCONTROL_CONTROLTYPE_PEAKMETER"));
789	break;
790	case MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER:
791	dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER"));
792	break;
793	case MIXERCONTROL_CONTROLTYPE_BOOLEAN:
794	dprintf(("MIXERCONTROL_CONTROLTYPE_BOOLEAN"));
795	break;
796	case MIXERCONTROL_CONTROLTYPE_ONOFF:
797	dprintf(("MIXERCONTROL_CONTROLTYPE_ONOFF"));
798	break;
799	case MIXERCONTROL_CONTROLTYPE_MUTE:
800	dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
801	break;
802	case MIXERCONTROL_CONTROLTYPE_MONO:
803	dprintf(("MIXERCONTROL_CONTROLTYPE_MONO"));
804	break;
805	case MIXERCONTROL_CONTROLTYPE_LOUDNESS:
806	dprintf(("MIXERCONTROL_CONTROLTYPE_LOUDNESS"));
807	break;
808	case MIXERCONTROL_CONTROLTYPE_STEREOENH:
809	dprintf(("MIXERCONTROL_CONTROLTYPE_STEREOENH"));
810	break;
811	case MIXERCONTROL_CONTROLTYPE_BUTTON:
812	dprintf(("MIXERCONTROL_CONTROLTYPE_BUTTON"));
813	break;
814	case MIXERCONTROL_CONTROLTYPE_DECIBELS:
815	dprintf(("MIXERCONTROL_CONTROLTYPE_DECIBELS"));
816	break;
817	case MIXERCONTROL_CONTROLTYPE_SIGNED:
818	dprintf(("MIXERCONTROL_CONTROLTYPE_SIGNED"));
819	break;
820	case MIXERCONTROL_CONTROLTYPE_UNSIGNED:
821	dprintf(("MIXERCONTROL_CONTROLTYPE_UNSIGNED"));
822	break;
823	case MIXERCONTROL_CONTROLTYPE_PERCENT:
824	dprintf(("MIXERCONTROL_CONTROLTYPE_PERCENT"));
825	break;
826	case MIXERCONTROL_CONTROLTYPE_SLIDER:
827	dprintf(("MIXERCONTROL_CONTROLTYPE_SLIDER"));
828	break;
829	case MIXERCONTROL_CONTROLTYPE_PAN:
830	dprintf(("MIXERCONTROL_CONTROLTYPE_PAN"));
831	break;
832	case MIXERCONTROL_CONTROLTYPE_QSOUNDPAN:
833	dprintf(("MIXERCONTROL_CONTROLTYPE_QSOUNDPAN"));
834	break;
835	case MIXERCONTROL_CONTROLTYPE_FADER:
836	dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
837	break;
838	case MIXERCONTROL_CONTROLTYPE_VOLUME:
839	dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
840	break;
841	case MIXERCONTROL_CONTROLTYPE_BASS:
842	dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
843	break;
844	case MIXERCONTROL_CONTROLTYPE_TREBLE:
845	dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
846	break;
847	case MIXERCONTROL_CONTROLTYPE_EQUALIZER:
848	dprintf(("MIXERCONTROL_CONTROLTYPE_EQUALIZER"));
849	break;
850	case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
851	dprintf(("MIXERCONTROL_CONTROLTYPE_SINGLESELECT"));
852	break;
853	case MIXERCONTROL_CONTROLTYPE_MUX:
854	dprintf(("MIXERCONTROL_CONTROLTYPE_MUX"));
855	break;
856	case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
857	dprintf(("MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT"));
858	break;
859	case MIXERCONTROL_CONTROLTYPE_MIXER:
860	dprintf(("MIXERCONTROL_CONTROLTYPE_MIXER"));
861	break;
862	case MIXERCONTROL_CONTROLTYPE_MICROTIME:
863	dprintf(("MIXERCONTROL_CONTROLTYPE_MICROTIME"));
864	break;
865	case MIXERCONTROL_CONTROLTYPE_MILLITIME:
866	dprintf(("MIXERCONTROL_CONTROLTYPE_MILLITIME"));
867	break;
868	default:
869	return MMSYSERR_INVALPARAM;
870	}
871	#endif
872	int idx;
873
874	for(int i=0;i<pmixerLines[lpMlc->dwLineID]->cControls;i++) {
875	idx = pmixerLines[lpMlc->dwLineID]->Controls[i];
876	if(mixerControls[idx].ctrl.dwControlType == lpMlc->u.dwControlType) {
877	memcpy(lpMlc->pamxctrl, &mixerControls[idx].ctrl, sizeof(MIXERCONTROLA));
878	dprintf(("found control %s (%s) control id %d", lpMlc->pamxctrl->szName, lpMlc->pamxctrl->szShortName, lpMlc->pamxctrl->dwControlID));
879	return MMSYSERR_NOERROR;
880	}
881
882	}
883	return MIXERR_INVALLINE; //returned by win2k when type not found
884	}
885	default:
886	dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
887	dwRet = MMSYSERR_INVALPARAM;
888	break;
889	}
890
891	return dwRet;
892	}
893	/******************************************************************************/
894	/******************************************************************************/
895	MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW lpmlcW, DWORD fdwControls)
896	{
897	MIXERLINECONTROLSA mlcA;
898	DWORD ret;
899	int i;
900
901	if (lpmlcW == NULL \|\| lpmlcW->cbStruct != sizeof(*lpmlcW) \|\| lpmlcW->cbmxctrl != sizeof(MIXERCONTROLW))
902	return MMSYSERR_INVALPARAM;
903
904	mlcA.cbStruct = sizeof(mlcA);
905	mlcA.dwLineID = lpmlcW->dwLineID;
906	mlcA.u.dwControlID = lpmlcW->u.dwControlID;
907	mlcA.u.dwControlType = lpmlcW->u.dwControlType;
908	mlcA.cControls = lpmlcW->cControls;
909	mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
910	mlcA.pamxctrl = (MIXERCONTROLA )HeapAlloc(GetProcessHeap(), 0, mlcA.cControls mlcA.cbmxctrl);
911
912	ret = mixerGetLineControlsA(hmxobj, &mlcA, fdwControls);
913
914	if (ret == MMSYSERR_NOERROR) {
915	lpmlcW->dwLineID = mlcA.dwLineID;
916	lpmlcW->u.dwControlID = mlcA.u.dwControlID;
917	lpmlcW->u.dwControlType = mlcA.u.dwControlType;
918	lpmlcW->cControls = mlcA.cControls;
919
920	for (i = 0; i < mlcA.cControls; i++) {
921	lpmlcW->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLW);
922	lpmlcW->pamxctrl[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
923	lpmlcW->pamxctrl[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
924	lpmlcW->pamxctrl[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
925	lpmlcW->pamxctrl[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
926	MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szShortName, -1,
927	lpmlcW->pamxctrl[i].szShortName,
928	sizeof(lpmlcW->pamxctrl[i].szShortName)/sizeof(WCHAR) );
929	MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szName, -1,
930	lpmlcW->pamxctrl[i].szName,
931	sizeof(lpmlcW->pamxctrl[i].szName)/sizeof(WCHAR) );
932	/* sizeof(lpmlcW->pamxctrl[i].Bounds) ==
933	* sizeof(mlcA.pamxctrl[i].Bounds) */
934	memcpy(&lpmlcW->pamxctrl[i].Bounds, &mlcA.pamxctrl[i].Bounds,
935	sizeof(mlcA.pamxctrl[i].Bounds));
936	/* sizeof(lpmlcW->pamxctrl[i].Metrics) ==
937	* sizeof(mlcA.pamxctrl[i].Metrics) */
938	memcpy(&lpmlcW->pamxctrl[i].Metrics, &mlcA.pamxctrl[i].Metrics,
939	sizeof(mlcA.pamxctrl[i].Metrics));
940	}
941	}
942
943	HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
944	return ret;
945	}
946	/******************************************************************************/
947	/******************************************************************************/
948	MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA lpMl, DWORD fdwInfo)
949	{
950	DEVICE_STRUCT pMixInfo = (DEVICE_STRUCT )hmxobj;
951
952	if((fdwInfo & 0xF0000000) == MIXER_OBJECTF_HMIXER) {
953	if(!pMixInfo) {
954	return MMSYSERR_INVALHANDLE;
955	}
956	}
957	else
958	if((fdwInfo & 0xF0000000) == MIXER_OBJECTF_MIXER) {
959	if(!HIWORD(hmxobj) && hmxobj > 0) {
960	return MMSYSERR_NODRIVER;
961	}
962	}
963
964	if (lpMl == NULL \|\| lpMl->cbStruct != sizeof(*lpMl)) {
965	dprintf(("ERROR: mixerGetLineInfoA: invalid paramter!!"));
966	return MMSYSERR_INVALPARAM;
967	}
968
969	switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
970	{
971	case MIXER_GETLINEINFOF_DESTINATION:
972	dprintf(("MIXER_GETLINEINFOF_DESTINATION %d", lpMl->dwDestination));
973	if(lpMl->dwDestination >= nrDestinations) {
974	dprintf(("ERROR: Invalid destination %d", lpMl->dwDestination));
975	return MMSYSERR_INVALPARAM;
976	}
977	memcpy(lpMl, &mixerDest[lpMl->dwDestination].line, sizeof(MIXERLINEA));
978	dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
979	break;
980
981	case MIXER_GETLINEINFOF_LINEID:
982	dprintf(("MIXER_GETLINEINFOF_LINEID %d", lpMl->dwLineID));
983	if(lpMl->dwLineID >= nrLines) {
984	dprintf(("ERROR: Invalid line %d", lpMl->dwLineID));
985	return MIXERR_INVALLINE;
986	}
987	memcpy(lpMl, &pmixerLines[lpMl->dwLineID]->line, sizeof(MIXERLINEA));
988	dprintf(("found line %s (%s) connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->cConnections, lpMl->cControls));
989	break;
990
991	case MIXER_GETLINEINFOF_SOURCE:
992	dprintf(("MIXER_GETLINEINFOF_SOURCE %d %d", lpMl->dwDestination, lpMl->dwSource));
993	if(lpMl->dwDestination >= nrDestinations) {
994	dprintf(("ERROR: Invalid destination %d", lpMl->dwDestination));
995	return MIXERR_INVALLINE;
996	}
997	if(lpMl->dwSource >= MIXER_SRC_MAX) {
998	dprintf(("ERROR: Invalid source %d", lpMl->dwSource));
999	return MIXERR_INVALLINE;
1000	}
1001	if(mixerDest[lpMl->dwDestination].Connections[lpMl->dwSource] == -1) {
1002	dprintf(("ERROR: Invalid destination/source combo (%d,%d)", lpMl->dwDestination, lpMl->dwSource));
1003	return MIXERR_INVALLINE;
1004	}
1005	memcpy(lpMl, &pmixerLines[mixerDest[lpMl->dwDestination].Connections[lpMl->dwSource]]->line, sizeof(MIXERLINEA));
1006	dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1007	break;
1008
1009	case MIXER_GETLINEINFOF_COMPONENTTYPE:
1010	{
1011	dprintf(("MIXER_GETLINEINFOF_COMPONENTTYPE"));
1012	#ifdef DEBUG
1013	switch (lpMl->dwComponentType)
1014	{
1015	case MIXERLINE_COMPONENTTYPE_DST_UNDEFINED:
1016	dprintf(("MIXERLINE_COMPONENTTYPE_DST_UNDEFINED"));
1017	break;
1018	case MIXERLINE_COMPONENTTYPE_DST_DIGITAL:
1019	dprintf(("MIXERLINE_COMPONENTTYPE_DST_DIGITAL"));
1020	break;
1021	case MIXERLINE_COMPONENTTYPE_DST_LINE:
1022	dprintf(("MIXERLINE_COMPONENTTYPE_DST_LINE"));
1023	break;
1024	case MIXERLINE_COMPONENTTYPE_DST_MONITOR:
1025	dprintf(("MIXERLINE_COMPONENTTYPE_DST_MONITOR"));
1026	break;
1027	case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
1028	dprintf(("MIXERLINE_COMPONENTTYPE_DST_SPEAKERS"));
1029	break;
1030	case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES:
1031	dprintf(("MIXERLINE_COMPONENTTYPE_DST_HEADPHONES"));
1032	break;
1033	case MIXERLINE_COMPONENTTYPE_DST_TELEPHONE:
1034	dprintf(("MIXERLINE_COMPONENTTYPE_DST_TELEPHONE"));
1035	break;
1036	case MIXERLINE_COMPONENTTYPE_DST_WAVEIN:
1037	dprintf(("MIXERLINE_COMPONENTTYPE_DST_WAVEIN"));
1038	break;
1039	case MIXERLINE_COMPONENTTYPE_DST_VOICEIN:
1040	dprintf(("MIXERLINE_COMPONENTTYPE_DST_VOICEIN"));
1041	break;
1042	case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED:
1043	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED"));
1044	break;
1045	case MIXERLINE_COMPONENTTYPE_SRC_DIGITAL:
1046	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_DIGITAL"));
1047	break;
1048	case MIXERLINE_COMPONENTTYPE_SRC_LINE:
1049	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_LINE"));
1050	break;
1051	case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE:
1052	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE"));
1053	break;
1054	case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER:
1055	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER"));
1056	break;
1057	case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC:
1058	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC"));
1059	break;
1060	case MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE:
1061	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE"));
1062	break;
1063	case MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER:
1064	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER"));
1065	break;
1066	case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
1067	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT"));
1068	break;
1069	case MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY:
1070	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY"));
1071	break;
1072	case MIXERLINE_COMPONENTTYPE_SRC_ANALOG:
1073	dprintf(("MIXERLINE_COMPONENTTYPE_SRC_ANALOG"));
1074	break;
1075	default:
1076	dprintf(("Unhandled component type (%08lx)\n", lpMl->dwComponentType));
1077	return MMSYSERR_INVALPARAM;
1078	}
1079	#endif
1080	//search all lines (src & dest) for one with specified type
1081	for(int i=0;i<nrLines;i++) {
1082	if(pmixerLines[i]->line.dwComponentType == lpMl->dwComponentType) {
1083	break;
1084	}
1085	}
1086	if(i == nrLines) {
1087	dprintf(("Component type %d not found!!", lpMl->dwComponentType));
1088	return MIXERR_INVALLINE;
1089	}
1090	memcpy(lpMl, &pmixerLines[i]->line, sizeof(MIXERLINEA));
1091	dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1092	break;
1093	}
1094	case MIXER_GETLINEINFOF_TARGETTYPE:
1095	{
1096	dprintf(("MIXER_GETLINEINFOF_TARGETTYPE %x", lpMl->Target.dwType));
1097	#ifdef DEBUG
1098	switch(lpMl->Target.dwType) {
1099	case MIXERLINE_TARGETTYPE_UNDEFINED:
1100	dprintf(("MIXERLINE_TARGETTYPE_UNDEFINED"));
1101	break;
1102	case MIXERLINE_TARGETTYPE_WAVEOUT:
1103	dprintf(("MIXERLINE_TARGETTYPE_WAVEOUT"));
1104	break;
1105	case MIXERLINE_TARGETTYPE_WAVEIN:
1106	dprintf(("MIXERLINE_TARGETTYPE_WAVEIN"));
1107	break;
1108	case MIXERLINE_TARGETTYPE_MIDIOUT:
1109	dprintf(("MIXERLINE_TARGETTYPE_MIDIOUT"));
1110	break;
1111	case MIXERLINE_TARGETTYPE_MIDIIN:
1112	dprintf(("MIXERLINE_TARGETTYPE_MIDIIN"));
1113	break;
1114	case MIXERLINE_TARGETTYPE_AUX:
1115	dprintf(("MIXERLINE_TARGETTYPE_AUX"));
1116	break;
1117	default:
1118	dprintf(("Unhandled target type (%08lx)\n", lpMl->Target.dwType));
1119	return MMSYSERR_INVALPARAM;
1120	}
1121	#endif
1122	//search all lines (src & dest) for one with specified type
1123	//TODO: Should we compare mid, pid & pddname too? (must be initialized according to MSDN)
1124	// (see below; unicode version doesn't copy pddname; change if these checks are required)
1125	for(int i=0;i<nrLines;i++) {
1126	if(pmixerLines[i]->line.Target.dwType == lpMl->Target.dwType) {
1127	break;
1128	}
1129	}
1130	if(i == nrLines) {
1131	dprintf(("Component type %d not found!!", lpMl->Target.dwType));
1132	return MIXERR_INVALLINE;
1133	}
1134	memcpy(lpMl, &pmixerLines[i]->line, sizeof(MIXERLINEA));
1135	dprintf(("found line %s (%s) id %d connections %d controls %d", lpMl->szName, lpMl->szShortName, lpMl->dwLineID, lpMl->cConnections, lpMl->cControls));
1136	break;
1137	}
1138	default:
1139	dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
1140	return MMSYSERR_INVALPARAM;
1141	break;
1142	}
1143	return MMSYSERR_NOERROR;
1144	}
1145	/******************************************************************************/
1146	/******************************************************************************/
1147	MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
1148	{
1149	DEVICE_STRUCT pMixInfo = (DEVICE_STRUCT )hmxobj;
1150	MIXERLINEA line;
1151	MMRESULT result;
1152
1153	line.cbStruct = sizeof(MIXERLINEA);
1154	line.cChannels = pmxl->cChannels;
1155	line.cConnections = pmxl->cConnections;
1156	line.cControls = pmxl->cControls;
1157	line.dwComponentType = pmxl->dwComponentType;
1158	line.dwDestination = pmxl->dwDestination;
1159	line.dwLineID = pmxl->dwLineID;
1160	line.dwSource = pmxl->dwSource;
1161	line.dwUser = pmxl->dwUser;
1162	line.fdwLine = pmxl->fdwLine;
1163	line.szName[0] = 0;
1164	line.szShortName[0] = 0;
1165	line.Target.dwDeviceID = pmxl->Target.dwDeviceID;
1166	line.Target.dwType = pmxl->Target.dwType;
1167	line.Target.vDriverVersion = pmxl->Target.vDriverVersion;
1168	line.Target.wMid = pmxl->Target.wMid;
1169	line.Target.wPid = pmxl->Target.wPid;
1170	//TODO: need to copy this?? (MIXER_GETLINEINFOF_TARGETTYPE)
1171	line.Target.szPname[0] = 0;
1172
1173	result = mixerGetLineInfoA(hmxobj, &line, fdwInfo);
1174	if(result != MMSYSERR_NOERROR) {
1175	return result;
1176	}
1177	pmxl->cbStruct = sizeof(MIXERLINEA);
1178	pmxl->cChannels = line.cChannels;
1179	pmxl->cConnections = line.cConnections;
1180	pmxl->cControls = line.cControls;
1181	pmxl->dwComponentType = line.dwComponentType;
1182	pmxl->dwDestination = line.dwDestination;
1183	pmxl->dwLineID = line.dwLineID;
1184	pmxl->dwSource = line.dwSource;
1185	pmxl->dwUser = line.dwUser;
1186	pmxl->fdwLine = line.fdwLine;
1187	MultiByteToWideChar(CP_ACP, 0, line.szName, -1, pmxl->szName, sizeof(line.szName));
1188	MultiByteToWideChar(CP_ACP, 0, line.szShortName, -1, pmxl->szShortName, sizeof(line.szShortName));
1189	pmxl->Target.dwDeviceID = line.Target.dwDeviceID;
1190	pmxl->Target.dwType = line.Target.dwType;
1191	pmxl->Target.vDriverVersion = line.Target.vDriverVersion;
1192	pmxl->Target.wMid = line.Target.wMid;
1193	pmxl->Target.wPid = line.Target.wPid;
1194	pmxl->Target.szPname[0] = 0;
1195	MultiByteToWideChar(CP_ACP, 0, line.Target.szPname, -1, pmxl->Target.szPname, sizeof(line.Target.szPname));
1196	return MMSYSERR_NOERROR;
1197	}
1198	/******************************************************************************/
1199	/******************************************************************************/
1200	MMRESULT WINAPI mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
1201	{
1202	dprintf(("WINMM:mixerMessage - NOT IMPLEMENTED" ));
1203	return MMSYSERR_NOTSUPPORTED;
1204	}
1205	/******************************************************************************/
1206	/******************************************************************************/
1207	UINT WINAPI mixerGetNumDevs()
1208	{
1209	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1210	return 0;
1211	}
1212	return 1;
1213	}
1214	/******************************************************************************/
1215	/******************************************************************************/
1216	MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
1217	{
1218	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1219	return MMSYSERR_BADDEVICEID;
1220	}
1221
1222	if(uMxId > 0) {
1223	return MMSYSERR_BADDEVICEID;
1224	}
1225
1226	//According to MSDN, nothing is copied when cbmxcaps is zero
1227	if(cbmxcaps >= sizeof(MIXERCAPSA)) {
1228	pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1229	pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1230	pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1231	strncpy( pmxcaps->szPname, WINMM_MIXERSTRING_A, sizeof(pmxcaps->szPname)); /* product name */
1232
1233	pmxcaps->fdwSupport = 0; //no mixer flags exist
1234	pmxcaps->cDestinations = nrDestinations;
1235	dprintf(("mixerGetDevCapsA: cDestinations %d", pmxcaps->cDestinations));
1236	}
1237
1238	return MMSYSERR_NOERROR;
1239	}
1240	/******************************************************************************/
1241	/******************************************************************************/
1242	MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
1243	{
1244	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1245	return MMSYSERR_BADDEVICEID;
1246	}
1247
1248	if(uMxId > 0) {
1249	return MMSYSERR_BADDEVICEID;
1250	}
1251
1252	//According to MSDN, nothing is copied when cbmxcaps is zero
1253	if(cbmxcaps >= sizeof(MIXERCAPSW)) {
1254	pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1255	pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1256	pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1257	lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
1258
1259	pmxcaps->fdwSupport = 0; //no mixer flags exist
1260	pmxcaps->cDestinations = nrDestinations;
1261	dprintf(("mixerGetDevCapsW: cDestinations %d", pmxcaps->cDestinations));
1262	}
1263
1264	return MMSYSERR_NOERROR;
1265	}
1266	/******************************************************************************/
1267	/******************************************************************************/
1268	MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
1269	{
1270	switch(fdwId) {
1271	case MIXER_OBJECTF_MIXER:
1272	{
1273	DEVICE_STRUCT pMixInfo = (DEVICE_STRUCT )hmxobj;
1274	if(!pMixInfo) {
1275	if(puMxId) {
1276	*puMxId = -1;
1277	}
1278	return MMSYSERR_INVALHANDLE;
1279	}
1280	if(puMxId) {
1281	*puMxId = pMixInfo->uDeviceID;
1282	}
1283	break;
1284	}
1285
1286	case MIXER_OBJECTF_HMIXER:
1287	case MIXER_OBJECTF_WAVEOUT:
1288	case MIXER_OBJECTF_HWAVEOUT:
1289	case MIXER_OBJECTF_WAVEIN:
1290	case MIXER_OBJECTF_HWAVEIN:
1291	case MIXER_OBJECTF_MIDIOUT:
1292	case MIXER_OBJECTF_HMIDIOUT:
1293	case MIXER_OBJECTF_MIDIIN:
1294	case MIXER_OBJECTF_HMIDIIN:
1295	case MIXER_OBJECTF_AUX:
1296	//TODO: assume default mixer
1297	if(puMxId) {
1298	*puMxId = 0;
1299	}
1300	break;
1301	default:
1302	if(puMxId) {
1303	*puMxId = -1;
1304	}
1305	return MMSYSERR_INVALPARAM;
1306	}
1307	return MMSYSERR_NOERROR;
1308	}
1309	/******************************************************************************/
1310	/******************************************************************************/
1311	MMRESULT WINAPI mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance,
1312	DWORD fdwOpen)
1313	{
1314	DEVICE_STRUCT *pMixInfo;
1315
1316	if(DartWaveOut::getNumDevices() == 0) {
1317	if(phmx) *phmx = 0;
1318	return MMSYSERR_NODRIVER;
1319	}
1320	pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
1321	if(pMixInfo == NULL) {
1322	return MMSYSERR_NODRIVER;
1323	}
1324	pMixInfo->dwCallback = dwCallback;
1325	pMixInfo->dwDriverInstance = dwInstance;
1326	pMixInfo->dwFlags = fdwOpen;
1327	pMixInfo->uDeviceID = uMxId;
1328	pMixInfo->type = WINMM_MIXER;
1329	if(phmx)
1330	*phmx = (HMIXER)pMixInfo;
1331
1332	return MMSYSERR_NOERROR;
1333	}
1334	/******************************************************************************/
1335	/******************************************************************************/
1336	MMRESULT WINAPI mixerClose(HMIXER hmx)
1337	{
1338	if(hmx) {
1339	free((void *)hmx);
1340	}
1341	return MMSYSERR_NOERROR;
1342	}
1343	/******************************************************************************/
1344	/******************************************************************************/
1345	BOOL mixerInit()
1346	{
1347	MIXLINE *pDestLine;
1348	MIXERCONTROLA *pWaveInMux;
1349
1350	if(!fMMPMAvailable) return TRUE;
1351
1352	memset(mixerDest, 0, sizeof(mixerDest));
1353	for(int i=0;i<MIXER_DEST_MAX;i++) {
1354	memset(mixerDest[i].Connections, -1, sizeof(mixerDest[i].Connections));
1355	memset(mixerDest[i].Controls, -1, sizeof(mixerDest[i].Controls));
1356	}
1357	memset(mixerSource, 0, sizeof(mixerSource));
1358	for(i=0;i<MIXER_SRC_MAX;i++) {
1359	memset(mixerSource[i].Connections, -1, sizeof(mixerSource[i].Connections));
1360	memset(mixerSource[i].Controls, -1, sizeof(mixerSource[i].Controls));
1361	mixerSource[i].id = -1;
1362	}
1363	if(OSLibMixerOpen() == FALSE) {
1364	//Line out destination
1365	pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1366	mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1367	mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1368
1369	//WaveIn destination
1370	pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1371	pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1372	mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pDestLine);
1373	mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pDestLine);
1374	pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1375	return TRUE;
1376	}
1377
1378	//Line out destination
1379	pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1380
1381	mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1382	mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1383	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DCENTER)) {
1384	mixerAddControl(MIX_CTRL_OUT_L_3DCENTER, pDestLine);
1385	}
1386	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DDEPTH)) {
1387	mixerAddControl(MIX_CTRL_OUT_L_3DDEPTH, pDestLine);
1388	}
1389	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_TREBLE)) {
1390	mixerAddControl(MIX_CTRL_OUT_L_TREBLE, pDestLine);
1391	}
1392	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_BASS)) {
1393	mixerAddControl(MIX_CTRL_OUT_L_BASS, pDestLine);
1394	}
1395
1396	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PCM)) {
1397	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PCM);
1398	mixerAddControl(MIX_CTRL_VOL_IN_L_PCM, pLine);
1399	mixerAddControl(MIX_CTRL_MUTE_IN_L_PCM, pLine);
1400	}
1401	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_WAVETABLE)) {
1402	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_WAVETABLE);
1403	mixerAddControl(MIX_CTRL_VOL_IN_L_WAVETABLE, pLine);
1404	mixerAddControl(MIX_CTRL_MUTE_IN_L_WAVETABLE, pLine);
1405	}
1406	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIDI)) {
1407	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIDI);
1408	mixerAddControl(MIX_CTRL_VOL_IN_L_MIDI, pLine);
1409	mixerAddControl(MIX_CTRL_MUTE_IN_L_MIDI, pLine);
1410	}
1411	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIC)) {
1412	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIC);
1413	mixerAddControl(MIX_CTRL_VOL_IN_L_MIC, pLine);
1414	mixerAddControl(MIX_CTRL_MUTE_IN_L_MIC, pLine);
1415	if(OSLibMixIsControlPresent(MIX_CTRL_BOOST_IN_L_MIC)) {
1416	mixerAddControl(MIX_CTRL_BOOST_IN_L_MIC, pLine);
1417	}
1418	}
1419	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_LINE)) {
1420	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_LINE);
1421	mixerAddControl(MIX_CTRL_VOL_IN_L_LINE, pLine);
1422	mixerAddControl(MIX_CTRL_MUTE_IN_L_LINE, pLine);
1423	}
1424	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_CD)) {
1425	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_CD);
1426	mixerAddControl(MIX_CTRL_VOL_IN_L_CD, pLine);
1427	mixerAddControl(MIX_CTRL_MUTE_IN_L_CD, pLine);
1428	}
1429	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_AUX)) {
1430	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_AUX);
1431	mixerAddControl(MIX_CTRL_VOL_IN_L_AUX, pLine);
1432	mixerAddControl(MIX_CTRL_MUTE_IN_L_AUX, pLine);
1433	}
1434	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_SPDIF)) {
1435	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_SPDIF);
1436	mixerAddControl(MIX_CTRL_VOL_IN_L_SPDIF, pLine);
1437	mixerAddControl(MIX_CTRL_MUTE_IN_L_SPDIF, pLine);
1438	}
1439	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MONO)) {
1440	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MONOIN);
1441	mixerAddControl(MIX_CTRL_VOL_IN_L_MONO, pLine);
1442	mixerAddControl(MIX_CTRL_MUTE_IN_L_MONO, pLine);
1443	}
1444	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PHONE)) {
1445	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PHONE);
1446	mixerAddControl(MIX_CTRL_VOL_IN_L_PHONE, pLine);
1447	mixerAddControl(MIX_CTRL_MUTE_IN_L_PHONE, pLine);
1448	}
1449	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_VIDEO)) {
1450	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_VIDEO);
1451	mixerAddControl(MIX_CTRL_VOL_IN_L_VIDEO, pLine);
1452	mixerAddControl(MIX_CTRL_MUTE_IN_L_VIDEO, pLine);
1453	}
1454
1455	//Wave In Destination
1456	if(OSLibMixIsControlPresent(MIX_CTRL_MUX_IN_W_SRC)) {
1457	pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1458	pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1459
1460	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIC)) {
1461	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIC);
1462	mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pLine);
1463	}
1464	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_LINE)) {
1465	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_LINE);
1466	mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pLine);
1467	}
1468	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_CD)) {
1469	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_CD);
1470	mixerAddControl(MIX_CTRL_VOL_IN_W_CD, pLine);
1471	}
1472	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_AUX)) {
1473	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_AUX);
1474	mixerAddControl(MIX_CTRL_VOL_IN_W_AUX, pLine);
1475	}
1476	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PCM)) {
1477	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PCM);
1478	mixerAddControl(MIX_CTRL_VOL_IN_W_PCM, pLine);
1479	}
1480	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_WAVETABLE)) {
1481	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_WAVETABLE);
1482	mixerAddControl(MIX_CTRL_VOL_IN_W_WAVETABLE, pLine);
1483	}
1484	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIDI)) {
1485	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIDI);
1486	mixerAddControl(MIX_CTRL_VOL_IN_W_MIDI, pLine);
1487	}
1488	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOIN)) {
1489	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOIN);
1490	mixerAddControl(MIX_CTRL_VOL_IN_W_MONO, pLine);
1491	}
1492	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PHONE)) {
1493	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PHONE);
1494	mixerAddControl(MIX_CTRL_VOL_IN_W_PHONE, pLine);
1495	}
1496	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_SPDIF)) {
1497	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_SPDIF);
1498	mixerAddControl(MIX_CTRL_VOL_IN_W_SPDIF, pLine);
1499	}
1500	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_VIDEO)) {
1501	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_VIDEO);
1502	mixerAddControl(MIX_CTRL_VOL_IN_W_VIDEO, pLine);
1503	}
1504	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_STEREOMIX)) {
1505	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_STEREOMIX);
1506	mixerAddControl(MIX_CTRL_VOL_IN_W_STEREOMIX, pLine);
1507	}
1508	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOMIX)) {
1509	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOMIX);
1510	mixerAddControl(MIX_CTRL_VOL_IN_W_MONOMIX, pLine);
1511	}
1512	pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1513	pWaveInMux->Bounds.s.lMinimum = 0;
1514	pWaveInMux->Bounds.s.lMaximum = pDestLine->line.cConnections;
1515	pWaveInMux->Metrics.cSteps = pDestLine->line.cConnections;
1516	}
1517
1518	//SPDIF destination
1519	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_OUT_SPDIF)) {
1520	pDestLine = mixerAddDestination(MIXER_DEST_SPDIFOUT);
1521	mixerAddControl(MIX_CTRL_VOL_OUT_SPDIF, pDestLine);
1522	mixerAddControl(MIX_CTRL_MUTE_OUT_SPDIF, pDestLine);
1523	}
1524
1525	return TRUE;
1526	}
1527	/******************************************************************************/
1528	/******************************************************************************/
1529	void mixerExit()
1530	{
1531	OSLibMixerClose();
1532	}
1533	/******************************************************************************/
1534	/******************************************************************************/
1535	static MIXLINE mixerAddSource(MIXLINE pDestLine, DWORD dwSource)
1536	{
1537	MIXLINE *pSource = &mixerSource[nrSources];
1538	MIXERLINEA *pline = &pSource->line;
1539
1540	if(nrSources >= MAX_MIXER_SOURCES) {
1541	dprintf(("ERROR: mixerAddSource: out of room!!!"));
1542	DebugInt3();
1543	return NULL;
1544	}
1545
1546	memset(pline, 0, sizeof(MIXERLINEA));
1547
1548	pline->cbStruct = sizeof(MIXERLINEA);
1549	pline->cConnections = 0;
1550	pline->cControls = 0;
1551	pline->dwDestination = 0;
1552	pline->fdwLine = MIXERLINE_LINEF_SOURCE;
1553	pline->Target.dwDeviceID = 0;
1554	pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1555	pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1556	pline->dwSource = nrSources;
1557	nrSources++;
1558
1559	switch(dwSource) {
1560	case MIXER_SRC_IN_L_MONOIN:
1561	case MIXER_SRC_IN_W_MONOIN:
1562	case MIXER_SRC_IN_L_PHONE:
1563	case MIXER_SRC_IN_W_PHONE:
1564	pline->cChannels = 1;
1565	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE;
1566	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1567	break;
1568
1569	case MIXER_SRC_IN_L_MIC:
1570	case MIXER_SRC_IN_W_MIC:
1571	pline->cChannels = 1;
1572	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
1573	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1574	break;
1575
1576	case MIXER_SRC_IN_L_LINE:
1577	case MIXER_SRC_IN_W_LINE:
1578	pline->cChannels = 2;
1579	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
1580	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1581	break;
1582
1583	case MIXER_SRC_IN_L_CD:
1584	case MIXER_SRC_IN_W_CD:
1585	pline->cChannels = 2;
1586	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
1587	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1588	break;
1589
1590	case MIXER_SRC_IN_L_SPDIF:
1591	case MIXER_SRC_IN_W_SPDIF:
1592	pline->cChannels = 2;
1593	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_DIGITAL;
1594	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1595	break;
1596
1597	case MIXER_SRC_IN_L_VIDEO:
1598	case MIXER_SRC_IN_W_VIDEO:
1599	pline->cChannels = 2;
1600	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
1601	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1602	break;
1603
1604	case MIXER_SRC_IN_L_AUX:
1605	case MIXER_SRC_IN_W_AUX:
1606	pline->cChannels = 2;
1607	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY;
1608	pline->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
1609	break;
1610
1611	case MIXER_SRC_IN_L_PCM:
1612	case MIXER_SRC_IN_W_PCM:
1613	pline->cChannels = 2;
1614	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
1615	pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
1616	break;
1617
1618	case MIXER_SRC_IN_L_WAVETABLE:
1619	case MIXER_SRC_IN_W_WAVETABLE:
1620	case MIXER_SRC_IN_L_MIDI:
1621	case MIXER_SRC_IN_W_MIDI:
1622	pline->cChannels = 2;
1623	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
1624	pline->Target.dwType = MIXERLINE_TARGETTYPE_MIDIOUT;
1625	break;
1626
1627	default:
1628	DebugInt3();
1629	return NULL;
1630	}
1631	strncpy(pline->szShortName, szSourceName[dwSource][0], sizeof(pline->szShortName));
1632	strncpy(pline->szName, szSourceName[dwSource][1], sizeof(pline->szName));
1633	strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1634
1635	//add to array of mixer line pointers
1636	pline->dwLineID = nrLines;
1637	pmixerLines[nrLines] = pSource;
1638	nrLines++;
1639
1640	//store line id in source to line mapping array
1641	pSource->id = dwSource;
1642
1643	//increase nr of inputs at destination line
1644	pDestLine->line.cConnections++;
1645	pDestLine->Connections[pDestLine->cConnections] = pline->dwLineID;
1646	pDestLine->cConnections++;
1647
1648	dprintf(("Adding Source %s (%s) with destination %s (%d -> %d)", pline->szName, pline->szShortName, pDestLine->line.szName, dwSource, pline->dwLineID));
1649
1650	return pSource;
1651	}
1652	/******************************************************************************/
1653	/******************************************************************************/
1654	static MIXLINE *mixerAddDestination(DWORD dwDest)
1655	{
1656	MIXLINE *pDest = &mixerDest[nrDestinations];
1657	MIXERLINEA *pline = &pDest->line;
1658
1659	if(nrDestinations >= MAX_MIXER_DESTINATIONS) {
1660	dprintf(("ERROR: mixerAddDestination: out of room!!!"));
1661	DebugInt3();
1662	return NULL;
1663	}
1664	memset(pline, 0, sizeof(MIXERLINEA));
1665	pline->cbStruct = sizeof(MIXERLINEA);
1666	pline->cConnections = 0;
1667	pline->cControls = 0;
1668	pline->dwSource = (DWORD)-1;
1669	pline->dwDestination = nrDestinations;
1670
1671	switch(dwDest) {
1672	case MIXER_DEST_LINEOUT:
1673	pline->cChannels = 2;
1674	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
1675	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1676	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1677	break;
1678
1679	case MIXER_DEST_SPDIFOUT:
1680	pline->cChannels = 2;
1681	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_DIGITAL;
1682	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1683	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1684	break;
1685
1686	case MIXER_DEST_WAVEIN:
1687	pline->cChannels = 2;
1688	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
1689	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1690	pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
1691	break;
1692
1693	default:
1694	DebugInt3();
1695	return NULL;
1696	}
1697	strncpy(pline->szShortName, szDestName[dwDest][0], sizeof(pline->szShortName));
1698	strncpy(pline->szName, szDestName[dwDest][1], sizeof(pline->szName));
1699	strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1700	pline->Target.dwDeviceID = 0;
1701	pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1702	pline->Target.wPid = WINMM_MIXER_CAPS_WPID;
1703	pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1704
1705	dprintf(("Adding destination %s (%s) connections %d controls %d", pline->szName, pline->szShortName, pline->cConnections, pline->cControls));
1706	nrDestinations++;
1707
1708	pline->dwLineID = nrLines;
1709	pmixerLines[nrLines] = pDest;
1710	nrLines++;
1711
1712	//save internal id
1713	pDest->id = dwDest;
1714	return pDest;
1715	}
1716	/******************************************************************************/
1717	/******************************************************************************/
1718	static MIXERCONTROLA * mixerAddControl(DWORD dwControl, MIXLINE *pSrcLine)
1719	{
1720	MIXCONTROL *pmixctrl = &mixerControls[nrControls];
1721	MIXERCONTROLA *pctrl = &pmixctrl->ctrl;
1722
1723	if(nrControls >= MAX_MIXER_CONTROLS) {
1724	dprintf(("ERROR: mixerAddControl: out of room!!!"));
1725	DebugInt3();
1726	return NULL;
1727	}
1728
1729	memset(pctrl, 0, sizeof(MIXERCONTROLA));
1730	pctrl->cbStruct = sizeof(MIXERCONTROLA);
1731	pctrl->cMultipleItems = 0;
1732	pctrl->dwControlID = nrControls;
1733	pctrl->fdwControl = 0;
1734	switch(dwControl) {
1735	case MIX_CTRL_MUX_IN_W_SRC:
1736	pctrl->fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE \| MIXERCONTROL_CONTROLF_UNIFORM;
1737	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;
1738	pctrl->Bounds.s.lMinimum = 0;
1739	pctrl->Bounds.s.lMaximum = 1;
1740	pctrl->Metrics.cSteps = 1;
1741	pctrl->cMultipleItems = 0; //to be filled in later (see caller)
1742	break;
1743
1744	case MIX_CTRL_VOL_OUT_LINE:
1745	case MIX_CTRL_VOL_IN_L_MONO:
1746	case MIX_CTRL_VOL_IN_L_PHONE:
1747	case MIX_CTRL_VOL_IN_L_MIC:
1748	case MIX_CTRL_VOL_IN_L_LINE:
1749	case MIX_CTRL_VOL_IN_L_CD:
1750	case MIX_CTRL_VOL_IN_L_SPDIF:
1751	case MIX_CTRL_VOL_IN_L_VIDEO:
1752	case MIX_CTRL_VOL_IN_L_AUX:
1753	case MIX_CTRL_VOL_IN_L_PCM:
1754	case MIX_CTRL_VOL_IN_L_WAVETABLE:
1755	case MIX_CTRL_VOL_IN_L_MIDI:
1756	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1757	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1758	break;
1759
1760	case MIX_CTRL_VOL_IN_W_MONO:
1761	case MIX_CTRL_VOL_IN_W_PHONE:
1762	case MIX_CTRL_VOL_IN_W_MIC:
1763	case MIX_CTRL_VOL_IN_W_LINE:
1764	case MIX_CTRL_VOL_IN_W_CD:
1765	case MIX_CTRL_VOL_IN_W_SPDIF:
1766	case MIX_CTRL_VOL_IN_W_VIDEO:
1767	case MIX_CTRL_VOL_IN_W_AUX:
1768	case MIX_CTRL_VOL_IN_W_PCM:
1769	case MIX_CTRL_VOL_IN_W_WAVETABLE:
1770	case MIX_CTRL_VOL_IN_W_MIDI:
1771	case MIX_CTRL_VOL_IN_W_STEREOMIX:
1772	case MIX_CTRL_VOL_IN_W_MONOMIX:
1773	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1774	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1775	break;
1776
1777	case MIX_CTRL_MUTE_OUT_LINE:
1778	case MIX_CTRL_MUTE_IN_L_MONO:
1779	case MIX_CTRL_MUTE_IN_L_PHONE:
1780	case MIX_CTRL_MUTE_IN_L_MIC:
1781	case MIX_CTRL_MUTE_IN_L_LINE:
1782	case MIX_CTRL_MUTE_IN_L_CD:
1783	case MIX_CTRL_MUTE_IN_L_SPDIF:
1784	case MIX_CTRL_MUTE_IN_L_VIDEO:
1785	case MIX_CTRL_MUTE_IN_L_AUX:
1786	case MIX_CTRL_MUTE_IN_L_PCM:
1787	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1788	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1789	pctrl->Bounds.s.lMinimum = 0;
1790	pctrl->Bounds.s.lMaximum = 1;
1791	pctrl->Metrics.cSteps = 0;
1792	break;
1793
1794	case MIX_CTRL_VOL_OUT_SPDIF:
1795	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1796	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1797	break;
1798
1799	case MIX_CTRL_MUTE_OUT_SPDIF:
1800	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1801	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1802	pctrl->Bounds.s.lMinimum = 0;
1803	pctrl->Bounds.s.lMaximum = 1;
1804	pctrl->Metrics.cSteps = 0;
1805	break;
1806
1807	case MIX_CTRL_BOOST_IN_L_MIC:
1808	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1809	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_ONOFF;
1810	pctrl->Bounds.s.lMinimum = 0;
1811	pctrl->Bounds.s.lMaximum = 1;
1812	pctrl->Metrics.cSteps = 0;
1813	break;
1814
1815	case MIX_CTRL_OUT_L_3DDEPTH:
1816	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1817	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1818	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1819	break;
1820
1821	case MIX_CTRL_OUT_L_3DCENTER:
1822	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1823	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1824	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1825	break;
1826
1827	case MIX_CTRL_OUT_L_TREBLE:
1828	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_TREBLE;
1829	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1830	break;
1831
1832	case MIX_CTRL_OUT_L_BASS:
1833	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_BASS;
1834	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1835	break;
1836
1837	default:
1838	DebugInt3();
1839	return FALSE;
1840	}
1841
1842	//add control to list of controls associated with source line
1843	pSrcLine->Controls[pSrcLine->cControls] = pctrl->dwControlID;
1844	pSrcLine->line.cControls++;
1845	pSrcLine->cControls++;
1846
1847	strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
1848	strncpy(pctrl->szName, szCtrlName[dwControl][1], sizeof(pctrl->szName));
1849
1850	//save internal id
1851	pmixctrl->id = dwControl;
1852	nrControls++;
1853	dprintf(("Adding control %s (%s)", pctrl->szName, pctrl->szShortName));
1854	return pctrl;
1855	}
1856	/******************************************************************************/
1857	/******************************************************************************/
1858

Note: See TracBrowser for help on using the repository browser.

Download in other formats: