summaryrefslogtreecommitdiffstats
path: root/lib/rbcodec/codecs/cRSID/C64/SID.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/rbcodec/codecs/cRSID/C64/SID.c')
-rw-r--r--lib/rbcodec/codecs/cRSID/C64/SID.c276
1 files changed, 276 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/cRSID/C64/SID.c b/lib/rbcodec/codecs/cRSID/C64/SID.c
new file mode 100644
index 0000000000..22b07c15da
--- /dev/null
+++ b/lib/rbcodec/codecs/cRSID/C64/SID.c
@@ -0,0 +1,276 @@
+
+//cRSID SID emulation engine
+
+
+void cRSID_createSIDchip (cRSID_C64instance* C64, cRSID_SIDinstance* SID, unsigned short model, unsigned short baseaddress) {
+ SID->C64 = C64;
+ SID->ChipModel = model;
+ if( baseaddress>=0xD400 && (baseaddress<0xD800 || (0xDE00<=baseaddress && baseaddress<=0xDFE0)) ) { //check valid address, avoid Color-RAM
+ SID->BaseAddress = baseaddress; SID->BasePtr = &C64->IObankWR[baseaddress];
+ }
+ else { SID->BaseAddress=0x0000; SID->BasePtr = NULL; }
+ cRSID_initSIDchip(SID);
+}
+
+
+void cRSID_initSIDchip (cRSID_SIDinstance* SID) {
+ static unsigned char Channel;
+ for (Channel = 0; Channel < 21; Channel+=7) {
+ SID->ADSRstate[Channel] = 0; SID->RateCounter[Channel] = 0;
+ SID->EnvelopeCounter[Channel] = 0; SID->ExponentCounter[Channel] = 0;
+ SID->PhaseAccu[Channel] = 0; SID->PrevPhaseAccu[Channel] = 0;
+ SID->NoiseLFSR[Channel] = 0x7FFFFF;
+ SID->PrevWavGenOut[Channel] = 0; SID->PrevWavData[Channel] = 0;
+ }
+ SID->SyncSourceMSBrise = 0; SID->RingSourceMSB = 0;
+ SID->PrevLowPass = SID->PrevBandPass = SID->PrevVolume = 0;
+}
+
+
+void cRSID_emulateADSRs (cRSID_SIDinstance *SID, char cycles) {
+
+ enum ADSRstateBits { GATE_BITVAL=0x01, ATTACK_BITVAL=0x80, DECAYSUSTAIN_BITVAL=0x40, HOLDZEROn_BITVAL=0x10 };
+
+ static const short ADSRprescalePeriods[16] = {
+ 9, 32, 63, 95, 149, 220, 267, 313, 392, 977, 1954, 3126, 3907, 11720, 19532, 31251
+ };
+ static const unsigned char ADSRexponentPeriods[256] = {
+ 1, 30, 30, 30, 30, 30, 30, 16, 16, 16, 16, 16, 16, 16, 16,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, //pos0:1 pos6:30 pos14:16 pos26:8
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, //pos54:4 //pos93:2
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+ };
+
+ static unsigned char Channel, PrevGate, AD, SR;
+ static unsigned short PrescalePeriod;
+ static unsigned char *ChannelPtr, *ADSRstatePtr, *EnvelopeCounterPtr, *ExponentCounterPtr;
+ static unsigned short *RateCounterPtr;
+
+
+ for (Channel=0; Channel<21; Channel+=7) {
+
+ ChannelPtr=&SID->BasePtr[Channel]; AD=ChannelPtr[5]; SR=ChannelPtr[6];
+ ADSRstatePtr = &(SID->ADSRstate[Channel]);
+ RateCounterPtr = &(SID->RateCounter[Channel]);
+ EnvelopeCounterPtr = &(SID->EnvelopeCounter[Channel]);
+ ExponentCounterPtr = &(SID->ExponentCounter[Channel]);
+
+ PrevGate = (*ADSRstatePtr & GATE_BITVAL);
+ if ( PrevGate != (ChannelPtr[4] & GATE_BITVAL) ) { //gatebit-change?
+ if (PrevGate) *ADSRstatePtr &= ~ (GATE_BITVAL | ATTACK_BITVAL | DECAYSUSTAIN_BITVAL); //falling edge
+ else *ADSRstatePtr = (GATE_BITVAL | ATTACK_BITVAL | DECAYSUSTAIN_BITVAL | HOLDZEROn_BITVAL); //rising edge
+ }
+
+ if (*ADSRstatePtr & ATTACK_BITVAL) PrescalePeriod = ADSRprescalePeriods[ AD >> 4 ];
+ else if (*ADSRstatePtr & DECAYSUSTAIN_BITVAL) PrescalePeriod = ADSRprescalePeriods[ AD & 0x0F ];
+ else PrescalePeriod = ADSRprescalePeriods[ SR & 0x0F ];
+
+ *RateCounterPtr += cycles; if (*RateCounterPtr >= 0x8000) *RateCounterPtr -= 0x8000; //*RateCounterPtr &= 0x7FFF; //can wrap around (ADSR delay-bug: short 1st frame)
+
+ if (PrescalePeriod <= *RateCounterPtr && *RateCounterPtr < PrescalePeriod+cycles) { //ratecounter shot (matches rateperiod) (in genuine SID ratecounter is LFSR)
+ *RateCounterPtr -= PrescalePeriod; //reset rate-counter on period-match
+ if ( (*ADSRstatePtr & ATTACK_BITVAL) || ++(*ExponentCounterPtr) == ADSRexponentPeriods[*EnvelopeCounterPtr] ) {
+ *ExponentCounterPtr = 0;
+ if (*ADSRstatePtr & HOLDZEROn_BITVAL) {
+ if (*ADSRstatePtr & ATTACK_BITVAL) {
+ ++(*EnvelopeCounterPtr);
+ if (*EnvelopeCounterPtr==0xFF) *ADSRstatePtr &= ~ATTACK_BITVAL;
+ }
+ else if ( !(*ADSRstatePtr & DECAYSUSTAIN_BITVAL) || *EnvelopeCounterPtr != (SR&0xF0)+(SR>>4) ) {
+ --(*EnvelopeCounterPtr); //resid adds 1 cycle delay, we omit that mechanism here
+ if (*EnvelopeCounterPtr==0) *ADSRstatePtr &= ~HOLDZEROn_BITVAL;
+ }}}}}
+
+}
+
+
+
+int cRSID_emulateWaves (cRSID_SIDinstance *SID) {
+
+ enum SIDspecs { CHANNELS=3+1, VOLUME_MAX=0xF, D418_DIGI_VOLUME=2 }; //digi-channel is counted too
+ enum WaveFormBits { NOISE_BITVAL=0x80, PULSE_BITVAL=0x40, SAW_BITVAL=0x20, TRI_BITVAL=0x10 };
+ enum ControlBits { TEST_BITVAL=0x08, RING_BITVAL=0x04, SYNC_BITVAL=0x02, GATE_BITVAL=0x01 };
+ enum FilterBits { OFF3_BITVAL=0x80, HIGHPASS_BITVAL=0x40, BANDPASS_BITVAL=0x20, LOWPASS_BITVAL=0x10 };
+
+ #include "SID.h"
+ static const unsigned char FilterSwitchVal[] = {1,1,1,1,1,1,1,2,2,2,2,2,2,2,4};
+
+ static char MainVolume;
+ static unsigned char Channel, WF, TestBit, Envelope, FilterSwitchReso, VolumeBand;
+ static unsigned int Utmp, PhaseAccuStep, MSB, WavGenOut, PW;
+ static int Tmp, Feedback, Steepness, PulsePeak;
+ static int FilterInput, Cutoff, Resonance, FilterOutput, NonFilted, Output;
+ static unsigned char *ChannelPtr;
+ static int *PhaseAccuPtr;
+
+
+ inline unsigned short combinedWF( const unsigned char* WFarray, unsigned short oscval) {
+ static unsigned char Pitch;
+ static unsigned short Filt;
+ if (SID->ChipModel==6581 && WFarray!=PulseTriangle) oscval &= 0x7FFF;
+ Pitch = ChannelPtr[1] ? ChannelPtr[1] : 1; //avoid division by zero
+ Filt = 0x7777 + (0x8888/Pitch);
+ SID->PrevWavData[Channel] = ( WFarray[oscval>>4]*Filt + SID->PrevWavData[Channel]*(0xFFFF-Filt) ) >> 16;
+ return SID->PrevWavData[Channel] << 8;
+ }
+
+
+ FilterInput = NonFilted = 0;
+ FilterSwitchReso = SID->BasePtr[0x17]; VolumeBand=SID->BasePtr[0x18];
+
+
+ //Waveform-generator //(phase accumulator and waveform-selector)
+
+
+ for (Channel=0; Channel<21; Channel+=7) {
+ ChannelPtr=&(SID->BasePtr[Channel]);
+
+ WF = ChannelPtr[4]; TestBit = ( (WF & TEST_BITVAL) != 0 );
+ PhaseAccuPtr = &(SID->PhaseAccu[Channel]);
+
+
+ PhaseAccuStep = ( (ChannelPtr[1]<<8) + ChannelPtr[0] ) * SID->C64->SampleClockRatio;
+ if (TestBit || ((WF & SYNC_BITVAL) && SID->SyncSourceMSBrise)) *PhaseAccuPtr = 0;
+ else { //stepping phase-accumulator (oscillator)
+ *PhaseAccuPtr += PhaseAccuStep;
+ if (*PhaseAccuPtr >= 0x10000000) *PhaseAccuPtr -= 0x10000000;
+ }
+ *PhaseAccuPtr &= 0xFFFFFFF;
+ MSB = *PhaseAccuPtr & 0x8000000;
+ SID->SyncSourceMSBrise = (MSB > (SID->PrevPhaseAccu[Channel] & 0x8000000)) ? 1 : 0;
+
+
+ if (WF & NOISE_BITVAL) { //noise waveform
+ Tmp = SID->NoiseLFSR[Channel]; //clock LFSR all time if clockrate exceeds observable at given samplerate (last term):
+ if ( ((*PhaseAccuPtr & 0x1000000) != (SID->PrevPhaseAccu[Channel] & 0x1000000)) || PhaseAccuStep >= 0x1000000 ) {
+ Feedback = ( (Tmp & 0x400000) ^ ((Tmp & 0x20000) << 5) ) != 0;
+ Tmp = ( (Tmp << 1) | Feedback|TestBit ) & 0x7FFFFF; //TEST-bit turns all bits in noise LFSR to 1 (on real SID slowly, in approx. 8000 microseconds ~ 300 samples)
+ SID->NoiseLFSR[Channel] = Tmp;
+ } //we simply zero output when other waveform is mixed with noise. On real SID LFSR continuously gets filled by zero and locks up. ($C1 waveform with pw<8 can keep it for a while.)
+ WavGenOut = (WF & 0x70) ? 0 : ((Tmp & 0x100000) >> 5) | ((Tmp & 0x40000) >> 4) | ((Tmp & 0x4000) >> 1) | ((Tmp & 0x800) << 1)
+ | ((Tmp & 0x200) << 2) | ((Tmp & 0x20) << 5) | ((Tmp & 0x04) << 7) | ((Tmp & 0x01) << 8);
+ }
+
+ else if (WF & PULSE_BITVAL) { //simple pulse
+ PW = ( ((ChannelPtr[3]&0xF) << 8) + ChannelPtr[2] ) << 4; //PW=0000..FFF0 from SID-register
+ Utmp = (int) (PhaseAccuStep >> 13); if (0 < PW && PW < Utmp) PW = Utmp; //Too thin pulsewidth? Correct...
+ Utmp ^= 0xFFFF; if (PW > Utmp) PW = Utmp; //Too thin pulsewidth? Correct it to a value representable at the current samplerate
+ Utmp = *PhaseAccuPtr >> 12;
+
+ if ( (WF&0xF0) == PULSE_BITVAL ) { //simple pulse, most often used waveform, make it sound as clean as possible (by making it trapezoid)
+ Steepness = (PhaseAccuStep>=4096) ? 0xFFFFFFF/PhaseAccuStep : 0xFFFF; //rising/falling-edge steepness (add/sub at samples)
+ if (TestBit) WavGenOut = 0xFFFF;
+ else if (Utmp<PW) { //rising edge (interpolation)
+ PulsePeak = (0xFFFF-PW) * Steepness; //very thin pulses don't make a full swing between 0 and max but make a little spike
+ if (PulsePeak>0xFFFF) PulsePeak=0xFFFF; //but adequately thick trapezoid pulses reach the maximum level
+ Tmp = PulsePeak - (PW-Utmp)*Steepness; //draw the slope from the peak
+ WavGenOut = (Tmp<0)? 0:Tmp; //but stop at 0-level
+ }
+ else { //falling edge (interpolation)
+ PulsePeak = PW*Steepness; //very thin pulses don't make a full swing between 0 and max but make a little spike
+ if (PulsePeak>0xFFFF) PulsePeak=0xFFFF; //adequately thick trapezoid pulses reach the maximum level
+ Tmp = (0xFFFF-Utmp)*Steepness - PulsePeak; //draw the slope from the peak
+ WavGenOut = (Tmp>=0)? 0xFFFF:Tmp; //but stop at max-level
+ }}
+
+ else { //combined pulse
+ WavGenOut = (Utmp >= PW || TestBit) ? 0xFFFF:0;
+ if (WF & TRI_BITVAL) {
+ if (WF & SAW_BITVAL) { //pulse+saw+triangle (waveform nearly identical to tri+saw)
+ if (WavGenOut) WavGenOut = combinedWF( PulseSawTriangle, Utmp);
+ }
+ else { //pulse+triangle
+ Tmp = *PhaseAccuPtr ^ ( (WF&RING_BITVAL)? SID->RingSourceMSB : 0 );
+ if (WavGenOut) WavGenOut = combinedWF( PulseTriangle, Tmp >> 12);
+ }}
+ else if (WF & SAW_BITVAL) { //pulse+saw
+ if(WavGenOut) WavGenOut = combinedWF( PulseSawtooth, Utmp);
+ }}
+ }
+
+ else if (WF & SAW_BITVAL) { //sawtooth
+ WavGenOut = *PhaseAccuPtr >> 12; //saw (this row would be enough for simple but aliased-at-high-pitch saw)
+ if (WF & TRI_BITVAL) WavGenOut = combinedWF( SawTriangle, WavGenOut); //saw+triangle
+ else { //simple cleaned (bandlimited) saw
+ Steepness = (PhaseAccuStep>>4)/288; if(Steepness==0) Steepness=1; //avoid division by zero in next steps
+ WavGenOut += (WavGenOut * Steepness) >> 16; //1st half (rising edge) of asymmetric triangle-like saw waveform
+ if (WavGenOut>0xFFFF) WavGenOut = 0xFFFF - ( ((WavGenOut-0x10000)<<16) / Steepness ); //2nd half (falling edge, reciprocal steepness)
+ }}
+
+ else if (WF & TRI_BITVAL) { //triangle (this waveform has no harsh edges, so it doesn't suffer from strong aliasing at high pitches)
+ Tmp = *PhaseAccuPtr ^ ( WF&RING_BITVAL? SID->RingSourceMSB : 0 );
+ WavGenOut = ( Tmp ^ (Tmp&0x8000000? 0xFFFFFFF:0) ) >> 11;
+ }
+
+
+ WavGenOut &= 0xFFFF;
+ if (WF&0xF0) SID->PrevWavGenOut[Channel] = WavGenOut; //emulate waveform 00 floating wave-DAC (utilized by SounDemon digis)
+ else WavGenOut = SID->PrevWavGenOut[Channel]; //(on real SID waveform00 decays, we just simply keep the value to avoid clicks)
+ SID->PrevPhaseAccu[Channel] = *PhaseAccuPtr;
+ SID->RingSourceMSB = MSB;
+
+ //routing the channel signal to either the filter or the unfiltered master output depending on filter-switch SID-registers
+ Envelope = SID->ChipModel==8580 ? SID->EnvelopeCounter[Channel] : ADSR_DAC_6581[SID->EnvelopeCounter[Channel]];
+ if (FilterSwitchReso & FilterSwitchVal[Channel]) {
+ FilterInput += ( ((int)WavGenOut-0x8000) * Envelope ) >> 8;
+ }
+ else if ( Channel!=14 || !(VolumeBand & OFF3_BITVAL) ) {
+ NonFilted += ( ((int)WavGenOut-0x8000) * Envelope ) >> 8;
+ }
+
+ }
+ //update readable SID1-registers (some SID tunes might use 3rd channel ENV3/OSC3 value as control)
+ SID->C64->IObankRD[SID->BaseAddress+0x1B] = WavGenOut>>8; //OSC3, ENV3 (some players rely on it, unfortunately even for timing)
+ SID->C64->IObankRD[SID->BaseAddress+0x1C] = SID->EnvelopeCounter[14]; //Envelope
+
+
+ //Filter
+
+
+ Cutoff = (SID->BasePtr[0x16] << 3) + (SID->BasePtr[0x15] & 7);
+ Resonance = FilterSwitchReso >> 4;
+ if (SID->ChipModel == 8580) {
+ Cutoff = CutoffMul8580_44100Hz[Cutoff];
+ Resonance = Resonances8580[Resonance];
+ }
+ else { //6581
+ Cutoff += (FilterInput*105)>>16; if (Cutoff>0x7FF) Cutoff=0x7FF; else if (Cutoff<0) Cutoff=0; //MOSFET-VCR control-voltage-modulation
+ Cutoff = CutoffMul6581_44100Hz[Cutoff]; //(resistance-modulation aka 6581 filter distortion) emulation
+ Resonance = Resonances6581[Resonance];
+ }
+
+ FilterOutput=0;
+ Tmp = FilterInput + ((SID->PrevBandPass * Resonance)>>12) + SID->PrevLowPass;
+ if (VolumeBand & HIGHPASS_BITVAL) FilterOutput -= Tmp;
+ Tmp = SID->PrevBandPass - ( (Tmp * Cutoff) >> 12 );
+ SID->PrevBandPass = Tmp;
+ if (VolumeBand & BANDPASS_BITVAL) FilterOutput -= Tmp;
+ Tmp = SID->PrevLowPass + ( (Tmp * Cutoff) >> 12 );
+ SID->PrevLowPass = Tmp;
+ if (VolumeBand & LOWPASS_BITVAL) FilterOutput += Tmp;
+
+
+ //Output stage
+ //For $D418 volume-register digi playback: an AC / DC separation for $D418 value at low (20Hz or so) cutoff-frequency,
+ //sending AC (highpass) value to a 4th 'digi' channel mixed to the master output, and set ONLY the DC (lowpass) value to the volume-control.
+ //This solved 2 issues: Thanks to the lowpass filtering of the volume-control, SID tunes where digi is played together with normal SID channels,
+ //won't sound distorted anymore, and the volume-clicks disappear when setting SID-volume. (This is useful for fade-in/out tunes like Hades Nebula, where clicking ruins the intro.)
+ if (SID->C64->RealSIDmode) {
+ Tmp = (signed int) ( (VolumeBand&0xF) << 12 );
+ NonFilted += (Tmp - SID->PrevVolume) * D418_DIGI_VOLUME; //highpass is digi, adding it to output must be before digifilter-code
+ SID->PrevVolume += (Tmp - SID->PrevVolume) >> 10; //arithmetic shift amount determines digi lowpass-frequency
+ MainVolume = SID->PrevVolume >> 12; //lowpass is main volume
+ }
+ else MainVolume = VolumeBand & 0xF;
+
+ Output = ((NonFilted+FilterOutput) * MainVolume) / ( (CHANNELS*VOLUME_MAX) + SID->C64->Attenuation );
+
+ return Output; // master output
+
+}
+