Update to v089 release.

byuu says:

Changelog to v089:
- fix SA-1 Mini Yonku Shining Scorpion
- load from command-line
- remove SNES::Cartridge::NVRAM
- fix SGB save RAM
- update cheats.xml
- already mapped inputs cancel input assign

BS-X wasn't broken after all. I forgot that I ran purify on my BS-X
images, and that the BS Zelda ZIP I have has the disable ROM bit set.
Whoops.

.gitignore

@@ -0,0 +1,3 @@
+purify/*.o
+purify/purify
+purify/analyze-gba

bsnes/Makefile

@@ -1,10 +1,12 @@
 include nall/Makefile
 
-nes := nes
-snes := snes
-gameboy := gameboy
+fc  := fc
+sfc := sfc
+gb  := gb
+gba := gba
+
 profile := accuracy
-target := ui
+target  := ethos
 
 # options += console
 
@@ -12,7 +14,7 @@ target := ui
 c       := $(compiler) -std=gnu99
 cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
 flags   := -I. -O3 -fomit-frame-pointer
-link    :=
+link    := -s
 objects := libco
 
 # profile-guided optimization mode
@@ -28,11 +30,12 @@ endif
 
 # platform
 ifeq ($(platform),x)
-  link += -s -ldl -lX11 -lXext
+  flags += -march=native
+  link += -ldl -lX11 -lXext
 else ifeq ($(platform),osx)
 else ifeq ($(platform),win)
   link += $(if $(findstring console,$(options)),-mconsole,-mwindows)
-  link += -mthreads -s -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32
+  link += -mthreads -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32
   link += -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
 else
   unknown_platform: help;
@@ -90,7 +93,8 @@ sync:
 	rm -r phoenix/nall
 	rm -r phoenix/test
 
-archive-all:
-	tar -cjf bsnes.tar.bz2 base data gameboy libco nall nes obj out phoenix ruby snes target-debugger target-libsnes target-ui Makefile cc.bat purge.bat
+archive:
+	if [ -f bsnes.tar.bz2 ]; then rm bsnes.tar.bz2; fi
+	tar -cjf bsnes.tar.bz2 `ls`
 
 help:;

bsnes/emulator/emulator.hpp

@@ -1,29 +1,36 @@
-#ifndef BASE_HPP
-#define BASE_HPP
+#ifndef EMULATOR_HPP
+#define EMULATOR_HPP
 
-const char Version[] = "087";
+namespace Emulator {
+  static const char Name[] = "bsnes";
+  static const char Version[] = "089";
+  static const char Author[] = "byuu";
+  static const char License[] = "GPLv3";
+}
 
 #include <nall/platform.hpp>
 #include <nall/algorithm.hpp>
-#include <nall/any.hpp>
-#include <nall/array.hpp>
 #include <nall/dl.hpp>
 #include <nall/dsp.hpp>
 #include <nall/endian.hpp>
 #include <nall/file.hpp>
 #include <nall/function.hpp>
-#include <nall/moduloarray.hpp>
 #include <nall/priorityqueue.hpp>
 #include <nall/property.hpp>
 #include <nall/random.hpp>
 #include <nall/serializer.hpp>
+#include <nall/sha256.hpp>
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 #include <nall/utility.hpp>
 #include <nall/varint.hpp>
 #include <nall/vector.hpp>
+#include <nall/stream/memory.hpp>
+#include <nall/stream/vector.hpp>
 using namespace nall;
 
+#include "interface.hpp"
+
 //debugging function hook:
 //no overhead (and no debugger invocation) if not compiled with -DDEBUGGER
 //wraps testing of function to allow invocation without a defined callback
@@ -42,8 +49,8 @@ template<typename R, typename... P> struct hook<R (P...)> {
   hook(const hook &hook) { callback = hook.callback; }
   hook(void *function) { callback = function; }
   hook(R (*function)(P...)) { callback = function; }
-  template<typename C> hook(R (C::*function)(P...), C *object) { callback = { function, object }; }
-  template<typename C> hook(R (C::*function)(P...) const, C *object) { callback = { function, object }; }
+  template<typename C> hook(R (C::*function)(P...), C *object) { callback = {function, object}; }
+  template<typename C> hook(R (C::*function)(P...) const, C *object) { callback = {function, object}; }
   template<typename L> hook(const L& function) { callback = function; }
 
   hook& operator=(const hook& hook) { callback = hook.callback; return *this; }
@@ -55,15 +62,15 @@ template<typename R, typename... P> struct hook<R (P...)> {
   #define privileged private
 #endif
 
-typedef  int1_t int1;
-typedef  int2_t int2;
-typedef  int3_t int3;
-typedef  int4_t int4;
-typedef  int5_t int5;
-typedef  int6_t int6;
-typedef  int7_t int7;
-typedef  int8_t int8;
-typedef  int9_t int9;
+typedef  int1_t  int1;
+typedef  int2_t  int2;
+typedef  int3_t  int3;
+typedef  int4_t  int4;
+typedef  int5_t  int5;
+typedef  int6_t  int6;
+typedef  int7_t  int7;
+typedef  int8_t  int8;
+typedef  int9_t  int9;
 typedef int10_t int10;
 typedef int11_t int11;
 typedef int12_t int12;
@@ -89,15 +96,15 @@ typedef int31_t int31;
 typedef int32_t int32;
 typedef int64_t int64;
 
-typedef  uint1_t uint1;
-typedef  uint2_t uint2;
-typedef  uint3_t uint3;
-typedef  uint4_t uint4;
-typedef  uint5_t uint5;
-typedef  uint6_t uint6;
-typedef  uint7_t uint7;
-typedef  uint8_t uint8;
-typedef  uint9_t uint9;
+typedef  uint1_t  uint1;
+typedef  uint2_t  uint2;
+typedef  uint3_t  uint3;
+typedef  uint4_t  uint4;
+typedef  uint5_t  uint5;
+typedef  uint6_t  uint6;
+typedef  uint7_t  uint7;
+typedef  uint8_t  uint8;
+typedef  uint9_t  uint9;
 typedef uint10_t uint10;
 typedef uint11_t uint11;
 typedef uint12_t uint12;
@@ -124,6 +131,6 @@ typedef uint32_t uint32;
 typedef uint_t<33> uint33;
 typedef uint64_t uint64;
 
-typedef varuint_t varuint;
+typedef varuint_t<unsigned> varuint;
 
 #endif

bsnes/emulator/interface.hpp

@@ -0,0 +1,108 @@
+#ifndef EMULATOR_INTERFACE_HPP
+#define EMULATOR_INTERFACE_HPP
+
+namespace Emulator {
+
+struct Interface {
+  struct Information {
+    string name;
+    unsigned width;
+    unsigned height;
+    bool overscan;
+    double aspectRatio;
+    bool resettable;
+  } information;
+
+  struct Media {
+    unsigned id;
+    string name;
+    string type;
+    string path;
+    string extension;
+  };
+
+  vector<Media> firmware;
+  vector<Media> media;
+
+  struct Memory {
+    unsigned id;
+    string name;
+  };
+  vector<Memory> memory;
+
+  struct Device {
+    unsigned id;
+    unsigned portmask;
+    string name;
+    struct Input {
+      unsigned id;
+      unsigned type;  //0 = digital, 1 = analog
+      string name;
+      unsigned guid;
+    };
+    vector<Input> input;
+    vector<unsigned> order;
+  };
+
+  struct Port {
+    unsigned id;
+    string name;
+    vector<Device> device;
+  };
+  vector<Port> port;
+
+  struct Bind {
+    virtual void loadRequest(unsigned, const string&) {}
+    virtual void loadRequest(unsigned, const string&, const string&, const string&) {}
+    virtual uint32_t videoColor(unsigned, uint16_t, uint16_t, uint16_t) { return 0u; }
+    virtual void videoRefresh(const uint32_t*, unsigned, unsigned, unsigned) {}
+    virtual void audioSample(int16_t, int16_t) {}
+    virtual int16_t inputPoll(unsigned, unsigned, unsigned) { return 0; }
+    virtual unsigned dipSettings(const XML::Node&) { return 0; }
+    virtual string path(unsigned) { return ""; }
+  } *bind;
+
+  //callback bindings (provided by user interface)
+  void loadRequest(unsigned id, const string &path) { return bind->loadRequest(id, path); }
+  void loadRequest(unsigned id, const string &name, const string &type, const string &path) { return bind->loadRequest(id, name, type, path); }
+  uint32_t videoColor(unsigned source, uint16_t red, uint16_t green, uint16_t blue) { return bind->videoColor(source, red, green, blue); }
+  void videoRefresh(const uint32_t *data, unsigned pitch, unsigned width, unsigned height) { return bind->videoRefresh(data, pitch, width, height); }
+  void audioSample(int16_t lsample, int16_t rsample) { return bind->audioSample(lsample, rsample); }
+  int16_t inputPoll(unsigned port, unsigned device, unsigned input) { return bind->inputPoll(port, device, input); }
+  unsigned dipSettings(const XML::Node &node) { return bind->dipSettings(node); }
+  string path(unsigned group) { return bind->path(group); }
+
+  //information
+  virtual double videoFrequency() = 0;
+  virtual double audioFrequency() = 0;
+
+  //media interface
+  virtual bool loaded() { return false; }
+  virtual string sha256() { return ""; }
+  virtual unsigned group(unsigned id) { return 0u; }
+  virtual void load(unsigned id, const stream &memory, const string &markup = "") {}
+  virtual void save(unsigned id, const stream &memory) {}
+  virtual void unload() {}
+
+  //system interface
+  virtual void connect(unsigned port, unsigned device) {}
+  virtual void power() {}
+  virtual void reset() {}
+  virtual void run() {}
+
+  //state functions
+  virtual serializer serialize() = 0;
+  virtual bool unserialize(serializer&) = 0;
+
+  //cheat functions
+  virtual void cheatSet(const lstring& = lstring{}) {}
+
+  //utility functions
+  virtual void updatePalette() {}
+
+  Interface() : bind(nullptr) {}
+};
+
+}
+
+#endif

bsnes/fc/Makefile

@@ -0,0 +1,16 @@
+fc_objects := fc-interface fc-system fc-scheduler fc-input
+fc_objects += fc-memory fc-cartridge fc-cpu fc-apu fc-ppu
+fc_objects += fc-cheat fc-video
+objects += $(fc_objects)
+
+obj/fc-interface.o: $(fc)/interface/interface.cpp $(call rwildcard,$(fc)/interface/)
+obj/fc-system.o: $(fc)/system/system.cpp $(call rwildcard,$(fc)/system/)
+obj/fc-scheduler.o: $(fc)/scheduler/scheduler.cpp $(call rwildcard,$(fc)/scheduler/)
+obj/fc-input.o: $(fc)/input/input.cpp $(call rwildcard,$(fc)/input/)
+obj/fc-memory.o: $(fc)/memory/memory.cpp $(call rwildcard,$(fc)/memory/)
+obj/fc-cartridge.o: $(fc)/cartridge/cartridge.cpp $(call rwildcard,$(fc)/cartridge/)
+obj/fc-cpu.o: $(fc)/cpu/cpu.cpp $(call rwildcard,$(fc)/cpu/)
+obj/fc-apu.o: $(fc)/apu/apu.cpp $(call rwildcard,$(fc)/apu/)
+obj/fc-ppu.o: $(fc)/ppu/ppu.cpp $(call rwildcard,$(fc)/ppu/)
+obj/fc-cheat.o: $(fc)/cheat/cheat.cpp $(call rwildcard,$(fc)/cheat/)
+obj/fc-video.o: $(fc)/video/video.cpp $(call rwildcard,$(fc)/video/)

bsnes/fc/apu/apu.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 #include "envelope.cpp"
 #include "sweep.cpp"
@@ -60,7 +60,7 @@ void APU::main() {
   //output  = filter.run_lopass(output);
     output  = sclamp<16>(output);
 
-    interface->audioSample(output);
+    interface->audioSample(output, output);
 
     tick();
   }
@@ -92,7 +92,7 @@ void APU::power() {
 }
 
 void APU::reset() {
-  Processor::create(APU::Main, 21477272);
+  create(APU::Main, 21477272);
 
   pulse[0].reset();
   pulse[1].reset();

bsnes/fc/apu/apu.hpp

@@ -1,4 +1,4 @@
-struct APU : Processor {
+struct APU : Thread {
   static void Main();
   void main();
   void tick();

bsnes/fc/apu/serialization.cpp

@@ -1,5 +1,5 @@
 void APU::serialize(serializer &s) {
-  Processor::serialize(s);
+  Thread::serialize(s);
 
   filter.serialize(s);
 

bsnes/fc/cartridge/board/bandai-fcg.cpp

@@ -111,7 +111,7 @@ void serialize(serializer &s) {
   s.integer(irq_latch);
 }
 
-BandaiFCG(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+BandaiFCG(XML::Document &document, const stream &memory) : Board(document, memory) {
 }
 
 };

bsnes/fc/cartridge/board/board.cpp

@@ -0,0 +1,167 @@
+#include "bandai-fcg.cpp"
+#include "konami-vrc1.cpp"
+#include "konami-vrc2.cpp"
+#include "konami-vrc3.cpp"
+#include "konami-vrc4.cpp"
+#include "konami-vrc6.cpp"
+#include "konami-vrc7.cpp"
+#include "nes-axrom.cpp"
+#include "nes-bnrom.cpp"
+#include "nes-cnrom.cpp"
+#include "nes-exrom.cpp"
+#include "nes-fxrom.cpp"
+#include "nes-gxrom.cpp"
+#include "nes-hkrom.cpp"
+#include "nes-nrom.cpp"
+#include "nes-pxrom.cpp"
+#include "nes-sxrom.cpp"
+#include "nes-txrom.cpp"
+#include "nes-uxrom.cpp"
+#include "sunsoft-5b.cpp"
+
+uint8 Board::Memory::read(unsigned addr) const {
+  return data[mirror(addr, size)];
+}
+
+void Board::Memory::write(unsigned addr, uint8 byte) {
+  if(writable) data[mirror(addr, size)] = byte;
+}
+
+unsigned Board::mirror(unsigned addr, unsigned size) {
+  unsigned base = 0;
+  if(size) {
+    unsigned mask = 1 << 23;
+    while(addr >= size) {
+      while(!(addr & mask)) mask >>= 1;
+      addr -= mask;
+      if(size > mask) {
+        size -= mask;
+        base += mask;
+      }
+      mask >>= 1;
+    }
+    base += addr;
+  }
+  return base;
+}
+
+void Board::main() {
+  while(true) {
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
+    }
+
+    cartridge.clock += 12 * 4095;
+    tick();
+  }
+}
+
+void Board::tick() {
+  cartridge.clock += 12;
+  if(cartridge.clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(cpu.thread);
+}
+
+uint8 Board::chr_read(unsigned addr) {
+  if(chrram.size) return chrram.data[mirror(addr, chrram.size)];
+  if(chrrom.size) return chrrom.data[mirror(addr, chrrom.size)];
+  return 0u;
+}
+
+void Board::chr_write(unsigned addr, uint8 data) {
+  if(chrram.size) chrram.data[mirror(addr, chrram.size)] = data;
+}
+
+Board::Memory& Board::memory() {
+  return prgram;
+}
+
+void Board::power() {
+}
+
+void Board::reset() {
+}
+
+void Board::serialize(serializer &s) {
+  if(prgram.size) s.array(prgram.data, prgram.size);
+  if(chrram.size) s.array(chrram.data, chrram.size);
+}
+
+Board::Board(XML::Document &document, const stream &memory) {
+  auto &cartridge = document["cartridge"];
+
+  information.type = cartridge["board"]["type"].data;
+  information.battery = cartridge["prg"]["ram"]["nonvolatile"].data == "true";
+
+  prgrom.size = numeral(cartridge["prg"]["rom"]["size"].data);
+  prgram.size = numeral(cartridge["prg"]["ram"]["size"].data);
+  chrrom.size = numeral(cartridge["chr"]["rom"]["size"].data);
+  chrram.size = numeral(cartridge["chr"]["ram"]["size"].data);
+
+  if(prgrom.size) prgrom.data = new uint8[prgrom.size]();
+  if(prgram.size) prgram.data = new uint8[prgram.size]();
+  if(chrrom.size) chrrom.data = new uint8[chrrom.size]();
+  if(chrram.size) chrram.data = new uint8[chrram.size]();
+
+  if(prgrom.size) memory.read(prgrom.data, prgrom.size);
+  if(chrrom.size) memory.read(chrrom.data, chrrom.size);
+
+  prgram.writable = true;
+  chrram.writable = true;
+}
+
+Board::~Board() {
+}
+
+Board* Board::load(const string &markup, const stream &memory) {
+  XML::Document document(markup);
+  string type = document["cartridge"]["board"]["type"].data;
+
+  if(type == "BANDAI-FCG") return new BandaiFCG(document, memory);
+
+  if(type == "KONAMI-VRC-1") return new KonamiVRC1(document, memory);
+  if(type == "KONAMI-VRC-2") return new KonamiVRC2(document, memory);
+  if(type == "KONAMI-VRC-3") return new KonamiVRC3(document, memory);
+  if(type == "KONAMI-VRC-4") return new KonamiVRC4(document, memory);
+  if(type == "KONAMI-VRC-6") return new KonamiVRC6(document, memory);
+  if(type == "KONAMI-VRC-7") return new KonamiVRC7(document, memory);
+
+  if(type == "NES-AMROM"   ) return new NES_AxROM(document, memory);
+  if(type == "NES-ANROM"   ) return new NES_AxROM(document, memory);
+  if(type == "NES-AN1ROM"  ) return new NES_AxROM(document, memory);
+  if(type == "NES-AOROM"   ) return new NES_AxROM(document, memory);
+
+  if(type == "NES-BNROM"   ) return new NES_BNROM(document, memory);
+
+  if(type == "NES-CNROM"   ) return new NES_CNROM(document, memory);
+
+  if(type == "NES-EKROM"   ) return new NES_ExROM(document, memory);
+  if(type == "NES-ELROM"   ) return new NES_ExROM(document, memory);
+  if(type == "NES-ETROM"   ) return new NES_ExROM(document, memory);
+  if(type == "NES-EWROM"   ) return new NES_ExROM(document, memory);
+
+  if(type == "NES-FJROM"   ) return new NES_FxROM(document, memory);
+  if(type == "NES-FKROM"   ) return new NES_FxROM(document, memory);
+
+  if(type == "NES-GNROM"   ) return new NES_GxROM(document, memory);
+  if(type == "NES-MHROM"   ) return new NES_GxROM(document, memory);
+
+  if(type == "NES-HKROM"   ) return new NES_HKROM(document, memory);
+
+  if(type == "NES-NROM-128") return new NES_NROM(document, memory);
+  if(type == "NES-NROM-256") return new NES_NROM(document, memory);
+
+  if(type == "NES-PEEOROM" ) return new NES_PxROM(document, memory);
+  if(type == "NES-PNROM"   ) return new NES_PxROM(document, memory);
+
+  if(type == "NES-SNROM"   ) return new NES_SxROM(document, memory);
+  if(type == "NES-SXROM"   ) return new NES_SxROM(document, memory);
+
+  if(type == "NES-TLROM"   ) return new NES_TxROM(document, memory);
+
+  if(type == "NES-UNROM"   ) return new NES_UxROM(document, memory);
+  if(type == "NES-UOROM"   ) return new NES_UxROM(document, memory);
+
+  if(type == "SUNSOFT-5B"  ) return new Sunsoft5B(document, memory);
+
+  return nullptr;
+}

bsnes/fc/cartridge/board/board.hpp

@@ -31,10 +31,10 @@ struct Board {
   virtual void reset();
 
   virtual void serialize(serializer&);
-  Board(XML::Node &board, const uint8_t *data, unsigned size);
+  Board(XML::Document &document, const stream &memory);
   virtual ~Board();
 
-  static Board* load(const string &markup, const uint8_t *data, unsigned size);
+  static Board* load(const string &markup, const stream &memory);
 
   struct Information {
     string type;

bsnes/fc/cartridge/board/konami-vrc1.cpp

@@ -34,7 +34,7 @@ void serialize(serializer &s) {
   vrc1.serialize(s);
 }
 
-KonamiVRC1(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc1(*this) {
+KonamiVRC1(XML::Document &document, const stream &memory) : Board(document, memory), vrc1(*this) {
 }
 
 };

bsnes/fc/cartridge/board/konami-vrc2.cpp

@@ -49,9 +49,9 @@ void serialize(serializer &s) {
   vrc2.serialize(s);
 }
 
-KonamiVRC2(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc2(*this) {
-  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].data);
-  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].data);
+KonamiVRC2(XML::Document &document, const stream &memory) : Board(document, memory), vrc2(*this) {
+  settings.pinout.a0 = 1 << decimal(document["cartridge"]["chip"]["pinout"]["a0"].data);
+  settings.pinout.a1 = 1 << decimal(document["cartridge"]["chip"]["pinout"]["a1"].data);
 }
 
 };

bsnes/fc/cartridge/board/konami-vrc3.cpp

@@ -50,8 +50,8 @@ void serialize(serializer &s) {
   vrc3.serialize(s);
 }
 
-KonamiVRC3(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc3(*this) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+KonamiVRC3(XML::Document &document, const stream &memory) : Board(document, memory), vrc3(*this) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/konami-vrc4.cpp

@@ -53,9 +53,9 @@ void serialize(serializer &s) {
   vrc4.serialize(s);
 }
 
-KonamiVRC4(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc4(*this) {
-  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].data);
-  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].data);
+KonamiVRC4(XML::Document &document, const stream &memory) : Board(document, memory), vrc4(*this) {
+  settings.pinout.a0 = 1 << decimal(document["cartridge"]["chip"]["pinout"]["a0"].data);
+  settings.pinout.a1 = 1 << decimal(document["cartridge"]["chip"]["pinout"]["a1"].data);
 }
 
 };

bsnes/fc/cartridge/board/konami-vrc6.cpp

@@ -36,7 +36,7 @@ void main() { vrc6.main(); }
 void power() { vrc6.power(); }
 void reset() { vrc6.reset(); }
 
-KonamiVRC6(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc6(*this) {
+KonamiVRC6(XML::Document &document, const stream &memory) : Board(document, memory), vrc6(*this) {
 }
 
 };

bsnes/fc/cartridge/board/konami-vrc7.cpp

@@ -41,7 +41,7 @@ void serialize(serializer &s) {
   vrc7.serialize(s);
 }
 
-KonamiVRC7(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc7(*this) {
+KonamiVRC7(XML::Document &document, const stream &memory) : Board(document, memory), vrc7(*this) {
 }
 
 };

bsnes/fc/cartridge/board/nes-axrom.cpp

@@ -45,7 +45,7 @@ void serialize(serializer &s) {
   s.integer(mirror_select);
 }
 
-NES_AxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+NES_AxROM(XML::Document &document, const stream &memory) : Board(document, memory) {
 }
 
 };

bsnes/fc/cartridge/board/nes-bnrom.cpp

@@ -45,8 +45,8 @@ void serialize(serializer &s) {
   s.integer(prg_bank);
 }
 
-NES_BNROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+NES_BNROM(XML::Document &document, const stream &memory) : Board(document, memory) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/nes-cnrom.cpp

@@ -47,8 +47,8 @@ void serialize(serializer &s) {
   s.integer(chr_bank);
 }
 
-NES_CNROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+NES_CNROM(XML::Document &document, const stream &memory) : Board(document, memory) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/nes-exrom.cpp

@@ -46,7 +46,7 @@ void serialize(serializer &s) {
   mmc5.serialize(s);
 }
 
-NES_ExROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc5(*this) {
+NES_ExROM(XML::Document &document, const stream &memory) : Board(document, memory), mmc5(*this) {
   revision = Revision::ELROM;
 }
 

bsnes/fc/cartridge/board/nes-fxrom.cpp

@@ -84,7 +84,7 @@ void serialize(serializer &s) {
   s.array(latch);
 }
 
-NES_FxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+NES_FxROM(XML::Document &document, const stream &memory) : Board(document, memory) {
   revision = Revision::FKROM;
 }
 

bsnes/fc/cartridge/board/nes-gxrom.cpp

@@ -54,8 +54,8 @@ void serialize(serializer &s) {
   s.integer(chr_bank);
 }
 
-NES_GxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+NES_GxROM(XML::Document &document, const stream &memory) : Board(document, memory) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/nes-hkrom.cpp

@@ -42,7 +42,7 @@ void serialize(serializer &s) {
   mmc6.serialize(s);
 }
 
-NES_HKROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc6(*this) {
+NES_HKROM(XML::Document &document, const stream &memory) : Board(document, memory), mmc6(*this) {
 }
 
 };

bsnes/fc/cartridge/board/nes-nrom.cpp

@@ -36,8 +36,8 @@ void serialize(serializer &s) {
   Board::serialize(s);
 }
 
-NES_NROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+NES_NROM(XML::Document &document, const stream &memory) : Board(document, memory) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/nes-pxrom.cpp

@@ -90,7 +90,7 @@ void serialize(serializer &s) {
   s.array(latch);
 }
 
-NES_PxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+NES_PxROM(XML::Document &document, const stream &memory) : Board(document, memory) {
   revision = Revision::PNROM;
 }
 

bsnes/fc/cartridge/board/nes-sxrom.cpp

@@ -94,7 +94,7 @@ void serialize(serializer &s) {
   mmc1.serialize(s);
 }
 
-NES_SxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc1(*this) {
+NES_SxROM(XML::Document &document, const stream &memory) : Board(document, memory), mmc1(*this) {
   revision = Revision::SXROM;
 }
 

bsnes/fc/cartridge/board/nes-txrom.cpp

@@ -60,7 +60,7 @@ void serialize(serializer &s) {
   mmc3.serialize(s);
 }
 
-NES_TxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc3(*this) {
+NES_TxROM(XML::Document &document, const stream &memory) : Board(document, memory), mmc3(*this) {
   revision = Revision::TLROM;
 }
 

bsnes/fc/cartridge/board/nes-uxrom.cpp

@@ -48,8 +48,8 @@ void serialize(serializer &s) {
   s.integer(prg_bank);
 }
 
-NES_UxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
+NES_UxROM(XML::Document &document, const stream &memory) : Board(document, memory) {
+  settings.mirror = document["cartridge"]["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/fc/cartridge/board/sunsoft-5b.cpp

@@ -220,7 +220,7 @@ void serialize(serializer &s) {
   pulse[2].serialize(s);
 }
 
-Sunsoft5B(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+Sunsoft5B(XML::Document &document, const stream &memory) : Board(document, memory) {
 }
 
 };

bsnes/fc/cartridge/cartridge.cpp

@@ -1,8 +1,7 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
-#include "ines.cpp"
 #include "chip/chip.cpp"
 #include "board/board.cpp"
 Cartridge cartridge;
@@ -15,18 +14,25 @@ void Cartridge::main() {
   board->main();
 }
 
-void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
-  if((size & 0xff) == 0) {
-    sha256 = nall::sha256(data, size);
-    board = Board::load(markup, data, size);
-  } else {
-  //unsigned crc32 = crc32_calculate(data + 16, size - 16);
-  //print(hex<8>(crc32), "\n");
-    sha256 = nall::sha256(data + 16, size - 16);
-    board = Board::load(!markup.empty() ? markup : iNES(data, size), data + 16, size - 16);
-  }
+void Cartridge::load(const string &markup, const stream &memory) {
+  information.markup = markup;
+
+  board = Board::load(markup, memory);
   if(board == nullptr) return;
 
+  interface->memory.append({ID::RAM, "save.ram"});
+
+  sha256_ctx sha;
+  uint8_t hash[32];
+  sha256_init(&sha);
+  sha256_chunk(&sha, board->prgrom.data, board->prgrom.size);
+  sha256_chunk(&sha, board->chrrom.data, board->chrrom.size);
+  sha256_final(&sha);
+  sha256_hash(&sha, hash);
+  string result;
+  for(auto &byte : hash) result.append(hex<2>(byte));
+  sha256 = result;
+
   system.load();
   loaded = true;
 }
@@ -78,7 +84,7 @@ void Cartridge::scanline(unsigned y) {
 }
 
 void Cartridge::serialize(serializer &s) {
-  Processor::serialize(s);
+  Thread::serialize(s);
   return board->serialize(s);
 }
 

bsnes/fc/cartridge/cartridge.hpp

@@ -1,11 +1,11 @@
 #include "chip/chip.hpp"
 #include "board/board.hpp"
 
-struct Cartridge : Processor, property<Cartridge> {
+struct Cartridge : Thread, property<Cartridge> {
   static void Main();
   void main();
 
-  void load(const string &markup, const uint8_t *data, unsigned size);
+  void load(const string &markup, const stream &memory);
   void unload();
 
   unsigned ram_size();
@@ -17,6 +17,10 @@ struct Cartridge : Processor, property<Cartridge> {
   readonly<bool> loaded;
   readonly<string> sha256;
 
+  struct Information {
+    string markup;
+  } information;
+
   void serialize(serializer&);
   Cartridge();
 

bsnes/fc/cheat/cheat.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 Cheat cheat;
 

bsnes/fc/cpu/cpu.cpp

@@ -1,40 +1,30 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
-#include "core/core.cpp"
-#include "memory/memory.cpp"
+#include "timing.cpp"
 #include "serialization.cpp"
 CPU cpu;
 
-void CPU::Main() {
-  cpu.main();
-}
-
-void CPU::main() {
-//trace = true;
-//FILE *fp = fopen("/home/byuu/Desktop/log.txt", "wb");
-
-  unsigned lpc = 0xffff;
+void CPU::Enter() {
   while(true) {
     if(scheduler.sync == Scheduler::SynchronizeMode::All) {
       scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
     }
 
-    if(status.interrupt_pending) {
-      interrupt();
-      continue;
-    }
-
-    if(trace) {
-      if(lpc != regs.pc) { print(disassemble(), "\n"); } lpc = regs.pc;
-    //if(lpc != regs.pc) { fprintf(fp, "%s\n", (const char*)disassemble()); fflush(fp); } lpc = regs.pc;
-    }
-
-    op_exec();
+    cpu.main();
   }
 }
 
+void CPU::main() {
+  if(status.interrupt_pending) {
+    interrupt();
+    return;
+  }
+
+  exec();
+}
+
 void CPU::add_clocks(unsigned clocks) {
   apu.clock -= clocks;
   if(apu.clock < 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(apu.thread);
@@ -47,11 +37,7 @@ void CPU::add_clocks(unsigned clocks) {
 }
 
 void CPU::power() {
-  regs.a = 0x00;
-  regs.x = 0x00;
-  regs.y = 0x00;
-  regs.s = 0x00;
-  regs.p = 0x04;
+  R6502::power();
 
   for(unsigned addr = 0; addr < 0x0800; addr++) ram[addr] = 0xff;
   ram[0x0008] = 0xf7;
@@ -61,11 +47,8 @@ void CPU::power() {
 }
 
 void CPU::reset() {
-  Processor::create(CPU::Main, 21477272);
-
-  regs.mdr = 0x00;
-  regs.s -= 3;
-  regs.p.i = 1;
+  R6502::reset();
+  create(CPU::Enter, 21477272);
 
   regs.pc  = bus.read(0xfffc) << 0;
   regs.pc |= bus.read(0xfffd) << 8;
@@ -87,16 +70,8 @@ void CPU::reset() {
   status.controller_port1 = 0;
 }
 
-uint8 CPU::mdr() const {
-  return regs.mdr;
-}
-
-void CPU::set_rdy_line(bool line) {
-  status.rdy_line = line;
-}
-
-void CPU::set_rdy_addr(optional<uint16> addr) {
-  status.rdy_addr = addr;
+uint8 CPU::debugger_read(uint16 addr) {
+  return bus.read(addr);
 }
 
 uint8 CPU::ram_read(uint16 addr) {
@@ -132,11 +107,4 @@ void CPU::write(uint16 addr, uint8 data) {
   return apu.write(addr, data);
 }
 
-void CPU::oam_dma() {
-  for(unsigned n = 0; n < 256; n++) {
-    uint8 data = op_read((status.oam_dma_page << 8) + n);
-    op_write(0x2004, data);
-  }
-}
-
 }

bsnes/fc/cpu/cpu.hpp

@@ -1,6 +1,4 @@
-struct CPU : Processor {
-  #include "core/core.hpp"
-  #include "memory/memory.hpp"
+struct CPU : Processor::R6502, Thread {
   uint8 ram[0x0800];
 
   struct Status {
@@ -21,16 +19,14 @@ struct CPU : Processor {
     unsigned controller_port1;
   } status;
 
-  static void Main();
+  static void Enter();
   void main();
   void add_clocks(unsigned clocks);
 
   void power();
   void reset();
 
-  uint8 mdr() const;
-  void set_rdy_line(bool);
-  void set_rdy_addr(optional<uint16>);
+  uint8 debugger_read(uint16 addr);
 
   uint8 ram_read(uint16 addr);
   void ram_write(uint16 addr, uint8 data);
@@ -38,12 +34,22 @@ struct CPU : Processor {
   uint8 read(uint16 addr);
   void write(uint16 addr, uint8 data);
 
-  void oam_dma();
-
   void serialize(serializer&);
 
-//internal:
-  bool trace;
+  //timing.cpp
+  uint8 op_read(uint16 addr);
+  void op_write(uint16 addr, uint8 data);
+  void last_cycle();
+  void nmi(uint16 &vector);
+
+  void oam_dma();
+
+  void set_nmi_line(bool);
+  void set_irq_line(bool);
+  void set_irq_apu_line(bool);
+
+  void set_rdy_line(bool);
+  void set_rdy_addr(optional<uint16>);
 };
 
 extern CPU cpu;

bsnes/fc/cpu/serialization.cpp

@@ -1,27 +1,9 @@
 void CPU::serialize(serializer &s) {
-  Processor::serialize(s);
+  R6502::serialize(s);
+  Thread::serialize(s);
 
   s.array(ram);
 
-  s.integer(regs.mdr);
-  s.integer(regs.pc);
-  s.integer(regs.a);
-  s.integer(regs.x);
-  s.integer(regs.y);
-  s.integer(regs.s);
-  s.integer(regs.p.n);
-  s.integer(regs.p.v);
-  s.integer(regs.p.d);
-  s.integer(regs.p.i);
-  s.integer(regs.p.z);
-  s.integer(regs.p.c);
-
-  s.integer(abs.w);
-  s.integer(iabs.w);
-  s.integer(rd);
-  s.integer(zp);
-  s.integer(aa);
-
   s.integer(status.interrupt_pending);
   s.integer(status.nmi_pending);
   s.integer(status.nmi_line);

bsnes/fc/cpu/timing.cpp

@@ -0,0 +1,63 @@
+uint8 CPU::op_read(uint16 addr) {
+  if(status.oam_dma_pending) {
+    status.oam_dma_pending = false;
+    op_read(addr);
+    oam_dma();
+  }
+
+  while(status.rdy_line == 0) {
+    regs.mdr = bus.read(status.rdy_addr ? status.rdy_addr() : addr);
+    add_clocks(12);
+  }
+
+  regs.mdr = bus.read(addr);
+  add_clocks(12);
+  return regs.mdr;
+}
+
+void CPU::op_write(uint16 addr, uint8 data) {
+  bus.write(addr, regs.mdr = data);
+  add_clocks(12);
+}
+
+void CPU::last_cycle() {
+  status.interrupt_pending = ((status.irq_line | status.irq_apu_line) & ~regs.p.i) | status.nmi_pending;
+}
+
+void CPU::nmi(uint16 &vector) {
+  if(status.nmi_pending) {
+    status.nmi_pending = false;
+    vector = 0xfffa;
+  }
+}
+
+void CPU::oam_dma() {
+  for(unsigned n = 0; n < 256; n++) {
+    uint8 data = op_read((status.oam_dma_page << 8) + n);
+    op_write(0x2004, data);
+  }
+}
+
+void CPU::set_nmi_line(bool line) {
+  //edge-sensitive (0->1)
+  if(!status.nmi_line && line) status.nmi_pending = true;
+  status.nmi_line = line;
+}
+
+void CPU::set_irq_line(bool line) {
+  //level-sensitive
+  status.irq_line = line;
+}
+
+void CPU::set_irq_apu_line(bool line) {
+  //level-sensitive
+  status.irq_apu_line = line;
+}
+
+void CPU::set_rdy_line(bool line) {
+  status.rdy_line = line;
+}
+
+void CPU::set_rdy_addr(optional<uint16> addr) {
+  status.rdy_addr = addr;
+}

bsnes/fc/fc.hpp

@@ -0,0 +1,62 @@
+#ifndef FC_HPP
+#define FC_HPP
+
+#include <emulator/emulator.hpp>
+#include <processor/r6502/r6502.hpp>
+
+namespace Famicom {
+  namespace Info {
+    static const char Name[] = "bnes";
+    static const unsigned SerializerVersion = 2;
+  }
+}
+
+/*
+  bnes - Famicom emulator
+  authors: byuu, Ryphecha
+  license: GPLv3
+  project started: 2011-09-05
+*/
+
+#include <libco/libco.h>
+
+namespace Famicom {
+  struct Thread {
+    cothread_t thread;
+    unsigned frequency;
+    int64 clock;
+
+    inline void create(void (*entrypoint)(), unsigned frequency) {
+      if(thread) co_delete(thread);
+      thread = co_create(65536 * sizeof(void*), entrypoint);
+      this->frequency = frequency;
+      clock = 0;
+    }
+
+    inline void serialize(serializer &s) {
+      s.integer(frequency);
+      s.integer(clock);
+    }
+
+    inline Thread() : thread(nullptr) {
+    }
+
+    inline ~Thread() {
+      if(thread) co_delete(thread);
+    }
+  };
+
+  #include <fc/system/system.hpp>
+  #include <fc/scheduler/scheduler.hpp>
+  #include <fc/input/input.hpp>
+  #include <fc/memory/memory.hpp>
+  #include <fc/cartridge/cartridge.hpp>
+  #include <fc/cpu/cpu.hpp>
+  #include <fc/apu/apu.hpp>
+  #include <fc/ppu/ppu.hpp>
+  #include <fc/cheat/cheat.hpp>
+  #include <fc/video/video.hpp>
+  #include <fc/interface/interface.hpp>
+}
+
+#endif

bsnes/fc/input/input.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 #include "serialization.cpp"
 Input input;

bsnes/fc/interface/interface.cpp

@@ -0,0 +1,121 @@
+#include <fc/fc.hpp>
+
+namespace Famicom {
+
+Interface *interface = nullptr;
+
+double Interface::videoFrequency() {
+  return 21477272.0 / (262.0 * 1364.0 - 4.0);
+}
+
+double Interface::audioFrequency() {
+  return 21477272.0 / 12.0;
+}
+
+bool Interface::loaded() {
+  return cartridge.loaded();
+}
+
+string Interface::sha256() {
+  return cartridge.sha256();
+}
+
+void Interface::load(unsigned id, const stream &stream, const string &markup) {
+  if(id == ID::ROM) {
+    cartridge.load(markup, stream);
+    system.power();
+    input.connect(0, Input::Device::Joypad);
+    input.connect(1, Input::Device::Joypad);
+  }
+
+  if(id == ID::RAM) {
+    stream.read(cartridge.ram_data(), min(stream.size(), cartridge.ram_size()));
+  }
+}
+
+void Interface::save(unsigned id, const stream &stream) {
+  if(id == ID::RAM) {
+    stream.write(cartridge.ram_data(), cartridge.ram_size());
+  }
+}
+
+void Interface::unload() {
+  cartridge.unload();
+}
+
+void Interface::power() {
+  system.power();
+}
+
+void Interface::reset() {
+  system.reset();
+}
+
+void Interface::run() {
+  system.run();
+}
+
+serializer Interface::serialize() {
+  system.runtosave();
+  return system.serialize();
+}
+
+bool Interface::unserialize(serializer &s) {
+  return system.unserialize(s);
+}
+
+void Interface::cheatSet(const lstring &list) {
+  cheat.reset();
+  for(auto &code : list) {
+    lstring codelist = code.split("+");
+    for(auto &part : codelist) {
+      unsigned addr, data, comp;
+      if(Cheat::decode(part, addr, data, comp)) cheat.append({addr, data, comp});
+    }
+  }
+  cheat.synchronize();
+}
+
+void Interface::updatePalette() {
+  video.generate_palette();
+}
+
+Interface::Interface() {
+  interface = this;
+
+  information.name        = "Famicom";
+  information.width       = 256;
+  information.height      = 240;
+  information.overscan    = true;
+  information.aspectRatio = 8.0 / 7.0;
+  information.resettable  = true;
+
+  media.append({ID::ROM, "Famicom", "sys", "program.rom", "fc"});
+
+  {
+    Device device{0, ID::Port1 | ID::Port2, "Controller"};
+    device.input.append({0, 0, "A"     });
+    device.input.append({1, 0, "B"     });
+    device.input.append({2, 0, "Select"});
+    device.input.append({3, 0, "Start" });
+    device.input.append({4, 0, "Up"    });
+    device.input.append({5, 0, "Down"  });
+    device.input.append({6, 0, "Left"  });
+    device.input.append({7, 0, "Right" });
+    device.order = {4, 5, 6, 7, 1, 0, 2, 3};
+    this->device.append(device);
+  }
+
+  port.append({0, "Port 1"});
+  port.append({1, "Port 2"});
+
+  for(auto &device : this->device) {
+    for(auto &port : this->port) {
+      if(device.portmask & (1 << port.id)) {
+        port.device.append(device);
+      }
+    }
+  }
+}
+
+}

bsnes/fc/interface/interface.hpp

@@ -0,0 +1,48 @@
+#ifndef FC_HPP
+namespace Famicom {
+#endif
+
+struct ID {
+  enum : unsigned {
+    ROM,
+    RAM,
+  };
+
+  enum : unsigned {
+    Port1 = 1,
+    Port2 = 2,
+  };
+};
+
+struct Interface : Emulator::Interface {
+  double videoFrequency();
+  double audioFrequency();
+
+  bool loaded();
+  string sha256();
+  void load(unsigned id, const stream &stream, const string &markup = "");
+  void save(unsigned id, const stream &stream);
+  void unload();
+
+  void power();
+  void reset();
+  void run();
+
+  serializer serialize();
+  bool unserialize(serializer&);
+
+  void cheatSet(const lstring&);
+
+  void updatePalette();
+
+  Interface();
+
+private:
+  vector<Device> device;
+};
+
+extern Interface *interface;
+
+#ifndef FC_HPP
+}
+#endif

bsnes/fc/memory/memory.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 Bus bus;
 

bsnes/fc/ppu/ppu.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 #include "serialization.cpp"
 PPU ppu;
@@ -47,7 +47,6 @@ void PPU::scanline() {
 
 void PPU::frame() {
   status.field ^= 1;
-  interface->videoRefresh(buffer);
   scheduler.exit(Scheduler::ExitReason::FrameEvent);
 }
 
@@ -282,7 +281,7 @@ void PPU::scrolly_increment() {
 //
 
 void PPU::raster_pixel() {
-  uint16 *output = buffer + status.ly * 256;
+  uint32 *output = buffer + status.ly * 256;
 
   unsigned mask = 0x8000 >> (status.xaddr + (status.lx & 7));
   unsigned palette = 0, object_palette = 0;
@@ -325,7 +324,7 @@ void PPU::raster_pixel() {
   }
 
   if(raster_enable() == false) palette = 0;
-  output[status.lx] = (status.emphasis << 6) | cgram_read(palette);
+  output[status.lx] = video.palette[(status.emphasis << 6) | cgram_read(palette)];
 }
 
 void PPU::raster_sprite() {

bsnes/fc/ppu/ppu.hpp

@@ -1,4 +1,4 @@
-struct PPU : Processor {
+struct PPU : Thread {
   static void Main();
   void main();
   void tick();
@@ -98,7 +98,7 @@ struct PPU : Processor {
     } oam[8], soam[8];
   } raster;
 
-  uint16 buffer[256 * 262];
+  uint32 buffer[256 * 262];
   uint8 ciram[2048];
   uint8 cgram[32];
   uint8 oam[256];

bsnes/fc/ppu/serialization.cpp

@@ -1,5 +1,5 @@
 void PPU::serialize(serializer &s) {
-  Processor::serialize(s);
+  Thread::serialize(s);
 
   s.integer(status.mdr);
 

bsnes/fc/scheduler/scheduler.cpp

@@ -1,6 +1,6 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 Scheduler scheduler;
 

bsnes/fc/system/serialization.cpp

@@ -1,13 +1,14 @@
 serializer System::serialize() {
   serializer s(serialize_size);
 
-  unsigned signature = 0x31545342, version = Info::SerializerVersion, crc32 = 0;
-  char description[512];
+  unsigned signature = 0x31545342, version = Info::SerializerVersion;
+  char hash[64], description[512];
+  memcpy(&hash, (const char*)cartridge.sha256(), 64);
   memset(&description, 0, sizeof description);
 
   s.integer(signature);
   s.integer(version);
-  s.integer(crc32);
+  s.array(hash);
   s.array(description);
 
   serialize_all(s);
@@ -15,17 +16,16 @@ serializer System::serialize() {
 }
 
 bool System::unserialize(serializer &s) {
-  unsigned signature, version, crc32;
-  char description[512];
+  unsigned signature, version;
+  char hash[64], description[512];
 
   s.integer(signature);
   s.integer(version);
-  s.integer(crc32);
+  s.array(hash);
   s.array(description);
 
   if(signature != 0x31545342) return false;
   if(version != Info::SerializerVersion) return false;
-//if(crc32 != 0) return false;
 
   power();
   serialize_all(s);
@@ -47,12 +47,12 @@ void System::serialize_all(serializer &s) {
 void System::serialize_init() {
   serializer s;
 
-  unsigned signature = 0, version = 0, crc32 = 0;
-  char description[512];
+  unsigned signature = 0, version = 0;
+  char hash[64], description[512];
 
   s.integer(signature);
   s.integer(version);
-  s.integer(crc32);
+  s.array(hash);
   s.array(description);
 
   serialize_all(s);

bsnes/fc/system/system.cpp

@@ -1,12 +1,15 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
-namespace NES {
+namespace Famicom {
 
 #include "serialization.cpp"
 System system;
 
 void System::run() {
   scheduler.enter();
+  if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
+    interface->videoRefresh(ppu.buffer, 4 * 256, 256, 240);
+  }
 }
 
 void System::runtosave() {
@@ -32,7 +35,9 @@ void System::runthreadtosave() {
   while(true) {
     scheduler.enter();
     if(scheduler.exit_reason() == Scheduler::ExitReason::SynchronizeEvent) break;
-    if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent);
+    if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
+      interface->videoRefresh(ppu.buffer, 4 * 256, 256, 240);
+    }
   }
 }
 

bsnes/fc/video/video.cpp

@@ -1,11 +1,23 @@
-#include <nes/nes.hpp>
+#include <fc/fc.hpp>
 
 #define VIDEO_CPP
-namespace NES {
+namespace Famicom {
 
 Video video;
 
-unsigned Video::palette30(
+void Video::generate_palette() {
+  for(unsigned n = 0; n < (1 << 9); n++) palette[n] = generate_color(n, 2.0, 0.0, 1.0, 1.0, 1.8);
+}
+
+Video::Video() {
+  palette = new unsigned[1 << 9];
+}
+
+Video::~Video() {
+  delete[] palette;
+}
+
+uint32_t Video::generate_color(
   unsigned n, double saturation, double hue,
   double contrast, double brightness, double gamma
 ) {
@@ -46,43 +58,11 @@ unsigned Video::palette30(
   q *= saturation;
 
   auto gammaAdjust = [=](double f) { return f < 0.0 ? 0.0 : std::pow(f, 2.2 / gamma); };
-  unsigned r = 1023.0 * gammaAdjust(y +  0.946882 * i +  0.623557 * q);
-  unsigned g = 1023.0 * gammaAdjust(y + -0.274788 * i + -0.635691 * q);
-  unsigned b = 1023.0 * gammaAdjust(y + -1.108545 * i +  1.709007 * q);
-  return (uclamp<10>(r) << 20) + (uclamp<10>(g) << 10) + (uclamp<10>(b) << 0);
-}
+  unsigned r = 65535.0 * gammaAdjust(y +  0.946882 * i +  0.623557 * q);
+  unsigned g = 65535.0 * gammaAdjust(y + -0.274788 * i + -0.635691 * q);
+  unsigned b = 65535.0 * gammaAdjust(y + -1.108545 * i +  1.709007 * q);
 
-void Video::generate(Format format) {
-  for(unsigned n = 0; n < (1 << 9); n++) palette[n] = palette30(n, 2.0, 0.0, 1.0, 1.0, 1.8);
-
-  if(format == Format::RGB24) {
-    for(unsigned n = 0; n < (1 << 9); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 6) & 0xff0000) + ((color >> 4) & 0x00ff00) + ((color >> 2) & 0x0000ff);
-    }
-  }
-
-  if(format == Format::RGB16) {
-    for(unsigned n = 0; n < (1 << 9); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 14) & 0xf800) + ((color >> 9) & 0x07e0) + ((color >> 5) & 0x001f);
-    }
-  }
-
-  if(format == Format::RGB15) {
-    for(unsigned n = 0; n < (1 << 9); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 15) & 0x7c00) + ((color >> 10) & 0x03e0) + ((color >> 5) & 0x001f);
-    }
-  }
-}
-
-Video::Video() {
-  palette = new unsigned[1 << 9];
-}
-
-Video::~Video() {
-  delete[] palette;
+  return interface->videoColor(n, uclamp<16>(r), uclamp<16>(g), uclamp<16>(b));
 }
 
 }

bsnes/fc/video/video.hpp

@@ -0,0 +1,12 @@
+struct Video {
+  unsigned *palette;
+  void generate_palette();
+
+  Video();
+  ~Video();
+
+private:
+  uint32_t generate_color(unsigned, double, double, double, double, double);
+};
+
+extern Video video;

bsnes/gameboy/Makefile

@@ -1,18 +0,0 @@
-options += gameboy
-
-gameboy_objects := gameboy-interface gameboy-system gameboy-scheduler
-gameboy_objects += gameboy-memory gameboy-cartridge
-gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd
-gameboy_objects += gameboy-cheat gameboy-video
-objects += $(gameboy_objects)
-
-obj/gameboy-interface.o: $(gameboy)/interface/interface.cpp $(call rwildcard,$(gameboy)/interface/)
-obj/gameboy-system.o: $(gameboy)/system/system.cpp $(call rwildcard,$(gameboy)/system/)
-obj/gameboy-scheduler.o: $(gameboy)/scheduler/scheduler.cpp $(call rwildcard,$(gameboy)/scheduler/)
-obj/gameboy-cartridge.o: $(gameboy)/cartridge/cartridge.cpp $(call rwildcard,$(gameboy)/cartridge/)
-obj/gameboy-memory.o: $(gameboy)/memory/memory.cpp $(call rwildcard,$(gameboy)/memory/)
-obj/gameboy-cpu.o: $(gameboy)/cpu/cpu.cpp $(call rwildcard,$(gameboy)/cpu/)
-obj/gameboy-apu.o: $(gameboy)/apu/apu.cpp $(call rwildcard,$(gameboy)/apu/)
-obj/gameboy-lcd.o: $(gameboy)/lcd/lcd.cpp $(call rwildcard,$(gameboy)/lcd/)
-obj/gameboy-cheat.o: $(gameboy)/cheat/cheat.cpp $(call rwildcard,$(gameboy)/cheat/)
-obj/gameboy-video.o: $(gameboy)/video/video.cpp $(call rwildcard,$(gameboy)/video/)

bsnes/gameboy/cpu/core/core.hpp

@@ -1,145 +0,0 @@
-#include "registers.hpp"
-void (CPU::*opcode_table[256])();
-void (CPU::*opcode_table_cb[256])();
-void initialize_opcode_table();
-
-void op_xx();
-void op_cb();
-
-//8-bit load commands
-template<unsigned x, unsigned y> void op_ld_r_r();
-template<unsigned x> void op_ld_r_n();
-template<unsigned x> void op_ld_r_hl();
-template<unsigned x> void op_ld_hl_r();
-void op_ld_hl_n();
-template<unsigned x> void op_ld_a_rr();
-void op_ld_a_nn();
-template<unsigned x> void op_ld_rr_a();
-void op_ld_nn_a();
-void op_ld_a_ffn();
-void op_ld_ffn_a();
-void op_ld_a_ffc();
-void op_ld_ffc_a();
-void op_ldi_hl_a();
-void op_ldi_a_hl();
-void op_ldd_hl_a();
-void op_ldd_a_hl();
-
-//16-bit load commands
-template<unsigned x> void op_ld_rr_nn();
-void op_ld_nn_sp();
-void op_ld_sp_hl();
-template<unsigned x> void op_push_rr();
-template<unsigned x> void op_pop_rr();
-
-//8-bit arithmetic commands
-void opi_add_a(uint8 x);
-template<unsigned x> void op_add_a_r();
-void op_add_a_n();
-void op_add_a_hl();
-
-void opi_adc_a(uint8 x);
-template<unsigned x> void op_adc_a_r();
-void op_adc_a_n();
-void op_adc_a_hl();
-
-void opi_sub_a(uint8 x);
-template<unsigned x> void op_sub_a_r();
-void op_sub_a_n();
-void op_sub_a_hl();
-
-void opi_sbc_a(uint8 x);
-template<unsigned x> void op_sbc_a_r();
-void op_sbc_a_n();
-void op_sbc_a_hl();
-
-void opi_and_a(uint8 x);
-template<unsigned x> void op_and_a_r();
-void op_and_a_n();
-void op_and_a_hl();
-
-void opi_xor_a(uint8 x);
-template<unsigned x> void op_xor_a_r();
-void op_xor_a_n();
-void op_xor_a_hl();
-
-void opi_or_a(uint8 x);
-template<unsigned x> void op_or_a_r();
-void op_or_a_n();
-void op_or_a_hl();
-
-void opi_cp_a(uint8 x);
-template<unsigned x> void op_cp_a_r();
-void op_cp_a_n();
-void op_cp_a_hl();
-
-template<unsigned x> void op_inc_r();
-void op_inc_hl();
-template<unsigned x> void op_dec_r();
-void op_dec_hl();
-void op_daa();
-void op_cpl();
-
-//16-bit arithmetic commands
-template<unsigned x> void op_add_hl_rr();
-template<unsigned x> void op_inc_rr();
-template<unsigned x> void op_dec_rr();
-void op_add_sp_n();
-void op_ld_hl_sp_n();
-
-//rotate/shift commands
-void op_rlca();
-void op_rla();
-void op_rrca();
-void op_rra();
-template<unsigned x> void op_rlc_r();
-void op_rlc_hl();
-template<unsigned x> void op_rl_r();
-void op_rl_hl();
-template<unsigned x> void op_rrc_r();
-void op_rrc_hl();
-template<unsigned x> void op_rr_r();
-void op_rr_hl();
-template<unsigned x> void op_sla_r();
-void op_sla_hl();
-template<unsigned x> void op_swap_r();
-void op_swap_hl();
-template<unsigned x> void op_sra_r();
-void op_sra_hl();
-template<unsigned x> void op_srl_r();
-void op_srl_hl();
-
-//single-bit commands
-template<unsigned b, unsigned x> void op_bit_n_r();
-template<unsigned b> void op_bit_n_hl();
-template<unsigned b, unsigned x> void op_set_n_r();
-template<unsigned b> void op_set_n_hl();
-template<unsigned b, unsigned x> void op_res_n_r();
-template<unsigned b> void op_res_n_hl();
-
-//control commands
-void op_ccf();
-void op_scf();
-void op_nop();
-void op_halt();
-void op_stop();
-void op_di();
-void op_ei();
-
-//jump commands
-void op_jp_nn();
-void op_jp_hl();
-template<unsigned x, bool y> void op_jp_f_nn();
-void op_jr_n();
-template<unsigned x, bool y> void op_jr_f_n();
-void op_call_nn();
-template<unsigned x, bool y> void op_call_f_nn();
-void op_ret();
-template<unsigned x, bool y> void op_ret_f();
-void op_reti();
-template<unsigned n> void op_rst_n();
-
-//disassembler.cpp
-string disassemble(uint16 pc);
-string disassemble_opcode(uint16 pc);
-string disassemble_opcode_cb(uint16 pc);

bsnes/gameboy/cpu/core/table.cpp

@@ -1,519 +0,0 @@
-#ifdef CPU_CPP
-
-void CPU::initialize_opcode_table() {
-  opcode_table[0x00] = &CPU::op_nop;
-  opcode_table[0x01] = &CPU::op_ld_rr_nn<BC>;
-  opcode_table[0x02] = &CPU::op_ld_rr_a<BC>;
-  opcode_table[0x03] = &CPU::op_inc_rr<BC>;
-  opcode_table[0x04] = &CPU::op_inc_r<B>;
-  opcode_table[0x05] = &CPU::op_dec_r<B>;
-  opcode_table[0x06] = &CPU::op_ld_r_n<B>;
-  opcode_table[0x07] = &CPU::op_rlca;
-  opcode_table[0x08] = &CPU::op_ld_nn_sp;
-  opcode_table[0x09] = &CPU::op_add_hl_rr<BC>;
-  opcode_table[0x0a] = &CPU::op_ld_a_rr<BC>;
-  opcode_table[0x0b] = &CPU::op_dec_rr<BC>;
-  opcode_table[0x0c] = &CPU::op_inc_r<C>;
-  opcode_table[0x0d] = &CPU::op_dec_r<C>;
-  opcode_table[0x0e] = &CPU::op_ld_r_n<C>;
-  opcode_table[0x0f] = &CPU::op_rrca;
-  opcode_table[0x10] = &CPU::op_stop;
-  opcode_table[0x11] = &CPU::op_ld_rr_nn<DE>;
-  opcode_table[0x12] = &CPU::op_ld_rr_a<DE>;
-  opcode_table[0x13] = &CPU::op_inc_rr<DE>;
-  opcode_table[0x14] = &CPU::op_inc_r<D>;
-  opcode_table[0x15] = &CPU::op_dec_r<D>;
-  opcode_table[0x16] = &CPU::op_ld_r_n<D>;
-  opcode_table[0x17] = &CPU::op_rla;
-  opcode_table[0x18] = &CPU::op_jr_n;
-  opcode_table[0x19] = &CPU::op_add_hl_rr<DE>;
-  opcode_table[0x1a] = &CPU::op_ld_a_rr<DE>;
-  opcode_table[0x1b] = &CPU::op_dec_rr<DE>;
-  opcode_table[0x1c] = &CPU::op_inc_r<E>;
-  opcode_table[0x1d] = &CPU::op_dec_r<E>;
-  opcode_table[0x1e] = &CPU::op_ld_r_n<E>;
-  opcode_table[0x1f] = &CPU::op_rra;
-  opcode_table[0x20] = &CPU::op_jr_f_n<ZF, 0>;
-  opcode_table[0x21] = &CPU::op_ld_rr_nn<HL>;
-  opcode_table[0x22] = &CPU::op_ldi_hl_a;
-  opcode_table[0x23] = &CPU::op_inc_rr<HL>;
-  opcode_table[0x24] = &CPU::op_inc_r<H>;
-  opcode_table[0x25] = &CPU::op_dec_r<H>;
-  opcode_table[0x26] = &CPU::op_ld_r_n<H>;
-  opcode_table[0x27] = &CPU::op_daa;
-  opcode_table[0x28] = &CPU::op_jr_f_n<ZF, 1>;
-  opcode_table[0x29] = &CPU::op_add_hl_rr<HL>;
-  opcode_table[0x2a] = &CPU::op_ldi_a_hl;
-  opcode_table[0x2b] = &CPU::op_dec_rr<HL>;
-  opcode_table[0x2c] = &CPU::op_inc_r<L>;
-  opcode_table[0x2d] = &CPU::op_dec_r<L>;
-  opcode_table[0x2e] = &CPU::op_ld_r_n<L>;
-  opcode_table[0x2f] = &CPU::op_cpl;
-  opcode_table[0x30] = &CPU::op_jr_f_n<CF, 0>;
-  opcode_table[0x31] = &CPU::op_ld_rr_nn<SP>;
-  opcode_table[0x32] = &CPU::op_ldd_hl_a;
-  opcode_table[0x33] = &CPU::op_inc_rr<SP>;
-  opcode_table[0x34] = &CPU::op_inc_hl;
-  opcode_table[0x35] = &CPU::op_dec_hl;
-  opcode_table[0x36] = &CPU::op_ld_hl_n;
-  opcode_table[0x37] = &CPU::op_scf;
-  opcode_table[0x38] = &CPU::op_jr_f_n<CF, 1>;
-  opcode_table[0x39] = &CPU::op_add_hl_rr<SP>;
-  opcode_table[0x3a] = &CPU::op_ldd_a_hl;
-  opcode_table[0x3b] = &CPU::op_dec_rr<SP>;
-  opcode_table[0x3c] = &CPU::op_inc_r<A>;
-  opcode_table[0x3d] = &CPU::op_dec_r<A>;
-  opcode_table[0x3e] = &CPU::op_ld_r_n<A>;
-  opcode_table[0x3f] = &CPU::op_ccf;
-  opcode_table[0x40] = &CPU::op_ld_r_r<B, B>;
-  opcode_table[0x41] = &CPU::op_ld_r_r<B, C>;
-  opcode_table[0x42] = &CPU::op_ld_r_r<B, D>;
-  opcode_table[0x43] = &CPU::op_ld_r_r<B, E>;
-  opcode_table[0x44] = &CPU::op_ld_r_r<B, H>;
-  opcode_table[0x45] = &CPU::op_ld_r_r<B, L>;
-  opcode_table[0x46] = &CPU::op_ld_r_hl<B>;
-  opcode_table[0x47] = &CPU::op_ld_r_r<B, A>;
-  opcode_table[0x48] = &CPU::op_ld_r_r<C, B>;
-  opcode_table[0x49] = &CPU::op_ld_r_r<C, C>;
-  opcode_table[0x4a] = &CPU::op_ld_r_r<C, D>;
-  opcode_table[0x4b] = &CPU::op_ld_r_r<C, E>;
-  opcode_table[0x4c] = &CPU::op_ld_r_r<C, H>;
-  opcode_table[0x4d] = &CPU::op_ld_r_r<C, L>;
-  opcode_table[0x4e] = &CPU::op_ld_r_hl<C>;
-  opcode_table[0x4f] = &CPU::op_ld_r_r<C, A>;
-  opcode_table[0x50] = &CPU::op_ld_r_r<D, B>;
-  opcode_table[0x51] = &CPU::op_ld_r_r<D, C>;
-  opcode_table[0x52] = &CPU::op_ld_r_r<D, D>;
-  opcode_table[0x53] = &CPU::op_ld_r_r<D, E>;
-  opcode_table[0x54] = &CPU::op_ld_r_r<D, H>;
-  opcode_table[0x55] = &CPU::op_ld_r_r<D, L>;
-  opcode_table[0x56] = &CPU::op_ld_r_hl<D>;
-  opcode_table[0x57] = &CPU::op_ld_r_r<D, A>;
-  opcode_table[0x58] = &CPU::op_ld_r_r<E, B>;
-  opcode_table[0x59] = &CPU::op_ld_r_r<E, C>;
-  opcode_table[0x5a] = &CPU::op_ld_r_r<E, D>;
-  opcode_table[0x5b] = &CPU::op_ld_r_r<E, E>;
-  opcode_table[0x5c] = &CPU::op_ld_r_r<E, H>;
-  opcode_table[0x5d] = &CPU::op_ld_r_r<E, L>;
-  opcode_table[0x5e] = &CPU::op_ld_r_hl<E>;
-  opcode_table[0x5f] = &CPU::op_ld_r_r<E, A>;
-  opcode_table[0x60] = &CPU::op_ld_r_r<H, B>;
-  opcode_table[0x61] = &CPU::op_ld_r_r<H, C>;
-  opcode_table[0x62] = &CPU::op_ld_r_r<H, D>;
-  opcode_table[0x63] = &CPU::op_ld_r_r<H, E>;
-  opcode_table[0x64] = &CPU::op_ld_r_r<H, H>;
-  opcode_table[0x65] = &CPU::op_ld_r_r<H, L>;
-  opcode_table[0x66] = &CPU::op_ld_r_hl<H>;
-  opcode_table[0x67] = &CPU::op_ld_r_r<H, A>;
-  opcode_table[0x68] = &CPU::op_ld_r_r<L, B>;
-  opcode_table[0x69] = &CPU::op_ld_r_r<L, C>;
-  opcode_table[0x6a] = &CPU::op_ld_r_r<L, D>;
-  opcode_table[0x6b] = &CPU::op_ld_r_r<L, E>;
-  opcode_table[0x6c] = &CPU::op_ld_r_r<L, H>;
-  opcode_table[0x6d] = &CPU::op_ld_r_r<L, L>;
-  opcode_table[0x6e] = &CPU::op_ld_r_hl<L>;
-  opcode_table[0x6f] = &CPU::op_ld_r_r<L, A>;
-  opcode_table[0x70] = &CPU::op_ld_hl_r<B>;
-  opcode_table[0x71] = &CPU::op_ld_hl_r<C>;
-  opcode_table[0x72] = &CPU::op_ld_hl_r<D>;
-  opcode_table[0x73] = &CPU::op_ld_hl_r<E>;
-  opcode_table[0x74] = &CPU::op_ld_hl_r<H>;
-  opcode_table[0x75] = &CPU::op_ld_hl_r<L>;
-  opcode_table[0x76] = &CPU::op_halt;
-  opcode_table[0x77] = &CPU::op_ld_hl_r<A>;
-  opcode_table[0x78] = &CPU::op_ld_r_r<A, B>;
-  opcode_table[0x79] = &CPU::op_ld_r_r<A, C>;
-  opcode_table[0x7a] = &CPU::op_ld_r_r<A, D>;
-  opcode_table[0x7b] = &CPU::op_ld_r_r<A, E>;
-  opcode_table[0x7c] = &CPU::op_ld_r_r<A, H>;
-  opcode_table[0x7d] = &CPU::op_ld_r_r<A, L>;
-  opcode_table[0x7e] = &CPU::op_ld_r_hl<A>;
-  opcode_table[0x7f] = &CPU::op_ld_r_r<A, A>;
-  opcode_table[0x80] = &CPU::op_add_a_r<B>;
-  opcode_table[0x81] = &CPU::op_add_a_r<C>;
-  opcode_table[0x82] = &CPU::op_add_a_r<D>;
-  opcode_table[0x83] = &CPU::op_add_a_r<E>;
-  opcode_table[0x84] = &CPU::op_add_a_r<H>;
-  opcode_table[0x85] = &CPU::op_add_a_r<L>;
-  opcode_table[0x86] = &CPU::op_add_a_hl;
-  opcode_table[0x87] = &CPU::op_add_a_r<A>;
-  opcode_table[0x88] = &CPU::op_adc_a_r<B>;
-  opcode_table[0x89] = &CPU::op_adc_a_r<C>;
-  opcode_table[0x8a] = &CPU::op_adc_a_r<D>;
-  opcode_table[0x8b] = &CPU::op_adc_a_r<E>;
-  opcode_table[0x8c] = &CPU::op_adc_a_r<H>;
-  opcode_table[0x8d] = &CPU::op_adc_a_r<L>;
-  opcode_table[0x8e] = &CPU::op_adc_a_hl;
-  opcode_table[0x8f] = &CPU::op_adc_a_r<A>;
-  opcode_table[0x90] = &CPU::op_sub_a_r<B>;
-  opcode_table[0x91] = &CPU::op_sub_a_r<C>;
-  opcode_table[0x92] = &CPU::op_sub_a_r<D>;
-  opcode_table[0x93] = &CPU::op_sub_a_r<E>;
-  opcode_table[0x94] = &CPU::op_sub_a_r<H>;
-  opcode_table[0x95] = &CPU::op_sub_a_r<L>;
-  opcode_table[0x96] = &CPU::op_sub_a_hl;
-  opcode_table[0x97] = &CPU::op_sub_a_r<A>;
-  opcode_table[0x98] = &CPU::op_sbc_a_r<B>;
-  opcode_table[0x99] = &CPU::op_sbc_a_r<C>;
-  opcode_table[0x9a] = &CPU::op_sbc_a_r<D>;
-  opcode_table[0x9b] = &CPU::op_sbc_a_r<E>;
-  opcode_table[0x9c] = &CPU::op_sbc_a_r<H>;
-  opcode_table[0x9d] = &CPU::op_sbc_a_r<L>;
-  opcode_table[0x9e] = &CPU::op_sbc_a_hl;
-  opcode_table[0x9f] = &CPU::op_sbc_a_r<A>;
-  opcode_table[0xa0] = &CPU::op_and_a_r<B>;
-  opcode_table[0xa1] = &CPU::op_and_a_r<C>;
-  opcode_table[0xa2] = &CPU::op_and_a_r<D>;
-  opcode_table[0xa3] = &CPU::op_and_a_r<E>;
-  opcode_table[0xa4] = &CPU::op_and_a_r<H>;
-  opcode_table[0xa5] = &CPU::op_and_a_r<L>;
-  opcode_table[0xa6] = &CPU::op_and_a_hl;
-  opcode_table[0xa7] = &CPU::op_and_a_r<A>;
-  opcode_table[0xa8] = &CPU::op_xor_a_r<B>;
-  opcode_table[0xa9] = &CPU::op_xor_a_r<C>;
-  opcode_table[0xaa] = &CPU::op_xor_a_r<D>;
-  opcode_table[0xab] = &CPU::op_xor_a_r<E>;
-  opcode_table[0xac] = &CPU::op_xor_a_r<H>;
-  opcode_table[0xad] = &CPU::op_xor_a_r<L>;
-  opcode_table[0xae] = &CPU::op_xor_a_hl;
-  opcode_table[0xaf] = &CPU::op_xor_a_r<A>;
-  opcode_table[0xb0] = &CPU::op_or_a_r<B>;
-  opcode_table[0xb1] = &CPU::op_or_a_r<C>;
-  opcode_table[0xb2] = &CPU::op_or_a_r<D>;
-  opcode_table[0xb3] = &CPU::op_or_a_r<E>;
-  opcode_table[0xb4] = &CPU::op_or_a_r<H>;
-  opcode_table[0xb5] = &CPU::op_or_a_r<L>;
-  opcode_table[0xb6] = &CPU::op_or_a_hl;
-  opcode_table[0xb7] = &CPU::op_or_a_r<A>;
-  opcode_table[0xb8] = &CPU::op_cp_a_r<B>;
-  opcode_table[0xb9] = &CPU::op_cp_a_r<C>;
-  opcode_table[0xba] = &CPU::op_cp_a_r<D>;
-  opcode_table[0xbb] = &CPU::op_cp_a_r<E>;
-  opcode_table[0xbc] = &CPU::op_cp_a_r<H>;
-  opcode_table[0xbd] = &CPU::op_cp_a_r<L>;
-  opcode_table[0xbe] = &CPU::op_cp_a_hl;
-  opcode_table[0xbf] = &CPU::op_cp_a_r<A>;
-  opcode_table[0xc0] = &CPU::op_ret_f<ZF, 0>;
-  opcode_table[0xc1] = &CPU::op_pop_rr<BC>;
-  opcode_table[0xc2] = &CPU::op_jp_f_nn<ZF, 0>;
-  opcode_table[0xc3] = &CPU::op_jp_nn;
-  opcode_table[0xc4] = &CPU::op_call_f_nn<ZF, 0>;
-  opcode_table[0xc5] = &CPU::op_push_rr<BC>;
-  opcode_table[0xc6] = &CPU::op_add_a_n;
-  opcode_table[0xc7] = &CPU::op_rst_n<0x00>;
-  opcode_table[0xc8] = &CPU::op_ret_f<ZF, 1>;
-  opcode_table[0xc9] = &CPU::op_ret;
-  opcode_table[0xca] = &CPU::op_jp_f_nn<ZF, 1>;
-  opcode_table[0xcb] = &CPU::op_cb;
-  opcode_table[0xcc] = &CPU::op_call_f_nn<ZF, 1>;
-  opcode_table[0xcd] = &CPU::op_call_nn;
-  opcode_table[0xce] = &CPU::op_adc_a_n;
-  opcode_table[0xcf] = &CPU::op_rst_n<0x08>;
-  opcode_table[0xd0] = &CPU::op_ret_f<CF, 0>;
-  opcode_table[0xd1] = &CPU::op_pop_rr<DE>;
-  opcode_table[0xd2] = &CPU::op_jp_f_nn<CF, 0>;
-  opcode_table[0xd3] = &CPU::op_xx;
-  opcode_table[0xd4] = &CPU::op_call_f_nn<CF, 0>;
-  opcode_table[0xd5] = &CPU::op_push_rr<DE>;
-  opcode_table[0xd6] = &CPU::op_sub_a_n;
-  opcode_table[0xd7] = &CPU::op_rst_n<0x10>;
-  opcode_table[0xd8] = &CPU::op_ret_f<CF, 1>;
-  opcode_table[0xd9] = &CPU::op_reti;
-  opcode_table[0xda] = &CPU::op_jp_f_nn<CF, 1>;
-  opcode_table[0xdb] = &CPU::op_xx;
-  opcode_table[0xdc] = &CPU::op_call_f_nn<CF, 1>;
-  opcode_table[0xdd] = &CPU::op_xx;
-  opcode_table[0xde] = &CPU::op_sbc_a_n;
-  opcode_table[0xdf] = &CPU::op_rst_n<0x18>;
-  opcode_table[0xe0] = &CPU::op_ld_ffn_a;
-  opcode_table[0xe1] = &CPU::op_pop_rr<HL>;
-  opcode_table[0xe2] = &CPU::op_ld_ffc_a;
-  opcode_table[0xe3] = &CPU::op_xx;
-  opcode_table[0xe4] = &CPU::op_xx;
-  opcode_table[0xe5] = &CPU::op_push_rr<HL>;
-  opcode_table[0xe6] = &CPU::op_and_a_n;
-  opcode_table[0xe7] = &CPU::op_rst_n<0x20>;
-  opcode_table[0xe8] = &CPU::op_add_sp_n;
-  opcode_table[0xe9] = &CPU::op_jp_hl;
-  opcode_table[0xea] = &CPU::op_ld_nn_a;
-  opcode_table[0xeb] = &CPU::op_xx;
-  opcode_table[0xec] = &CPU::op_xx;
-  opcode_table[0xed] = &CPU::op_xx;
-  opcode_table[0xee] = &CPU::op_xor_a_n;
-  opcode_table[0xef] = &CPU::op_rst_n<0x28>;
-  opcode_table[0xf0] = &CPU::op_ld_a_ffn;
-  opcode_table[0xf1] = &CPU::op_pop_rr<AF>;
-  opcode_table[0xf2] = &CPU::op_ld_a_ffc;
-  opcode_table[0xf3] = &CPU::op_di;
-  opcode_table[0xf4] = &CPU::op_xx;
-  opcode_table[0xf5] = &CPU::op_push_rr<AF>;
-  opcode_table[0xf6] = &CPU::op_or_a_n;
-  opcode_table[0xf7] = &CPU::op_rst_n<0x30>;
-  opcode_table[0xf8] = &CPU::op_ld_hl_sp_n;
-  opcode_table[0xf9] = &CPU::op_ld_sp_hl;
-  opcode_table[0xfa] = &CPU::op_ld_a_nn;
-  opcode_table[0xfb] = &CPU::op_ei;
-  opcode_table[0xfc] = &CPU::op_xx;
-  opcode_table[0xfd] = &CPU::op_xx;
-  opcode_table[0xfe] = &CPU::op_cp_a_n;
-  opcode_table[0xff] = &CPU::op_rst_n<0x38>;
-
-  opcode_table_cb[0x00] = &CPU::op_rlc_r<B>;
-  opcode_table_cb[0x01] = &CPU::op_rlc_r<C>;
-  opcode_table_cb[0x02] = &CPU::op_rlc_r<D>;
-  opcode_table_cb[0x03] = &CPU::op_rlc_r<E>;
-  opcode_table_cb[0x04] = &CPU::op_rlc_r<H>;
-  opcode_table_cb[0x05] = &CPU::op_rlc_r<L>;
-  opcode_table_cb[0x06] = &CPU::op_rlc_hl;
-  opcode_table_cb[0x07] = &CPU::op_rlc_r<A>;
-  opcode_table_cb[0x08] = &CPU::op_rrc_r<B>;
-  opcode_table_cb[0x09] = &CPU::op_rrc_r<C>;
-  opcode_table_cb[0x0a] = &CPU::op_rrc_r<D>;
-  opcode_table_cb[0x0b] = &CPU::op_rrc_r<E>;
-  opcode_table_cb[0x0c] = &CPU::op_rrc_r<H>;
-  opcode_table_cb[0x0d] = &CPU::op_rrc_r<L>;
-  opcode_table_cb[0x0e] = &CPU::op_rrc_hl;
-  opcode_table_cb[0x0f] = &CPU::op_rrc_r<A>;
-  opcode_table_cb[0x10] = &CPU::op_rl_r<B>;
-  opcode_table_cb[0x11] = &CPU::op_rl_r<C>;
-  opcode_table_cb[0x12] = &CPU::op_rl_r<D>;
-  opcode_table_cb[0x13] = &CPU::op_rl_r<E>;
-  opcode_table_cb[0x14] = &CPU::op_rl_r<H>;
-  opcode_table_cb[0x15] = &CPU::op_rl_r<L>;
-  opcode_table_cb[0x16] = &CPU::op_rl_hl;
-  opcode_table_cb[0x17] = &CPU::op_rl_r<A>;
-  opcode_table_cb[0x18] = &CPU::op_rr_r<B>;
-  opcode_table_cb[0x19] = &CPU::op_rr_r<C>;
-  opcode_table_cb[0x1a] = &CPU::op_rr_r<D>;
-  opcode_table_cb[0x1b] = &CPU::op_rr_r<E>;
-  opcode_table_cb[0x1c] = &CPU::op_rr_r<H>;
-  opcode_table_cb[0x1d] = &CPU::op_rr_r<L>;
-  opcode_table_cb[0x1e] = &CPU::op_rr_hl;
-  opcode_table_cb[0x1f] = &CPU::op_rr_r<A>;
-  opcode_table_cb[0x20] = &CPU::op_sla_r<B>;
-  opcode_table_cb[0x21] = &CPU::op_sla_r<C>;
-  opcode_table_cb[0x22] = &CPU::op_sla_r<D>;
-  opcode_table_cb[0x23] = &CPU::op_sla_r<E>;
-  opcode_table_cb[0x24] = &CPU::op_sla_r<H>;
-  opcode_table_cb[0x25] = &CPU::op_sla_r<L>;
-  opcode_table_cb[0x26] = &CPU::op_sla_hl;
-  opcode_table_cb[0x27] = &CPU::op_sla_r<A>;
-  opcode_table_cb[0x28] = &CPU::op_sra_r<B>;
-  opcode_table_cb[0x29] = &CPU::op_sra_r<C>;
-  opcode_table_cb[0x2a] = &CPU::op_sra_r<D>;
-  opcode_table_cb[0x2b] = &CPU::op_sra_r<E>;
-  opcode_table_cb[0x2c] = &CPU::op_sra_r<H>;
-  opcode_table_cb[0x2d] = &CPU::op_sra_r<L>;
-  opcode_table_cb[0x2e] = &CPU::op_sra_hl;
-  opcode_table_cb[0x2f] = &CPU::op_sra_r<A>;
-  opcode_table_cb[0x30] = &CPU::op_swap_r<B>;
-  opcode_table_cb[0x31] = &CPU::op_swap_r<C>;
-  opcode_table_cb[0x32] = &CPU::op_swap_r<D>;
-  opcode_table_cb[0x33] = &CPU::op_swap_r<E>;
-  opcode_table_cb[0x34] = &CPU::op_swap_r<H>;
-  opcode_table_cb[0x35] = &CPU::op_swap_r<L>;
-  opcode_table_cb[0x36] = &CPU::op_swap_hl;
-  opcode_table_cb[0x37] = &CPU::op_swap_r<A>;
-  opcode_table_cb[0x38] = &CPU::op_srl_r<B>;
-  opcode_table_cb[0x39] = &CPU::op_srl_r<C>;
-  opcode_table_cb[0x3a] = &CPU::op_srl_r<D>;
-  opcode_table_cb[0x3b] = &CPU::op_srl_r<E>;
-  opcode_table_cb[0x3c] = &CPU::op_srl_r<H>;
-  opcode_table_cb[0x3d] = &CPU::op_srl_r<L>;
-  opcode_table_cb[0x3e] = &CPU::op_srl_hl;
-  opcode_table_cb[0x3f] = &CPU::op_srl_r<A>;
-  opcode_table_cb[0x40] = &CPU::op_bit_n_r<0, B>;
-  opcode_table_cb[0x41] = &CPU::op_bit_n_r<0, C>;
-  opcode_table_cb[0x42] = &CPU::op_bit_n_r<0, D>;
-  opcode_table_cb[0x43] = &CPU::op_bit_n_r<0, E>;
-  opcode_table_cb[0x44] = &CPU::op_bit_n_r<0, H>;
-  opcode_table_cb[0x45] = &CPU::op_bit_n_r<0, L>;
-  opcode_table_cb[0x46] = &CPU::op_bit_n_hl<0>;
-  opcode_table_cb[0x47] = &CPU::op_bit_n_r<0, A>;
-  opcode_table_cb[0x48] = &CPU::op_bit_n_r<1, B>;
-  opcode_table_cb[0x49] = &CPU::op_bit_n_r<1, C>;
-  opcode_table_cb[0x4a] = &CPU::op_bit_n_r<1, D>;
-  opcode_table_cb[0x4b] = &CPU::op_bit_n_r<1, E>;
-  opcode_table_cb[0x4c] = &CPU::op_bit_n_r<1, H>;
-  opcode_table_cb[0x4d] = &CPU::op_bit_n_r<1, L>;
-  opcode_table_cb[0x4e] = &CPU::op_bit_n_hl<1>;
-  opcode_table_cb[0x4f] = &CPU::op_bit_n_r<1, A>;
-  opcode_table_cb[0x50] = &CPU::op_bit_n_r<2, B>;
-  opcode_table_cb[0x51] = &CPU::op_bit_n_r<2, C>;
-  opcode_table_cb[0x52] = &CPU::op_bit_n_r<2, D>;
-  opcode_table_cb[0x53] = &CPU::op_bit_n_r<2, E>;
-  opcode_table_cb[0x54] = &CPU::op_bit_n_r<2, H>;
-  opcode_table_cb[0x55] = &CPU::op_bit_n_r<2, L>;
-  opcode_table_cb[0x56] = &CPU::op_bit_n_hl<2>;
-  opcode_table_cb[0x57] = &CPU::op_bit_n_r<2, A>;
-  opcode_table_cb[0x58] = &CPU::op_bit_n_r<3, B>;
-  opcode_table_cb[0x59] = &CPU::op_bit_n_r<3, C>;
-  opcode_table_cb[0x5a] = &CPU::op_bit_n_r<3, D>;
-  opcode_table_cb[0x5b] = &CPU::op_bit_n_r<3, E>;
-  opcode_table_cb[0x5c] = &CPU::op_bit_n_r<3, H>;
-  opcode_table_cb[0x5d] = &CPU::op_bit_n_r<3, L>;
-  opcode_table_cb[0x5e] = &CPU::op_bit_n_hl<3>;
-  opcode_table_cb[0x5f] = &CPU::op_bit_n_r<3, A>;
-  opcode_table_cb[0x60] = &CPU::op_bit_n_r<4, B>;
-  opcode_table_cb[0x61] = &CPU::op_bit_n_r<4, C>;
-  opcode_table_cb[0x62] = &CPU::op_bit_n_r<4, D>;
-  opcode_table_cb[0x63] = &CPU::op_bit_n_r<4, E>;
-  opcode_table_cb[0x64] = &CPU::op_bit_n_r<4, H>;
-  opcode_table_cb[0x65] = &CPU::op_bit_n_r<4, L>;
-  opcode_table_cb[0x66] = &CPU::op_bit_n_hl<4>;
-  opcode_table_cb[0x67] = &CPU::op_bit_n_r<4, A>;
-  opcode_table_cb[0x68] = &CPU::op_bit_n_r<5, B>;
-  opcode_table_cb[0x69] = &CPU::op_bit_n_r<5, C>;
-  opcode_table_cb[0x6a] = &CPU::op_bit_n_r<5, D>;
-  opcode_table_cb[0x6b] = &CPU::op_bit_n_r<5, E>;
-  opcode_table_cb[0x6c] = &CPU::op_bit_n_r<5, H>;
-  opcode_table_cb[0x6d] = &CPU::op_bit_n_r<5, L>;
-  opcode_table_cb[0x6e] = &CPU::op_bit_n_hl<5>;
-  opcode_table_cb[0x6f] = &CPU::op_bit_n_r<5, A>;
-  opcode_table_cb[0x70] = &CPU::op_bit_n_r<6, B>;
-  opcode_table_cb[0x71] = &CPU::op_bit_n_r<6, C>;
-  opcode_table_cb[0x72] = &CPU::op_bit_n_r<6, D>;
-  opcode_table_cb[0x73] = &CPU::op_bit_n_r<6, E>;
-  opcode_table_cb[0x74] = &CPU::op_bit_n_r<6, H>;
-  opcode_table_cb[0x75] = &CPU::op_bit_n_r<6, L>;
-  opcode_table_cb[0x76] = &CPU::op_bit_n_hl<6>;
-  opcode_table_cb[0x77] = &CPU::op_bit_n_r<6, A>;
-  opcode_table_cb[0x78] = &CPU::op_bit_n_r<7, B>;
-  opcode_table_cb[0x79] = &CPU::op_bit_n_r<7, C>;
-  opcode_table_cb[0x7a] = &CPU::op_bit_n_r<7, D>;
-  opcode_table_cb[0x7b] = &CPU::op_bit_n_r<7, E>;
-  opcode_table_cb[0x7c] = &CPU::op_bit_n_r<7, H>;
-  opcode_table_cb[0x7d] = &CPU::op_bit_n_r<7, L>;
-  opcode_table_cb[0x7e] = &CPU::op_bit_n_hl<7>;
-  opcode_table_cb[0x7f] = &CPU::op_bit_n_r<7, A>;
-  opcode_table_cb[0x80] = &CPU::op_res_n_r<0, B>;
-  opcode_table_cb[0x81] = &CPU::op_res_n_r<0, C>;
-  opcode_table_cb[0x82] = &CPU::op_res_n_r<0, D>;
-  opcode_table_cb[0x83] = &CPU::op_res_n_r<0, E>;
-  opcode_table_cb[0x84] = &CPU::op_res_n_r<0, H>;
-  opcode_table_cb[0x85] = &CPU::op_res_n_r<0, L>;
-  opcode_table_cb[0x86] = &CPU::op_res_n_hl<0>;
-  opcode_table_cb[0x87] = &CPU::op_res_n_r<0, A>;
-  opcode_table_cb[0x88] = &CPU::op_res_n_r<1, B>;
-  opcode_table_cb[0x89] = &CPU::op_res_n_r<1, C>;
-  opcode_table_cb[0x8a] = &CPU::op_res_n_r<1, D>;
-  opcode_table_cb[0x8b] = &CPU::op_res_n_r<1, E>;
-  opcode_table_cb[0x8c] = &CPU::op_res_n_r<1, H>;
-  opcode_table_cb[0x8d] = &CPU::op_res_n_r<1, L>;
-  opcode_table_cb[0x8e] = &CPU::op_res_n_hl<1>;
-  opcode_table_cb[0x8f] = &CPU::op_res_n_r<1, A>;
-  opcode_table_cb[0x90] = &CPU::op_res_n_r<2, B>;
-  opcode_table_cb[0x91] = &CPU::op_res_n_r<2, C>;
-  opcode_table_cb[0x92] = &CPU::op_res_n_r<2, D>;
-  opcode_table_cb[0x93] = &CPU::op_res_n_r<2, E>;
-  opcode_table_cb[0x94] = &CPU::op_res_n_r<2, H>;
-  opcode_table_cb[0x95] = &CPU::op_res_n_r<2, L>;
-  opcode_table_cb[0x96] = &CPU::op_res_n_hl<2>;
-  opcode_table_cb[0x97] = &CPU::op_res_n_r<2, A>;
-  opcode_table_cb[0x98] = &CPU::op_res_n_r<3, B>;
-  opcode_table_cb[0x99] = &CPU::op_res_n_r<3, C>;
-  opcode_table_cb[0x9a] = &CPU::op_res_n_r<3, D>;
-  opcode_table_cb[0x9b] = &CPU::op_res_n_r<3, E>;
-  opcode_table_cb[0x9c] = &CPU::op_res_n_r<3, H>;
-  opcode_table_cb[0x9d] = &CPU::op_res_n_r<3, L>;
-  opcode_table_cb[0x9e] = &CPU::op_res_n_hl<3>;
-  opcode_table_cb[0x9f] = &CPU::op_res_n_r<3, A>;
-  opcode_table_cb[0xa0] = &CPU::op_res_n_r<4, B>;
-  opcode_table_cb[0xa1] = &CPU::op_res_n_r<4, C>;
-  opcode_table_cb[0xa2] = &CPU::op_res_n_r<4, D>;
-  opcode_table_cb[0xa3] = &CPU::op_res_n_r<4, E>;
-  opcode_table_cb[0xa4] = &CPU::op_res_n_r<4, H>;
-  opcode_table_cb[0xa5] = &CPU::op_res_n_r<4, L>;
-  opcode_table_cb[0xa6] = &CPU::op_res_n_hl<4>;
-  opcode_table_cb[0xa7] = &CPU::op_res_n_r<4, A>;
-  opcode_table_cb[0xa8] = &CPU::op_res_n_r<5, B>;
-  opcode_table_cb[0xa9] = &CPU::op_res_n_r<5, C>;
-  opcode_table_cb[0xaa] = &CPU::op_res_n_r<5, D>;
-  opcode_table_cb[0xab] = &CPU::op_res_n_r<5, E>;
-  opcode_table_cb[0xac] = &CPU::op_res_n_r<5, H>;
-  opcode_table_cb[0xad] = &CPU::op_res_n_r<5, L>;
-  opcode_table_cb[0xae] = &CPU::op_res_n_hl<5>;
-  opcode_table_cb[0xaf] = &CPU::op_res_n_r<5, A>;
-  opcode_table_cb[0xb0] = &CPU::op_res_n_r<6, B>;
-  opcode_table_cb[0xb1] = &CPU::op_res_n_r<6, C>;
-  opcode_table_cb[0xb2] = &CPU::op_res_n_r<6, D>;
-  opcode_table_cb[0xb3] = &CPU::op_res_n_r<6, E>;
-  opcode_table_cb[0xb4] = &CPU::op_res_n_r<6, H>;
-  opcode_table_cb[0xb5] = &CPU::op_res_n_r<6, L>;
-  opcode_table_cb[0xb6] = &CPU::op_res_n_hl<6>;
-  opcode_table_cb[0xb7] = &CPU::op_res_n_r<6, A>;
-  opcode_table_cb[0xb8] = &CPU::op_res_n_r<7, B>;
-  opcode_table_cb[0xb9] = &CPU::op_res_n_r<7, C>;
-  opcode_table_cb[0xba] = &CPU::op_res_n_r<7, D>;
-  opcode_table_cb[0xbb] = &CPU::op_res_n_r<7, E>;
-  opcode_table_cb[0xbc] = &CPU::op_res_n_r<7, H>;
-  opcode_table_cb[0xbd] = &CPU::op_res_n_r<7, L>;
-  opcode_table_cb[0xbe] = &CPU::op_res_n_hl<7>;
-  opcode_table_cb[0xbf] = &CPU::op_res_n_r<7, A>;
-  opcode_table_cb[0xc0] = &CPU::op_set_n_r<0, B>;
-  opcode_table_cb[0xc1] = &CPU::op_set_n_r<0, C>;
-  opcode_table_cb[0xc2] = &CPU::op_set_n_r<0, D>;
-  opcode_table_cb[0xc3] = &CPU::op_set_n_r<0, E>;
-  opcode_table_cb[0xc4] = &CPU::op_set_n_r<0, H>;
-  opcode_table_cb[0xc5] = &CPU::op_set_n_r<0, L>;
-  opcode_table_cb[0xc6] = &CPU::op_set_n_hl<0>;
-  opcode_table_cb[0xc7] = &CPU::op_set_n_r<0, A>;
-  opcode_table_cb[0xc8] = &CPU::op_set_n_r<1, B>;
-  opcode_table_cb[0xc9] = &CPU::op_set_n_r<1, C>;
-  opcode_table_cb[0xca] = &CPU::op_set_n_r<1, D>;
-  opcode_table_cb[0xcb] = &CPU::op_set_n_r<1, E>;
-  opcode_table_cb[0xcc] = &CPU::op_set_n_r<1, H>;
-  opcode_table_cb[0xcd] = &CPU::op_set_n_r<1, L>;
-  opcode_table_cb[0xce] = &CPU::op_set_n_hl<1>;
-  opcode_table_cb[0xcf] = &CPU::op_set_n_r<1, A>;
-  opcode_table_cb[0xd0] = &CPU::op_set_n_r<2, B>;
-  opcode_table_cb[0xd1] = &CPU::op_set_n_r<2, C>;
-  opcode_table_cb[0xd2] = &CPU::op_set_n_r<2, D>;
-  opcode_table_cb[0xd3] = &CPU::op_set_n_r<2, E>;
-  opcode_table_cb[0xd4] = &CPU::op_set_n_r<2, H>;
-  opcode_table_cb[0xd5] = &CPU::op_set_n_r<2, L>;
-  opcode_table_cb[0xd6] = &CPU::op_set_n_hl<2>;
-  opcode_table_cb[0xd7] = &CPU::op_set_n_r<2, A>;
-  opcode_table_cb[0xd8] = &CPU::op_set_n_r<3, B>;
-  opcode_table_cb[0xd9] = &CPU::op_set_n_r<3, C>;
-  opcode_table_cb[0xda] = &CPU::op_set_n_r<3, D>;
-  opcode_table_cb[0xdb] = &CPU::op_set_n_r<3, E>;
-  opcode_table_cb[0xdc] = &CPU::op_set_n_r<3, H>;
-  opcode_table_cb[0xdd] = &CPU::op_set_n_r<3, L>;
-  opcode_table_cb[0xde] = &CPU::op_set_n_hl<3>;
-  opcode_table_cb[0xdf] = &CPU::op_set_n_r<3, A>;
-  opcode_table_cb[0xe0] = &CPU::op_set_n_r<4, B>;
-  opcode_table_cb[0xe1] = &CPU::op_set_n_r<4, C>;
-  opcode_table_cb[0xe2] = &CPU::op_set_n_r<4, D>;
-  opcode_table_cb[0xe3] = &CPU::op_set_n_r<4, E>;
-  opcode_table_cb[0xe4] = &CPU::op_set_n_r<4, H>;
-  opcode_table_cb[0xe5] = &CPU::op_set_n_r<4, L>;
-  opcode_table_cb[0xe6] = &CPU::op_set_n_hl<4>;
-  opcode_table_cb[0xe7] = &CPU::op_set_n_r<4, A>;
-  opcode_table_cb[0xe8] = &CPU::op_set_n_r<5, B>;
-  opcode_table_cb[0xe9] = &CPU::op_set_n_r<5, C>;
-  opcode_table_cb[0xea] = &CPU::op_set_n_r<5, D>;
-  opcode_table_cb[0xeb] = &CPU::op_set_n_r<5, E>;
-  opcode_table_cb[0xec] = &CPU::op_set_n_r<5, H>;
-  opcode_table_cb[0xed] = &CPU::op_set_n_r<5, L>;
-  opcode_table_cb[0xee] = &CPU::op_set_n_hl<5>;
-  opcode_table_cb[0xef] = &CPU::op_set_n_r<5, A>;
-  opcode_table_cb[0xf0] = &CPU::op_set_n_r<6, B>;
-  opcode_table_cb[0xf1] = &CPU::op_set_n_r<6, C>;
-  opcode_table_cb[0xf2] = &CPU::op_set_n_r<6, D>;
-  opcode_table_cb[0xf3] = &CPU::op_set_n_r<6, E>;
-  opcode_table_cb[0xf4] = &CPU::op_set_n_r<6, H>;
-  opcode_table_cb[0xf5] = &CPU::op_set_n_r<6, L>;
-  opcode_table_cb[0xf6] = &CPU::op_set_n_hl<6>;
-  opcode_table_cb[0xf7] = &CPU::op_set_n_r<6, A>;
-  opcode_table_cb[0xf8] = &CPU::op_set_n_r<7, B>;
-  opcode_table_cb[0xf9] = &CPU::op_set_n_r<7, C>;
-  opcode_table_cb[0xfa] = &CPU::op_set_n_r<7, D>;
-  opcode_table_cb[0xfb] = &CPU::op_set_n_r<7, E>;
-  opcode_table_cb[0xfc] = &CPU::op_set_n_r<7, H>;
-  opcode_table_cb[0xfd] = &CPU::op_set_n_r<7, L>;
-  opcode_table_cb[0xfe] = &CPU::op_set_n_hl<7>;
-  opcode_table_cb[0xff] = &CPU::op_set_n_r<7, A>;
-}
-
-#endif

bsnes/gameboy/cpu/mmio/mmio.hpp

@@ -1,4 +0,0 @@
-unsigned wram_addr(uint16 addr) const;
-void mmio_joyp_poll();
-uint8 mmio_read(uint16 addr);
-void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cpu/timing/timing.hpp

@@ -1,13 +0,0 @@
-void add_clocks(unsigned clocks);
-void timer_262144hz();
-void timer_65536hz();
-void timer_16384hz();
-void timer_8192hz();
-void timer_4096hz();
-void hblank();
-
-//opcode.cpp
-void op_io();
-uint8 op_read(uint16 addr);
-void op_write(uint16 addr, uint8 data);
-void cycle_edge();

bsnes/gameboy/gameboy.hpp

@@ -1,60 +0,0 @@
-#ifndef GAMEBOY_HPP
-#define GAMEBOY_HPP
-
-#include <base/base.hpp>
-
-namespace GameBoy {
-  namespace Info {
-    static const char Name[] = "bgameboy";
-    static const unsigned SerializerVersion = 3;
-  }
-}
-
-/*
-  bgameboy - Game Boy, Super Game Boy, and Game Boy Color emulator
-  author: byuu
-  license: GPLv3
-  project started: 2010-12-27
-*/
-
-#include <libco/libco.h>
-#include <nall/gameboy/cartridge.hpp>
-
-namespace GameBoy {
-  struct Processor {
-    cothread_t thread;
-    unsigned frequency;
-    int64 clock;
-
-    inline void create(void (*entrypoint)(), unsigned frequency) {
-      if(thread) co_delete(thread);
-      thread = co_create(65536 * sizeof(void*), entrypoint);
-      this->frequency = frequency;
-      clock = 0;
-    }
-
-    inline void serialize(serializer &s) {
-      s.integer(frequency);
-      s.integer(clock);
-    }
-
-    inline Processor() : thread(nullptr) {
-    }
-
-    inline ~Processor() {
-      if(thread) co_delete(thread);
-    }
-  };
-
-  #include <gameboy/memory/memory.hpp>
-  #include <gameboy/system/system.hpp>
-  #include <gameboy/scheduler/scheduler.hpp>
-  #include <gameboy/cartridge/cartridge.hpp>
-  #include <gameboy/cpu/cpu.hpp>
-  #include <gameboy/apu/apu.hpp>
-  #include <gameboy/lcd/lcd.hpp>
-  #include <gameboy/cheat/cheat.hpp>
-  #include <gameboy/video/video.hpp>
-};
-
-#endif

bsnes/gameboy/interface/interface.cpp

@@ -1,27 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-namespace GameBoy {
-
-Interface *interface = nullptr;
-
-void Interface::lcdScanline() {
-}
-
-void Interface::joypWrite(bool p15, bool p14) {
-}
-
-void Interface::videoRefresh(const uint16_t *data) {
-}
-
-void Interface::audioSample(int16_t center, int16_t left, int16_t right) {
-}
-
-bool Interface::inputPoll(unsigned id) {
-  return false;
-}
-
-void Interface::message(const string &text) {
-  print(text, "\n");
-}
-
-}

bsnes/gameboy/interface/interface.hpp

@@ -1,12 +0,0 @@
-struct Interface {
-  virtual void lcdScanline();
-  virtual void joypWrite(bool p15, bool p14);
-
-  virtual void videoRefresh(const uint16_t *data);
-  virtual void audioSample(int16_t center, int16_t left, int16_t right);
-  virtual bool inputPoll(unsigned id);
-
-  virtual void message(const string &text);
-};
-
-extern Interface *interface;

bsnes/gameboy/lcd/mmio/mmio.hpp

@@ -1,3 +0,0 @@
-unsigned vram_addr(uint16 addr) const;
-uint8 mmio_read(uint16 addr);
-void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/system/bootrom-cgb.cpp

@@ -1,135 +0,0 @@
-#ifdef SYSTEM_CPP
-
-//SHA256 = 4bf5021be357ce523a59ac5f4efff5d6371ae50112a6db0adf4a75916ad760a9
-const uint8_t System::BootROM::cgb[2048] = {
-  0x31,0xfe,0xff,0x3e,0x02,0xc3,0x7c,0x00,0xd3,0x00,0x98,0xa0,0x12,0xd3,0x00,0x80,
-  0x00,0x40,0x1e,0x53,0xd0,0x00,0x1f,0x42,0x1c,0x00,0x14,0x2a,0x4d,0x19,0x8c,0x7e,
-  0x00,0x7c,0x31,0x6e,0x4a,0x45,0x52,0x4a,0x00,0x00,0xff,0x53,0x1f,0x7c,0xff,0x03,
-  0x1f,0x00,0xff,0x1f,0xa7,0x00,0xef,0x1b,0x1f,0x00,0xef,0x1b,0x00,0x7c,0x00,0x00,
-  0xff,0x03,0xce,0xed,0x66,0x66,0xcc,0x0d,0x00,0x0b,0x03,0x73,0x00,0x83,0x00,0x0c,
-  0x00,0x0d,0x00,0x08,0x11,0x1f,0x88,0x89,0x00,0x0e,0xdc,0xcc,0x6e,0xe6,0xdd,0xdd,
-  0xd9,0x99,0xbb,0xbb,0x67,0x63,0x6e,0x0e,0xec,0xcc,0xdd,0xdc,0x99,0x9f,0xbb,0xb9,
-  0x33,0x3e,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,0x58,0x43,0xe0,0x70,0x3e,0xfc,
-  0xe0,0x47,0xcd,0x75,0x02,0xcd,0x00,0x02,0x26,0xd0,0xcd,0x03,0x02,0x21,0x00,0xfe,
-  0x0e,0xa0,0xaf,0x22,0x0d,0x20,0xfc,0x11,0x04,0x01,0x21,0x10,0x80,0x4c,0x1a,0xe2,
-  0x0c,0xcd,0xc6,0x03,0xcd,0xc7,0x03,0x13,0x7b,0xfe,0x34,0x20,0xf1,0x11,0x72,0x00,
-  0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,0xcd,0xf0,0x03,0x3e,0x01,0xe0,0x4f,
-  0x3e,0x91,0xe0,0x40,0x21,0xb2,0x98,0x06,0x4e,0x0e,0x44,0xcd,0x91,0x02,0xaf,0xe0,
-  0x4f,0x0e,0x80,0x21,0x42,0x00,0x06,0x18,0xf2,0x0c,0xbe,0x20,0xfe,0x23,0x05,0x20,
-  0xf7,0x21,0x34,0x01,0x06,0x19,0x78,0x86,0x2c,0x05,0x20,0xfb,0x86,0x20,0xfe,0xcd,
-  0x1c,0x03,0x18,0x02,0x00,0x00,0xcd,0xd0,0x05,0xaf,0xe0,0x70,0x3e,0x11,0xe0,0x50,
-  0x21,0x00,0x80,0xaf,0x22,0xcb,0x6c,0x28,0xfb,0xc9,0x2a,0x12,0x13,0x0d,0x20,0xfa,
-  0xc9,0xe5,0x21,0x0f,0xff,0xcb,0x86,0xcb,0x46,0x28,0xfc,0xe1,0xc9,0x11,0x00,0xff,
-  0x21,0x03,0xd0,0x0e,0x0f,0x3e,0x30,0x12,0x3e,0x20,0x12,0x1a,0x2f,0xa1,0xcb,0x37,
-  0x47,0x3e,0x10,0x12,0x1a,0x2f,0xa1,0xb0,0x4f,0x7e,0xa9,0xe6,0xf0,0x47,0x2a,0xa9,
-  0xa1,0xb0,0x32,0x47,0x79,0x77,0x3e,0x30,0x12,0xc9,0x3e,0x80,0xe0,0x68,0xe0,0x6a,
-  0x0e,0x6b,0x2a,0xe2,0x05,0x20,0xfb,0x4a,0x09,0x43,0x0e,0x69,0x2a,0xe2,0x05,0x20,
-  0xfb,0xc9,0xc5,0xd5,0xe5,0x21,0x00,0xd8,0x06,0x01,0x16,0x3f,0x1e,0x40,0xcd,0x4a,
-  0x02,0xe1,0xd1,0xc1,0xc9,0x3e,0x80,0xe0,0x26,0xe0,0x11,0x3e,0xf3,0xe0,0x12,0xe0,
-  0x25,0x3e,0x77,0xe0,0x24,0x21,0x30,0xff,0xaf,0x0e,0x10,0x22,0x2f,0x0d,0x20,0xfb,
-  0xc9,0xcd,0x11,0x02,0xcd,0x62,0x02,0x79,0xfe,0x38,0x20,0x14,0xe5,0xaf,0xe0,0x4f,
-  0x21,0xa7,0x99,0x3e,0x38,0x22,0x3c,0xfe,0x3f,0x20,0xfa,0x3e,0x01,0xe0,0x4f,0xe1,
-  0xc5,0xe5,0x21,0x43,0x01,0xcb,0x7e,0xcc,0x89,0x05,0xe1,0xc1,0xcd,0x11,0x02,0x79,
-  0xd6,0x30,0xd2,0x06,0x03,0x79,0xfe,0x01,0xca,0x06,0x03,0x7d,0xfe,0xd1,0x28,0x21,
-  0xc5,0x06,0x03,0x0e,0x01,0x16,0x03,0x7e,0xe6,0xf8,0xb1,0x22,0x15,0x20,0xf8,0x0c,
-  0x79,0xfe,0x06,0x20,0xf0,0x11,0x11,0x00,0x19,0x05,0x20,0xe7,0x11,0xa1,0xff,0x19,
-  0xc1,0x04,0x78,0x1e,0x83,0xfe,0x62,0x28,0x06,0x1e,0xc1,0xfe,0x64,0x20,0x07,0x7b,
-  0xe0,0x13,0x3e,0x87,0xe0,0x14,0xfa,0x02,0xd0,0xfe,0x00,0x28,0x0a,0x3d,0xea,0x02,
-  0xd0,0x79,0xfe,0x01,0xca,0x91,0x02,0x0d,0xc2,0x91,0x02,0xc9,0x0e,0x26,0xcd,0x4a,
-  0x03,0xcd,0x11,0x02,0xcd,0x62,0x02,0x0d,0x20,0xf4,0xcd,0x11,0x02,0x3e,0x01,0xe0,
-  0x4f,0xcd,0x3e,0x03,0xcd,0x41,0x03,0xaf,0xe0,0x4f,0xcd,0x3e,0x03,0xc9,0x21,0x08,
-  0x00,0x11,0x51,0xff,0x0e,0x05,0xcd,0x0a,0x02,0xc9,0xc5,0xd5,0xe5,0x21,0x40,0xd8,
-  0x0e,0x20,0x7e,0xe6,0x1f,0xfe,0x1f,0x28,0x01,0x3c,0x57,0x2a,0x07,0x07,0x07,0xe6,
-  0x07,0x47,0x3a,0x07,0x07,0x07,0xe6,0x18,0xb0,0xfe,0x1f,0x28,0x01,0x3c,0x0f,0x0f,
-  0x0f,0x47,0xe6,0xe0,0xb2,0x22,0x78,0xe6,0x03,0x5f,0x7e,0x0f,0x0f,0xe6,0x1f,0xfe,
-  0x1f,0x28,0x01,0x3c,0x07,0x07,0xb3,0x22,0x0d,0x20,0xc7,0xe1,0xd1,0xc1,0xc9,0x0e,
-  0x00,0x1a,0xe6,0xf0,0xcb,0x49,0x28,0x02,0xcb,0x37,0x47,0x23,0x7e,0xb0,0x22,0x1a,
-  0xe6,0x0f,0xcb,0x49,0x20,0x02,0xcb,0x37,0x47,0x23,0x7e,0xb0,0x22,0x13,0xcb,0x41,
-  0x28,0x0d,0xd5,0x11,0xf8,0xff,0xcb,0x49,0x28,0x03,0x11,0x08,0x00,0x19,0xd1,0x0c,
-  0x79,0xfe,0x18,0x20,0xcc,0xc9,0x47,0xd5,0x16,0x04,0x58,0xcb,0x10,0x17,0xcb,0x13,
-  0x17,0x15,0x20,0xf6,0xd1,0x22,0x23,0x22,0x23,0xc9,0x3e,0x19,0xea,0x10,0x99,0x21,
-  0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,0xf9,0x2e,0x0f,0x18,0xf3,0xc9,
-  0x3e,0x01,0xe0,0x4f,0xcd,0x00,0x02,0x11,0x07,0x06,0x21,0x80,0x80,0x0e,0xc0,0x1a,
-  0x22,0x23,0x22,0x23,0x13,0x0d,0x20,0xf7,0x11,0x04,0x01,0xcd,0x8f,0x03,0x01,0xa8,
-  0xff,0x09,0xcd,0x8f,0x03,0x01,0xf8,0xff,0x09,0x11,0x72,0x00,0x0e,0x08,0x23,0x1a,
-  0x22,0x13,0x0d,0x20,0xf9,0x21,0xc2,0x98,0x06,0x08,0x3e,0x08,0x0e,0x10,0x22,0x0d,
-  0x20,0xfc,0x11,0x10,0x00,0x19,0x05,0x20,0xf3,0xaf,0xe0,0x4f,0x21,0xc2,0x98,0x3e,
-  0x08,0x22,0x3c,0xfe,0x18,0x20,0x02,0x2e,0xe2,0xfe,0x28,0x20,0x03,0x21,0x02,0x99,
-  0xfe,0x38,0x20,0xed,0x21,0xd8,0x08,0x11,0x40,0xd8,0x06,0x08,0x3e,0xff,0x12,0x13,
-  0x12,0x13,0x0e,0x02,0xcd,0x0a,0x02,0x3e,0x00,0x12,0x13,0x12,0x13,0x13,0x13,0x05,
-  0x20,0xea,0xcd,0x62,0x02,0x21,0x4b,0x01,0x7e,0xfe,0x33,0x20,0x0b,0x2e,0x44,0x1e,
-  0x30,0x2a,0xbb,0x20,0x49,0x1c,0x18,0x04,0x2e,0x4b,0x1e,0x01,0x2a,0xbb,0x20,0x3e,
-  0x2e,0x34,0x01,0x10,0x00,0x2a,0x80,0x47,0x0d,0x20,0xfa,0xea,0x00,0xd0,0x21,0xc7,
-  0x06,0x0e,0x00,0x2a,0xb8,0x28,0x08,0x0c,0x79,0xfe,0x4f,0x20,0xf6,0x18,0x1f,0x79,
-  0xd6,0x41,0x38,0x1c,0x21,0x16,0x07,0x16,0x00,0x5f,0x19,0xfa,0x37,0x01,0x57,0x7e,
-  0xba,0x28,0x0d,0x11,0x0e,0x00,0x19,0x79,0x83,0x4f,0xd6,0x5e,0x38,0xed,0x0e,0x00,
-  0x21,0x33,0x07,0x06,0x00,0x09,0x7e,0xe6,0x1f,0xea,0x08,0xd0,0x7e,0xe6,0xe0,0x07,
-  0x07,0x07,0xea,0x0b,0xd0,0xcd,0xe9,0x04,0xc9,0x11,0x91,0x07,0x21,0x00,0xd9,0xfa,
-  0x0b,0xd0,0x47,0x0e,0x1e,0xcb,0x40,0x20,0x02,0x13,0x13,0x1a,0x22,0x20,0x02,0x1b,
-  0x1b,0xcb,0x48,0x20,0x02,0x13,0x13,0x1a,0x22,0x13,0x13,0x20,0x02,0x1b,0x1b,0xcb,
-  0x50,0x28,0x05,0x1b,0x2b,0x1a,0x22,0x13,0x1a,0x22,0x13,0x0d,0x20,0xd7,0x21,0x00,
-  0xd9,0x11,0x00,0xda,0xcd,0x64,0x05,0xc9,0x21,0x12,0x00,0xfa,0x05,0xd0,0x07,0x07,
-  0x06,0x00,0x4f,0x09,0x11,0x40,0xd8,0x06,0x08,0xe5,0x0e,0x02,0xcd,0x0a,0x02,0x13,
-  0x13,0x13,0x13,0x13,0x13,0xe1,0x05,0x20,0xf0,0x11,0x42,0xd8,0x0e,0x02,0xcd,0x0a,
-  0x02,0x11,0x4a,0xd8,0x0e,0x02,0xcd,0x0a,0x02,0x2b,0x2b,0x11,0x44,0xd8,0x0e,0x02,
-  0xcd,0x0a,0x02,0xc9,0x0e,0x60,0x2a,0xe5,0xc5,0x21,0xe8,0x07,0x06,0x00,0x4f,0x09,
-  0x0e,0x08,0xcd,0x0a,0x02,0xc1,0xe1,0x0d,0x20,0xec,0xc9,0xfa,0x08,0xd0,0x11,0x18,
-  0x00,0x3c,0x3d,0x28,0x03,0x19,0x20,0xfa,0xc9,0xcd,0x1d,0x02,0x78,0xe6,0xff,0x28,
-  0x0f,0x21,0xe4,0x08,0x06,0x00,0x2a,0xb9,0x28,0x08,0x04,0x78,0xfe,0x0c,0x20,0xf6,
-  0x18,0x2d,0x78,0xea,0x05,0xd0,0x3e,0x1e,0xea,0x02,0xd0,0x11,0x0b,0x00,0x19,0x56,
-  0x7a,0xe6,0x1f,0x5f,0x21,0x08,0xd0,0x3a,0x22,0x7b,0x77,0x7a,0xe6,0xe0,0x07,0x07,
-  0x07,0x5f,0x21,0x0b,0xd0,0x3a,0x22,0x7b,0x77,0xcd,0xe9,0x04,0xcd,0x28,0x05,0xc9,
-  0xcd,0x11,0x02,0xfa,0x43,0x01,0xcb,0x7f,0x28,0x04,0xe0,0x4c,0x18,0x28,0x3e,0x04,
-  0xe0,0x4c,0x3e,0x01,0xe0,0x6c,0x21,0x00,0xda,0xcd,0x7b,0x05,0x06,0x10,0x16,0x00,
-  0x1e,0x08,0xcd,0x4a,0x02,0x21,0x7a,0x00,0xfa,0x00,0xd0,0x47,0x0e,0x02,0x2a,0xb8,
-  0xcc,0xda,0x03,0x0d,0x20,0xf8,0xc9,0x01,0x0f,0x3f,0x7e,0xff,0xff,0xc0,0x00,0xc0,
-  0xf0,0xf1,0x03,0x7c,0xfc,0xfe,0xfe,0x03,0x07,0x07,0x0f,0xe0,0xe0,0xf0,0xf0,0x1e,
-  0x3e,0x7e,0xfe,0x0f,0x0f,0x1f,0x1f,0xff,0xff,0x00,0x00,0x01,0x01,0x01,0x03,0xff,
-  0xff,0xe1,0xe0,0xc0,0xf0,0xf9,0xfb,0x1f,0x7f,0xf8,0xe0,0xf3,0xfd,0x3e,0x1e,0xe0,
-  0xf0,0xf9,0x7f,0x3e,0x7c,0xf8,0xe0,0xf8,0xf0,0xf0,0xf8,0x00,0x00,0x7f,0x7f,0x07,
-  0x0f,0x9f,0xbf,0x9e,0x1f,0xff,0xff,0x0f,0x1e,0x3e,0x3c,0xf1,0xfb,0x7f,0x7f,0xfe,
-  0xde,0xdf,0x9f,0x1f,0x3f,0x3e,0x3c,0xf8,0xf8,0x00,0x00,0x03,0x03,0x07,0x07,0xff,
-  0xff,0xc1,0xc0,0xf3,0xe7,0xf7,0xf3,0xc0,0xc0,0xc0,0xc0,0x1f,0x1f,0x1e,0x3e,0x3f,
-  0x1f,0x3e,0x3e,0x80,0x00,0x00,0x00,0x7c,0x1f,0x07,0x00,0x0f,0xff,0xfe,0x00,0x7c,
-  0xf8,0xf0,0x00,0x1f,0x0f,0x0f,0x00,0x7c,0xf8,0xf8,0x00,0x3f,0x3e,0x1c,0x00,0x0f,
-  0x0f,0x0f,0x00,0x7c,0xff,0xff,0x00,0x00,0xf8,0xf8,0x00,0x07,0x0f,0x0f,0x00,0x81,
-  0xff,0xff,0x00,0xf3,0xe1,0x80,0x00,0xe0,0xff,0x7f,0x00,0xfc,0xf0,0xc0,0x00,0x3e,
-  0x7c,0x7c,0x00,0x00,0x00,0x00,0x00,0x00,0x88,0x16,0x36,0xd1,0xdb,0xf2,0x3c,0x8c,
-  0x92,0x3d,0x5c,0x58,0xc9,0x3e,0x70,0x1d,0x59,0x69,0x19,0x35,0xa8,0x14,0xaa,0x75,
-  0x95,0x99,0x34,0x6f,0x15,0xff,0x97,0x4b,0x90,0x17,0x10,0x39,0xf7,0xf6,0xa2,0x49,
-  0x4e,0x43,0x68,0xe0,0x8b,0xf0,0xce,0x0c,0x29,0xe8,0xb7,0x86,0x9a,0x52,0x01,0x9d,
-  0x71,0x9c,0xbd,0x5d,0x6d,0x67,0x3f,0x6b,0xb3,0x46,0x28,0xa5,0xc6,0xd3,0x27,0x61,
-  0x18,0x66,0x6a,0xbf,0x0d,0xf4,0x42,0x45,0x46,0x41,0x41,0x52,0x42,0x45,0x4b,0x45,
-  0x4b,0x20,0x52,0x2d,0x55,0x52,0x41,0x52,0x20,0x49,0x4e,0x41,0x49,0x4c,0x49,0x43,
-  0x45,0x20,0x52,0x7c,0x08,0x12,0xa3,0xa2,0x07,0x87,0x4b,0x20,0x12,0x65,0xa8,0x16,
-  0xa9,0x86,0xb1,0x68,0xa0,0x87,0x66,0x12,0xa1,0x30,0x3c,0x12,0x85,0x12,0x64,0x1b,
-  0x07,0x06,0x6f,0x6e,0x6e,0xae,0xaf,0x6f,0xb2,0xaf,0xb2,0xa8,0xab,0x6f,0xaf,0x86,
-  0xae,0xa2,0xa2,0x12,0xaf,0x13,0x12,0xa1,0x6e,0xaf,0xaf,0xad,0x06,0x4c,0x6e,0xaf,
-  0xaf,0x12,0x7c,0xac,0xa8,0x6a,0x6e,0x13,0xa0,0x2d,0xa8,0x2b,0xac,0x64,0xac,0x6d,
-  0x87,0xbc,0x60,0xb4,0x13,0x72,0x7c,0xb5,0xae,0xae,0x7c,0x7c,0x65,0xa2,0x6c,0x64,
-  0x85,0x80,0xb0,0x40,0x88,0x20,0x68,0xde,0x00,0x70,0xde,0x20,0x78,0x20,0x20,0x38,
-  0x20,0xb0,0x90,0x20,0xb0,0xa0,0xe0,0xb0,0xc0,0x98,0xb6,0x48,0x80,0xe0,0x50,0x1e,
-  0x1e,0x58,0x20,0xb8,0xe0,0x88,0xb0,0x10,0x20,0x00,0x10,0x20,0xe0,0x18,0xe0,0x18,
-  0x00,0x18,0xe0,0x20,0xa8,0xe0,0x20,0x18,0xe0,0x00,0x20,0x18,0xd8,0xc8,0x18,0xe0,
-  0x00,0xe0,0x40,0x28,0x28,0x28,0x18,0xe0,0x60,0x20,0x18,0xe0,0x00,0x00,0x08,0xe0,
-  0x18,0x30,0xd0,0xd0,0xd0,0x20,0xe0,0xe8,0xff,0x7f,0xbf,0x32,0xd0,0x00,0x00,0x00,
-  0x9f,0x63,0x79,0x42,0xb0,0x15,0xcb,0x04,0xff,0x7f,0x31,0x6e,0x4a,0x45,0x00,0x00,
-  0xff,0x7f,0xef,0x1b,0x00,0x02,0x00,0x00,0xff,0x7f,0x1f,0x42,0xf2,0x1c,0x00,0x00,
-  0xff,0x7f,0x94,0x52,0x4a,0x29,0x00,0x00,0xff,0x7f,0xff,0x03,0x2f,0x01,0x00,0x00,
-  0xff,0x7f,0xef,0x03,0xd6,0x01,0x00,0x00,0xff,0x7f,0xb5,0x42,0xc8,0x3d,0x00,0x00,
-  0x74,0x7e,0xff,0x03,0x80,0x01,0x00,0x00,0xff,0x67,0xac,0x77,0x13,0x1a,0x6b,0x2d,
-  0xd6,0x7e,0xff,0x4b,0x75,0x21,0x00,0x00,0xff,0x53,0x5f,0x4a,0x52,0x7e,0x00,0x00,
-  0xff,0x4f,0xd2,0x7e,0x4c,0x3a,0xe0,0x1c,0xed,0x03,0xff,0x7f,0x5f,0x25,0x00,0x00,
-  0x6a,0x03,0x1f,0x02,0xff,0x03,0xff,0x7f,0xff,0x7f,0xdf,0x01,0x12,0x01,0x00,0x00,
-  0x1f,0x23,0x5f,0x03,0xf2,0x00,0x09,0x00,0xff,0x7f,0xea,0x03,0x1f,0x01,0x00,0x00,
-  0x9f,0x29,0x1a,0x00,0x0c,0x00,0x00,0x00,0xff,0x7f,0x7f,0x02,0x1f,0x00,0x00,0x00,
-  0xff,0x7f,0xe0,0x03,0x06,0x02,0x20,0x01,0xff,0x7f,0xeb,0x7e,0x1f,0x00,0x00,0x7c,
-  0xff,0x7f,0xff,0x3f,0x00,0x7e,0x1f,0x00,0xff,0x7f,0xff,0x03,0x1f,0x00,0x00,0x00,
-  0xff,0x03,0x1f,0x00,0x0c,0x00,0x00,0x00,0xff,0x7f,0x3f,0x03,0x93,0x01,0x00,0x00,
-  0x00,0x00,0x00,0x42,0x7f,0x03,0xff,0x7f,0xff,0x7f,0x8c,0x7e,0x00,0x7c,0x00,0x00,
-  0xff,0x7f,0xef,0x1b,0x80,0x61,0x00,0x00,0xff,0x7f,0x00,0x7c,0xe0,0x03,0x1f,0x7c,
-  0x1f,0x00,0xff,0x03,0x40,0x41,0x42,0x20,0x21,0x22,0x80,0x81,0x82,0x10,0x11,0x12,
-  0x12,0xb0,0x79,0xb8,0xad,0x16,0x17,0x07,0xba,0x05,0x7c,0x13,0x00,0x00,0x00,0x00,
-};
-
-#endif

bsnes/gameboy/system/bootrom-dmg.cpp

@@ -1,23 +0,0 @@
-#ifdef SYSTEM_CPP
-
-//SHA256 = cf053eccb4ccafff9e67339d4e78e98dce7d1ed59be819d2a1ba2232c6fce1c7
-const uint8_t System::BootROM::dmg[256] = {
-  0x31,0xfe,0xff,0xaf,0x21,0xff,0x9f,0x32,0xcb,0x7c,0x20,0xfb,0x21,0x26,0xff,0x0e,
-  0x11,0x3e,0x80,0x32,0xe2,0x0c,0x3e,0xf3,0xe2,0x32,0x3e,0x77,0x77,0x3e,0xfc,0xe0,
-  0x47,0x11,0x04,0x01,0x21,0x10,0x80,0x1a,0xcd,0x95,0x00,0xcd,0x96,0x00,0x13,0x7b,
-  0xfe,0x34,0x20,0xf3,0x11,0xd8,0x00,0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,
-  0x3e,0x19,0xea,0x10,0x99,0x21,0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,
-  0xf9,0x2e,0x0f,0x18,0xf3,0x67,0x3e,0x64,0x57,0xe0,0x42,0x3e,0x91,0xe0,0x40,0x04,
-  0x1e,0x02,0x0e,0x0c,0xf0,0x44,0xfe,0x90,0x20,0xfa,0x0d,0x20,0xf7,0x1d,0x20,0xf2,
-  0x0e,0x13,0x24,0x7c,0x1e,0x83,0xfe,0x62,0x28,0x06,0x1e,0xc1,0xfe,0x64,0x20,0x06,
-  0x7b,0xe2,0x0c,0x3e,0x87,0xe2,0xf0,0x42,0x90,0xe0,0x42,0x15,0x20,0xd2,0x05,0x20,
-  0x4f,0x16,0x20,0x18,0xcb,0x4f,0x06,0x04,0xc5,0xcb,0x11,0x17,0xc1,0xcb,0x11,0x17,
-  0x05,0x20,0xf5,0x22,0x23,0x22,0x23,0xc9,0xce,0xed,0x66,0x66,0xcc,0x0d,0x00,0x0b,
-  0x03,0x73,0x00,0x83,0x00,0x0c,0x00,0x0d,0x00,0x08,0x11,0x1f,0x88,0x89,0x00,0x0e,
-  0xdc,0xcc,0x6e,0xe6,0xdd,0xdd,0xd9,0x99,0xbb,0xbb,0x67,0x63,0x6e,0x0e,0xec,0xcc,
-  0xdd,0xdc,0x99,0x9f,0xbb,0xb9,0x33,0x3e,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,
-  0x21,0x04,0x01,0x11,0xa8,0x00,0x1a,0x13,0xbe,0x20,0xfe,0x23,0x7d,0xfe,0x34,0x20,
-  0xf5,0x06,0x19,0x78,0x86,0x23,0x05,0x20,0xfb,0x86,0x20,0xfe,0x3e,0x01,0xe0,0x50,
-};
-
-#endif

bsnes/gameboy/system/bootrom-sgb.cpp

@@ -1,23 +0,0 @@
-#ifdef SYSTEM_CPP
-
-//SHA256 = 0e4ddff32fc9d1eeaae812a157dd246459b00c9e14f2f61751f661f32361e360
-const uint8_t System::BootROM::sgb[256] = {
-  0x31,0xfe,0xff,0x3e,0x30,0xe0,0x00,0xaf,0x21,0xff,0x9f,0x32,0xcb,0x7c,0x20,0xfb,
-  0x21,0x26,0xff,0x0e,0x11,0x3e,0x80,0x32,0xe2,0x0c,0x3e,0xf3,0xe2,0x32,0x3e,0x77,
-  0x77,0x3e,0xfc,0xe0,0x47,0x21,0x5f,0xc0,0x0e,0x08,0xaf,0x32,0x0d,0x20,0xfc,0x11,
-  0x4f,0x01,0x3e,0xfb,0x0e,0x06,0xf5,0x06,0x00,0x1a,0x1b,0x32,0x80,0x47,0x0d,0x20,
-  0xf8,0x32,0xf1,0x32,0x0e,0x0e,0xd6,0x02,0xfe,0xef,0x20,0xea,0x11,0x04,0x01,0x21,
-  0x10,0x80,0x1a,0xcd,0xd3,0x00,0xcd,0xd4,0x00,0x13,0x7b,0xfe,0x34,0x20,0xf3,0x11,
-  0xe6,0x00,0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,0x3e,0x19,0xea,0x10,0x99,
-  0x21,0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,0xf9,0x2e,0x0f,0x18,0xf3,
-  0x3e,0x91,0xe0,0x40,0x21,0x00,0xc0,0x0e,0x00,0x3e,0x00,0xe2,0x3e,0x30,0xe2,0x06,
-  0x10,0x1e,0x08,0x2a,0x57,0xcb,0x42,0x3e,0x10,0x20,0x02,0x3e,0x20,0xe2,0x3e,0x30,
-  0xe2,0xcb,0x1a,0x1d,0x20,0xef,0x05,0x20,0xe8,0x3e,0x20,0xe2,0x3e,0x30,0xe2,0xcd,
-  0xc2,0x00,0x7d,0xfe,0x60,0x20,0xd2,0x0e,0x13,0x3e,0xc1,0xe2,0x0c,0x3e,0x07,0xe2,
-  0x18,0x3a,0x16,0x04,0xf0,0x44,0xfe,0x90,0x20,0xfa,0x1e,0x00,0x1d,0x20,0xfd,0x15,
-  0x20,0xf2,0xc9,0x4f,0x06,0x04,0xc5,0xcb,0x11,0x17,0xc1,0xcb,0x11,0x17,0x05,0x20,
-  0xf5,0x22,0x23,0x22,0x23,0xc9,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,0x00,0x00,
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x01,0xe0,0x50,
-};
-
-#endif

bsnes/gameboy/video/video.cpp

@@ -1,82 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#define VIDEO_CPP
-namespace GameBoy {
-
-Video video;
-
-unsigned Video::palette_dmg(unsigned color) const {
-  unsigned R = monochrome[color][0] * 1023.0;
-  unsigned G = monochrome[color][1] * 1023.0;
-  unsigned B = monochrome[color][2] * 1023.0;
-
-  return (R << 20) + (G << 10) + (B << 0);
-}
-
-unsigned Video::palette_sgb(unsigned color) const {
-  unsigned R = (3 - color) * 341;
-  unsigned G = (3 - color) * 341;
-  unsigned B = (3 - color) * 341;
-
-  return (R << 20) + (G << 10) + (B << 0);
-}
-
-unsigned Video::palette_cgb(unsigned color) const {
-  unsigned r = (color >>  0) & 31;
-  unsigned g = (color >>  5) & 31;
-  unsigned b = (color >> 10) & 31;
-
-  unsigned R = (r * 26 + g *  4 + b *  2);
-  unsigned G = (         g * 24 + b *  8);
-  unsigned B = (r *  6 + g *  4 + b * 22);
-
-  R = min(960, R);
-  G = min(960, G);
-  B = min(960, B);
-
-  return (R << 20) + (G << 10) + (B << 0);
-}
-
-void Video::generate(Format format) {
-  if(system.dmg()) for(unsigned n = 0; n < 4; n++) palette[n] = palette_dmg(n);
-  if(system.sgb()) for(unsigned n = 0; n < 4; n++) palette[n] = palette_sgb(n);
-  if(system.cgb()) for(unsigned n = 0; n < (1 << 15); n++) palette[n] = palette_cgb(n);
-
-  if(format == Format::RGB24) {
-    for(unsigned n = 0; n < (1 << 15); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 6) & 0xff0000) + ((color >> 4) & 0x00ff00) + ((color >> 2) & 0x0000ff);
-    }
-  }
-
-  if(format == Format::RGB16) {
-    for(unsigned n = 0; n < (1 << 15); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 14) & 0xf800) + ((color >> 9) & 0x07e0) + ((color >> 5) & 0x001f);
-    }
-  }
-
-  if(format == Format::RGB15) {
-    for(unsigned n = 0; n < (1 << 15); n++) {
-      unsigned color = palette[n];
-      palette[n] = ((color >> 15) & 0x7c00) + ((color >> 10) & 0x03e0) + ((color >> 5) & 0x001f);
-    }
-  }
-}
-
-Video::Video() {
-  palette = new unsigned[1 << 15];
-}
-
-Video::~Video() {
-  delete[] palette;
-}
-
-const double Video::monochrome[4][3] = {
-  { 0.605, 0.734, 0.059 },
-  { 0.543, 0.672, 0.059 },
-  { 0.188, 0.383, 0.188 },
-  { 0.059, 0.219, 0.059 },
-};
-
-}

bsnes/gameboy/video/video.hpp

@@ -1,17 +0,0 @@
-struct Video {
-  enum class Format : unsigned { RGB30, RGB24, RGB16, RGB15 };
-  unsigned *palette;
-
-  unsigned palette_dmg(unsigned color) const;
-  unsigned palette_sgb(unsigned color) const;
-  unsigned palette_cgb(unsigned color) const;
-
-  void generate(Format format);
-  Video();
-  ~Video();
-
-private:
-  static const double monochrome[4][3];
-};
-
-extern Video video;

bsnes/gb/Makefile

@@ -0,0 +1,16 @@
+gb_objects := gb-interface gb-system gb-scheduler
+gb_objects += gb-memory gb-cartridge
+gb_objects += gb-cpu gb-ppu gb-apu
+gb_objects += gb-cheat gb-video
+objects += $(gb_objects)
+
+obj/gb-interface.o: $(gb)/interface/interface.cpp $(call rwildcard,$(gb)/interface/)
+obj/gb-system.o:    $(gb)/system/system.cpp $(call rwildcard,$(gb)/system/)
+obj/gb-scheduler.o: $(gb)/scheduler/scheduler.cpp $(call rwildcard,$(gb)/scheduler/)
+obj/gb-cartridge.o: $(gb)/cartridge/cartridge.cpp $(call rwildcard,$(gb)/cartridge/)
+obj/gb-memory.o:    $(gb)/memory/memory.cpp $(call rwildcard,$(gb)/memory/)
+obj/gb-cpu.o:       $(gb)/cpu/cpu.cpp $(call rwildcard,$(gb)/cpu/)
+obj/gb-ppu.o:       $(gb)/ppu/ppu.cpp $(call rwildcard,$(gb)/ppu/)
+obj/gb-apu.o:       $(gb)/apu/apu.cpp $(call rwildcard,$(gb)/apu/)
+obj/gb-cheat.o:     $(gb)/cheat/cheat.cpp $(call rwildcard,$(gb)/cheat/)
+obj/gb-video.o:     $(gb)/video/video.cpp $(call rwildcard,$(gb)/video/)

bsnes/gb/apu/apu.cpp

@@ -1,4 +1,4 @@
-#include <gameboy/gameboy.hpp>
+#include <gb/gb.hpp>
 
 #define APU_CPP
 namespace GameBoy {
@@ -46,10 +46,10 @@ void APU::main() {
     noise.run();
     master.run();
 
-    interface->audioSample(master.center, master.left, master.right);
+    interface->audioSample(master.left, master.right);
 
-    clock += 1 * cpu.frequency;
-    if(clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
+    clock += cpu.frequency;
+    if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(scheduler.active_thread = cpu.thread);
   }
 }
 

bsnes/gb/apu/apu.hpp

@@ -1,4 +1,4 @@
-struct APU : Processor, MMIO {
+struct APU : Thread, MMIO {
   #include "square1/square1.hpp"
   #include "square2/square2.hpp"
   #include "wave/wave.hpp"

bsnes/gb/apu/master/master.cpp

@@ -20,36 +20,18 @@ void APU::Master::run() {
   if(channel2_left_enable) sample += apu.square2.output;
   if(channel3_left_enable) sample +=    apu.wave.output;
   if(channel4_left_enable) sample +=   apu.noise.output;
-  left = (sample * 512) - 16384;
-
-  switch(left_volume) {
-    case 0: left >>= 3;                       break;  // 12.5%
-    case 1: left >>= 2;                       break;  // 25.0%
-    case 2: left = (left >> 2) + (left >> 3); break;  // 37.5%
-    case 3: left >>= 1;                       break;  // 50.0%
-    case 4: left = (left >> 1) + (left >> 3); break;  // 62.5%
-    case 5: left -= (left >> 2);              break;  // 75.0%
-    case 6: left -= (left >> 3);              break;  // 87.5%
-  //case 7:                                   break;  //100.0%
-  }
+  sample = (sample * 512) - 16384;
+  sample = (sample * (left_volume  + 1)) / 8;
+  left  = sample;
 
   sample = 0;
   if(channel1_right_enable) sample += apu.square1.output;
   if(channel2_right_enable) sample += apu.square2.output;
   if(channel3_right_enable) sample +=    apu.wave.output;
   if(channel4_right_enable) sample +=   apu.noise.output;
-  right = (sample * 512) - 16384;
-
-  switch(right_volume) {
-    case 0: right >>= 3;                         break;  // 12.5%
-    case 1: right >>= 2;                         break;  // 25.0%
-    case 2: right = (right >> 2) + (right >> 3); break;  // 37.5%
-    case 3: right >>= 1;                         break;  // 50.0%
-    case 4: right = (right >> 1) + (right >> 3); break;  // 62.5%
-    case 5: right -= (right >> 2);               break;  // 75.0%
-    case 6: right -= (right >> 3);               break;  // 87.5%
-  //case 7:                                      break;  //100.0%
-  }
+  sample = (sample * 512) - 16384;
+  sample = (sample * (right_volume + 1)) / 8;
+  right = sample;
 }
 
 void APU::Master::write(unsigned r, uint8 data) {