ws: implement Karnak mapper ADPCM decoder

Author: asiekierka

ares/ws/cartridge/cartridge.hpp

@@ -115,15 +115,21 @@ struct Cartridge : IO, Thread {
     //karnak.cpp
     auto power() -> void;
     auto reset() -> void;
+    auto adpcmReset() -> void;
+    auto adpcmNext(n4 sample) -> void;
     auto main() -> void;
     auto step(u32 clocks) -> void;
 
     //serialization.cpp
     auto serialize(serializer& s) -> void;
 
-    n1 timerEnable;
+    n1 enable;
     n7 timerPeriod;
     n9 timerCounter;
+
+    n10 adpcmAccumulator;
+    i5 adpcmStepIndex;
+    n1 adpcmInputShift;
   } karnak;
 
   struct FLASH {

ares/ws/cartridge/io.cpp

@@ -77,17 +77,19 @@ auto Cartridge::readIO(n16 address) -> n8 {
     break;
 
   case 0x00d6:  //KARNAK_TIMER
-    data.bit(7) = karnak.timerEnable;
+    data.bit(7) = karnak.enable;
     data.bit(6, 0) = karnak.timerPeriod;
     break;
 
-  case 0x00d7:  //KARNAK
+  case 0x00d7:
+  case 0x00d8:  //KARNAK_ADPCM_INPUT
     data = 0xFF;
     break;
 
-  case 0x00d8:
-  case 0x00d9:
-    debug(unimplemented, "[KARNAK] ADPCM read ", hex(address, 2L));
+  case 0x00d9:  //KARNAK_ADPCM_OUTPUT
+    if (karnak.adpcmAccumulator >= 0x300) data = 0x00;
+    else if (karnak.adpcmAccumulator >= 0x200) data = 0xFF;
+    else data = karnak.adpcmAccumulator >> 1;
     break;
 
   }
@@ -174,13 +176,15 @@ auto Cartridge::writeIO(n16 address, n8 data) -> void {
     break;
 
   case 0x00d6:  //KARNAK_TIMER
-    karnak.timerEnable = data.bit(7);
+    karnak.enable = data.bit(7);
     karnak.timerPeriod = data.bit(6, 0);
+    if (!karnak.enable) karnak.adpcmReset();
     break;
 
-  case 0x00d8:
-  case 0x00d9:
-    debug(unimplemented, "[KARNAK] ADPCM write ", hex(address, 2L), "=", hex(data, 2L));
+  case 0x00d8:  //KARNAK_ADPCM_INPUT
+    if (!karnak.enable) return;
+    karnak.adpcmNext(data >> (karnak.adpcmInputShift ? 0 : 4));
+    karnak.adpcmInputShift ^= 1;
     break;
 
   }

ares/ws/cartridge/karnak.cpp

@@ -1,24 +1,58 @@
+static const n10 adpcmAccumulatorStep[16][16] = {
+  { 0,  0,  1,  2,  3,   5,   7,  10,  0,   0,  -1,  -2,  -3,   -5,   -7,  -10 },
+  { 0,  1,  2,  3,  4,   6,   8,  13,  0,  -1,  -2,  -3,  -4,   -6,   -8,  -13 },
+  { 0,  1,  2,  4,  5,   7,  10,  15,  0,  -1,  -2,  -4,  -5,   -7,  -10,  -15 },
+  { 0,  1,  3,  4,  6,   9,  13,  19,  0,  -1,  -3,  -4,  -6,   -9,  -13,  -19 },
+  { 0,  2,  3,  5,  8,  11,  15,  23,  0,  -2,  -3,  -5,  -8,  -11,  -15,  -23 },
+  { 0,  2,  4,  7, 10,  14,  19,  29,  0,  -2,  -4,  -7, -10,  -14,  -19,  -29 },
+  { 0,  3,  5,  8, 12,  16,  22,  33,  0,  -3,  -5,  -8, -12,  -16,  -22,  -33 },
+  { 1,  4,  7, 10, 15,  20,  29,  43, -1,  -4,  -7, -10, -15,  -20,  -29,  -43 },
+  { 1,  4,  8, 13, 18,  25,  35,  53, -1,  -4,  -8, -13, -18,  -25,  -35,  -53 },
+  { 1,  6, 10, 16, 22,  31,  43,  64, -1,  -6, -10, -16, -22,  -31,  -43,  -64 },
+  { 2,  7, 12, 19, 27,  37,  51,  76, -2,  -7, -12, -19, -27,  -37,  -51,  -76 },
+  { 2,  9, 16, 24, 34,  46,  64,  96, -2,  -9, -16, -24, -34,  -46,  -64,  -96 },
+  { 3, 11, 19, 29, 41,  57,  79, 117, -3, -11, -19, -29, -41,  -57,  -79, -117 },
+  { 4, 13, 24, 36, 50,  69,  96, 143, -4, -13, -24, -36, -50,  -69,  -96, -143 },
+  { 4, 16, 29, 44, 62,  85, 118, 175, -4, -16, -29, -44, -62,  -85, -118, -175 },
+  { 6, 20, 36, 54, 76, 104, 144, 214, -6, -20, -36, -54, -76, -104, -144, -214 }
+};
+static const i4 adpcmIndexStep[8] = {
+  -1, -1, 0, 0, 1, 2, 2, 3
+};
 
 auto Cartridge::KARNAK::power() -> void {
   Thread::create(384'000, std::bind_front(&Cartridge::KARNAK::main, this));
 
-  timerEnable = 0;
+  enable = 0;
   timerPeriod = 0;
   timerCounter = 0;
+
+  adpcmReset();
 }
 
 auto Cartridge::KARNAK::reset() -> void {
   Thread::destroy();
 }
 
+auto Cartridge::KARNAK::adpcmReset() -> void {
+  adpcmAccumulator = 0x100;
+  adpcmInputShift = 0;
+  adpcmStepIndex = 0;
+}
+
+auto Cartridge::KARNAK::adpcmNext(n4 sample) -> void {
+  adpcmAccumulator += adpcmAccumulatorStep[adpcmStepIndex][sample];
+  adpcmStepIndex = std::clamp(adpcmStepIndex + adpcmIndexStep[sample & 7], 0, 15);
+}
+
 auto Cartridge::KARNAK::main() -> void {
-  if(timerEnable) {
+  if(enable) {
     if(!timerCounter) {
       timerCounter = (timerPeriod + 1) * 2;
     }
     timerCounter--;
   }
-  cpu.irqLevel(CPU::Interrupt::Cartridge, timerEnable && !timerCounter);
+  cpu.irqLevel(CPU::Interrupt::Cartridge, enable && !timerCounter);
   step(1);
 }
 

ares/ws/cartridge/serialization.cpp

@@ -50,7 +50,11 @@ auto Cartridge::RTC::serialize(serializer& s) -> void {
 auto Cartridge::KARNAK::serialize(serializer& s) -> void {
   Thread::serialize(s);
 
-  s(timerEnable);
+  s(enable);
   s(timerPeriod);
   s(timerCounter);
+
+  s(adpcmAccumulator);
+  s(adpcmStepIndex);
+  s(adpcmInputShift);
 }

ares/ws/system/serialization.cpp

@@ -1,4 +1,4 @@
-static const string SerializerVersion = "v144.3";
+static const string SerializerVersion = "v145.1";
 
 auto System::serialize(bool synchronize) -> serializer {
   if(synchronize) scheduler.enter(Scheduler::Mode::Synchronize);