Update to v102 release.

byuu says (in the public announcement):

This release adds very preliminary emulation of the Sega Master System
(Mark III), Sega Game Gear, Sega Mega Drive (Genesis), and NEC PC Engine
(Turbografx-16). These cores do not yet offer sound emulation, save
states or cheat codes.

I'm always very hesitant to release a new emulation core in its alpha
stages, as in the past this has resulted in lasting bad impressions
of cores that have since improved greatly. For instance, the Game Boy
Advance emulation offered today is easily the second most accurate around,
yet it is still widely judged by its much older alpha implementation.

However, it's always been tradition with higan to not hold onto code
in secret. Rather than delay future releases for another year or two,
I'll put my faith in you all to understand that the emulation of these
systems will improve over time.

I hope that by releasing things as they are now, I might be able to
receive some much needed assistance in improving these cores, as the
documentation for these new systems is very much less than ideal.

byuu says (in the WIP forum):

Changelog:

  - PCE: latch background scroll registers (fixes Neutopia scrolling)
  - PCE: clip background attribute table scrolling (fixes Blazing Lazers
    scrolling)
  - PCE: support background/sprite enable/disable bits
  - PCE: fix large sprite indexing (fixes Blazing Lazers title screen
    sprites)
  - HuC6280: wrap zeropage accesses to never go beyond $20xx
  - HuC6280: fix alternating addresses for block move instructions
    (fixes Neutopia II)
  - HuC6280: block move instructions save and restore A,X,Y registers
  - HuC6280: emulate BCD mode (may not be 100% correct, based on SNES
    BCD) (fixes Blazing Lazers scoring)

.gitlab-ci.yml

@@ -0,0 +1,47 @@
+# NOTE: This file is not part of the official higan source, it's been added
+# to help build WIP binaries with minimal fuss.
+
+image: debian:stable
+
+linux-x86_64-binaries:
+  script:
+    - apt-get update && apt-get -y install build-essential libgtk2.0-dev libpulse-dev mesa-common-dev libgtksourceview2.0-dev libcairo2-dev libsdl1.2-dev libxv-dev libao-dev libopenal-dev libudev-dev
+    - make -C icarus compiler=g++
+    - make -C higan compiler=g++
+    - mkdir higan-nightly
+    - cp -a icarus/out/icarus higan-nightly/icarus
+    - cp -a icarus/Database higan-nightly/
+    - cp -a higan/out/higan higan-nightly/higan
+    - cp -a higan/data/cheats.bml higan-nightly/
+    - cp -a higan/systems/* higan-nightly/
+  artifacts:
+    paths:
+      - higan-nightly/*
+  cache:
+    paths:
+      - icarus/obj/*.o
+      - higan/obj/*.o
+
+windows-x86_64-binaries:
+  # This is a normal Windows cross-compile process, except that
+  # nall::chrono tries to use clock_gettime on Windows even
+  # though it's a POSIX function, and for some weird reason mingw has
+  # clock_gettime() in the pthread library.
+  script:
+    - apt-get update && apt-get -y install build-essential mingw-w64
+    - sed -i -e 's/-lole32/& -static -lpthread/' nall/GNUmakefile
+    - make -C icarus platform=windows compiler="x86_64-w64-mingw32-g++ -static-libgcc -static-libstdc++" windres="x86_64-w64-mingw32-windres"
+    - make -C higan platform=windows compiler="x86_64-w64-mingw32-g++ -static-libgcc -static-libstdc++" windres="x86_64-w64-mingw32-windres"
+    - mkdir higan-nightly
+    - cp -a icarus/out/icarus higan-nightly/icarus.exe
+    - cp -a icarus/Database higan-nightly/
+    - cp -a higan/out/higan higan-nightly/higan.exe
+    - cp -a higan/data/cheats.bml higan-nightly/
+    - cp -a higan/systems/* higan-nightly/
+  artifacts:
+    paths:
+      - higan-nightly/*
+  cache:
+    paths:
+      - icarus/obj/*.o
+      - higan/obj/*.o

higan/GNUmakefile

@@ -4,7 +4,7 @@ target := tomoko
 # console := true
 
 flags += -I. -I.. -O3
-objects := libco audio video resource
+objects := libco emulator audio video resource
 
 # profile-guided optimization mode
 # pgo := instrument
@@ -24,7 +24,7 @@ ifeq ($(platform),windows)
   else
     link += -mwindows
   endif
-  link += -mthreads -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
+  link += -mthreads -lpthread -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
   link += -Wl,-enable-auto-import
   link += -Wl,-enable-runtime-pseudo-reloc
 else ifeq ($(platform),macosx)
@@ -52,10 +52,11 @@ compile = \
 
 all: build;
 
-obj/libco.o: ../libco/libco.c $(call rwildcard,../libco/)
-obj/audio.o: audio/audio.cpp $(call rwildcard,audio/)
-obj/video.o: video/video.cpp $(call rwildcard,video/)
-obj/resource.o: resource/resource.cpp $(call rwildcard,resource/)
+obj/libco.o: ../libco/libco.c $(call rwildcard,../libco)
+obj/emulator.o: emulator/emulator.cpp $(call rwildcard,emulator)
+obj/audio.o: audio/audio.cpp $(call rwildcard,audio)
+obj/video.o: video/video.cpp $(call rwildcard,video)
+obj/resource.o: resource/resource.cpp $(call rwildcard,resource)
 
 ui := target-$(target)
 include $(ui)/GNUmakefile

higan/audio/audio.cpp

@@ -6,6 +6,8 @@ namespace Emulator {
 Audio audio;
 
 auto Audio::reset(maybe<uint> channels_, maybe<double> frequency_) -> void {
+  interface = nullptr;
+
   if(channels_) channels = channels_();
   if(frequency_) frequency = frequency_();
 
@@ -81,7 +83,7 @@ auto Audio::process() -> void {
       if(balance > 0.0) samples[0] *= 1.0 - balance;
     }
 
-    interface->audioSample(samples, channels);
+    platform->audioSample(samples, channels);
   }
 }
 

higan/audio/audio.hpp

@@ -11,7 +11,7 @@ struct Stream;
 
 struct Audio {
   auto reset(maybe<uint> channels = nothing, maybe<double> frequency = nothing) -> void;
-  auto setInterface(Interface*) -> void;
+  auto setInterface(Interface* interface) -> void;
 
   auto setVolume(double volume) -> void;
   auto setBalance(double balance) -> void;

higan/emulator/cheat.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+namespace Emulator {
+
+struct Cheat {
+  struct Code {
+    uint addr;
+    uint data;
+    maybe<uint> comp;
+  };
+
+  explicit operator bool() const {
+    return codes.size() > 0;
+  }
+
+  auto reset() -> void {
+    codes.reset();
+  }
+
+  auto append(uint addr, uint data, maybe<uint> comp = nothing) -> void {
+    codes.append({addr, data, comp});
+  }
+
+  auto assign(const string_vector& list) -> void {
+    reset();
+    for(auto& entry : list) {
+      for(auto code : entry.split("+")) {
+        auto part = code.split("/");
+        if(part.size() == 2) append(part[0].hex(), part[1].hex());
+        if(part.size() == 3) append(part[0].hex(), part[2].hex(), part[1].hex());
+      }
+    }
+  }
+
+  auto find(uint addr, uint comp) -> maybe<uint> {
+    for(auto& code : codes) {
+      if(code.addr == addr && (!code.comp || code.comp() == comp)) {
+        return code.data;
+      }
+    }
+    return nothing;
+  }
+
+private:
+  vector<Code> codes;
+};
+
+}

higan/emulator/emulator.cpp

@@ -0,0 +1,7 @@
+#include <emulator/emulator.hpp>
+
+namespace Emulator {
+
+Platform* platform = nullptr;
+
+}

higan/emulator/emulator.hpp

@@ -4,6 +4,7 @@
 #include <nall/vfs.hpp>
 using namespace nall;
 
+#include "types.hpp"
 #include <libco/libco.h>
 #include <audio/audio.hpp>
 #include <video/video.hpp>
@@ -11,19 +12,20 @@ using namespace nall;
 
 namespace Emulator {
   static const string Name    = "higan";
-  static const string Version = "100";
+  static const string Version = "102";
   static const string Author  = "byuu";
   static const string License = "GPLv3";
   static const string Website = "http://byuu.org/";
 
   //incremented only when serialization format changes
-  static const string SerializerVersion = "100";
+  static const string SerializerVersion = "101";
+
+  namespace Constants {
+    namespace Colorburst {
+      static constexpr double NTSC = 315.0 / 88.0 * 1'000'000.0;
+      static constexpr double PAL  = 283.75 * 15'625.0 + 25.0;
+    }
+  }
 }
 
 #include "interface.hpp"
-
-#if defined(DEBUGGER)
-  #define privileged public
-#else
-  #define privileged private
-#endif

higan/emulator/interface.hpp

@@ -2,14 +2,23 @@
 
 namespace Emulator {
 
+struct Platform {
+  virtual auto path(uint id) -> string { return ""; }
+  virtual auto open(uint id, string name, vfs::file::mode mode, bool required = false) -> vfs::shared::file { return {}; }
+  virtual auto load(uint id, string name, string type) -> maybe<uint> { return nothing; }
+  virtual auto videoRefresh(const uint32* data, uint pitch, uint width, uint height) -> void {}
+  virtual auto audioSample(const double* samples, uint channels) -> void {}
+  virtual auto inputPoll(uint port, uint device, uint input) -> int16 { return 0; }
+  virtual auto inputRumble(uint port, uint device, uint input, bool enable) -> void {}
+  virtual auto dipSettings(Markup::Node node) -> uint { return 0; }
+  virtual auto notify(string text) -> void { print(text, "\n"); }
+};
+
 struct Interface {
   struct Information {
     string manufacturer;
     string name;
-    uint width;
-    uint height;
     bool overscan;
-    double aspectRatio;
     bool resettable;
     struct Capability {
       bool states;
@@ -41,35 +50,14 @@ struct Interface {
   };
   vector<Port> ports;
 
-  struct Bind {
-    virtual auto path(uint) -> string { return ""; }
-    virtual auto open(uint, string, vfs::file::mode, bool) -> vfs::shared::file { return {}; }
-    virtual auto load(uint, string, string) -> maybe<uint> { return nothing; }
-    virtual auto videoRefresh(const uint32*, uint, uint, uint) -> void {}
-    virtual auto audioSample(const double*, uint) -> void {}
-    virtual auto inputPoll(uint, uint, uint) -> int16 { return 0; }
-    virtual auto inputRumble(uint, uint, uint, bool) -> void {}
-    virtual auto dipSettings(Markup::Node) -> uint { return 0; }
-    virtual auto notify(string text) -> void { print(text, "\n"); }
-  };
-  Bind* bind = nullptr;
-
-  //callback bindings (provided by user interface)
-  auto path(uint id) -> string { return bind->path(id); }
-  auto open(uint id, string name, vfs::file::mode mode, bool required = false) -> vfs::shared::file { return bind->open(id, name, mode, required); }
-  auto load(uint id, string name, string type) -> maybe<uint> { return bind->load(id, name, type); }
-  auto videoRefresh(const uint32* data, uint pitch, uint width, uint height) -> void { return bind->videoRefresh(data, pitch, width, height); }
-  auto audioSample(const double* samples, uint channels) -> void { return bind->audioSample(samples, channels); }
-  auto inputPoll(uint port, uint device, uint input) -> int16 { return bind->inputPoll(port, device, input); }
-  auto inputRumble(uint port, uint device, uint input, bool enable) -> void { return bind->inputRumble(port, device, input, enable); }
-  auto dipSettings(Markup::Node node) -> uint { return bind->dipSettings(node); }
-  template<typename... P> auto notify(P&&... p) -> void { return bind->notify({forward<P>(p)...}); }
-
   //information
   virtual auto manifest() -> string = 0;
   virtual auto title() -> string = 0;
 
   //video information
+  struct VideoSize { uint width, height; };
+  virtual auto videoSize() -> VideoSize = 0;
+  virtual auto videoSize(uint width, uint height, bool arc) -> VideoSize = 0;
   virtual auto videoFrequency() -> double = 0;
   virtual auto videoColors() -> uint32 = 0;
   virtual auto videoColor(uint32 color) -> uint64 = 0;
@@ -118,4 +106,6 @@ struct File {
   static const auto Required = true;
 };
 
+extern Platform* platform;
+
 }

higan/emulator/scheduler.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+namespace Emulator {
+
+struct Scheduler {
+  enum class Mode : uint {
+    Run,
+    SynchronizeMaster,
+    SynchronizeSlave,
+  };
+
+  enum class Event : uint {
+    Step,
+    Frame,
+    Synchronize,
+  };
+
+  inline auto synchronizing() const -> bool { return _mode == Mode::SynchronizeSlave; }
+
+  auto reset() -> void {
+    _host = co_active();
+    _threads.reset();
+  }
+
+  auto primary(Thread& thread) -> void {
+    _master = _resume = thread.handle();
+  }
+
+  auto append(Thread& thread) -> bool {
+    if(_threads.find(&thread)) return false;
+    thread._clock += _threads.size();  //this bias prioritizes threads appended earlier first
+    return _threads.append(&thread), true;
+  }
+
+  auto remove(Thread& thread) -> bool {
+    if(auto offset = _threads.find(&thread)) return _threads.remove(*offset), true;
+    return false;
+  }
+
+  auto enter(Mode mode = Mode::Run) -> Event {
+    _mode = mode;
+    _host = co_active();
+    co_switch(_resume);
+    return _event;
+  }
+
+  inline auto resume(Thread& thread) -> void {
+    if(_mode != Mode::SynchronizeSlave) co_switch(thread.handle());
+  }
+
+  auto exit(Event event) -> void {
+    uintmax minimum = -1;
+    for(auto thread : _threads) {
+      if(thread->_clock < minimum) minimum = thread->_clock;
+    }
+    for(auto thread : _threads) {
+      thread->_clock -= minimum;
+    }
+
+    _event = event;
+    _resume = co_active();
+    co_switch(_host);
+  }
+
+  inline auto synchronize(Thread& thread) -> void {
+    if(thread.handle() == _master) {
+      while(enter(Mode::SynchronizeMaster) != Event::Synchronize);
+    } else {
+      _resume = thread.handle();
+      while(enter(Mode::SynchronizeSlave) != Event::Synchronize);
+    }
+  }
+
+  inline auto synchronize() -> void {
+    if(co_active() == _master) {
+      if(_mode == Mode::SynchronizeMaster) return exit(Event::Synchronize);
+    } else {
+      if(_mode == Mode::SynchronizeSlave) return exit(Event::Synchronize);
+    }
+  }
+
+private:
+  cothread_t _host = nullptr;    //program thread (used to exit scheduler)
+  cothread_t _resume = nullptr;  //resume thread (used to enter scheduler)
+  cothread_t _master = nullptr;  //primary thread (used to synchronize components)
+  Mode _mode = Mode::Run;
+  Event _event = Event::Step;
+  vector<Thread*> _threads;
+};
+
+}

higan/emulator/thread.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+namespace Emulator {
+
+struct Thread {
+  enum : uintmax { Second = (uintmax)-1 >> 1 };
+
+  virtual ~Thread() {
+    if(_handle) co_delete(_handle);
+  }
+
+  inline auto active() const { return co_active() == _handle; }
+  inline auto handle() const { return _handle; }
+  inline auto frequency() const { return _frequency; }
+  inline auto scalar() const { return _scalar; }
+  inline auto clock() const { return _clock; }
+
+  auto setFrequency(double frequency) -> void {
+    _frequency = frequency + 0.5;
+    _scalar = Second / _frequency;
+  }
+
+  auto setScalar(uintmax scalar) -> void {
+    _scalar = scalar;
+  }
+
+  auto setClock(uintmax clock) -> void {
+    _clock = clock;
+  }
+
+  auto create(auto (*entrypoint)() -> void, double frequency) -> void {
+    if(_handle) co_delete(_handle);
+    _handle = co_create(64 * 1024 * sizeof(void*), entrypoint);
+    setFrequency(frequency);
+    setClock(0);
+  }
+
+  inline auto step(uint clocks) -> void {
+    _clock += _scalar * clocks;
+  }
+
+  auto serialize(serializer& s) -> void {
+    s.integer(_frequency);
+    s.integer(_scalar);
+    s.integer(_clock);
+  }
+
+protected:
+  cothread_t _handle = nullptr;
+  uintmax _frequency = 0;
+  uintmax _scalar = 0;
+  uintmax _clock = 0;
+
+  friend class Scheduler;
+};
+
+}

higan/emulator/types.hpp

@@ -0,0 +1,129 @@
+using  int1 = nall::Integer< 1>;
+using  int2 = nall::Integer< 2>;
+using  int3 = nall::Integer< 3>;
+using  int4 = nall::Integer< 4>;
+using  int5 = nall::Integer< 5>;
+using  int6 = nall::Integer< 6>;
+using  int7 = nall::Integer< 7>;
+using  int8 = nall::Integer< 8>;
+using  int9 = nall::Integer< 9>;
+using int10 = nall::Integer<10>;
+using int11 = nall::Integer<11>;
+using int12 = nall::Integer<12>;
+using int13 = nall::Integer<13>;
+using int14 = nall::Integer<14>;
+using int15 = nall::Integer<15>;
+using int16 = nall::Integer<16>;
+using int17 = nall::Integer<17>;
+using int18 = nall::Integer<18>;
+using int19 = nall::Integer<19>;
+using int20 = nall::Integer<20>;
+using int21 = nall::Integer<21>;
+using int22 = nall::Integer<22>;
+using int23 = nall::Integer<23>;
+using int24 = nall::Integer<24>;
+using int25 = nall::Integer<25>;
+using int26 = nall::Integer<26>;
+using int27 = nall::Integer<27>;
+using int28 = nall::Integer<28>;
+using int29 = nall::Integer<29>;
+using int30 = nall::Integer<30>;
+using int31 = nall::Integer<31>;
+using int32 = nall::Integer<32>;
+using int33 = nall::Integer<33>;
+using int34 = nall::Integer<34>;
+using int35 = nall::Integer<35>;
+using int36 = nall::Integer<36>;
+using int37 = nall::Integer<37>;
+using int38 = nall::Integer<38>;
+using int39 = nall::Integer<39>;
+using int40 = nall::Integer<40>;
+using int41 = nall::Integer<41>;
+using int42 = nall::Integer<42>;
+using int43 = nall::Integer<43>;
+using int44 = nall::Integer<44>;
+using int45 = nall::Integer<45>;
+using int46 = nall::Integer<46>;
+using int47 = nall::Integer<47>;
+using int48 = nall::Integer<48>;
+using int49 = nall::Integer<49>;
+using int50 = nall::Integer<50>;
+using int51 = nall::Integer<51>;
+using int52 = nall::Integer<52>;
+using int53 = nall::Integer<53>;
+using int54 = nall::Integer<54>;
+using int55 = nall::Integer<55>;
+using int56 = nall::Integer<56>;
+using int57 = nall::Integer<57>;
+using int58 = nall::Integer<58>;
+using int59 = nall::Integer<59>;
+using int60 = nall::Integer<60>;
+using int61 = nall::Integer<61>;
+using int62 = nall::Integer<62>;
+using int63 = nall::Integer<63>;
+using int64 = nall::Integer<64>;
+
+using  uint1 = nall::Natural< 1>;
+using  uint2 = nall::Natural< 2>;
+using  uint3 = nall::Natural< 3>;
+using  uint4 = nall::Natural< 4>;
+using  uint5 = nall::Natural< 5>;
+using  uint6 = nall::Natural< 6>;
+using  uint7 = nall::Natural< 7>;
+using  uint8 = nall::Natural< 8>;
+using  uint9 = nall::Natural< 9>;
+using uint10 = nall::Natural<10>;
+using uint11 = nall::Natural<11>;
+using uint12 = nall::Natural<12>;
+using uint13 = nall::Natural<13>;
+using uint14 = nall::Natural<14>;
+using uint15 = nall::Natural<15>;
+using uint16 = nall::Natural<16>;
+using uint17 = nall::Natural<17>;
+using uint18 = nall::Natural<18>;
+using uint19 = nall::Natural<19>;
+using uint20 = nall::Natural<20>;
+using uint21 = nall::Natural<21>;
+using uint22 = nall::Natural<22>;
+using uint23 = nall::Natural<23>;
+using uint24 = nall::Natural<24>;
+using uint25 = nall::Natural<25>;
+using uint26 = nall::Natural<26>;
+using uint27 = nall::Natural<27>;
+using uint28 = nall::Natural<28>;
+using uint29 = nall::Natural<29>;
+using uint30 = nall::Natural<30>;
+using uint31 = nall::Natural<31>;
+using uint32 = nall::Natural<32>;
+using uint33 = nall::Natural<33>;
+using uint34 = nall::Natural<34>;
+using uint35 = nall::Natural<35>;
+using uint36 = nall::Natural<36>;
+using uint37 = nall::Natural<37>;
+using uint38 = nall::Natural<38>;
+using uint39 = nall::Natural<39>;
+using uint40 = nall::Natural<40>;
+using uint41 = nall::Natural<41>;
+using uint42 = nall::Natural<42>;
+using uint43 = nall::Natural<43>;
+using uint44 = nall::Natural<44>;
+using uint45 = nall::Natural<45>;
+using uint46 = nall::Natural<46>;
+using uint47 = nall::Natural<47>;
+using uint48 = nall::Natural<48>;
+using uint49 = nall::Natural<49>;
+using uint50 = nall::Natural<50>;
+using uint51 = nall::Natural<51>;
+using uint52 = nall::Natural<52>;
+using uint53 = nall::Natural<53>;
+using uint54 = nall::Natural<54>;
+using uint55 = nall::Natural<55>;
+using uint56 = nall::Natural<56>;
+using uint57 = nall::Natural<57>;
+using uint58 = nall::Natural<58>;
+using uint59 = nall::Natural<59>;
+using uint60 = nall::Natural<60>;
+using uint61 = nall::Natural<61>;
+using uint62 = nall::Natural<62>;
+using uint63 = nall::Natural<63>;
+using uint64 = nall::Natural<64>;

higan/fc/GNUmakefile

@@ -1,16 +1,13 @@
 processors += r6502
 
-objects += fc-interface fc-system fc-scheduler fc-controller
+objects += fc-interface fc-system fc-controller
 objects += fc-memory fc-cartridge fc-cpu fc-apu fc-ppu
-objects += fc-cheat
 
 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-controller.o: fc/controller/controller.cpp $(call rwildcard,fc/controller/)
 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/)

higan/fc/apu/apu.cpp

@@ -63,8 +63,8 @@ auto APU::main() -> void {
 }
 
 auto APU::tick() -> void {
-  clock += 12;
-  if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+  Thread::step(12);
+  synchronize(cpu);
 }
 
 auto APU::setIRQ() -> void {
@@ -88,8 +88,8 @@ auto APU::power() -> void {
 }
 
 auto APU::reset() -> void {
-  create(APU::Enter, 21'477'272);
-  stream = Emulator::audio.createStream(1, 21'477'272.0 / 12.0);
+  create(APU::Enter, system.colorburst() * 6.0);
+  stream = Emulator::audio.createStream(1, system.colorburst() / 2.0);
 
   pulse[0].reset();
   pulse[1].reset();

higan/fc/cartridge/board/board.cpp

@@ -42,22 +42,22 @@ Board::Board(Markup::Node& document) {
   if(chrram.size) chrram.data = new uint8_t[chrram.size]();
 
   if(prgrom.name = prom["name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), prgrom.name, File::Read, File::Required)) {
+    if(auto fp = platform->open(cartridge.pathID(), prgrom.name, File::Read, File::Required)) {
       fp->read(prgrom.data, min(prgrom.size, fp->size()));
     }
   }
   if(prgram.name = pram["name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), prgram.name, File::Read)) {
+    if(auto fp = platform->open(cartridge.pathID(), prgram.name, File::Read)) {
       fp->read(prgram.data, min(prgram.size, fp->size()));
     }
   }
   if(chrrom.name = crom["name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), chrrom.name, File::Read, File::Required)) {
+    if(auto fp = platform->open(cartridge.pathID(), chrrom.name, File::Read, File::Required)) {
       fp->read(chrrom.data, min(chrrom.size, fp->size()));
     }
   }
   if(chrram.name = cram["name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), chrram.name, File::Read)) {
+    if(auto fp = platform->open(cartridge.pathID(), chrram.name, File::Read)) {
       fp->read(chrram.data, min(chrram.size, fp->size()));
     }
   }
@@ -70,13 +70,13 @@ auto Board::save() -> void {
   auto document = BML::unserialize(cartridge.manifest());
 
   if(auto name = document["board/prg/ram/name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), name, File::Write)) {
+    if(auto fp = platform->open(cartridge.pathID(), name, File::Write)) {
       fp->write(prgram.data, prgram.size);
     }
   }
 
   if(auto name = document["board/chr/ram/name"].text()) {
-    if(auto fp = interface->open(cartridge.pathID(), name, File::Write)) {
+    if(auto fp = platform->open(cartridge.pathID(), name, File::Write)) {
       fp->write(chrram.data, chrram.size);
     }
   }
@@ -109,13 +109,13 @@ auto Board::mirror(uint addr, uint size) -> uint {
 }
 
 auto Board::main() -> void {
-  cartridge.clock += 12 * 4095;
+  cartridge.step(12 * 4095);
   tick();
 }
 
 auto Board::tick() -> void {
-  cartridge.clock += 12;
-  if(cartridge.clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+  cartridge.step(12);
+  cartridge.synchronize(cpu);
 }
 
 auto Board::readCHR(uint addr) -> uint8 {

higan/fc/cartridge/cartridge.cpp

@@ -15,11 +15,11 @@ auto Cartridge::main() -> void {
 }
 
 auto Cartridge::load() -> bool {
-  if(auto pathID = interface->load(ID::Famicom, "Famicom", "fc")) {
+  if(auto pathID = platform->load(ID::Famicom, "Famicom", "fc")) {
     information.pathID = pathID();
   } else return false;
 
-  if(auto fp = interface->open(pathID(), "manifest.bml", File::Read, File::Required)) {
+  if(auto fp = platform->open(pathID(), "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else {
     return false;
@@ -29,8 +29,8 @@ auto Cartridge::load() -> bool {
   if(!board) return false;
 
   Hash::SHA256 sha;
-  sha.data(board->prgrom.data, board->prgrom.size);
-  sha.data(board->chrrom.data, board->chrrom.size);
+  sha.input(board->prgrom.data, board->prgrom.size);
+  sha.input(board->chrrom.data, board->chrrom.size);
   information.sha256 = sha.digest();
   return true;
 }
@@ -49,7 +49,7 @@ auto Cartridge::power() -> void {
 }
 
 auto Cartridge::reset() -> void {
-  create(Cartridge::Enter, 21'477'272);
+  create(Cartridge::Enter, system.colorburst() * 6.0);
   board->reset();
 }
 

higan/fc/cheat/cheat.cpp

@@ -1,28 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-Cheat cheat;
-
-auto Cheat::reset() -> void {
-  codes.reset();
-}
-
-auto Cheat::append(uint addr, uint data) -> void {
-  codes.append({addr, Unused, data});
-}
-
-auto Cheat::append(uint addr, uint comp, uint data) -> void {
-  codes.append({addr, comp, data});
-}
-
-auto Cheat::find(uint addr, uint comp) -> maybe<uint> {
-  for(auto& code : codes) {
-    if(code.addr == addr && (code.comp == Unused || code.comp == comp)) {
-      return code.data;
-    }
-  }
-  return nothing;
-}
-
-}

higan/fc/cheat/cheat.hpp

@@ -1,17 +0,0 @@
-struct Cheat {
-  struct Code {
-    uint addr;
-    uint comp;
-    uint data;
-  };
-  vector<Code> codes;
-  enum : uint { Unused = ~0u };
-
-  alwaysinline auto enable() const -> bool { return codes.size() > 0; }
-  auto reset() -> void;
-  auto append(uint addr, uint data) -> void;
-  auto append(uint addr, uint comp, uint data) -> void;
-  auto find(uint addr, uint comp) -> maybe<uint>;
-};
-
-extern Cheat cheat;

higan/fc/controller/controller.cpp

@@ -5,22 +5,24 @@ namespace Famicom {
 #include "gamepad/gamepad.cpp"
 
 Controller::Controller(bool port) : port(port) {
-  if(!thread) create(Controller::Enter, 1);
+  if(!handle()) create(Controller::Enter, 1);
 }
 
 Controller::~Controller() {
+  scheduler.remove(*this);
 }
 
 auto Controller::Enter() -> void {
   while(true) {
     scheduler.synchronize();
-    if(co_active() == peripherals.controllerPort1->thread) peripherals.controllerPort1->main();
-    if(co_active() == peripherals.controllerPort2->thread) peripherals.controllerPort2->main();
+    if(peripherals.controllerPort1->active()) peripherals.controllerPort1->main();
+    if(peripherals.controllerPort2->active()) peripherals.controllerPort2->main();
   }
 }
 
 auto Controller::main() -> void {
   step(1);
+  synchronize(cpu);
 }
 
 }

higan/fc/controller/controller.hpp

@@ -16,7 +16,7 @@
 //  6:  data4  $4016.d4 read   $4017.d4 read
 //  7:  gnd
 
-struct Controller : Cothread {
+struct Controller : Thread {
   enum : bool { Port1 = 0, Port2 = 1 };
 
   Controller(bool port);

higan/fc/controller/gamepad/gamepad.cpp

@@ -3,7 +3,7 @@ Gamepad::Gamepad(bool port) : Controller(port) {
 
 auto Gamepad::data() -> uint3 {
   if(counter >= 8) return 1;
-  if(latched == 1) return interface->inputPoll(port, ID::Device::Gamepad, A);
+  if(latched == 1) return platform->inputPoll(port, ID::Device::Gamepad, A);
 
   switch(counter++) {
   case 0: return a;
@@ -24,13 +24,13 @@ auto Gamepad::latch(bool data) -> void {
   counter = 0;
 
   if(latched == 0) {
-    a      = interface->inputPoll(port, ID::Device::Gamepad, A);
-    b      = interface->inputPoll(port, ID::Device::Gamepad, B);
-    select = interface->inputPoll(port, ID::Device::Gamepad, Select);
-    start  = interface->inputPoll(port, ID::Device::Gamepad, Start);
-    up     = interface->inputPoll(port, ID::Device::Gamepad, Up);
-    down   = interface->inputPoll(port, ID::Device::Gamepad, Down);
-    left   = interface->inputPoll(port, ID::Device::Gamepad, Left);
-    right  = interface->inputPoll(port, ID::Device::Gamepad, Right);
+    a      = platform->inputPoll(port, ID::Device::Gamepad, A);
+    b      = platform->inputPoll(port, ID::Device::Gamepad, B);
+    select = platform->inputPoll(port, ID::Device::Gamepad, Select);
+    start  = platform->inputPoll(port, ID::Device::Gamepad, Start);
+    up     = platform->inputPoll(port, ID::Device::Gamepad, Up);
+    down   = platform->inputPoll(port, ID::Device::Gamepad, Down);
+    left   = platform->inputPoll(port, ID::Device::Gamepad, Left);
+    right  = platform->inputPoll(port, ID::Device::Gamepad, Right);
   }
 }

higan/fc/cpu/cpu.cpp

@@ -17,19 +17,11 @@ auto CPU::main() -> void {
 }
 
 auto CPU::step(uint clocks) -> void {
-  apu.clock -= clocks;
-  if(apu.clock < 0) co_switch(apu.thread);
-
-  ppu.clock -= clocks;
-  if(ppu.clock < 0) co_switch(ppu.thread);
-
-  cartridge.clock -= clocks;
-  if(cartridge.clock < 0) co_switch(cartridge.thread);
-
-  for(auto peripheral : peripherals) {
-    peripheral->clock -= clocks * (uint64)peripheral->frequency;
-    if(peripheral->clock < 0) co_switch(peripheral->thread);
-  }
+  Thread::step(clocks);
+  synchronize(apu);
+  synchronize(ppu);
+  synchronize(cartridge);
+  for(auto peripheral : peripherals) synchronize(*peripheral);
 }
 
 auto CPU::power() -> void {
@@ -44,7 +36,7 @@ auto CPU::power() -> void {
 
 auto CPU::reset() -> void {
   R6502::reset();
-  create(CPU::Enter, 21'477'272);
+  create(CPU::Enter, system.colorburst() * 6.0);
 
   regs.pc  = bus.read(0xfffc) << 0;
   regs.pc |= bus.read(0xfffd) << 8;

higan/fc/fc.hpp

@@ -4,39 +4,31 @@
 //started: 2011-09-05
 
 #include <emulator/emulator.hpp>
+#include <emulator/thread.hpp>
+#include <emulator/scheduler.hpp>
+#include <emulator/cheat.hpp>
+
 #include <processor/r6502/r6502.hpp>
 
 namespace Famicom {
+  #define platform Emulator::platform
   using File = Emulator::File;
+  using Scheduler = Emulator::Scheduler;
+  using Cheat = Emulator::Cheat;
+  extern Scheduler scheduler;
+  extern Cheat cheat;
 
-  struct Thread {
-    ~Thread() {
-      if(thread) co_delete(thread);
+  struct Thread : Emulator::Thread {
+    auto create(auto (*entrypoint)() -> void, double frequency) -> void {
+      Emulator::Thread::create(entrypoint, frequency);
+      scheduler.append(*this);
     }
 
-    auto create(auto (*entrypoint)() -> void, uint frequency) -> void {
-      if(thread) co_delete(thread);
-      thread = co_create(65'536 * sizeof(void*), entrypoint);
-      this->frequency = frequency;
-      clock = 0;
+    inline auto synchronize(Thread& thread) -> void {
+      if(clock() >= thread.clock()) scheduler.resume(thread);
     }
-
-    auto serialize(serializer& s) -> void {
-      s.integer(frequency);
-      s.integer(clock);
-    }
-
-    cothread_t thread = nullptr;
-    uint frequency = 0;
-    int64 clock = 0;
   };
 
-  struct Cothread : Thread {
-    auto step(uint clocks) -> void;
-    auto synchronizeCPU() -> void;
-  };
-
-  #include <fc/scheduler/scheduler.hpp>
   #include <fc/controller/controller.hpp>
   #include <fc/system/system.hpp>
   #include <fc/memory/memory.hpp>
@@ -44,16 +36,6 @@ namespace Famicom {
   #include <fc/cpu/cpu.hpp>
   #include <fc/apu/apu.hpp>
   #include <fc/ppu/ppu.hpp>
-  #include <fc/cheat/cheat.hpp>
-
-  inline auto Cothread::step(uint clocks) -> void {
-    clock += clocks * (uint64)cpu.frequency;
-    synchronizeCPU();
-  }
-
-  inline auto Cothread::synchronizeCPU() -> void {
-    if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
-  }
 }
 
 #include <fc/interface/interface.hpp>

higan/fc/interface/interface.cpp

@@ -2,18 +2,12 @@
 
 namespace Famicom {
 
-Interface* interface = nullptr;
 Settings settings;
 
 Interface::Interface() {
-  interface = this;
-
   information.manufacturer = "Nintendo";
   information.name         = "Famicom";
-  information.width        = 256;
-  information.height       = 240;
   information.overscan     = true;
-  information.aspectRatio  = 8.0 / 7.0;
   information.resettable   = true;
 
   information.capability.states = true;
@@ -54,6 +48,17 @@ auto Interface::title() -> string {
   return cartridge.title();
 }
 
+auto Interface::videoSize() -> VideoSize {
+  return {256, 240};
+}
+
+auto Interface::videoSize(uint width, uint height, bool arc) -> VideoSize {
+  uint w = 256 * (arc ? 8.0 / 7.0 : 1.0);
+  uint h = 240;
+  uint m = min(width / w, height / h);
+  return {w * m, h * m};
+}
+
 auto Interface::videoFrequency() -> double {
   return 21477272.0 / (262.0 * 1364.0 - 4.0);
 }
@@ -126,7 +131,7 @@ auto Interface::sha256() -> string {
 }
 
 auto Interface::load(uint id) -> bool {
-  return system.load();
+  return system.load(this);
 }
 
 auto Interface::save() -> void {
@@ -139,7 +144,7 @@ auto Interface::unload() -> void {
 }
 
 auto Interface::connect(uint port, uint device) -> void {
-  Famicom::peripherals.connect(port, device);
+  peripherals.connect(port, device);
 }
 
 auto Interface::power() -> void {
@@ -164,15 +169,7 @@ auto Interface::unserialize(serializer& s) -> bool {
 }
 
 auto Interface::cheatSet(const string_vector& list) -> void {
-  cheat.reset();
-  for(auto& codeset : list) {
-    auto codes = codeset.split("+");
-    for(auto& code : codes) {
-      auto part = code.split("/");
-      if(part.size() == 2) cheat.append(part[0].hex(), part[1].hex());
-      if(part.size() == 3) cheat.append(part[0].hex(), part[1].hex(), part[2].hex());
-    }
-  }
+  cheat.assign(list);
 }
 
 auto Interface::cap(const string& name) -> bool {

higan/fc/interface/interface.hpp

@@ -25,9 +25,13 @@ struct Interface : Emulator::Interface {
 
   auto manifest() -> string override;
   auto title() -> string override;
+
+  auto videoSize() -> VideoSize override;
+  auto videoSize(uint width, uint height, bool arc) -> VideoSize override;
   auto videoFrequency() -> double override;
   auto videoColors() -> uint32 override;
   auto videoColor(uint32 color) -> uint64 override;
+
   auto audioFrequency() -> double override;
 
   auto loaded() -> bool override;
@@ -60,7 +64,6 @@ struct Settings {
   uint expansionPort = 0;
 };
 
-extern Interface* interface;
 extern Settings settings;
 
 }

higan/fc/memory/memory.cpp

@@ -17,7 +17,7 @@ auto Bus::read(uint16 addr) -> uint8 {
   else if(addr <= 0x3fff) data = ppu.readIO(addr);
   else if(addr <= 0x4017) data = cpu.readIO(addr);
 
-  if(cheat.enable()) {
+  if(cheat) {
     if(auto result = cheat.find(addr, data)) return result();
   }
 

higan/fc/ppu/ppu.cpp

@@ -27,8 +27,8 @@ auto PPU::step(uint clocks) -> void {
     if(io.ly == 261 && io.lx ==   0) io.nmiFlag = io.nmiHold;
     if(io.ly == 261 && io.lx ==   2) cpu.nmiLine(io.nmiEnable && io.nmiFlag);
 
-    clock += 4;
-    if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+    Thread::step(4);
+    synchronize(cpu);
 
     io.lx++;
   }
@@ -56,7 +56,7 @@ auto PPU::power() -> void {
 }
 
 auto PPU::reset() -> void {
-  create(PPU::Enter, 21'477'272);
+  create(PPU::Enter, system.colorburst() * 6.0);
 
   memory::fill(&io, sizeof(IO));
   memory::fill(&latch, sizeof(Latches));

higan/fc/scheduler/scheduler.cpp

@@ -1,44 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-Scheduler scheduler;
-
-auto Scheduler::reset() -> void {
-  host = co_active();
-  resume = cpu.thread;
-}
-
-auto Scheduler::enter(Mode mode_) -> Event {
-  mode = mode_;
-  host = co_active();
-  co_switch(resume);
-  if(event == Event::Frame) ppu.refresh();
-  return event;
-}
-
-auto Scheduler::exit(Event event_) -> void {
-  event = event_;
-  resume = co_active();
-  co_switch(host);
-}
-
-auto Scheduler::synchronize(cothread_t thread) -> void {
-  if(thread == cpu.thread) {
-    while(enter(Mode::SynchronizeCPU) != Event::Synchronize);
-  } else {
-    resume = thread;
-    while(enter(Mode::SynchronizeAll) != Event::Synchronize);
-  }
-}
-
-auto Scheduler::synchronize() -> void {
-  if(co_active() == cpu.thread && mode == Mode::SynchronizeCPU) return exit(Event::Synchronize);
-  if(co_active() != cpu.thread && mode == Mode::SynchronizeAll) return exit(Event::Synchronize);
-}
-
-auto Scheduler::synchronizing() const -> bool {
-  return mode == Mode::SynchronizeAll;
-}
-
-}

higan/fc/scheduler/scheduler.hpp

@@ -1,28 +0,0 @@
-struct Scheduler {
-  enum class Mode : uint {
-    Run,
-    SynchronizeCPU,
-    SynchronizeAll,
-  };
-
-  enum class Event : uint {
-    Unknown,
-    Frame,
-    Synchronize,
-  };
-
-  auto reset() -> void;
-  auto enter(Mode = Mode::Run) -> Event;
-  auto exit(Event) -> void;
-  auto synchronize(cothread_t) -> void;
-  auto synchronize() -> void;
-  auto synchronizing() const -> bool;
-
-private:
-  cothread_t host = nullptr;
-  cothread_t resume = nullptr;
-  Mode mode = Mode::Run;
-  Event event = Event::Unknown;
-};
-
-extern Scheduler scheduler;

higan/fc/system/system.cpp

@@ -6,30 +6,33 @@ namespace Famicom {
 #include "video.cpp"
 #include "serialization.cpp"
 System system;
+Scheduler scheduler;
+Cheat cheat;
 
 auto System::run() -> void {
-  scheduler.enter();
+  if(scheduler.enter() == Scheduler::Event::Frame) ppu.refresh();
 }
 
 auto System::runToSave() -> void {
-  scheduler.synchronize(cpu.thread);
-  scheduler.synchronize(apu.thread);
-  scheduler.synchronize(ppu.thread);
-  scheduler.synchronize(cartridge.thread);
-  for(auto peripheral : cpu.peripherals) {
-    scheduler.synchronize(peripheral->thread);
-  }
+  scheduler.synchronize(cpu);
+  scheduler.synchronize(apu);
+  scheduler.synchronize(ppu);
+  scheduler.synchronize(cartridge);
+  for(auto peripheral : cpu.peripherals) scheduler.synchronize(*peripheral);
 }
 
-auto System::load() -> bool {
+auto System::load(Emulator::Interface* interface) -> bool {
   information = Information();
-  if(auto fp = interface->open(ID::System, "manifest.bml", File::Read, File::Required)) {
+  if(auto fp = platform->open(ID::System, "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else {
     return false;
   }
   auto document = BML::unserialize(information.manifest);
   if(!cartridge.load()) return false;
+
+  this->interface = interface;
+  information.colorburst = Emulator::Constants::Colorburst::NTSC;
   serializeInit();
   return information.loaded = true;
 }
@@ -62,11 +65,12 @@ auto System::reset() -> void {
   Emulator::audio.reset();
   Emulator::audio.setInterface(interface);
 
+  scheduler.reset();
   cartridge.reset();
   cpu.reset();
   apu.reset();
   ppu.reset();
-  scheduler.reset();
+  scheduler.primary(cpu);
   peripherals.reset();
 }
 

higan/fc/system/system.hpp

@@ -1,10 +1,11 @@
 struct System {
   auto loaded() const -> bool { return information.loaded; }
+  auto colorburst() const -> double { return information.colorburst; }
 
   auto run() -> void;
   auto runToSave() -> void;
 
-  auto load() -> bool;
+  auto load(Emulator::Interface*) -> bool;
   auto save() -> void;
   auto unload() -> void;
   auto power() -> void;
@@ -25,12 +26,15 @@ struct System {
   auto serializeAll(serializer&) -> void;
   auto serializeInit() -> void;
 
+private:
+  Emulator::Interface* interface = nullptr;
+
   struct Information {
     bool loaded = false;
+    double colorburst = 0.0;
     string manifest;
   } information;
 
-private:
   uint _serializeSize = 0;
 };
 

higan/gb/GNUmakefile

@@ -1,16 +1,13 @@
 processors += lr35902
 
-objects += gb-interface gb-system gb-scheduler
+objects += gb-interface gb-system
 objects += gb-memory gb-cartridge
 objects += gb-cpu gb-ppu gb-apu
-objects += gb-cheat
 
 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/)

higan/gb/apu/apu.cpp

@@ -29,7 +29,7 @@ auto APU::main() -> void {
     stream->sample(sequencer.left / 32768.0, sequencer.right / 32768.0);
   } else {
     double samples[] = {sequencer.left / 32768.0, sequencer.right / 32768.0};
-    interface->audioSample(samples, 2);
+  //interface->audioSample(samples, 2);
   }
 
   if(cycle == 0) {  //512hz
@@ -51,8 +51,8 @@ auto APU::main() -> void {
   }
   cycle++;
 
-  clock += cpu.frequency;
-  if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+  Thread::step(1);
+  synchronize(cpu);
 }
 
 //filter to remove DC bias

higan/gb/cartridge/cartridge.cpp

@@ -19,23 +19,23 @@ auto Cartridge::load(System::Revision revision) -> bool {
 
   switch(revision) {
   case System::Revision::GameBoy:
-    if(auto pathID = interface->load(ID::GameBoy, "Game Boy", "gb")) {
+    if(auto pathID = platform->load(ID::GameBoy, "Game Boy", "gb")) {
       information.pathID = pathID();
     } else return false;
     break;
   case System::Revision::SuperGameBoy:
-    if(auto pathID = interface->load(ID::SuperGameBoy, "Game Boy", "gb")) {
+    if(auto pathID = platform->load(ID::SuperGameBoy, "Game Boy", "gb")) {
       information.pathID = pathID();
     } else return false;
     break;
   case System::Revision::GameBoyColor:
-    if(auto pathID = interface->load(ID::GameBoyColor, "Game Boy Color", "gbc")) {
+    if(auto pathID = platform->load(ID::GameBoyColor, "Game Boy Color", "gbc")) {
       information.pathID = pathID();
     } else return false;
     break;
   }
 
-  if(auto fp = interface->open(pathID(), "manifest.bml", File::Read, File::Required)) {
+  if(auto fp = platform->open(pathID(), "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else return false;
 
@@ -64,12 +64,12 @@ auto Cartridge::load(System::Revision revision) -> bool {
   ram.data = (uint8*)memory::allocate(ram.size, 0xff);
 
   if(auto name = board["rom/name"].text()) {
-    if(auto fp = interface->open(pathID(), name, File::Read, File::Required)) {
+    if(auto fp = platform->open(pathID(), name, File::Read, File::Required)) {
       fp->read(rom.data, min(rom.size, fp->size()));
     }
   }
   if(auto name = board["ram/name"].text()) {
-    if(auto fp = interface->open(pathID(), name, File::Read, File::Optional)) {
+    if(auto fp = platform->open(pathID(), name, File::Read, File::Optional)) {
       fp->read(ram.data, min(ram.size, fp->size()));
     }
   }
@@ -96,7 +96,7 @@ auto Cartridge::save() -> void {
   auto document = BML::unserialize(information.manifest);
 
   if(auto name = document["board/ram/name"].text()) {
-    if(auto fp = interface->open(pathID(), name, File::Write)) {
+    if(auto fp = platform->open(pathID(), name, File::Write)) {
       fp->write(ram.data, ram.size);
     }
   }

higan/gb/cheat/cheat.cpp

@@ -1,28 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-Cheat cheat;
-
-auto Cheat::reset() -> void {
-  codes.reset();
-}
-
-auto Cheat::append(uint addr, uint data) -> void {
-  codes.append({addr, Unused, data});
-}
-
-auto Cheat::append(uint addr, uint comp, uint data) -> void {
-  codes.append({addr, comp, data});
-}
-
-auto Cheat::find(uint addr, uint comp) -> maybe<uint> {
-  for(auto& code : codes) {
-    if(code.addr == addr && (code.comp == Unused || code.comp == comp)) {
-      return code.data;
-    }
-  }
-  return nothing;
-}
-
-}

higan/gb/cheat/cheat.hpp

@@ -1,18 +0,0 @@
-struct Cheat {
-  struct Code {
-    uint addr;
-    uint comp;
-    uint data;
-  };
-  vector<Code> codes;
-  enum : uint { Unused = ~0u };
-
-  alwaysinline auto enable() const -> bool { return codes.size() > 0; }
-
-  auto reset() -> void;
-  auto append(uint addr, uint data) -> void;
-  auto append(uint addr, uint comp, uint data) -> void;
-  auto find(uint addr, uint comp) -> maybe<uint>;
-};
-
-extern Cheat cheat;

higan/gb/cpu/cpu.cpp

@@ -77,8 +77,8 @@ auto CPU::stop() -> bool {
   if(status.speedSwitch) {
     status.speedSwitch = 0;
     status.speedDouble ^= 1;
-    if(status.speedDouble == 0) frequency = 4 * 1024 * 1024;
-    if(status.speedDouble == 1) frequency = 8 * 1024 * 1024;
+    if(status.speedDouble == 0) setFrequency(4 * 1024 * 1024);
+    if(status.speedDouble == 1) setFrequency(8 * 1024 * 1024);
     return true;
   }
   return false;

higan/gb/cpu/io.cpp

@@ -8,15 +8,15 @@ auto CPU::wramAddress(uint16 addr) const -> uint {
 auto CPU::joypPoll() -> void {
   uint button = 0, dpad = 0;
 
-  button |= interface->inputPoll(0, 0, (uint)Input::Start) << 3;
-  button |= interface->inputPoll(0, 0, (uint)Input::Select) << 2;
-  button |= interface->inputPoll(0, 0, (uint)Input::B) << 1;
-  button |= interface->inputPoll(0, 0, (uint)Input::A) << 0;
+  button |= platform->inputPoll(0, 0, (uint)Input::Start) << 3;
+  button |= platform->inputPoll(0, 0, (uint)Input::Select) << 2;
+  button |= platform->inputPoll(0, 0, (uint)Input::B) << 1;
+  button |= platform->inputPoll(0, 0, (uint)Input::A) << 0;
 
-  dpad |= interface->inputPoll(0, 0, (uint)Input::Down) << 3;
-  dpad |= interface->inputPoll(0, 0, (uint)Input::Up) << 2;
-  dpad |= interface->inputPoll(0, 0, (uint)Input::Left) << 1;
-  dpad |= interface->inputPoll(0, 0, (uint)Input::Right) << 0;
+  dpad |= platform->inputPoll(0, 0, (uint)Input::Down) << 3;
+  dpad |= platform->inputPoll(0, 0, (uint)Input::Up) << 2;
+  dpad |= platform->inputPoll(0, 0, (uint)Input::Left) << 1;
+  dpad |= platform->inputPoll(0, 0, (uint)Input::Right) << 0;
 
   if(system.revision() != System::Revision::SuperGameBoy) {
     //D-pad pivot makes it impossible to press opposing directions at the same time
@@ -145,7 +145,7 @@ auto CPU::writeIO(uint16 addr, uint8 data) -> void {
   if(addr == 0xff00) {  //JOYP
     status.p15 = data & 0x20;
     status.p14 = data & 0x10;
-    interface->joypWrite(status.p15, status.p14);
+  //interface->joypWrite(status.p15, status.p14);
     return;
   }
 

higan/gb/cpu/timing.cpp

@@ -16,11 +16,9 @@ auto CPU::step(uint clocks) -> void {
     if((status.div &  511) == 0)   timer8192hz();
     if((status.div & 1023) == 0)   timer4096hz();
 
-    ppu.clock -= ppu.frequency;
-    if(ppu.clock < 0) co_switch(ppu.thread);
-
-    apu.clock -= apu.frequency;
-    if(apu.clock < 0) co_switch(apu.thread);
+    Thread::step(1);
+    synchronize(ppu);
+    synchronize(apu);
   }
 
   if(system.sgb()) {

higan/gb/gb.hpp

@@ -4,41 +4,37 @@
 //started: 2010-12-27
 
 #include <emulator/emulator.hpp>
+#include <emulator/thread.hpp>
+#include <emulator/scheduler.hpp>
+#include <emulator/cheat.hpp>
+
 #include <processor/lr35902/lr35902.hpp>
 
 namespace GameBoy {
+  #define platform Emulator::platform
   using File = Emulator::File;
+  using Scheduler = Emulator::Scheduler;
+  using Cheat = Emulator::Cheat;
+  extern Scheduler scheduler;
+  extern Cheat cheat;
 
-  struct Thread {
-    ~Thread() {
-      if(thread) co_delete(thread);
+  struct Thread : Emulator::Thread {
+    auto create(auto (*entrypoint)() -> void, double frequency) -> void {
+      Emulator::Thread::create(entrypoint, frequency);
+      scheduler.append(*this);
     }
 
-    auto create(auto (*entrypoint)() -> void, uint frequency) -> void {
-      if(thread) co_delete(thread);
-      thread = co_create(65'536 * sizeof(void*), entrypoint);
-      this->frequency = frequency;
-      clock = 0;
+    inline auto synchronize(Thread& thread) -> void {
+      if(clock() >= thread.clock()) scheduler.resume(thread);
     }
-
-    auto serialize(serializer& s) -> void {
-      s.integer(frequency);
-      s.integer(clock);
-    }
-
-    cothread_t thread = nullptr;
-    uint frequency = 0;
-    int64 clock = 0;
   };
 
   #include <gb/memory/memory.hpp>
   #include <gb/system/system.hpp>
-  #include <gb/scheduler/scheduler.hpp>
   #include <gb/cartridge/cartridge.hpp>
   #include <gb/cpu/cpu.hpp>
   #include <gb/ppu/ppu.hpp>
   #include <gb/apu/apu.hpp>
-  #include <gb/cheat/cheat.hpp>
 }
 
 #include <gb/interface/interface.hpp>

higan/gb/interface/interface.cpp

@@ -2,19 +2,14 @@
 
 namespace GameBoy {
 
-Interface* interface = nullptr;
 Settings settings;
 
 Interface::Interface() {
-  interface = this;
   hook = nullptr;
 
   information.manufacturer = "Nintendo";
   information.name         = "Game Boy";
-  information.width        = 160;
-  information.height       = 144;
   information.overscan     = false;
-  information.aspectRatio  = 1.0;
   information.resettable   = false;
 
   information.capability.states = true;
@@ -48,6 +43,17 @@ auto Interface::title() -> string {
   return cartridge.title();
 }
 
+auto Interface::videoSize() -> VideoSize {
+  return {160, 144};
+}
+
+auto Interface::videoSize(uint width, uint height, bool arc) -> VideoSize {
+  uint w = 160;
+  uint h = 144;
+  uint m = min(width / w, height / h);
+  return {w * m, h * m};
+}
+
 auto Interface::videoFrequency() -> double {
   return 4194304.0 / (154.0 * 456.0);
 }
@@ -126,9 +132,9 @@ auto Interface::sha256() -> string {
 }
 
 auto Interface::load(uint id) -> bool {
-  if(id == ID::GameBoy) return system.load(System::Revision::GameBoy);
-  if(id == ID::SuperGameBoy) return system.load(System::Revision::SuperGameBoy);
-  if(id == ID::GameBoyColor) return system.load(System::Revision::GameBoyColor);
+  if(id == ID::GameBoy) return system.load(this, System::Revision::GameBoy);
+  if(id == ID::SuperGameBoy) return system.load(this, System::Revision::SuperGameBoy);
+  if(id == ID::GameBoyColor) return system.load(this, System::Revision::GameBoyColor);
   return false;
 }
 
@@ -163,15 +169,7 @@ auto Interface::unserialize(serializer& s) -> bool {
 }
 
 auto Interface::cheatSet(const string_vector& list) -> void {
-  cheat.reset();
-  for(auto& codeset : list) {
-    auto codes = codeset.split("+");
-    for(auto& code : codes) {
-      auto part = code.split("/");
-      if(part.size() == 2) cheat.append(part[0].hex(), part[1].hex());
-      if(part.size() == 3) cheat.append(part[0].hex(), part[1].hex(), part[2].hex());
-    }
-  }
+  cheat.assign(list);
 }
 
 auto Interface::lcdScanline() -> void {

higan/gb/interface/interface.hpp

@@ -24,9 +24,13 @@ struct Interface : Emulator::Interface {
 
   auto manifest() -> string override;
   auto title() -> string override;
+
+  auto videoSize() -> VideoSize override;
+  auto videoSize(uint width, uint height, bool arc) -> VideoSize override;
   auto videoFrequency() -> double override;
   auto videoColors() -> uint32 override;
   auto videoColor(uint32 color) -> uint64 override;
+
   auto audioFrequency() -> double override;
 
   auto loaded() -> bool override;
@@ -66,7 +70,6 @@ struct Settings {
   bool colorEmulation = true;
 };
 
-extern Interface* interface;
 extern Settings settings;
 
 }

higan/gb/memory/memory.cpp

@@ -38,7 +38,7 @@ auto Memory::free() -> void {
 auto Bus::read(uint16 addr) -> uint8 {
   uint8 data = mmio[addr]->readIO(addr);
 
-  if(cheat.enable()) {
+  if(cheat) {
     if(auto result = cheat.find(addr, data)) return result();
   }
 

higan/gb/ppu/dmg.cpp

@@ -78,7 +78,7 @@ auto PPU::runDMG() -> void {
 
   uint32* output = screen + status.ly * 160 + px++;
   *output = color;
-  interface->lcdOutput(color);  //Super Game Boy notification
+//interface->lcdOutput(color);  //Super Game Boy notification
 }
 
 auto PPU::runBackgroundDMG() -> void {

higan/gb/ppu/io.cpp

@@ -118,9 +118,9 @@ auto PPU::writeIO(uint16 addr, uint8 data) -> void {
       status.lx = 0;
 
       //restart cothread to begin new frame
-      auto clock = this->clock;
+      auto clock = Thread::clock();
       create(Enter, 4 * 1024 * 1024);
-      this->clock = clock;
+      Thread::setClock(clock);
     }
 
     status.displayEnable = data & 0x80;

higan/gb/ppu/ppu.cpp

@@ -16,7 +16,7 @@ auto PPU::Enter() -> void {
 
 auto PPU::main() -> void {
   status.lx = 0;
-  interface->lcdScanline();  //Super Game Boy notification
+//interface->lcdScanline();  //Super Game Boy notification
 
   if(status.ly <= 143) {
     mode(2);
@@ -94,8 +94,8 @@ auto PPU::step(uint clocks) -> void {
     }
 
     status.lx++;
-    clock += cpu.frequency;
-    if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+    Thread::step(1);
+    synchronize(cpu);
   }
 }
 

higan/gb/scheduler/scheduler.cpp

@@ -1,44 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-Scheduler scheduler;
-
-auto Scheduler::power() -> void {
-  host = co_active();
-  resume = cpu.thread;
-}
-
-auto Scheduler::enter(Mode mode_) -> Event {
-  mode = mode_;
-  host = co_active();
-  co_switch(resume);
-  if(event == Event::Frame) ppu.refresh();
-  return event;
-}
-
-auto Scheduler::exit(Event event_) -> void {
-  event = event_;
-  resume = co_active();
-  co_switch(host);
-}
-
-auto Scheduler::synchronize(cothread_t thread) -> void {
-  if(thread == cpu.thread) {
-    while(enter(Mode::SynchronizeCPU) != Event::Synchronize);
-  } else {
-    resume = thread;
-    while(enter(Mode::SynchronizeAll) != Event::Synchronize);
-  }
-}
-
-auto Scheduler::synchronize() -> void {
-  if(co_active() == cpu.thread && mode == Mode::SynchronizeCPU) return exit(Event::Synchronize);
-  if(co_active() != cpu.thread && mode == Mode::SynchronizeAll) return exit(Event::Synchronize);
-}
-
-auto Scheduler::synchronizing() const -> bool {
-  return mode == Mode::SynchronizeAll;
-}
-
-}

higan/gb/scheduler/scheduler.hpp

@@ -1,29 +0,0 @@
-struct Scheduler {
-  enum class Mode : uint {
-    Run,
-    SynchronizeCPU,
-    SynchronizeAll,
-  };
-
-  enum class Event : uint {
-    Unknown,
-    Step,
-    Frame,
-    Synchronize,
-  };
-
-  auto power() -> void;
-  auto enter(Mode = Mode::Run) -> Event;
-  auto exit(Event) -> void;
-  auto synchronize(cothread_t) -> void;
-  auto synchronize() -> void;
-  auto synchronizing() const -> bool;
-
-private:
-  cothread_t host = nullptr;
-  cothread_t resume = nullptr;
-  Mode mode = Mode::Run;
-  Event event = Event::Unknown;
-};
-
-extern Scheduler scheduler;

higan/gb/system/system.cpp

@@ -5,25 +5,27 @@ namespace GameBoy {
 #include "video.cpp"
 #include "serialization.cpp"
 System system;
+Scheduler scheduler;
+Cheat cheat;
 
 auto System::run() -> void {
-  scheduler.enter();
+  if(scheduler.enter() == Scheduler::Event::Frame) ppu.refresh();
 }
 
 auto System::runToSave() -> void {
-  scheduler.synchronize(cpu.thread);
-  scheduler.synchronize(ppu.thread);
-  scheduler.synchronize(apu.thread);
+  scheduler.synchronize(cpu);
+  scheduler.synchronize(ppu);
+  scheduler.synchronize(apu);
 }
 
 auto System::init() -> void {
   assert(interface != nullptr);
 }
 
-auto System::load(Revision revision) -> bool {
+auto System::load(Emulator::Interface* interface, Revision revision) -> bool {
   _revision = revision;
 
-  if(auto fp = interface->open(ID::System, "manifest.bml", File::Read, File::Required)) {
+  if(auto fp = platform->open(ID::System, "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else return false;
 
@@ -32,7 +34,7 @@ auto System::load(Revision revision) -> bool {
   if(revision == Revision::SuperGameBoy) path = "board/icd2/rom/name";
 
   if(auto name = document[path].text()) {
-    if(auto fp = interface->open(ID::System, name, File::Read, File::Required)) {
+    if(auto fp = platform->open(ID::System, name, File::Read, File::Required)) {
       if(revision == Revision::GameBoy) fp->read(bootROM.dmg, 256);
       if(revision == Revision::SuperGameBoy) fp->read(bootROM.sgb, 256);
       if(revision == Revision::GameBoyColor) fp->read(bootROM.cgb, 2048);
@@ -41,6 +43,7 @@ auto System::load(Revision revision) -> bool {
 
   if(!cartridge.load(revision)) return false;
   serializeInit();
+  this->interface = interface;
   return _loaded = true;
 }
 
@@ -66,12 +69,13 @@ auto System::power() -> void {
     Emulator::audio.setInterface(interface);
   }
 
+  scheduler.reset();
   bus.power();
   cartridge.power();
   cpu.power();
   ppu.power();
   apu.power();
-  scheduler.power();
+  scheduler.primary(cpu);
 
   _clocksExecuted = 0;
 }

higan/gb/system/system.hpp

@@ -1,5 +1,3 @@
-struct Interface;
-
 enum class Input : uint {
   Up, Down, Left, Right, B, A, Select, Start,
 };
@@ -23,7 +21,7 @@ struct System {
   auto runToSave() -> void;
 
   auto init() -> void;
-  auto load(Revision) -> bool;
+  auto load(Emulator::Interface*, Revision) -> bool;
   auto save() -> void;
   auto unload() -> void;
   auto power() -> void;
@@ -40,6 +38,8 @@ struct System {
   auto serializeAll(serializer&) -> void;
   auto serializeInit() -> void;
 
+  Emulator::Interface* interface = nullptr;
+
   struct BootROM {
     uint8 dmg[ 256];
     uint8 sgb[ 256];

higan/gba/GNUmakefile

@@ -1,12 +1,11 @@
 processors += arm
 
-objects += gba-memory gba-interface gba-scheduler gba-system
+objects += gba-memory gba-interface gba-system
 objects += gba-cartridge gba-player
 objects += gba-cpu gba-ppu gba-apu
 
 obj/gba-memory.o:    gba/memory/memory.cpp $(call rwildcard,gba/memory)
 obj/gba-interface.o: gba/interface/interface.cpp $(call rwildcard,gba/interface)
-obj/gba-scheduler.o: gba/scheduler/scheduler.cpp $(call rwildcard,gba/scheduler)
 obj/gba-system.o:    gba/system/system.cpp $(call rwildcard,gba/system)
 obj/gba-cartridge.o: gba/cartridge/cartridge.cpp $(call rwildcard,gba/cartridge)
 obj/gba-player.o:    gba/player/player.cpp $(call rwildcard,gba/player)

higan/gba/apu/apu.cpp

@@ -68,8 +68,8 @@ auto APU::main() -> void {
 }
 
 auto APU::step(uint clocks) -> void {
-  clock += clocks;
-  if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+  Thread::step(clocks);
+  synchronize(cpu);
 }
 
 auto APU::power() -> void {

higan/gba/cartridge/cartridge.cpp

@@ -26,11 +26,11 @@ Cartridge::~Cartridge() {
 auto Cartridge::load() -> bool {
   information = Information();
 
-  if(auto pathID = interface->load(ID::GameBoyAdvance, "Game Boy Advance", "gba")) {
+  if(auto pathID = platform->load(ID::GameBoyAdvance, "Game Boy Advance", "gba")) {
     information.pathID = pathID();
   } else return false;
 
-  if(auto fp = interface->open(pathID(), "manifest.bml", File::Read, File::Required)) {
+  if(auto fp = platform->open(pathID(), "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else return false;
 
@@ -43,7 +43,7 @@ auto Cartridge::load() -> bool {
 
   if(auto node = document["board/rom"]) {
     mrom.size = min(32 * 1024 * 1024, node["size"].natural());
-    if(auto fp = interface->open(pathID(), node["name"].text(), File::Read, File::Required)) {
+    if(auto fp = platform->open(pathID(), node["name"].text(), File::Read, File::Required)) {
       fp->read(mrom.data, mrom.size);
     }
   }
@@ -55,7 +55,7 @@ auto Cartridge::load() -> bool {
       sram.mask = sram.size - 1;
       for(auto n : range(sram.size)) sram.data[n] = 0xff;
 
-      if(auto fp = interface->open(pathID(), node["name"].text(), File::Read)) {
+      if(auto fp = platform->open(pathID(), node["name"].text(), File::Read)) {
         fp->read(sram.data, sram.size);
       }
     }
@@ -69,7 +69,7 @@ auto Cartridge::load() -> bool {
       eeprom.test = mrom.size > 16 * 1024 * 1024 ? 0x0dffff00 : 0x0d000000;
       for(auto n : range(eeprom.size)) eeprom.data[n] = 0xff;
 
-      if(auto fp = interface->open(pathID(), node["name"].text(), File::Read)) {
+      if(auto fp = platform->open(pathID(), node["name"].text(), File::Read)) {
         fp->read(eeprom.data, eeprom.size);
       }
     }
@@ -85,7 +85,7 @@ auto Cartridge::load() -> bool {
       if(!flash.id && flash.size ==  64 * 1024) flash.id = 0x1cc2;
       if(!flash.id && flash.size == 128 * 1024) flash.id = 0x09c2;
 
-      if(auto fp = interface->open(pathID(), node["name"].text(), File::Read)) {
+      if(auto fp = platform->open(pathID(), node["name"].text(), File::Read)) {
         fp->read(flash.data, flash.size);
       }
     }
@@ -98,7 +98,7 @@ auto Cartridge::load() -> bool {
 auto Cartridge::save() -> void {
   auto document = BML::unserialize(information.manifest);
   if(auto node = document["board/ram"]) {
-    if(auto fp = interface->open(pathID(), node["name"].text(), File::Write)) {
+    if(auto fp = platform->open(pathID(), node["name"].text(), File::Write)) {
       if(node["type"].text() == "sram") fp->write(sram.data, sram.size);
       if(node["type"].text() == "eeprom") fp->write(eeprom.data, eeprom.size);
       if(node["type"].text() == "flash") fp->write(flash.data, flash.size);

higan/gba/cpu/cpu.cpp

@@ -83,11 +83,9 @@ auto CPU::step(uint clocks) -> void {
 }
 
 auto CPU::syncStep(uint clocks) -> void {
-  ppu.clock -= clocks;
-  if(ppu.clock < 0) co_switch(ppu.thread);
-
-  apu.clock -= clocks;
-  if(apu.clock < 0) co_switch(apu.thread);
+  Thread::step(clocks);
+  synchronize(ppu);
+  synchronize(apu);
 }
 
 auto CPU::keypadRun() -> void {
@@ -99,7 +97,7 @@ auto CPU::keypadRun() -> void {
   bool test = regs.keypad.control.condition;  //0 = OR, 1 = AND
   for(auto n : range(10)) {
     if(!regs.keypad.control.flag[n]) continue;
-    bool input = interface->inputPoll(0, 0, lookup[n]);
+    bool input = platform->inputPoll(0, 0, lookup[n]);
     if(regs.keypad.control.condition == 0) test |= input;
     if(regs.keypad.control.condition == 1) test &= input;
   }
@@ -150,7 +148,7 @@ auto CPU::power() -> void {
   for(auto& swait : regs.wait.control.swait) swait = 0;
   regs.wait.control.phi = 0;
   regs.wait.control.prefetch = 0;
-  regs.wait.control.gametype = 0;
+  regs.wait.control.gametype = 0;  //0 = GBA, 1 = GBC
   regs.postboot = 0;
   regs.mode = Registers::Mode::Normal;
   regs.clock = 0;

higan/gba/cpu/io.cpp

@@ -64,7 +64,7 @@ auto CPU::readIO(uint32 addr) -> uint8 {
     static const uint lookup[] = {5, 4, 8, 9, 3, 2, 0, 1};
     if(auto result = player.keyinput()) return result() >> 0;
     uint8 result = 0;
-    for(uint n = 0; n < 8; n++) result |= interface->inputPoll(0, 0, lookup[n]) << n;
+    for(uint n = 0; n < 8; n++) result |= platform->inputPoll(0, 0, lookup[n]) << n;
     if((result & 0xc0) == 0xc0) result &= (uint8)~0xc0;  //up+down cannot be pressed simultaneously
     if((result & 0x30) == 0x30) result &= (uint8)~0x30;  //left+right cannot be pressed simultaneously
     return result ^ 0xff;
@@ -72,8 +72,8 @@ auto CPU::readIO(uint32 addr) -> uint8 {
   case 0x04000131: {
     if(auto result = player.keyinput()) return result() >> 8;
     uint8 result = 0;
-    result |= interface->inputPoll(0, 0, 7) << 0;
-    result |= interface->inputPoll(0, 0, 6) << 1;
+    result |= platform->inputPoll(0, 0, 7) << 0;
+    result |= platform->inputPoll(0, 0, 6) << 1;
     return result ^ 0x03;
   }
 
@@ -383,7 +383,7 @@ auto CPU::writeIO(uint32 addr, uint8 data) -> void {
     regs.wait.control.swait[2] = data.bit (2);
     regs.wait.control.phi      = data.bit (3);
     regs.wait.control.prefetch = data.bit (6);
-    regs.wait.control.gametype = data.bit (7);
+  //regs.wait.control.gametype is read-only
     return;
 
   //IME

higan/gba/gba.hpp

@@ -4,10 +4,16 @@
 //started: 2012-03-19
 
 #include <emulator/emulator.hpp>
+#include <emulator/thread.hpp>
+#include <emulator/scheduler.hpp>
+
 #include <processor/arm/arm.hpp>
 
 namespace GameBoyAdvance {
+  #define platform Emulator::platform
   using File = Emulator::File;
+  using Scheduler = Emulator::Scheduler;
+  extern Scheduler scheduler;
 
   enum : uint {           //mode flags for bus read, write:
     Nonsequential =   1,  //N cycle
@@ -21,30 +27,22 @@ namespace GameBoyAdvance {
     Signed        = 256,  //sign extended
   };
 
-  struct Thread {
-    ~Thread() {
-      if(thread) co_delete(thread);
+  struct Thread : Emulator::Thread {
+    auto create(auto (*entrypoint)() -> void, double frequency) -> void {
+      Emulator::Thread::create(entrypoint, frequency);
+      scheduler.append(*this);
     }
 
-    auto create(auto (*entrypoint)() -> void, uint frequency) -> void {
-      if(thread) co_delete(thread);
-      thread = co_create(65'536 * sizeof(void*), entrypoint);
-      this->frequency = frequency;
-      clock = 0;
+    inline auto synchronize(Thread& thread) -> void {
+      if(clock() >= thread.clock()) scheduler.resume(thread);
     }
 
-    auto serialize(serializer& s) -> void {
-      s.integer(frequency);
-      s.integer(clock);
+    inline auto step(uint clocks) -> void {
+      _clock += clocks;
     }
-
-    cothread_t thread = nullptr;
-    uint frequency = 0;
-    int clock = 0;
   };
 
   #include <gba/memory/memory.hpp>
-  #include <gba/scheduler/scheduler.hpp>
   #include <gba/system/system.hpp>
   #include <gba/cartridge/cartridge.hpp>
   #include <gba/player/player.hpp>

higan/gba/interface/interface.cpp

@@ -2,18 +2,12 @@
 
 namespace GameBoyAdvance {
 
-Interface* interface = nullptr;
 Settings settings;
 
 Interface::Interface() {
-  interface = this;
-
   information.manufacturer = "Nintendo";
   information.name         = "Game Boy Advance";
-  information.width        = 240;
-  information.height       = 160;
   information.overscan     = false;
-  information.aspectRatio  = 1.0;
   information.resettable   = false;
 
   information.capability.states = true;
@@ -49,6 +43,17 @@ auto Interface::title() -> string {
   return cartridge.title();
 }
 
+auto Interface::videoSize() -> VideoSize {
+  return {240, 160};
+}
+
+auto Interface::videoSize(uint width, uint height, bool arc) -> VideoSize {
+  uint w = 240;
+  uint h = 160;
+  uint m = min(width / w, height / h);
+  return {w * m, h * m};
+}
+
 auto Interface::videoFrequency() -> double {
   return 16777216.0 / (228.0 * 1232.0);
 }
@@ -88,7 +93,7 @@ auto Interface::loaded() -> bool {
 }
 
 auto Interface::load(uint id) -> bool {
-  return system.load();
+  return system.load(this);
 }
 
 auto Interface::save() -> void {

higan/gba/interface/interface.hpp

@@ -22,9 +22,13 @@ struct Interface : Emulator::Interface {
 
   auto manifest() -> string override;
   auto title() -> string override;
+
+  auto videoSize() -> VideoSize override;
+  auto videoSize(uint width, uint height, bool arc) -> VideoSize override;
   auto videoFrequency() -> double override;
   auto videoColors() -> uint32 override;
   auto videoColor(uint32 color) -> uint64 override;
+
   auto audioFrequency() -> double override;
 
   auto loaded() -> bool override;
@@ -49,7 +53,6 @@ struct Settings {
   bool colorEmulation = true;
 };
 
-extern Interface* interface;
 extern Settings settings;
 
 }

higan/gba/player/player.cpp

@@ -100,7 +100,7 @@ auto Player::write(uint2 addr, uint8 byte) -> void {
 
   if(addr == 3 && status.packet == 15) {
     status.rumble = (status.recv & 0xff) == 0x26;  //on = 0x26, off = 0x04
-    interface->inputRumble(0, 0, 10, status.rumble);
+    platform->inputRumble(0, 0, 10, status.rumble);
   }
 }
 

higan/gba/ppu/ppu.cpp

@@ -43,8 +43,8 @@ auto PPU::main() -> void {
 }
 
 auto PPU::step(uint clocks) -> void {
-  clock += clocks;
-  if(clock >= 0 && !scheduler.synchronizing()) co_switch(cpu.thread);
+  Thread::step(clocks);
+  synchronize(cpu);
 }
 
 auto PPU::power() -> void {

higan/gba/scheduler/scheduler.cpp

@@ -1,44 +0,0 @@
-#include <gba/gba.hpp>
-
-namespace GameBoyAdvance {
-
-Scheduler scheduler;
-
-auto Scheduler::power() -> void {
-  host = co_active();
-  resume = cpu.thread;
-}
-
-auto Scheduler::enter(Mode mode_) -> Event {
-  mode = mode_;
-  host = co_active();
-  co_switch(resume);
-  if(event == Event::Frame) ppu.refresh();
-  return event;
-}
-
-auto Scheduler::exit(Event event_) -> void {
-  event = event_;
-  resume = co_active();
-  co_switch(host);
-}
-
-auto Scheduler::synchronize(cothread_t thread) -> void {
-  if(thread == cpu.thread) {
-    while(enter(Mode::SynchronizeCPU) != Event::Synchronize);
-  } else {
-    resume = thread;
-    while(enter(Mode::SynchronizeAll) != Event::Synchronize);
-  }
-}
-
-auto Scheduler::synchronize() -> void {
-  if(co_active() == cpu.thread && mode == Mode::SynchronizeCPU) return exit(Event::Synchronize);
-  if(co_active() != cpu.thread && mode == Mode::SynchronizeAll) return exit(Event::Synchronize);
-}
-
-auto Scheduler::synchronizing() const -> bool {
-  return mode == Mode::SynchronizeAll;
-}
-
-}

higan/gba/scheduler/scheduler.hpp

@@ -1,28 +0,0 @@
-struct Scheduler {
-  enum class Mode : uint {
-    Run,
-    SynchronizeCPU,
-    SynchronizeAll,
-  };
-
-  enum class Event : uint {
-    Unknown,
-    Frame,
-    Synchronize,
-  };
-
-  auto power() -> void;
-  auto enter(Mode = Mode::Run) -> Event;
-  auto exit(Event) -> void;
-  auto synchronize(cothread_t) -> void;
-  auto synchronize() -> void;
-  auto synchronizing() const -> bool;
-
-private:
-  cothread_t host = nullptr;
-  cothread_t resume = nullptr;
-  Mode mode = Mode::Run;
-  Event event = Event::Unknown;
-};
-
-extern Scheduler scheduler;

higan/gba/system/system.cpp

@@ -7,6 +7,7 @@ namespace GameBoyAdvance {
 #include "serialization.cpp"
 BIOS bios;
 System system;
+Scheduler scheduler;
 
 auto System::init() -> void {
 }
@@ -23,29 +24,33 @@ auto System::power() -> void {
   Emulator::audio.reset();
   Emulator::audio.setInterface(interface);
 
+  scheduler.reset();
   bus.power();
   player.power();
   cpu.power();
   ppu.power();
   apu.power();
   cartridge.power();
-  scheduler.power();
+  scheduler.primary(cpu);
 }
 
-auto System::load() -> bool {
-  if(auto fp = interface->open(ID::System, "manifest.bml", File::Read, File::Required)) {
+auto System::load(Emulator::Interface* interface) -> bool {
+  if(auto fp = platform->open(ID::System, "manifest.bml", File::Read, File::Required)) {
     information.manifest = fp->reads();
   } else return false;
+
   auto document = BML::unserialize(information.manifest);
 
   if(auto name = document["system/cpu/rom/name"].text()) {
-    if(auto fp = interface->open(ID::System, name, File::Read, File::Required)) {
+    if(auto fp = platform->open(ID::System, name, File::Read, File::Required)) {
       fp->read(bios.data, bios.size);
     }
   }
 
   if(!cartridge.load()) return false;
+
   serializeInit();
+  this->interface = interface;
   return _loaded = true;
 }
 
@@ -61,13 +66,13 @@ auto System::unload() -> void {
 }
 
 auto System::run() -> void {
-  while(scheduler.enter() != Scheduler::Event::Frame);
+  if(scheduler.enter() == Scheduler::Event::Frame) ppu.refresh();
 }
 
 auto System::runToSave() -> void {
-  scheduler.synchronize(cpu.thread);
-  scheduler.synchronize(ppu.thread);
-  scheduler.synchronize(apu.thread);
+  scheduler.synchronize(cpu);
+  scheduler.synchronize(ppu);
+  scheduler.synchronize(apu);
 }
 
 }

higan/gba/system/system.hpp

@@ -19,7 +19,7 @@ struct System {
 
   auto init() -> void;
   auto term() -> void;
-  auto load() -> bool;
+  auto load(Emulator::Interface*) -> bool;
   auto save() -> void;
   auto unload() -> void;
   auto power() -> void;
@@ -38,6 +38,9 @@ struct System {
   auto serializeAll(serializer&) -> void;
   auto serializeInit() -> void;
 
+private:
+  Emulator::Interface* interface = nullptr;
+
   struct Information {
     string manifest;
   } information;

higan/md/GNUmakefile

@@ -0,0 +1,17 @@
+processors += m68k z80
+
+objects += md-interface
+objects += md-cpu md-apu md-vdp md-psg md-ym2612
+objects += md-system md-cartridge md-bus
+objects += md-controller
+
+obj/md-interface.o:  md/interface/interface.cpp $(call rwildcard,md/interface)
+obj/md-cpu.o:        md/cpu/cpu.cpp $(call rwildcard,md/cpu)
+obj/md-apu.o:        md/apu/apu.cpp $(call rwildcard,md/apu)
+obj/md-vdp.o:        md/vdp/vdp.cpp $(call rwildcard,md/vdp)
+obj/md-psg.o:        md/psg/psg.cpp $(call rwildcard,md/psg)
+obj/md-ym2612.o:     md/ym2612/ym2612.cpp $(call rwildcard,md/ym2612)
+obj/md-system.o:     md/system/system.cpp $(call rwildcard,md/system)
+obj/md-cartridge.o:  md/cartridge/cartridge.cpp $(call rwildcard,md/cartridge)
+obj/md-bus.o:        md/bus/bus.cpp $(call rwildcard,md/bus)
+obj/md-controller.o: md/controller/controller.cpp $(call rwildcard,md/controller)

higan/md/apu/apu.cpp

@@ -0,0 +1,26 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+APU apu;
+
+auto APU::Enter() -> void {
+  while(true) scheduler.synchronize(), apu.main();
+}
+
+auto APU::main() -> void {
+  step(1);
+}
+
+auto APU::step(uint clocks) -> void {
+  Thread::step(clocks);
+  synchronize(cpu);
+}
+
+auto APU::power() -> void {
+  Z80::bus = &busAPU;
+  Z80::power();
+  create(APU::Enter, system.colorburst());
+}
+
+}

higan/md/apu/apu.hpp

@@ -0,0 +1,11 @@
+//Zilog Z80
+
+struct APU : Processor::Z80, Thread {
+  static auto Enter() -> void;
+  auto main() -> void;
+  auto step(uint clocks) -> void;
+
+  auto power() -> void;
+};
+
+extern APU apu;

higan/md/bus/bus.cpp

@@ -0,0 +1,94 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+BusCPU busCPU;
+BusAPU busAPU;
+
+auto BusCPU::readByte(uint24 addr) -> uint16 {
+  if(addr < 0x400000) return cartridge.read(addr & ~1).byte(!addr.bit(0));
+  if(addr < 0xa00000) return 0x0000;
+  if(addr < 0xa10000) return 0x0000;
+  if(addr < 0xa10020) return readIO(addr);
+  if(addr < 0xc00000) return 0x0000;
+  if(addr < 0xe00000) return vdp.read(addr & ~1).byte(!addr.bit(0));
+  return ram[addr & 0xffff];
+}
+
+auto BusCPU::readWord(uint24 addr) -> uint16 {
+  if(addr < 0x400000) return cartridge.read(addr);
+  if(addr < 0xa00000) return 0x0000;
+  if(addr < 0xa10000) return 0x0000;
+  if(addr < 0xa10020) return readIO(addr);
+  if(addr < 0xc00000) return 0x0000;
+  if(addr < 0xe00000) return vdp.read(addr);
+  uint16 data = ram[addr + 0 & 0xffff] << 8;
+  return data | ram[addr + 1 & 0xffff] << 0;
+}
+
+auto BusCPU::writeByte(uint24 addr, uint16 data) -> void {
+  if(addr < 0x400000) return cartridge.write(addr & ~1, data << 8 | data << 0);
+  if(addr < 0xa00000) return;
+  if(addr < 0xa10000) return;
+  if(addr < 0xa10020) return writeIO(addr, data);
+  if(addr < 0xc00000) return;
+  if(addr < 0xe00000) return vdp.write(addr & ~1, data << 8 | data << 0);
+  ram[addr & 0xffff] = data;
+}
+
+auto BusCPU::writeWord(uint24 addr, uint16 data) -> void {
+  if(addr < 0x400000) return cartridge.write(addr, data);
+  if(addr < 0xa00000) return;
+  if(addr < 0xa10000) return;
+  if(addr < 0xa10020) return writeIO(addr, data);
+  if(addr < 0xc00000) return;
+  if(addr < 0xe00000) return vdp.write(addr, data);
+  ram[addr + 0 & 0xffff] = data >> 8;
+  ram[addr + 1 & 0xffff] = data >> 0;
+}
+
+//
+
+auto BusCPU::readIO(uint24 addr) -> uint16 {
+  switch(addr & ~1) {
+  case 0xa10002: return peripherals.controllerPort1->readData();
+  case 0xa10004: return peripherals.controllerPort2->readData();
+  case 0xa10006: return peripherals.extensionPort->readData();
+
+  case 0xa10008: return peripherals.controllerPort1->readControl();
+  case 0xa1000a: return peripherals.controllerPort2->readControl();
+  case 0xa1000c: return peripherals.extensionPort->readControl();
+  }
+
+  return 0x0000;
+}
+
+auto BusCPU::writeIO(uint24 addr, uint16 data) -> void {
+  switch(addr & ~1) {
+  case 0xa10002: return peripherals.controllerPort1->writeData(data);
+  case 0xa10004: return peripherals.controllerPort2->writeData(data);
+  case 0xa10006: return peripherals.extensionPort->writeData(data);
+
+  case 0xa10008: return peripherals.controllerPort1->writeControl(data);
+  case 0xa1000a: return peripherals.controllerPort2->writeControl(data);
+  case 0xa1000c: return peripherals.extensionPort->writeControl(data);
+  }
+}
+
+//
+
+auto BusAPU::read(uint16 addr) -> uint8 {
+  return 0x00;
+}
+
+auto BusAPU::write(uint16 addr, uint8 data) -> void {
+}
+
+auto BusAPU::in(uint8 addr) -> uint8 {
+  return 0x00;
+}
+
+auto BusAPU::out(uint8 addr, uint8 data) -> void {
+}
+
+}

higan/md/bus/bus.hpp

@@ -0,0 +1,22 @@
+struct BusCPU : Processor::M68K::Bus {
+  auto readByte(uint24 addr) -> uint16 override;
+  auto readWord(uint24 addr) -> uint16 override;
+  auto writeByte(uint24 addr, uint16 data) -> void override;
+  auto writeWord(uint24 addr, uint16 data) -> void override;
+
+  auto readIO(uint24 addr) -> uint16;
+  auto writeIO(uint24 addr, uint16 data) -> void;
+
+private:
+  uint8 ram[64 * 1024];
+};
+
+struct BusAPU : Processor::Z80::Bus {
+  auto read(uint16 addr) -> uint8 override;
+  auto write(uint16 addr, uint8 data) -> void override;
+  auto in(uint8 addr) -> uint8 override;
+  auto out(uint8 addr, uint8 data) -> void override;
+};
+
+extern BusCPU busCPU;
+extern BusAPU busAPU;

higan/md/cartridge/cartridge.cpp

@@ -0,0 +1,81 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+Cartridge cartridge;
+
+auto Cartridge::load() -> bool {
+  information = {};
+
+  if(auto pathID = platform->load(ID::MegaDrive, "Mega Drive", "md")) {
+    information.pathID = pathID();
+  } else return false;
+
+  if(auto fp = platform->open(pathID(), "manifest.bml", File::Read, File::Required)) {
+    information.manifest = fp->reads();
+  } else return false;
+
+  auto document = BML::unserialize(information.manifest);
+  information.title = document["information/title"].text();
+
+  if(auto node = document["board/rom"]) {
+    rom.size = node["size"].natural();
+    rom.mask = bit::round(rom.size) - 1;
+    if(rom.size) {
+      rom.data = new uint8[rom.mask + 1];
+      if(auto name = node["name"].text()) {
+        if(auto fp = platform->open(pathID(), name, File::Read, File::Required)) {
+          fp->read(rom.data, rom.size);
+        }
+      }
+    }
+  }
+
+  if(auto node = document["board/ram"]) {
+    ram.size = node["size"].natural();
+    ram.mask = bit::round(ram.size) - 1;
+    if(ram.size) {
+      ram.data = new uint8[ram.mask + 1];
+      if(auto name = node["name"].text()) {
+        if(auto fp = platform->open(pathID(), name, File::Read)) {
+          fp->read(ram.data, ram.size);
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+auto Cartridge::save() -> void {
+  auto document = BML::unserialize(information.manifest);
+
+  if(auto name = document["board/ram/name"].text()) {
+    if(auto fp = platform->open(pathID(), name, File::Write)) {
+      fp->write(ram.data, ram.size);
+    }
+  }
+}
+
+auto Cartridge::unload() -> void {
+  delete[] rom.data;
+  delete[] ram.data;
+  rom = Memory();
+  ram = Memory();
+}
+
+auto Cartridge::power() -> void {
+}
+
+auto Cartridge::reset() -> void {
+}
+
+auto Cartridge::read(uint24 addr) -> uint16 {
+  uint16 data = rom.data[addr + 0 & rom.mask] << 8;
+  return data | rom.data[addr + 1 & rom.mask] << 0;
+}
+
+auto Cartridge::write(uint24 addr, uint16 data) -> void {
+}
+
+}

higan/md/cartridge/cartridge.hpp

@@ -0,0 +1,33 @@
+struct Cartridge {
+  auto pathID() const -> uint { return information.pathID; }
+  auto sha256() const -> string { return information.sha256; }
+  auto manifest() const -> string { return information.manifest; }
+  auto title() const -> string { return information.title; }
+
+  auto load() -> bool;
+  auto save() -> void;
+  auto unload() -> void;
+  auto power() -> void;
+  auto reset() -> void;
+
+  auto read(uint24 addr) -> uint16;
+  auto write(uint24 addr, uint16 data) -> void;
+
+  struct Information {
+    uint pathID = 0;
+    string sha256;
+    string manifest;
+    string title;
+  } information;
+
+  struct Memory {
+    uint8* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+  };
+
+  Memory rom;
+  Memory ram;
+};
+
+extern Cartridge cartridge;

higan/md/controller/controller.cpp

@@ -0,0 +1,28 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+#include "gamepad/gamepad.cpp"
+
+Controller::Controller(uint port) : port(port) {
+  if(!handle()) create(Controller::Enter, 100);
+}
+
+Controller::~Controller() {
+}
+
+auto Controller::Enter() -> void {
+  while(true) {
+    scheduler.synchronize();
+    if(peripherals.controllerPort1->active()) peripherals.controllerPort1->main();
+    if(peripherals.controllerPort2->active()) peripherals.controllerPort2->main();
+    if(peripherals.extensionPort->active())   peripherals.extensionPort->main();
+  }
+}
+
+auto Controller::main() -> void {
+  step(1);
+  synchronize(cpu);
+}
+
+}

higan/md/controller/controller.hpp

@@ -0,0 +1,17 @@
+struct Controller : Thread {
+  Controller(uint port);
+  virtual ~Controller();
+
+  static auto Enter() -> void;
+  auto main() -> void;
+
+  virtual auto readData() -> uint8 { return 0xff; }
+  virtual auto writeData(uint8 data) -> void {}
+
+  virtual auto readControl() -> uint8 { return 0x00; }
+  virtual auto writeControl(uint8 data) -> void {}
+
+  const uint port;
+};
+
+#include "gamepad/gamepad.hpp"

higan/md/controller/gamepad/gamepad.cpp

@@ -0,0 +1,30 @@
+Gamepad::Gamepad(uint port) : Controller(port) {
+}
+
+auto Gamepad::readData() -> uint8 {
+  uint6 data;
+
+  if(select == 0) {
+    data.bit(0) = platform->inputPoll(port, ID::Device::Gamepad, Up);
+    data.bit(1) = platform->inputPoll(port, ID::Device::Gamepad, Down);
+    data.bit(2) = 1;
+    data.bit(3) = 1;
+    data.bit(4) = platform->inputPoll(port, ID::Device::Gamepad, A);
+    data.bit(5) = platform->inputPoll(port, ID::Device::Gamepad, Start);
+  } else {
+    data.bit(0) = platform->inputPoll(port, ID::Device::Gamepad, Up);
+    data.bit(1) = platform->inputPoll(port, ID::Device::Gamepad, Down);
+    data.bit(2) = platform->inputPoll(port, ID::Device::Gamepad, Left);
+    data.bit(3) = platform->inputPoll(port, ID::Device::Gamepad, Right);
+    data.bit(4) = platform->inputPoll(port, ID::Device::Gamepad, B);
+    data.bit(5) = platform->inputPoll(port, ID::Device::Gamepad, C);
+  }
+
+  data = ~data;
+  return latch << 7 | select << 6 | data;
+}
+
+auto Gamepad::writeData(uint8 data) -> void {
+  select = data.bit(6);
+  latch  = data.bit(7);
+}

higan/md/controller/gamepad/gamepad.hpp

@@ -0,0 +1,13 @@
+struct Gamepad : Controller {
+  enum : uint {
+    Up, Down, Left, Right, A, B, C, X, Y, Z, Start,
+  };
+
+  Gamepad(uint port);
+
+  auto readData() -> uint8 override;
+  auto writeData(uint8 data) -> void override;
+
+  boolean select;
+  boolean latch;
+};

higan/md/cpu/cpu.cpp

@@ -0,0 +1,85 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+CPU cpu;
+
+auto CPU::Enter() -> void {
+  cpu.boot();
+  while(true) scheduler.synchronize(), cpu.main();
+}
+
+auto CPU::boot() -> void {
+  r.a[7] = bus->readWord(0) << 16 | bus->readWord(2) << 0;
+  r.pc   = bus->readWord(4) << 16 | bus->readWord(6) << 0;
+}
+
+auto CPU::main() -> void {
+  #if 0
+  static file fp;
+  if(!fp) fp.open({Path::user(), "Desktop/tracer.log"}, file::mode::write);
+  fp.print(pad(disassemble(r.pc), -60, ' '), " ", disassembleRegisters().replace("\n", " "), "\n");
+  #endif
+
+  if(state.interruptPending) {
+    if(state.interruptPending.bit((uint)Interrupt::HorizontalBlank)) {
+      if(4 > r.i) {
+        state.interruptPending.bit((uint)Interrupt::HorizontalBlank) = 0;
+        return exception(Exception::Interrupt, Vector::HorizontalBlank, 4);
+      }
+    }
+
+    if(state.interruptPending.bit((uint)Interrupt::VerticalBlank)) {
+      if(6 > r.i) {
+        state.interruptPending.bit((uint)Interrupt::VerticalBlank) = 0;
+        return exception(Exception::Interrupt, Vector::VerticalBlank, 6);
+      }
+    }
+  }
+
+  instruction();
+}
+
+auto CPU::step(uint clocks) -> void {
+  while(wait) {
+    Thread::step(1);
+    synchronize();
+  }
+
+  Thread::step(clocks);
+  synchronize();
+}
+
+auto CPU::synchronize() -> void {
+  synchronize(apu);
+  synchronize(vdp);
+  synchronize(psg);
+  synchronize(ym2612);
+  for(auto peripheral : peripherals) synchronize(*peripheral);
+}
+
+auto CPU::raise(Interrupt interrupt) -> void {
+  if(!state.interruptLine.bit((uint)interrupt)) {
+    state.interruptLine.bit((uint)interrupt) = 1;
+    state.interruptPending.bit((uint)interrupt) = 1;
+  }
+}
+
+auto CPU::lower(Interrupt interrupt) -> void {
+  state.interruptLine.bit((uint)interrupt) = 0;
+  state.interruptPending.bit((uint)interrupt) = 0;
+}
+
+auto CPU::power() -> void {
+  M68K::bus = &busCPU;
+  M68K::power();
+}
+
+auto CPU::reset() -> void {
+  M68K::reset();
+  create(CPU::Enter, system.colorburst() * 15.0 / 7.0);
+
+  memory::fill(&state, sizeof(State));
+}
+
+}

higan/md/cpu/cpu.hpp

@@ -0,0 +1,32 @@
+//Motorola 68000
+
+struct CPU : Processor::M68K, Thread {
+  enum class Interrupt : uint {
+    HorizontalBlank,
+    VerticalBlank,
+  };
+
+  using Thread::synchronize;
+
+  static auto Enter() -> void;
+  auto boot() -> void;
+  auto main() -> void;
+  auto step(uint clocks) -> void override;
+  auto synchronize() -> void;
+
+  auto raise(Interrupt) -> void;
+  auto lower(Interrupt) -> void;
+
+  auto power() -> void;
+  auto reset() -> void;
+
+  vector<Thread*> peripherals;
+
+private:
+  struct State {
+    uint32 interruptLine;
+    uint32 interruptPending;
+  } state;
+};
+
+extern CPU cpu;

higan/md/interface/interface.cpp

@@ -0,0 +1,144 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+Settings settings;
+
+Interface::Interface() {
+  information.manufacturer = "Sega";
+  information.name         = "Mega Drive";
+  information.overscan     = true;
+  information.resettable   = true;
+
+  information.capability.states = false;
+  information.capability.cheats = false;
+
+  media.append({ID::MegaDrive, "Mega Drive", "md"});
+
+  Port controllerPort1{ID::Port::Controller1, "Controller Port 1"};
+  Port controllerPort2{ID::Port::Controller2, "Controller Port 2"};
+  Port extensionPort{ID::Port::Extension, "Extension Port"};
+
+  { Device device{ID::Device::None, "None"};
+    controllerPort1.devices.append(device);
+    controllerPort2.devices.append(device);
+    extensionPort.devices.append(device);
+  }
+
+  { Device device{ID::Device::Gamepad, "Gamepad"};
+    device.inputs.append({0, "Up"   });
+    device.inputs.append({0, "Down" });
+    device.inputs.append({0, "Left" });
+    device.inputs.append({0, "Right"});
+    device.inputs.append({0, "A"    });
+    device.inputs.append({0, "B"    });
+    device.inputs.append({0, "C"    });
+    device.inputs.append({0, "X"    });
+    device.inputs.append({0, "Y"    });
+    device.inputs.append({0, "Z"    });
+    device.inputs.append({0, "Start"});
+    controllerPort1.devices.append(device);
+    controllerPort2.devices.append(device);
+  }
+
+  ports.append(move(controllerPort1));
+  ports.append(move(controllerPort2));
+  ports.append(move(extensionPort));
+}
+
+auto Interface::manifest() -> string {
+  return cartridge.manifest();
+}
+
+auto Interface::title() -> string {
+  return cartridge.title();
+}
+
+auto Interface::videoSize() -> VideoSize {
+  return {1280, 480};
+}
+
+auto Interface::videoSize(uint width, uint height, bool arc) -> VideoSize {
+  uint w = 320;
+  uint h = 240;
+  uint m = min(width / w, height / h);
+  return {w * m, h * m};
+}
+
+auto Interface::videoFrequency() -> double {
+  return 60.0;
+}
+
+auto Interface::videoColors() -> uint32 {
+  return 1 << 9;
+}
+
+auto Interface::videoColor(uint32 color) -> uint64 {
+  uint R = color.bits(0,2);
+  uint G = color.bits(3,5);
+  uint B = color.bits(6,8);
+
+  uint64 r = image::normalize(R, 3, 16);
+  uint64 g = image::normalize(G, 3, 16);
+  uint64 b = image::normalize(B, 3, 16);
+
+  return r << 32 | g << 16 | b << 0;
+}
+
+auto Interface::audioFrequency() -> double {
+  return 52'000.0;
+}
+
+auto Interface::loaded() -> bool {
+  return system.loaded();
+}
+
+auto Interface::load(uint id) -> bool {
+  return system.load(this);
+}
+
+auto Interface::save() -> void {
+  system.save();
+}
+
+auto Interface::unload() -> void {
+  system.unload();
+}
+
+auto Interface::connect(uint port, uint device) -> void {
+  peripherals.connect(port, device);
+}
+
+auto Interface::power() -> void {
+  system.power();
+}
+
+auto Interface::reset() -> void {
+  system.reset();
+}
+
+auto Interface::run() -> void {
+  system.run();
+}
+
+auto Interface::serialize() -> serializer {
+  return {};
+}
+
+auto Interface::unserialize(serializer& s) -> bool {
+  return false;
+}
+
+auto Interface::cap(const string& name) -> bool {
+  return false;
+}
+
+auto Interface::get(const string& name) -> any {
+  return {};
+}
+
+auto Interface::set(const string& name, const any& value) -> bool {
+  return false;
+}
+
+}

higan/md/interface/interface.hpp

@@ -0,0 +1,63 @@
+namespace MegaDrive {
+
+struct ID {
+  enum : uint {
+    System,
+    MegaDrive,
+  };
+
+  struct Port { enum : uint {
+    Controller1,
+    Controller2,
+    Extension,
+  };};
+
+  struct Device { enum : uint {
+    None,
+    Gamepad,
+  };};
+};
+
+struct Interface : Emulator::Interface {
+  using Emulator::Interface::load;
+
+  Interface();
+
+  auto manifest() -> string override;
+  auto title() -> string override;
+
+  auto videoSize() -> VideoSize override;
+  auto videoSize(uint width, uint height, bool arc) -> VideoSize override;
+  auto videoFrequency() -> double override;
+  auto videoColors() -> uint32 override;
+  auto videoColor(uint32 color) -> uint64 override;
+
+  auto audioFrequency() -> double override;
+
+  auto loaded() -> bool override;
+  auto load(uint id) -> bool override;
+  auto save() -> void override;
+  auto unload() -> void override;
+
+  auto connect(uint port, uint device) -> void override;
+  auto power() -> void override;
+  auto reset() -> void override;
+  auto run() -> void override;
+
+  auto serialize() -> serializer override;
+  auto unserialize(serializer&) -> bool override;
+
+  auto cap(const string& name) -> bool override;
+  auto get(const string& name) -> any override;
+  auto set(const string& name, const any& value) -> bool override;
+};
+
+struct Settings {
+  uint controllerPort1 = 0;
+  uint controllerPort2 = 0;
+  uint extensionPort = 0;
+};
+
+extern Settings settings;
+
+}

higan/md/md.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+//license: GPLv3
+//started: 2016-07-08
+
+#include <emulator/emulator.hpp>
+#include <emulator/thread.hpp>
+#include <emulator/scheduler.hpp>
+
+#include <processor/m68k/m68k.hpp>
+#include <processor/z80/z80.hpp>
+
+namespace MegaDrive {
+  #define platform Emulator::platform
+  using File = Emulator::File;
+  using Scheduler = Emulator::Scheduler;
+  extern Scheduler scheduler;
+
+  struct Wait {
+    enum : uint {
+      VDP_DMA = 1 << 0,
+    };
+  };
+
+  struct Thread : Emulator::Thread {
+    auto create(auto (*entrypoint)() -> void, double frequency) -> void {
+      Emulator::Thread::create(entrypoint, frequency);
+      scheduler.append(*this);
+      wait = 0;
+    }
+
+    inline auto synchronize(Thread& thread) -> void {
+      if(clock() >= thread.clock()) scheduler.resume(thread);
+    }
+
+    uint wait = 0;
+  };
+
+  #include <md/controller/controller.hpp>
+
+  #include <md/cpu/cpu.hpp>
+  #include <md/apu/apu.hpp>
+  #include <md/vdp/vdp.hpp>
+  #include <md/psg/psg.hpp>
+  #include <md/ym2612/ym2612.hpp>
+
+  #include <md/system/system.hpp>
+  #include <md/cartridge/cartridge.hpp>
+  #include <md/bus/bus.hpp>
+}
+
+#include <md/interface/interface.hpp>

higan/md/psg/psg.cpp

@@ -0,0 +1,29 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+PSG psg;
+
+auto PSG::Enter() -> void {
+  while(true) scheduler.synchronize(), psg.main();
+}
+
+auto PSG::main() -> void {
+  stream->sample(0.0, 0.0);
+  step(1);
+}
+
+auto PSG::step(uint clocks) -> void {
+  Thread::step(clocks);
+  synchronize(cpu);
+}
+
+auto PSG::power() -> void {
+}
+
+auto PSG::reset() -> void {
+  create(PSG::Enter, 52'000);  //system.colorburst());
+  stream = Emulator::audio.createStream(2, 52'000.0);
+}
+
+}

higan/md/psg/psg.hpp

@@ -0,0 +1,14 @@
+//TI SN76489
+
+struct PSG : Thread {
+  shared_pointer<Emulator::Stream> stream;
+
+  static auto Enter() -> void;
+  auto main() -> void;
+  auto step(uint clocks) -> void;
+
+  auto power() -> void;
+  auto reset() -> void;
+};
+
+extern PSG psg;

higan/md/system/peripherals.cpp

@@ -0,0 +1,55 @@
+Peripherals peripherals;
+
+auto Peripherals::unload() -> void {
+  delete controllerPort1;
+  delete controllerPort2;
+  delete extensionPort;
+  controllerPort1 = nullptr;
+  controllerPort2 = nullptr;
+  extensionPort = nullptr;
+}
+
+auto Peripherals::reset() -> void {
+  connect(ID::Port::Controller1, settings.controllerPort1);
+  connect(ID::Port::Controller2, settings.controllerPort2);
+  connect(ID::Port::Extension, settings.extensionPort);
+}
+
+auto Peripherals::connect(uint port, uint device) -> void {
+  if(port == ID::Port::Controller1) {
+    settings.controllerPort1 = device;
+    if(!system.loaded()) return;
+
+    delete controllerPort1;
+    switch(device) { default:
+    case ID::Device::None:    controllerPort1 = new Controller(0); break;
+    case ID::Device::Gamepad: controllerPort1 = new Gamepad(0); break;
+    }
+  }
+
+  if(port == ID::Port::Controller2) {
+    settings.controllerPort2 = device;
+    if(!system.loaded()) return;
+
+    delete controllerPort2;
+    switch(device) { default:
+    case ID::Device::None:    controllerPort2 = new Controller(1); break;
+    case ID::Device::Gamepad: controllerPort2 = new Gamepad(1); break;
+    }
+  }
+
+  if(port == ID::Port::Extension) {
+    settings.extensionPort = device;
+    if(!system.loaded()) return;
+
+    delete extensionPort;
+    switch(device) { default:
+    case ID::Device::None: extensionPort = new Controller(2); break;
+    }
+  }
+
+  cpu.peripherals.reset();
+  cpu.peripherals.append(controllerPort1);
+  cpu.peripherals.append(controllerPort2);
+  cpu.peripherals.append(extensionPort);
+}

higan/md/system/system.cpp

@@ -0,0 +1,67 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+#include "peripherals.cpp"
+System system;
+Scheduler scheduler;
+
+auto System::run() -> void {
+  if(scheduler.enter() == Scheduler::Event::Frame) vdp.refresh();
+}
+
+auto System::load(Emulator::Interface* interface) -> bool {
+  information = {};
+
+  if(auto fp = platform->open(ID::System, "manifest.bml", File::Read, File::Required)) {
+    information.manifest = fp->reads();
+  } else return false;
+
+  auto document = BML::unserialize(information.manifest);
+  if(!cartridge.load()) return false;
+
+  information.colorburst = Emulator::Constants::Colorburst::NTSC;
+  this->interface = interface;
+  return information.loaded = true;
+}
+
+auto System::save() -> void {
+  cartridge.save();
+}
+
+auto System::unload() -> void {
+  peripherals.unload();
+  cartridge.unload();
+}
+
+auto System::power() -> void {
+  cartridge.power();
+  cpu.power();
+  apu.power();
+  vdp.power();
+  psg.power();
+  ym2612.power();
+  reset();
+}
+
+auto System::reset() -> void {
+  Emulator::video.reset();
+  Emulator::video.setInterface(interface);
+  Emulator::video.setPalette();
+
+  Emulator::audio.reset();
+  Emulator::audio.setInterface(interface);
+
+  scheduler.reset();
+  cartridge.reset();
+  cpu.reset();
+  apu.power();
+  vdp.reset();
+  psg.reset();
+  ym2612.reset();
+  scheduler.primary(cpu);
+
+  peripherals.reset();
+}
+
+}

higan/md/system/system.hpp

@@ -0,0 +1,34 @@
+struct System {
+  auto loaded() const -> bool { return information.loaded; }
+  auto colorburst() const -> double { return information.colorburst; }
+
+  auto run() -> void;
+
+  auto load(Emulator::Interface*) -> bool;
+  auto save() -> void;
+  auto unload() -> void;
+  auto power() -> void;
+  auto reset() -> void;
+
+private:
+  Emulator::Interface* interface = nullptr;
+
+  struct Information {
+    bool loaded = false;
+    string manifest;
+    double colorburst = 0.0;
+  } information;
+};
+
+struct Peripherals {
+  auto unload() -> void;
+  auto reset() -> void;
+  auto connect(uint port, uint device) -> void;
+
+  Controller* controllerPort1 = nullptr;
+  Controller* controllerPort2 = nullptr;
+  Controller* extensionPort = nullptr;
+};
+
+extern System system;
+extern Peripherals peripherals;

higan/md/vdp/background.cpp

@@ -0,0 +1,85 @@
+auto VDP::Background::isWindowed(uint x, uint y) -> bool {
+  if((x < io.horizontalOffset) ^ io.horizontalDirection) return true;
+  if((y < io.verticalOffset  ) ^ io.verticalDirection  ) return true;
+  return false;
+}
+
+auto VDP::Background::updateHorizontalScroll(uint y) -> void {
+  if(id == ID::Window) return;
+
+  uint15 address = io.horizontalScrollAddress;
+
+  static const uint mask[] = {0u, 7u, ~7u, ~0u};
+  address += (y & mask[io.horizontalScrollMode]) << 1;
+  address += id == ID::PlaneB;
+
+  state.horizontalScroll = vdp.vram[address].bits(0,9);
+}
+
+auto VDP::Background::updateVerticalScroll(uint x, uint y) -> void {
+  if(id == ID::Window) return;
+
+  auto address = (x >> 4 & 0 - io.verticalScrollMode) << 1;
+  address += id == ID::PlaneB;
+
+  state.verticalScroll = vdp.vsram[address];
+}
+
+auto VDP::Background::nametableAddress() -> uint15 {
+  if(id == ID::Window && vdp.screenWidth() == 320) return io.nametableAddress & ~0x0400;
+  return io.nametableAddress;
+}
+
+auto VDP::Background::nametableWidth() -> uint {
+  if(id == ID::Window) return vdp.screenWidth() == 320 ? 64 : 32;
+  return 32 * (1 + io.nametableWidth);
+}
+
+auto VDP::Background::nametableHeight() -> uint {
+  if(id == ID::Window) return 32;
+  return 32 * (1 + io.nametableHeight);
+}
+
+auto VDP::Background::scanline(uint y) -> void {
+  updateHorizontalScroll(y);
+}
+
+auto VDP::Background::run(uint x, uint y) -> void {
+  updateVerticalScroll(x, y);
+
+  output.priority = 0;
+  output.color = 0;
+
+  x -= state.horizontalScroll;
+  y += state.verticalScroll;
+
+  uint width  = nametableWidth();
+  uint height = nametableHeight();
+
+  uint tileX = x >> 3 & width  - 1;
+  uint tileY = y >> 3 & height - 1;
+
+  auto address = nametableAddress();
+  address += (tileY * width + tileX) & 0x0fff;
+
+  uint16 tileAttributes = vdp.vram[address];
+  uint15 tileAddress = tileAttributes.bits(0,10) << 4;
+  uint pixelX = (x & 7) ^ (tileAttributes.bit(11) ? 7 : 0);
+  uint pixelY = (y & 7) ^ (tileAttributes.bit(12) ? 7 : 0);
+  tileAddress += pixelY << 1 | pixelX >> 2;
+
+  uint16 tileData = vdp.vram[tileAddress];
+  uint4 color = tileData >> (((pixelX & 3) ^ 3) << 2);
+  if(color) {
+    output.color = tileAttributes.bits(13,14) << 4 | color;
+    output.priority = tileAttributes.bit(15);
+  }
+}
+
+auto VDP::Background::power() -> void {
+}
+
+auto VDP::Background::reset() -> void {
+  memory::fill(&io, sizeof(IO));
+  memory::fill(&state, sizeof(State));
+}

higan/md/vdp/dma.cpp

@@ -0,0 +1,36 @@
+auto VDP::dmaRun() -> void {
+  if(!io.dmaEnable) return;
+  if(!io.command.bit(5)) return;
+
+  if(io.dmaMode <= 1) return dmaLoad();
+  if(io.dmaMode == 2) return dmaFill();
+  if(io.dmaMode == 3) return dmaCopy();
+}
+
+auto VDP::dmaLoad() -> void {
+  cpu.wait |= Wait::VDP_DMA;
+
+  auto data = busCPU.readWord(io.dmaMode.bit(0) << 23 | io.dmaSource << 1);
+  writeDataPort(data);
+
+  io.dmaSource.bits(0,15)++;
+  if(--io.dmaLength == 0) {
+    io.command.bit(5) = 0;
+    cpu.wait &=~ Wait::VDP_DMA;
+  }
+}
+
+auto VDP::dmaFill() -> void {
+  if(io.dmaFillWait) return;
+
+  auto data = io.dmaFillByte;
+  writeDataPort(data << 8 | data << 0);
+
+  io.dmaSource.bits(0,15)++;
+  if(--io.dmaLength == 0) {
+    io.command.bit(5) = 0;
+  }
+}
+
+auto VDP::dmaCopy() -> void {
+}

higan/md/vdp/io.cpp

@@ -0,0 +1,318 @@
+auto VDP::read(uint24 addr) -> uint16 {
+  switch(addr & 0xc0001e) {
+
+  //data port
+  case 0xc00000: case 0xc00002: {
+    return readDataPort();
+  }
+
+  //control port
+  case 0xc00004: case 0xc00006: {
+    return readControlPort();
+  }
+
+  //counter
+  case 0xc00008: case 0xc0000a: case 0xc0000c: case 0xc0000e: {
+    return state.y << 8 | (state.x >> 1) << 0;
+  }
+
+  }
+
+  return 0x0000;
+}
+
+auto VDP::write(uint24 addr, uint16 data) -> void {
+  switch(addr & 0xc0001e) {
+
+  //data port
+  case 0xc00000: case 0xc00002: {
+    return writeDataPort(data);
+  }
+
+  //control port
+  case 0xc00004: case 0xc00006: {
+    return writeControlPort(data);
+  }
+
+  }
+}
+
+//
+
+auto VDP::readDataPort() -> uint16 {
+  io.commandPending = false;
+
+  //VRAM read
+  if(io.command.bits(0,3) == 0) {
+    auto address = io.address.bits(1,15);
+    auto data = vram[address];
+    io.address += io.dataIncrement;
+    return data;
+  }
+
+  //VSRAM read
+  if(io.command.bits(0,3) == 4) {
+    auto address = io.address.bits(1,6);
+    if(address >= 40) return 0x0000;
+    auto data = vsram[address];
+    io.address += io.dataIncrement;
+    return data;
+  }
+
+  //CRAM read
+  if(io.command.bits(0,3) == 8) {
+    auto address = io.address.bits(1,6);
+    auto data = cram[address];
+    io.address += io.dataIncrement;
+    return data.bits(0,2) << 1 | data.bits(3,5) << 2 | data.bits(6,8) << 3;
+  }
+
+  return 0x0000;
+}
+
+auto VDP::writeDataPort(uint16 data) -> void {
+  io.commandPending = false;
+
+  //DMA VRAM fill
+  if(io.dmaFillWait.lower()) {
+    io.dmaFillByte = data >> 8;
+  }
+
+  //VRAM write
+  if(io.command.bits(0,3) == 1) {
+    auto address = io.address.bits(1,15);
+    if(io.address.bit(0)) data = data >> 8 | data << 8;
+    vram[address] = data;
+    if(address >= sprite.io.attributeAddress && address < sprite.io.attributeAddress + 320) {
+      sprite.write(address, data);
+    }
+    io.address += io.dataIncrement;
+    return;
+  }
+
+  //VSRAM write
+  if(io.command.bits(0,3) == 5) {
+    auto address = io.address.bits(1,6);
+    if(address >= 40) return;
+    //data format: ---- --yy yyyy yyyy
+    vsram[address] = data.bits(0,9);
+    io.address += io.dataIncrement;
+    return;
+  }
+
+  //CRAM write
+  if(io.command.bits(0,3) == 3) {
+    auto address = io.address.bits(1,6);
+    //data format: ---- bbb- ggg- rrr-
+    cram[address] = data.bits(1,3) << 0 | data.bits(5,7) << 3 | data.bits(9,11) << 6;
+    io.address += io.dataIncrement;
+    return;
+  }
+}
+
+//
+
+auto VDP::readControlPort() -> uint16 {
+  io.commandPending = false;
+
+  uint16 result = 0b0011'0100'0000'0000;
+  result |= 1 << 9;  //FIFO empty
+  result |= (state.y >= 240) << 3;  //vertical blank
+  result |= (state.y >= 240 || state.x >= 320) << 2;  //horizontal blank
+  result |= io.command.bit(5) << 1;  //DMA active
+  return result;
+}
+
+auto VDP::writeControlPort(uint16 data) -> void {
+//print("[VDPC] ", hex(data, 4L), "\n");
+
+  //command write (lo)
+  if(io.commandPending) {
+    io.commandPending = false;
+
+    io.command.bits(2,5) = data.bits(4,7);
+    io.address.bits(14,15) = data.bits(0,1);
+    io.dmaFillWait = io.dmaMode == 2 && io.command.bits(4,5) == 2;
+    return;
+  }
+
+  //command write (hi)
+  if(data.bits(14,15) != 2) {
+    io.commandPending = true;
+
+    io.command.bits(0,1) = data.bits(14,15);
+    io.address.bits(0,13) = data.bits(0,13);
+    return;
+  }
+
+  //register write (d13 is ignored)
+  if(data.bits(14,15) == 2)
+  switch(data.bits(8,12)) {
+
+  //mode register 1
+  case 0x00: {
+    io.displayOverlayEnable = data.bit(0);
+    io.counterLatch = data.bit(1);
+    io.horizontalBlankInterruptEnable = data.bit(4);
+    io.leftColumnBlank = data.bit(5);
+    return;
+  }
+
+  //mode register 2
+  case 0x01: {
+    io.videoMode = data.bit(2);
+    io.overscan = data.bit(3);
+    io.dmaEnable = data.bit(4);
+    io.verticalBlankInterruptEnable = data.bit(5);
+    io.displayEnable = data.bit(6);
+    io.externalVRAM = data.bit(7);
+
+    if(!io.dmaEnable) io.command.bit(5) = 0;
+
+    return;
+  }
+
+  //plane A name table location
+  case 0x02: {
+    planeA.io.nametableAddress = data.bits(3,6) << 12;
+    return;
+  }
+
+  //window name table location
+  case 0x03: {
+    window.io.nametableAddress = data.bits(1,6) << 10;
+    return;
+  }
+
+  //plane B name table location
+  case 0x04: {
+    planeB.io.nametableAddress = data.bits(0,3) << 12;
+    return;
+  }
+
+  //sprite attribute table location
+  case 0x05: {
+    sprite.io.attributeAddress = data.bits(0,7) << 8;
+    return;
+  }
+
+  //sprite pattern base address
+  case 0x06: {
+    sprite.io.nametableAddressBase = data.bit(5);
+    return;
+  }
+
+  //background color
+  case 0x07: {
+    io.backgroundColor = data.bits(0,5);
+    return;
+  }
+
+  //horizontal interrupt counter
+  case 0x0a: {
+    io.horizontalInterruptCounter = data.bits(0,7);
+    return;
+  }
+
+  //mode register 3
+  case 0x0b: {
+    planeA.io.horizontalScrollMode = data.bits(0,1);
+    planeB.io.horizontalScrollMode = data.bits(0,1);
+    planeA.io.verticalScrollMode = data.bit(2);
+    planeB.io.verticalScrollMode = data.bit(2);
+    io.externalInterruptEnable = data.bit(3);
+    return;
+  }
+
+  //mode register 4
+  case 0x0c: {
+    io.tileWidth = data.bit(0) | data.bit(7) << 1;
+    io.interlaceMode = data.bits(1,2);
+    io.shadowHighlightEnable = data.bit(3);
+    io.externalColorEnable = data.bit(4);
+    io.horizontalSync = data.bit(5);
+    io.verticalSync = data.bit(6);
+    return;
+  }
+
+  //horizontal scroll data location
+  case 0x0d: {
+    planeA.io.horizontalScrollAddress = data.bits(0,6) << 9;
+    planeB.io.horizontalScrollAddress = data.bits(0,6) << 9;
+    return;
+  }
+
+  //nametable pattern base address
+  case 0x0e: {
+    io.nametableBasePatternA = data.bit(0);
+    io.nametableBasePatternB = data.bit(1);
+    return;
+  }
+
+  //data port auto-increment value
+  case 0x0f: {
+    io.dataIncrement = data.bits(0,7);
+    return;
+  }
+
+  //plane size
+  case 0x10: {
+    planeA.io.nametableWidth = data.bits(0,1);
+    planeB.io.nametableWidth = data.bits(0,1);
+    planeA.io.nametableHeight = data.bits(4,5);
+    planeB.io.nametableHeight = data.bits(4,5);
+    return;
+  }
+
+  //window plane horizontal position
+  case 0x11: {
+    window.io.horizontalDirection = data.bit(7);
+    window.io.horizontalOffset = data.bits(0,4) << 4;
+    return;
+  }
+
+  //window plane vertical position
+  case 0x12: {
+    window.io.verticalDirection = data.bit(7);
+    window.io.verticalOffset = data.bits(0,4) << 3;
+    return;
+  }
+
+  //DMA length
+  case 0x13: {
+    io.dmaLength.bits(0,7) = data.bits(0,7);
+    return;
+  }
+
+  //DMA length
+  case 0x14: {
+    io.dmaLength.bits(8,15) = data.bits(0,7);
+    return;
+  }
+
+  //DMA source
+  case 0x15: {
+    io.dmaSource.bits(0,7) = data.bits(0,7);
+    return;
+  }
+
+  //DMA source
+  case 0x16: {
+    io.dmaSource.bits(8,15) = data.bits(0,7);
+    return;
+  }
+
+  //DMA source
+  case 0x17: {
+    io.dmaSource.bits(16,21) = data.bits(0,5);
+    io.dmaMode = data.bits(6,7);
+    return;
+  }
+
+  //unused
+  default: {
+    return;
+  }
+
+  }
+}

higan/md/vdp/render.cpp

@@ -0,0 +1,44 @@
+auto VDP::scanline() -> void {
+  state.x = 0;
+  if(++state.y >= 262) state.y = 0;
+
+  if(state.y < screenHeight()) {
+    planeA.scanline(state.y);
+    window.scanline(state.y);
+    planeB.scanline(state.y);
+    sprite.scanline(state.y);
+  }
+
+  if(state.y == 240) scheduler.exit(Scheduler::Event::Frame);
+
+  state.output = buffer + (state.y * 2 + 0) * 1280;
+}
+
+auto VDP::run() -> void {
+  if(!io.displayEnable) return outputPixel(0);
+  if(state.y >= screenHeight()) return outputPixel(0);
+
+  auto& planeA = window.isWindowed(state.x, state.y) ? window : this->planeA;
+  planeA.run(state.x, state.y);
+  planeB.run(state.x, state.y);
+  sprite.run(state.x, state.y);
+
+  auto output = io.backgroundColor;
+  if(auto color = planeB.output.color) output = color;
+  if(auto color = planeA.output.color) output = color;
+  if(auto color = sprite.output.color) output = color;
+  if(planeB.output.priority) if(auto color = planeB.output.color) output = color;
+  if(planeA.output.priority) if(auto color = planeA.output.color) output = color;
+  if(sprite.output.priority) if(auto color = sprite.output.color) output = color;
+
+  outputPixel(cram[output]);
+  state.x++;
+}
+
+auto VDP::outputPixel(uint9 color) -> void {
+  for(auto n : range(4)) {
+    state.output[   0 + n] = color;
+    state.output[1280 + n] = color;
+  }
+  state.output += 4;
+}

higan/md/vdp/sprite.cpp

@@ -0,0 +1,90 @@
+auto VDP::Sprite::write(uint9 address, uint16 data) -> void {
+  if(address > 320) return;
+
+  auto& object = oam[address >> 2];
+  switch(address.bits(0,1)) {
+
+  case 0: {
+    object.y = data.bits(0,8);
+    break;
+  }
+
+  case 1: {
+    object.link = data.bits(0,6);
+    object.height = 1 + data.bits(8,9) << 3;
+    object.width = 1 + data.bits(10,11) << 3;
+    break;
+  }
+
+  case 2: {
+    object.address = data.bits(0,10) << 4;
+    object.horizontalFlip = data.bit(11);
+    object.verticalFlip = data.bit(12);
+    object.palette = data.bits(13,14);
+    object.priority = data.bit(15);
+    break;
+  }
+
+  case 3: {
+    object.x = data.bits(0,8);
+    break;
+  }
+
+  }
+}
+
+auto VDP::Sprite::scanline(uint y) -> void {
+  objects.reset();
+
+  uint7 link = 0;
+  uint tiles = 0;
+  do {
+    auto& object = oam[link];
+    link = object.link;
+
+    if(128 + y <  object.y) continue;
+    if(128 + y >= object.y + object.height) continue;
+    if(object.x == 0) break;
+
+    objects.append(object);
+    tiles += object.width >> 3;
+  } while(link && link < 80 && objects.size() < 20 && tiles < 40);
+}
+
+auto VDP::Sprite::run(uint x, uint y) -> void {
+  output.priority = 0;
+  output.color = 0;
+
+  for(auto& o : objects) {
+    if(128 + x <  o.x) continue;
+    if(128 + x >= o.x + o.width) continue;
+
+    uint objectX = 128 + x - o.x;
+    uint objectY = 128 + y - o.y;
+    if(o.horizontalFlip) objectX = (o.width - 1) - objectX;
+    if(o.verticalFlip) objectY = (o.height - 1) - objectY;
+
+    uint tileX = objectX >> 3;
+    uint tileY = objectY >> 3;
+    uint tileNumber = tileX * (o.height >> 3) + tileY;
+    uint15 tileAddress = o.address + (tileNumber << 4);
+    uint pixelX = objectX & 7;
+    uint pixelY = objectY & 7;
+    tileAddress += pixelY << 1 | pixelX >> 2;
+
+    uint16 tileData = vdp.vram[tileAddress];
+    uint4 color = tileData >> (((pixelX & 3) ^ 3) << 2);
+    if(color) {
+      output.color = o.palette << 4 | color;
+      output.priority = o.priority;
+      break;
+    }
+  }
+}
+
+auto VDP::Sprite::power() -> void {
+}
+
+auto VDP::Sprite::reset() -> void {
+  memory::fill(&io, sizeof(IO));
+}

higan/md/vdp/vdp.cpp

@@ -0,0 +1,72 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+VDP vdp;
+#include "io.cpp"
+#include "dma.cpp"
+#include "render.cpp"
+#include "background.cpp"
+#include "sprite.cpp"
+
+auto VDP::Enter() -> void {
+  while(true) scheduler.synchronize(), vdp.main();
+}
+
+auto VDP::main() -> void {
+  scanline();
+  if(state.y < screenHeight()) {
+    if(state.y == 0) {
+      cpu.lower(CPU::Interrupt::VerticalBlank);
+    }
+    cpu.lower(CPU::Interrupt::HorizontalBlank);
+    for(uint x : range(320)) {
+      run();
+      step(4);
+    }
+    if(io.horizontalBlankInterruptEnable) {
+      cpu.raise(CPU::Interrupt::HorizontalBlank);
+    }
+    step(430);
+  } else {
+    if(state.y == screenHeight()) {
+      if(io.verticalBlankInterruptEnable) {
+        cpu.raise(CPU::Interrupt::VerticalBlank);
+      }
+    }
+    step(1710);
+  }
+}
+
+auto VDP::step(uint clocks) -> void {
+  while(clocks--) {
+    dmaRun();
+    Thread::step(1);
+    synchronize(cpu);
+  }
+}
+
+auto VDP::refresh() -> void {
+  Emulator::video.refresh(buffer, 1280 * sizeof(uint32), 1280, 480);
+}
+
+auto VDP::power() -> void {
+  planeA.power();
+  window.power();
+  planeB.power();
+  sprite.power();
+}
+
+auto VDP::reset() -> void {
+  create(VDP::Enter, system.colorburst() * 15.0 / 2.0);
+
+  memory::fill(&io, sizeof(IO));
+  memory::fill(&state, sizeof(State));
+
+  planeA.reset();
+  window.reset();
+  planeB.reset();
+  sprite.reset();
+}
+
+}

higan/md/vdp/vdp.hpp

@@ -0,0 +1,194 @@
+//Yamaha YM7101
+
+struct VDP : Thread {
+  static auto Enter() -> void;
+  auto main() -> void;
+  auto step(uint clocks) -> void;
+  auto refresh() -> void;
+
+  auto power() -> void;
+  auto reset() -> void;
+
+  //io.cpp
+  auto read(uint24 addr) -> uint16;
+  auto write(uint24 addr, uint16 data) -> void;
+
+  auto readDataPort() -> uint16;
+  auto writeDataPort(uint16 data) -> void;
+
+  auto readControlPort() -> uint16;
+  auto writeControlPort(uint16 data) -> void;
+
+  //dma.cpp
+  auto dmaRun() -> void;
+  auto dmaLoad() -> void;
+  auto dmaFill() -> void;
+  auto dmaCopy() -> void;
+
+  //render.cpp
+  auto scanline() -> void;
+  auto run() -> void;
+  auto outputPixel(uint9 color) -> void;
+
+  //background.cpp
+  struct Background {
+    enum class ID : uint { PlaneA, Window, PlaneB } id;
+
+    auto isWindowed(uint x, uint y) -> bool;
+
+    auto updateHorizontalScroll(uint y) -> void;
+    auto updateVerticalScroll(uint x, uint y) -> void;
+
+    auto nametableAddress() -> uint15;
+    auto nametableWidth() -> uint;
+    auto nametableHeight() -> uint;
+
+    auto scanline(uint y) -> void;
+    auto run(uint x, uint y) -> void;
+
+    auto power() -> void;
+    auto reset() -> void;
+
+    struct IO {
+      uint15 nametableAddress;
+
+      //PlaneA, PlaneB
+      uint2  nametableWidth;
+      uint2  nametableHeight;
+      uint15 horizontalScrollAddress;
+      uint2  horizontalScrollMode;
+      uint1  verticalScrollMode;
+
+      //Window
+      uint1  horizontalDirection;
+      uint10 horizontalOffset;
+      uint1  verticalDirection;
+      uint10 verticalOffset;
+    } io;
+
+    struct State {
+      uint10 horizontalScroll;
+      uint10 verticalScroll;
+    } state;
+
+    struct Output {
+      uint6 color;
+      boolean priority;
+    } output;
+  };
+  Background planeA{Background::ID::PlaneA};
+  Background window{Background::ID::Window};
+  Background planeB{Background::ID::PlaneB};
+
+  //sprite.cpp
+  struct Sprite {
+    auto write(uint9 addr, uint16 data) -> void;
+    auto scanline(uint y) -> void;
+    auto run(uint x, uint y) -> void;
+
+    auto power() -> void;
+    auto reset() -> void;
+
+    struct IO {
+      uint15 attributeAddress;
+      uint1  nametableAddressBase;
+    } io;
+
+    struct Object {
+      uint9  x;
+      uint9  y;
+      uint   width;
+      uint   height;
+      bool   horizontalFlip;
+      bool   verticalFlip;
+      uint2  palette;
+      uint1  priority;
+      uint15 address;
+      uint7  link;
+    };
+
+    struct Output {
+      uint6   color;
+      boolean priority;
+    } output;
+
+    array<Object, 80> oam;
+    array<Object, 20> objects;
+  };
+  Sprite sprite;
+
+private:
+  auto screenWidth() const -> uint { return io.tileWidth ? 320 : 256; }
+  auto screenHeight() const -> uint { return io.overscan ? 240 : 224; }
+
+  uint16 vram[32768];
+  uint16 vramExpansion[32768];  //not present in stock Mega Drive hardware
+  uint9 cram[64];
+  uint10 vsram[40];
+
+  struct IO {
+    //internal state
+    boolean dmaFillWait;
+    uint8 dmaFillByte;
+
+    //command
+    uint6 command;
+    uint16 address;
+    boolean commandPending;
+
+    //$00  mode register 1
+    uint1 displayOverlayEnable;
+    uint1 counterLatch;
+    uint1 horizontalBlankInterruptEnable;
+    uint1 leftColumnBlank;
+
+    //$01  mode register 2
+    uint1 videoMode;  //0 = Master System; 1 = Mega Drive
+    uint1 overscan;   //0 = 224 lines; 1 = 240 lines
+    uint1 dmaEnable;
+    uint1 verticalBlankInterruptEnable;
+    uint1 displayEnable;
+    uint1 externalVRAM;
+
+    //$07  background color
+    uint6 backgroundColor;
+
+    //$0a  horizontal interrupt counter
+    uint8 horizontalInterruptCounter;
+
+    //$0b  mode register 3
+    uint1 externalInterruptEnable;
+
+    //$0c  mode register 4
+    uint2 tileWidth;
+    uint2 interlaceMode;
+    uint1 shadowHighlightEnable;
+    uint1 externalColorEnable;
+    uint1 horizontalSync;
+    uint1 verticalSync;
+
+    //$0e  nametable pattern base address
+    uint1 nametableBasePatternA;
+    uint1 nametableBasePatternB;
+
+    //$0f  data port auto-increment value
+    uint8 dataIncrement;
+
+    //$13-$14  DMA length
+    uint16 dmaLength;
+
+    //$15-$17  DMA source
+    uint22 dmaSource;
+    uint2 dmaMode;
+  } io;
+
+  struct State {
+    uint32* output = nullptr;
+    uint x;
+    uint y;
+  } state;
+
+  uint32 buffer[1280 * 480];
+};
+
+extern VDP vdp;

higan/md/ym2612/ym2612.cpp

@@ -0,0 +1,27 @@
+#include <md/md.hpp>
+
+namespace MegaDrive {
+
+YM2612 ym2612;
+
+auto YM2612::Enter() -> void {
+  while(true) scheduler.synchronize(), ym2612.main();
+}
+
+auto YM2612::main() -> void {
+  step(1);
+}
+
+auto YM2612::step(uint clocks) -> void {
+  Thread::step(clocks);
+  synchronize(cpu);
+}
+
+auto YM2612::power() -> void {
+}
+
+auto YM2612::reset() -> void {
+  create(YM2612::Enter, system.colorburst() * 15.0 / 7.0);
+}
+
+}

higan/md/ym2612/ym2612.hpp

@@ -0,0 +1,12 @@
+//Yamaha YM2612
+
+struct YM2612 : Thread {
+  static auto Enter() -> void;
+  auto main() -> void;
+  auto step(uint clocks) -> void;
+
+  auto power() -> void;
+  auto reset() -> void;
+};
+
+extern YM2612 ym2612;

higan/ms/GNUmakefile

@@ -0,0 +1,15 @@
+processors += z80
+
+objects += ms-interface
+objects += ms-cpu ms-vdp ms-psg
+objects += ms-system ms-cartridge ms-bus
+objects += ms-controller
+
+obj/ms-interface.o:  ms/interface/interface.cpp $(call rwildcard,ms/interface)
+obj/ms-cpu.o:        ms/cpu/cpu.cpp $(call rwildcard,ms/cpu)
+obj/ms-vdp.o:        ms/vdp/vdp.cpp $(call rwildcard,ms/vdp)
+obj/ms-psg.o:        ms/psg/psg.cpp $(call rwildcard,ms/psg)
+obj/ms-system.o:     ms/system/system.cpp $(call rwildcard,ms/system)
+obj/ms-cartridge.o:  ms/cartridge/cartridge.cpp $(call rwildcard,ms/cartridge)
+obj/ms-bus.o:        ms/bus/bus.cpp $(call rwildcard,ms/bus)
+obj/ms-controller.o: ms/controller/controller.cpp $(call rwildcard,ms/controller)

higan/ms/bus/bus.cpp

@@ -0,0 +1,86 @@
+#include <ms/ms.hpp>
+
+namespace MasterSystem {
+
+Bus bus;
+
+auto Bus::read(uint16 addr) -> uint8 {
+  if(auto data = cartridge.read(addr)) return data();
+  if(addr >= 0xc000) return ram[addr & 0x1fff];
+  return 0x00;
+}
+
+auto Bus::write(uint16 addr, uint8 data) -> void {
+  if(cartridge.write(addr, data)) return;
+  if(addr >= 0xc000) ram[addr & 0x1fff] = data;
+}
+
+auto Bus::in(uint8 addr) -> uint8 {
+  switch(addr >> 6) {
+
+  case 0: {
+    if(system.model() == Model::GameGear) {
+      bool start = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 6);
+      return start << 7 | 0x7f;
+    }
+
+    return 0xff;  //SMS1 = MDR, SMS2 = 0xff
+  }
+
+  case 1: {
+    return !addr.bit(0) ? vdp.vcounter() : vdp.hcounter();
+  }
+
+  case 2: {
+    return !addr.bit(0) ? vdp.data() : vdp.status();
+  }
+
+  case 3: {
+    if(system.model() == Model::MasterSystem) {
+      bool reset = !platform->inputPoll(ID::Port::Hardware, ID::Device::MasterSystemControls, 0);
+      auto port1 = peripherals.controllerPort1->readData();
+      auto port2 = peripherals.controllerPort2->readData();
+      if(addr.bit(0) == 0) {
+        return port1.bits(0,5) << 0 | port2.bits(0,1) << 6;
+      } else {
+        return port2.bits(2,5) << 0 | reset << 4 | 1 << 5 | port1.bit(6) << 6 | port2.bit(6) << 7;
+      }
+    }
+    if(system.model() == Model::GameGear) {
+      bool up    = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 0);
+      bool down  = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 1);
+      bool left  = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 2);
+      bool right = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 3);
+      bool one   = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 4);
+      bool two   = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 5);
+      if(!up && !down) up = 1, down = 1;
+      if(!left && !right) left = 1, right = 1;
+      if(addr.bit(0) == 0) {
+        return up << 0 | down << 1 | left << 2 | right << 3 | one << 4 | two << 5 | 1 << 6 | 1 << 7;
+      } else {
+        return 0xff;
+      }
+    }
+    return 0xff;
+  }
+
+  }
+
+  return 0xff;
+}
+
+auto Bus::out(uint8 addr, uint8 data) -> void {
+  switch(addr >> 6) {
+
+  case 2: {
+    return !addr.bit(0) ? vdp.data(data) : vdp.control(data);
+  }
+
+  case 3: {
+    return;  //unmapped
+  }
+
+  }
+}
+
+}

higan/ms/bus/bus.hpp

@@ -0,0 +1,12 @@
+struct Bus : Processor::Z80::Bus {
+  auto read(uint16 addr) -> uint8 override;
+  auto write(uint16 addr, uint8 data) -> void override;
+
+  auto in(uint8 addr) -> uint8 override;
+  auto out(uint8 addr, uint8 data) -> void override;
+
+private:
+  uint8 ram[0x2000];
+};
+
+extern Bus bus;

higan/ms/cartridge/cartridge.cpp

@@ -0,0 +1,109 @@
+#include <ms/ms.hpp>
+
+namespace MasterSystem {
+
+Cartridge cartridge;
+#include "mapper.cpp"
+
+auto Cartridge::load() -> bool {
+  information = {};
+
+  switch(system.model()) {
+  case Model::MasterSystem:
+    if(auto pathID = platform->load(ID::MasterSystem, "Master System", "ms")) {
+      information.pathID = pathID();
+    } else return false;
+    break;
+  case Model::GameGear:
+    if(auto pathID = platform->load(ID::GameGear, "Game Gear", "gg")) {
+      information.pathID = pathID();
+    } else return false;
+    break;
+  }
+
+  if(auto fp = platform->open(pathID(), "manifest.bml", File::Read, File::Required)) {
+    information.manifest = fp->reads();
+  } else return false;
+
+  auto document = BML::unserialize(information.manifest);
+  information.title = document["information/title"].text();
+
+  if(auto node = document["board/rom"]) {
+    rom.size = node["size"].natural();
+    rom.mask = bit::round(rom.size) - 1;
+    if(rom.size) {
+      rom.data = new uint8[rom.mask + 1];
+      if(auto name = node["name"].text()) {
+        if(auto fp = platform->open(pathID(), name, File::Read, File::Required)) {
+          fp->read(rom.data, rom.size);
+        }
+      }
+    }
+  }
+
+  if(auto node = document["board/ram"]) {
+    ram.size = node["size"].natural();
+    ram.mask = bit::round(ram.size) - 1;
+    if(ram.size) {
+      ram.data = new uint8[ram.mask + 1];
+      if(auto name = node["name"].text()) {
+        if(auto fp = platform->open(pathID(), name, File::Read)) {
+          fp->read(ram.data, ram.size);
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+auto Cartridge::save() -> void {
+  auto document = BML::unserialize(information.manifest);
+
+  if(auto name = document["board/ram/name"].text()) {
+    if(auto fp = platform->open(pathID(), name, File::Write)) {
+      fp->write(ram.data, ram.size);
+    }
+  }
+}
+
+auto Cartridge::unload() -> void {
+  delete[] rom.data;
+  delete[] ram.data;
+  rom = {};
+  ram = {};
+}
+
+auto Cartridge::power() -> void {
+  memory::fill(&mapper, sizeof(Mapper));
+  mapper.romPage0 = 0;
+  mapper.romPage1 = 1;
+  mapper.romPage2 = 2;
+}
+
+auto Cartridge::Memory::mirror(uint addr, uint size) -> uint {
+  uint base = 0;
+  uint mask = 1 << 21;
+  while(addr >= size) {
+    while(!(addr & mask)) mask >>= 1;
+    addr -= mask;
+    if(size > mask) {
+      size -= mask;
+      base += mask;
+    }
+    mask >>= 1;
+  }
+  return base + addr;
+}
+
+auto Cartridge::Memory::read(uint addr) -> uint8 {
+  if(!size) return 0x00;
+  return this->data[mirror(addr, size)];
+}
+
+auto Cartridge::Memory::write(uint addr, uint8 data) -> void {
+  if(!size) return;
+  this->data[mirror(addr, size)] = data;
+}
+
+}

higan/ms/cartridge/cartridge.hpp

@@ -0,0 +1,57 @@
+struct Cartridge {
+  auto pathID() const -> uint { return information.pathID; }
+  auto sha256() const -> string { return information.sha256; }
+  auto manifest() const -> string { return information.manifest; }
+  auto title() const -> string { return information.title; }
+
+  auto load() -> bool;
+  auto save() -> void;
+  auto unload() -> void;
+
+  auto power() -> void;
+
+  //mapper.cpp
+  auto read(uint16 addr) -> maybe<uint8>;
+  auto write(uint16 addr, uint8 data) -> bool;
+
+private:
+  struct Information {
+    uint pathID = 0;
+    string sha256;
+    string manifest;
+    string title;
+  } information;
+
+  struct Memory {
+    uint8* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+
+    static auto mirror(uint addr, uint size) -> uint;
+    auto read(uint addr) -> uint8;
+    auto write(uint addr, uint8 data) -> void;
+  };
+
+  Memory rom;
+  Memory ram;
+
+  struct Mapper {
+    //$fffc
+    uint2 shift;
+    uint1 ramPage2;
+    uint1 ramEnablePage2;
+    uint1 ramEnablePage3;
+    uint1 romWriteEnable;
+
+    //$fffd
+    uint8 romPage0;
+
+    //$fffe
+    uint8 romPage1;
+
+    //$ffff
+    uint8 romPage2;
+  } mapper;
+};
+
+extern Cartridge cartridge;

higan/ms/cartridge/mapper.cpp

@@ -0,0 +1,92 @@
+auto Cartridge::read(uint16 addr) -> maybe<uint8> {
+  uint2 page = addr >> 14;
+  addr &= 0x3fff;
+
+  switch(page) {
+
+  case 0: {
+    if(addr <= 0x03ff) return rom.read(addr);
+    return rom.read(mapper.romPage0 << 14 | addr);
+  }
+
+  case 1: {
+    return rom.read(mapper.romPage1 << 14 | addr);
+  }
+
+  case 2: {
+    if(mapper.ramEnablePage2) {
+      return ram.read(mapper.ramPage2 << 14 | addr);
+    }
+
+    return rom.read(mapper.romPage2 << 14 | addr);
+  }
+
+  case 3: {
+    if(mapper.ramEnablePage3) {
+      return ram.read(addr);
+    }
+
+    return nothing;
+  }
+
+  }
+
+  unreachable;
+}
+
+auto Cartridge::write(uint16 addr, uint8 data) -> bool {
+  if(addr == 0xfffc) {
+    mapper.shift = data.bits(0,1);
+    mapper.ramPage2 = data.bit(2);
+    mapper.ramEnablePage2 = data.bit(3);
+    mapper.ramEnablePage3 = data.bit(4);
+    mapper.romWriteEnable = data.bit(7);
+  }
+
+  if(addr == 0xfffd) {
+    mapper.romPage0 = data;
+  }
+
+  if(addr == 0xfffe) {
+    mapper.romPage1 = data;
+  }
+
+  if(addr == 0xffff) {
+    mapper.romPage2 = data;
+  }
+
+  uint2 page = addr >> 14;
+  addr &= 0x3fff;
+
+  switch(page) {
+
+  case 0: {
+    return false;
+  }
+
+  case 1: {
+    return false;
+  }
+
+  case 2: {
+    if(mapper.ramEnablePage2) {
+      ram.write(mapper.ramPage2 << 14 | addr, data);
+      return true;
+    }
+
+    return false;
+  }
+
+  case 3: {
+    if(mapper.ramEnablePage3) {
+      ram.write(addr, data);
+      return true;
+    }
+
+    return false;
+  }
+
+  }
+
+  unreachable;
+}

higan/ms/controller/controller.cpp

@@ -0,0 +1,27 @@
+#include <ms/ms.hpp>
+
+namespace MasterSystem {
+
+#include "gamepad/gamepad.cpp"
+
+Controller::Controller(uint port) : port(port) {
+  if(!handle()) create(Controller::Enter, 100);
+}
+
+Controller::~Controller() {
+}
+
+auto Controller::Enter() -> void {
+  while(true) {
+    scheduler.synchronize();
+    if(auto device = peripherals.controllerPort1) if(device->active()) device->main();
+    if(auto device = peripherals.controllerPort2) if(device->active()) device->main();
+  }
+}
+
+auto Controller::main() -> void {
+  step(1);
+  synchronize(cpu);
+}
+
+}