// ****************************************************************************
//
//              CPipeOutCtrl.cpp
//
//              Class to control output pipes on cards with or without vmixers.
//
// ----------------------------------------------------------------------------
//
// 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 "CPipeOutCtrl.h"

extern INT32 PanToDb( INT32 iPan );


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

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


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

ECHOSTATUS CPipeOutCtrl::Init(CEchoGals *pEG)
{
        DWORD   dwBytes;
        WORD    wPipe,wStereoBus;

        m_Gains = NULL;
        m_Mutes = NULL;
        m_Pans = NULL;
        m_PanDbs = NULL;
        
        //
        // Cache stuff
        //
        m_pEG = pEG;
        m_wNumPipesOut = pEG->GetNumPipesOut();
        m_wNumBussesOut = pEG->GetNumBussesOut();
        m_fHasVmixer = pEG->HasVmixer();
        
        //
        // Allocate the arrays
        //
        if (m_fHasVmixer)
        {
                WORD wNumStereoBusses = m_wNumBussesOut >> 1;
                
                //
                // Allocate arrays for vmixer support
                //
                dwBytes = sizeof(INT8) * m_wNumPipesOut * wNumStereoBusses;
                OsAllocateNonPaged(dwBytes,(void **) &m_Gains);
                if (NULL == m_Gains)
                {
                        return ECHOSTATUS_NO_MEM;
                }

                dwBytes = sizeof(BYTE) * m_wNumPipesOut * wNumStereoBusses;
                OsAllocateNonPaged(dwBytes,(void **) &m_Mutes);
                if (NULL == m_Mutes)
                {
                        Cleanup();
                        return ECHOSTATUS_NO_MEM;
                }
                
                dwBytes = sizeof(WORD) * m_wNumPipesOut * wNumStereoBusses;
                OsAllocateNonPaged(dwBytes,(void **) &m_Pans);
                if (NULL == m_Pans)
                {
                        Cleanup();
                        return ECHOSTATUS_NO_MEM;
                }
                
                dwBytes = sizeof(PAN_DB) * m_wNumPipesOut * wNumStereoBusses;
                OsAllocateNonPaged(dwBytes,(void **) &m_PanDbs);
                if (NULL == m_PanDbs)
                {
                        Cleanup();
                        return ECHOSTATUS_NO_MEM;
                }
                
                //
                // Initialize pans and mutes
                //
                for (wPipe = 0; wPipe < m_wNumPipesOut; wPipe++)
                {
                        for (wStereoBus = 0; wStereoBus < wNumStereoBusses; wStereoBus++)
                        {
                                WORD wIndex;
                                
                                wIndex = GetIndex(wPipe,wStereoBus << 1);

                                //
                                //      Pans
                                // 
                                if (0 == (wPipe & 1))
                                {
                                        //
                                        // Even channel - pan hard left
                                        //
                                        m_Pans[wIndex] = 0;
                                        m_PanDbs[wIndex].iLeft = 0;
                                        m_PanDbs[wIndex].iRight = GENERIC_TO_DSP( ECHOGAIN_MUTED );
                                }
                                else
                                {
                                        //
                                        // Odd channel - pan hard right
                                        //
                                        m_Pans[wIndex] = MAX_MIXER_PAN;
                                        m_PanDbs[wIndex].iLeft = GENERIC_TO_DSP( ECHOGAIN_MUTED );
                                        m_PanDbs[wIndex].iRight = 0;
                                }
                                
                                //
                                // Mutes
                                //
                                if ((wPipe >> 1) == wStereoBus)
                                {
                                        m_Mutes[wIndex] = FALSE;
                                }
                                else
                                {
                                        m_Mutes[wIndex] = TRUE;
                                }
                                
                                //
                                // Set the gain to the DSP; use fImmedate = FALSE here
                                // to make this faster
                                //
                                SetGain(wPipe,wStereoBus << 1,ECHOGAIN_UPDATE,FALSE);
                                
                        }
                }
                        
                //
                // Set the gain one more time with the immediate flag set to
                // make sure the DSP gets the message
                //
                SetGain(0,0,ECHOGAIN_UPDATE,TRUE);
        }
        else
        {
                //
                // Allocate arrays for no vmixer support - don't need pans
                //
                dwBytes = sizeof(INT8) * m_wNumPipesOut;
                OsAllocateNonPaged(dwBytes,(void **) &m_Gains);
                if (NULL == m_Gains)
                {
                        return ECHOSTATUS_NO_MEM;
                }

                dwBytes = sizeof(BYTE) * m_wNumPipesOut;
                OsAllocateNonPaged(dwBytes,(void **) &m_Mutes);
                if (NULL == m_Mutes)
                {
                        OsFreeNonPaged(m_Gains);
                        return ECHOSTATUS_NO_MEM;
                }
                
        }         
        
        return ECHOSTATUS_OK;
        
}       // Init


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

void CPipeOutCtrl::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
//
// For cards without vmixers, output bus gain is not handled by the DSP.
// Instead, the driver adjusts the output pipe volumes by the output bus gain
// and sends that value to the DSP.
//
// For cards with vmixers, the output bus gain is handled by the DSP, so
// the gain setting does not need to take into account the output bus gain
// stored by the driver.
//
//*****************************************************************************

ECHOSTATUS CPipeOutCtrl::SetGain
(
        WORD    wPipeOut, 
        WORD    wBusOut, 
        INT32 iGain,
        BOOL    fImmediate
)
{
        INT32 iBusOutGain;
        ECHOSTATUS Status;

        if ( NULL == m_pEG)
                return ECHOSTATUS_DSP_DEAD;
                
        if (!m_fHasVmixer && (wPipeOut != wBusOut))
                return ECHOSTATUS_OK;
        
        if ((NULL == m_Gains) || (NULL == m_Mutes))
                return ECHOSTATUS_NO_MEM;
        
        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::SetGain - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }
        
        WORD wIndex = GetIndex(wPipeOut,wBusOut);

        /*
        ECHO_DEBUGPRINTF(("CPipeOutCtrl::SetGain pipe %d  bus %d  gain 0x%lx  index %d\n",
                                                        wPipeOut,wBusOut,iGain,wIndex));
        */
        
        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 );
                
                //
                // Store the notify
                //
                m_pEG->MixerControlChanged(ECHO_PIPE_OUT,MXN_LEVEL,wPipeOut,wBusOut);
        }
                
        if (m_fHasVmixer)
        {
                wBusOut &= 0xfffe;
                
                if (NULL == m_Pans)
                        return ECHOSTATUS_NO_MEM;
        
                //
                // For vmixer cards, the DSP handles the output bus gain, 
                // so no need to account for it here.  Vmixer output pipes
                // do have to handle panning.
                //
                INT32 iLeft = iGain + DSP_TO_GENERIC( m_PanDbs[wIndex].iLeft );
                INT32 iRight = iGain + DSP_TO_GENERIC( m_PanDbs[wIndex].iRight );
                
                //
                // Add master gain values
                //
                iBusOutGain = m_pEG->m_BusOutLineLevels[wBusOut].GetGain();
                iLeft += iBusOutGain;
                iBusOutGain = m_pEG->m_BusOutLineLevels[wBusOut+1].GetGain();
                iRight += iBusOutGain;
                
                //
                // Muting and clamping
                //              
                if (m_Mutes[wIndex])
                {
                        iLeft = ECHOGAIN_MUTED;
                        iRight = ECHOGAIN_MUTED;
                }
                else
                {
                        if (  (m_pEG->m_BusOutLineLevels[wBusOut].IsMuteOn()) ||
                                        (iLeft < ECHOGAIN_MUTED))
                        {
                                iLeft = ECHOGAIN_MUTED;
                        }
                        else if (iLeft > ECHOGAIN_MAXOUT)
                        {
                                iLeft = ECHOGAIN_MAXOUT;                                
                        }

                        if (  (m_pEG->m_BusOutLineLevels[wBusOut + 1].IsMuteOn()) ||
                                        (iRight < ECHOGAIN_MUTED))
                        {
                                iRight = ECHOGAIN_MUTED;
                        }
                        else if (iRight > ECHOGAIN_MAXOUT)
                        {
                                iRight = ECHOGAIN_MAXOUT;                               
                        }
                }
                
                //
                // Set the left channel gain
                //
                Status = m_pEG->GetDspCommObject()->SetPipeOutGain(wPipeOut,
                                                                                                                                                        wBusOut,
                                                                                                                                                        iLeft,
                                                                                                                                                        FALSE);
                if (ECHOSTATUS_OK == Status)
                {
                        //
                        // And the right channel
                        //
                        Status = m_pEG->GetDspCommObject()->SetPipeOutGain(wPipeOut,
                                                                                                                                                                wBusOut + 1,
                                                                                                                                                                iRight,
                                                                                                                                                                fImmediate);
                }
                
        }
        else
        {
                //
                // Add this output pipe gain to the output bus gain
                // Since these gains are in decibels, it's OK to just add them
                //
                iBusOutGain = m_pEG->m_BusOutLineLevels[wBusOut].GetGain();
                iGain += iBusOutGain;

                //
                // Mute this output pipe if this output bus is muted
                //      
                if (m_Mutes[ wIndex ] ||
                         (m_pEG->m_BusOutLineLevels[wBusOut].IsMuteOn()) )
                {
                        iGain = ECHOGAIN_MUTED;
                }
                else
                {
                        //
                        // Clamp the output pipe gain if necessary
                        //
                        if (iGain < ECHOGAIN_MUTED)
                                iGain = ECHOGAIN_MUTED;
                        else if (iGain > ECHOGAIN_MAXOUT)
                                iGain = ECHOGAIN_MAXOUT;
                        
                }

                //
                // Set the gain
                //
                Status = m_pEG->GetDspCommObject()->SetPipeOutGain(wPipeOut,
                                                                                                                                                        wBusOut,
                                                                                                                                                        iGain,
                                                                                                                                                        fImmediate);

        }
        
        return Status;
}       


ECHOSTATUS CPipeOutCtrl::GetGain(WORD wPipeOut, WORD wBusOut, INT32 &iGain)
{
        WORD    wIndex = GetIndex(wPipeOut,wBusOut);
        
        if (NULL == m_Gains)
                return ECHOSTATUS_NO_MEM;

        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::GetGain - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }

        iGain = DSP_TO_GENERIC( m_Gains[wIndex] );

        /*
        ECHO_DEBUGPRINTF(("CPipeOutCtrl::GetGain pipe %d  bus %d  gain 0x%lx  index %d\n",
                                                        wPipeOut,wBusOut,iGain,wIndex));
        */
                                        
        return ECHOSTATUS_OK;
}       


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

ECHOSTATUS CPipeOutCtrl::SetMute
(
        WORD wPipeOut, 
        WORD wBusOut, 
        BOOL bMute,
        BOOL fImmediate
)
{
        if (!m_fHasVmixer && (wPipeOut != wBusOut))
                return ECHOSTATUS_OK;

        if (NULL == m_Mutes)
                return ECHOSTATUS_NO_MEM;

        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::SetMute - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }

        WORD wIndex = GetIndex(wPipeOut,wBusOut);
        
        /*
        ECHO_DEBUGPRINTF(("CPipeOutCtrl::SetMute wPipeOut %d  wBusOut %d  bMute %ld\n",
                                                        wPipeOut,wBusOut,bMute));
        */
        
        //
        // Store the mute
        //
        m_Mutes[ wIndex ] = (BYTE) bMute;

        //
        // Store the notify
        //
        m_pEG->MixerControlChanged(ECHO_PIPE_OUT,MXN_MUTE,wPipeOut,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(wPipeOut,wBusOut,ECHOGAIN_UPDATE,fImmediate);
}       


ECHOSTATUS CPipeOutCtrl::GetMute(WORD wPipeOut, WORD wBusOut, BOOL &bMute)
{
        WORD    wIndex = GetIndex(wPipeOut,wBusOut);
        
        if (NULL == m_Mutes)
                return ECHOSTATUS_NO_MEM;

        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::GetMute - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }

        bMute = (BOOL) m_Mutes[ wIndex ];

        /*
        ECHO_DEBUGPRINTF(("CPipeOutCtrl::GetMute wPipeOut %d  wBusOut %d  bMute %ld\n",
                                                        wPipeOut,wBusOut,bMute));
        */

        return ECHOSTATUS_OK;
}       


//*****************************************************************************
//
// Set and get pan (vmixer only)
//
//*****************************************************************************

ECHOSTATUS CPipeOutCtrl::SetPan(WORD wPipeOut, WORD wBusOut, INT32 iPan)
{
        if (!m_fHasVmixer)
                return ECHOSTATUS_OK;
                
        if (NULL == m_Pans)
                return ECHOSTATUS_NO_MEM;
        
        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::SetPan - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }
                

        WORD    wIndex = GetIndex(wPipeOut,wBusOut);            

        //
        // 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;

        //
        // Store the notify
        //
        m_pEG->MixerControlChanged(ECHO_PIPE_OUT,MXN_PAN,wPipeOut,wBusOut);

        //
        //      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) );

        //
        // Again, SetGain does all the hard work
        //      
        return SetGain(wPipeOut,wBusOut,ECHOGAIN_UPDATE);
}       


ECHOSTATUS CPipeOutCtrl::GetPan(WORD wPipeOut, WORD wBusOut, INT32 &iPan)
{
        WORD    wIndex = GetIndex(wPipeOut,wBusOut);
        
        if (NULL == m_Pans)
                return ECHOSTATUS_NO_MEM;

        if ((wPipeOut >= m_wNumPipesOut) || (wBusOut >= m_wNumBussesOut))
        {
                ECHO_DEBUGPRINTF(("CPipeOutCtrl::GetPan - out of range pipe %d bus %d\n",
                                                                wPipeOut,wBusOut));
                return ECHOSTATUS_INVALID_PARAM;                
        }

        iPan = m_Pans[ wIndex ];

        return ECHOSTATUS_OK;
}