haiku.git

// ****************************************************************************
//
//		CEchoGals_mixer.cpp
//
//		Implementation file for the CEchoGals driver class (mixer functions).
//		Set editor tabs to 3 for your viewing pleasure.
//
// ----------------------------------------------------------------------------
//
// This file is part of Echo Digital Audio's generic driver library.
// Copyright Echo Digital Audio Corporation (c) 1998 - 2005
// All rights reserved
// www.echoaudio.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// ****************************************************************************

#include "CEchoGals.h"

#undef ECHO_DEBUGPRINTF
#define ECHO_DEBUGPRINTF(x)

/****************************************************************************

	CEchoGals mixer client management

 ****************************************************************************/

//===========================================================================
//
// Open the mixer - create a mixer client structure for this client and 
// return the cookie.  The cookie uniquely identifies this client to the 
// mixer driver. 
//
// Valid cookies are non-zero.  If you get a zero cookie, the open failed
// somehow.
//
// Clients can change mixer controls without calling OpenMixer first; it just
// means that they can't track control changes made by other clients.
//
//===========================================================================

ECHOSTATUS CEchoGals::OpenMixer(NUINT &Cookie)
{
	ECHO_MIXER_CLIENT *pTemp;

	if (m_fMixerDisabled)
		return ECHOSTATUS_MIXER_DISABLED;

	//
	// If the cookie is non-zero, then use the specified value
	//
	if (0 != Cookie)
	{
		pTemp = m_pMixerClients;
		while (pTemp != NULL)
		{
			if (Cookie == pTemp->Cookie)
			{
				ECHO_DEBUGPRINTF(("CEchoGals::OpenMixer - cookie 0x%lx already in use\n",
										Cookie));
				return ECHOSTATUS_BAD_COOKIE;
			}
			
			pTemp = pTemp->pNext;
		}
	}
	else
	{
		//
		// Make a new cookie
		//
		ULONGLONG ullTime;

		m_pOsSupport->OsGetSystemTime(&ullTime);
		Cookie = (NUINT) ullTime;
		if (0 == Cookie)
			Cookie = 1;
		
		//
		// Look through the existing mixer client list to ensure that this
		// cookie is unique.
		//
		pTemp = m_pMixerClients;
		while (pTemp != NULL)
		{
			if (Cookie == pTemp->Cookie)
			{
				//
				// Oops, someone is already using this cookie.  Increment 
				// the new cookie and try again.
				//
				Cookie++;
				pTemp = m_pMixerClients;			
			}
		
			pTemp = pTemp->pNext;
		}
		
	}
	

	//
	// Allocate the mixer client structure
	//
	ECHO_MIXER_CLIENT *pClient = NULL;
	ECHOSTATUS			Status;
	
	Status = OsAllocateNonPaged(sizeof(ECHO_MIXER_CLIENT),(void **) &pClient);
	if (NULL == pClient)
	{
		Cookie = 0;
		return Status;		
	}

	
	//
	// Store the new cookie and the new mixer client
	//
	pClient->Cookie = Cookie;
	pClient->pNext = m_pMixerClients;
	m_pMixerClients = pClient;
	
	return ECHOSTATUS_OK;
	
}	// OpenMixer


//===========================================================================
//
// Find a mixer client that matches a cookie
//
//===========================================================================

ECHO_MIXER_CLIENT *CEchoGals::GetMixerClient(NUINT Cookie)
{
	ECHO_MIXER_CLIENT *pTemp;
	
	pTemp = m_pMixerClients;
	while (NULL != pTemp)
	{
		if (Cookie == pTemp->Cookie)
			break;
			
		pTemp = pTemp->pNext;
	}
	
	return pTemp;
	
}	// GetMixerClient


//===========================================================================
//
// Close the mixer - free the mixer client structure
//
//===========================================================================

ECHOSTATUS CEchoGals::CloseMixer(NUINT Cookie)
{
	//
	//	Search the linked list and remove the client that matches the cookie
	// 
	ECHO_MIXER_CLIENT *pTemp;
	
	pTemp = m_pMixerClients;
	if (NULL == pTemp)
		return ECHOSTATUS_BAD_COOKIE;
		
	//
	// Head of the list?
	//		
	if (pTemp->Cookie == Cookie)
	{
		m_pMixerClients = pTemp->pNext;
		OsFreeNonPaged(pTemp);
		
		return ECHOSTATUS_OK;
	}
		
	//
	// Not the head of the list; search the list
	//
	while (NULL != pTemp->pNext)
	{
		if (Cookie == pTemp->pNext->Cookie)
		{
			ECHO_MIXER_CLIENT *pDeadClient;
			
			pDeadClient = pTemp->pNext;
			pTemp->pNext = pDeadClient->pNext;
			OsFreeNonPaged(pDeadClient);
			
			return ECHOSTATUS_OK;
		}
			
		pTemp = pTemp->pNext;
	}

	//
	// No soup for you!
	//
	return ECHOSTATUS_BAD_COOKIE;

} // CloseMixer	


//===========================================================================
//
// IsMixerOpen - returns true if at least one client has the mixer open
//
//===========================================================================

BOOL CEchoGals::IsMixerOpen()
{
	if (NULL == m_pMixerClients)
		return FALSE;
		
	return TRUE;
	
}	// IsMixerOpen


//===========================================================================
//
// This function is called when a mixer control changes; add the change
//	to the queue for each client.
//
// Here's what the wCh1 and wCh2 parameters represent, based on the wType
// parameter:
//
// wType				wCh1				wCh2
// -----				----				----
// ECHO_BUS_OUT	Output bus		Ignored
// ECHO_BUS_IN		Input bus		Ignored
// ECHO_PIPE_OUT	Output pipe		Output bus
// ECHO_MONITOR	Input bus		Output bus
//
// ECHO_PIPE_IN is not used right now.
//
//===========================================================================

ECHOSTATUS CEchoGals::MixerControlChanged
(
	WORD	wType,		// One of the ECHO_CHANNEL_TYPES
	WORD  wParameter, // One of the MXN_* values
	WORD 	wCh1,			// Depends on the wType value
	WORD  wCh2			// Also depends on wType value
)
{
	ECHO_MIXER_CLIENT *pClient = m_pMixerClients;
	PMIXER_NOTIFY		pNotify;
	
	if (m_fMixerDisabled)
		return ECHOSTATUS_MIXER_DISABLED;
	
	//
	// Go through all the clients and store this control change
	//
	while (NULL != pClient)
	{
		//
		// Search the circular buffer for this client and see if 
		// this control change is already stored
		//
		DWORD				dwIndex,dwCount;
		BOOL				fFound;
		
		dwCount = pClient->dwCount;
		dwIndex = pClient->dwTail;
		fFound = FALSE;
		while (dwCount > 0)
		{
			pNotify = pClient->Notifies + dwIndex;
			if (	(pNotify->wType == wType) &&
					(pNotify->wParameter == wParameter) &&
					(pNotify->u.wPipeOut == wCh1) && 	// can use any union member her
					(pNotify->wBusOut == wCh2))
			{
				//
				// Found this notify already in the circular buffer 
				//
				fFound = TRUE;
				break;
			}
			dwIndex++;
			dwIndex &= MAX_MIXER_NOTIFIES - 1;
			dwCount--;
		}
		
		//
		// If the notify was not found, add this notify to the circular buffer if 
		// there is enough room.
		//
		if ( 	(FALSE == fFound) &&
				(pClient->dwCount != MAX_MIXER_NOTIFIES))
		{
			pNotify = pClient->Notifies + pClient->dwHead;
			
			pNotify->wType 		= wType;
			pNotify->wParameter 	= wParameter;
			
			if (ECHO_BUS_OUT == wType)
			{
				pNotify->u.wPipeOut = ECHO_CHANNEL_UNUSED;
				pNotify->wBusOut = wCh1;
			}
			else
			{
				pNotify->u.wPipeOut	= wCh1;		// can use any union member here also
				pNotify->wBusOut	= wCh2;
			}
			
			pClient->dwCount += 1;
			pClient->dwHead = (pClient->dwHead + 1) & (MAX_MIXER_NOTIFIES - 1);
		}
		
		pClient = pClient->pNext;
	}
	
	return ECHOSTATUS_OK;
	
}	// MixerControlChanged


//===========================================================================
//
// This method is called when a client wants to know what controls have 
// changed.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetControlChanges
(
	PMIXER_MULTI_NOTIFY	pNotifies,
	NUINT	MixerCookie
)
{
	//
	// Match the cookie
	//
	ECHO_MIXER_CLIENT *pClient = GetMixerClient(MixerCookie);
	
	if (NULL == pClient)
	{
		pNotifies->dwCount = 0;
		return ECHOSTATUS_BAD_COOKIE;		
	}
	
	//
	// Copy mixer notifies
	//
	PMIXER_NOTIFY	pDest,pSrc;
	DWORD				dwNumClientNotifies,dwNumReturned;
	
	dwNumClientNotifies = pNotifies->dwCount;
	pDest = pNotifies->Notifies;
	dwNumReturned = 0;
	while ( (dwNumClientNotifies > 0) && (pClient->dwCount > 0))
	{
		pSrc = pClient->Notifies + pClient->dwTail;
	
		OsCopyMemory(pDest,pSrc,sizeof(MIXER_NOTIFY));
		
		pDest++;

		pClient->dwTail = (pClient->dwTail + 1) & (MAX_MIXER_NOTIFIES - 1);
		pClient->dwCount -= 1;

		dwNumClientNotifies--;

		dwNumReturned++;
	}
	
	pNotifies->dwCount = dwNumReturned;
	
	return ECHOSTATUS_OK;

}	// GetControlChanges




/****************************************************************************

	CEchoGals mixer control

 ****************************************************************************/

//===========================================================================
//
// Process mixer function - service a single mixer function
//
//===========================================================================

ECHOSTATUS CEchoGals::ProcessMixerFunction
(
	PMIXER_FUNCTION	pMixerFunction,
	INT32 &					iRtnDataSz
)
{
	ECHOSTATUS			Status = ECHOSTATUS_OK;
	
	if (m_fMixerDisabled)
		return ECHOSTATUS_MIXER_DISABLED;
	
	switch ( pMixerFunction->iFunction )
	{
		case MXF_GET_CAPS :
			Status = GetCapabilities( &pMixerFunction->Data.Capabilities );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_CAPS  Status %ld\n", Status) );
			break;

		case MXF_GET_LEVEL :
			Status = GetAudioLineLevel( pMixerFunction);
			/*
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_LEVEL  Status %ld\n", Status) );
			*/
			break;

		case MXF_SET_LEVEL :
			Status = SetAudioLineLevel( pMixerFunction);
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_LEVEL  Status %ld\n", Status) );
			break;

		case MXF_GET_NOMINAL :
			Status = GetAudioNominal( pMixerFunction);
			/*
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_NOMINAL  Status %ld\n", Status) );
			*/
			break;

		case MXF_SET_NOMINAL :
			Status = SetAudioNominal( pMixerFunction);
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_NOMINAL  Status %ld\n", Status) );
			break;

		case MXF_GET_MONITOR :
			Status = GetAudioMonitor( pMixerFunction->Channel.wChannel,
											  pMixerFunction->Data.Monitor.wBusOut,
											  pMixerFunction->Data.Monitor.Data.iLevel );
			/*	  
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MONITOR  Status %ld\n", Status) );
			*/
			break;

		case MXF_SET_MONITOR :
			Status = SetAudioMonitor( pMixerFunction->Channel.wChannel,
											  pMixerFunction->Data.Monitor.wBusOut,
											  pMixerFunction->Data.Monitor.Data.iLevel );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_MONITOR  Status %ld\n", Status) );
			break;

		case MXF_GET_CLOCK_DETECT :
			Status = GetInputClockDetect( pMixerFunction->Data.dwClockDetectBits );
			break;
	
		case MXF_GET_INPUT_CLOCK :
			Status = GetInputClock( pMixerFunction->Data.wClock );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_INPUT_CLOCK  Status %ld\n", Status) );
			break;			

		case MXF_SET_INPUT_CLOCK :
			Status = SetInputClock( pMixerFunction->Data.wClock );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_INPUT_CLOCK  Status %ld\n", Status) );
			break;			


		case MXF_GET_OUTPUT_CLOCK :
			Status = GetOutputClock( pMixerFunction->Data.wClock );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_OUTPUT_CLOCK  Status %ld\n", Status) );
			break;			

		case MXF_SET_OUTPUT_CLOCK :
			Status = SetOutputClock( pMixerFunction->Data.wClock );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_OUTPUT_CLOCK  Status %ld\n", Status) );
			break;			


		case MXF_GET_METERS :
		
			if (NULL != GetDspCommObject())
			{
				Status = GetDspCommObject()->
								GetAudioMeters( &pMixerFunction->Data.Meters );				
			}
			else
			{
				Status = ECHOSTATUS_DSP_DEAD;
			}

			//ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
			// 						 "MXF_GET_METERS  Status %ld\n", Status) );
			break;

		case MXF_GET_METERS_ON :
			Status = GetMetersOn( pMixerFunction->Data.bMetersOn );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_METERS  Status %ld\n", Status) );
			break;

		case MXF_SET_METERS_ON :
			Status = SetMetersOn( pMixerFunction->Data.bMetersOn );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_METERS_ON  Status %ld\n", Status) );
			break;

		case MXF_GET_PROF_SPDIF :
			if ( NULL == GetDspCommObject() )
			{
				Status = ECHOSTATUS_DSP_DEAD;				
			}
			else
			{
				pMixerFunction->Data.bProfSpdif = IsProfessionalSpdif();
			}
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_PROF_SPDIF  Pro S/PDIF: 0x%x  Status %ld\n", 
									 pMixerFunction->Data.bProfSpdif,
									 Status) );
			break;

		case MXF_SET_PROF_SPDIF :
			SetProfessionalSpdif( pMixerFunction->Data.bProfSpdif );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_PROF_SPDIF  Pro S/PDIF: 0x%x  Status %ld\n", 
									 pMixerFunction->Data.bProfSpdif,
									 Status) );
			break;

		case MXF_GET_MUTE :
			Status = GetAudioMute(pMixerFunction);
			/*
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MUTE  Status %ld\n", Status) );
			*/
			break;

		case MXF_SET_MUTE :
			Status = SetAudioMute(pMixerFunction);
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_MUTE  Status %ld\n", Status) );
			break;

		case MXF_GET_MONITOR_MUTE :
			Status = 
				GetAudioMonitorMute( pMixerFunction->Channel.wChannel,
										   pMixerFunction->Data.Monitor.wBusOut,
										   pMixerFunction->Data.Monitor.Data.bMuteOn );
			/*
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MONITOR_MUTE  Status %ld\n", Status) );
			*/
			break;

		case MXF_SET_MONITOR_MUTE :
			Status = 
				SetAudioMonitorMute( pMixerFunction->Channel.wChannel,
										   pMixerFunction->Data.Monitor.wBusOut,
										   pMixerFunction->Data.Monitor.Data.bMuteOn );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_MONITOR_MUTE  Status %ld\n", Status) );
			break;

		case MXF_GET_MONITOR_PAN :
			Status = 
				GetAudioMonitorPan( pMixerFunction->Channel.wChannel,
										  pMixerFunction->Data.Monitor.wBusOut,
										  pMixerFunction->Data.Monitor.Data.iPan);
			/*

			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MONITOR_PAN  Status %ld\n", Status) );
			*/									 
									 
			break;
		case MXF_SET_MONITOR_PAN :
			Status = 
				SetAudioMonitorPan( pMixerFunction->Channel.wChannel,
										  pMixerFunction->Data.Monitor.wBusOut,
										  pMixerFunction->Data.Monitor.Data.iPan );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_MONITOR_PAN  Status %ld\n", Status) );
			break;

		case MXF_GET_FLAGS :
			pMixerFunction->Data.wFlags = GetFlags();
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_FLAGS 0x%x  Status %ld\n",
									 pMixerFunction->Data.wFlags,
									 Status) );
			break;
		case MXF_SET_FLAGS :
			SetFlags( pMixerFunction->Data.wFlags );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_FLAGS 0x%x  Status %ld\n",
									 pMixerFunction->Data.wFlags,
									 Status) );
			break;
		case MXF_CLEAR_FLAGS :
			ClearFlags( pMixerFunction->Data.wFlags );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_CLEAR_FLAGS 0x%x  Status %ld\n",
									 pMixerFunction->Data.wFlags,
									 Status) );
			break;

		case MXF_GET_SAMPLERATE_LOCK :
			GetAudioLockedSampleRate( pMixerFunction->Data.dwLockedSampleRate );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_SAMPLERATE_LOCK 0x%lx  Status %ld\n",
									 pMixerFunction->Data.dwLockedSampleRate,
									 Status) );
			break;

		case MXF_SET_SAMPLERATE_LOCK :
			SetAudioLockedSampleRate( pMixerFunction->Data.dwLockedSampleRate );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_SAMPLERATE_LOCK 0x%lx  Status %ld\n",
									 pMixerFunction->Data.dwLockedSampleRate,
									 Status) );
			break;

		case MXF_GET_SAMPLERATE :
		
			GetAudioSampleRate( &pMixerFunction->Data.dwSampleRate );

			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_SAMPLERATE 0x%lx  Status %ld\n",
									 pMixerFunction->Data.dwSampleRate,
									 Status) );
			break;

#ifdef MIDI_SUPPORT			

		case MXF_GET_MIDI_IN_ACTIVITY :
			pMixerFunction->Data.bMidiActive = m_MidiIn.IsActive();

			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MIDI_IN_ACTIVITY %s "
									 "Status %ld\n",
									 ( pMixerFunction->Data.bMidiActive ) 
										? "ACTIVE" : "INACTIVE",
									 Status) );
			break;


		case MXF_GET_MIDI_OUT_ACTIVITY :
			pMixerFunction->Data.bMidiActive =
				GetDspCommObject()->IsMidiOutActive();

			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_MIDI_OUT_ACTIVITY %s "
									 "Status %ld\n",
									 ( pMixerFunction->Data.bMidiActive ) 
										? "ACTIVE" : "INACTIVE",
									 Status) );
			break;

#endif // MIDI_SUPPORT


		case MXF_GET_DIGITAL_MODE :
			Status = ECHOSTATUS_OK;
			pMixerFunction->Data.iDigMode = GetDigitalMode();
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_DIGITAL_MODE %s "
									 "Status %ld\n",
									 ( DIGITAL_MODE_SPDIF_RCA == 
											pMixerFunction->Data.iDigMode )
										? "S/PDIF RCA" 
										: ( DIGITAL_MODE_SPDIF_OPTICAL == 
											pMixerFunction->Data.iDigMode )
												? "S/PDIF Optical" : "ADAT",
									 Status) );
			break;


		case MXF_SET_DIGITAL_MODE :
			Status = SetDigitalMode( (BYTE) pMixerFunction->Data.iDigMode );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_DIGITAL_MODE %s "
									 "Status %ld\n",
									 ( DIGITAL_MODE_SPDIF_RCA == 
											pMixerFunction->Data.iDigMode )
										? "S/PDIF RCA" 
										: ( DIGITAL_MODE_SPDIF_OPTICAL == 
											pMixerFunction->Data.iDigMode )
												? "S/PDIF Optical" : "ADAT",
									 Status) );
			break;


		case MXF_GET_PAN :
			Status = GetAudioPan( pMixerFunction);
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_PAN  Status %ld\n", Status) );
			break;

		case MXF_SET_PAN :
			Status = SetAudioPan( pMixerFunction);
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_PAN  Status %ld\n", Status) );
			break;
			
#ifdef DIGITAL_INPUT_AUTO_MUTE_SUPPORT

		case MXF_GET_DIG_IN_AUTO_MUTE	:
			Status =  GetDigitalInAutoMute( pMixerFunction );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_GET_DIG_IN_AUTO_MUTE  Status %ld\n", Status) );
			break;
			

		case MXF_SET_DIG_IN_AUTO_MUTE	:
			Status = SetDigitalInAutoMute( pMixerFunction );
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "MXF_SET_DIG_IN_AUTO_MUTE  Status %ld\n", Status) );
			break;

#endif // DIGITAL_INPUT_AUTO_MUTE_SUPPORT

		case MXF_GET_AUDIO_LATENCY :
			GetAudioLatency( &(pMixerFunction->Data.Latency) );
			break;
			
#ifdef PHANTOM_POWER_CONTROL
		
		case MXF_GET_PHANTOM_POWER :
			GetPhantomPower( &(pMixerFunction->Data.fPhantomPower) );
			break;
			
		case MXF_SET_PHANTOM_POWER :
			SetPhantomPower( pMixerFunction->Data.fPhantomPower );
			break;
			
#endif

		default :
			iRtnDataSz = 0;
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerFunction: "
									 "Function %ld not supported\n",
									 pMixerFunction->iFunction) );
			return ECHOSTATUS_NOT_SUPPORTED;
	}

	pMixerFunction->RtnStatus = Status;
	iRtnDataSz = sizeof( MIXER_FUNCTION );

	return Status;

}	// ECHOSTATUS CEchoGals::ProcessMixerFunction




//===========================================================================
//
// Process multiple mixer functions
//
//===========================================================================

ECHOSTATUS CEchoGals::ProcessMixerMultiFunction
(
	PMIXER_MULTI_FUNCTION	pMixerFunctions,	// Request from mixer
	INT32 &							iRtnDataSz			// # bytes returned (if any)
)
{
	ECHOSTATUS			Status = ECHOSTATUS_NOT_SUPPORTED;
	PMIXER_FUNCTION	pMixerFunction;
	INT32					iRtn, nCard, i;
	
	if (m_fMixerDisabled)
		return ECHOSTATUS_MIXER_DISABLED;

	iRtnDataSz = sizeof( MIXER_MULTI_FUNCTION ) - sizeof( MIXER_FUNCTION );
	pMixerFunction = &pMixerFunctions->MixerFunction[ 0 ];
	nCard = pMixerFunction->Channel.wCardId;
	for ( i = 0; i < pMixerFunctions->iCount; i++ )
	{
		pMixerFunction = &pMixerFunctions->MixerFunction[ i ];
		if ( nCard != pMixerFunction->Channel.wCardId )
		{
			ECHO_DEBUGPRINTF( ("CEchoGals::ProcessMixerMultiFunction: "
									 "All functions MUST be for the same card "
									 "exp %ld act %d!\n",
									 nCard,
									 pMixerFunction->Channel.wCardId) );
			return ECHOSTATUS_NOT_SUPPORTED;
		}

		Status = ProcessMixerFunction(pMixerFunction,iRtn);
		iRtnDataSz += iRtn;
	}

	return Status;

}	// ECHOSTATUS CEchoGals::ProcessMixerMultiFunction




//===========================================================================
//
// Typically, if you are writing a console, you will be polling the driver
// to get the current peak and VU meters, clock detect bits, and 
// control changes.  GetPolledStuff will fill out an ECHO_POLLED_STUFF
// structure with all of those things.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetPolledStuff
(
	ECHO_POLLED_STUFF *pPolledStuff,
	NUINT MixerCookie
)
{
	ECHO_MIXER_CLIENT *pClient;
	CDspCommObject *pDCO = GetDspCommObject();
	
	if (m_fMixerDisabled)
		return ECHOSTATUS_MIXER_DISABLED;
	
	if (NULL == pDCO)
		return ECHOSTATUS_DSP_DEAD;
		
	//
	// Fill out the non-client-specific portions of the struct
	//
	pDCO->GetAudioMeters(&(pPolledStuff->Meters));
	GetInputClockDetect(pPolledStuff->dwClockDetectBits);
	
	//
	// If there is a matching client, fill out the number
	// of notifies
	//
	pClient = GetMixerClient(MixerCookie);
	if (NULL == pClient)
		pPolledStuff->dwNumPendingNotifies = 0;
	else	
		pPolledStuff->dwNumPendingNotifies = pClient->dwCount;
	
	return ECHOSTATUS_OK;
	
}	// GetPolledStuff


//===========================================================================
//
//	Get the pan setting for an output pipe (virtual outputs only)
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioPan
(
	PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;
	
	if ( 	(pMF->Channel.dwType != ECHO_PIPE_OUT) ||
			( !HasVmixer() ) )
		return ECHOSTATUS_INVALID_CHANNEL;
		
	wPipe = pMF->Channel.wChannel;
	wBus = pMF->Data.PipeOut.wBusOut;
	Status = m_PipeOutCtrl.GetPan(wPipe,
											wBus,
											pMF->Data.PipeOut.Data.iPan);

	return Status;

}	// ECHOSTATUS CEchoGals::GetAudioPan


//===========================================================================
//
//	Set the pan for an output pipe (virtual outputs only)
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioPan
(
	PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;
	
	if ( 	(pMF->Channel.dwType != ECHO_PIPE_OUT) ||
			( !HasVmixer() ) )
		return ECHOSTATUS_INVALID_CHANNEL;
		
	wPipe = pMF->Channel.wChannel;
	wBus = pMF->Data.PipeOut.wBusOut;
	Status = m_PipeOutCtrl.SetPan(wPipe,
											wBus,
											pMF->Data.PipeOut.Data.iPan);

	return Status;
	
}	// ECHOSTATUS CEchoGals::SetAudioPan




/****************************************************************************

	CEchoGals clock control
	
	The input clock is the sync source - is the audio for this card running
	off of the internal clock, synced to word clock, etc.
	
	Output clock is only supported on Layla20 - Layla20 can transmit either
	word or super clock.

 ****************************************************************************/

//===========================================================================
//
// Get input and output clocks - just return the stored value
//
//===========================================================================

ECHOSTATUS CEchoGals::GetInputClock(WORD &wClock)
{
	if ( NULL == GetDspCommObject() )
		return ECHOSTATUS_DSP_DEAD;

	wClock = GetDspCommObject()->GetInputClock();
	
	return ECHOSTATUS_OK;
}	


ECHOSTATUS CEchoGals::GetOutputClock(WORD &wClock)
{
	if ( NULL == GetDspCommObject() )
		return ECHOSTATUS_DSP_DEAD;

	wClock = GetDspCommObject()->GetOutputClock();
	
	return ECHOSTATUS_OK;
}	


//===========================================================================
//
// Set input and output clocks - pass it down to the comm page and
// store the control change.
//
//===========================================================================

ECHOSTATUS CEchoGals::SetInputClock(WORD wClock)
{
	ECHOSTATUS Status;

	if ( NULL == GetDspCommObject() || GetDspCommObject()->IsBoardBad() )
		return ECHOSTATUS_DSP_DEAD;

	ECHO_DEBUGPRINTF( ("CEchoGals::SetInputClock: ") );
	
	Status = GetDspCommObject()->SetInputClock( wClock );

	if (ECHOSTATUS_OK == Status)
	{
		MixerControlChanged( ECHO_NO_CHANNEL_TYPE,
									MXN_INPUT_CLOCK);
	}
	return Status;

}	// SetInputClock


ECHOSTATUS CEchoGals::SetOutputClock(WORD wClock)
{
	ECHOSTATUS Status;

	if ( NULL == GetDspCommObject() || GetDspCommObject()->IsBoardBad() )
		return ECHOSTATUS_DSP_DEAD;

	ECHO_DEBUGPRINTF( ("CEchoGals::SetOutputClock: ") );
	
	Status = GetDspCommObject()->SetOutputClock( wClock );

	if (ECHOSTATUS_OK == Status)
	{
		MixerControlChanged( ECHO_NO_CHANNEL_TYPE,
									MXN_OUTPUT_CLOCK);
	}
	return Status;

}	


//===========================================================================
//
// Get the currently detected clock bits - default method.  Overridden by 
// derived card classes.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetInputClockDetect(DWORD &dwClockDetectBits)
{
	dwClockDetectBits = ECHO_CLOCK_INTERNAL;

	return ECHOSTATUS_OK;
}	


//===========================================================================
//
// Set the locked sample rate
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioLockedSampleRate
(
	DWORD		dwSampleRate
)
{
	ECHOSTATUS	Status;
							 
	Status = QueryAudioSampleRate( dwSampleRate );
	if ( ECHOSTATUS_OK != Status )
		return Status;

	if (0 != (ECHOGALS_FLAG_SAMPLE_RATE_LOCKED & GetFlags()))
	{
		GetDspCommObject()->SetSampleRate( dwSampleRate );
		m_dwSampleRate = dwSampleRate;
	}

	m_dwLockedSampleRate = dwSampleRate;

	return ECHOSTATUS_OK;

}	// ECHOSTATUS CEchoGals::SetAudioLockedSampleRate


//===========================================================================
//
// Get the locked sample rate
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioLockedSampleRate
(
	DWORD	   &dwSampleRate
)
{
	dwSampleRate = m_dwLockedSampleRate;
		
	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CEchoGals::GetAudioLockedSampleRate



#ifdef DIGITAL_INPUT_AUTO_MUTE_SUPPORT

//===========================================================================
//
// Get the digital input auto mute flag from the comm page
//
//===========================================================================

ECHOSTATUS CEchoGals::GetDigitalInAutoMute(PMIXER_FUNCTION pMixerFunction)
{
	BOOL fAutoMute;
	
	if (0 == (m_wFlags & ECHOGALS_ROFLAG_DIGITAL_IN_AUTOMUTE))
	{
		pMixerFunction->Data.fDigitalInAutoMute = FALSE;
		return ECHOSTATUS_NOT_SUPPORTED;
	}

	GetDspCommObject()->GetDigitalInputAutoMute(	fAutoMute );
	pMixerFunction->Data.fDigitalInAutoMute = fAutoMute;
	
	return ECHOSTATUS_OK;		
	
} // GetDigitalInAutoMute


//===========================================================================
//
// Set the digital input auto mute flag
//
//===========================================================================

ECHOSTATUS CEchoGals::SetDigitalInAutoMute(PMIXER_FUNCTION pMixerFunction)
{
	BOOL fAutoMute;
	
	if (0 == (m_wFlags & ECHOGALS_ROFLAG_DIGITAL_IN_AUTOMUTE))
		return ECHOSTATUS_NOT_SUPPORTED;
	
	fAutoMute = pMixerFunction->Data.fDigitalInAutoMute;
	GetDspCommObject()->SetDigitalInputAutoMute( fAutoMute );	
	
	return ECHOSTATUS_OK;		
	
} // SetDigitalInAutoMute

#endif // DIGITAL_INPUT_AUTO_MUTE_SUPPORT


//===========================================================================
//
// Get the gain for an output bus, input bus, or output pipe.
//
// Gain levels are in units of dB * 256.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioLineLevel
(
	PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;

	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :
			
			wBus = pMF->Channel.wChannel;
			
			if (wBus < GetNumBussesOut())
			{
				pMF->Data.iLevel = m_BusOutLineLevels[wBus].GetGain();				
				Status = ECHOSTATUS_OK;
			}
			else
			{
				Status = ECHOSTATUS_INVALID_CHANNEL;
			}

			break;
 
		case ECHO_BUS_IN :

			wBus = pMF->Channel.wChannel;
			if (wBus < GetNumBussesIn())
			{
				pMF->Data.iLevel = m_BusInLineLevels[wBus].GetGain();				
				Status = ECHOSTATUS_OK;
			}
			else
			{
				Status = ECHOSTATUS_INVALID_CHANNEL;
			}
			break;
		
		case ECHO_PIPE_OUT :
		
			wPipe = pMF->Channel.wChannel;
			wBus = pMF->Data.PipeOut.wBusOut;
 			Status = m_PipeOutCtrl.GetGain(	wPipe,
														wBus,
														pMF->Data.PipeOut.Data.iLevel);
			break;

		default:
			Status = ECHOSTATUS_INVALID_PARAM;
			break;
	}

	return Status;

}	// ECHOSTATUS CEchoGals::GetAudioLineLevel


//===========================================================================
//
// Utility function to check that a setting is within the correct range.
//
//===========================================================================

ECHOSTATUS CheckSetting(INT32 iValue,INT32 iMin,INT32 iMax)
{
	if ( (iValue > iMax) || (iValue < iMin))
		return ECHOSTATUS_INVALID_PARAM;
	
	return ECHOSTATUS_OK;	
		
}	// CheckSetting


//===========================================================================
//
// Set the gain for an output bus, input bus, or output pipe.
//
// Gain levels are in units of dB * 256.
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioLineLevel
(
	PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;
	INT32 			iLevel;

	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :

			wBus = pMF->Channel.wChannel;
			iLevel = pMF->Data.iLevel;
			
			Status = CheckSetting(iLevel,ECHOGAIN_MINOUT,ECHOGAIN_MAXOUT);
			if (ECHOSTATUS_OK != Status)
				break;
			
			Status = m_BusOutLineLevels[wBus].SetGain(iLevel);
			break;
			
		case ECHO_BUS_IN :
		
			wBus = pMF->Channel.wChannel;
			iLevel = pMF->Data.iLevel;

			Status = CheckSetting(iLevel,ECHOGAIN_MININP,ECHOGAIN_MAXINP);
			if (ECHOSTATUS_OK != Status)
				break;

			Status = m_BusInLineLevels[wBus].SetGain(iLevel);
			break;
			
		case ECHO_PIPE_OUT :

			wPipe = pMF->Channel.wChannel;
			wBus = pMF->Data.PipeOut.wBusOut;
			iLevel = pMF->Data.PipeOut.Data.iLevel;

			Status = CheckSetting(iLevel,ECHOGAIN_MINOUT,ECHOGAIN_MAXOUT);
			if (ECHOSTATUS_OK != Status)
				break;

 			Status = m_PipeOutCtrl.SetGain(	wPipe,
														wBus,
														iLevel);
			break;
			
		default:
			Status = ECHOSTATUS_INVALID_PARAM;
			break;
	}

	return Status;
	
}	// ECHOSTATUS CEchoGals::SetAudioLineLevel


//===========================================================================
//
// Get the nominal level for an output or input bus.  The nominal level is
// also referred to as the +4/-10 switch.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioNominal
(
	PMIXER_FUNCTION	pMF
)
{
	BYTE					byNominal;
	ECHOSTATUS			Status;
	CDspCommObject *	pDspCommObj = GetDspCommObject();
	WORD					wCh;

	if ( NULL == pDspCommObj || pDspCommObj->IsBoardBad() )
		return ECHOSTATUS_DSP_DEAD;
		
	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :
			wCh = pMF->Channel.wChannel;
			break;
			
		case ECHO_BUS_IN :
			wCh = pMF->Channel.wChannel + GetNumBussesOut();
			break;
		
		default :
			return ECHOSTATUS_INVALID_CHANNEL;
	}
		
	Status = pDspCommObj->GetNominalLevel( wCh, &byNominal );

	if ( ECHOSTATUS_OK != Status )
		return Status;

	pMF->Data.iNominal = ( byNominal ) ? -10 : 4;

	return ECHOSTATUS_OK;
}	// ECHOSTATUS CEchoGals::GetAudioNominal


//===========================================================================
//
// Set the nominal level for an output or input bus.  The nominal level is
// also referred to as the +4/-10 switch.
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioNominal
(
	PMIXER_FUNCTION	pMF
)
{
	ECHOSTATUS	Status;
	WORD			wCh;
	INT32			iNominal;

	if ( NULL == GetDspCommObject() || GetDspCommObject()->IsBoardBad() )
		return ECHOSTATUS_DSP_DEAD;
	
	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :
			wCh = pMF->Channel.wChannel;
			break;
			
		case ECHO_BUS_IN :
			wCh = pMF->Channel.wChannel + GetNumBussesOut();
			break;
		
		default :
			return ECHOSTATUS_INVALID_CHANNEL;
	}

	iNominal = pMF->Data.iNominal;
	
	if ((iNominal!= -10) && (iNominal != 4))
		return ECHOSTATUS_INVALID_PARAM;
	
	Status =
		GetDspCommObject()->SetNominalLevel( wCh,
														( iNominal == -10 ) );

	if ( ECHOSTATUS_OK != Status )
		return Status;

	Status = MixerControlChanged( (WORD) pMF->Channel.dwType,
											MXN_NOMINAL,
											pMF->Channel.wChannel);
	return Status;

}	// ECHOSTATUS CEchoGals::SetAudioNominal


//===========================================================================
//
// Set the mute for an output bus, input bus, or output pipe.
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioMute
(
		PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;
	BOOL			bMute;
	
	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :

			wBus = pMF->Channel.wChannel;
			bMute = pMF->Data.bMuteOn;
			Status = m_BusOutLineLevels[wBus].SetMute(bMute);
			break;
			
		case ECHO_BUS_IN :
	
			wBus = pMF->Channel.wChannel;
			bMute = pMF->Data.bMuteOn;
			Status = m_BusInLineLevels[wBus].SetMute(bMute);
			break;
			
		case ECHO_PIPE_OUT :

			wPipe = pMF->Channel.wChannel;
			wBus = pMF->Data.PipeOut.wBusOut;
			bMute = pMF->Data.PipeOut.Data.bMuteOn;
 			Status = m_PipeOutCtrl.SetMute(	wPipe,
														wBus,
														bMute);
			break;
			
		default:
			Status = ECHOSTATUS_INVALID_PARAM;
			break;
	}

	return Status;
}	// ECHOSTATUS CEchoGals::SetAudioMute


//===========================================================================
//
// Get the mute for an output bus, input bus, or output pipe.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioMute
(
		PMIXER_FUNCTION	pMF
)
{
	WORD 			wPipe;
	WORD 			wBus;
	ECHOSTATUS 	Status;

	switch (pMF->Channel.dwType)
	{
		case ECHO_BUS_OUT :
			
			wBus = pMF->Channel.wChannel;
			
			if (wBus < GetNumBussesOut())
			{
				pMF->Data.bMuteOn = m_BusOutLineLevels[wBus].IsMuteOn();
				Status = ECHOSTATUS_OK;
			}
			else
			{
				Status = ECHOSTATUS_INVALID_CHANNEL;
			}

			break;
 
		case ECHO_BUS_IN :

			wBus = pMF->Channel.wChannel;
			
			if (wBus < GetNumBussesIn())
			{
				pMF->Data.bMuteOn = m_BusInLineLevels[wBus].IsMuteOn();
				Status = ECHOSTATUS_OK;
			}
			else
			{
				Status = ECHOSTATUS_INVALID_CHANNEL;
			}
			break;
		
		case ECHO_PIPE_OUT :
		
			wPipe = pMF->Channel.wChannel;
			wBus = pMF->Data.PipeOut.wBusOut;
 			Status = m_PipeOutCtrl.GetMute(	wPipe,
														wBus,
														pMF->Data.PipeOut.Data.bMuteOn);
			break;

		default:
			Status = ECHOSTATUS_INVALID_PARAM;
			break;
	}

	return Status;

}	// ECHOSTATUS CEchoGals::GetAudioMute


//===========================================================================
//
// Get the monitor gain for a single input bus mixed to a single output bus.
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioMonitor
(
	WORD	wBusIn,
	WORD	wBusOut,
	INT32 &	iGain
)
{
	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	//
	// Get the monitor value
	//
	m_MonitorCtrl.GetGain(wBusIn,wBusOut,iGain);
	
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CEchoGals::GetAudioMonitor


//===========================================================================
//
// Set the monitor gain for a single input bus mixed to a single output bus.
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioMonitor
(
	WORD	wBusIn,
	WORD	wBusOut,
	INT32	iGain
)
{
	ECHOSTATUS	Status;

	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	Status = CheckSetting(iGain,ECHOGAIN_MINOUT,ECHOGAIN_MAXOUT);
	if (ECHOSTATUS_OK == Status)
	{
		//
		// Set the monitor gain
		// 
		m_MonitorCtrl.SetGain(wBusIn,wBusOut,iGain);
	}

	return Status;
	
}	// ECHOSTATUS CEchoGals::SetAudioMonitor


//===========================================================================
//
//	Helper functions for doing log conversions on pan values
//
// The parameter iNum is a fixed point 32 bit number in 16.16 format;
// that is, 16 bits of integer and 16 bits of decimal
// To convert a float number to fixed point, simply multiply by 2^16 and round
//
// Valid range for iNum is from +1.0 (0x10000) to 0.
//
//===========================================================================

#define FIXED_BASE		16							// 16 bits of fraction
#define FIXED_ONE_HALF	((INT32) 0x00008000)	// 0.5 in 16.16 format
#define COEFF_A2			((INT32) 0xffffa9ac)	// -.3372223
#define COEFF_A1			((INT32) 0x0000ff8a)	//  .9981958
#define COEFF_A0			((INT32) 0xffff5661)	// -.6626105

#define DB_CONVERT		0x60546		// 6.02... in 16.16

// Note use of double precision here to prevent overflow
static INT32 FixedMult( INT32 iNum1, INT32 iNum2 )
{
	LONGLONG llNum;

	llNum = (LONGLONG) iNum1 * (LONGLONG) iNum2;

	return (INT32) (llNum >> FIXED_BASE);
}	// INT32 FixedMult( INT32 iNum1, INT32 iNum2 )


static INT32 log2( INT32 iNum )
{
	INT32 iNumShifts;
	INT32 iTemp;

	// log2 is undefined for zero, so return -infinity (or close enough)
	if ( 0 == iNum )
		return ECHOGAIN_MUTED;

	// Step 1 - Normalize and save the number of shifts
	// Keep shifting iNum up until iNum > 0.5
	iNumShifts = 0;
	while ( iNum < FIXED_ONE_HALF )
	{
		iNumShifts++;
		iNum <<= 1;
	}

	// Step 2 - Calculate LOG2 by polynomial approximation.  8 bit accuracy.
	//
	// LOG2(x) = 4.0* (-.3372223 x*x + .9981958 x - .6626105)
	//                           a2             a1            a0
	// where  0.5 <= x < 1.0
	//

	// Compute polynomial sum
	iTemp = FixedMult( iNum, iNum );				// iTemp now has iNum squared
	iTemp = FixedMult( iTemp, COEFF_A2 );
	iTemp += FixedMult( iNum, COEFF_A1 );
	iTemp += COEFF_A0;

	// Multiply by four
	iTemp <<= 2;

	// Account for the normalize shifts
	iTemp -= ( iNumShifts << FIXED_BASE );

	return( iTemp );
}	// INT32 log2( INT32 iNum )


//
//	Convert pan value to Db X 256
//	Pan value is 0 - MAX_MIXER_PAN
//
INT32 PanToDb( INT32 iPan )
{
	if ( iPan >= ( MAX_MIXER_PAN - 1 ) )
		return( 0 );
	if ( iPan <= 1 )
		return( ECHOGAIN_MUTED );
	//
	//	Convert pan to 16.16
	//
	iPan = ( iPan << 16 ) / MAX_MIXER_PAN;
	//
	//	Take the log
	//
	iPan = log2( iPan );
	//
	// To convert to decibels*256, just multiply by the conversion factor
	//
	iPan = FixedMult( iPan << 8, DB_CONVERT );
	//
	// To round, add one half and then mask off the fractional bits
	//
	iPan = ( iPan + FIXED_ONE_HALF ) >> FIXED_BASE;
	return( iPan );
}	// INT32 PanToDb( INT32 iPan )


//===========================================================================
//
// Set the monitor pan
//
//	For this to work effectively, both the input and output channels must
//	both either be odd or even.  Thus even channel numbers are for the
//	left channel and odd channel numbers are for the right channel.
//	Pan values will be computed for both channels.
//
// iPan ranges from 0 (hard left) to MAX_MIXER_PAN (hard right)
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioMonitorPan
(
	WORD	wBusIn,
	WORD	wBusOut,
	INT32	iPan						// New pan
)
{
	ECHOSTATUS Status;

	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	Status = CheckSetting(iPan,0,MAX_MIXER_PAN);
	if (ECHOSTATUS_OK == Status)
	{
		//
		// Set the pan
		// 
		m_MonitorCtrl.SetPan(wBusIn,wBusOut,iPan);
	}

	return Status;
		
}	// ECHOSTATUS CEchoGals::SetAudioMonitorPan


//===========================================================================
//
// Get the monitor pan
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioMonitorPan
(
	WORD	wBusIn,
	WORD	wBusOut,
	INT32 &	iPan						// Returns current pan (0 - MAX_MIXER_PAN)
)
{
	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	//
	// Get the pan
	// 
	m_MonitorCtrl.GetPan(wBusIn,wBusOut,iPan);
	
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CEchoGals::GetAudioMonitorPan


//===========================================================================
//
// Set the monitor mute
//
//===========================================================================

ECHOSTATUS CEchoGals::SetAudioMonitorMute
(
	WORD	wBusIn,
	WORD	wBusOut,
	BOOL	bMute						// New state
)
{
	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	//
	// Set the mute
	// 
	m_MonitorCtrl.SetMute(wBusIn,wBusOut,bMute);
		
	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CEchoGals::SetAudioMonitorMute


//===========================================================================
//
// Get the monitor mute
//
//===========================================================================

ECHOSTATUS CEchoGals::GetAudioMonitorMute
(
	WORD	wBusIn,
	WORD	wBusOut,
	BOOL 	&bMute	  				// Returns current state
)
{
	if ( wBusIn  >= GetNumBussesIn() ||
		  wBusOut >= GetNumBussesOut() )
	{
		return ECHOSTATUS_INVALID_INDEX;
	}
	
	//
	// Get the mute
	// 
	m_MonitorCtrl.GetMute(wBusIn,wBusOut,bMute);
	
	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CEchoGals::GetAudioMonitorMute


//===========================================================================
//
// Set the S/PDIF output format to professional or consumer
//
//===========================================================================

void CEchoGals::SetProfessionalSpdif( BOOL bNewStatus )
{
	ECHO_DEBUGPRINTF(("CEchoGals::SetProfessionalSpdif %d\n",bNewStatus));
	
	if ( NULL != GetDspCommObject() )
	{
		GetDspCommObject()->SetProfessionalSpdif( bNewStatus );
		MixerControlChanged( ECHO_NO_CHANNEL_TYPE,
									MXN_SPDIF );
	}
}	// void CEchoGals::SetProfessionalSpdif( BOOL bNewStatus )


//===========================================================================
//
// Set driver flags
//
//	See ECHOGALS_FLAG_??? definitions in EchoGalsXface.h
//
//===========================================================================

ECHOSTATUS CEchoGals::SetFlags
(
	WORD	wFlags
)
{
	//
	// Mask off the read-only flags so they don't change
	//
	wFlags &= ECHOGALS_FLAG_WRITABLE_MASK;

	//
	// Set the flags & mark the flags as changed
	//
	m_wFlags |= wFlags;

	MixerControlChanged(	ECHO_NO_CHANNEL_TYPE,
								MXN_FLAGS );

	return ECHOSTATUS_OK;

}	// ECHOSTATUS CEchoGals::SetFlags


//===========================================================================
//
// Clear driver flags
//
//	See ECHOGALS_FLAG_??? definitions in EchoGalsXface.h
//
//===========================================================================

ECHOSTATUS CEchoGals::ClearFlags
(
	WORD	wFlags
)
{
	//
	// Mask off the read-only flags so they don't change
	//
	wFlags &= ECHOGALS_FLAG_WRITABLE_MASK;

	//
	// Clear the flags & mark the flags as changed
	//
	m_wFlags &= ~wFlags;

	MixerControlChanged(	ECHO_NO_CHANNEL_TYPE,
								MXN_FLAGS );

	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CEchoGals::ClearFlags


//===========================================================================
//
// Set the digital mode - currently for Gina24, Layla24, and Mona
//
//===========================================================================

ECHOSTATUS CEchoGals::SetDigitalMode
(
	BYTE byDigitalMode
)
{
	ECHOSTATUS	Status;
	BYTE			byPreviousDigitalMode;

	if ( NULL == GetDspCommObject() || GetDspCommObject()->IsBoardBad() )
		return ECHOSTATUS_DSP_DEAD;

	if ( 0 == GetDspCommObject()->GetDigitalModes() )
		return ECHOSTATUS_DIGITAL_MODE_NOT_SUPPORTED;

	if ( TRUE == GetDspCommObject()->IsTransportActive() ) 
	{
		ECHO_DEBUGPRINTF( ( 	"CEchoGals::SetDigitalMode()  Cannot set the digital "
									"mode while transport is running\n"));
		return ECHOSTATUS_BUSY;
	}
	byPreviousDigitalMode = GetDspCommObject()->GetDigitalMode();
	Status = GetDspCommObject()->SetDigitalMode( byDigitalMode );
	MixerControlChanged( ECHO_NO_CHANNEL_TYPE,
								MXN_DIGITAL_MODE );
	MixerControlChanged( ECHO_NO_CHANNEL_TYPE, 
								MXN_INPUT_CLOCK );

	//
	//	If we successfully changed the digital mode from or to ADAT, then 
	//	make sure all output, input and monitor levels are updated by the
	//	DSP comm object.
	//
	if ( ECHOSTATUS_OK == Status &&
		  byPreviousDigitalMode != byDigitalMode &&
		  ( DIGITAL_MODE_ADAT == byPreviousDigitalMode ||
		    DIGITAL_MODE_ADAT == byDigitalMode ) )
	{
		WORD	i, j,wBus,wPipe;

		for ( i = 0; i < GetNumBussesIn(); i++ )
		{
			for ( j = 0; j < GetNumBussesOut(); j += 2 )
			{
				m_MonitorCtrl.SetGain(i,j,ECHOGAIN_UPDATE,FALSE);
			}
		}

		for ( wBus = 0; wBus < GetNumBussesOut(); wBus++)
		{
			for ( wPipe = 0; wPipe < GetNumPipesOut(); wPipe++)
			{
				m_PipeOutCtrl.SetGain(wPipe,wBus,ECHOGAIN_UPDATE,FALSE);
			}
		}

		for ( i = 0; i < GetNumBussesOut(); i++ )
		{
			m_BusOutLineLevels[ i ].SetGain(ECHOGAIN_UPDATE,FALSE);
		}

		for ( i = 0; i < GetNumBussesIn(); i++ )
		{
			m_BusInLineLevels[ i ].SetGain( ECHOGAIN_UPDATE );
		}
		
		//
		// Now set them all at once, since all the
		// fImmediate parameters were set to FALSE.  Do the output
		// bus _and_ the output pipe in case this is a vmixer card.
		//
		m_BusOutLineLevels[0].SetGain(ECHOGAIN_UPDATE,TRUE);
		m_PipeOutCtrl.SetGain(0,0,ECHOGAIN_UPDATE,TRUE);
	}
	
	//
	// If the card has just been put in ADAT mode, it is possible
	// that the locked sample rate is greater than 48KHz, which is not allowed
	// in ADAT mode.  If this happens, change the locked rate to 48.
	//
	if ( 	(DIGITAL_MODE_ADAT == byDigitalMode) &&
			(m_wFlags & ECHOGALS_FLAG_SAMPLE_RATE_LOCKED) &&
			(m_dwLockedSampleRate > 48000) )
	{
		m_dwLockedSampleRate = 48000;
	}
	
	return Status;
	
}	// ECHOSTATUS CEchoGals::SetDigitalMode( ... )


/*

The output bus gain controls aren't actually implemented in the hardware;
insted they are virtual controls created by the generic code.

The signal sent to an output bus is a mix of the monitors and output pipes
routed to that bus; the output bus gain is therefore implemented by tweaking
each appropriate monitor and output pipe gain.

*/


//===========================================================================
//
// Adjust all the monitor levels for a particular output bus
//
// For efficiency, fImmediate is set to FALSE in the call
// to SetGain; all the monitor and pipe out gains are
// sent to the DSP at once by AdjustPipesOutForBusOut.
//
//===========================================================================

ECHOSTATUS CEchoGals::AdjustMonitorsForBusOut(WORD wBusOut)
{
	WORD wBusIn;
	
	//
	// Poke the monitors
	//
	for (wBusIn = 0; wBusIn < GetNumBussesIn(); wBusIn++)
	{
		m_MonitorCtrl.SetGain(wBusIn,wBusOut,ECHOGAIN_UPDATE,FALSE);
	}
	
	return ECHOSTATUS_OK;
	
}	// AdjustMonitorsForBusOut

	
//===========================================================================
//
// Adjust all the pipe out levels for a particular output bus
//
// For efficiency, fImmediate is set to FALSE in the call
// to SetGain; all the monitor and pipe out gains are
// sent to the DSP at once by AdjustPipesOutForBusOut.
//
//===========================================================================

ECHOSTATUS CEchoGals::AdjustPipesOutForBusOut(WORD wBusOut,INT32 iBusOutGain)
{
	ECHO_DEBUGPRINTF(("CEchoGals::AdjustPipesOutForBusOut wBusOut %d  iBusOutGain %ld\n",
							wBusOut,
							iBusOutGain));
					
	//
	// Round down to the nearest even bus
	//
	wBusOut &= 0xfffe;							
							
	m_PipeOutCtrl.SetGain(wBusOut,wBusOut,ECHOGAIN_UPDATE,FALSE);
	wBusOut++;
	m_PipeOutCtrl.SetGain(wBusOut,wBusOut,ECHOGAIN_UPDATE,TRUE);	
	
	return ECHOSTATUS_OK;
	
}	// AdjustPipesOutForBusOut



//===========================================================================
//
// GetAudioLatency - returns the latency for a single pipe
//
//===========================================================================

void CEchoGals::GetAudioLatency(ECHO_AUDIO_LATENCY *pLatency)
{
	DWORD dwLatency;

	if (FALSE == pLatency->wIsInput)
	{
		if (pLatency->wPipe >= GetFirstDigitalBusOut())
			dwLatency = m_wDigitalOutputLatency;
		else
			dwLatency = m_wAnalogOutputLatency;	
	}
	else
	{
		if (pLatency->wPipe >= GetFirstDigitalBusIn())
			dwLatency = m_wDigitalInputLatency;
		else
			dwLatency = m_wAnalogInputLatency;	
	}
	
	pLatency->dwLatency = dwLatency;

}	// GetAudioLatency