haiku.git

// ****************************************************************************
//
//		CMonitorCtrl.cpp
//
//		Class to control monitors
//
// ----------------------------------------------------------------------------
//
// 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"
#include "CMonitorCtrl.h"

//*****************************************************************************
//
// Destructor (this class uses the default constructor)
//
//*****************************************************************************

CMonitorCtrl::~CMonitorCtrl()
{
	Cleanup();	
}	


//*****************************************************************************
//
// Init
//
//*****************************************************************************

ECHOSTATUS CMonitorCtrl::Init(CEchoGals *pEG)
{
	DWORD	dwBytes;
	DWORD	dwArraySize;

	m_Gains = NULL;
	m_Mutes = NULL;
	m_Pans = NULL;
	m_PanDbs = NULL;
	
	//
	// Cache stuff
	//
	m_pEG = pEG;
	m_wNumBussesIn = pEG->GetNumBussesIn();
	m_wNumBussesOut = pEG->GetNumBussesOut();

	//
	// Indigo has no inputs; attempting to allocate 0 bytes 
	// causes a BSOD on Windows ME.
	//
	if ((0 == m_wNumBussesIn) || (0 == m_wNumBussesOut))
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::Init - this card has no inputs!\n"));
		return ECHOSTATUS_OK;
	}
	
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	//
	// Allocate the arrays
	//
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
	dwArraySize = m_wNumBussesIn * (m_wNumBussesOut >> 1);

	dwBytes = sizeof(INT8) * dwArraySize;
	OsAllocateNonPaged(dwBytes,(void **) &m_Gains);
	if (NULL == m_Gains)
	{
		Cleanup();
		return ECHOSTATUS_NO_MEM;
	}
	
	dwBytes = sizeof(WORD) * dwArraySize;
	OsAllocateNonPaged(dwBytes,(void **) &m_Pans);
	if (NULL == m_Pans)
	{
		Cleanup();
		return ECHOSTATUS_NO_MEM;
	}
	
	dwBytes = sizeof(BYTE) * dwArraySize;
	OsAllocateNonPaged(dwBytes,(void **) &m_Mutes);
	if (NULL == m_Mutes)
	{
		Cleanup();
		return ECHOSTATUS_NO_MEM;
	}
	
	dwBytes = sizeof(PAN_DB) * dwArraySize;
	OsAllocateNonPaged(dwBytes,(void **) &m_PanDbs );
	if (NULL == m_PanDbs)
	{
		Cleanup();
		return ECHOSTATUS_NO_MEM;
	}

	//==============================================================
	//		
	// Init the arrays
	//
	//==============================================================
	
	WORD wBusIn,wBusOut,wIndex;
	
	for (wBusIn = 0; wBusIn < m_wNumBussesIn; wBusIn++)
		for (wBusOut = 0; wBusOut < m_wNumBussesOut; wBusOut += 2)
		{
			wIndex = GetIndex(wBusIn,wBusOut);
			
			//
			// Pan hard left for even inputs, hard right for odd
			//
			if (0 == (wBusIn & 1))
			{
				m_Pans[wIndex] = 0;
				m_PanDbs[wIndex].iLeft = 0;
				m_PanDbs[wIndex].iRight = (INT8) GENERIC_TO_DSP( ECHOGAIN_MUTED );
			}
			else
			{
				m_Pans[wIndex] = MAX_MIXER_PAN;
				m_PanDbs[wIndex].iLeft = (INT8) GENERIC_TO_DSP( ECHOGAIN_MUTED );
				m_PanDbs[wIndex].iRight = 0;
			}
			
			//
			// Mute unless this is not a digital input
			// and the input is going to the same-numbered output
			//
			if ( (wBusIn  < m_pEG->GetFirstDigitalBusIn()) &&
				  ( (wBusIn & 0xfffe) == wBusOut ) )
			{
				m_Mutes[wIndex] = FALSE;
			}
			else
			{
				m_Mutes[wIndex] = TRUE;
			}
			
			//
			// Put stuff in the comm page
			//
			SetGain(wBusIn,wBusOut,ECHOGAIN_UPDATE,FALSE);
		}
		
	//
	// Now actually update the DSP
	//
	m_pEG->GetDspCommObject()->UpdateAudioOutLineLevel();

	
	return ECHOSTATUS_OK;
	
}	// Init


//*****************************************************************************
//
// Cleanup - free allocated memory
//
//*****************************************************************************

void CMonitorCtrl::Cleanup()
{
	if (m_Gains)
		OsFreeNonPaged(m_Gains);
		
	if (m_Mutes)
		OsFreeNonPaged(m_Mutes);
		
	if (m_Pans)
		OsFreeNonPaged(m_Pans);
		
	if (m_PanDbs)
		OsFreeNonPaged(m_PanDbs);
	
}	// Cleanup


//*****************************************************************************
//
// Set and get gain
//
//*****************************************************************************

ECHOSTATUS CMonitorCtrl::SetGain
(
	WORD 	wBusIn, 
	WORD 	wBusOut, 
	INT32 iGain,
	BOOL 	fImmediate
)
{
	ECHOSTATUS Status;

	if (NULL == m_pEG)
		return ECHOSTATUS_DSP_DEAD;
	
	if (	(NULL == m_Gains) ||
			(NULL == m_PanDbs) )
		return ECHOSTATUS_NO_MEM;
	
	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::SetGain - out of range   in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}
	
	//
	// Round down to the nearest even bus
	//
	wBusOut &= 0xfffe;

	//
	// Figure out the index into the array
	//
	WORD wIndex = GetIndex(wBusIn,wBusOut);
	
	if (ECHOGAIN_UPDATE == iGain)
	{
		iGain = DSP_TO_GENERIC( m_Gains[ wIndex ] );
	}
	else
	{
		if (iGain > ECHOGAIN_MAXOUT)
			iGain = ECHOGAIN_MAXOUT;
		else if (iGain < ECHOGAIN_MUTED)
			iGain = ECHOGAIN_MUTED;
	
		m_Gains[ wIndex ] = (INT8) GENERIC_TO_DSP( iGain );
		
		//
		// Gain has changed; store the notify
		//
		m_pEG->MixerControlChanged(ECHO_MONITOR,MXN_LEVEL,wBusIn,wBusOut);
	}
		
	//
	// Use the gain that was passed in, the pan setting,
	// and the mute to calculate the left and right gains
	//		
	INT32 iLeft = iGain + DSP_TO_GENERIC( m_PanDbs[wIndex].iLeft );
	INT32 iRight = iGain + DSP_TO_GENERIC( m_PanDbs[wIndex].iRight );
	
	//
	// Adjust left and right by the output bus gain
	//
	iLeft += m_pEG->m_BusOutLineLevels[wBusOut].GetGain();
	iRight += m_pEG->m_BusOutLineLevels[wBusOut + 1].GetGain();

	//
	// Either mute or clamp
	//
	if (TRUE == m_Mutes[wIndex])
	{
		iLeft = ECHOGAIN_MUTED;
		iRight = ECHOGAIN_MUTED;
	}
	else
	{
		if ( m_pEG->m_BusOutLineLevels[wBusOut].IsMuteOn() )
		{
			iLeft = ECHOGAIN_MUTED;
		}
		else
		{
			//
			// Clamp left
			//
			if (iLeft > ECHOGAIN_MAXOUT)
				iLeft = ECHOGAIN_MAXOUT;
			else if (iLeft < ECHOGAIN_MUTED)
				iLeft = ECHOGAIN_MUTED;
		}
			
		if ( m_pEG->m_BusOutLineLevels[wBusOut + 1].IsMuteOn() )
		{
			iRight = ECHOGAIN_MUTED;
		}
		else
		{
			//
			// Clamp right
			//
			if (iRight > ECHOGAIN_MAXOUT)
				iRight = ECHOGAIN_MAXOUT;
			else if (iRight < ECHOGAIN_MUTED)
				iRight = ECHOGAIN_MUTED;
			
		}
	}


	//
	// Set the left channel
	//	
	if ( (NULL == m_pEG) ||
			(NULL == m_pEG->GetDspCommObject() ) )
		return ECHOSTATUS_DSP_DEAD;
	
		
	Status = m_pEG->
					GetDspCommObject()->
						SetAudioMonitor( 	wBusOut,
												wBusIn,
												iLeft,
												FALSE);

	//
	//	Set the right channel
	// 
	if (ECHOSTATUS_OK == Status)
	{
		Status = m_pEG->
						GetDspCommObject()->
							SetAudioMonitor( 	wBusOut + 1,
													wBusIn,
													iRight,
													fImmediate);
	}

	return Status;
}	


ECHOSTATUS CMonitorCtrl::GetGain(WORD wBusIn, WORD wBusOut, INT32 &iGain)
{
	WORD	wIndex = GetIndex(wBusIn,wBusOut);
	
	if (NULL == m_Gains)
		return ECHOSTATUS_NO_MEM;
	
	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::GetGain - out of range in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}

	iGain = DSP_TO_GENERIC( m_Gains[wIndex] );

	return ECHOSTATUS_OK;
}	


//*****************************************************************************
//
// Set and get mute
//
//*****************************************************************************

ECHOSTATUS CMonitorCtrl::SetMute
(
	WORD wBusIn, 
	WORD wBusOut, 
	BOOL bMute,
	BOOL fImmediate
)
{
	if (NULL == m_Mutes)
		return ECHOSTATUS_NO_MEM;

	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::SetMute - out of range   in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}
	
	wBusOut &= 0xfffe;	

	WORD wIndex = GetIndex(wBusIn,wBusOut);
	
	//
	// Store the mute
	//
 	m_Mutes[ wIndex ] = (BYTE) bMute;

	//
	// Store the notify
	//
	m_pEG->MixerControlChanged(ECHO_MONITOR,MXN_MUTE,wBusIn,wBusOut);
	

	//
	// Call the SetGain function to do all the heavy lifting
	// Use the ECHOGAIN_UPDATE value to tell the function to 
	// recalculate the gain setting using the currently stored value.
	//
	return SetGain(wBusIn,wBusOut,ECHOGAIN_UPDATE,fImmediate);
}	


ECHOSTATUS CMonitorCtrl::GetMute(WORD wBusIn, WORD wBusOut, BOOL &bMute)
{
	wBusOut &= 0xfffe;

	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::GetMute - out of range   in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}


	WORD	wIndex = GetIndex(wBusIn,wBusOut);
	
	if (NULL == m_Mutes)
		return ECHOSTATUS_NO_MEM;

	bMute = (BOOL) m_Mutes[ wIndex ];

	return ECHOSTATUS_OK;
}	


//*****************************************************************************
//
// Set and get pan
//
//*****************************************************************************

ECHOSTATUS CMonitorCtrl::SetPan(WORD wBusIn, WORD wBusOut, INT32 iPan)
{
	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::SetPan - out of range   in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}

	wBusOut &= 0xfffe;

	WORD	wIndex = GetIndex(wBusIn,wBusOut);		

	if (NULL == m_Pans)
		return ECHOSTATUS_NO_MEM;

	//
	// Clamp it and stash it
	//		
	if (iPan < 0)
		iPan = 0;
	else if (iPan > MAX_MIXER_PAN)
		iPan = MAX_MIXER_PAN;
		
	m_Pans[wIndex] = (WORD) iPan;

	//
	//	Convert this pan setting into left and right dB values
	// 		
	m_PanDbs[wIndex].iLeft = (INT8) GENERIC_TO_DSP( PanToDb(MAX_MIXER_PAN - iPan) );
	m_PanDbs[wIndex].iRight = (INT8) GENERIC_TO_DSP( PanToDb(iPan) );

	//
	// Store the notify
	//
	m_pEG->MixerControlChanged(ECHO_MONITOR,MXN_PAN,wBusIn,wBusOut);

	//
	// Once again SetGain does all the hard work
	//
	return SetGain(wBusIn,wBusOut,ECHOGAIN_UPDATE);
}	


ECHOSTATUS CMonitorCtrl::GetPan(WORD wBusIn, WORD wBusOut, INT32 &iPan)
{
	if (	(wBusIn >= m_wNumBussesIn) || (wBusOut >= m_wNumBussesOut) )
	{
		ECHO_DEBUGPRINTF(("CMonitorCtrl::GetPan - out of range   in %d out %d\n",
								wBusIn,wBusOut));
		return ECHOSTATUS_INVALID_PARAM;		
	}


	wBusOut &= 0xfffe;

	WORD	wIndex = GetIndex(wBusIn,wBusOut);
	
	if (NULL == m_Pans)
		return ECHOSTATUS_NO_MEM;

	iPan = m_Pans[ wIndex ];

	return ECHOSTATUS_OK;
}