// **************************************************************************** // // CChannelMask.cpp // // Implementation file for the CChannelMask class. // // CChannelMask is a handy way to specify a group of pipes simultaneously. // It should really be called "CPipeMask", but the class name predates // the term "pipe". // // Since these masks are sometimes passed to the DSP, they must be kept in // little-endian format; the class does this for you. // // ---------------------------------------------------------------------------- // // 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" /**************************************************************************** CChannelMask ****************************************************************************/ //=========================================================================== // // Constructor // //=========================================================================== CChannelMask::CChannelMask() { Clear(); } // CChannelMask::CChannelMask() //=========================================================================== // // SetMask, SetOutMask, and SetInMask all allow you to just set // the masks directly. // //=========================================================================== void CChannelMask::SetMask( CH_MASK OutMask, CH_MASK InMask, int nOutputs ) { m_Mask = OutMask; m_Mask |= InMask << nOutputs; } // void CChannelMask::SetMask( ... ) void CChannelMask::SetOutMask( CH_MASK OutMask, int nOutputs ) { m_Mask &= ((CH_MASK) -1) << nOutputs; m_Mask |= OutMask; } // void CChannelMask::SetOutMask( CH_MASK OutMask, int nOutputs ) void CChannelMask::SetInMask( CH_MASK InMask, int nOutputs ) { m_Mask &= ~( (CH_MASK) -1 << nOutputs ); m_Mask |= InMask << nOutputs; } // void CChannelMask::SetInMask( CH_MASK InMask, int nOutputs ) //=========================================================================== // // Retrieve an output bit mask and an input bitmask. // //=========================================================================== void CChannelMask::GetMask( CH_MASK & OutMask, CH_MASK & InMask, int nOutputs ) { OutMask = GetOutMask( nOutputs ); InMask = GetInMask( nOutputs ); } // void CChannelMask::GetMask( ... ) CH_MASK CChannelMask::GetOutMask( int nOutputs ) { return m_Mask & ~( (CH_MASK) -1 << nOutputs ); } // CH_MASK CChannelMask::GetOutMask( int nOutputs ) CH_MASK CChannelMask::GetInMask( int nOutputs ) { return m_Mask >> nOutputs; } // CH_MASK CChannelMask::GetIntMask( int nOutputs ) //=========================================================================== // // IsEmpty returns TRUE if mask has no bits set // //=========================================================================== BOOL CChannelMask::IsEmpty() { if (0 != m_Mask) return FALSE; return TRUE; } // void CChannelMask::IsEmpty() //=========================================================================== // // Call SetIndexInMask and ClearIndexInMask to set or clear a single bit. // //=========================================================================== // Set driver channel index into DSP mask format void CChannelMask::SetIndexInMask( WORD wPipeIndex ) { m_Mask |= 1 << wPipeIndex; } // void CChannelMask::SetIndexInMask( WORD wPipeIndex ) // Clear driver channel index into DSP mask format void CChannelMask::ClearIndexInMask( WORD wPipeIndex ) { m_Mask &= ~((CH_MASK) 1 << wPipeIndex); } // void CChannelMask::ClearIndexInMask( WORD wPipeIndex ) //=========================================================================== // // Use GetIndexFromMask to search the mask for bits that are set. // // The search starts at the bit specified by wStartPipeIndex and returns // the pipe index for the first non-zero bit found. // // Returns ECHO_INVALID_CHANNEL if none are found. // //=========================================================================== WORD CChannelMask::GetIndexFromMask( WORD wStartPipeIndex ) { CH_MASK bit; WORD index; bit = 1 << wStartPipeIndex; index = wStartPipeIndex; while (bit != 0) { if (0 != (m_Mask & bit)) return index; bit <<= 1; index++; } return( (WORD) ECHO_INVALID_CHANNEL ); } // WORD CChannelMask::GetIndexFromMask( WORD wStartIndex ) //=========================================================================== // // Returns TRUE if the bit specified by the pipe index is set. // //=========================================================================== BOOL CChannelMask::TestIndexInMask( WORD wPipeIndex ) { if (0 != (m_Mask & ((CH_MASK) 1 << wPipeIndex))) return TRUE; return FALSE; } // BOOL CChannelMask::TestIndexInMask( WORD wPipeIndex ) //=========================================================================== // // Clear bits in this mask that are in SrcMask - this is just like // operator -=, below. // //=========================================================================== void CChannelMask::ClearMask( CChannelMask SrcMask ) { m_Mask &= ~SrcMask.m_Mask; } // void CChannelMask::ClearMask( CChannelMask SrcMask ) //=========================================================================== // // Clear all channels in this mask // //=========================================================================== void CChannelMask::Clear() { m_Mask = 0; } // void CChannelMask::Clear() //=========================================================================== // // operator += Add channels in source mask to this mask // //=========================================================================== VOID CChannelMask::operator += (CONST CChannelMask & RVal) { m_Mask |= RVal.m_Mask; } // VOID operator += (CONST CChannelMask & RVal) //=========================================================================== // // operator -= Remove channels in source mask from this mask // //=========================================================================== VOID CChannelMask::operator -= (CONST CChannelMask & RVal) { ClearMask(RVal); } // VOID operator -= (CONST CChannelMask & RVal) //=========================================================================== // // Test returns TRUE if any bits in source mask are set in this mask // //=========================================================================== BOOL CChannelMask::Test( PCChannelMask pSrcMask ) { if (0 != (m_Mask & pSrcMask->m_Mask)) return TRUE; return FALSE; } // BOOL CChannelMask::Test( PChannelMask pSrcMask ) //=========================================================================== // // IsSubsetOf returns TRUE if all of the channels in TstMask are set in // m_Mask. // // Use to be sure all channels in this instance exist in // another instance. // //=========================================================================== BOOL CChannelMask::IsSubsetOf ( CChannelMask& TstMask ) { if ((m_Mask & TstMask.m_Mask) != TstMask.m_Mask) return FALSE; return TRUE; } // BOOL CChannelMask::IsSubsetOf //=========================================================================== // // IsIntersectionOf returns TRUE if TstMask contains at least one of the // channels enabled in this instance. // // Use this to find out if any channels in this instance exist in // another instance. // //=========================================================================== BOOL CChannelMask::IsIntersectionOf ( CChannelMask& TstMask ) { if (0 != (m_Mask & TstMask.m_Mask)) return TRUE; return FALSE; } // BOOL CChannelMask::IsIntersectionOf //=========================================================================== // // Operator == is just what you'd expect - it tells you if one mask is // the same as another // //=========================================================================== BOOLEAN operator == ( CONST CChannelMask &LVal, CONST CChannelMask &RVal ) { if (LVal.m_Mask != RVal.m_Mask) return FALSE; return TRUE; } // BOOLEAN operator == ( CONST CChannelMask &LVal, CONST CChannelMask &RVal ) //=========================================================================== // // Operator = just copies from one mask to another. // //=========================================================================== CChannelMask& CChannelMask::operator =(CONST CChannelMask & RVal) { if ( &RVal == this ) return *this; m_Mask = RVal.m_Mask; return *this; } // CChannelMask& CChannelMask::operator = (CONTS CChannelMask & RVal) //=========================================================================== // // Operator & performs a bitwise logical AND // //=========================================================================== VOID CChannelMask::operator &= (CONST CChannelMask & RVal) { if ( &RVal == this ) return; m_Mask &= RVal.m_Mask; } // VOID CChannelMask::operator &= (CONST CChannelMask & RVal) //=========================================================================== // // Operator & performs a bitwise logical OR // //=========================================================================== VOID CChannelMask::operator |= (CONST CChannelMask & RVal) { if ( &RVal == this ) return; m_Mask |= RVal.m_Mask; } // VOID CChannelMask::operator |= (CONST CChannelMask & RVal) //=========================================================================== // // Overload new & delete so memory for this object is allocated // from non-paged memory. // //=========================================================================== PVOID CChannelMask::operator new( size_t Size ) { PVOID pMemory; ECHOSTATUS Status; Status = OsAllocateNonPaged(Size,&pMemory); if ( (ECHOSTATUS_OK != Status) || (NULL == pMemory )) { ECHO_DEBUGPRINTF(("CChannelMask::operator new - memory allocation failed\n")); pMemory = NULL; } else { memset( pMemory, 0, Size ); } return pMemory; } // PVOID CChannelMask::operator new( size_t Size ) VOID CChannelMask::operator delete( PVOID pVoid ) { if ( ECHOSTATUS_OK != OsFreeNonPaged( pVoid ) ) { ECHO_DEBUGPRINTF(("CChannelMask::operator delete memory free failed\n")); } } // VOID CChannelMask::operator delete( PVOID pVoid ) /**************************************************************************** CChMaskDsp ****************************************************************************/ //=========================================================================== // // Constructor // //=========================================================================== CChMaskDsp::CChMaskDsp() { Clear(); } // CChMaskDsp::CChMaskDsp() //=========================================================================== // // IsEmpty returns TRUE if mask has no bits set // //=========================================================================== BOOL CChMaskDsp::IsEmpty() { if (0 != m_Mask) return FALSE; return TRUE; } // void CChMaskDsp::IsEmpty() //=========================================================================== // // Call SetIndexInMask and ClearIndexInMask to set or clear a single bit. // //=========================================================================== // Set driver channel index into DSP mask format void CChMaskDsp::SetIndexInMask( WORD wPipeIndex ) { CH_MASK_DSP bit,temp; temp = SWAP( m_Mask ); bit = 1 << wPipeIndex; temp |= bit; m_Mask = SWAP( temp ); } // void CChMaskDsp::SetIndexInMask( WORD wPipeIndex ) // Clear driver channel index into DSP mask format void CChMaskDsp::ClearIndexInMask( WORD wPipeIndex ) { CH_MASK_DSP bit,temp; temp = SWAP( m_Mask ); bit = 1 << wPipeIndex; temp &= ~bit; m_Mask = SWAP( temp ); } // void CChMaskDsp::SetIndexInMask( WORD wPipeIndex ) //=========================================================================== // // Returns TRUE if the bit specified by the pipe index is set. // //=========================================================================== BOOL CChMaskDsp::TestIndexInMask( WORD wPipeIndex ) { CH_MASK_DSP temp,bit; temp = SWAP(m_Mask); bit = 1 << wPipeIndex; if (0 != (temp & bit)) return TRUE; return FALSE; } // BOOL CChMaskDsp::TestIndexInMask( WORD wPipeIndex ) //=========================================================================== // // Clear all channels in this mask // //=========================================================================== void CChMaskDsp::Clear() { m_Mask = 0; } // void CChMaskDsp::Clear() //=========================================================================== // // Operator = just copies from one mask to another. // //=========================================================================== CChMaskDsp& CChMaskDsp::operator =(CONST CChannelMask & RVal) { m_Mask = SWAP(RVal.m_Mask); return *this; } // CChMaskDsp& CChMaskDsp::operator =(CONST CChannelMask & RVal) //=========================================================================== // // Overload new & delete so memory for this object is allocated // from non-paged memory. // //=========================================================================== PVOID CChMaskDsp::operator new( size_t Size ) { PVOID pMemory; ECHOSTATUS Status; Status = OsAllocateNonPaged(Size,&pMemory); if ( (ECHOSTATUS_OK != Status) || (NULL == pMemory )) { ECHO_DEBUGPRINTF(("CChMaskDsp::operator new memory allocation failed\n")); pMemory = NULL; } else { memset( pMemory, 0, Size ); } return pMemory; } // PVOID CChMaskDsp::operator new( size_t Size ) VOID CChMaskDsp::operator delete( PVOID pVoid ) { if ( ECHOSTATUS_OK != OsFreeNonPaged( pVoid ) ) { ECHO_DEBUGPRINTF(("CChMaskDsp::operator delete memory free failed\n")); } } // VOID CChMaskDsp::operator delete( PVOID pVoid ) // ChannelMask.cpp
