Add files via upload

Author: frntc

Source/reSID16/SKpico_readme.txt

@@ -0,0 +1,7 @@
+This directory contains a modified version of reSID 0.16 (with parts from reSID 1.0) by Dag Lem.
+
+There are modifications at several locations, e.g. LUTs, waveforms/voices, enforcing outputs of digi techniques, creating outputs for RGB LEDs etc. 
+
+I strongly recommend to not work from this version when using reSID in other projects. 
+
+If the emulation is not working as intended it is probably because of the SKpico-modifications. Please refer to the unmodified reSID 0.16 and 1.0 source code.

Source/reSID16/envelope.cc

@@ -17,40 +17,12 @@
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 //  ---------------------------------------------------------------------------
 
-#define __ENVELOPE_CC__
-#include "envelope.h"
-
-// ----------------------------------------------------------------------------
-// Constructor.
-// ----------------------------------------------------------------------------
-__attribute__( ( optimize( "Os" ) ) ) EnvelopeGenerator::EnvelopeGenerator()
-{
-  reset();
-}
-
-// ----------------------------------------------------------------------------
-// SID reset.
-// ----------------------------------------------------------------------------
-void __attribute__( ( optimize( "Os" ) ) ) EnvelopeGenerator::reset()
-{
-  envelope_counter = 0;
-
-  attack = 0;
-  decay = 0;
-  sustain = 0;
-  release = 0;
 
-  gate = 0;
-
-  rate_counter = 0;
-  exponential_counter = 0;
-  exponential_counter_period = 1;
-
-  state = RELEASE;
-  rate_period = rate_counter_period[release];
-  hold_zero = true;
-}
+// please note that modifications have been made to this source code 
+// for the use in the SIDKick pico firmware!
 
+#define __ENVELOPE_CC__
+#include "envelope.h"
 
 // Rate counter periods are calculated from the Envelope Rates table in
 // the Programmer's Reference Guide. The rate counter period is the number of
@@ -96,23 +68,23 @@ void __attribute__( ( optimize( "Os" ) ) ) EnvelopeGenerator::reset()
 // The described method is thus sufficient for exact calculation of the rate
 // periods.
 //
-short EnvelopeGenerator::rate_counter_period[] = {
-      9,  //   2ms*1.0MHz/256 =     7.81
-     32,  //   8ms*1.0MHz/256 =    31.25
-     63,  //  16ms*1.0MHz/256 =    62.50
-     95,  //  24ms*1.0MHz/256 =    93.75
-    149,  //  38ms*1.0MHz/256 =   148.44
-    220,  //  56ms*1.0MHz/256 =   218.75
-    267,  //  68ms*1.0MHz/256 =   265.63
-    313,  //  80ms*1.0MHz/256 =   312.50
-    392,  // 100ms*1.0MHz/256 =   390.63
-    977,  // 250ms*1.0MHz/256 =   976.56
-   1954,  // 500ms*1.0MHz/256 =  1953.13
-   3126,  // 800ms*1.0MHz/256 =  3125.00
-   3907,  //   1 s*1.0MHz/256 =  3906.25
-  11720,  //   3 s*1.0MHz/256 = 11718.75
-  19532,  //   5 s*1.0MHz/256 = 19531.25
-  31251   //   8 s*1.0MHz/256 = 31250.00
+reg16 EnvelopeGenerator::rate_counter_period[] = {
+      8,  //   2ms*1.0MHz/256 =     7.81
+     31,  //   8ms*1.0MHz/256 =    31.25
+     62,  //  16ms*1.0MHz/256 =    62.50
+     94,  //  24ms*1.0MHz/256 =    93.75
+    148,  //  38ms*1.0MHz/256 =   148.44
+    219,  //  56ms*1.0MHz/256 =   218.75
+    266,  //  68ms*1.0MHz/256 =   265.63
+    312,  //  80ms*1.0MHz/256 =   312.50
+    391,  // 100ms*1.0MHz/256 =   390.63
+    976,  // 250ms*1.0MHz/256 =   976.56
+   1953,  // 500ms*1.0MHz/256 =  1953.13
+   3125,  // 800ms*1.0MHz/256 =  3125.00
+   3906,  //   1 s*1.0MHz/256 =  3906.25
+  11719,  //   3 s*1.0MHz/256 = 11718.75
+  19531,  //   5 s*1.0MHz/256 = 19531.25
+  31250   //   8 s*1.0MHz/256 = 31250.00
 };
 
 
@@ -146,14 +118,14 @@ short EnvelopeGenerator::rate_counter_period[] = {
 // (255 + 162*1 + 39*2 + 28*4 + 12*8 + 8*16 + 6*30)*32 = 756*32 = 32352
 // which corresponds exactly to the timed value divided by the number of
 // complete envelopes.
-// NB! This one cycle delay is not modeled.
+// NB! This one cycle delay is only modeled for single cycle clocking.
 
 
 // From the sustain levels it follows that both the low and high 4 bits of the
 // envelope counter are compared to the 4-bit sustain value.
 // This has been verified by sampling ENV3.
 //
-unsigned char EnvelopeGenerator::sustain_level[] = {
+reg8 EnvelopeGenerator::sustain_level[] = {
   0x00,
   0x11,
   0x22,
@@ -173,55 +145,122 @@ unsigned char EnvelopeGenerator::sustain_level[] = {
 };
 
 
+// DAC lookup tables.
+/*unsigned short EnvelopeGenerator::model_dac[ 2 ][ 1 << 8 ] = {
+  {0},
+  {0},
+};*/
+
+
 // ----------------------------------------------------------------------------
-// Register functions.
+// Constructor.
 // ----------------------------------------------------------------------------
-void EnvelopeGenerator::writeCONTROL_REG(reg8 control)
+EnvelopeGenerator::EnvelopeGenerator()
 {
-  reg8 gate_next = control & 0x01;
+    static bool class_init;
 
-  // The rate counter is never reset, thus there will be a delay before the
-  // envelope counter starts counting up (attack) or down (release).
+/*    if ( !class_init ) {
+        // Build DAC lookup tables for 8-bit DACs.
+        // MOS 6581: 2R/R ~ 2.20, missing termination resistor.
+        build_dac_table( model_dac[ 0 ], 8, 2.20, false );
+        // MOS 8580: 2R/R ~ 2.00, correct termination.
+        build_dac_table( model_dac[ 1 ], 8, 2.00, true );
 
-  // Gate bit on: Start attack, decay, sustain.
-  if (!gate && gate_next) {
-    state = ATTACK;
-    rate_period = rate_counter_period[attack];
+        class_init = true;
+    }*/
+
+    set_chip_model( MOS6581 );
+
+    // Counter's odd bits are high on powerup
+    envelope_counter = 0xaa;
+
+    reset();
+}
+
+// ----------------------------------------------------------------------------
+// SID reset.
+// ----------------------------------------------------------------------------
+void EnvelopeGenerator::reset()
+{
+    // counter is not changed on reset
+    envelope_pipeline = 0;
+    exponential_pipeline = 0;
+
+    state_pipeline = 0;
+
+    attack = 0;
+    decay = 0;
+    sustain = 0;
+    release = 0;
+
+    gate = 0;
+
+    rate_counter = 0;
+    exponential_counter = 0;
+    exponential_counter_period = 1;
+    new_exponential_counter_period = 0;
+    reset_rate_counter = false;
 
-    // Switching to attack state unlocks the zero freeze.
-    hold_zero = false;
-  }
-  // Gate bit off: Start release.
-  else if (gate && !gate_next) {
     state = RELEASE;
-    rate_period = rate_counter_period[release];
-  }
+    rate_period = rate_counter_period[ release ];
+    hold_zero = false;
+
+    next_state = RELEASE;
+    env3 = 0;
+    envelope_counter = 0xaa;
+}
+
+
+// ----------------------------------------------------------------------------
+// Set chip model.
+// ----------------------------------------------------------------------------
+void EnvelopeGenerator::set_chip_model( chip_model model )
+{
+    sid_model = model;
+}
+
+
+// ----------------------------------------------------------------------------
+// Register functions.
+// ----------------------------------------------------------------------------
+void EnvelopeGenerator::writeCONTROL_REG( reg8 control )
+{
+    reg8 gate_next = control & 0x01;
+
+    // The rate counter is never reset, thus there will be a delay before the
+    // envelope counter starts counting up (attack) or down (release).
+
+    if ( gate != gate_next ) {
+        // Gate bit on: Start attack, decay, sustain.
+        // Gate bit off: Start release.
+        next_state = gate_next ? ATTACK : RELEASE;
+        state_pipeline = 2;
 
-  gate = gate_next;
+        gate = gate_next;
+    }
 }
 
-void EnvelopeGenerator::writeATTACK_DECAY(reg8 attack_decay)
+void EnvelopeGenerator::writeATTACK_DECAY( reg8 attack_decay )
 {
-  attack = (attack_decay >> 4) & 0x0f;
-  decay = attack_decay & 0x0f;
-  if (state == ATTACK) {
-    rate_period = rate_counter_period[attack];
-  }
-  else if (state == DECAY_SUSTAIN) {
-    rate_period = rate_counter_period[decay];
-  }
+    attack = ( attack_decay >> 4 ) & 0x0f;
+    decay = attack_decay & 0x0f;
+    if ( state == ATTACK ) {
+        rate_period = rate_counter_period[ attack ];
+    } else if ( state == DECAY_SUSTAIN ) {
+        rate_period = rate_counter_period[ decay ];
+    }
 }
 
-void EnvelopeGenerator::writeSUSTAIN_RELEASE(reg8 sustain_release)
+void EnvelopeGenerator::writeSUSTAIN_RELEASE( reg8 sustain_release )
 {
-  sustain = (sustain_release >> 4) & 0x0f;
-  release = sustain_release & 0x0f;
-  if (state == RELEASE) {
-    rate_period = rate_counter_period[release];
-  }
+    sustain = ( sustain_release >> 4 ) & 0x0f;
+    release = sustain_release & 0x0f;
+    if ( state == RELEASE ) {
+        rate_period = rate_counter_period[ release ];
+    }
 }
 
 reg8 EnvelopeGenerator::readENV()
 {
-  return output();
+    return env3;
 }