mirror of
https://github.com/holub/mame
synced 2025-04-20 07:22:04 +03:00
mos6581.cpp : Add save states
sid.cpp : Reduce duplicates, Add postload function sidvoice.cpp : Fix type value when DIRECT_FIXPOINT defined sidenvel.cpp, sidvoice.cpp, sid.cpp : Fix spacings
This commit is contained in:
cam900
parent
5aac500dee
commit
be9efeee59
@ -68,6 +68,125 @@ mos8580_device::mos8580_device(const machine_config &mconfig, const char *tag, d
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------
|
||||
// save_state - add save states
|
||||
//-------------------------------------------------
|
||||
|
||||
void mos6581_device::save_state(SID6581_t *token)
|
||||
{
|
||||
save_item(NAME(token->type));
|
||||
save_item(NAME(token->clock));
|
||||
|
||||
save_item(NAME(token->PCMfreq));
|
||||
save_item(NAME(token->PCMsid));
|
||||
save_item(NAME(token->PCMsidNoise));
|
||||
|
||||
save_item(NAME(token->reg));
|
||||
//save_item(NAME(token->sidKeysOn));
|
||||
//save_item(NAME(token->sidKeysOff));
|
||||
|
||||
save_item(NAME(token->masterVolume));
|
||||
save_item(NAME(token->masterVolumeAmplIndex));
|
||||
|
||||
save_item(NAME(token->filter.Enabled));
|
||||
save_item(NAME(token->filter.Type));
|
||||
save_item(NAME(token->filter.CurType));
|
||||
save_item(NAME(token->filter.Dy));
|
||||
save_item(NAME(token->filter.ResDy));
|
||||
save_item(NAME(token->filter.Value));
|
||||
|
||||
for (int v = 0; v < m_token->max_voices; v++)
|
||||
{
|
||||
save_item(NAME(token->optr[v].reg), v);
|
||||
|
||||
save_item(NAME(token->optr[v].SIDfreq), v);
|
||||
save_item(NAME(token->optr[v].SIDpulseWidth), v);
|
||||
save_item(NAME(token->optr[v].SIDctrl), v);
|
||||
save_item(NAME(token->optr[v].SIDAD), v);
|
||||
save_item(NAME(token->optr[v].SIDSR), v);
|
||||
|
||||
save_item(NAME(token->optr[v].sync), v);
|
||||
|
||||
save_item(NAME(token->optr[v].pulseIndex), v);
|
||||
save_item(NAME(token->optr[v].newPulseIndex), v);
|
||||
|
||||
save_item(NAME(token->optr[v].curSIDfreq), v);
|
||||
save_item(NAME(token->optr[v].curNoiseFreq), v);
|
||||
|
||||
save_item(NAME(token->optr[v].output), v);
|
||||
//save_item(NAME(token->optr[v].outputMask), v);
|
||||
|
||||
save_item(NAME(token->optr[v].filtVoiceMask), v);
|
||||
save_item(NAME(token->optr[v].filtEnabled), v);
|
||||
save_item(NAME(token->optr[v].filtLow), v);
|
||||
save_item(NAME(token->optr[v].filtRef), v);
|
||||
save_item(NAME(token->optr[v].filtIO), v);
|
||||
|
||||
save_item(NAME(token->optr[v].cycleLenCount), v);
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
save_item(NAME(token->optr[v].cycleLen.l), v);
|
||||
save_item(NAME(token->optr[v].cycleAddLen.l), v);
|
||||
#else
|
||||
save_item(NAME(token->optr[v].cycleAddLenPnt), v);
|
||||
save_item(NAME(token->optr[v].cycleLen), v);
|
||||
save_item(NAME(token->optr[v].cycleLenPnt), v);
|
||||
#endif
|
||||
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
save_item(NAME(token->optr[v].waveStep.l), v);
|
||||
save_item(NAME(token->optr[v].waveStepAdd.l), v);
|
||||
#else
|
||||
save_item(NAME(token->optr[v].waveStep), v);
|
||||
save_item(NAME(token->optr[v].waveStepAdd), v);
|
||||
save_item(NAME(token->optr[v].waveStepPnt), v);
|
||||
save_item(NAME(token->optr[v].waveStepAddPnt), v);
|
||||
#endif
|
||||
save_item(NAME(token->optr[v].waveStepOld), v);
|
||||
for (int n = 0; n < 2; n++)
|
||||
{
|
||||
save_item(NAME(token->optr[v].wavePre[n].len), v | (n << 4));
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
save_item(NAME(token->optr[v].wavePre[n].stp), v | (n << 4));
|
||||
#else
|
||||
save_item(NAME(token->optr[v].wavePre[n].pnt), v | (n << 4));
|
||||
save_item(NAME(token->optr[v].wavePre[n].stp), v | (n << 4));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
save_item(NAME(token->optr[v].noiseReg.l), v);
|
||||
#else
|
||||
save_item(NAME(token->optr[v].noiseReg), v);
|
||||
#endif
|
||||
save_item(NAME(token->optr[v].noiseStep), v);
|
||||
save_item(NAME(token->optr[v].noiseStepAdd), v);
|
||||
save_item(NAME(token->optr[v].noiseOutput), v);
|
||||
save_item(NAME(token->optr[v].noiseIsLocked), v);
|
||||
|
||||
save_item(NAME(token->optr[v].ADSRctrl), v);
|
||||
//save_item(NAME(token->optr[v].gateOnCtrl), v);
|
||||
//save_item(NAME(token->optr[v].gateOffCtrl), v);
|
||||
|
||||
#ifdef SID_FPUENVE
|
||||
save_item(NAME(token->optr[v].fenveStep), v);
|
||||
save_item(NAME(token->optr[v].fenveStepAdd), v);
|
||||
save_item(NAME(token->optr[v].enveStep), v);
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
save_item(NAME(token->optr[v].enveStep.l), v);
|
||||
save_item(NAME(token->optr[v].enveStepAdd.l), v);
|
||||
#else
|
||||
save_item(NAME(token->optr[v].enveStep), v);
|
||||
save_item(NAME(token->optr[v].enveStepAdd), v);
|
||||
save_item(NAME(token->optr[v].enveStepPnt), v);
|
||||
save_item(NAME(token->optr[v].enveStepAddPnt), v);
|
||||
#endif
|
||||
save_item(NAME(token->optr[v].enveVol), v);
|
||||
save_item(NAME(token->optr[v].enveSusVol), v);
|
||||
save_item(NAME(token->optr[v].enveShortAttackCount), v);
|
||||
}
|
||||
|
||||
save_item(NAME(token->optr3_outputmask));
|
||||
}
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_start - device-specific startup
|
||||
@ -91,6 +210,7 @@ void mos6581_device::device_start()
|
||||
|
||||
m_token->init();
|
||||
sidInitWaveformTables(m_variant);
|
||||
save_state(m_token.get());
|
||||
}
|
||||
|
||||
|
||||
@ -104,6 +224,16 @@ void mos6581_device::device_reset()
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// device_post_load - device-specific post-load
|
||||
//-------------------------------------------------
|
||||
|
||||
void mos6581_device::device_post_load()
|
||||
{
|
||||
m_token->postload();
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// sound_stream_update - handle update requests for
|
||||
// our sound stream
|
||||
|
||||
@ -62,10 +62,12 @@ protected:
|
||||
// device-level overrides
|
||||
virtual void device_start() override;
|
||||
virtual void device_reset() override;
|
||||
virtual void device_post_load() override;
|
||||
|
||||
// device_sound_interface overrides
|
||||
virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) override;
|
||||
|
||||
void save_state(SID6581_t *token);
|
||||
private:
|
||||
devcb_read8 m_read_potx;
|
||||
devcb_read8 m_read_poty;
|
||||
|
||||
@ -32,7 +32,7 @@ float filterResTable[16];
|
||||
const int mix16monoMiddleIndex = 256*maxLogicalVoices/2;
|
||||
uint16_t mix16mono[256*maxLogicalVoices];
|
||||
|
||||
uint16_t zero16bit=0; /* either signed or unsigned */
|
||||
uint16_t zero16bit = 0; /* either signed or unsigned */
|
||||
//uint32_t splitBufferLen;
|
||||
|
||||
void MixerInit(int threeVoiceAmplify)
|
||||
@ -49,7 +49,7 @@ void MixerInit(int threeVoiceAmplify)
|
||||
/* Mixing formulas are optimized by sample input value. */
|
||||
|
||||
si = (-128*maxLogicalVoices) * 256;
|
||||
for (ui = 0; ui < sizeof(mix16mono)/sizeof(uint16_t); ui++ )
|
||||
for (ui = 0; ui < sizeof(mix16mono)/sizeof(uint16_t); ui++)
|
||||
{
|
||||
mix16mono[ui] = (uint16_t)(si/ampDiv) + zero16bit;
|
||||
si+=256;
|
||||
@ -62,43 +62,25 @@ void MixerInit(int threeVoiceAmplify)
|
||||
|
||||
inline void SID6581_t::syncEm()
|
||||
{
|
||||
bool const sync1(optr1.modulator->cycleLenCount <= 0);
|
||||
bool const sync2(optr2.modulator->cycleLenCount <= 0);
|
||||
bool const sync3(optr3.modulator->cycleLenCount <= 0);
|
||||
|
||||
optr1.cycleLenCount--;
|
||||
optr2.cycleLenCount--;
|
||||
optr3.cycleLenCount--;
|
||||
|
||||
if (optr1.sync && sync1)
|
||||
bool sync[3];
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr1.cycleLenCount = 0;
|
||||
optr1.outProc = &sidOperator::wave_calc_normal;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
optr1.waveStep.l = 0;
|
||||
#else
|
||||
optr1.waveStep = optr1.waveStepPnt = 0;
|
||||
#endif
|
||||
sync[v] = optr[v].modulator->cycleLenCount <= 0;
|
||||
optr[v].cycleLenCount--;
|
||||
}
|
||||
if (optr2.sync && sync2)
|
||||
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr2.cycleLenCount = 0;
|
||||
optr2.outProc = &sidOperator::wave_calc_normal;
|
||||
if (optr[v].sync && sync[v])
|
||||
{
|
||||
optr[v].cycleLenCount = 0;
|
||||
optr[v].outProc = &sidOperator::wave_calc_normal;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
optr2.waveStep.l = 0;
|
||||
optr[v].waveStep.l = 0;
|
||||
#else
|
||||
optr2.waveStep = optr2.waveStepPnt = 0;
|
||||
#endif
|
||||
}
|
||||
if (optr3.sync && sync3)
|
||||
{
|
||||
optr3.cycleLenCount = 0;
|
||||
optr3.outProc = &sidOperator::wave_calc_normal;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
optr3.waveStep.l = 0;
|
||||
#else
|
||||
optr3.waveStep = optr3.waveStepPnt = 0;
|
||||
optr[v].waveStep = optr[v].waveStepPnt = 0;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -107,12 +89,12 @@ void SID6581_t::fill_buffer(stream_sample_t *buffer, uint32_t bufferLen)
|
||||
{
|
||||
//void* SID6581_t::fill16bitMono(void* buffer, uint32_t numberOfSamples)
|
||||
|
||||
for ( ; bufferLen > 0; bufferLen-- )
|
||||
for (; bufferLen > 0; bufferLen--)
|
||||
{
|
||||
*buffer++ = (int16_t) mix16mono[unsigned(mix16monoMiddleIndex
|
||||
+(*optr1.outProc)(&optr1)
|
||||
+(*optr2.outProc)(&optr2)
|
||||
+(optr3.outProc(&optr3)&optr3_outputmask)
|
||||
+(*optr[0].outProc)(&optr[0])
|
||||
+(*optr[1].outProc)(&optr[1])
|
||||
+(optr[2].outProc(&optr[2])&optr3_outputmask)
|
||||
/* hack for digi sounds
|
||||
does n't seam to come from a tone operator
|
||||
ghostbusters and goldrunner everything except volume zeroed */
|
||||
@ -130,12 +112,11 @@ void SID6581_t::fill_buffer(stream_sample_t *buffer, uint32_t bufferLen)
|
||||
|
||||
bool SID6581_t::reset()
|
||||
{
|
||||
optr1.clear();
|
||||
enveEmuResetOperator( &optr1 );
|
||||
optr2.clear();
|
||||
enveEmuResetOperator( &optr2 );
|
||||
optr3.clear();
|
||||
enveEmuResetOperator( &optr3 );
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].clear();
|
||||
enveEmuResetOperator(&optr[v]);
|
||||
}
|
||||
optr3_outputmask = ~0; /* on */
|
||||
|
||||
//sampleEmuReset();
|
||||
@ -144,17 +125,24 @@ bool SID6581_t::reset()
|
||||
filter.Value = 0;
|
||||
filter.Dy = filter.ResDy = 0;
|
||||
|
||||
optr1.set();
|
||||
optr2.set();
|
||||
optr3.set();
|
||||
|
||||
optr1.set2();
|
||||
optr2.set2();
|
||||
optr3.set2();
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].set();
|
||||
optr[v].set2();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void SID6581_t::postload()
|
||||
{
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].set();
|
||||
optr[v].set2();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void filterTableInit(running_machine &machine)
|
||||
{
|
||||
@ -177,13 +165,13 @@ static void filterTableInit(running_machine &machine)
|
||||
bandPassParam = std::make_unique<float[]>(0x800);
|
||||
|
||||
uk = 0;
|
||||
for ( rk = 0; rk < 0x800; rk++ )
|
||||
for (rk = 0; rk < 0x800; rk++)
|
||||
{
|
||||
filterTable[uk] = (((expf(rk/0x800*logf(400.0f))/60.0f)+0.05f)
|
||||
*filterRefFreq) / sample_rate;
|
||||
if ( filterTable[uk] < yMin )
|
||||
if (filterTable[uk] < yMin)
|
||||
filterTable[uk] = yMin;
|
||||
if ( filterTable[uk] > yMax )
|
||||
if (filterTable[uk] > yMax)
|
||||
filterTable[uk] = yMax;
|
||||
uk++;
|
||||
}
|
||||
@ -195,7 +183,7 @@ static void filterTableInit(running_machine &machine)
|
||||
yTmp = yMin;
|
||||
uk = 0;
|
||||
/* Some C++ compilers still have non-local scope! */
|
||||
for ( rk2 = 0; rk2 < 0x800; rk2++ )
|
||||
for (rk2 = 0; rk2 < 0x800; rk2++)
|
||||
{
|
||||
bandPassParam[uk] = (yTmp*filterRefFreq) / sample_rate;
|
||||
yTmp += yAdd;
|
||||
@ -206,10 +194,10 @@ static void filterTableInit(running_machine &machine)
|
||||
resDyMax = 1.0f;
|
||||
resDyMin = 2.0f;
|
||||
resDy = resDyMin;
|
||||
for ( uk = 0; uk < 16; uk++ )
|
||||
for (uk = 0; uk < 16; uk++)
|
||||
{
|
||||
filterResTable[uk] = resDy;
|
||||
resDy -= (( resDyMin - resDyMax ) / 15 );
|
||||
resDy -= ((resDyMin - resDyMax) / 15);
|
||||
}
|
||||
filterResTable[0] = resDyMin;
|
||||
filterResTable[15] = resDyMax;
|
||||
@ -217,22 +205,15 @@ static void filterTableInit(running_machine &machine)
|
||||
|
||||
void SID6581_t::init()
|
||||
{
|
||||
optr1.sid = this;
|
||||
optr2.sid = this;
|
||||
optr3.sid = this;
|
||||
|
||||
optr1.modulator = &optr3;
|
||||
optr3.carrier = &optr1;
|
||||
optr1.filtVoiceMask = 1;
|
||||
|
||||
optr2.modulator = &optr1;
|
||||
optr1.carrier = &optr2;
|
||||
optr2.filtVoiceMask = 2;
|
||||
|
||||
optr3.modulator = &optr2;
|
||||
optr2.carrier = &optr3;
|
||||
optr3.filtVoiceMask = 4;
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].sid = this;
|
||||
|
||||
int mod_voi = (v - 1) % max_voices;
|
||||
optr[v].modulator = &optr[mod_voi];
|
||||
optr[mod_voi].carrier = &optr[v];
|
||||
optr[v].filtVoiceMask = 1 << v;
|
||||
}
|
||||
|
||||
PCMsid = uint32_t(PCMfreq * (16777216.0 / clock));
|
||||
PCMsidNoise = uint32_t((clock * 256.0) / PCMfreq);
|
||||
@ -275,7 +256,7 @@ void SID6581_t::port_w(int offset, int data)
|
||||
masterVolume = reg[0x18] & 15;
|
||||
masterVolumeAmplIndex = masterVolume << 8;
|
||||
|
||||
if ((reg[0x18] & 0x80) && !(reg[0x17] & optr3.filtVoiceMask))
|
||||
if ((reg[0x18] & 0x80) && !(reg[0x17] & optr[2].filtVoiceMask))
|
||||
optr3_outputmask = 0; /* off */
|
||||
else
|
||||
optr3_outputmask = ~0; /* on */
|
||||
@ -284,11 +265,10 @@ void SID6581_t::port_w(int offset, int data)
|
||||
if (filter.Type != filter.CurType)
|
||||
{
|
||||
filter.CurType = filter.Type;
|
||||
optr1.filtLow = optr1.filtRef = 0;
|
||||
optr2.filtLow = optr2.filtRef = 0;
|
||||
optr3.filtLow = optr3.filtRef = 0;
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
optr[v].filtLow = optr[v].filtRef = 0;
|
||||
}
|
||||
if (filter.Enabled )
|
||||
if (filter.Enabled)
|
||||
{
|
||||
filter.Value = 0x7ff & ((reg[0x15] & 7) | (uint16_t(reg[0x16]) << 3));
|
||||
if (filter.Type == 0x20)
|
||||
@ -300,14 +280,13 @@ void SID6581_t::port_w(int offset, int data)
|
||||
filter.ResDy = 1.0f;
|
||||
}
|
||||
|
||||
optr1.set();
|
||||
optr3.set();
|
||||
optr2.set();
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].set();
|
||||
|
||||
// relies on sidEmuSet also for other channels!
|
||||
optr1.set2();
|
||||
optr2.set2();
|
||||
optr3.set2();
|
||||
// relies on sidEmuSet also for other channels!
|
||||
optr[v].set2();
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
@ -315,20 +294,19 @@ void SID6581_t::port_w(int offset, int data)
|
||||
reg[offset] = data;
|
||||
|
||||
if (offset < 7)
|
||||
optr1.reg[offset] = data;
|
||||
optr[0].reg[offset] = data;
|
||||
else if (offset < 14)
|
||||
optr2.reg[offset - 7] = data;
|
||||
optr[1].reg[offset - 7] = data;
|
||||
else if (offset < 21)
|
||||
optr3.reg[offset - 14] = data;
|
||||
optr[2].reg[offset - 14] = data;
|
||||
|
||||
optr1.set();
|
||||
optr3.set();
|
||||
optr2.set();
|
||||
for (int v = 0; v < max_voices; v++)
|
||||
{
|
||||
optr[v].set();
|
||||
|
||||
// relies on sidEmuSet also for other channels!
|
||||
optr1.set2();
|
||||
optr2.set2();
|
||||
optr3.set2();
|
||||
// relies on sidEmuSet also for other channels!
|
||||
optr[v].set2();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -348,11 +326,11 @@ int SID6581_t::port_r(running_machine &machine, int offset)
|
||||
break;
|
||||
case 0x1b:
|
||||
mixer_channel->update();
|
||||
data = optr3.output;
|
||||
data = optr[2].output;
|
||||
break;
|
||||
case 0x1c:
|
||||
mixer_channel->update();
|
||||
data = optr3.enveVol;
|
||||
data = optr[2].enveVol;
|
||||
break;
|
||||
default:
|
||||
data = reg[offset];
|
||||
|
||||
@ -15,6 +15,8 @@
|
||||
/* private area */
|
||||
struct SID6581_t
|
||||
{
|
||||
static constexpr uint8_t max_voices = 3;
|
||||
|
||||
device_t *device;
|
||||
sound_stream *mixer_channel; // mame stream/ mixer channel
|
||||
|
||||
@ -49,13 +51,15 @@ struct SID6581_t
|
||||
uint16_t Value;
|
||||
} filter;
|
||||
|
||||
sidOperator optr1, optr2, optr3;
|
||||
sidOperator optr[max_voices];
|
||||
int optr3_outputmask;
|
||||
|
||||
void init();
|
||||
|
||||
bool reset();
|
||||
|
||||
void postload();
|
||||
|
||||
int port_r(running_machine &machine, int offset);
|
||||
void port_w(int offset, int data);
|
||||
|
||||
|
||||
@ -94,19 +94,19 @@ static uint32_t releaseTabLen;
|
||||
static uint32_t releasePos[256];
|
||||
|
||||
|
||||
void enveEmuInit( uint32_t updateFreq, int measuredValues )
|
||||
void enveEmuInit(uint32_t updateFreq, int measuredValues)
|
||||
{
|
||||
uint32_t i, j, k;
|
||||
|
||||
releaseTabLen = sizeof(releaseTab);
|
||||
for ( i = 0; i < 256; i++ )
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
j = 0;
|
||||
while (( j < releaseTabLen ) && (releaseTab[j] > i) )
|
||||
while ((j < releaseTabLen) && (releaseTab[j] > i))
|
||||
{
|
||||
j++;
|
||||
}
|
||||
if ( j < releaseTabLen )
|
||||
if (j < releaseTabLen)
|
||||
{
|
||||
releasePos[i] = j;
|
||||
}
|
||||
@ -117,9 +117,9 @@ void enveEmuInit( uint32_t updateFreq, int measuredValues )
|
||||
}
|
||||
|
||||
k = 0;
|
||||
for ( i = 0; i < 16; i++ )
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
for ( j = 0; j < 256; j++ )
|
||||
for (j = 0; j < 256; j++)
|
||||
{
|
||||
uint16_t tmpVol = j;
|
||||
if (measuredValues)
|
||||
@ -135,41 +135,41 @@ void enveEmuInit( uint32_t updateFreq, int measuredValues )
|
||||
}
|
||||
}
|
||||
|
||||
for ( i = 0; i < 16; i++ )
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
#ifdef SID_FPUENVE
|
||||
double scaledenvelen = floor(( attackTimes[i] * updateFreq ) / 1000UL );
|
||||
double scaledenvelen = floor((attackTimes[i] * updateFreq) / 1000UL);
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
attackRates[i] = attackTabLen / scaledenvelen;
|
||||
|
||||
scaledenvelen = floor(( decayReleaseTimes[i] * updateFreq ) / 1000UL );
|
||||
scaledenvelen = floor((decayReleaseTimes[i] * updateFreq) / 1000UL);
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
decayReleaseRates[i] = releaseTabLen / scaledenvelen;
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
uint32_t scaledenvelen = (uint32_t)floor(( attackTimes[i] * updateFreq ) / 1000UL );
|
||||
uint32_t scaledenvelen = (uint32_t)floor((attackTimes[i] * updateFreq) / 1000UL);
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
attackRates[i] = (attackTabLen << 16) / scaledenvelen;
|
||||
|
||||
scaledenvelen = (uint32_t)floor(( decayReleaseTimes[i] * updateFreq ) / 1000UL );
|
||||
scaledenvelen = (uint32_t)floor((decayReleaseTimes[i] * updateFreq) / 1000UL);
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
decayReleaseRates[i] = (releaseTabLen << 16) / scaledenvelen;
|
||||
#else
|
||||
uint32_t scaledenvelen = (uint32_t)(/*floor*/(( attackTimes[i] * updateFreq ) / 1000UL ));
|
||||
uint32_t scaledenvelen = (uint32_t)(/*floor*/((attackTimes[i] * updateFreq) / 1000UL));
|
||||
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
attackRates[i] = attackTabLen / scaledenvelen;
|
||||
attackRatesP[i] = (( attackTabLen % scaledenvelen ) * 65536UL ) / scaledenvelen;
|
||||
attackRatesP[i] = ((attackTabLen % scaledenvelen) * 65536UL) / scaledenvelen;
|
||||
|
||||
scaledenvelen = (uint32_t)(/*floor*/(( decayReleaseTimes[i] * updateFreq ) / 1000UL ));
|
||||
scaledenvelen = (uint32_t)(/*floor*/((decayReleaseTimes[i] * updateFreq) / 1000UL));
|
||||
if (scaledenvelen == 0)
|
||||
scaledenvelen = 1;
|
||||
decayReleaseRates[i] = releaseTabLen / scaledenvelen;
|
||||
decayReleaseRatesP[i] = (( releaseTabLen % scaledenvelen ) * 65536UL ) / scaledenvelen;
|
||||
decayReleaseRatesP[i] = ((releaseTabLen % scaledenvelen) * 65536UL) / scaledenvelen;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@ -249,7 +249,7 @@ static inline void enveEmuEnveAdvance(sidOperator* pVoice)
|
||||
pVoice->enveStep.l += pVoice->enveStepAdd.l;
|
||||
#else
|
||||
pVoice->enveStepPnt += pVoice->enveStepAddPnt;
|
||||
pVoice->enveStep += pVoice->enveStepAdd + ( pVoice->enveStepPnt > 65535 );
|
||||
pVoice->enveStep += pVoice->enveStepAdd + (pVoice->enveStepPnt > 65535);
|
||||
pVoice->enveStepPnt &= 0xFFFF;
|
||||
#endif
|
||||
}
|
||||
@ -274,9 +274,9 @@ static inline uint16_t enveEmuRelease(sidOperator* pVoice)
|
||||
pVoice->enveStep = (uint16_t)pVoice->fenveStep;
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
if ( pVoice->enveStep.w[HI] >= releaseTabLen )
|
||||
if (pVoice->enveStep.w.h >= releaseTabLen)
|
||||
#else
|
||||
if ( pVoice->enveStep >= releaseTabLen )
|
||||
if (pVoice->enveStep >= releaseTabLen)
|
||||
#endif
|
||||
{
|
||||
pVoice->enveVol = releaseTab[releaseTabLen -1];
|
||||
@ -285,7 +285,7 @@ static inline uint16_t enveEmuRelease(sidOperator* pVoice)
|
||||
else
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w[HI]];
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w.h];
|
||||
#else
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep];
|
||||
#endif
|
||||
@ -315,8 +315,8 @@ static inline uint16_t enveEmuStartRelease(sidOperator* pVoice)
|
||||
#ifdef SID_FPUENVE
|
||||
pVoice->fenveStep = releasePos[pVoice->enveVol];
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
pVoice->enveStep.w[HI] = releasePos[pVoice->enveVol];
|
||||
pVoice->enveStep.w[LO] = 0;
|
||||
pVoice->enveStep.w.h = releasePos[pVoice->enveVol];
|
||||
pVoice->enveStep.w.l = 0;
|
||||
#else
|
||||
pVoice->enveStep = releasePos[pVoice->enveVol];
|
||||
pVoice->enveStepPnt = 0;
|
||||
@ -339,9 +339,9 @@ static inline uint16_t enveEmuSustainDecay(sidOperator* pVoice)
|
||||
pVoice->enveStep = (uint16_t)pVoice->fenveStep;
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
if ( pVoice->enveStep.w[HI] >= releaseTabLen )
|
||||
if (pVoice->enveStep.w.h >= releaseTabLen)
|
||||
#else
|
||||
if ( pVoice->enveStep >= releaseTabLen )
|
||||
if (pVoice->enveStep >= releaseTabLen)
|
||||
#endif
|
||||
{
|
||||
pVoice->enveVol = releaseTab[releaseTabLen-1];
|
||||
@ -350,12 +350,12 @@ static inline uint16_t enveEmuSustainDecay(sidOperator* pVoice)
|
||||
else
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w[HI]];
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w.h];
|
||||
#else
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep];
|
||||
#endif
|
||||
/* Will be controlled from sidEmuSet2(). */
|
||||
if ( pVoice->enveVol <= pVoice->enveSusVol )
|
||||
if (pVoice->enveVol <= pVoice->enveSusVol)
|
||||
{
|
||||
pVoice->enveVol = pVoice->enveSusVol;
|
||||
return enveEmuAlterSustain(pVoice);
|
||||
@ -387,7 +387,7 @@ static inline uint16_t enveEmuAlterSustainDecay(sidOperator* pVoice)
|
||||
/* This is the same as enveEmuStartSustain(). */
|
||||
static inline uint16_t enveEmuAlterSustain(sidOperator* pVoice)
|
||||
{
|
||||
if ( pVoice->enveVol > pVoice->enveSusVol )
|
||||
if (pVoice->enveVol > pVoice->enveSusVol)
|
||||
{
|
||||
pVoice->ADSRctrl = ENVE_SUSTAINDECAY;
|
||||
pVoice->ADSRproc = &enveEmuSustainDecay;
|
||||
@ -411,9 +411,9 @@ static inline uint16_t enveEmuDecay(sidOperator* pVoice)
|
||||
pVoice->enveStep = (uint16_t)pVoice->fenveStep;
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
if ( pVoice->enveStep.w[HI] >= releaseTabLen )
|
||||
if (pVoice->enveStep.w.h >= releaseTabLen)
|
||||
#else
|
||||
if ( pVoice->enveStep >= releaseTabLen )
|
||||
if (pVoice->enveStep >= releaseTabLen)
|
||||
#endif
|
||||
{
|
||||
pVoice->enveVol = pVoice->enveSusVol;
|
||||
@ -422,12 +422,12 @@ static inline uint16_t enveEmuDecay(sidOperator* pVoice)
|
||||
else
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w[HI]];
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep.w.h];
|
||||
#else
|
||||
pVoice->enveVol = releaseTab[pVoice->enveStep];
|
||||
#endif
|
||||
/* Will be controlled from sidEmuSet2(). */
|
||||
if ( pVoice->enveVol <= pVoice->enveSusVol )
|
||||
if (pVoice->enveVol <= pVoice->enveSusVol)
|
||||
{
|
||||
pVoice->enveVol = pVoice->enveSusVol;
|
||||
return enveEmuAlterSustain(pVoice); /* start sustain */
|
||||
@ -478,15 +478,15 @@ static inline uint16_t enveEmuAttack(sidOperator* pVoice)
|
||||
pVoice->enveStep = (uint16_t)pVoice->fenveStep;
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
if ( pVoice->enveStep.w[HI] > attackTabLen )
|
||||
if (pVoice->enveStep.w.h > attackTabLen)
|
||||
#else
|
||||
if ( pVoice->enveStep >= attackTabLen )
|
||||
if (pVoice->enveStep >= attackTabLen)
|
||||
#endif
|
||||
return enveEmuStartDecay(pVoice);
|
||||
else
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
pVoice->enveVol = pVoice->enveStep.w[HI];
|
||||
pVoice->enveVol = pVoice->enveStep.w.h;
|
||||
#else
|
||||
pVoice->enveVol = pVoice->enveStep;
|
||||
#endif
|
||||
@ -516,8 +516,8 @@ static inline uint16_t enveEmuStartAttack(sidOperator* pVoice)
|
||||
#ifdef SID_FPUENVE
|
||||
pVoice->fenveStep = (float)pVoice->enveVol;
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
pVoice->enveStep.w[HI] = pVoice->enveVol;
|
||||
pVoice->enveStep.w[LO] = 0;
|
||||
pVoice->enveStep.w.h = pVoice->enveVol;
|
||||
pVoice->enveStep.w.l = 0;
|
||||
#else
|
||||
pVoice->enveStep = pVoice->enveVol;
|
||||
pVoice->enveStepPnt = 0;
|
||||
@ -538,7 +538,7 @@ static inline uint16_t enveEmuShortAttack(sidOperator* pVoice)
|
||||
pVoice->enveStep = (uint16_t)pVoice->fenveStep;
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
if ((pVoice->enveStep.w[HI] > attackTabLen) ||
|
||||
if ((pVoice->enveStep.w.h > attackTabLen) ||
|
||||
(pVoice->enveShortAttackCount == 0))
|
||||
#else
|
||||
if ((pVoice->enveStep >= attackTabLen) ||
|
||||
@ -547,7 +547,7 @@ static inline uint16_t enveEmuShortAttack(sidOperator* pVoice)
|
||||
/* return enveEmuStartRelease(pVoice); */
|
||||
return enveEmuStartDecay(pVoice);
|
||||
#if defined(DIRECT_FIXPOINT) && !defined(SID_FPUENVE)
|
||||
pVoice->enveVol = pVoice->enveStep.w[HI];
|
||||
pVoice->enveVol = pVoice->enveStep.w.h;
|
||||
#else
|
||||
pVoice->enveVol = pVoice->enveStep;
|
||||
#endif
|
||||
@ -578,8 +578,8 @@ static inline uint16_t enveEmuStartShortAttack(sidOperator* pVoice)
|
||||
#ifdef SID_FPUENVE
|
||||
pVoice->fenveStep = (float)pVoice->enveVol;
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
pVoice->enveStep.w[HI] = pVoice->enveVol;
|
||||
pVoice->enveStep.w[LO] = 0;
|
||||
pVoice->enveStep.w.h = pVoice->enveVol;
|
||||
pVoice->enveStep.w.l = 0;
|
||||
#else
|
||||
pVoice->enveStep = pVoice->enveVol;
|
||||
pVoice->enveStepPnt = 0;
|
||||
|
||||
@ -34,18 +34,15 @@ static const uint32_t noiseSeed = 0x7ffff8;
|
||||
|
||||
void sidInitMixerEngine(running_machine &machine)
|
||||
{
|
||||
uint16_t uk;
|
||||
int32_t si, sj ;
|
||||
|
||||
/* 8-bit volume modulation tables. */
|
||||
float filterAmpl = 0.7f;
|
||||
|
||||
ampMod1x8=std::make_unique<int8_t[]>(256*256);
|
||||
ampMod1x8 = std::make_unique<int8_t[]>(256*256);
|
||||
|
||||
uk = 0;
|
||||
for ( si = 0; si < 256; si++ )
|
||||
uint16_t uk = 0;
|
||||
for (int32_t si = 0; si < 256; si++)
|
||||
{
|
||||
for ( sj = -128; sj < 128; sj++, uk++ )
|
||||
for (int32_t sj = -128; sj < 128; sj++, uk++)
|
||||
{
|
||||
ampMod1x8[uk] = (int8_t)(((si*sj)/255)*filterAmpl);
|
||||
}
|
||||
@ -57,11 +54,11 @@ static inline void waveAdvance(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->waveStep.l += pVoice->waveStepAdd.l;
|
||||
pVoice->waveStep.w[HI] &= 4095;
|
||||
pVoice->waveStep.w.h &= 4095;
|
||||
#else
|
||||
pVoice->waveStepPnt += pVoice->waveStepAddPnt;
|
||||
pVoice->waveStep += pVoice->waveStepAdd;
|
||||
if (pVoice->waveStepPnt > 65535 ) pVoice->waveStep++;
|
||||
if (pVoice->waveStepPnt > 65535) pVoice->waveStep++;
|
||||
pVoice->waveStepPnt &= 0xFFFF;
|
||||
pVoice->waveStep &= 4095;
|
||||
#endif
|
||||
@ -70,9 +67,9 @@ static inline void waveAdvance(sidOperator* pVoice)
|
||||
static inline void noiseAdvance(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->noiseStep += pVoice->noiseStepAdd;
|
||||
if (pVoice->noiseStep >= (1L<<20))
|
||||
if (pVoice->noiseStep >= (1L << 20))
|
||||
{
|
||||
pVoice->noiseStep -= (1L<<20);
|
||||
pVoice->noiseStep -= (1L << 20);
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->noiseReg.l = (pVoice->noiseReg.l << 1) |
|
||||
(((pVoice->noiseReg.l >> 22) ^ (pVoice->noiseReg.l >> 17)) & 1);
|
||||
@ -81,16 +78,16 @@ static inline void noiseAdvance(sidOperator* pVoice)
|
||||
(((pVoice->noiseReg >> 22) ^ (pVoice->noiseReg >> 17)) & 1);
|
||||
#endif
|
||||
#if defined(DIRECT_FIXPOINT) && defined(LARGE_NOISE_TABLE)
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.w[LO]]
|
||||
|noiseTableMSB[pVoice->noiseReg.w[HI]&0xff]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.w.l]
|
||||
|noiseTableMSB[pVoice->noiseReg.w.h & 0xff]);
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.b[LOLO]]
|
||||
|noiseTableMID[pVoice->noiseReg.b[LOHI]]
|
||||
|noiseTableMSB[pVoice->noiseReg.b[HILO]]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.b.l]
|
||||
|noiseTableMID[pVoice->noiseReg.b.h]
|
||||
|noiseTableMSB[pVoice->noiseReg.b.h2]);
|
||||
#else
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg&0xff]
|
||||
|noiseTableMID[pVoice->noiseReg>>8&0xff]
|
||||
|noiseTableMSB[pVoice->noiseReg>>16&0xff]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg & 0xff]
|
||||
|noiseTableMID[pVoice->noiseReg >> 8 & 0xff]
|
||||
|noiseTableMSB[pVoice->noiseReg >> 16 & 0xff]);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@ -98,9 +95,9 @@ static inline void noiseAdvance(sidOperator* pVoice)
|
||||
static inline void noiseAdvanceHp(sidOperator* pVoice)
|
||||
{
|
||||
uint32_t tmp = pVoice->noiseStepAdd;
|
||||
while (tmp >= (1L<<20))
|
||||
while (tmp >= (1L << 20))
|
||||
{
|
||||
tmp -= (1L<<20);
|
||||
tmp -= (1L << 20);
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->noiseReg.l = (pVoice->noiseReg.l << 1) |
|
||||
(((pVoice->noiseReg.l >> 22) ^ (pVoice->noiseReg.l >> 17)) & 1);
|
||||
@ -110,9 +107,9 @@ static inline void noiseAdvanceHp(sidOperator* pVoice)
|
||||
#endif
|
||||
}
|
||||
pVoice->noiseStep += tmp;
|
||||
if (pVoice->noiseStep >= (1L<<20))
|
||||
if (pVoice->noiseStep >= (1L << 20))
|
||||
{
|
||||
pVoice->noiseStep -= (1L<<20);
|
||||
pVoice->noiseStep -= (1L << 20);
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->noiseReg.l = (pVoice->noiseReg.l << 1) |
|
||||
(((pVoice->noiseReg.l >> 22) ^ (pVoice->noiseReg.l >> 17)) & 1);
|
||||
@ -122,28 +119,28 @@ static inline void noiseAdvanceHp(sidOperator* pVoice)
|
||||
#endif
|
||||
}
|
||||
#if defined(DIRECT_FIXPOINT) && defined(LARGE_NOISE_TABLE)
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.w[LO]]
|
||||
|noiseTableMSB[pVoice->noiseReg.w[HI]&0xff]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.w.l]
|
||||
|noiseTableMSB[pVoice->noiseReg.w.h & 0xff]);
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.b[LOLO]]
|
||||
|noiseTableMID[pVoice->noiseReg.b[LOHI]]
|
||||
|noiseTableMSB[pVoice->noiseReg.b[HILO]]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg.b.l]
|
||||
|noiseTableMID[pVoice->noiseReg.b.h]
|
||||
|noiseTableMSB[pVoice->noiseReg.b.h2]);
|
||||
#else
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg&0xff]
|
||||
|noiseTableMID[pVoice->noiseReg>>8&0xff]
|
||||
|noiseTableMSB[pVoice->noiseReg>>16&0xff]);
|
||||
pVoice->noiseOutput = (noiseTableLSB[pVoice->noiseReg & 0xff]
|
||||
|noiseTableMID[pVoice->noiseReg >> 8 & 0xff]
|
||||
|noiseTableMSB[pVoice->noiseReg >> 16 & 0xff]);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
#define triangle triangleTable[pVoice->waveStep.w[HI]]
|
||||
#define sawtooth sawtoothTable[pVoice->waveStep.w[HI]]
|
||||
#define square squareTable[pVoice->waveStep.w[HI] + pVoice->pulseIndex]
|
||||
#define triSaw waveform30[pVoice->waveStep.w[HI]]
|
||||
#define triSquare waveform50[pVoice->waveStep.w[HI] + pVoice->SIDpulseWidth]
|
||||
#define sawSquare waveform60[pVoice->waveStep.w[HI] + pVoice->SIDpulseWidth]
|
||||
#define triSawSquare waveform70[pVoice->waveStep.w[HI] + pVoice->SIDpulseWidth]
|
||||
#define triangle triangleTable[pVoice->waveStep.w.h]
|
||||
#define sawtooth sawtoothTable[pVoice->waveStep.w.h]
|
||||
#define square squareTable[pVoice->waveStep.w.h + pVoice->pulseIndex]
|
||||
#define triSaw waveform30[pVoice->waveStep.w.h]
|
||||
#define triSquare waveform50[pVoice->waveStep.w.h + pVoice->SIDpulseWidth]
|
||||
#define sawSquare waveform60[pVoice->waveStep.w.h + pVoice->SIDpulseWidth]
|
||||
#define triSawSquare waveform70[pVoice->waveStep.w.h + pVoice->SIDpulseWidth]
|
||||
#else
|
||||
#define triangle triangleTable[pVoice->waveStep]
|
||||
#define sawtooth sawtoothTable[pVoice->waveStep]
|
||||
@ -155,61 +152,72 @@ static inline void noiseAdvanceHp(sidOperator* pVoice)
|
||||
#endif
|
||||
|
||||
|
||||
static void sidMode00(sidOperator* pVoice) {
|
||||
pVoice->output = (pVoice->filtIO-0x80);
|
||||
static void sidMode00(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = (pVoice->filtIO - 0x80);
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* not used */
|
||||
static void sidModeReal00(sidOperator* pVoice) {
|
||||
static void sidModeReal00(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = 0;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void sidMode10(sidOperator* pVoice) {
|
||||
static void sidMode10(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = triangle;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode20(sidOperator* pVoice) {
|
||||
static void sidMode20(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = sawtooth;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode30(sidOperator* pVoice) {
|
||||
static void sidMode30(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = triSaw;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode40(sidOperator* pVoice) {
|
||||
static void sidMode40(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = square;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode50(sidOperator* pVoice) {
|
||||
static void sidMode50(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = triSquare;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode60(sidOperator* pVoice) {
|
||||
static void sidMode60(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = sawSquare;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode70(sidOperator* pVoice) {
|
||||
static void sidMode70(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = triSawSquare;
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode80(sidOperator* pVoice) {
|
||||
static void sidMode80(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = pVoice->noiseOutput;
|
||||
waveAdvance(pVoice);
|
||||
noiseAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode80hp(sidOperator* pVoice) {
|
||||
static void sidMode80hp(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->output = pVoice->noiseOutput;
|
||||
waveAdvance(pVoice);
|
||||
noiseAdvanceHp(pVoice);
|
||||
@ -218,7 +226,7 @@ static void sidMode80hp(sidOperator* pVoice) {
|
||||
static void sidModeLock(sidOperator* pVoice)
|
||||
{
|
||||
pVoice->noiseIsLocked = true;
|
||||
pVoice->output = (pVoice->filtIO-0x80);
|
||||
pVoice->output = (pVoice->filtIO - 0x80);
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
@ -229,9 +237,9 @@ static void sidModeLock(sidOperator* pVoice)
|
||||
static void sidMode14(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
if ( pVoice->modulator->waveStep.w[HI] < 2048 )
|
||||
if (pVoice->modulator->waveStep.w.h < 2048)
|
||||
#else
|
||||
if ( pVoice->modulator->waveStep < 2048 )
|
||||
if (pVoice->modulator->waveStep < 2048)
|
||||
#endif
|
||||
pVoice->output = triangle;
|
||||
else
|
||||
@ -239,11 +247,12 @@ static void sidMode14(sidOperator* pVoice)
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode34(sidOperator* pVoice) {
|
||||
static void sidMode34(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
if ( pVoice->modulator->waveStep.w[HI] < 2048 )
|
||||
if (pVoice->modulator->waveStep.w.h < 2048)
|
||||
#else
|
||||
if ( pVoice->modulator->waveStep < 2048 )
|
||||
if (pVoice->modulator->waveStep < 2048)
|
||||
#endif
|
||||
pVoice->output = triSaw;
|
||||
else
|
||||
@ -251,11 +260,12 @@ static void sidMode34(sidOperator* pVoice) {
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode54(sidOperator* pVoice) {
|
||||
static void sidMode54(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
if ( pVoice->modulator->waveStep.w[HI] < 2048 )
|
||||
if (pVoice->modulator->waveStep.w.h < 2048)
|
||||
#else
|
||||
if ( pVoice->modulator->waveStep < 2048 )
|
||||
if (pVoice->modulator->waveStep < 2048)
|
||||
#endif
|
||||
pVoice->output = triSquare;
|
||||
else
|
||||
@ -263,11 +273,12 @@ static void sidMode54(sidOperator* pVoice) {
|
||||
waveAdvance(pVoice);
|
||||
}
|
||||
|
||||
static void sidMode74(sidOperator* pVoice) {
|
||||
static void sidMode74(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
if ( pVoice->modulator->waveStep.w[HI] < 2048 )
|
||||
if (pVoice->modulator->waveStep.w.h < 2048)
|
||||
#else
|
||||
if ( pVoice->modulator->waveStep < 2048 )
|
||||
if (pVoice->modulator->waveStep < 2048)
|
||||
#endif
|
||||
pVoice->output = triSawSquare;
|
||||
else
|
||||
@ -281,26 +292,26 @@ static void sidMode74(sidOperator* pVoice) {
|
||||
|
||||
static inline void waveCalcFilter(sidOperator* pVoice)
|
||||
{
|
||||
if ( pVoice->filtEnabled )
|
||||
if (pVoice->filtEnabled)
|
||||
{
|
||||
if ( pVoice->sid->filter.Type != 0 )
|
||||
if (pVoice->sid->filter.Type != 0)
|
||||
{
|
||||
if ( pVoice->sid->filter.Type == 0x20 )
|
||||
if (pVoice->sid->filter.Type == 0x20)
|
||||
{
|
||||
float tmp;
|
||||
pVoice->filtLow += ( pVoice->filtRef * pVoice->sid->filter.Dy );
|
||||
pVoice->filtLow += (pVoice->filtRef * pVoice->sid->filter.Dy);
|
||||
tmp = (float)pVoice->filtIO - pVoice->filtLow;
|
||||
tmp -= pVoice->filtRef * pVoice->sid->filter.ResDy;
|
||||
pVoice->filtRef += ( tmp * (pVoice->sid->filter.Dy) );
|
||||
pVoice->filtRef += (tmp * (pVoice->sid->filter.Dy));
|
||||
pVoice->filtIO = (int8_t)(pVoice->filtRef-pVoice->filtLow/4);
|
||||
}
|
||||
else if (pVoice->sid->filter.Type == 0x40)
|
||||
{
|
||||
float tmp, tmp2;
|
||||
pVoice->filtLow += ( pVoice->filtRef * pVoice->sid->filter.Dy * 0.1f );
|
||||
pVoice->filtLow += (pVoice->filtRef * pVoice->sid->filter.Dy * 0.1f);
|
||||
tmp = (float)pVoice->filtIO - pVoice->filtLow;
|
||||
tmp -= pVoice->filtRef * pVoice->sid->filter.ResDy;
|
||||
pVoice->filtRef += ( tmp * (pVoice->sid->filter.Dy) );
|
||||
pVoice->filtRef += (tmp * (pVoice->sid->filter.Dy));
|
||||
tmp2 = pVoice->filtRef - pVoice->filtIO/8;
|
||||
if (tmp2 < -128)
|
||||
tmp2 = -128;
|
||||
@ -312,30 +323,30 @@ static inline void waveCalcFilter(sidOperator* pVoice)
|
||||
{
|
||||
float sample, sample2;
|
||||
int tmp;
|
||||
pVoice->filtLow += ( pVoice->filtRef * pVoice->sid->filter.Dy );
|
||||
pVoice->filtLow += (pVoice->filtRef * pVoice->sid->filter.Dy);
|
||||
sample = pVoice->filtIO;
|
||||
sample2 = sample - pVoice->filtLow;
|
||||
tmp = (int)sample2;
|
||||
sample2 -= pVoice->filtRef * pVoice->sid->filter.ResDy;
|
||||
pVoice->filtRef += ( sample2 * pVoice->sid->filter.Dy );
|
||||
pVoice->filtRef += (sample2 * pVoice->sid->filter.Dy);
|
||||
|
||||
if ( pVoice->sid->filter.Type == 0x10 )
|
||||
if (pVoice->sid->filter.Type == 0x10)
|
||||
{
|
||||
pVoice->filtIO = (int8_t)pVoice->filtLow;
|
||||
}
|
||||
else if ( pVoice->sid->filter.Type == 0x30 )
|
||||
else if (pVoice->sid->filter.Type == 0x30)
|
||||
{
|
||||
pVoice->filtIO = (int8_t)pVoice->filtLow;
|
||||
}
|
||||
else if ( pVoice->sid->filter.Type == 0x50 )
|
||||
else if (pVoice->sid->filter.Type == 0x50)
|
||||
{
|
||||
pVoice->filtIO = (int8_t)(sample - (tmp >> 1));
|
||||
}
|
||||
else if ( pVoice->sid->filter.Type == 0x60 )
|
||||
else if (pVoice->sid->filter.Type == 0x60)
|
||||
{
|
||||
pVoice->filtIO = (int8_t)tmp;
|
||||
}
|
||||
else if ( pVoice->sid->filter.Type == 0x70 )
|
||||
else if (pVoice->sid->filter.Type == 0x70)
|
||||
{
|
||||
pVoice->filtIO = (int8_t)(sample - (tmp >> 1));
|
||||
}
|
||||
@ -358,9 +369,9 @@ static int8_t waveCalcMute(sidOperator* pVoice)
|
||||
static int8_t waveCalcRangeCheck(sidOperator* pVoice)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->waveStepOld = pVoice->waveStep.w[HI];
|
||||
pVoice->waveStepOld = pVoice->waveStep.w.h;
|
||||
(*pVoice->waveProc)(pVoice);
|
||||
if (pVoice->waveStep.w[HI] < pVoice->waveStepOld)
|
||||
if (pVoice->waveStep.w.h < pVoice->waveStepOld)
|
||||
#else
|
||||
pVoice->waveStepOld = pVoice->waveStep;
|
||||
(*pVoice->waveProc)(pVoice);
|
||||
@ -371,7 +382,7 @@ static int8_t waveCalcRangeCheck(sidOperator* pVoice)
|
||||
pVoice->cycleLenCount = 0;
|
||||
pVoice->outProc = &sidOperator::wave_calc_normal;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->waveStep.w[HI] = 4095;
|
||||
pVoice->waveStep.w.h = 4095;
|
||||
#else
|
||||
pVoice->waveStep = 4095;
|
||||
#endif
|
||||
@ -457,11 +468,11 @@ void sidOperator::set()
|
||||
SIDpulseWidth = (reg[2] | (reg[3] << 8)) & 0x0FFF;
|
||||
newPulseIndex = 4096 - SIDpulseWidth;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
if (((waveStep.w[HI] + pulseIndex) >= 0x1000) && ((waveStep.w[HI] + newPulseIndex) >= 0x1000))
|
||||
if (((waveStep.w.h + pulseIndex) >= 0x1000) && ((waveStep.w.h + newPulseIndex) >= 0x1000))
|
||||
{
|
||||
pulseIndex = newPulseIndex;
|
||||
}
|
||||
else if (((waveStep.w[HI] + pulseIndex) < 0x1000) && ((waveStep.w[HI] + newPulseIndex) < 0x1000))
|
||||
else if (((waveStep.w.h + pulseIndex) < 0x1000) && ((waveStep.w.h + newPulseIndex) < 0x1000))
|
||||
{
|
||||
pulseIndex = newPulseIndex;
|
||||
}
|
||||
@ -598,7 +609,7 @@ void sidOperator::set2()
|
||||
|
||||
if (SIDctrl & 2)
|
||||
{
|
||||
if (!modulator->SIDfreq || (modulator->SIDctrl & 8 ))
|
||||
if (!modulator->SIDfreq || (modulator->SIDctrl & 8))
|
||||
{
|
||||
}
|
||||
else if ((carrier->SIDctrl & 2) && (modulator->SIDfreq >= (SIDfreq << 1)))
|
||||
@ -610,7 +621,7 @@ void sidOperator::set2()
|
||||
}
|
||||
}
|
||||
|
||||
if (((SIDctrl & 0x14 ) == 0x14) && modulator->SIDfreq)
|
||||
if (((SIDctrl & 0x14) == 0x14) && modulator->SIDfreq)
|
||||
waveProc = sidModeRingTable[SIDctrl >> 4];
|
||||
else
|
||||
waveProc = sidModeNormalTable[SIDctrl >> 4];
|
||||
@ -629,7 +640,7 @@ int8_t sidOperator::wave_calc_normal(sidOperator* pVoice)
|
||||
if (pVoice->pulseIndex > 2048)
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
pVoice->waveStep.w[HI] = 0;
|
||||
pVoice->waveStep.w.h = 0;
|
||||
#else
|
||||
pVoice->waveStep = 0;
|
||||
#endif
|
||||
@ -648,9 +659,9 @@ int8_t sidOperator::wave_calc_normal(sidOperator* pVoice)
|
||||
inline void sidOperator::wave_calc_cycle_len()
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
cycleAddLen.w[HI] = 0;
|
||||
cycleAddLen.w.h = 0;
|
||||
cycleAddLen.l += cycleLen.l;
|
||||
cycleLenCount = cycleAddLen.w[HI];
|
||||
cycleLenCount = cycleAddLen.w.h;
|
||||
#else
|
||||
cycleAddLenPnt += cycleLenPnt;
|
||||
cycleLenCount = cycleLen;
|
||||
@ -673,7 +684,7 @@ inline void sidOperator::wave_calc_cycle_len()
|
||||
#endif
|
||||
{
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
uint16_t diff = cycleLenCount - cycleLen.w[HI];
|
||||
uint16_t diff = cycleLenCount - cycleLen.w.h;
|
||||
#else
|
||||
uint16_t diff = cycleLenCount - cycleLen;
|
||||
#endif
|
||||
@ -706,25 +717,25 @@ void sidInitWaveformTables(int type)
|
||||
uint16_t k;
|
||||
|
||||
k = 0;
|
||||
for ( i = 0; i < 256; i++ )
|
||||
for ( j = 0; j < 8; j++ )
|
||||
for (i = 0; i < 256; i++)
|
||||
for (j = 0; j < 8; j++)
|
||||
triangleTable[k++] = i;
|
||||
for ( i = 255; i >= 0; i-- )
|
||||
for ( j = 0; j < 8; j++ )
|
||||
for (i = 255; i >= 0; i--)
|
||||
for (j = 0; j < 8; j++)
|
||||
triangleTable[k++] = i;
|
||||
|
||||
k = 0;
|
||||
for ( i = 0; i < 256; i++ )
|
||||
for ( j = 0; j < 16; j++ )
|
||||
for (i = 0; i < 256; i++)
|
||||
for (j = 0; j < 16; j++)
|
||||
sawtoothTable[k++] = i;
|
||||
|
||||
k = 0;
|
||||
for ( i = 0; i < 4096; i++ )
|
||||
for (i = 0; i < 4096; i++)
|
||||
squareTable[k++] = 255; //0; my estimation; especial for digi sound
|
||||
for ( i = 0; i < 4096; i++ )
|
||||
for (i = 0; i < 4096; i++)
|
||||
squareTable[k++] = 0; //255;
|
||||
|
||||
if ( type==mos6581_device::TYPE_8580 )
|
||||
if (type == mos6581_device::TYPE_8580)
|
||||
{
|
||||
waveform30 = waveform30_8580;
|
||||
waveform50 = waveform50_8580;
|
||||
@ -739,7 +750,7 @@ void sidInitWaveformTables(int type)
|
||||
waveform70 = waveform70_6581; /* really audible? */
|
||||
}
|
||||
|
||||
if ( type==mos6581_device::TYPE_8580 )
|
||||
if (type == mos6581_device::TYPE_8580)
|
||||
{
|
||||
sidModeNormalTable[3] = sidMode30;
|
||||
sidModeNormalTable[6] = sidMode60;
|
||||
|
||||
@ -49,7 +49,7 @@ struct sidOperator
|
||||
|
||||
int32_t cycleLenCount;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
cpuLword cycleLen, cycleAddLen;
|
||||
PAIR cycleLen, cycleAddLen;
|
||||
#else
|
||||
uint32_t cycleAddLenPnt;
|
||||
uint16_t cycleLen, cycleLenPnt;
|
||||
@ -59,7 +59,7 @@ struct sidOperator
|
||||
void (*waveProc)(sidOperator *);
|
||||
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
cpuLword waveStep, waveStepAdd;
|
||||
PAIR waveStep, waveStepAdd;
|
||||
#else
|
||||
uint16_t waveStep, waveStepAdd;
|
||||
uint32_t waveStepPnt, waveStepAddPnt;
|
||||
@ -67,10 +67,8 @@ struct sidOperator
|
||||
uint16_t waveStepOld;
|
||||
sw_storage wavePre[2];
|
||||
|
||||
#if defined(DIRECT_FIXPOINT) && defined(LARGE_NOISE_TABLE)
|
||||
cpuLword noiseReg;
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
cpuLBword noiseReg;
|
||||
#if defined(DIRECT_FIXPOINT)
|
||||
PAIR noiseReg;
|
||||
#else
|
||||
uint32_t noiseReg;
|
||||
#endif
|
||||
@ -86,7 +84,7 @@ struct sidOperator
|
||||
float fenveStep, fenveStepAdd;
|
||||
uint32_t enveStep;
|
||||
#elif defined(DIRECT_FIXPOINT)
|
||||
cpuLword enveStep, enveStepAdd;
|
||||
PAIR enveStep, enveStepAdd;
|
||||
#else
|
||||
uint16_t enveStep, enveStepAdd;
|
||||
uint32_t enveStepPnt, enveStepAddPnt;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user