Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed some warnings in multi.cpp

Browse Source 
updated with Release B3 (I didn't test yet) :
-Firmware to support new revision 5 Indigo io and Indigo dj hardware
-Firmware to support new revision 4 Mia MIDI hardware
-New FPGA & DSP code to correct problems with S/PDIF at 96 kHz on Gina3G (note new,
longer timeout required in C3gDco.cpp)
-Changes to support x64 Windows
-Fix for 96 kHz on Mac OS X for Echo 3G
-New QuerySampleRateRange method for all devices
-Simplified channel mask classes
-New ECHO_ASSERT macro to simplfy enabling and disabling asserts
-Removed m_wBytesPerSample from CEchoGals; it wasn't being used and caused housekeeping problems for Adobe Audition recording in mono mode
-Now using READ_REGISTER_ULONG and WRITE_REGISTER_ULONG macros to read and write DSP registers; these
are automatically defined if the platform environment doesn't define them.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20394 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Jérôme Duval 2007-03-19 19:06:47 +00:00
parent 467b8adffa
commit 4dd9e43637
54 changed files with 9597 additions and 9430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15245
src/add-ons/kernel/drivers/audio/echo/generic/ASIC/3G_ASIC.c
View File

File diff suppressed because it is too large Load Diff

14
src/add-ons/kernel/drivers/audio/echo/generic/C3g.cpp
View File

@ -137,7 +137,7 @@ ECHOSTATUS C3g::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new C3gDco( (PDWORD) m_pvSharedMemory, m_pOsSupport );
if (NULL == m_pDspCommObject)
{
@ -311,6 +311,14 @@ ECHOSTATUS C3g::QueryAudioSampleRate
} // ECHOSTATUS C3g::QueryAudioSampleRate
void C3g::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 32000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input
@ -493,9 +501,9 @@ ECHOSTATUS C3g::Start
BOOL intersect;
//
// See if ADAT in 3-8 or out 3-8 have been opened
// See if ADAT in 3-8 or out 3-8 are being started
//
intersect = m_cmAudioOpen.IsIntersectionOf( pDCO->m_Adat38Mask );
intersect = pChannelMask->IsIntersectionOf( pDCO->m_Adat38Mask );
if (intersect)
{
ECHO_DEBUGPRINTF(("Cannot start ADAT channels 3-8 in double speed mode\n"));

2
src/add-ons/kernel/drivers/audio/echo/generic/C3g.h
View File

@ -81,6 +81,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Start transport for several pipes at once
//

24
src/add-ons/kernel/drivers/audio/echo/generic/C3gDco.cpp
View File

@ -145,9 +145,9 @@ BOOL C3gDco::LoadASIC()
return FALSE;
//
// Give the ASIC a few milliseconds to set up
// Give the ASIC a whole second to set up
//
m_pOsSupport->OsSnooze( 2000 );
m_pOsSupport->OsSnooze( 1000000 );
//
// See if it worked
@ -282,8 +282,6 @@ ECHOSTATUS C3gDco::SetInputClock(WORD wClock)
//
// Set the audio sample rate for 3G
//
// fixme - it's pointless to return the sample rate back?
//
//===========================================================================
DWORD C3gDco::SetSampleRate( DWORD dwNewSampleRate )
@ -381,6 +379,12 @@ DWORD C3gDco::SetSampleRate( DWORD dwNewSampleRate )
ECHO_DEBUGPRINTF( ("C3gDco::SetSampleRate: %ld clock %lx\n", dwNewSampleRate, dwControlReg) );
}
else
{
ECHO_DEBUGPRINTF( ("C3gDco::SetSampleRate: could not set sample rate %ld\n", dwNewSampleRate) );
dwNewSampleRate = SWAP( m_pDspCommPage->dwSampleRate );
}
return dwNewSampleRate;
@ -652,7 +656,10 @@ BOOL C3gDco::CheckAsicStatus()
DWORD dwBoxStatus,dwBoxType;
if ( !WaitForHandshake() )
{
ECHO_DEBUGPRINTF(("CheckAsicStatus - no handshake!\n"));
return FALSE;
}
//
// Send the vector command
@ -667,6 +674,7 @@ BOOL C3gDco::CheckAsicStatus()
//
if ( !WaitForHandshake() )
{
ECHO_DEBUGPRINTF(("CheckAsicStatus - no handshake after VC\n"));
m_pwDspCode = NULL;
m_ullLastLoadAttemptTime = 0; // so LoadFirmware will try again right away
return FALSE;
@ -678,12 +686,14 @@ BOOL C3gDco::CheckAsicStatus()
dwBoxStatus = SWAP(m_pDspCommPage->dwExtBoxStatus);
if (E3G_ASIC_NOT_LOADED == dwBoxStatus)
{
ECHO_DEBUGPRINTF(("CheckAsicStatus - ASIC not loaded\n"));
dwBoxType = NO3GBOX;
}
else
{
dwBoxType = dwBoxStatus & E3G_BOX_TYPE_MASK;
m_bASICLoaded = TRUE;
ECHO_DEBUGPRINTF(("CheckAsicStatus - read box type %x\n",dwBoxType));
}
m_dwCurrentBoxType = dwBoxType;
@ -700,10 +710,11 @@ BOOL C3gDco::CheckAsicStatus()
if ( (NO3GBOX == dwBoxType) ||
(dwBoxType != m_dwOriginalBoxType) )
{
//GoComatose();
ECHO_DEBUGPRINTF(("CheckAsicStatus - box type mismatch - original %x, got %x\n",m_dwOriginalBoxType,dwBoxType));
return FALSE;
}
ECHO_DEBUGPRINTF(("CheckAsicStatus - ASIC ok\n"));
m_bASICLoaded = TRUE;
return TRUE;
}
@ -720,7 +731,10 @@ BOOL C3gDco::CheckAsicStatus()
// Set the bad board flag if no external box
//
if (NO3GBOX == dwBoxType)
{
ECHO_DEBUGPRINTF(("CheckAsicStatus - no external box\n"));
m_bBadBoard = TRUE;
}
return m_bASICLoaded;

2
src/add-ons/kernel/drivers/audio/echo/generic/C3gDco.h
View File

@ -132,7 +132,7 @@ protected:
// Returns 3G frequency register
//
DWORD Get3gFreqReg()
{ ASSERT( NULL != m_pDspCommPage );
{ ECHO_ASSERT(NULL != m_pDspCommPage );
return SWAP( m_pDspCommPage->dw3gFreqReg ); }
//

64
src/add-ons/kernel/drivers/audio/echo/generic/CChannelMask.cpp
View File

@ -447,10 +447,7 @@ CChMaskDsp::CChMaskDsp()
BOOL CChMaskDsp::IsEmpty()
{
int i;
for ( i = 0; i < CH_MASK_SZ; i++ )
if ( 0 != m_MaskRegs[ i ] )
if (0 != m_Mask)
return FALSE;
return TRUE;
@ -467,17 +464,25 @@ BOOL CChMaskDsp::IsEmpty()
// 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 );
m_MaskRegs[ wPipeIndex / CH_MASK_DSP_BITS ] |=
SWAP( (CH_MASK_DSP)(( (CH_MASK_DSP) 1 ) << ( wPipeIndex % CH_MASK_DSP_BITS ) ) );
} // void CChMaskDsp::SetIndexInMask( WORD wPipeIndex )
// Clear driver channel index into DSP mask format
void CChMaskDsp::ClearIndexInMask( WORD wPipeIndex )
{
m_MaskRegs[ wPipeIndex / CH_MASK_DSP_BITS ] &=
SWAP( (CH_MASK_DSP)(~( ( (CH_MASK_DSP) 1 ) << ( wPipeIndex % CH_MASK_DSP_BITS ) ) ) );
CH_MASK_DSP bit,temp;
temp = SWAP( m_Mask );
bit = 1 << wPipeIndex;
temp &= ~bit;
m_Mask = SWAP( temp );
} // void CChMaskDsp::SetIndexInMask( WORD wPipeIndex )
@ -490,8 +495,11 @@ void CChMaskDsp::ClearIndexInMask( WORD wPipeIndex )
BOOL CChMaskDsp::TestIndexInMask( WORD wPipeIndex )
{
if ( m_MaskRegs[ wPipeIndex / CH_MASK_DSP_BITS ] &
SWAP( (CH_MASK_DSP)( ( (CH_MASK_DSP) 1 ) << ( wPipeIndex % CH_MASK_DSP_BITS ) ) ) )
CH_MASK_DSP temp,bit;
temp = SWAP(m_Mask);
bit = 1 << wPipeIndex;
if (0 != (temp & bit))
return TRUE;
return FALSE;
@ -507,41 +515,10 @@ BOOL CChMaskDsp::TestIndexInMask( WORD wPipeIndex )
void CChMaskDsp::Clear()
{
int i;
for ( i = 0; i < CH_MASK_SZ; i++ )
m_MaskRegs[ i ] = 0;
m_Mask = 0;
} // void CChMaskDsp::Clear()
//===========================================================================
//
// operator += Add channels in source mask to this mask
//
//===========================================================================
VOID CChMaskDsp::operator += (CONST CChannelMask & RVal)
{
CH_MASK * pMask = (CH_MASK *) &m_MaskRegs[ 0 ];
*pMask |= RVal.m_Mask;
} // VOID operator += (CONST CChMaskDsp & RVal)
//===========================================================================
//
// operator -= Remove channels in source mask from this mask
//
//===========================================================================
VOID CChMaskDsp::operator -= (CONST CChannelMask & RVal)
{
CH_MASK * pMask = (CH_MASK *) &m_MaskRegs[ 0 ];
*pMask &= ~RVal.m_Mask;
} // VOID operator += (CONST CChMaskDsp & RVal)
//===========================================================================
//
// Operator = just copies from one mask to another.
@ -550,9 +527,8 @@ VOID CChMaskDsp::operator -= (CONST CChannelMask & RVal)
CChMaskDsp& CChMaskDsp::operator =(CONST CChannelMask & RVal)
{
CH_MASK * pMask = (CH_MASK *) &m_MaskRegs[ 0 ];
m_Mask = SWAP(RVal.m_Mask);
*pMask = RVal.m_Mask;
return *this;
} // CChMaskDsp& CChMaskDsp::operator =(CONST CChannelMask & RVal)

29
src/add-ons/kernel/drivers/audio/echo/generic/CChannelMask.h
View File

@ -54,7 +54,7 @@ typedef unsigned long CH_MASK;
#define ECHO_INVALID_CHANNEL ((WORD)(-1))
// Marks unused channel #
typedef unsigned short CH_MASK_DSP;
typedef unsigned long CH_MASK_DSP;
#define CH_MASK_DSP_BITS (sizeof( CH_MASK_DSP ) * 8)
// Max bits per mask entry
@ -79,6 +79,11 @@ public:
CChannelMask();
~CChannelMask() {}
CH_MASK GetMask()
{
return m_Mask;
}
// Returns TRUE if no bits set
BOOL IsEmpty();
@ -184,18 +189,9 @@ typedef CChannelMask * PCChannelMask;
class CChMaskDsp
{
protected:
enum
{
CH_MASK_SZ = 4 / sizeof(CH_MASK_DSP)
};
CH_MASK_DSP m_MaskRegs[ CH_MASK_SZ ]; // One bit per output or input channel
// 32 bits total
public:
CH_MASK_DSP m_Mask; // One bit per output or input channel
// 32 bits total
CChMaskDsp();
~CChMaskDsp() {}
@ -227,18 +223,9 @@ public:
//
friend class CChannelMask;
inline CH_MASK_DSP operator [] ( int iNdx )
{ return SWAP( m_MaskRegs[ iNdx ] ); }
// Copy mask bits in source to this mask
CChMaskDsp& operator = (CONST CChannelMask & RVal);
// Add mask bits in source to this mask
VOID operator += (CONST CChannelMask & RVal);
// Subtract mask bits in source to this mask
VOID operator -= (CONST CChannelMask & RVal);
protected :
}; // class CChMaskDsp

2
src/add-ons/kernel/drivers/audio/echo/generic/CDaffyDuck.cpp
View File

@ -380,7 +380,7 @@ ECHOSTATUS CDaffyDuck::AddDoubleZero()
void CDaffyDuck::Wrap()
{
ASSERT(m_dwCount != MAX_ENTRIES);
ECHO_ASSERT(m_dwCount != MAX_ENTRIES);
//
// Put in the address of the start of the duck entries

10
src/add-ons/kernel/drivers/audio/echo/generic/CDarla.cpp
View File

@ -129,7 +129,7 @@ ECHOSTATUS CDarla::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CDarlaDspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -202,4 +202,12 @@ ECHOSTATUS CDarla::QueryAudioSampleRate
} // ECHOSTATUS CDarla::QueryAudioSampleRate
void CDarla::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 44100;
dwMaxRate = 48000;
}
// *** CDarla.cpp ***

2
src/add-ons/kernel/drivers/audio/echo/generic/CDarla.h
View File

@ -63,6 +63,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Overload new & delete so memory for this object is allocated from non-paged memory.
//

9
src/add-ons/kernel/drivers/audio/echo/generic/CDarla24.cpp
View File

@ -129,7 +129,7 @@ ECHOSTATUS CDarla24::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CDarla24DspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -292,5 +292,12 @@ ECHOSTATUS CDarla24::QueryAudioSampleRate
} // ECHOSTATUS CDarla24::QueryAudioSampleRate
void CDarla24::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 8000;
dwMaxRate = 96000;
}
// *** CDarla24.cpp ***

2
src/add-ons/kernel/drivers/audio/echo/generic/CDarla24.h
View File

@ -81,6 +81,8 @@ public:
(
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Overload new & delete so memory for this object is allocated from

27
src/add-ons/kernel/drivers/audio/echo/generic/CDspCommObject.cpp
View File

@ -96,7 +96,7 @@ CDspCommObject::CDspCommObject
{
INT32 i;
ASSERT( pOsSupport );
ECHO_ASSERT(pOsSupport );
//
// Init all the basic stuff
@ -274,6 +274,9 @@ BOOL CDspCommObject::LoadASIC
)
{
DWORD i;
#ifdef _WIN32
DWORD dwChecksum = 0;
#endif
ECHO_DEBUGPRINTF(("CDspCommObject::LoadASIC\n"));
@ -281,7 +284,6 @@ BOOL CDspCommObject::LoadASIC
return TRUE;
#ifdef _DEBUG
DWORD dwChecksum = 0;
ULONGLONG ullStartTime, ullCurTime;
m_pOsSupport->OsGetSystemTime( &ullStartTime );
#endif
@ -296,7 +298,7 @@ BOOL CDspCommObject::LoadASIC
for ( i = 0; i < dwSize; i++ )
{
#ifdef _DEBUG
#ifdef _WIN32
dwChecksum += pCode[i];
#endif
@ -311,11 +313,15 @@ BOOL CDspCommObject::LoadASIC
m_pOsSupport->OsGetSystemTime( &ullCurTime );
ECHO_DEBUGPRINTF( ("CDspCommObject::LoadASIC took %ld usec.\n",
(ULONG) ( ullCurTime - ullStartTime ) ) );
ECHO_DEBUGPRINTF(("\tChecksum is 0x%lx\n",dwChecksum));
ECHO_DEBUGPRINTF(("ASIC load OK\n"));
#endif
#if defined(_WIN32) && (DBG)
DbgPrint("--- ASIC checksum is 0x%lx\n",dwChecksum);
#endif
return TRUE;
} // BOOL CDspCommObject::LoadASIC( DWORD dwCmd, PBYTE pCode, DWORD dwSize )
@ -704,6 +710,8 @@ set_dsp_format_bits:
} // DWORD CDspCommObject::LoadDSP
//===========================================================================
//
// LoadFirmware takes care of loading the DSP and any ASIC code.
@ -933,6 +941,8 @@ ECHOSTATUS CDspCommObject::Write_DSP
} // ECHOSTATUS CDspCommObject::Write_DSP
//===========================================================================
//
// Read_DSP reads a 32-bit value from the DSP; this is used almost
@ -972,6 +982,7 @@ ECHOSTATUS CDspCommObject::Read_DSP
} // ECHOSTATUS CDspCommObject::Read_DSP
//===========================================================================
//
// Much of the interaction between the DSP and the driver is done via vector
@ -1086,6 +1097,7 @@ ECHOSTATUS CDspCommObject::SendVector
} // ECHOSTATUS CDspCommObject::SendVector
//===========================================================================
//
// Some vector commands involve the DSP reading or writing data to and
@ -1098,13 +1110,12 @@ ECHOSTATUS CDspCommObject::SendVector
BOOL CDspCommObject::WaitForHandshake()
{
DWORD dwDelta;
ULONGLONG ullDelta;
ULONGLONG ullStartTime,ullTime;
//
// Wait up to three milliseconds for the handshake from the DSP
//
dwDelta = 0;
m_pOsSupport->OsGetSystemTime( &ullStartTime );
do
{
@ -1118,8 +1129,8 @@ BOOL CDspCommObject::WaitForHandshake()
m_pOsSupport->OsSnooze( 2 );
m_pOsSupport->OsGetSystemTime(&ullTime);
dwDelta = (DWORD) (ullTime - ullStartTime);
} while (dwDelta < HANDSHAKE_TIMEOUT);
ullDelta = ullTime - ullStartTime;
} while (ullDelta < (ULONGLONG) HANDSHAKE_TIMEOUT);
ECHO_DEBUGPRINTF( ("CDspCommObject::WaitForHandshake: Timeout waiting "
"for DSP\n") );

78
src/add-ons/kernel/drivers/audio/echo/generic/CDspCommObject.h
View File

@ -243,6 +243,10 @@ SET_LAYLA24_FREQUENCY_REG command.
#define DSP_VC_UPDATE_FLAGS 0x00FB // Handshke rqd.
#define DSP_VC_GO_COMATOSE 0x00d9
#ifdef SUPERMIX
#define DSP_VC_TRIGGER 0x00f3
#endif
#endif
@ -268,6 +272,10 @@ SET_LAYLA24_FREQUENCY_REG command.
// set it for AC3 or WMA or some such
#define DSP_FLAG_PROFESSIONAL_SPDIF 0x0008 // 1 Professional, 0 Consumer
#ifdef SUPERMIX
#define DSP_FLAG_SUPERMIX_SRC 0x0080 // Turn on sample rate conversion for supermixer
#endif
//==================================================================================
@ -527,6 +535,21 @@ SET_LAYLA24_FREQUENCY_REG command.
#define DSP_MIDI_OUT_FIFO_SIZE 64
//==================================================================================
//
// Macros for reading and writing DSP registers
//
//==================================================================================
#ifndef READ_REGISTER_ULONG
#define READ_REGISTER_ULONG(ptr) ( *(ptr) )
#endif
#ifndef WRITE_REGISTER_ULONG
#define WRITE_REGISTER_ULONG(ptr,val) *(ptr) = val
#endif
/****************************************************************************
The comm page. This structure is read and written by the DSP; the
@ -611,7 +634,7 @@ typedef struct
class CDspCommObject
{
protected:
PDspCommPage m_pDspCommPage; // Physical memory seen by DSP
volatile PDspCommPage m_pDspCommPage; // Physical memory seen by DSP
PPAGE_BLOCK m_pDspCommPageBlock; // Physical memory info for COsSupport
//
@ -634,7 +657,7 @@ protected:
BOOL m_bHasASIC; // Set TRUE if card has an ASIC
BOOL m_bASICLoaded; // Set TRUE when ASIC loaded
DWORD m_dwCommPagePhys; // Physical addr of this object
PDWORD m_pdwDspRegBase; // DSP's register base
volatile PDWORD m_pdwDspRegBase; // DSP's register base
CChannelMask m_cmActive; // Chs. active mask
BOOL m_bBadBoard; // Set TRUE if DSP won't load
// or punks out
@ -711,27 +734,34 @@ protected :
// Get/Set handshake Flag
//
DWORD GetHandshakeFlag()
{ ASSERT( NULL != m_pDspCommPage );
{ ECHO_ASSERT( NULL != m_pDspCommPage );
return( SWAP( m_pDspCommPage->dwHandshake ) ); }
void ClearHandshake()
{ ASSERT( NULL != m_pDspCommPage );
{ ECHO_ASSERT( NULL != m_pDspCommPage );
m_pDspCommPage->dwHandshake = 0; }
//
// Get/set DSP registers
//
DWORD GetDspRegister( DWORD dwIndex )
{ ASSERT( NULL != m_pdwDspRegBase );
return( SWAP( m_pdwDspRegBase[ dwIndex ] ) ); }
{
ECHO_ASSERT( NULL != m_pdwDspRegBase );
return READ_REGISTER_ULONG( m_pdwDspRegBase + dwIndex);
}
void SetDspRegister( DWORD dwIndex, DWORD dwValue )
{ ASSERT( NULL != m_pdwDspRegBase );
m_pdwDspRegBase[ dwIndex ] = SWAP( dwValue ); }
{
ECHO_ASSERT( NULL != m_pdwDspRegBase );
WRITE_REGISTER_ULONG( m_pdwDspRegBase + dwIndex, dwValue);
}
//
// Set control register in CommPage
//
void SetControlRegister( DWORD dwControlRegister )
{ ASSERT( NULL != m_pDspCommPage );
{ ECHO_ASSERT( NULL != m_pDspCommPage );
m_pDspCommPage->dwControlReg = SWAP( dwControlRegister ); }
//
@ -886,7 +916,7 @@ public:
// Returns control register
//
DWORD GetControlRegister()
{ ASSERT( NULL != m_pDspCommPage );
{ ECHO_ASSERT( NULL != m_pDspCommPage );
return SWAP( m_pDspCommPage->dwControlReg ); }
//
@ -895,6 +925,13 @@ public:
virtual ECHOSTATUS SetInputClock(WORD wClock);
virtual ECHOSTATUS SetOutputClock(WORD wClock);
#ifdef COURT8_FAMILY
virtual ECHOSTATUS SetPhoneBits(DWORD dwPhoneBits)
{
return ECHOSTATUS_NOT_SUPPORTED;
}
#endif
//
// Set digital mode
//
@ -924,7 +961,7 @@ public:
// Return audio channel position in bytes
//
DWORD GetAudioPosition( WORD wPipeIndex )
{ ASSERT( wPipeIndex < ECHO_MAXAUDIOPIPES );
{ ECHO_ASSERT( wPipeIndex < ECHO_MAXAUDIOPIPES );
return( ( wPipeIndex < ECHO_MAXAUDIOPIPES )
? SWAP( m_pDspCommPage->dwPosition[ wPipeIndex ] )
@ -992,6 +1029,13 @@ public:
PCChannelMask pChannelMask
);
#ifdef SUPERMIX
//
// Trigger this card for synced transport; used for Supermix mode
//
ECHOSTATUS TriggerTransport();
#endif
//
// See if any pipes are playing or recording
//
@ -1014,7 +1058,9 @@ public:
// Read extended status register from the DSP
//
DWORD GetStatusReg()
{ return( SWAP( m_pdwDspRegBase[ CHI32_STATUS_REG ] ) ); }
{
return READ_REGISTER_ULONG( m_pdwDspRegBase + CHI32_STATUS_REG );
}
//
// Tell DSP to release the hardware interrupt
@ -1219,6 +1265,14 @@ public:
#endif // DIGITAL_INPUT_AUTO_MUTE_SUPPORT
#ifdef SUPERMIX
//
// Set the input gain boost
//
virtual ECHOSTATUS SetInputGainBoost(WORD wBusIn,BYTE bBoostDb)
{ return ECHOSTATUS_NOT_SUPPORTED; }
#endif
}; // class CDspCommObject
typedef CDspCommObject * PCDspCommObject;

4
src/add-ons/kernel/drivers/audio/echo/generic/CDspCommObjectVmixer.cpp
View File

@ -172,11 +172,13 @@ ECHOSTATUS CDspCommObjectVmixer::SetPipeOutGain
DWORD dwIndex = wBusOut * m_wNumPipesOut + wPipeOut;
m_pDspCommPage->byVmixerLevel[ dwIndex ] = (BYTE) iGain;
/*
ECHO_DEBUGPRINTF( ("CDspCommObjectVmixer::SetPipeOutGain: Out pipe %d, "
"out bus %d = 0x%lx\n",
wPipeOut,
wBusOut,
iGain) );
*/
if (fImmediate)
{
@ -268,7 +270,7 @@ ECHOSTATUS CDspCommObjectVmixer::SetBusOutGain(WORD wBusOut,INT32 iGain)
ECHOSTATUS CDspCommObjectVmixer::UpdateVmixerLevel()
{
ECHO_DEBUGPRINTF( ( "CDspCommObjectVmixer::UpdateVmixerLevel:\n" ) );
//ECHO_DEBUGPRINTF( ( "CDspCommObjectVmixer::UpdateVmixerLevel:\n" ) );
ClearHandshake();
return( SendVector( DSP_VC_SET_VMIXER_GAIN ) );

19
src/add-ons/kernel/drivers/audio/echo/generic/CEchoGals.cpp
View File

@ -87,19 +87,12 @@ CEchoGals::CEchoGals
PCOsSupport pOsSupport
)
{
INT32 i;
ASSERT( pOsSupport );
ECHO_ASSERT(pOsSupport );
m_pOsSupport = pOsSupport; // Ptr to OS Support methods & data
m_wFlags = ECHOGALS_FLAG_BADBOARD;
for ( i = 0; i < ECHO_MAXAUDIOPIPES; i++ )
{
m_wBytesPerSample[ i ] = 1;
}
m_dwLockedSampleRate = 44100;
} // CEchoGals::CEchoGals()
@ -172,14 +165,14 @@ ECHOSTATUS CEchoGals::AssignResources
)
{
//
// Use ASSERT to be sure this isn't called twice!
// Use ECHO_ASSERT(to be sure this isn't called twice!
//
ASSERT( NULL == m_pvSharedMemory );
ECHO_ASSERT(NULL == m_pvSharedMemory );
//
// Check and store the parameters
//
ASSERT( pvSharedMemory );
ECHO_ASSERT(pvSharedMemory );
if ( NULL == pszCardName )
{
return( ECHOSTATUS_BAD_CARD_NAME );
@ -213,9 +206,9 @@ ECHOSTATUS CEchoGals::AssignResources
ECHOSTATUS CEchoGals::InitHw()
{
//
// Use ASSERT to be sure AssignResources was called!
// Use ECHO_ASSERT to be sure AssignResources was called!
//
ASSERT( m_pvSharedMemory );
ECHO_ASSERT(m_pvSharedMemory );
return ECHOSTATUS_OK;

20
src/add-ons/kernel/drivers/audio/echo/generic/CEchoGals.h
View File

@ -201,16 +201,24 @@ public:
// for this client. dwNumNotifies is the size of the array passed in
// pNotifies; dwNumReturned specifies how many were actually copied in.
//
// Takes the cookie as a separate parameter; the one in MIXER_MULTI_NOTIFY
// is ignored since it's not 64 bits
//
ECHOSTATUS GetControlChanges
(
PMIXER_MULTI_NOTIFY pNotifies
PMIXER_MULTI_NOTIFY pNotifies,
NUINT MixerCookie
);
//
// Get a bunch of useful polled stuff- audio meters,
// clock detect bits, and pending notifies
//
ECHOSTATUS GetPolledStuff(ECHO_POLLED_STUFF *pPolledStuff);
ECHOSTATUS GetPolledStuff
(
ECHO_POLLED_STUFF *pPolledStuff,
NUINT MixerCookie
);
//
// Get the digital mode
@ -484,9 +492,9 @@ public:
virtual ECHOSTATUS QueryAudioSampleRate
(
DWORD dwSampleRate
)
{ return( ECHOSTATUS_NOT_SUPPORTED ); }
) = 0;
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate) = 0;
//
// I'm not going to tell you what the next two functions do; you'll just
@ -717,8 +725,6 @@ protected:
ECHOGALS_AUDIO_PIPE
m_Pipes[ ECHO_MAXAUDIOPIPES ];
// Keep mapping info on open pipes
WORD m_wBytesPerSample[ ECHO_MAXAUDIOPIPES ];
// Keep conversion info on open pipes
BYTE m_byPipeState[ ECHO_MAXAUDIOPIPES ];
// Track state of all pipes
PVOID m_ProcessId[ ECHO_MAXAUDIOPIPES ];

2
src/add-ons/kernel/drivers/audio/echo/generic/CEchoGals_info.cpp
View File

@ -75,7 +75,7 @@ ECHOSTATUS CEchoGals::GetBaseCapabilities
pCapabilities->wNumMidiIn = GetDspCommObject()->GetNumMidiInChannels();
pCapabilities->dwOutClockTypes = 0;
pCapabilities->dwInClockTypes = ECHO_CLOCK_BIT_INTERNAL;;
pCapabilities->dwInClockTypes = ECHO_CLOCK_BIT_INTERNAL;
//
// Add the controls to the output pipes that are

15
src/add-ons/kernel/drivers/audio/echo/generic/CEchoGals_mixer.cpp
View File

@ -30,6 +30,8 @@
#include "CEchoGals.h"
#undef ECHO_DEBUGPRINTF
#define ECHO_DEBUGPRINTF(x)
/****************************************************************************
@ -343,13 +345,14 @@ ECHOSTATUS CEchoGals::MixerControlChanged
ECHOSTATUS CEchoGals::GetControlChanges
(
PMIXER_MULTI_NOTIFY pNotifies
PMIXER_MULTI_NOTIFY pNotifies,
NUINT MixerCookie
)
{
//
// Match the cookie
//
ECHO_MIXER_CLIENT *pClient = GetMixerClient(pNotifies->Cookie);
ECHO_MIXER_CLIENT *pClient = GetMixerClient(MixerCookie);
if (NULL == pClient)
{
@ -830,7 +833,11 @@ ECHOSTATUS CEchoGals::ProcessMixerMultiFunction
//
//===========================================================================
ECHOSTATUS CEchoGals::GetPolledStuff(ECHO_POLLED_STUFF *pPolledStuff)
ECHOSTATUS CEchoGals::GetPolledStuff
(
ECHO_POLLED_STUFF *pPolledStuff,
NUINT MixerCookie
)
{
ECHO_MIXER_CLIENT *pClient;
CDspCommObject *pDCO = GetDspCommObject();
@ -851,7 +858,7 @@ ECHOSTATUS CEchoGals::GetPolledStuff(ECHO_POLLED_STUFF *pPolledStuff)
// If there is a matching client, fill out the number
// of notifies
//
pClient = GetMixerClient(pPolledStuff->Cookie);
pClient = GetMixerClient(MixerCookie);
if (NULL == pClient)
pPolledStuff->dwNumPendingNotifies = 0;
else

28
src/add-ons/kernel/drivers/audio/echo/generic/CEchoGals_transport.cpp
View File

@ -139,8 +139,9 @@ ECHOSTATUS CEchoGals::OpenAudio
if ( m_cmAudioOpen.Test( &cmMask ) )
{
ECHO_DEBUGPRINTF( ("\tECHOSTATUS_CHANNEL_ALREADY_OPEN\n") );
return( ECHOSTATUS_CHANNEL_ALREADY_OPEN );
ECHO_DEBUGPRINTF( ("OpenAudio - ECHOSTATUS_CHANNEL_ALREADY_OPEN - m_cmAudioOpen 0x%x cmMask 0x%x\n",
m_cmAudioOpen.GetMask(),cmMask.GetMask()) );
return ECHOSTATUS_CHANNEL_ALREADY_OPEN;
}
#ifdef AUTO_DUCK_ALLOCATE
@ -185,7 +186,7 @@ ECHOSTATUS CEchoGals::OpenAudio
m_ProcessId[ wPipeIndex ] = pOpenParameters->ProcessId;
Reset( wPipeIndex );
ECHO_DEBUGPRINTF( ("\tECHOSTATUS_OK\n") );
ECHO_DEBUGPRINTF( ("OpenAudio - ECHOSTATUS_OK - m_cmAudioOpen 0x%x\n",m_cmAudioOpen.GetMask()) );
return ECHOSTATUS_OK;
} // ECHOSTATUS CEchoGals::OpenAudio
@ -223,6 +224,7 @@ ECHOSTATUS CEchoGals::CloseAudio
{
cmMask.SetIndexInMask( wPipeIndex + i );
}
Reset( wPipeIndex );
//
@ -243,7 +245,7 @@ ECHOSTATUS CEchoGals::CloseAudio
m_ProcessId[ wPipeIndex ] = NULL;
m_Pipes[ wPipeIndex ].wInterleave = 0;
ECHO_DEBUGPRINTF( ("\tECHOSTATUS_OK\n") );
ECHO_DEBUGPRINTF( ("CloseAudio - ECHOSTATUS_OK - m_cmAudioOpen 0x%x\n",m_cmAudioOpen.GetMask()) );
return ECHOSTATUS_OK;
} // ECHOSTATUS CEchoGals::CloseAudio
@ -272,7 +274,8 @@ ECHOSTATUS CEchoGals::VerifyAudioOpen
cmMask.SetIndexInMask( wPipeIndex );
if ( !( m_cmAudioOpen.Test( &cmMask ) ) )
{
ECHO_DEBUGPRINTF( ("\tECHOSTATUS_CHANNEL_NOT_OPEN\n") );
ECHO_DEBUGPRINTF( ("VerifyAudioOpen - ECHOSTATUS_CHANNEL_NOT_OPEN - wPipeIndex %d - m_cmAudioOpen 0x%x - cmMask 0x%x\n",
wPipeIndex,m_cmAudioOpen.GetMask(),cmMask.GetMask()) );
return ECHOSTATUS_CHANNEL_NOT_OPEN;
}
@ -536,14 +539,6 @@ ECHOSTATUS CEchoGals::SetAudioFormat
// Set the format
//
Status = GetDspCommObject()->SetAudioFormat( wPipeIndex, pAudioFormat );
if (ECHOSTATUS_OK == Status)
{
WORD wBytesPerSample;
wBytesPerSample = pAudioFormat->wDataInterleave * (pAudioFormat->wBitsPerSample / 8);
m_wBytesPerSample[ wPipeIndex ] = wBytesPerSample;
m_Pipes[ wPipeIndex ].wInterleave = pAudioFormat->wDataInterleave;
}
return Status;
@ -573,8 +568,6 @@ ECHOSTATUS CEchoGals::SetAudioFormat
for ( ; ; )
{
WORD wBytesPerSample;
wPipeIndex = pChannelMask->GetIndexFromMask( ++wPipeIndex );
if ( (WORD) ECHO_INVALID_CHANNEL == wPipeIndex )
break; // We be done!
@ -606,10 +599,6 @@ ECHOSTATUS CEchoGals::SetAudioFormat
Status = GetDspCommObject()->SetAudioFormat( wPipeIndex, pAudioFormat );
if ( ECHOSTATUS_OK != Status )
return Status;
wBytesPerSample = pAudioFormat->wDataInterleave * (pAudioFormat->wBitsPerSample / 8);
m_wBytesPerSample[ wPipeIndex ] = wBytesPerSample;
m_Pipes[ wPipeIndex ].wInterleave = pAudioFormat->wDataInterleave;
}
return ECHOSTATUS_OK;
@ -1220,3 +1209,4 @@ ECHOSTATUS CEchoGals::GetAudioPositionPtr
} // ECHOSTATUS CEchoGals::GetAudioPositionPtr

8
src/add-ons/kernel/drivers/audio/echo/generic/CGina.cpp
View File

@ -132,7 +132,7 @@ ECHOSTATUS CGina::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CGinaDspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -273,4 +273,10 @@ ECHOSTATUS CGina::QueryAudioSampleRate
} // ECHOSTATUS CGina::QueryAudioSampleRate
void CGina::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 44100;
dwMaxRate = 48000;
}
// *** CGina.cpp ***

2
src/add-ons/kernel/drivers/audio/echo/generic/CGina.h
View File

@ -74,6 +74,8 @@ public:
(
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Overload new & delete so memory for this object is allocated from non-paged memory.

11
src/add-ons/kernel/drivers/audio/echo/generic/CGina24.cpp
View File

@ -133,7 +133,7 @@ ECHOSTATUS CGina24::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CGina24DspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -142,7 +142,7 @@ ECHOSTATUS CGina24::InitHw()
return ECHOSTATUS_NO_MEM;
}
ASSERT( GetDspCommObject() );
ECHO_ASSERT(GetDspCommObject() );
//
// Load the DSP and the ASIC on the PCI card
@ -293,6 +293,13 @@ ECHOSTATUS CGina24::QueryAudioSampleRate
} // ECHOSTATUS CGina24::QueryAudioSampleRate
void CGina24::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 8000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input

2
src/add-ons/kernel/drivers/audio/echo/generic/CGina24.h
View File

@ -77,6 +77,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Get a bitmask of all the clocks the hardware is currently detecting
//

7
src/add-ons/kernel/drivers/audio/echo/generic/CIndigo.cpp
View File

@ -232,6 +232,13 @@ ECHOSTATUS CIndigo::QueryAudioSampleRate
} // ECHOSTATUS CIndigo::QueryAudioSampleRate
void CIndigo::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 32000;
dwMaxRate = 96000;
}
//===========================================================================
//
// Indigo & Indigo DJ don't have monitor mixers, so this works differently

2
src/add-ons/kernel/drivers/audio/echo/generic/CIndigo.h
View File

@ -77,6 +77,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Overload new & delete so memory for this object is allocated from
// non-paged memory.

9
src/add-ons/kernel/drivers/audio/echo/generic/CIndigoIO.cpp
View File

@ -128,7 +128,7 @@ ECHOSTATUS CIndigoIO::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CIndigoIODspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -232,6 +232,13 @@ ECHOSTATUS CIndigoIO::QueryAudioSampleRate
} // ECHOSTATUS CIndigoIO::QueryAudioSampleRate
void CIndigoIO::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 32000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetAudioLatency - returns the latency for a single pipe

2
src/add-ons/kernel/drivers/audio/echo/generic/CIndigoIO.h
View File

@ -76,6 +76,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Overload new & delete so memory for this object is allocated from
// non-paged memory.

9
src/add-ons/kernel/drivers/audio/echo/generic/CLayla.cpp
View File

@ -136,7 +136,7 @@ ECHOSTATUS CLayla::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CLaylaDspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -293,6 +293,13 @@ ECHOSTATUS CLayla::QueryAudioSampleRate
} // ECHOSTATUS CLayla::QueryAudioSampleRate
void CLayla::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 8000;
dwMaxRate = 50000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input

2
src/add-ons/kernel/drivers/audio/echo/generic/CLayla.h
View File

@ -71,6 +71,8 @@ public:
(
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Get a bitmask of all the clocks the hardware is currently detecting

10
src/add-ons/kernel/drivers/audio/echo/generic/CLayla24.cpp
View File

@ -135,7 +135,7 @@ ECHOSTATUS CLayla24::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CLayla24DspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -330,6 +330,14 @@ qasr_ex:
} // ECHOSTATUS CLayla24::QueryAudioSampleRate
void CLayla24::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 8000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input

2
src/add-ons/kernel/drivers/audio/echo/generic/CLayla24.h
View File

@ -69,6 +69,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Get a bitmask of all the clocks the hardware is currently detecting
//

10
src/add-ons/kernel/drivers/audio/echo/generic/CMia.cpp
View File

@ -134,7 +134,7 @@ ECHOSTATUS CMia::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CMiaDspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -280,6 +280,14 @@ ECHOSTATUS CMia::QueryAudioSampleRate
} // ECHOSTATUS CMia::QueryAudioSampleRate
void CMia::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 32000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input

3
src/add-ons/kernel/drivers/audio/echo/generic/CMia.h
View File

@ -68,12 +68,13 @@ public:
//
// Audio Interface methods
//
virtual ECHOSTATUS QueryAudioSampleRate
(
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Get a bitmask of all the clocks the hardware is currently detecting
//

9
src/add-ons/kernel/drivers/audio/echo/generic/CMona.cpp
View File

@ -132,7 +132,7 @@ ECHOSTATUS CMona::InitHw()
//
// Create the DSP comm object
//
ASSERT( NULL == m_pDspCommObject );
ECHO_ASSERT(NULL == m_pDspCommObject );
m_pDspCommObject = new CMonaDspCommObject( (PDWORD) m_pvSharedMemory,
m_pOsSupport );
if (NULL == m_pDspCommObject)
@ -259,6 +259,13 @@ ECHOSTATUS CMona::QueryAudioSampleRate
} // ECHOSTATUS CMona::QueryAudioSampleRate
void CMona::QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate)
{
dwMinRate = 8000;
dwMaxRate = 96000;
}
//===========================================================================
//
// GetInputClockDetect returns a bitmask consisting of all the input

2
src/add-ons/kernel/drivers/audio/echo/generic/CMona.h
View File

@ -77,6 +77,8 @@ public:
DWORD dwSampleRate
);
virtual void QuerySampleRateRange(DWORD &dwMinRate,DWORD &dwMaxRate);
//
// Get a bitmask of all the clocks the hardware is currently detecting
//

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Darla24DSP.c
View File

@ -1,7 +1,7 @@
// darla24 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -747,7 +747,7 @@ WORD pwDarla24DSP[] =
0x0000, 0x016a, 0x005e, 0xdc00, 0x004c, 0xe000, 0x000d, 0x0172,
0x005e, 0x5800, 0x0020, 0x000b, 0x000e, 0x216f, 0x000a, 0x7002,
0x0000, 0x0025, 0x000a, 0x2587, 0x0000, 0x016f, 0x000c, 0x0128,
0x0021, 0xc644, 0x000c, 0x1ec8, 0x000e, 0xa177, 0x0020, 0x0040,
0x0021, 0xc644, 0x000c, 0x1c08, 0x000e, 0xa177, 0x0020, 0x0040,
0x0000, 0x000c, 0x0020, 0x0051, 0x0000, 0x000c, 0x00c1, 0x0002,
0x0000, 0x005b, 0x0000, 0x09cd, 0x000a, 0x2596, 0x0000, 0x0a04,
0x0001, 0x0f00, 0x0004, 0x4e8c, 0x0020, 0x001b, 0x0044, 0xf403,

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Echo3gDSP.c
View File

@ -1,7 +1,7 @@
// echo3g DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1836,7 +1836,7 @@ WORD pwEcho3gDSP[] =
0x0000, 0x0120, 0x0000, 0x0110, 0x0000, 0x000e, 0x0000, 0x000a,
0x0000, 0x0008, 0x0000, 0x0004, 0x0000, 0x0fc6, 0x0000, 0x120f,
0x000f, 0x0f0f, 0x0000, 0xfe7f, 0x0000, 0x0019, 0x0000, 0x1e07,
0x0000, 0x000c, 0x00ff, 0xfde1, 0x0000, 0x021f, 0x00ff, 0xfee1,
0x0000, 0x0018, 0x00ff, 0xfde1, 0x0000, 0x021f, 0x00ff, 0xfee1,
0x0000, 0x011f, 0x0000, 0x0011, 0x0000, 0x0011, 0x0000, 0x0021,
0x0000, 0x0021, 0x0000, 0x0440, 0x0000, 0x0440, 0x0000, 0x0220,
0x0000, 0x0010, 0x0000, 0x0010, 0x0000, 0x0011, 0x0000, 0x0011,

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Gina24DSP.c
View File

@ -1,7 +1,7 @@
// Gina24 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1053,7 +1053,7 @@ WORD pwGina24DSP[] =
0x0006, 0x1080, 0x0000, 0x0168, 0x005e, 0xdc00, 0x004c, 0xe000,
0x000d, 0x0170, 0x005e, 0x5800, 0x0020, 0x000b, 0x000e, 0x216d,
0x000a, 0x7002, 0x0000, 0x0025, 0x000a, 0x2587, 0x0000, 0x016d,
0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1ec8, 0x000e, 0xa175,
0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1c08, 0x000e, 0xa175,
0x0020, 0x0040, 0x0000, 0x000c, 0x0020, 0x0051, 0x0000, 0x000c,
0x009d, 0x0002, 0x0000, 0x0049, 0x0000, 0x09d5, 0x000a, 0x2596,
0x0000, 0x0a03, 0x0004, 0x4e30, 0x0044, 0xa900, 0x0020, 0x0045,

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Gina24_361DSP.c
View File

@ -1,7 +1,7 @@
// Gina24_361 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1054,7 +1054,7 @@ WORD pwGina24_361DSP[] =
0x005e, 0xdc00, 0x004c, 0xe000, 0x000d, 0x0170, 0x005e, 0x5800,
0x0020, 0x000b, 0x000e, 0x216d, 0x000a, 0x7002, 0x0000, 0x0025,
0x000a, 0x2587, 0x0000, 0x016d, 0x000c, 0x0127, 0x0021, 0xc644,
0x000c, 0x1ec8, 0x000e, 0xa175, 0x0020, 0x0040, 0x0000, 0x000c,
0x000c, 0x1c08, 0x000e, 0xa175, 0x0020, 0x0040, 0x0000, 0x000c,
0x0020, 0x0051, 0x0000, 0x000c, 0x009d, 0x0002, 0x0000, 0x0049,
0x0000, 0x09d7, 0x000a, 0x2596, 0x0000, 0x0a05, 0x0004, 0x4e70,
0x0044, 0xa900, 0x0020, 0x0045, 0x000e, 0xa9e7, 0x0021, 0x9700,

880
src/add-ons/kernel/drivers/audio/echo/generic/DSP/IndigoDJDSP.c
View File

File diff suppressed because it is too large Load Diff

65
src/add-ons/kernel/drivers/audio/echo/generic/DSP/IndigoDSP.c
View File

@ -1,7 +1,7 @@
// indigo DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -107,11 +107,11 @@ WORD pwIndigoDSP[] =
0x00ff, 0xffff, 0x000d, 0x0002, 0x0000, 0x0001, 0x0000, 0x0193,
0x0000, 0x03f8, 0x003d, 0x0002, 0x0000, 0x0019, 0x0000, 0x0194,
0x0004, 0x4e8b, 0x000d, 0x0956, 0x0001, 0x4285, 0x000a, 0xf0aa,
0x0000, 0x01b1, 0x0001, 0x40c5, 0x0000, 0x00d0, 0x000e, 0xaad9,
0x0001, 0x40c5, 0x0000, 0x00d1, 0x000e, 0xaae1, 0x0001, 0x40c5,
0x0000, 0x00d2, 0x000e, 0xaae9, 0x0001, 0x40c5, 0x0000, 0x00d4,
0x000e, 0xaaf1, 0x0001, 0x40c5, 0x0000, 0x00d5, 0x000e, 0xaaf6,
0x0001, 0x40c5, 0x0000, 0x00d6, 0x000e, 0xaafb, 0x006b, 0x9100,
0x0000, 0x01b1, 0x0001, 0x40c5, 0x0000, 0x00d0, 0x000e, 0xaadd,
0x0001, 0x40c5, 0x0000, 0x00d1, 0x000e, 0xaae5, 0x0001, 0x40c5,
0x0000, 0x00d2, 0x000e, 0xaaed, 0x0001, 0x40c5, 0x0000, 0x00d4,
0x000e, 0xaaf5, 0x0001, 0x40c5, 0x0000, 0x00d5, 0x000e, 0xaafa,
0x0001, 0x40c5, 0x0000, 0x00d6, 0x000e, 0xaaff, 0x006b, 0x9100,
0x0005, 0x9263, 0x0011, 0x0002, 0x0000, 0x0003, 0x0000, 0x01ad,
0x0052, 0x9100, 0x0040, 0x8100, 0x0042, 0x8300, 0x0033, 0x0002,
0x0000, 0x0014, 0x0000, 0x01b0, 0x0000, 0x0004, 0x006b, 0x1100,
@ -696,7 +696,7 @@ WORD pwIndigoDSP[] =
0x0061, 0xf400, 0x0000, 0x0181, 0x0006, 0x0a90, 0x0000, 0x002f,
0x000a, 0xc900, 0x0000, 0x09cf, 0x0056, 0xaf00, 0x0001, 0x4180,
0x000a, 0x67a0, 0x0000, 0x09cf, 0x0054, 0x2f00, 0x0056, 0xe100,
0x000d, 0x0b58, 0x0056, 0xf400, 0x0000, 0x05d9, 0x0044, 0xf400,
0x000d, 0x0b5c, 0x0056, 0xf400, 0x0000, 0x05d9, 0x0044, 0xf400,
0x0000, 0x0794, 0x000b, 0x6722, 0x0002, 0x8040, 0x000a, 0x6720,
0x0002, 0x17ac, 0x0022, 0xf000, 0x0002, 0x279e, 0x0001, 0x4184,
0x000a, 0x67a2, 0x0000, 0x09c0, 0x0044, 0xf400, 0x0000, 0x065e,
@ -750,7 +750,7 @@ WORD pwIndigoDSP[] =
0x0006, 0x1080, 0x0000, 0x0159, 0x005e, 0xdc00, 0x004c, 0xe000,
0x000d, 0x0161, 0x005e, 0x5800, 0x0020, 0x000b, 0x000e, 0x215e,
0x000a, 0x7002, 0x0000, 0x0026, 0x000a, 0x2687, 0x0000, 0x015e,
0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1ec8, 0x000e, 0xa166,
0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1c08, 0x000e, 0xa166,
0x0020, 0x0040, 0x0000, 0x000c, 0x0020, 0x0051, 0x0000, 0x000c,
0x0095, 0x0002, 0x0000, 0x0045, 0x0000, 0x0a2e, 0x000a, 0x2696,
0x0000, 0x0a5c, 0x0056, 0xb000, 0x0044, 0xb100, 0x0020, 0x0045,
@ -776,7 +776,7 @@ WORD pwIndigoDSP[] =
0x0000, 0x017c, 0x0001, 0x4184, 0x000e, 0x7a7f, 0x002c, 0x0400,
0x000a, 0x7035, 0x0000, 0x0026, 0x0054, 0x7000, 0x0000, 0x017c,
0x0011, 0x0002, 0x0000, 0x0003, 0x0000, 0x0a81, 0x0052, 0xaa00,
0x0040, 0x8b00, 0x0042, 0x8d00, 0x00b5, 0x0002, 0x0000, 0x0055,
0x0040, 0x8b00, 0x0042, 0x8d00, 0x00bd, 0x0002, 0x0000, 0x0059,
0x0000, 0x0a84, 0x0000, 0x0004, 0x000a, 0x7025, 0x0000, 0x0025,
0x0000, 0x0004, 0x0045, 0xf400, 0x0000, 0x0240, 0x0044, 0xf400,
0x0000, 0x0004, 0x0061, 0xf400, 0x0000, 0x0181, 0x000d, 0x091b,
@ -791,12 +791,13 @@ WORD pwIndigoDSP[] =
0x0000, 0x0025, 0x000a, 0x702d, 0x0000, 0x0025, 0x000c, 0x0181,
0x000a, 0x7026, 0x0000, 0x0025, 0x0000, 0x0004, 0x0045, 0xf400,
0x0000, 0x0ba0, 0x0044, 0xf400, 0x0000, 0x0010, 0x0061, 0xf400,
0x0000, 0x0181, 0x000d, 0x091b, 0x000a, 0x24a0, 0x0000, 0x0ad8,
0x0000, 0x0181, 0x000d, 0x091b, 0x000a, 0x24a0, 0x0000, 0x0adc,
0x0060, 0xf400, 0x0000, 0x0181, 0x0061, 0xf400, 0x0000, 0x0812,
0x0006, 0x0890, 0x0000, 0x000d, 0x0020, 0x0013, 0x0052, 0xe000,
0x000c, 0x1c30, 0x000d, 0x0883, 0x005e, 0x5900, 0x0056, 0xd800,
0x0001, 0x40c6, 0x0000, 0xff00, 0x000c, 0x1d20, 0x000c, 0x1c30,
0x000d, 0x0883, 0x005e, 0x5900, 0x000a, 0x7022, 0x0000, 0x0026,
0x0006, 0x0890, 0x0000, 0x0011, 0x0020, 0x0013, 0x0052, 0xe000,
0x000c, 0x1c30, 0x000d, 0x0883, 0x0020, 0x0036, 0x0000, 0x0000,
0x005e, 0x5900, 0x0056, 0xd800, 0x0001, 0x40c6, 0x0000, 0xff00,
0x000c, 0x1d20, 0x000c, 0x1c30, 0x000d, 0x0883, 0x0020, 0x0036,
0x0000, 0x0000, 0x005e, 0x5900, 0x000a, 0x7022, 0x0000, 0x0026,
0x000a, 0x7006, 0x0000, 0x0025, 0x000a, 0x702d, 0x0000, 0x0025,
0x000c, 0x0181, 0x0000, 0x000c, 0x000f, 0x0002, 0x0001, 0x0002,
0x0000, 0x000a, 0x0000, 0x0000, 0x0000, 0x0000, 0x000f, 0x0002,
@ -804,19 +805,19 @@ WORD pwIndigoDSP[] =
0x000d, 0x0002, 0x0001, 0x0001, 0x0000, 0x0029, 0x0000, 0x0040,
0x0017, 0x0002, 0x0002, 0x0006, 0x0000, 0x0022, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x007f, 0xffff, 0x007f, 0xffff,
0x0000, 0x0b25, 0x0015, 0x0002, 0x0001, 0x0005, 0x0000, 0x0030,
0x0000, 0x0b29, 0x0015, 0x0002, 0x0001, 0x0005, 0x0000, 0x0030,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0061,
0x0000, 0x0061, 0x0011, 0x0002, 0x0001, 0x0003, 0x0000, 0x0135,
0x0000, 0xbb80, 0x0000, 0xbb80, 0x0000, 0xbb80, 0x000d, 0x0002,
0x0002, 0x0001, 0x0000, 0x0800, 0x0000, 0x0000, 0x004d, 0x0002,
0x0002, 0x0021, 0x0000, 0x0801, 0x0000, 0x0000, 0x0040, 0x0000,
0x0002, 0x0021, 0x0000, 0x0801, 0x0000, 0x0000, 0x00c0, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0040, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0040, 0x0000,
0x00c0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00c0, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0040, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x00c0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x000d, 0x0002,
0x0002, 0x0001, 0x0000, 0x0822, 0x0000, 0x0000, 0x000d, 0x0002,
0x0002, 0x0001, 0x0000, 0x0823, 0x0000, 0x0000, 0x000d, 0x0002,
@ -903,9 +904,9 @@ WORD pwIndigoDSP[] =
0x0000, 0x0000, 0x000c, 0x004c, 0x0000, 0x0000, 0x000c, 0x004e,
0x0000, 0x0000, 0x000c, 0x0050, 0x0000, 0x0000, 0x000c, 0x0052,
0x0000, 0x0000, 0x000c, 0x0054, 0x0000, 0x0000, 0x000c, 0x0056,
0x0000, 0x0000, 0x000d, 0x0b00, 0x0000, 0x0000, 0x000c, 0x005a,
0x0000, 0x0000, 0x000d, 0x0b04, 0x0000, 0x0000, 0x000c, 0x005a,
0x0000, 0x0000, 0x000c, 0x005c, 0x0000, 0x0000, 0x000c, 0x005e,
0x0000, 0x0000, 0x0059, 0x0002, 0x0000, 0x0027, 0x0000, 0x0ad9,
0x0000, 0x0000, 0x0059, 0x0002, 0x0000, 0x0027, 0x0000, 0x0add,
0x000d, 0x095e, 0x0021, 0x9300, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0056, 0xe300, 0x000d, 0x0969, 0x000c, 0x01ab,
0x000d, 0x095e, 0x0021, 0x9300, 0x0000, 0x0000, 0x0000, 0x0000,
@ -916,8 +917,8 @@ WORD pwIndigoDSP[] =
0x000c, 0x01ab, 0x000d, 0x095e, 0x0021, 0x9300, 0x000d, 0x095e,
0x005c, 0x6300, 0x000c, 0x01ab, 0x000d, 0x095e, 0x0021, 0x9300,
0x000d, 0x095e, 0x0007, 0x638c, 0x000c, 0x01ab, 0x0055, 0x0002,
0x0000, 0x0025, 0x0000, 0x0b00, 0x006b, 0x1300, 0x0005, 0x1463,
0x0063, 0xa100, 0x0005, 0x7fa3, 0x0001, 0xb38d, 0x0000, 0x0b14,
0x0000, 0x0025, 0x0000, 0x0b04, 0x006b, 0x1300, 0x0005, 0x1463,
0x0063, 0xa100, 0x0005, 0x7fa3, 0x0001, 0xb38d, 0x0000, 0x0b18,
0x0042, 0x1000, 0x0024, 0x0000, 0x0020, 0x5b00, 0x004c, 0x6300,
0x0042, 0x9000, 0x0063, 0x9f00, 0x0005, 0x7fa3, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0007, 0xe320, 0x006b, 0x9300,
@ -939,11 +940,11 @@ WORD pwIndigoDSP[] =
0x000c, 0x0088, 0x0000, 0x0000, 0x000d, 0x018c, 0x0000, 0x0000,
0x000c, 0x008c, 0x0000, 0x0000, 0x000c, 0x008e, 0x0000, 0x0000,
0x000b, 0xf080, 0x0000, 0x0285, 0x0071, 0x0002, 0x0000, 0x0033,
0x0000, 0x0b25, 0x000a, 0x2684, 0x0000, 0x0b25, 0x0067, 0xf400,
0x0000, 0x0b29, 0x000a, 0x2684, 0x0000, 0x0b29, 0x0067, 0xf400,
0x0000, 0x0900, 0x003f, 0x0a00, 0x0038, 0x0200, 0x0005, 0x7fa0,
0x0061, 0xf400, 0x0000, 0x0480, 0x0039, 0x0200, 0x0062, 0xa000,
0x0004, 0x62a0, 0x0006, 0x0280, 0x0000, 0x0b3c, 0x0057, 0xe100,
0x0022, 0x5000, 0x0006, 0x2080, 0x0000, 0x0b38, 0x0056, 0xc800,
0x0004, 0x62a0, 0x0006, 0x0280, 0x0000, 0x0b40, 0x0057, 0xe100,
0x0022, 0x5000, 0x0006, 0x2080, 0x0000, 0x0b3c, 0x0056, 0xc800,
0x0020, 0x4e15, 0x0020, 0x002e, 0x000a, 0x4f03, 0x0057, 0x4900,
0x0020, 0x5a00, 0x0005, 0xf420, 0x00ff, 0xffff, 0x0004, 0x62a0,
0x000a, 0x7004, 0x0000, 0x0026, 0x0063, 0xa000, 0x003b, 0x0200,
@ -967,13 +968,13 @@ WORD pwIndigoDSP[] =
0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0003, 0x0000, 0x0003,
0x0000, 0x0003, 0x0000, 0x0003, 0x0000, 0x0001, 0x0000, 0x0001,
0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002, 0x0000, 0x0002,
0x0000, 0x0003, 0x00bb, 0x0002, 0x0000, 0x0058, 0x0000, 0x0b58,
0x000a, 0xcc27, 0x0000, 0x0b65, 0x000a, 0xcc06, 0x0000, 0x0b9b,
0x0000, 0x0003, 0x00bb, 0x0002, 0x0000, 0x0058, 0x0000, 0x0b5c,
0x000a, 0xcc27, 0x0000, 0x0b69, 0x000a, 0xcc06, 0x0000, 0x0b9f,
0x0062, 0xf400, 0x0000, 0x085b, 0x0066, 0xf400, 0x0000, 0x03c4,
0x0076, 0xf400, 0x0000, 0x05a9, 0x0047, 0xf400, 0x0000, 0x0020,
0x000c, 0x0b76, 0x0062, 0xf400, 0x0000, 0x0854, 0x000a, 0xcc26,
0x0000, 0x0b70, 0x0066, 0xf400, 0x0000, 0x0423, 0x0076, 0xf400,
0x0000, 0x0542, 0x0047, 0xf400, 0x0000, 0x0040, 0x000c, 0x0b76,
0x000c, 0x0b7a, 0x0062, 0xf400, 0x0000, 0x0854, 0x000a, 0xcc26,
0x0000, 0x0b74, 0x0066, 0xf400, 0x0000, 0x0423, 0x0076, 0xf400,
0x0000, 0x0542, 0x0047, 0xf400, 0x0000, 0x0040, 0x000c, 0x0b7a,
0x0066, 0xf400, 0x0000, 0x03f2, 0x0076, 0xf400, 0x0000, 0x0569,
0x0047, 0xf400, 0x0000, 0x0030, 0x0001, 0x7f86, 0x0021, 0xc500,
0x0001, 0x4484, 0x0020, 0x0023, 0x0002, 0x2785, 0x0021, 0x9a00,
@ -986,7 +987,7 @@ WORD pwIndigoDSP[] =
0x0002, 0x27cc, 0x0022, 0xcc00, 0x000b, 0x6722, 0x0002, 0x8050,
0x0000, 0x0000, 0x0002, 0x07ac, 0x0000, 0x000c, 0x0021, 0xc600,
0x000c, 0x1e84, 0x0062, 0xf400, 0x0000, 0x0828, 0x0021, 0x9a00,
0x0056, 0xf400, 0x0000, 0xfffb, 0x0020, 0x0056, 0x000e, 0x2ba5,
0x0056, 0xf400, 0x0000, 0xfffb, 0x0020, 0x0056, 0x000e, 0x2ba9,
0x000a, 0x6727, 0x0020, 0x4a00, 0x005e, 0xda00, 0x004d, 0xda00,
0x000b, 0x6722, 0x0002, 0x8060, 0x004c, 0xda00, 0x0002, 0x2784,
0x004c, 0xda00, 0x0002, 0x1fe4, 0x0002, 0x07ac, 0x0000, 0x000c,

945
src/add-ons/kernel/drivers/audio/echo/generic/DSP/IndigoIODSP.c
View File

File diff suppressed because it is too large Load Diff

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Layla20DSP.c
View File

@ -1,7 +1,7 @@
// Layla20 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -966,7 +966,7 @@ WORD pwLayla20DSP[] =
0x0000, 0x06b1, 0x0006, 0x0c80, 0x0000, 0x017b, 0x005e, 0xdc00,
0x004c, 0xe000, 0x000d, 0x0183, 0x005e, 0x5800, 0x0020, 0x000b,
0x000e, 0x2180, 0x000a, 0x7002, 0x0000, 0x0025, 0x000a, 0x2587,
0x0000, 0x0180, 0x000c, 0x012c, 0x0021, 0xc644, 0x000c, 0x1ec8,
0x0000, 0x0180, 0x000c, 0x012c, 0x0021, 0xc644, 0x000c, 0x1c08,
0x000e, 0xa188, 0x0020, 0x0040, 0x0000, 0x000c, 0x0020, 0x0051,
0x0000, 0x000c, 0x005d, 0x0002, 0x0000, 0x0029, 0x0000, 0x0d7f,
0x000a, 0x7024, 0x0000, 0x0024, 0x0000, 0x0004, 0x005e, 0xf000,

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Layla24DSP.c
View File

@ -1,7 +1,7 @@
// Layla24 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1230,7 +1230,7 @@ WORD pwLayla24DSP[] =
0x0000, 0x0180, 0x005e, 0xdc00, 0x004c, 0xe000, 0x000d, 0x0188,
0x005e, 0x5800, 0x0020, 0x000b, 0x000e, 0x2185, 0x000a, 0x7002,
0x0000, 0x0025, 0x000a, 0x2587, 0x0000, 0x0185, 0x000c, 0x0128,
0x0021, 0xc644, 0x000c, 0x1ec8, 0x000e, 0xa18d, 0x0020, 0x0040,
0x0021, 0xc644, 0x000c, 0x1c08, 0x000e, 0xa18d, 0x0020, 0x0040,
0x0000, 0x000c, 0x0020, 0x0051, 0x0000, 0x000c, 0x009d, 0x0002,
0x0000, 0x0049, 0x0000, 0x0a5b, 0x000a, 0x2596, 0x0000, 0x0a89,
0x0004, 0x4e70, 0x0044, 0xaa00, 0x0020, 0x0045, 0x000e, 0xaa6b,

1394
src/add-ons/kernel/drivers/audio/echo/generic/DSP/MiaDSP.c
View File

File diff suppressed because it is too large Load Diff

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/Mona361DSP.c
View File

@ -1,7 +1,7 @@
// Mona361 DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1055,7 +1055,7 @@ WORD pwMona361DSP[] =
0x0000, 0x0159, 0x005e, 0xdc00, 0x004c, 0xe000, 0x000d, 0x0161,
0x005e, 0x5800, 0x0020, 0x000b, 0x000e, 0x215e, 0x000a, 0x7002,
0x0000, 0x0025, 0x000a, 0x2587, 0x0000, 0x015e, 0x000c, 0x0127,
0x0021, 0xc644, 0x000c, 0x1ec8, 0x000e, 0xa166, 0x0020, 0x0040,
0x0021, 0xc644, 0x000c, 0x1c08, 0x000e, 0xa166, 0x0020, 0x0040,
0x0000, 0x000c, 0x0020, 0x0051, 0x0000, 0x000c, 0x009d, 0x0002,
0x0000, 0x0049, 0x0000, 0x09e0, 0x000a, 0x2596, 0x0000, 0x0a0e,
0x0004, 0x4e70, 0x0044, 0xaa00, 0x0020, 0x0045, 0x000e, 0xa9f0,

4
src/add-ons/kernel/drivers/audio/echo/generic/DSP/MonaDSP.c
View File

@ -1,7 +1,7 @@
// mona DSP Code File (Converted by LRS2VxD)
// ----------------------------------------------------------------------------
//
// Copyright Echo Digital Audio Corporation (c) 2005
// Copyright Echo Digital Audio Corporation (c) 2006
// All rights reserved
// www.echoaudio.com
//
@ -1054,7 +1054,7 @@ WORD pwMonaDSP[] =
0x0000, 0x02da, 0x0006, 0x0e80, 0x0000, 0x0159, 0x005e, 0xdc00,
0x004c, 0xe000, 0x000d, 0x0161, 0x005e, 0x5800, 0x0020, 0x000b,
0x000e, 0x215e, 0x000a, 0x7002, 0x0000, 0x0025, 0x000a, 0x2587,
0x0000, 0x015e, 0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1ec8,
0x0000, 0x015e, 0x000c, 0x0127, 0x0021, 0xc644, 0x000c, 0x1c08,
0x000e, 0xa166, 0x0020, 0x0040, 0x0000, 0x000c, 0x0020, 0x0051,
0x0000, 0x000c, 0x009d, 0x0002, 0x0000, 0x0049, 0x0000, 0x09de,
0x000a, 0x2596, 0x0000, 0x0a0c, 0x0004, 0x4e30, 0x0044, 0xaa00,

1
src/add-ons/kernel/drivers/audio/echo/generic/EchoGalsXface.h
View File

@ -190,6 +190,7 @@
#define INDIGO 0x0090
#define INDIGO_IO 0x00a0
#define INDIGO_DJ 0x00b0
#define DC8 0x00c0
#define ECHO3G 0x0100
#define BASEPCI 0xfff0

10
src/add-ons/kernel/drivers/audio/echo/generic/MixerXface.h
View File

@ -313,7 +313,7 @@ typedef struct tMIXER_NOTIFY
typedef struct tMIXER_MULTI_NOTIFY
{
NUINT Cookie;
DWORD dwUnused;
DWORD dwCount; // When passed to the generic driver,
// dwCount holds the size of the Notifies array.
// On returning from the driver, dwCount
@ -334,15 +334,11 @@ typedef struct tMIXER_MULTI_NOTIFY
// learned that it's useful to be able to get all the following stuff at
// once. Typically the console will run a timer that fetchs this periodically.
//
// Cookie is the unique ID for the mixer client; this is obtained by calling
// CEchoGals::OpenMixer. The generic driver will maintain a separate notify
// queue for each client.
//
// Meters and dwClockDetectBits are exactly the same as you would get if you
// did each of those mixer functions separately.
//
// dwNumPendingNotifies is how many notifies are in the queue associated with
// the cookie. You can use this number to create an array of MIXER_NOTIFY
// the client. You can use this number to create an array of MIXER_NOTIFY
// structures and call CEchoGals::GetControlChanges. This way you only check
// for control changes if the controls have actually changed.
//
@ -350,7 +346,7 @@ typedef struct tMIXER_MULTI_NOTIFY
typedef struct tECHO_POLLED_STUFF
{
NUINT Cookie;
DWORD dwUnused;
ECHOGALS_METERS Meters;
DWORD dwClockDetectBits;
DWORD dwNumPendingNotifies;

2
src/add-ons/kernel/drivers/audio/echo/generic/OsSupportBeOS.cpp
View File

@ -63,7 +63,7 @@ BYTE OsGetRelease()
//
DWORD gAllocNonPagedCount = 0;
LIST_HEAD(, _echo_mem) mems;
LIST_HEAD(mems, _echo_mem) mems;
static echo_mem *

6
src/add-ons/kernel/drivers/audio/echo/generic/OsSupportBeOS.h
View File

@ -54,6 +54,12 @@
#endif
//
// Assert macro
//
//#define ECHO_ASSERT(exp) ASSERT(exp)
#define ECHO_ASSERT(exp)
//
// Specify OS specific types
//

3
src/add-ons/kernel/drivers/audio/echo/generic/family.h
View File

@ -76,7 +76,8 @@
#define LAYLA24_DSP_CODE pwLayla24DSP
#define LAYLA24_HAS_VMIXER FALSE
#define LAYLA24_2ASIC_FILENAME "Layla24_2S_ASIC.c"
#define LAYLA24_DSP_FILENAME "Layla24DSP.c"
#define LAYLA24_DSP_FILENAME "Layla24DSP.c"
#define MIN_MTC_1X_RATE 8000

1
src/add-ons/kernel/drivers/audio/echo/multi.cpp
View File

@ -199,6 +199,7 @@ echo_create_controls_list(multi_dev *multi)
parent = echo_create_group_control(multi, &index, 0, S_OUTPUT, NULL);
MIXER_AUDIO_CHANNEL channel;
channel.wCardId = 0;
channel.dwType = ECHO_BUS_OUT;
for (i=0; i < card->caps.wNumBussesOut / 2; i++) {
channel.wChannel = i * 2;