Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

mixer.cpp

Visit:

Last change on this file was 21916, checked in by dmik, 14 years ago
Merge branch gcc-kmk to trunk.
File size: 75.2 KB

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

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

Context Navigation

source: trunk/src/winmm/mixer.cpp

Download in other formats: