Context Navigation

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

Visit:

Last change on this file since 8508 was 8508, checked in by sandervl, 23 years ago
fixed wave recording; waveIn/OutOpen fixes for WAVE_FORMAT_QUERY flag
File size: 74.4 KB

Line
1	/* $Id: mixer.cpp,v 1.22 2002-05-28 14:09:24 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 %d (id %d)", 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 %d (%s)", 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 %d (id %d)", 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 \|\| lpMlc->cbmxctrl < pLine->cControls*sizeof(MIXERCONTROLA)) {
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, &pmixerLines[lpMlc->dwLineID]->Controls[i], 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.dwComponentType = pmxl->dwComponentType;
1157	line.dwDestination = pmxl->dwDestination;
1158	line.dwLineID = pmxl->dwLineID;
1159	line.dwSource = pmxl->dwSource;
1160	line.dwUser = pmxl->dwUser;
1161	line.fdwLine = pmxl->fdwLine;
1162	line.szName[0] = 0;
1163	line.szShortName[0] = 0;
1164	line.Target.dwDeviceID = pmxl->Target.dwDeviceID;
1165	line.Target.dwType = pmxl->Target.dwType;
1166	line.Target.vDriverVersion = pmxl->Target.vDriverVersion;
1167	line.Target.wMid = pmxl->Target.wMid;
1168	line.Target.wPid = pmxl->Target.wPid;
1169	//TODO: need to copy this?? (MIXER_GETLINEINFOF_TARGETTYPE)
1170	line.Target.szPname[0] = 0;
1171
1172	result = mixerGetLineInfoA(hmxobj, &line, fdwInfo);
1173	if(result != MMSYSERR_NOERROR) {
1174	return result;
1175	}
1176	pmxl->cbStruct = sizeof(MIXERLINEA);
1177	pmxl->cChannels = line.cChannels;
1178	pmxl->cConnections = line.cConnections;
1179	pmxl->dwComponentType = line.dwComponentType;
1180	pmxl->dwDestination = line.dwDestination;
1181	pmxl->dwLineID = line.dwLineID;
1182	pmxl->dwSource = line.dwSource;
1183	pmxl->dwUser = line.dwUser;
1184	pmxl->fdwLine = line.fdwLine;
1185	MultiByteToWideChar(CP_ACP, 0, line.szName, -1, pmxl->szName, sizeof(line.szName));
1186	MultiByteToWideChar(CP_ACP, 0, line.szShortName, -1, pmxl->szShortName, sizeof(line.szShortName));
1187	pmxl->Target.dwDeviceID = line.Target.dwDeviceID;
1188	pmxl->Target.dwType = line.Target.dwType;
1189	pmxl->Target.vDriverVersion = line.Target.vDriverVersion;
1190	pmxl->Target.wMid = line.Target.wMid;
1191	pmxl->Target.wPid = line.Target.wPid;
1192	pmxl->Target.szPname[0] = 0;
1193	MultiByteToWideChar(CP_ACP, 0, line.Target.szPname, -1, pmxl->Target.szPname, sizeof(line.Target.szPname));
1194	return MMSYSERR_NOERROR;
1195	}
1196	/******************************************************************************/
1197	/******************************************************************************/
1198	MMRESULT WINAPI mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
1199	{
1200	dprintf(("WINMM:mixerMessage - NOT IMPLEMENTED" ));
1201	return MMSYSERR_NOTSUPPORTED;
1202	}
1203	/******************************************************************************/
1204	/******************************************************************************/
1205	UINT WINAPI mixerGetNumDevs()
1206	{
1207	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1208	return 0;
1209	}
1210	return 1;
1211	}
1212	/******************************************************************************/
1213	/******************************************************************************/
1214	MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
1215	{
1216	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1217	return MMSYSERR_BADDEVICEID;
1218	}
1219
1220	if(uMxId > 0) {
1221	return MMSYSERR_BADDEVICEID;
1222	}
1223
1224	//According to MSDN, nothing is copied when cbmxcaps is zero
1225	if(cbmxcaps >= sizeof(MIXERCAPSA)) {
1226	pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1227	pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1228	pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1229	strncpy( pmxcaps->szPname, WINMM_MIXERSTRING_A, sizeof(pmxcaps->szPname)); /* product name */
1230
1231	pmxcaps->fdwSupport = 0; //no mixer flags exist
1232	pmxcaps->cDestinations = nrDestinations;
1233	dprintf(("mixerGetDevCapsA: cDestinations %d", pmxcaps->cDestinations));
1234	}
1235
1236	return MMSYSERR_NOERROR;
1237	}
1238	/******************************************************************************/
1239	/******************************************************************************/
1240	MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
1241	{
1242	if(fMMPMAvailable == FALSE \|\| DartWaveOut::getNumDevices() == 0) {
1243	return MMSYSERR_BADDEVICEID;
1244	}
1245
1246	if(uMxId > 0) {
1247	return MMSYSERR_BADDEVICEID;
1248	}
1249
1250	//According to MSDN, nothing is copied when cbmxcaps is zero
1251	if(cbmxcaps >= sizeof(MIXERCAPSW)) {
1252	pmxcaps->wMid = WINMM_MIXER_CAPS_WMID; /* manufacturer ID */
1253	pmxcaps->wPid = WINMM_MIXER_CAPS_WPID; /* product ID */
1254	pmxcaps->vDriverVersion = WINMM_MIXER_CAPS_VERSION; /* version of the driver */
1255	lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
1256
1257	pmxcaps->fdwSupport = 0; //no mixer flags exist
1258	pmxcaps->cDestinations = nrDestinations;
1259	dprintf(("mixerGetDevCapsW: cDestinations %d", pmxcaps->cDestinations));
1260	}
1261
1262	return MMSYSERR_NOERROR;
1263	}
1264	/******************************************************************************/
1265	/******************************************************************************/
1266	MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
1267	{
1268	switch(fdwId) {
1269	case MIXER_OBJECTF_MIXER:
1270	{
1271	DEVICE_STRUCT pMixInfo = (DEVICE_STRUCT )hmxobj;
1272	if(!pMixInfo) {
1273	if(puMxId) {
1274	*puMxId = -1;
1275	}
1276	return MMSYSERR_INVALHANDLE;
1277	}
1278	if(puMxId) {
1279	*puMxId = pMixInfo->uDeviceID;
1280	}
1281	break;
1282	}
1283
1284	case MIXER_OBJECTF_HMIXER:
1285	case MIXER_OBJECTF_WAVEOUT:
1286	case MIXER_OBJECTF_HWAVEOUT:
1287	case MIXER_OBJECTF_WAVEIN:
1288	case MIXER_OBJECTF_HWAVEIN:
1289	case MIXER_OBJECTF_MIDIOUT:
1290	case MIXER_OBJECTF_HMIDIOUT:
1291	case MIXER_OBJECTF_MIDIIN:
1292	case MIXER_OBJECTF_HMIDIIN:
1293	case MIXER_OBJECTF_AUX:
1294	//TODO: assume default mixer
1295	if(puMxId) {
1296	*puMxId = 0;
1297	}
1298	break;
1299	default:
1300	if(puMxId) {
1301	*puMxId = -1;
1302	}
1303	return MMSYSERR_INVALPARAM;
1304	}
1305	return MMSYSERR_NOERROR;
1306	}
1307	/******************************************************************************/
1308	/******************************************************************************/
1309	MMRESULT WINAPI mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance,
1310	DWORD fdwOpen)
1311	{
1312	DEVICE_STRUCT *pMixInfo;
1313
1314	if(DartWaveOut::getNumDevices() == 0) {
1315	if(phmx) *phmx = 0;
1316	return MMSYSERR_NODRIVER;
1317	}
1318	pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
1319	if(pMixInfo == NULL) {
1320	return MMSYSERR_NODRIVER;
1321	}
1322	pMixInfo->dwCallback = dwCallback;
1323	pMixInfo->dwDriverInstance = dwInstance;
1324	pMixInfo->dwFlags = fdwOpen;
1325	pMixInfo->uDeviceID = uMxId;
1326	pMixInfo->type = WINMM_MIXER;
1327	if(phmx)
1328	*phmx = (HMIXER)pMixInfo;
1329
1330	return MMSYSERR_NOERROR;
1331	}
1332	/******************************************************************************/
1333	/******************************************************************************/
1334	MMRESULT WINAPI mixerClose(HMIXER hmx)
1335	{
1336	if(hmx) {
1337	free((void *)hmx);
1338	}
1339	return MMSYSERR_NOERROR;
1340	}
1341	/******************************************************************************/
1342	/******************************************************************************/
1343	BOOL mixerInit()
1344	{
1345	MIXLINE *pDestLine;
1346	MIXERCONTROLA *pWaveInMux;
1347
1348	if(!fMMPMAvailable) return TRUE;
1349
1350	memset(mixerDest, 0, sizeof(mixerDest));
1351	for(int i=0;i<MIXER_DEST_MAX;i++) {
1352	memset(mixerDest[i].Connections, -1, sizeof(mixerDest[i].Connections));
1353	memset(mixerDest[i].Controls, -1, sizeof(mixerDest[i].Controls));
1354	}
1355	memset(mixerSource, 0, sizeof(mixerSource));
1356	for(i=0;i<MIXER_SRC_MAX;i++) {
1357	memset(mixerSource[i].Connections, -1, sizeof(mixerSource[i].Connections));
1358	memset(mixerSource[i].Controls, -1, sizeof(mixerSource[i].Controls));
1359	mixerSource[i].id = -1;
1360	}
1361	if(OSLibMixerOpen() == FALSE) {
1362	//Line out destination
1363	pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1364	mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1365	mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1366
1367	//WaveIn destination
1368	pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1369	pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1370	mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pDestLine);
1371	mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pDestLine);
1372	pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1373	return TRUE;
1374	}
1375
1376	//Line out destination
1377	pDestLine = mixerAddDestination(MIXER_DEST_LINEOUT);
1378
1379	mixerAddControl(MIX_CTRL_VOL_OUT_LINE, pDestLine);
1380	mixerAddControl(MIX_CTRL_MUTE_OUT_LINE, pDestLine);
1381	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DCENTER)) {
1382	mixerAddControl(MIX_CTRL_OUT_L_3DCENTER, pDestLine);
1383	}
1384	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DDEPTH)) {
1385	mixerAddControl(MIX_CTRL_OUT_L_3DDEPTH, pDestLine);
1386	}
1387	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_TREBLE)) {
1388	mixerAddControl(MIX_CTRL_OUT_L_TREBLE, pDestLine);
1389	}
1390	if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_BASS)) {
1391	mixerAddControl(MIX_CTRL_OUT_L_BASS, pDestLine);
1392	}
1393
1394	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PCM)) {
1395	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PCM);
1396	mixerAddControl(MIX_CTRL_VOL_IN_L_PCM, pLine);
1397	mixerAddControl(MIX_CTRL_MUTE_IN_L_PCM, pLine);
1398	}
1399	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_WAVETABLE)) {
1400	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_WAVETABLE);
1401	mixerAddControl(MIX_CTRL_VOL_IN_L_WAVETABLE, pLine);
1402	mixerAddControl(MIX_CTRL_MUTE_IN_L_WAVETABLE, pLine);
1403	}
1404	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIDI)) {
1405	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIDI);
1406	mixerAddControl(MIX_CTRL_VOL_IN_L_MIDI, pLine);
1407	mixerAddControl(MIX_CTRL_MUTE_IN_L_MIDI, pLine);
1408	}
1409	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIC)) {
1410	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MIC);
1411	mixerAddControl(MIX_CTRL_VOL_IN_L_MIC, pLine);
1412	mixerAddControl(MIX_CTRL_MUTE_IN_L_MIC, pLine);
1413	if(OSLibMixIsControlPresent(MIX_CTRL_BOOST_IN_L_MIC)) {
1414	mixerAddControl(MIX_CTRL_BOOST_IN_L_MIC, pLine);
1415	}
1416	}
1417	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_LINE)) {
1418	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_LINE);
1419	mixerAddControl(MIX_CTRL_VOL_IN_L_LINE, pLine);
1420	mixerAddControl(MIX_CTRL_MUTE_IN_L_LINE, pLine);
1421	}
1422	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_CD)) {
1423	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_CD);
1424	mixerAddControl(MIX_CTRL_VOL_IN_L_CD, pLine);
1425	mixerAddControl(MIX_CTRL_MUTE_IN_L_CD, pLine);
1426	}
1427	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_AUX)) {
1428	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_AUX);
1429	mixerAddControl(MIX_CTRL_VOL_IN_L_AUX, pLine);
1430	mixerAddControl(MIX_CTRL_MUTE_IN_L_AUX, pLine);
1431	}
1432	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_SPDIF)) {
1433	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_SPDIF);
1434	mixerAddControl(MIX_CTRL_VOL_IN_L_SPDIF, pLine);
1435	mixerAddControl(MIX_CTRL_MUTE_IN_L_SPDIF, pLine);
1436	}
1437	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MONO)) {
1438	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_MONOIN);
1439	mixerAddControl(MIX_CTRL_VOL_IN_L_MONO, pLine);
1440	mixerAddControl(MIX_CTRL_MUTE_IN_L_MONO, pLine);
1441	}
1442	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PHONE)) {
1443	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_PHONE);
1444	mixerAddControl(MIX_CTRL_VOL_IN_L_PHONE, pLine);
1445	mixerAddControl(MIX_CTRL_MUTE_IN_L_PHONE, pLine);
1446	}
1447	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_VIDEO)) {
1448	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_L_VIDEO);
1449	mixerAddControl(MIX_CTRL_VOL_IN_L_VIDEO, pLine);
1450	mixerAddControl(MIX_CTRL_MUTE_IN_L_VIDEO, pLine);
1451	}
1452
1453	//Wave In Destination
1454	if(OSLibMixIsControlPresent(MIX_CTRL_MUX_IN_W_SRC)) {
1455	pDestLine = mixerAddDestination(MIXER_DEST_WAVEIN);
1456	pWaveInMux = mixerAddControl(MIX_CTRL_MUX_IN_W_SRC, pDestLine);
1457
1458	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIC)) {
1459	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIC);
1460	mixerAddControl(MIX_CTRL_VOL_IN_W_MIC, pLine);
1461	}
1462	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_LINE)) {
1463	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_LINE);
1464	mixerAddControl(MIX_CTRL_VOL_IN_W_LINE, pLine);
1465	}
1466	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_CD)) {
1467	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_CD);
1468	mixerAddControl(MIX_CTRL_VOL_IN_W_CD, pLine);
1469	}
1470	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_AUX)) {
1471	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_AUX);
1472	mixerAddControl(MIX_CTRL_VOL_IN_W_AUX, pLine);
1473	}
1474	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PCM)) {
1475	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PCM);
1476	mixerAddControl(MIX_CTRL_VOL_IN_W_PCM, pLine);
1477	}
1478	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_WAVETABLE)) {
1479	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_WAVETABLE);
1480	mixerAddControl(MIX_CTRL_VOL_IN_W_WAVETABLE, pLine);
1481	}
1482	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MIDI)) {
1483	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MIDI);
1484	mixerAddControl(MIX_CTRL_VOL_IN_W_MIDI, pLine);
1485	}
1486	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOIN)) {
1487	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOIN);
1488	mixerAddControl(MIX_CTRL_VOL_IN_W_MONO, pLine);
1489	}
1490	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_PHONE)) {
1491	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_PHONE);
1492	mixerAddControl(MIX_CTRL_VOL_IN_W_PHONE, pLine);
1493	}
1494	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_SPDIF)) {
1495	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_SPDIF);
1496	mixerAddControl(MIX_CTRL_VOL_IN_W_SPDIF, pLine);
1497	}
1498	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_VIDEO)) {
1499	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_VIDEO);
1500	mixerAddControl(MIX_CTRL_VOL_IN_W_VIDEO, pLine);
1501	}
1502	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_STEREOMIX)) {
1503	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_STEREOMIX);
1504	mixerAddControl(MIX_CTRL_VOL_IN_W_STEREOMIX, pLine);
1505	}
1506	if(OSLibMixIsRecSourcePresent(MIXER_SRC_IN_W_MONOMIX)) {
1507	MIXLINE *pLine = mixerAddSource(pDestLine, MIXER_SRC_IN_W_MONOMIX);
1508	mixerAddControl(MIX_CTRL_VOL_IN_W_MONOMIX, pLine);
1509	}
1510	pWaveInMux->cMultipleItems = pDestLine->line.cConnections;
1511	pWaveInMux->Bounds.s.lMinimum = 0;
1512	pWaveInMux->Bounds.s.lMaximum = pDestLine->line.cConnections;
1513	pWaveInMux->Metrics.cSteps = pDestLine->line.cConnections;
1514	}
1515
1516	//SPDIF destination
1517	if(OSLibMixIsControlPresent(MIX_CTRL_VOL_OUT_SPDIF)) {
1518	pDestLine = mixerAddDestination(MIXER_DEST_SPDIFOUT);
1519	mixerAddControl(MIX_CTRL_VOL_OUT_SPDIF, pDestLine);
1520	mixerAddControl(MIX_CTRL_MUTE_OUT_SPDIF, pDestLine);
1521	}
1522
1523	return TRUE;
1524	}
1525	/******************************************************************************/
1526	/******************************************************************************/
1527	void mixerExit()
1528	{
1529	OSLibMixerClose();
1530	}
1531	/******************************************************************************/
1532	/******************************************************************************/
1533	static MIXLINE mixerAddSource(MIXLINE pDestLine, DWORD dwSource)
1534	{
1535	MIXLINE *pSource = &mixerSource[nrSources];
1536	MIXERLINEA *pline = &pSource->line;
1537
1538	if(nrSources >= MAX_MIXER_SOURCES) {
1539	dprintf(("ERROR: mixerAddSource: out of room!!!"));
1540	DebugInt3();
1541	return NULL;
1542	}
1543
1544	memset(pline, 0, sizeof(MIXERLINEA));
1545
1546	pline->cbStruct = sizeof(MIXERLINEA);
1547	pline->cConnections = 0;
1548	pline->cControls = 0;
1549	pline->dwDestination = 0;
1550	pline->fdwLine = MIXERLINE_LINEF_SOURCE;
1551	pline->Target.dwDeviceID = 0;
1552	pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1553	pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1554	pline->dwSource = nrSources;
1555	nrSources++;
1556
1557	switch(dwSource) {
1558	case MIXER_SRC_IN_L_MONOIN:
1559	case MIXER_SRC_IN_W_MONOIN:
1560	case MIXER_SRC_IN_L_PHONE:
1561	case MIXER_SRC_IN_W_PHONE:
1562	pline->cChannels = 1;
1563	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE;
1564	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1565	break;
1566
1567	case MIXER_SRC_IN_L_MIC:
1568	case MIXER_SRC_IN_W_MIC:
1569	pline->cChannels = 1;
1570	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
1571	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1572	break;
1573
1574	case MIXER_SRC_IN_L_LINE:
1575	case MIXER_SRC_IN_W_LINE:
1576	pline->cChannels = 2;
1577	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
1578	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1579	break;
1580
1581	case MIXER_SRC_IN_L_CD:
1582	case MIXER_SRC_IN_W_CD:
1583	pline->cChannels = 2;
1584	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
1585	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1586	break;
1587
1588	case MIXER_SRC_IN_L_SPDIF:
1589	case MIXER_SRC_IN_W_SPDIF:
1590	pline->cChannels = 2;
1591	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_DIGITAL;
1592	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1593	break;
1594
1595	case MIXER_SRC_IN_L_VIDEO:
1596	case MIXER_SRC_IN_W_VIDEO:
1597	pline->cChannels = 2;
1598	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
1599	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1600	break;
1601
1602	case MIXER_SRC_IN_L_AUX:
1603	case MIXER_SRC_IN_W_AUX:
1604	pline->cChannels = 2;
1605	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY;
1606	pline->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
1607	break;
1608
1609	case MIXER_SRC_IN_L_PCM:
1610	case MIXER_SRC_IN_W_PCM:
1611	pline->cChannels = 2;
1612	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
1613	pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
1614	break;
1615
1616	case MIXER_SRC_IN_L_WAVETABLE:
1617	case MIXER_SRC_IN_W_WAVETABLE:
1618	case MIXER_SRC_IN_L_MIDI:
1619	case MIXER_SRC_IN_W_MIDI:
1620	pline->cChannels = 2;
1621	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
1622	pline->Target.dwType = MIXERLINE_TARGETTYPE_MIDIOUT;
1623	break;
1624
1625	default:
1626	DebugInt3();
1627	return NULL;
1628	}
1629	strncpy(pline->szShortName, szSourceName[dwSource][0], sizeof(pline->szShortName));
1630	strncpy(pline->szName, szSourceName[dwSource][1], sizeof(pline->szName));
1631	strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1632
1633	//add to array of mixer line pointers
1634	pline->dwLineID = nrLines;
1635	pmixerLines[nrLines] = pSource;
1636	nrLines++;
1637
1638	//store line id in source to line mapping array
1639	pSource->id = dwSource;
1640
1641	//increase nr of inputs at destination line
1642	pDestLine->line.cConnections++;
1643	pDestLine->Connections[pDestLine->cConnections] = pline->dwLineID;
1644	pDestLine->cConnections++;
1645
1646	dprintf(("Adding Source %s (%s) with destination %s (%d -> %d)", pline->szName, pline->szShortName, pDestLine->line.szName, dwSource, pline->dwLineID));
1647
1648	return pSource;
1649	}
1650	/******************************************************************************/
1651	/******************************************************************************/
1652	static MIXLINE *mixerAddDestination(DWORD dwDest)
1653	{
1654	MIXLINE *pDest = &mixerDest[nrDestinations];
1655	MIXERLINEA *pline = &pDest->line;
1656
1657	if(nrDestinations >= MAX_MIXER_DESTINATIONS) {
1658	dprintf(("ERROR: mixerAddDestination: out of room!!!"));
1659	DebugInt3();
1660	return NULL;
1661	}
1662	memset(pline, 0, sizeof(MIXERLINEA));
1663	pline->cbStruct = sizeof(MIXERLINEA);
1664	pline->cConnections = 0;
1665	pline->cControls = 0;
1666	pline->dwSource = (DWORD)-1;
1667	pline->dwDestination = nrDestinations;
1668
1669	switch(dwDest) {
1670	case MIXER_DEST_LINEOUT:
1671	pline->cChannels = 2;
1672	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
1673	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1674	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1675	break;
1676
1677	case MIXER_DEST_SPDIFOUT:
1678	pline->cChannels = 2;
1679	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_DIGITAL;
1680	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1681	pline->Target.dwType = MIXERLINE_TARGETTYPE_UNDEFINED;
1682	break;
1683
1684	case MIXER_DEST_WAVEIN:
1685	pline->cChannels = 2;
1686	pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
1687	pline->fdwLine = MIXERLINE_LINEF_ACTIVE;
1688	pline->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
1689	break;
1690
1691	default:
1692	DebugInt3();
1693	return NULL;
1694	}
1695	strncpy(pline->szShortName, szDestName[dwDest][0], sizeof(pline->szShortName));
1696	strncpy(pline->szName, szDestName[dwDest][1], sizeof(pline->szName));
1697	strncpy(pline->Target.szPname, WINMM_MIXERSTRING_A, sizeof(pline->Target.szPname));
1698	pline->Target.dwDeviceID = 0;
1699	pline->Target.wMid = WINMM_MIXER_CAPS_WMID;
1700	pline->Target.wPid = WINMM_MIXER_CAPS_WPID;
1701	pline->Target.vDriverVersion = WINMM_MIXER_CAPS_VERSION;
1702
1703	dprintf(("Adding destination %s (%s) connections %d controls %d", pline->szName, pline->szShortName, pline->cConnections, pline->cControls));
1704	nrDestinations++;
1705
1706	pline->dwLineID = nrLines;
1707	pmixerLines[nrLines] = pDest;
1708	nrLines++;
1709
1710	//save internal id
1711	pDest->id = dwDest;
1712	return pDest;
1713	}
1714	/******************************************************************************/
1715	/******************************************************************************/
1716	static MIXERCONTROLA * mixerAddControl(DWORD dwControl, MIXLINE *pSrcLine)
1717	{
1718	MIXCONTROL *pmixctrl = &mixerControls[nrControls];
1719	MIXERCONTROLA *pctrl = &pmixctrl->ctrl;
1720
1721	if(nrControls >= MAX_MIXER_CONTROLS) {
1722	dprintf(("ERROR: mixerAddControl: out of room!!!"));
1723	DebugInt3();
1724	return NULL;
1725	}
1726
1727	memset(pctrl, 0, sizeof(MIXERCONTROLA));
1728	pctrl->cbStruct = sizeof(MIXERCONTROLA);
1729	pctrl->cMultipleItems = 0;
1730	pctrl->dwControlID = nrControls;
1731	pctrl->fdwControl = 0;
1732	switch(dwControl) {
1733	case MIX_CTRL_MUX_IN_W_SRC:
1734	pctrl->fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE \| MIXERCONTROL_CONTROLF_UNIFORM;
1735	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;
1736	pctrl->Bounds.s.lMinimum = 0;
1737	pctrl->Bounds.s.lMaximum = 1;
1738	pctrl->Metrics.cSteps = 1;
1739	pctrl->cMultipleItems = 0; //to be filled in later (see caller)
1740	break;
1741
1742	case MIX_CTRL_VOL_OUT_LINE:
1743	case MIX_CTRL_VOL_IN_L_MONO:
1744	case MIX_CTRL_VOL_IN_L_PHONE:
1745	case MIX_CTRL_VOL_IN_L_MIC:
1746	case MIX_CTRL_VOL_IN_L_LINE:
1747	case MIX_CTRL_VOL_IN_L_CD:
1748	case MIX_CTRL_VOL_IN_L_SPDIF:
1749	case MIX_CTRL_VOL_IN_L_VIDEO:
1750	case MIX_CTRL_VOL_IN_L_AUX:
1751	case MIX_CTRL_VOL_IN_L_PCM:
1752	case MIX_CTRL_VOL_IN_L_WAVETABLE:
1753	case MIX_CTRL_VOL_IN_L_MIDI:
1754	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1755	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1756	break;
1757
1758	case MIX_CTRL_VOL_IN_W_MONO:
1759	case MIX_CTRL_VOL_IN_W_PHONE:
1760	case MIX_CTRL_VOL_IN_W_MIC:
1761	case MIX_CTRL_VOL_IN_W_LINE:
1762	case MIX_CTRL_VOL_IN_W_CD:
1763	case MIX_CTRL_VOL_IN_W_SPDIF:
1764	case MIX_CTRL_VOL_IN_W_VIDEO:
1765	case MIX_CTRL_VOL_IN_W_AUX:
1766	case MIX_CTRL_VOL_IN_W_PCM:
1767	case MIX_CTRL_VOL_IN_W_WAVETABLE:
1768	case MIX_CTRL_VOL_IN_W_MIDI:
1769	case MIX_CTRL_VOL_IN_W_STEREOMIX:
1770	case MIX_CTRL_VOL_IN_W_MONOMIX:
1771	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1772	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1773	break;
1774
1775	case MIX_CTRL_MUTE_OUT_LINE:
1776	case MIX_CTRL_MUTE_IN_L_MONO:
1777	case MIX_CTRL_MUTE_IN_L_PHONE:
1778	case MIX_CTRL_MUTE_IN_L_MIC:
1779	case MIX_CTRL_MUTE_IN_L_LINE:
1780	case MIX_CTRL_MUTE_IN_L_CD:
1781	case MIX_CTRL_MUTE_IN_L_SPDIF:
1782	case MIX_CTRL_MUTE_IN_L_VIDEO:
1783	case MIX_CTRL_MUTE_IN_L_AUX:
1784	case MIX_CTRL_MUTE_IN_L_PCM:
1785	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1786	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1787	pctrl->Bounds.s.lMinimum = 0;
1788	pctrl->Bounds.s.lMaximum = 1;
1789	pctrl->Metrics.cSteps = 0;
1790	break;
1791
1792	case MIX_CTRL_VOL_OUT_SPDIF:
1793	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
1794	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1795	break;
1796
1797	case MIX_CTRL_MUTE_OUT_SPDIF:
1798	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1799	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
1800	pctrl->Bounds.s.lMinimum = 0;
1801	pctrl->Bounds.s.lMaximum = 1;
1802	pctrl->Metrics.cSteps = 0;
1803	break;
1804
1805	case MIX_CTRL_BOOST_IN_L_MIC:
1806	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1807	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_ONOFF;
1808	pctrl->Bounds.s.lMinimum = 0;
1809	pctrl->Bounds.s.lMaximum = 1;
1810	pctrl->Metrics.cSteps = 0;
1811	break;
1812
1813	case MIX_CTRL_OUT_L_3DDEPTH:
1814	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1815	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1816	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1817	break;
1818
1819	case MIX_CTRL_OUT_L_3DCENTER:
1820	pctrl->fdwControl = MIXERCONTROL_CONTROLF_UNIFORM;
1821	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_FADER;
1822	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1823	break;
1824
1825	case MIX_CTRL_OUT_L_TREBLE:
1826	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_TREBLE;
1827	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1828	break;
1829
1830	case MIX_CTRL_OUT_L_BASS:
1831	pctrl->dwControlType = MIXERCONTROL_CONTROLTYPE_BASS;
1832	OSLibMixGetCtrlCaps(dwControl, &pctrl->Bounds.s.lMinimum, &pctrl->Bounds.s.lMaximum, &pctrl->Metrics.cSteps);
1833	break;
1834
1835	default:
1836	DebugInt3();
1837	return FALSE;
1838	}
1839
1840	//add control to list of controls associated with source line
1841	pSrcLine->Controls[pSrcLine->cControls] = pctrl->dwControlID;
1842	pSrcLine->cControls++;
1843
1844	strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
1845	strncpy(pctrl->szName, szCtrlName[dwControl][1], sizeof(pctrl->szName));
1846
1847	//save internal id
1848	pmixctrl->id = dwControl;
1849	nrControls++;
1850	dprintf(("Adding control %s (%s)", pctrl->szName, pctrl->szShortName));
1851	return pctrl;
1852	}
1853	/******************************************************************************/
1854	/******************************************************************************/
1855

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

Download in other formats: