Update to v100 release.

byuu says:

higan has finally reached v100!

I feel it's important to stress right away that this is not "version
1.00", nor is it a major milestone release. Rather than arbitrary version
numbers, all of my software simply bumps version numbers by one for each
official release. As such, higan v100 is simply higan's 100th release.

That said, the primary focus of this release has been code
clean-ups. These are always somewhat dangerous in that regressions are
possible. We've tested through sixteen WIP revisions, one of which was
open to the public, to try and minimize any regressions. But all the same,
please report any regressions if you discover any.

Changelog (since v099):
FC: render during pixels 1-256 instead of 0-255 [hex_usr]
FC: rewrote controller emulation code
SFC: 8% speedup over the previous release thanks to PPU optimizations
SFC: fixed nasty DB address wrapping regression from v099
SFC: USART developer controller removed; superseded by 21fx
SFC: Super Multitap option removed from controller port 1; ports
    renamed 2-5
SFC: hidden option to experiment with 128KB VRAM (strictly for novelty)
higan: audio volume no longer divided by number of audio streams
higan: updated controller polling code to fix possible future mapping
    issues
higan: replaced nall/stream with nall/vfs for file-loading subsystem
tomoko: can now load multi-slotted games via command-line
tomoko: synchronize video removed from UI; still available in the
    settings file
tomoko, icarus: can navigate to root drive selection on Windows
all: major code cleanups and refactoring (~1MB diff against v099)

Note 1: the audio volume change means that SGB and MSU1 games won't
lose half the volume on the SNES sounds anymore. However, if one goes
overboard and drives the sound all the way to max volume with the MSU1,
clamping may occur. The obvious solution is not to drive volume that high
(it will vastly overpower the SNES audio, which usually never exceeds
25% volume.) Another option is to lower the volume in the audio settings
panel to 50%. In general, neither is likely to ever be necessary.

Note 2: the synchronize video option was hidden from the UI because it
is no longer useful. With the advent of compositors, the loss of the
complicated timing settings panel, support for the WonderSwan and its
75hz display, the need to emulate variable refresh rate behaviors in the
Game Boy, the unfortunate latency spike and audio distortion caused by
long Vsync pauses, and the arrival of adaptive sync technology ... it
no longer makes sense to present this option. However, as stated, you
can edit settings.bml to enable this option anyway if you insist and
understand the aforementioned risks.

Changelog (since v099r16 open beta):

- fixed MSU1 audio sign extension
- fixed compilation with SGB support disabled
- icarus can now navigate to root directory
- fixed compilation issues with OS X port
- (hopefully) fixed label height issue with hiro that affected icarus
  import dialog
- (mostly) fixed BS Memory, Sufami Turbo slot loading

Errata:

- forgot to remove the " - Slot A", " - Slot B" suffixes for Sufami
  Turbo slot loading
  - this means you have to navigate up one folder and then into Sufami
    Turbo/ to load games for this system
- moving WonderSwan orientation controls to the device slot is causing
  some nastiness
  - can now select orientation from the main menu, but it doesn't rotate
    the display

.gitignore

@@ -1,2 +1,2 @@
-ananke/libananke.so
-icarus/icarus
+higan/profile/WonderSwan.sys/internal.ram
+higan/profile/WonderSwan Color.sys/internal.ram

GNUmakefile

@@ -1,105 +0,0 @@
-include nall/GNUmakefile
-
-fc  := fc
-sfc := sfc
-gb  := gb
-gba := gba
-
-profile := accuracy
-target := tomoko
-# console := true
-
-# compiler
-flags += -I. -O3
-objects := libco
-
-# profile-guided optimization mode
-# pgo := instrument
-# pgo := optimize
-
-ifeq ($(pgo),instrument)
-  flags += -fprofile-generate
-  link += -lgcov
-else ifeq ($(pgo),optimize)
-  flags += -fprofile-use
-endif
-
-# platform
-ifeq ($(platform),windows)
-  ifeq ($(console),true)
-    link += -mconsole
-  else
-    link += -mwindows
-  endif
-  link += -mthreads -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
-  link += -Wl,-enable-auto-import
-  link += -Wl,-enable-runtime-pseudo-reloc
-else ifeq ($(platform),macosx)
-  flags += -march=native
-else ifeq ($(platform),linux)
-  flags += -march=native -fopenmp
-  link += -fopenmp
-  link += -Wl,-export-dynamic
-  link += -lX11 -lXext
-else ifeq ($(platform),bsd)
-  flags += -march=native -fopenmp
-  link += -fopenmp
-  link += -Wl,-export-dynamic
-  link += -lX11 -lXext
-else
-  $(error unsupported platform.)
-endif
-
-ui := target-$(target)
-
-# implicit rules
-compile = \
-  $(strip \
-    $(if $(filter %.c,$<), \
-      $(compiler) $(cflags) $(flags) $1 -c $< -o $@, \
-      $(if $(filter %.cpp,$<), \
-        $(compiler) $(cppflags) $(flags) $1 -c $< -o $@ \
-      ) \
-    ) \
-  )
-
-%.o: $<; $(call compile)
-
-all: build;
-
-obj/libco.o: libco/libco.c libco/*
-
-include $(ui)/GNUmakefile
-flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
-
-# targets
-clean:
-	-@$(call delete,out/*)
-	-@$(call delete,obj/*.o)
-	-@$(call delete,obj/*.a)
-	-@$(call delete,obj/*.so)
-	-@$(call delete,obj/*.dylib)
-	-@$(call delete,obj/*.dll)
-
-archive:
-	if [ -f higan.tar.xz ]; then rm higan.tar.xz; fi
-	tar -cJf higan.tar.xz `ls`
-
-sync:
-ifeq ($(shell id -un),byuu)
-	if [ -d ./libco ]; then rm -r ./libco; fi
-	if [ -d ./nall ]; then rm -r ./nall; fi
-	if [ -d ./ruby ]; then rm -r ./ruby; fi
-	if [ -d ./hiro ]; then rm -r ./hiro; fi
-	cp -r ../libco ./libco
-	cp -r ../nall ./nall
-	cp -r ../ruby ./ruby
-	cp -r ../hiro ./hiro
-	rm -r libco/doc
-	rm -r libco/-test
-	rm -r nall/-test
-	rm -r ruby/-test
-	rm -r hiro/-test
-endif
-
-help:;

emulator/emulator.hpp

@@ -1,59 +0,0 @@
-#ifndef EMULATOR_HPP
-#define EMULATOR_HPP
-
-#include <nall/nall.hpp>
-#include <nall/dsp.hpp>
-using namespace nall;
-
-namespace Emulator {
-  static const string Name = "higan";
-  static const string Version = "096";
-  static const string Author = "byuu";
-  static const string License = "GPLv3";
-  static const string Website = "http://byuu.org/";
-
-  #if defined(PROFILE_ACCURACY)
-  static const string Profile = "Accuracy";
-  #elif defined(PROFILE_BALANCED)
-  static const string Profile = "Balanced";
-  #elif defined(PROFILE_PERFORMANCE)
-  static const string Profile = "Performance";
-  #endif
-}
-
-#include "interface.hpp"
-
-//debugging function hook:
-//no overhead (and no debugger invocation) if not compiled with -DDEBUGGER
-//wraps testing of function to allow invocation without a defined callback
-template<typename T> struct hook;
-template<typename R, typename... P> struct hook<auto (P...) -> R> {
-  function<auto (P...) -> R> callback;
-
-  auto operator()(P... p) const -> R {
-    #if defined(DEBUGGER)
-    if(callback) return callback(forward<P>(p)...);
-    #endif
-    return R();
-  }
-
-  hook() {}
-  hook(const hook& hook) { callback = hook.callback; }
-  hook(void* function) { callback = function; }
-  hook(auto (*function)(P...) -> R) { callback = function; }
-  template<typename C> hook(auto (C::*function)(P...) -> R, C* object) { callback = {function, object}; }
-  template<typename C> hook(auto (C::*function)(P...) const -> R, C* object) { callback = {function, object}; }
-  template<typename L> hook(const L& function) { callback = function; }
-
-  auto operator=(const hook& source) -> hook& { callback = source.callback; return *this; }
-};
-
-#if defined(DEBUGGER)
-  #define privileged public
-#else
-  #define privileged private
-#endif
-
-using varuint = varuint_t<uint>;
-
-#endif

emulator/interface.hpp

@@ -1,117 +0,0 @@
-#ifndef EMULATOR_INTERFACE_HPP
-#define EMULATOR_INTERFACE_HPP
-
-namespace Emulator {
-
-struct Interface {
-  struct Information {
-    string name;
-    uint width;
-    uint height;
-    bool overscan;
-    double aspectRatio;
-    bool resettable;
-    struct Capability {
-      bool states;
-      bool cheats;
-    } capability;
-  } information;
-
-  struct Media {
-    uint id;
-    string name;
-    string type;
-    bool bootable;  //false for cartridge slots (eg Sufami Turbo cartridges)
-  };
-  vector<Media> media;
-
-  struct Device {
-    uint id;
-    uint portmask;
-    string name;
-    struct Input {
-      uint id;
-      uint type;  //0 = digital, 1 = analog (relative), 2 = rumble
-      string name;
-      uintptr guid;  //user data field
-    };
-    vector<Input> input;
-    vector<uint> order;
-  };
-
-  struct Port {
-    uint id;
-    string name;
-    vector<Device> device;
-  };
-  vector<Port> port;
-
-  struct Bind {
-    virtual auto loadRequest(uint, string, string, bool) -> void {}
-    virtual auto loadRequest(uint, string, bool) -> void {}
-    virtual auto saveRequest(uint, string) -> void {}
-    virtual auto videoColor(uint, uint16, uint16, uint16, uint16) -> uint32 { return 0u; }
-    virtual auto videoRefresh(const uint32*, const uint32*, uint, uint, uint) -> void {}
-    virtual auto audioSample(int16, int16) -> void {}
-    virtual auto inputPoll(uint, uint, uint) -> int16 { return 0; }
-    virtual auto inputRumble(uint, uint, uint, bool) -> void {}
-    virtual auto dipSettings(const Markup::Node&) -> uint { return 0; }
-    virtual auto path(uint) -> string { return ""; }
-    virtual auto notify(string text) -> void { print(text, "\n"); }
-  };
-  Bind* bind = nullptr;
-
-  //callback bindings (provided by user interface)
-  auto loadRequest(uint id, string name, string type, bool required) -> void { return bind->loadRequest(id, name, type, required); }
-  auto loadRequest(uint id, string path, bool required) -> void { return bind->loadRequest(id, path, required); }
-  auto saveRequest(uint id, string path) -> void { return bind->saveRequest(id, path); }
-  auto videoColor(uint source, uint16 alpha, uint16 red, uint16 green, uint16 blue) -> uint32 { return bind->videoColor(source, alpha, red, green, blue); }
-  auto videoRefresh(const uint32* palette, const uint32* data, uint pitch, uint width, uint height) -> void { return bind->videoRefresh(palette, data, pitch, width, height); }
-  auto audioSample(int16 lsample, int16 rsample) -> void { return bind->audioSample(lsample, rsample); }
-  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(const Markup::Node& node) -> uint { return bind->dipSettings(node); }
-  auto path(uint group) -> string { return bind->path(group); }
-  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;
-  virtual auto videoFrequency() -> double = 0;
-  virtual auto audioFrequency() -> double = 0;
-
-  //media interface
-  virtual auto loaded() -> bool { return false; }
-  virtual auto sha256() -> string { return ""; }
-  virtual auto group(uint id) -> uint = 0;
-  virtual auto load(uint id) -> void {}
-  virtual auto save() -> void {}
-  virtual auto load(uint id, const stream& memory) -> void {}
-  virtual auto save(uint id, const stream& memory) -> void {}
-  virtual auto unload() -> void {}
-
-  //system interface
-  virtual auto connect(uint port, uint device) -> void {}
-  virtual auto power() -> void {}
-  virtual auto reset() -> void {}
-  virtual auto run() -> void {}
-
-  //time functions
-  virtual auto rtc() -> bool { return false; }
-  virtual auto rtcsync() -> void {}
-
-  //state functions
-  virtual auto serialize() -> serializer = 0;
-  virtual auto unserialize(serializer&) -> bool = 0;
-
-  //cheat functions
-  virtual auto cheatSet(const lstring& = lstring{}) -> void {}
-
-  //utility functions
-  enum class PaletteMode : uint { Literal, Channel, Standard, Emulation };
-  virtual auto paletteUpdate(PaletteMode mode) -> void {}
-};
-
-}
-
-#endif

fc/GNUmakefile

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

fc/apu/apu.cpp

@@ -1,329 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "envelope.cpp"
-#include "sweep.cpp"
-#include "pulse.cpp"
-#include "triangle.cpp"
-#include "noise.cpp"
-#include "dmc.cpp"
-#include "serialization.cpp"
-APU apu;
-
-APU::APU() {
-  for(uint amp : range(32)) {
-    if(amp == 0) {
-      pulse_dac[amp] = 0;
-    } else {
-      pulse_dac[amp] = 16384.0 * 95.88 / (8128.0 / amp + 100.0);
-    }
-  }
-
-  for(uint dmc_amp : range(128)) {
-    for(uint triangle_amp : range(16)) {
-      for(uint noise_amp : range(16)) {
-        if(dmc_amp == 0 && triangle_amp == 0 && noise_amp == 0) {
-          dmc_triangle_noise_dac[dmc_amp][triangle_amp][noise_amp] = 0;
-        } else {
-          dmc_triangle_noise_dac[dmc_amp][triangle_amp][noise_amp]
-          = 16384.0 * 159.79 / (100.0 + 1.0 / (triangle_amp / 8227.0 + noise_amp / 12241.0 + dmc_amp / 22638.0));
-        }
-      }
-    }
-  }
-}
-
-auto APU::Main() -> void {
-  apu.main();
-}
-
-auto APU::main() -> void {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    uint pulse_output, triangle_output, noise_output, dmc_output;
-
-    pulse_output  = pulse[0].clock();
-    pulse_output += pulse[1].clock();
-    triangle_output = triangle.clock();
-    noise_output = noise.clock();
-    dmc_output = dmc.clock();
-
-    clock_frame_counter_divider();
-
-    int output = pulse_dac[pulse_output] + dmc_triangle_noise_dac[dmc_output][triangle_output][noise_output];
-
-    output  = filter.run_hipass_strong(output);
-    output += cartridge_sample;
-    output  = filter.run_hipass_weak(output);
-  //output  = filter.run_lopass(output);
-    output  = sclamp<16>(output);
-
-    interface->audioSample(output, output);
-
-    tick();
-  }
-}
-
-auto APU::tick() -> void {
-  clock += 12;
-  if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(cpu.thread);
-}
-
-auto APU::set_irq_line() -> void {
-  cpu.set_irq_apu_line(frame.irq_pending || dmc.irq_pending);
-}
-
-auto APU::set_sample(int16 sample) -> void {
-  cartridge_sample = sample;
-}
-
-auto APU::power() -> void {
-  filter.hipass_strong = 0;
-  filter.hipass_weak = 0;
-  filter.lopass = 0;
-
-  pulse[0].power();
-  pulse[1].power();
-  triangle.power();
-  noise.power();
-  dmc.power();
-}
-
-auto APU::reset() -> void {
-  create(APU::Main, 21477272);
-
-  pulse[0].reset();
-  pulse[1].reset();
-  triangle.reset();
-  noise.reset();
-  dmc.reset();
-
-  frame.irq_pending = 0;
-
-  frame.mode = 0;
-  frame.counter = 0;
-  frame.divider = 1;
-
-  enabled_channels = 0;
-  cartridge_sample = 0;
-
-  set_irq_line();
-}
-
-auto APU::read(uint16 addr) -> uint8 {
-  if(addr == 0x4015) {
-    uint8 result = 0x00;
-    result |= pulse[0].length_counter ? 0x01 : 0;
-    result |= pulse[1].length_counter ? 0x02 : 0;
-    result |= triangle.length_counter ? 0x04 : 0;
-    result |=    noise.length_counter ? 0x08 : 0;
-    result |=      dmc.length_counter ? 0x10 : 0;
-    result |=       frame.irq_pending ? 0x40 : 0;
-    result |=         dmc.irq_pending ? 0x80 : 0;
-
-    frame.irq_pending = false;
-    set_irq_line();
-
-    return result;
-  }
-
-  return cpu.mdr();
-}
-
-auto APU::write(uint16 addr, uint8 data) -> void {
-  const uint n = (addr >> 2) & 1;  //pulse#
-
-  switch(addr) {
-  case 0x4000: case 0x4004:
-    pulse[n].duty = data >> 6;
-    pulse[n].envelope.loop_mode = data & 0x20;
-    pulse[n].envelope.use_speed_as_volume = data & 0x10;
-    pulse[n].envelope.speed = data & 0x0f;
-    break;
-
-  case 0x4001: case 0x4005:
-    pulse[n].sweep.enable = data & 0x80;
-    pulse[n].sweep.period = (data & 0x70) >> 4;
-    pulse[n].sweep.decrement = data & 0x08;
-    pulse[n].sweep.shift = data & 0x07;
-    pulse[n].sweep.reload = true;
-    break;
-
-  case 0x4002: case 0x4006:
-    pulse[n].period = (pulse[n].period & 0x0700) | (data << 0);
-    pulse[n].sweep.pulse_period = (pulse[n].sweep.pulse_period & 0x0700) | (data << 0);
-    break;
-
-  case 0x4003: case 0x4007:
-    pulse[n].period = (pulse[n].period & 0x00ff) | (data << 8);
-    pulse[n].sweep.pulse_period = (pulse[n].sweep.pulse_period & 0x00ff) | (data << 8);
-
-    pulse[n].duty_counter = 7;
-    pulse[n].envelope.reload_decay = true;
-
-    if(enabled_channels & (1 << n)) {
-      pulse[n].length_counter = length_counter_table[(data >> 3) & 0x1f];
-    }
-    break;
-
-  case 0x4008:
-    triangle.halt_length_counter = data & 0x80;
-    triangle.linear_length = data & 0x7f;
-    break;
-
-  case 0x400a:
-    triangle.period = (triangle.period & 0x0700) | (data << 0);
-    break;
-
-  case 0x400b:
-    triangle.period = (triangle.period & 0x00ff) | (data << 8);
-
-    triangle.reload_linear = true;
-
-    if(enabled_channels & (1 << 2)) {
-      triangle.length_counter = length_counter_table[(data >> 3) & 0x1f];
-    }
-    break;
-
-  case 0x400c:
-    noise.envelope.loop_mode = data & 0x20;
-    noise.envelope.use_speed_as_volume = data & 0x10;
-    noise.envelope.speed = data & 0x0f;
-    break;
-
-  case 0x400e:
-    noise.short_mode = data & 0x80;
-    noise.period = data & 0x0f;
-    break;
-
-  case 0x400f:
-    noise.envelope.reload_decay = true;
-
-    if(enabled_channels & (1 << 3)) {
-      noise.length_counter = length_counter_table[(data >> 3) & 0x1f];
-    }
-    break;
-
-  case 0x4010:
-    dmc.irq_enable = data & 0x80;
-    dmc.loop_mode = data & 0x40;
-    dmc.period = data & 0x0f;
-
-    dmc.irq_pending = dmc.irq_pending && dmc.irq_enable && !dmc.loop_mode;
-    set_irq_line();
-    break;
-
-  case 0x4011:
-    dmc.dac_latch = data & 0x7f;
-    break;
-
-  case 0x4012:
-    dmc.addr_latch = data;
-    break;
-
-  case 0x4013:
-    dmc.length_latch = data;
-    break;
-
-  case 0x4015:
-    if((data & 0x01) == 0) pulse[0].length_counter = 0;
-    if((data & 0x02) == 0) pulse[1].length_counter = 0;
-    if((data & 0x04) == 0) triangle.length_counter = 0;
-    if((data & 0x08) == 0)    noise.length_counter = 0;
-
-    (data & 0x10) ? dmc.start() : dmc.stop();
-    dmc.irq_pending = false;
-
-    set_irq_line();
-    enabled_channels = data & 0x1f;
-    break;
-
-  case 0x4017:
-    frame.mode = data >> 6;
-
-    frame.counter = 0;
-    if(frame.mode & 2) clock_frame_counter();
-    if(frame.mode & 1) {
-      frame.irq_pending = false;
-      set_irq_line();
-    }
-    frame.divider = FrameCounter::NtscPeriod;
-    break;
-  }
-}
-
-auto APU::Filter::run_hipass_strong(int sample) -> int {
-  hipass_strong += ((((int64)sample << 16) - (hipass_strong >> 16)) * HiPassStrong) >> 16;
-  return sample - (hipass_strong >> 32);
-}
-
-auto APU::Filter::run_hipass_weak(int sample) -> int {
-  hipass_weak += ((((int64)sample << 16) - (hipass_weak >> 16)) * HiPassWeak) >> 16;
-  return sample - (hipass_weak >> 32);
-}
-
-auto APU::Filter::run_lopass(int sample) -> int {
-  lopass += ((((int64)sample << 16) - (lopass >> 16)) * LoPass) >> 16;
-  return (lopass >> 32);
-}
-
-auto APU::clock_frame_counter() -> void {
-  frame.counter++;
-
-  if(frame.counter & 1) {
-    pulse[0].clock_length();
-    pulse[0].sweep.clock(0);
-    pulse[1].clock_length();
-    pulse[1].sweep.clock(1);
-    triangle.clock_length();
-    noise.clock_length();
-  }
-
-  pulse[0].envelope.clock();
-  pulse[1].envelope.clock();
-  triangle.clock_linear_length();
-  noise.envelope.clock();
-
-  if(frame.counter == 0) {
-    if(frame.mode & 2) frame.divider += FrameCounter::NtscPeriod;
-    if(frame.mode == 0) {
-      frame.irq_pending = true;
-      set_irq_line();
-    }
-  }
-}
-
-auto APU::clock_frame_counter_divider() -> void {
-  frame.divider -= 2;
-  if(frame.divider <= 0) {
-    clock_frame_counter();
-    frame.divider += FrameCounter::NtscPeriod;
-  }
-}
-
-const uint8 APU::length_counter_table[32] = {
-  0x0a, 0xfe, 0x14, 0x02, 0x28, 0x04, 0x50, 0x06, 0xa0, 0x08, 0x3c, 0x0a, 0x0e, 0x0c, 0x1a, 0x0e,
-  0x0c, 0x10, 0x18, 0x12, 0x30, 0x14, 0x60, 0x16, 0xc0, 0x18, 0x48, 0x1a, 0x10, 0x1c, 0x20, 0x1e,
-};
-
-const uint16 APU::ntsc_noise_period_table[16] = {
-  4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 4068,
-};
-
-const uint16 APU::pal_noise_period_table[16] = {
-  4, 7, 14, 30, 60, 88, 118, 148, 188, 236, 354, 472, 708,  944, 1890, 3778,
-};
-
-const uint16 APU::ntsc_dmc_period_table[16] = {
-  428, 380, 340, 320, 286, 254, 226, 214, 190, 160, 142, 128, 106, 84, 72, 54,
-};
-
-const uint16 APU::pal_dmc_period_table[16] = {
-  398, 354, 316, 298, 276, 236, 210, 198, 176, 148, 132, 118,  98, 78, 66, 50,
-};
-
-}

fc/apu/apu.hpp

@@ -1,70 +0,0 @@
-struct APU : Thread {
-  APU();
-
-  static auto Main() -> void;
-  auto main() -> void;
-  auto tick() -> void;
-  auto set_irq_line() -> void;
-  auto set_sample(int16 sample) -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto read(uint16 addr) -> uint8;
-  auto write(uint16 addr, uint8 data) -> void;
-
-  auto serialize(serializer&) -> void;
-
-  struct Filter {
-    auto run_hipass_strong(int sample) -> int;
-    auto run_hipass_weak(int sample) -> int;
-    auto run_lopass(int sample) -> int;
-
-    auto serialize(serializer&) -> void;
-
-    enum : int { HiPassStrong = 225574, HiPassWeak = 57593, LoPass = 86322413 };
-
-    int64 hipass_strong;
-    int64 hipass_weak;
-    int64 lopass;
-  };
-
-  #include "envelope.hpp"
-  #include "sweep.hpp"
-  #include "pulse.hpp"
-  #include "triangle.hpp"
-  #include "noise.hpp"
-  #include "dmc.hpp"
-
-  struct FrameCounter {
-    auto serialize(serializer&) -> void;
-
-    enum : uint { NtscPeriod = 14915 };  //~(21.477MHz / 6 / 240hz)
-
-    bool irq_pending;
-
-    uint2 mode;
-    uint2 counter;
-    int divider;
-  };
-
-  auto clock_frame_counter() -> void;
-  auto clock_frame_counter_divider() -> void;
-
-  Filter filter;
-  FrameCounter frame;
-
-  uint8 enabled_channels;
-  int16 cartridge_sample;
-
-  int16 pulse_dac[32];
-  int16 dmc_triangle_noise_dac[128][16][16];
-
-  static const uint8 length_counter_table[32];
-  static const uint16 ntsc_dmc_period_table[16];
-  static const uint16 pal_dmc_period_table[16];
-  static const uint16 ntsc_noise_period_table[16];
-  static const uint16 pal_noise_period_table[16];
-};
-
-extern APU apu;

fc/apu/dmc.cpp

@@ -1,117 +0,0 @@
-auto APU::DMC::start() -> void {
-  if(length_counter == 0) {
-    read_addr = 0x4000 + (addr_latch << 6);
-    length_counter = (length_latch << 4) + 1;
-  }
-}
-
-auto APU::DMC::stop() -> void {
-  length_counter = 0;
-  dma_delay_counter = 0;
-  cpu.set_rdy_line(1);
-  cpu.set_rdy_addr(false);
-}
-
-auto APU::DMC::clock() -> uint8 {
-  uint8 result = dac_latch;
-
-  if(dma_delay_counter > 0) {
-    dma_delay_counter--;
-
-    if(dma_delay_counter == 1) {
-      cpu.set_rdy_addr(true, 0x8000 | read_addr);
-    } else if(dma_delay_counter == 0) {
-      cpu.set_rdy_line(1);
-      cpu.set_rdy_addr(false);
-
-      dma_buffer = cpu.mdr();
-      have_dma_buffer = true;
-      length_counter--;
-      read_addr++;
-
-      if(length_counter == 0) {
-        if(loop_mode) {
-          start();
-        } else if(irq_enable) {
-          irq_pending = true;
-          apu.set_irq_line();
-        }
-      }
-    }
-  }
-
-  if(--period_counter == 0) {
-    if(have_sample) {
-      int delta = (((sample >> bit_counter) & 1) << 2) - 2;
-      uint data = dac_latch + delta;
-      if((data & 0x80) == 0) dac_latch = data;
-    }
-
-    if(++bit_counter == 0) {
-      if(have_dma_buffer) {
-        have_sample = true;
-        sample = dma_buffer;
-        have_dma_buffer = false;
-      } else {
-        have_sample = false;
-      }
-    }
-
-    period_counter = ntsc_dmc_period_table[period];
-  }
-
-  if(length_counter > 0 && have_dma_buffer == false && dma_delay_counter == 0) {
-    cpu.set_rdy_line(0);
-    dma_delay_counter = 4;
-  }
-
-  return result;
-}
-
-auto APU::DMC::power() -> void {
-}
-
-auto APU::DMC::reset() -> void {
-  length_counter = 0;
-  irq_pending = 0;
-
-  period = 0;
-  period_counter = ntsc_dmc_period_table[0];
-  irq_enable = 0;
-  loop_mode = 0;
-  dac_latch = 0;
-  addr_latch = 0;
-  length_latch = 0;
-  read_addr = 0;
-  dma_delay_counter = 0;
-  bit_counter = 0;
-  have_dma_buffer = 0;
-  dma_buffer = 0;
-  have_sample = 0;
-  sample = 0;
-}
-
-auto APU::DMC::serialize(serializer& s) -> void {
-  s.integer(length_counter);
-  s.integer(irq_pending);
-
-  s.integer(period);
-  s.integer(period_counter);
-
-  s.integer(irq_enable);
-  s.integer(loop_mode);
-
-  s.integer(dac_latch);
-  s.integer(addr_latch);
-  s.integer(length_latch);
-
-  s.integer(read_addr);
-  s.integer(dma_delay_counter);
-
-  s.integer(bit_counter);
-  s.integer(have_dma_buffer);
-  s.integer(dma_buffer);
-
-  s.integer(have_sample);
-  s.integer(sample);
-}

fc/apu/dmc.hpp

@@ -1,33 +0,0 @@
-struct DMC {
-  auto start() -> void;
-  auto stop() -> void;
-  auto clock() -> uint8;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint length_counter;
-  bool irq_pending;
-
-  uint4 period;
-  uint period_counter;
-
-  bool irq_enable;
-  bool loop_mode;
-
-  uint8 dac_latch;
-  uint8 addr_latch;
-  uint8 length_latch;
-
-  uint15 read_addr;
-  uint dma_delay_counter;
-
-  uint3 bit_counter;
-  bool have_dma_buffer;
-  uint8 dma_buffer;
-
-  bool have_sample;
-  uint8 sample;
-} dmc;

fc/apu/envelope.cpp

@@ -1,39 +0,0 @@
-auto APU::Envelope::volume() const -> uint {
-  return use_speed_as_volume ? speed : decay_volume;
-}
-
-auto APU::Envelope::clock() -> void {
-  if(reload_decay) {
-    reload_decay = false;
-    decay_volume = 0x0f;
-    decay_counter = speed + 1;
-    return;
-  }
-
-  if(--decay_counter == 0) {
-    decay_counter = speed + 1;
-    if(decay_volume || loop_mode) decay_volume--;
-  }
-}
-
-auto APU::Envelope::power() -> void {
-}
-
-auto APU::Envelope::reset() -> void {
-  speed = 0;
-  use_speed_as_volume = 0;
-  loop_mode = 0;
-  reload_decay = 0;
-  decay_counter = 0;
-  decay_volume = 0;
-}
-
-auto APU::Envelope::serialize(serializer& s) -> void {
-  s.integer(speed);
-  s.integer(use_speed_as_volume);
-  s.integer(loop_mode);
-
-  s.integer(reload_decay);
-  s.integer(decay_counter);
-  s.integer(decay_volume);
-}

fc/apu/envelope.hpp

@@ -1,17 +0,0 @@
-struct Envelope {
-  auto volume() const -> uint;
-  auto clock() -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint4 speed;
-  bool use_speed_as_volume;
-  bool loop_mode;
-
-  bool reload_decay;
-  uint8 decay_counter;
-  uint4 decay_volume;
-};

fc/apu/noise.cpp

@@ -1,57 +0,0 @@
-auto APU::Noise::clock_length() -> void {
-  if(envelope.loop_mode == 0) {
-    if(length_counter > 0) length_counter--;
-  }
-}
-
-auto APU::Noise::clock() -> uint8 {
-  if(length_counter == 0) return 0;
-
-  uint8 result = (lfsr & 1) ? envelope.volume() : 0;
-
-  if(--period_counter == 0) {
-    uint feedback;
-
-    if(short_mode) {
-      feedback = ((lfsr >> 0) & 1) ^ ((lfsr >> 6) & 1);
-    } else {
-      feedback = ((lfsr >> 0) & 1) ^ ((lfsr >> 1) & 1);
-    }
-
-    lfsr = (lfsr >> 1) | (feedback << 14);
-    period_counter = apu.ntsc_noise_period_table[period];
-  }
-
-  return result;
-}
-
-auto APU::Noise::power() -> void {
-}
-
-auto APU::Noise::reset() -> void {
-  length_counter = 0;
-
-  envelope.speed = 0;
-  envelope.use_speed_as_volume = 0;
-  envelope.loop_mode = 0;
-  envelope.reload_decay = 0;
-  envelope.decay_counter = 0;
-  envelope.decay_volume = 0;
-
-  period = 0;
-  period_counter = 1;
-  short_mode = 0;
-  lfsr = 1;
-}
-
-auto APU::Noise::serialize(serializer& s) -> void {
-  s.integer(length_counter);
-
-  envelope.serialize(s);
-
-  s.integer(period);
-  s.integer(period_counter);
-
-  s.integer(short_mode);
-  s.integer(lfsr);
-}

fc/apu/noise.hpp

@@ -1,19 +0,0 @@
-struct Noise {
-  auto clock_length() -> void;
-  auto clock() -> uint8;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint length_counter;
-
-  Envelope envelope;
-
-  uint4 period;
-  uint period_counter;
-
-  bool short_mode;
-  uint15 lfsr;
-} noise;

fc/apu/pulse.cpp

@@ -1,51 +0,0 @@
-auto APU::Pulse::clock_length() -> void {
-  if(envelope.loop_mode == 0) {
-    if(length_counter) length_counter--;
-  }
-}
-
-auto APU::Pulse::clock() -> uint8 {
-  if(sweep.check_period() == false) return 0;
-  if(length_counter == 0) return 0;
-
-  static const uint duty_table[] = {1, 2, 4, 6};
-  uint8 result = (duty_counter < duty_table[duty]) ? envelope.volume() : 0;
-  if(sweep.pulse_period < 0x008) result = 0;
-
-  if(--period_counter == 0) {
-    period_counter = (sweep.pulse_period + 1) * 2;
-    duty_counter++;
-  }
-
-  return result;
-}
-
-auto APU::Pulse::power() -> void {
-  envelope.power();
-  sweep.power();
-}
-
-auto APU::Pulse::reset() -> void {
-  envelope.reset();
-  sweep.reset();
-
-  length_counter = 0;
-
-  duty = 0;
-  duty_counter = 0;
-  period = 0;
-  period_counter = 1;
-}
-
-auto APU::Pulse::serialize(serializer& s) -> void {
-  s.integer(length_counter);
-
-  envelope.serialize(s);
-  sweep.serialize(s);
-
-  s.integer(duty);
-  s.integer(duty_counter);
-
-  s.integer(period);
-  s.integer(period_counter);
-}

fc/apu/pulse.hpp

@@ -1,21 +0,0 @@
-struct Pulse {
-  auto clock_length() -> void;
-  auto check_period() -> bool;
-  auto clock() -> uint8;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint length_counter;
-
-  Envelope envelope;
-  Sweep sweep;
-
-  uint2 duty;
-  uint3 duty_counter;
-
-  uint11 period;
-  uint period_counter;
-} pulse[2];

fc/apu/serialization.cpp

@@ -1,28 +0,0 @@
-auto APU::serialize(serializer& s) -> void {
-  Thread::serialize(s);
-
-  filter.serialize(s);
-
-  pulse[0].serialize(s);
-  pulse[1].serialize(s);
-  triangle.serialize(s);
-  dmc.serialize(s);
-  frame.serialize(s);
-
-  s.integer(enabled_channels);
-  s.integer(cartridge_sample);
-}
-
-auto APU::Filter::serialize(serializer& s) -> void {
-  s.integer(hipass_strong);
-  s.integer(hipass_weak);
-  s.integer(lopass);
-}
-
-auto APU::FrameCounter::serialize(serializer& s) -> void {
-  s.integer(irq_pending);
-
-  s.integer(mode);
-  s.integer(counter);
-  s.integer(divider);
-}

fc/apu/sweep.cpp

@@ -1,53 +0,0 @@
-auto APU::Sweep::check_period() -> bool {
-  if(pulse_period > 0x7ff) return false;
-
-  if(decrement == 0) {
-    if((pulse_period + (pulse_period >> shift)) & 0x800) return false;
-  }
-
-  return true;
-}
-
-auto APU::Sweep::clock(uint channel) -> void {
-  if(--counter == 0) {
-    counter = period + 1;
-    if(enable && shift && pulse_period > 8) {
-      int delta = pulse_period >> shift;
-
-      if(decrement) {
-        pulse_period -= delta;
-        if(channel == 0) pulse_period--;
-      } else if((pulse_period + delta) < 0x800) {
-        pulse_period += delta;
-      }
-    }
-  }
-
-  if(reload) {
-    reload = false;
-    counter = period + 1;
-  }
-}
-
-auto APU::Sweep::power() -> void {
-  shift = 0;
-  decrement = 0;
-  period = 0;
-  counter = 1;
-  enable = 0;
-  reload = 0;
-  pulse_period = 0;
-}
-
-auto APU::Sweep::reset() -> void {
-}
-
-auto APU::Sweep::serialize(serializer& s) -> void {
-  s.integer(shift);
-  s.integer(decrement);
-  s.integer(period);
-  s.integer(counter);
-  s.integer(enable);
-  s.integer(reload);
-  s.integer(pulse_period);
-}

fc/apu/sweep.hpp

@@ -1,17 +0,0 @@
-struct Sweep {
-  auto check_period() -> bool;
-  auto clock(uint channel) -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint8 shift;
-  bool decrement;
-  uint3 period;
-  uint8 counter;
-  bool enable;
-  bool reload;
-  uint11 pulse_period;
-};

fc/apu/triangle.cpp

@@ -1,58 +0,0 @@
-auto APU::Triangle::clock_length() -> void {
-  if(halt_length_counter == 0) {
-    if(length_counter > 0) length_counter--;
-  }
-}
-
-auto APU::Triangle::clock_linear_length() -> void {
-  if(reload_linear) {
-    linear_length_counter = linear_length;
-  } else if(linear_length_counter) {
-    linear_length_counter--;
-  }
-
-  if(halt_length_counter == 0) reload_linear = false;
-}
-
-auto APU::Triangle::clock() -> uint8 {
-  uint8 result = step_counter & 0x0f;
-  if((step_counter & 0x10) == 0) result ^= 0x0f;
-  if(length_counter == 0 || linear_length_counter == 0) return result;
-
-  if(--period_counter == 0) {
-    step_counter++;
-    period_counter = period + 1;
-  }
-
-  return result;
-}
-
-auto APU::Triangle::power() -> void {
-  reset();
-}
-
-auto APU::Triangle::reset() -> void {
-  length_counter = 0;
-
-  linear_length = 0;
-  halt_length_counter = 0;
-  period = 0;
-  period_counter = 1;
-  step_counter = 0;
-  linear_length_counter = 0;
-  reload_linear = 0;
-}
-
-auto APU::Triangle::serialize(serializer& s) -> void {
-  s.integer(length_counter);
-
-  s.integer(linear_length);
-  s.integer(halt_length_counter);
-
-  s.integer(period);
-  s.integer(period_counter);
-
-  s.integer(step_counter);
-  s.integer(linear_length_counter);
-  s.integer(reload_linear);
-}

fc/apu/triangle.hpp

@@ -1,22 +0,0 @@
-struct Triangle {
-  auto clock_length() -> void;
-  auto clock_linear_length() -> void;
-  auto clock() -> uint8;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  uint length_counter;
-
-  uint8 linear_length;
-  bool halt_length_counter;
-
-  uint11 period;
-  uint period_counter;
-
-  uint5 step_counter;
-  uint8 linear_length_counter;
-  bool reload_linear;
-} triangle;

fc/cartridge/board/bandai-fcg.cpp

@@ -1,115 +0,0 @@
-//BANDAI-FCG
-
-struct BandaiFCG : Board {
-  BandaiFCG(Markup::Node& document) : Board(document) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_counter_enable) {
-        if(--irq_counter == 0xffff) {
-          cpu.set_irq_line(1);
-          irq_counter_enable = false;
-        }
-      }
-
-      tick();
-    }
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    switch(mirror) {
-    case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff);
-    case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-    case 2: return 0x0000 | (addr & 0x03ff);
-    case 3: return 0x0400 | (addr & 0x03ff);
-    }
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr & 0x8000) {
-      bool region = addr & 0x4000;
-      uint bank = (region == 0 ? prg_bank : 0x0f);
-      return prgrom.read((bank << 14) | (addr & 0x3fff));
-    }
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr >= 0x6000) {
-      switch(addr & 15) {
-      case 0x00: case 0x01: case 0x02: case 0x03:
-      case 0x04: case 0x05: case 0x06: case 0x07:
-        chr_bank[addr & 7] = data;
-        break;
-      case 0x08:
-        prg_bank = data & 0x0f;
-        break;
-      case 0x09:
-        mirror = data & 0x03;
-        break;
-      case 0x0a:
-        cpu.set_irq_line(0);
-        irq_counter_enable = data & 0x01;
-        irq_counter = irq_latch;
-        break;
-      case 0x0b:
-        irq_latch = (irq_latch & 0xff00) | (data << 0);
-        break;
-      case 0x0c:
-        irq_latch = (irq_latch & 0x00ff) | (data << 8);
-        break;
-      case 0x0d:
-        //TODO: serial EEPROM support
-        break;
-      }
-    }
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read(ciram_addr(addr));
-    addr = (chr_bank[addr >> 10] << 10) | (addr & 0x03ff);
-    return Board::chr_read(addr);
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write(ciram_addr(addr), data);
-    addr = (chr_bank[addr >> 10] << 10) | (addr & 0x03ff);
-    return Board::chr_write(addr, data);
-  }
-
-  auto power() -> void {
-    reset();
-  }
-
-  auto reset() -> void {
-    for(auto &n : chr_bank) n = 0;
-    prg_bank = 0;
-    mirror = 0;
-    irq_counter_enable = 0;
-    irq_counter = 0;
-    irq_latch = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-
-    s.array(chr_bank);
-    s.integer(prg_bank);
-    s.integer(mirror);
-    s.integer(irq_counter_enable);
-    s.integer(irq_counter);
-    s.integer(irq_latch);
-  }
-
-  uint8 chr_bank[8];
-  uint8 prg_bank;
-  uint2 mirror;
-  bool irq_counter_enable;
-  uint16 irq_counter;
-  uint16 irq_latch;
-};

fc/cartridge/board/konami-vrc1.cpp

@@ -1,38 +0,0 @@
-struct KonamiVRC1 : Board {
-  KonamiVRC1(Markup::Node& document) : Board(document), vrc1(*this) {
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr & 0x8000) return prgrom.read(vrc1.prg_addr(addr));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr & 0x8000) return vrc1.reg_write(addr, data);
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read(vrc1.ciram_addr(addr));
-    return Board::chr_read(vrc1.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write(vrc1.ciram_addr(addr), data);
-    return Board::chr_write(vrc1.chr_addr(addr), data);
-  }
-
-  auto power() -> void {
-    vrc1.power();
-  }
-
-  auto reset() -> void {
-    vrc1.reset();
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    vrc1.serialize(s);
-  }
-
-  VRC1 vrc1;
-};

fc/cartridge/board/konami-vrc2.cpp

@@ -1,55 +0,0 @@
-struct KonamiVRC2 : Board {
-  KonamiVRC2(Markup::Node& document) : Board(document), vrc2(*this) {
-    settings.pinout.a0 = 1 << document["cartridge/chip/pinout/a0"].natural();
-    settings.pinout.a1 = 1 << document["cartridge/chip/pinout/a1"].natural();
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr < 0x6000) return cpu.mdr();
-    if(addr < 0x8000) return vrc2.ram_read(addr);
-    return prgrom.read(vrc2.prg_addr(addr));
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr < 0x6000) return;
-    if(addr < 0x8000) return vrc2.ram_write(addr, data);
-
-    bool a0 = (addr & settings.pinout.a0);
-    bool a1 = (addr & settings.pinout.a1);
-    addr &= 0xfff0;
-    addr |= (a0 << 0) | (a1 << 1);
-    return vrc2.reg_write(addr, data);
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read(vrc2.ciram_addr(addr));
-    return Board::chr_read(vrc2.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write(vrc2.ciram_addr(addr), data);
-    return Board::chr_write(vrc2.chr_addr(addr), data);
-  }
-
-  auto power() -> void {
-    vrc2.power();
-  }
-
-  auto reset() -> void {
-    vrc2.reset();
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    vrc2.serialize(s);
-  }
-
-  struct Settings {
-    struct Pinout {
-      uint a0;
-      uint a1;
-    } pinout;
-  } settings;
-
-  VRC2 vrc2;
-};

fc/cartridge/board/konami-vrc6.cpp

@@ -1,40 +0,0 @@
-struct KonamiVRC6 : Board {
-  KonamiVRC6(Markup::Node& document) : Board(document), vrc6(*this) {
-  }
-
-  auto prg_read(uint addr) -> uint8{
-    if((addr & 0xe000) == 0x6000) return vrc6.ram_read(addr);
-    if(addr & 0x8000) return prgrom.read(vrc6.prg_addr(addr));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if((addr & 0xe000) == 0x6000) return vrc6.ram_write(addr, data);
-    if(addr & 0x8000) {
-      addr = (addr & 0xf003);
-      if(prgram.size) addr = (addr & ~3) | ((addr & 2) >> 1) | ((addr & 1) << 1);
-      return vrc6.reg_write(addr, data);
-    }
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read(vrc6.ciram_addr(addr));
-    return Board::chr_read(vrc6.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write(vrc6.ciram_addr(addr), data);
-    return Board::chr_write(vrc6.chr_addr(addr), data);
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    vrc6.serialize(s);
-  }
-
-  auto main() -> void { vrc6.main(); }
-  auto power() -> void { vrc6.power(); }
-  auto reset() -> void { vrc6.reset(); }
-
-  VRC6 vrc6;
-};

fc/cartridge/board/nes-axrom.cpp

@@ -1,49 +0,0 @@
-//NES-AMROM
-//NES-ANROM
-//NES-AN1ROM
-//NES-AOROM
-
-struct NES_AxROM : Board {
-  NES_AxROM(Markup::Node& document) : Board(document) {
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr & 0x8000) return prgrom.read((prg_bank << 15) | (addr & 0x7fff));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr & 0x8000) {
-      prg_bank = data & 0x0f;
-      mirror_select = data & 0x10;
-    }
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read((mirror_select << 10) | (addr & 0x03ff));
-    return Board::chr_read(addr);
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write((mirror_select << 10) | (addr & 0x03ff), data);
-    return Board::chr_write(addr, data);
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_bank = 0x0f;
-    mirror_select = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-
-    s.integer(prg_bank);
-    s.integer(mirror_select);
-  }
-
-  uint4 prg_bank;
-  bool mirror_select;
-};

fc/cartridge/board/nes-bnrom.cpp

@@ -1,50 +0,0 @@
-//NES-BN-ROM-01
-
-struct NES_BNROM : Board {
-  NES_BNROM(Markup::Node& document) : Board(document) {
-    settings.mirror = document["cartridge/mirror/mode"].text() == "vertical" ? 1 : 0;
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr & 0x8000) return prgrom.read((prg_bank << 15) | (addr & 0x7fff));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr & 0x8000) prg_bank = data & 0x03;
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_read(addr);
-    }
-    return Board::chr_read(addr);
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_write(addr, data);
-    }
-    return Board::chr_write(addr, data);
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_bank = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    s.integer(prg_bank);
-  }
-
-  struct Settings {
-    bool mirror;  //0 = horizontal, 1 = vertical
-  } settings;
-
-  uint2 prg_bank;
-};

fc/cartridge/board/nes-gxrom.cpp

@@ -1,59 +0,0 @@
-//NES-GNROM
-//NES-MHROM
-
-struct NES_GxROM : Board {
-  NES_GxROM(Markup::Node& document) : Board(document) {
-    settings.mirror = document["cartridge/mirror/mode"].text() == "vertical" ? 1 : 0;
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if(addr & 0x8000) return prgrom.read((prg_bank << 15) | (addr & 0x7fff));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr & 0x8000) {
-      prg_bank = (data & 0x30) >> 4;
-      chr_bank = (data & 0x03) >> 0;
-    }
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_read(addr & 0x07ff);
-    }
-    addr = (chr_bank * 0x2000) + (addr & 0x1fff);
-    return Board::chr_read(addr);
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_write(addr & 0x07ff, data);
-    }
-    addr = (chr_bank * 0x2000) + (addr & 0x1fff);
-    Board::chr_write(addr, data);
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_bank = 0;
-    chr_bank = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    s.integer(prg_bank);
-    s.integer(chr_bank);
-  }
-
-  struct Settings {
-    bool mirror;  //0 = horizontal, 1 = vertical
-  } settings;
-
-  uint2 prg_bank;
-  uint2 chr_bank;
-};

fc/cartridge/board/nes-hkrom.cpp

@@ -1,46 +0,0 @@
-struct NES_HKROM : Board {
-  NES_HKROM(Markup::Node& document) : Board(document), mmc6(*this) {
-  }
-
-  auto main() -> void {
-    mmc6.main();
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if((addr & 0xf000) == 0x7000) return mmc6.ram_read(addr);
-    if(addr & 0x8000) return prgrom.read(mmc6.prg_addr(addr));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if((addr & 0xf000) == 0x7000) return mmc6.ram_write(addr, data);
-    if(addr & 0x8000) return mmc6.reg_write(addr, data);
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    mmc6.irq_test(addr);
-    if(addr & 0x2000) return ppu.ciram_read(mmc6.ciram_addr(addr));
-    return Board::chr_read(mmc6.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    mmc6.irq_test(addr);
-    if(addr & 0x2000) return ppu.ciram_write(mmc6.ciram_addr(addr), data);
-    return Board::chr_write(mmc6.chr_addr(addr), data);
-  }
-
-  auto power() -> void {
-    mmc6.power();
-  }
-
-  auto reset() -> void {
-    mmc6.reset();
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    mmc6.serialize(s);
-  }
-
-  MMC6 mmc6;
-};

fc/cartridge/board/nes-sxrom.cpp

@@ -1,99 +0,0 @@
-struct NES_SxROM : Board {
-  NES_SxROM(Markup::Node& document) : Board(document), mmc1(*this) {
-    revision = Revision::SXROM;
-  }
-
-  auto main() -> void {
-    return mmc1.main();
-  }
-
-  auto ram_addr(uint addr) -> uint {
-    uint bank = 0;
-    if(revision == Revision::SOROM) bank = (mmc1.chr_bank[0] & 0x08) >> 3;
-    if(revision == Revision::SUROM) bank = (mmc1.chr_bank[0] & 0x0c) >> 2;
-    if(revision == Revision::SXROM) bank = (mmc1.chr_bank[0] & 0x0c) >> 2;
-    return (bank << 13) | (addr & 0x1fff);
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if((addr & 0xe000) == 0x6000) {
-      if(revision == Revision::SNROM) {
-        if(mmc1.chr_bank[0] & 0x10) return cpu.mdr();
-      }
-      if(mmc1.ram_disable) return 0x00;
-      return prgram.read(ram_addr(addr));
-    }
-
-    if(addr & 0x8000) {
-      addr = mmc1.prg_addr(addr);
-      if(revision == Revision::SXROM) {
-        addr |= ((mmc1.chr_bank[0] & 0x10) >> 4) << 18;
-      }
-      return prgrom.read(addr);
-    }
-
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if((addr & 0xe000) == 0x6000) {
-      if(revision == Revision::SNROM) {
-        if(mmc1.chr_bank[0] & 0x10) return;
-      }
-      if(mmc1.ram_disable) return;
-      return prgram.write(ram_addr(addr), data);
-    }
-
-    if(addr & 0x8000) return mmc1.mmio_write(addr, data);
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) return ppu.ciram_read(mmc1.ciram_addr(addr));
-    return Board::chr_read(mmc1.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) return ppu.ciram_write(mmc1.ciram_addr(addr), data);
-    return Board::chr_write(mmc1.chr_addr(addr), data);
-  }
-
-  auto power() -> void {
-    mmc1.power();
-  }
-
-  auto reset() -> void {
-    mmc1.reset();
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    mmc1.serialize(s);
-  }
-
-  enum class Revision : uint {
-    SAROM,
-    SBROM,
-    SCROM,
-    SC1ROM,
-    SEROM,
-    SFROM,
-    SGROM,
-    SHROM,
-    SH1ROM,
-    SIROM,
-    SJROM,
-    SKROM,
-    SLROM,
-    SL1ROM,
-    SL2ROM,
-    SL3ROM,
-    SLRROM,
-    SMROM,
-    SNROM,
-    SOROM,
-    SUROM,
-    SXROM,
-  } revision;
-
-  MMC1 mmc1;
-};

fc/cartridge/board/nes-txrom.cpp

@@ -1,65 +0,0 @@
-struct NES_TxROM : Board {
-  NES_TxROM(Markup::Node& document) : Board(document), mmc3(*this) {
-    revision = Revision::TLROM;
-  }
-
-  auto main() -> void {
-    mmc3.main();
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if((addr & 0xe000) == 0x6000) return mmc3.ram_read(addr);
-    if(addr & 0x8000) return prgrom.read(mmc3.prg_addr(addr));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if((addr & 0xe000) == 0x6000) return mmc3.ram_write(addr, data);
-    if(addr & 0x8000) return mmc3.reg_write(addr, data);
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    mmc3.irq_test(addr);
-    if(addr & 0x2000) return ppu.ciram_read(mmc3.ciram_addr(addr));
-    return Board::chr_read(mmc3.chr_addr(addr));
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    mmc3.irq_test(addr);
-    if(addr & 0x2000) return ppu.ciram_write(mmc3.ciram_addr(addr), data);
-    return Board::chr_write(mmc3.chr_addr(addr), data);
-  }
-
-  auto power() -> void {
-    mmc3.power();
-  }
-
-  auto reset() -> void {
-    mmc3.reset();
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-    mmc3.serialize(s);
-  }
-
-  enum class Revision : uint {
-    TBROM,
-    TEROM,
-    TFROM,
-    TGROM,
-    TKROM,
-    TKSROM,
-    TLROM,
-    TL1ROM,
-    TL2ROM,
-    TLSROM,
-    TNROM,
-    TQROM,
-    TR1ROM,
-    TSROM,
-    TVROM,
-  } revision;
-
-  MMC3 mmc3;
-};

fc/cartridge/board/nes-uxrom.cpp

@@ -1,53 +0,0 @@
-//NES-UNROM
-//NES-UOROM
-
-struct NES_UxROM : Board {
-  NES_UxROM(Markup::Node& document) : Board(document) {
-    settings.mirror = document["cartridge/mirror/mode"].text() == "vertical" ? 1 : 0;
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if((addr & 0xc000) == 0x8000) return prgrom.read((prg_bank << 14) | (addr & 0x3fff));
-    if((addr & 0xc000) == 0xc000) return prgrom.read((    0x0f << 14) | (addr & 0x3fff));
-    return cpu.mdr();
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if(addr & 0x8000) prg_bank = data & 0x0f;
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_read(addr);
-    }
-    return Board::chr_read(addr);
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) {
-      if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-      return ppu.ciram_write(addr, data);
-    }
-    return Board::chr_write(addr, data);
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_bank = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    Board::serialize(s);
-
-    s.integer(prg_bank);
-  }
-
-  struct Settings {
-    bool mirror;  //0 = horizontal, 1 = vertical
-  } settings;
-
-  uint4 prg_bank;
-};

fc/cartridge/cartridge.cpp

@@ -1,88 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "chip/chip.cpp"
-#include "board/board.cpp"
-Cartridge cartridge;
-
-auto Cartridge::loaded() const -> bool {
-  return _loaded;
-}
-
-auto Cartridge::sha256() const -> string {
-  return _sha256;
-}
-
-auto Cartridge::manifest() const -> string {
-  return information.markup;
-}
-
-auto Cartridge::title() const -> string {
-  return information.title;
-}
-
-auto Cartridge::Main() -> void {
-  cartridge.main();
-}
-
-auto Cartridge::main() -> void {
-  board->main();
-}
-
-auto Cartridge::load() -> void {
-  interface->loadRequest(ID::Manifest, "manifest.bml", true);
-
-  Board::load(information.markup);  //this call will set Cartridge::board if successful
-  if(!board) return;
-
-  Hash::SHA256 sha;
-  sha.data(board->prgrom.data, board->prgrom.size);
-  sha.data(board->chrrom.data, board->chrrom.size);
-  _sha256 = sha.digest();
-
-  system.load();
-  _loaded = true;
-}
-
-auto Cartridge::unload() -> void {
-  if(!loaded()) return;
-  _loaded = false;
-  memory.reset();
-}
-
-auto Cartridge::power() -> void {
-  board->power();
-}
-
-auto Cartridge::reset() -> void {
-  create(Cartridge::Main, 21477272);
-  board->reset();
-}
-
-auto Cartridge::prg_read(uint addr) -> uint8 {
-  return board->prg_read(addr);
-}
-
-auto Cartridge::prg_write(uint addr, uint8 data) -> void {
-  return board->prg_write(addr, data);
-}
-
-auto Cartridge::chr_read(uint addr) -> uint8 {
-  return board->chr_read(addr);
-}
-
-auto Cartridge::chr_write(uint addr, uint8 data) -> void {
-  return board->chr_write(addr, data);
-}
-
-auto Cartridge::scanline(uint y) -> void {
-  return board->scanline(y);
-}
-
-auto Cartridge::serialize(serializer& s) -> void {
-  Thread::serialize(s);
-  return board->serialize(s);
-}
-
-}

fc/cartridge/cartridge.hpp

@@ -1,48 +0,0 @@
-#include "chip/chip.hpp"
-#include "board/board.hpp"
-
-struct Cartridge : Thread {
-  static auto Main() -> void;
-  auto main() -> void;
-
-  auto loaded() const -> bool;
-  auto sha256() const -> string;
-  auto manifest() const -> string;
-  auto title() const -> string;
-
-  auto load() -> void;
-  auto unload() -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  struct Information {
-    string markup;
-    string title;
-  } information;
-
-  struct Memory {
-    unsigned id;
-    string name;
-  };
-  vector<Memory> memory;
-
-//privileged:
-  Board* board = nullptr;
-  bool _loaded = false;
-  string _sha256;
-
-  auto prg_read(uint addr) -> uint8;
-  auto prg_write(uint addr, uint8 data) -> void;
-
-  auto chr_read(uint addr) -> uint8;
-  auto chr_write(uint addr, uint8 data) -> void;
-
-  //scanline() is for debugging purposes only:
-  //boards must detect scanline edges on their own
-  auto scanline(uint y) -> void;
-};
-
-extern Cartridge cartridge;

fc/cartridge/chip/mmc3.cpp

@@ -1,187 +0,0 @@
-struct MMC3 : Chip {
-  MMC3(Board& board) : Chip(board) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_delay) irq_delay--;
-      cpu.set_irq_line(irq_line);
-      tick();
-    }
-  }
-
-  auto irq_test(uint addr) -> void {
-    if(!(chr_abus & 0x1000) && (addr & 0x1000)) {
-      if(irq_delay == 0) {
-        if(irq_counter == 0) {
-          irq_counter = irq_latch;
-        } else if(--irq_counter == 0) {
-          if(irq_enable) irq_line = 1;
-        }
-      }
-      irq_delay = 6;
-    }
-    chr_abus = addr;
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    switch((addr >> 13) & 3) {
-    case 0:
-      if(prg_mode == 1) return (0x3e << 13) | (addr & 0x1fff);
-      return (prg_bank[0] << 13) | (addr & 0x1fff);
-    case 1:
-      return (prg_bank[1] << 13) | (addr & 0x1fff);
-    case 2:
-      if(prg_mode == 0) return (0x3e << 13) | (addr & 0x1fff);
-      return (prg_bank[0] << 13) | (addr & 0x1fff);
-    case 3:
-      return (0x3f << 13) | (addr & 0x1fff);
-    }
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    if(chr_mode == 0) {
-      if(addr <= 0x07ff) return (chr_bank[0] << 10) | (addr & 0x07ff);
-      if(addr <= 0x0fff) return (chr_bank[1] << 10) | (addr & 0x07ff);
-      if(addr <= 0x13ff) return (chr_bank[2] << 10) | (addr & 0x03ff);
-      if(addr <= 0x17ff) return (chr_bank[3] << 10) | (addr & 0x03ff);
-      if(addr <= 0x1bff) return (chr_bank[4] << 10) | (addr & 0x03ff);
-      if(addr <= 0x1fff) return (chr_bank[5] << 10) | (addr & 0x03ff);
-    } else {
-      if(addr <= 0x03ff) return (chr_bank[2] << 10) | (addr & 0x03ff);
-      if(addr <= 0x07ff) return (chr_bank[3] << 10) | (addr & 0x03ff);
-      if(addr <= 0x0bff) return (chr_bank[4] << 10) | (addr & 0x03ff);
-      if(addr <= 0x0fff) return (chr_bank[5] << 10) | (addr & 0x03ff);
-      if(addr <= 0x17ff) return (chr_bank[0] << 10) | (addr & 0x07ff);
-      if(addr <= 0x1fff) return (chr_bank[1] << 10) | (addr & 0x07ff);
-    }
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    if(mirror == 0) return ((addr & 0x0400) >> 0) | (addr & 0x03ff);
-    if(mirror == 1) return ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-  }
-
-  auto ram_read(uint addr) -> uint8 {
-    if(ram_enable) return board.prgram.data[addr & 0x1fff];
-    return 0x00;
-  }
-
-  auto ram_write(uint addr, uint8 data) -> void {
-    if(ram_enable && !ram_write_protect) board.prgram.data[addr & 0x1fff] = data;
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr & 0xe001) {
-    case 0x8000:
-      chr_mode = data & 0x80;
-      prg_mode = data & 0x40;
-      bank_select = data & 0x07;
-      break;
-
-    case 0x8001:
-      switch(bank_select) {
-      case 0: chr_bank[0] = data & ~1; break;
-      case 1: chr_bank[1] = data & ~1; break;
-      case 2: chr_bank[2] = data; break;
-      case 3: chr_bank[3] = data; break;
-      case 4: chr_bank[4] = data; break;
-      case 5: chr_bank[5] = data; break;
-      case 6: prg_bank[0] = data & 0x3f; break;
-      case 7: prg_bank[1] = data & 0x3f; break;
-      }
-      break;
-
-    case 0xa000:
-      mirror = data & 0x01;
-      break;
-
-    case 0xa001:
-      ram_enable = data & 0x80;
-      ram_write_protect = data & 0x40;
-      break;
-
-    case 0xc000:
-      irq_latch = data;
-      break;
-
-    case 0xc001:
-      irq_counter = 0;
-      break;
-
-    case 0xe000:
-      irq_enable = false;
-      irq_line = 0;
-      break;
-
-    case 0xe001:
-      irq_enable = true;
-      break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    chr_mode = 0;
-    prg_mode = 0;
-    bank_select = 0;
-    prg_bank[0] = 0;
-    prg_bank[1] = 0;
-    chr_bank[0] = 0;
-    chr_bank[1] = 0;
-    chr_bank[2] = 0;
-    chr_bank[3] = 0;
-    chr_bank[4] = 0;
-    chr_bank[5] = 0;
-    mirror = 0;
-    ram_enable = 1;
-    ram_write_protect = 0;
-    irq_latch = 0;
-    irq_counter = 0;
-    irq_enable = false;
-    irq_delay = 0;
-    irq_line = 0;
-
-    chr_abus = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.integer(chr_mode);
-    s.integer(prg_mode);
-    s.integer(bank_select);
-    s.array(prg_bank);
-    s.array(chr_bank);
-    s.integer(mirror);
-    s.integer(ram_enable);
-    s.integer(ram_write_protect);
-    s.integer(irq_latch);
-    s.integer(irq_counter);
-    s.integer(irq_enable);
-    s.integer(irq_delay);
-    s.integer(irq_line);
-
-    s.integer(chr_abus);
-  }
-
-  bool chr_mode;
-  bool prg_mode;
-  uint3 bank_select;
-  uint8 prg_bank[2];
-  uint8 chr_bank[6];
-  bool mirror;
-  bool ram_enable;
-  bool ram_write_protect;
-  uint8 irq_latch;
-  uint8 irq_counter;
-  bool irq_enable;
-  uint irq_delay;
-  bool irq_line;
-
-  uint16 chr_abus;
-};

fc/cartridge/chip/mmc5.cpp

@@ -1,495 +0,0 @@
-struct MMC5 : Chip {
-  MMC5(Board& board) : Chip(board) {
-    revision = Revision::MMC5;
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      //scanline() resets this; if no scanlines detected, enter video blanking period
-      if(++cpu_cycle_counter >= 200) blank();  //113-114 normal; ~2500 across Vblank period
-
-      cpu.set_irq_line(irq_enable && irq_pending);
-      tick();
-    }
-  }
-
-  auto scanline(uint y) -> void {
-  //used for testing only, to verify MMC5 scanline detection is accurate:
-  //if(y != vcounter && y <= 240) print(y, " vs ", vcounter, "\n");
-  }
-
-  auto prg_access(bool write, uint addr, uint8 data = 0x00) -> uint8 {
-    uint bank;
-
-    if((addr & 0xe000) == 0x6000) {
-      bank = (ram_select << 2) | ram_bank;
-      addr &= 0x1fff;
-    } else if(prg_mode == 0) {
-      bank = prg_bank[3] & ~3;
-      addr &= 0x7fff;
-    } else if(prg_mode == 1) {
-      if((addr & 0xc000) == 0x8000) bank = (prg_bank[1] & ~1);
-      if((addr & 0xe000) == 0xc000) bank = (prg_bank[3] & ~1);
-      addr &= 0x3fff;
-    } else if(prg_mode == 2) {
-      if((addr & 0xe000) == 0x8000) bank = (prg_bank[1] & ~1) | 0;
-      if((addr & 0xe000) == 0xa000) bank = (prg_bank[1] & ~1) | 1;
-      if((addr & 0xe000) == 0xc000) bank = (prg_bank[2]);
-      if((addr & 0xe000) == 0xe000) bank = (prg_bank[3]);
-      addr &= 0x1fff;
-    } else if(prg_mode == 3) {
-      if((addr & 0xe000) == 0x8000) bank = prg_bank[0];
-      if((addr & 0xe000) == 0xa000) bank = prg_bank[1];
-      if((addr & 0xe000) == 0xc000) bank = prg_bank[2];
-      if((addr & 0xe000) == 0xe000) bank = prg_bank[3];
-      addr &= 0x1fff;
-    }
-
-    bool rom = bank & 0x80;
-    bank &= 0x7f;
-
-    if(write == false) {
-      if(rom) {
-        return board.prgrom.read((bank << 13) | addr);
-      } else {
-        return board.prgram.read((bank << 13) | addr);
-      }
-    } else {
-      if(rom) {
-        board.prgrom.write((bank << 13) | addr, data);
-      } else {
-        if(prgram_write_protect[0] == 2 && prgram_write_protect[1] == 1) {
-          board.prgram.write((bank << 13) | addr, data);
-        }
-      }
-      return 0x00;
-    }
-  }
-
-  auto prg_read(uint addr) -> uint8 {
-    if((addr & 0xfc00) == 0x5c00) {
-      if(exram_mode >= 2) return exram[addr & 0x03ff];
-      return cpu.mdr();
-    }
-
-    if(addr >= 0x6000) {
-      return prg_access(0, addr);
-    }
-
-    switch(addr) {
-    case 0x5204: {
-      uint8 result = (irq_pending << 7) | (in_frame << 6);
-      irq_pending = false;
-      return result;
-    }
-    case 0x5205: return (multiplier * multiplicand) >> 0;
-    case 0x5206: return (multiplier * multiplicand) >> 8;
-    }
-  }
-
-  auto prg_write(uint addr, uint8 data) -> void {
-    if((addr & 0xfc00) == 0x5c00) {
-      //writes 0x00 *during* Vblank (not during screen rendering ...)
-      if(exram_mode == 0 || exram_mode == 1) exram[addr & 0x03ff] = in_frame ? data : 0x00;
-      if(exram_mode == 2) exram[addr & 0x03ff] = data;
-      return;
-    }
-
-    if(addr >= 0x6000) {
-      prg_access(1, addr, data);
-      return;
-    }
-
-    switch(addr) {
-    case 0x2000:
-      sprite_8x16 = data & 0x20;
-      break;
-
-    case 0x2001:
-      //if BG+sprites are disabled; enter video blanking period
-      if((data & 0x18) == 0) blank();
-      break;
-
-    case 0x5100: prg_mode = data & 3; break;
-    case 0x5101: chr_mode = data & 3; break;
-
-    case 0x5102: prgram_write_protect[0] = data & 3; break;
-    case 0x5103: prgram_write_protect[1] = data & 3; break;
-
-    case 0x5104:
-      exram_mode = data & 3;
-      break;
-
-    case 0x5105:
-      nametable_mode[0] = (data & 0x03) >> 0;
-      nametable_mode[1] = (data & 0x0c) >> 2;
-      nametable_mode[2] = (data & 0x30) >> 4;
-      nametable_mode[3] = (data & 0xc0) >> 6;
-      break;
-
-    case 0x5106:
-      fillmode_tile = data;
-      break;
-
-    case 0x5107:
-      fillmode_color = data & 3;
-      fillmode_color |= fillmode_color << 2;
-      fillmode_color |= fillmode_color << 4;
-      break;
-
-    case 0x5113:
-      ram_select = data & 0x04;
-      ram_bank = data & 0x03;
-      break;
-
-    case 0x5114: prg_bank[0] = data; break;
-    case 0x5115: prg_bank[1] = data; break;
-    case 0x5116: prg_bank[2] = data; break;
-    case 0x5117: prg_bank[3] = data | 0x80; break;
-
-    case 0x5120: chr_sprite_bank[0] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5121: chr_sprite_bank[1] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5122: chr_sprite_bank[2] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5123: chr_sprite_bank[3] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5124: chr_sprite_bank[4] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5125: chr_sprite_bank[5] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5126: chr_sprite_bank[6] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-    case 0x5127: chr_sprite_bank[7] = (chr_bank_hi << 8) | data; chr_active = 0; break;
-
-    case 0x5128: chr_bg_bank[0] = (chr_bank_hi << 8) | data; chr_active = 1; break;
-    case 0x5129: chr_bg_bank[1] = (chr_bank_hi << 8) | data; chr_active = 1; break;
-    case 0x512a: chr_bg_bank[2] = (chr_bank_hi << 8) | data; chr_active = 1; break;
-    case 0x512b: chr_bg_bank[3] = (chr_bank_hi << 8) | data; chr_active = 1; break;
-
-    case 0x5130:
-      chr_bank_hi = data & 3;
-      break;
-
-    case 0x5200:
-      vs_enable = data & 0x80;
-      vs_side = data & 0x40;
-      vs_tile = data & 0x1f;
-      break;
-
-    case 0x5201:
-      vs_scroll = data;
-      break;
-
-    case 0x5202:
-      vs_bank = data;
-      break;
-
-    case 0x5203:
-      irq_line = data;
-      break;
-
-    case 0x5204:
-      irq_enable = data & 0x80;
-      break;
-
-    case 0x5205:
-      multiplicand = data;
-      break;
-
-    case 0x5206:
-      multiplier = data;
-      break;
-    }
-  }
-
-  auto chr_sprite_addr(uint addr) -> uint {
-    if(chr_mode == 0) {
-      auto bank = chr_sprite_bank[7];
-      return (bank * 0x2000) + (addr & 0x1fff);
-    }
-
-    if(chr_mode == 1) {
-      auto bank = chr_sprite_bank[(addr / 0x1000) * 4 + 3];
-      return (bank * 0x1000) + (addr & 0x0fff);
-    }
-
-    if(chr_mode == 2) {
-      auto bank = chr_sprite_bank[(addr / 0x0800) * 2 + 1];
-      return (bank * 0x0800) + (addr & 0x07ff);
-    }
-
-    if(chr_mode == 3) {
-      auto bank = chr_sprite_bank[(addr / 0x0400)];
-      return (bank * 0x0400) + (addr & 0x03ff);
-    }
-  }
-
-  auto chr_bg_addr(uint addr) -> uint {
-    addr &= 0x0fff;
-
-    if(chr_mode == 0) {
-      auto bank = chr_bg_bank[3];
-      return (bank * 0x2000) + (addr & 0x0fff);
-    }
-
-    if(chr_mode == 1) {
-      auto bank = chr_bg_bank[3];
-      return (bank * 0x1000) + (addr & 0x0fff);
-    }
-
-    if(chr_mode == 2) {
-      auto bank = chr_bg_bank[(addr / 0x0800) * 2 + 1];
-      return (bank * 0x0800) + (addr & 0x07ff);
-    }
-
-    if(chr_mode == 3) {
-      auto bank = chr_bg_bank[(addr / 0x0400)];
-      return (bank * 0x0400) + (addr & 0x03ff);
-    }
-  }
-
-  auto chr_vs_addr(uint addr) -> uint {
-    return (vs_bank * 0x1000) + (addr & 0x0ff8) + (vs_vpos & 7);
-  }
-
-  auto blank() -> void {
-    in_frame = false;
-  }
-
-  auto scanline() -> void {
-    hcounter = 0;
-
-    if(in_frame == false) {
-      in_frame = true;
-      irq_pending = false;
-      vcounter = 0;
-    } else {
-      if(vcounter == irq_line) irq_pending = true;
-      vcounter++;
-    }
-
-    cpu_cycle_counter = 0;
-  }
-
-  auto ciram_read(uint addr) -> uint8 {
-    if(vs_fetch && (hcounter & 2) == 0) return exram[vs_vpos / 8 * 32 + vs_hpos / 8];
-    if(vs_fetch && (hcounter & 2) != 0) return exram[vs_vpos / 32 * 8 + vs_hpos / 32 + 0x03c0];
-
-    switch(nametable_mode[(addr >> 10) & 3]) {
-    case 0: return ppu.ciram_read(0x0000 | (addr & 0x03ff));
-    case 1: return ppu.ciram_read(0x0400 | (addr & 0x03ff));
-    case 2: return exram_mode < 2 ? exram[addr & 0x03ff] : 0x00;
-    case 3: return (hcounter & 2) == 0 ? fillmode_tile : fillmode_color;
-    }
-  }
-
-  auto chr_read(uint addr) -> uint8 {
-    chr_access[0] = chr_access[1];
-    chr_access[1] = chr_access[2];
-    chr_access[2] = chr_access[3];
-    chr_access[3] = addr;
-
-    //detect two unused nametable fetches at end of each scanline
-    if((chr_access[0] & 0x2000) == 0
-    && (chr_access[1] & 0x2000)
-    && (chr_access[2] & 0x2000)
-    && (chr_access[3] & 0x2000)) scanline();
-
-    if(in_frame == false) {
-      vs_fetch = false;
-      if(addr & 0x2000) return ciram_read(addr);
-      return board.chrrom.read(chr_active ? chr_bg_addr(addr) : chr_sprite_addr(addr));
-    }
-
-    bool bg_fetch = (hcounter < 256 || hcounter >= 320);
-    uint8 result = 0x00;
-
-    if((hcounter & 7) == 0) {
-      vs_hpos  = hcounter >= 320 ? hcounter - 320 : hcounter + 16;
-      vs_vpos  = vcounter + vs_scroll;
-      vs_fetch = vs_enable && bg_fetch && exram_mode < 2
-      && (vs_side ? vs_hpos / 8 >= vs_tile : vs_hpos / 8 < vs_tile);
-      if(vs_vpos >= 240) vs_vpos -= 240;
-
-      result = ciram_read(addr);
-
-      exbank = (chr_bank_hi << 6) | (exram[addr & 0x03ff] & 0x3f);
-      exattr = exram[addr & 0x03ff] >> 6;
-      exattr |= exattr << 2;
-      exattr |= exattr << 4;
-    } else if((hcounter & 7) == 2) {
-      result = ciram_read(addr);
-      if(bg_fetch && exram_mode == 1) result = exattr;
-    } else {
-      if(vs_fetch) result = board.chrrom.read(chr_vs_addr(addr));
-      else if(sprite_8x16 ? bg_fetch : chr_active) result = board.chrrom.read(chr_bg_addr(addr));
-      else result = board.chrrom.read(chr_sprite_addr(addr));
-      if(bg_fetch && exram_mode == 1) result = board.chrrom.read(exbank * 0x1000 + (addr & 0x0fff));
-    }
-
-    hcounter += 2;
-    return result;
-  }
-
-  auto chr_write(uint addr, uint8 data) -> void {
-    if(addr & 0x2000) {
-      switch(nametable_mode[(addr >> 10) & 3]) {
-      case 0: return ppu.ciram_write(0x0000 | (addr & 0x03ff), data);
-      case 1: return ppu.ciram_write(0x0400 | (addr & 0x03ff), data);
-      case 2: exram[addr & 0x03ff] = data; break;
-      }
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    for(auto& n : exram) n = 0xff;
-
-    prg_mode = 3;
-    chr_mode = 0;
-    for(auto& n : prgram_write_protect) n = 0;
-    exram_mode = 0;
-    for(auto& n : nametable_mode) n = 0;
-    fillmode_tile = 0;
-    fillmode_color = 0;
-    ram_select = 0;
-    ram_bank = 0;
-    prg_bank[0] = 0x00;
-    prg_bank[1] = 0x00;
-    prg_bank[2] = 0x00;
-    prg_bank[3] = 0xff;
-    for(auto& n : chr_sprite_bank) n = 0;
-    for(auto& n : chr_bg_bank) n = 0;
-    chr_bank_hi = 0;
-    vs_enable = 0;
-    vs_side = 0;
-    vs_tile = 0;
-    vs_scroll = 0;
-    vs_bank = 0;
-    irq_line = 0;
-    irq_enable = 0;
-    multiplicand = 0;
-    multiplier = 0;
-
-    cpu_cycle_counter = 0;
-    irq_counter = 0;
-    irq_pending = 0;
-    in_frame = 0;
-    vcounter = 0;
-    hcounter = 0;
-    for(auto& n : chr_access) n = 0;
-    chr_active = 0;
-    sprite_8x16 = 0;
-
-    exbank = 0;
-    exattr = 0;
-
-    vs_fetch = 0;
-    vs_vpos = 0;
-    vs_hpos = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.array(exram);
-
-    s.integer(prg_mode);
-    s.integer(chr_mode);
-    for(auto& n : prgram_write_protect) s.integer(n);
-    s.integer(exram_mode);
-    for(auto& n : nametable_mode) s.integer(n);
-    s.integer(fillmode_tile);
-    s.integer(fillmode_color);
-    s.integer(ram_select);
-    s.integer(ram_bank);
-    for(auto& n : prg_bank) s.integer(n);
-    for(auto& n : chr_sprite_bank) s.integer(n);
-    for(auto& n : chr_bg_bank) s.integer(n);
-    s.integer(chr_bank_hi);
-    s.integer(vs_enable);
-    s.integer(vs_side);
-    s.integer(vs_tile);
-    s.integer(vs_scroll);
-    s.integer(vs_bank);
-    s.integer(irq_line);
-    s.integer(irq_enable);
-    s.integer(multiplicand);
-    s.integer(multiplier);
-
-    s.integer(cpu_cycle_counter);
-    s.integer(irq_counter);
-    s.integer(irq_pending);
-    s.integer(in_frame);
-
-    s.integer(vcounter);
-    s.integer(hcounter);
-    for(auto& n : chr_access) s.integer(n);
-    s.integer(chr_active);
-    s.integer(sprite_8x16);
-
-    s.integer(exbank);
-    s.integer(exattr);
-
-    s.integer(vs_fetch);
-    s.integer(vs_vpos);
-    s.integer(vs_hpos);
-  }
-
-  enum class Revision : uint {
-    MMC5,
-    MMC5B,
-  } revision;
-
-  uint8 exram[1024];
-
-  //programmable registers
-
-  uint2 prg_mode;  //$5100
-  uint2 chr_mode;  //$5101
-
-  uint2 prgram_write_protect[2];  //$5102,$5103
-
-  uint2 exram_mode;         //$5104
-  uint2 nametable_mode[4];  //$5105
-  uint8 fillmode_tile;      //$5106
-  uint8 fillmode_color;     //$5107
-
-  bool ram_select;            //$5113
-  uint2 ram_bank;             //$5113
-  uint8 prg_bank[4];          //$5114-5117
-  uint10 chr_sprite_bank[8];  //$5120-5127
-  uint10 chr_bg_bank[4];      //$5128-512b
-  uint2 chr_bank_hi;          //$5130
-
-  bool vs_enable;      //$5200
-  bool vs_side;        //$5200
-  uint5 vs_tile;       //$5200
-  uint8 vs_scroll;     //$5201
-  uint8 vs_bank;       //$5202
-
-  uint8 irq_line;      //$5203
-  bool irq_enable;     //$5204
-
-  uint8 multiplicand;  //$5205
-  uint8 multiplier;    //$5206
-
-  //status registers
-
-  uint cpu_cycle_counter;
-  uint irq_counter;
-  bool irq_pending;
-  bool in_frame;
-
-  uint vcounter;
-  uint hcounter;
-  uint16 chr_access[4];
-  bool chr_active;
-  bool sprite_8x16;
-
-  uint8 exbank;
-  uint8 exattr;
-
-  bool vs_fetch;
-  uint8 vs_vpos;
-  uint8 vs_hpos;
-};

fc/cartridge/chip/mmc6.cpp

@@ -1,198 +0,0 @@
-struct MMC6 : Chip {
-  MMC6(Board& board) : Chip(board) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_delay) irq_delay--;
-      cpu.set_irq_line(irq_line);
-      tick();
-    }
-  }
-
-  auto irq_test(uint addr) -> void {
-    if(!(chr_abus & 0x1000) && (addr & 0x1000)) {
-      if(irq_delay == 0) {
-        if(irq_counter == 0) {
-          irq_counter = irq_latch;
-        } else if(--irq_counter == 0) {
-          if(irq_enable) irq_line = 1;
-        }
-      }
-      irq_delay = 6;
-    }
-    chr_abus = addr;
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    switch((addr >> 13) & 3) {
-    case 0:
-      if(prg_mode == 1) return (0x3e << 13) | (addr & 0x1fff);
-      return (prg_bank[0] << 13) | (addr & 0x1fff);
-    case 1:
-      return (prg_bank[1] << 13) | (addr & 0x1fff);
-    case 2:
-      if(prg_mode == 0) return (0x3e << 13) | (addr & 0x1fff);
-      return (prg_bank[0] << 13) | (addr & 0x1fff);
-    case 3:
-      return (0x3f << 13) | (addr & 0x1fff);
-    }
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    if(chr_mode == 0) {
-      if(addr <= 0x07ff) return (chr_bank[0] << 10) | (addr & 0x07ff);
-      if(addr <= 0x0fff) return (chr_bank[1] << 10) | (addr & 0x07ff);
-      if(addr <= 0x13ff) return (chr_bank[2] << 10) | (addr & 0x03ff);
-      if(addr <= 0x17ff) return (chr_bank[3] << 10) | (addr & 0x03ff);
-      if(addr <= 0x1bff) return (chr_bank[4] << 10) | (addr & 0x03ff);
-      if(addr <= 0x1fff) return (chr_bank[5] << 10) | (addr & 0x03ff);
-    } else {
-      if(addr <= 0x03ff) return (chr_bank[2] << 10) | (addr & 0x03ff);
-      if(addr <= 0x07ff) return (chr_bank[3] << 10) | (addr & 0x03ff);
-      if(addr <= 0x0bff) return (chr_bank[4] << 10) | (addr & 0x03ff);
-      if(addr <= 0x0fff) return (chr_bank[5] << 10) | (addr & 0x03ff);
-      if(addr <= 0x17ff) return (chr_bank[0] << 10) | (addr & 0x07ff);
-      if(addr <= 0x1fff) return (chr_bank[1] << 10) | (addr & 0x07ff);
-    }
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    if(mirror == 0) return ((addr & 0x0400) >> 0) | (addr & 0x03ff);
-    if(mirror == 1) return ((addr & 0x0800) >> 1) | (addr & 0x03ff);
-  }
-
-  auto ram_read(uint addr) -> uint8 {
-    if(ram_enable == false) return cpu.mdr();
-    if(ram_readable[0] == false && ram_readable[1] == false) return cpu.mdr();
-    bool region = addr & 0x0200;
-    if(ram_readable[region] == false) return 0x00;
-    return board.prgram.read((region * 0x0200) + (addr & 0x01ff));
-  }
-
-  auto ram_write(uint addr, uint8 data) -> void {
-    if(ram_enable == false) return;
-    bool region = addr & 0x0200;
-    if(ram_writable[region] == false) return;
-    return board.prgram.write((region * 0x0200) + (addr & 0x01ff), data);
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr & 0xe001) {
-    case 0x8000:
-      chr_mode = data & 0x80;
-      prg_mode = data & 0x40;
-      ram_enable = data & 0x20;
-      bank_select = data & 0x07;
-      if(ram_enable == false) {
-        for(auto &n : ram_readable) n = false;
-        for(auto &n : ram_writable) n = false;
-      }
-      break;
-
-    case 0x8001:
-      switch(bank_select) {
-      case 0: chr_bank[0] = data & ~1; break;
-      case 1: chr_bank[1] = data & ~1; break;
-      case 2: chr_bank[2] = data; break;
-      case 3: chr_bank[3] = data; break;
-      case 4: chr_bank[4] = data; break;
-      case 5: chr_bank[5] = data; break;
-      case 6: prg_bank[0] = data & 0x3f; break;
-      case 7: prg_bank[1] = data & 0x3f; break;
-      }
-      break;
-
-    case 0xa000:
-      mirror = data & 0x01;
-      break;
-
-    case 0xa001:
-      if(ram_enable == false) break;
-      ram_readable[1] = data & 0x80;
-      ram_writable[1] = data & 0x40;
-      ram_readable[0] = data & 0x20;
-      ram_writable[0] = data & 0x10;
-      break;
-
-    case 0xc000:
-      irq_latch = data;
-      break;
-
-    case 0xc001:
-      irq_counter = 0;
-      break;
-
-    case 0xe000:
-      irq_enable = false;
-      irq_line = 0;
-      break;
-
-    case 0xe001:
-      irq_enable = true;
-      break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    chr_mode = 0;
-    prg_mode = 0;
-    ram_enable = 0;
-    bank_select = 0;
-    for(auto& n : prg_bank) n = 0;
-    for(auto& n : chr_bank) n = 0;
-    mirror = 0;
-    for(auto& n : ram_readable) n = 0;
-    for(auto& n : ram_writable) n = 0;
-    irq_latch = 0;
-    irq_counter = 0;
-    irq_enable = 0;
-    irq_delay = 0;
-    irq_line = 0;
-
-    chr_abus = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.integer(chr_mode);
-    s.integer(prg_mode);
-    s.integer(ram_enable);
-    s.integer(bank_select);
-    for(auto& n : prg_bank) s.integer(n);
-    for(auto& n : chr_bank) s.integer(n);
-    s.integer(mirror);
-    for(auto& n : ram_readable) s.integer(n);
-    for(auto& n : ram_writable) s.integer(n);
-    s.integer(irq_latch);
-    s.integer(irq_counter);
-    s.integer(irq_enable);
-    s.integer(irq_delay);
-    s.integer(irq_line);
-
-    s.integer(chr_abus);
-  }
-
-  bool chr_mode;
-  bool prg_mode;
-  bool ram_enable;
-  uint3 bank_select;
-  uint8 prg_bank[2];
-  uint8 chr_bank[6];
-  bool mirror;
-  bool ram_readable[2];
-  bool ram_writable[2];
-  uint8 irq_latch;
-  uint8 irq_counter;
-  bool irq_enable;
-  uint irq_delay;
-  bool irq_line;
-
-  uint16 chr_abus;
-};

fc/cartridge/chip/vrc1.cpp

@@ -1,78 +0,0 @@
-struct VRC1 : Chip {
-  VRC1(Board& board) : Chip(board) {
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    uint bank = 0x0f;
-    if((addr & 0xe000) == 0x8000) bank = prg_bank[0];
-    if((addr & 0xe000) == 0xa000) bank = prg_bank[1];
-    if((addr & 0xe000) == 0xc000) bank = prg_bank[2];
-    return (bank * 0x2000) + (addr & 0x1fff);
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    uint bank = chr_banklo[(bool)(addr & 0x1000)];
-    bank |= chr_bankhi[(bool)(addr & 0x1000)] << 4;
-    return (bank * 0x1000) + (addr & 0x0fff);  
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    switch(mirror) {
-    case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff);  //vertical mirroring
-    case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff);  //horizontal mirroring
-    }
-    throw;
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr & 0xf000) {
-    case 0x8000:
-      prg_bank[0] = data & 0x0f;
-      break;
-
-    case 0x9000:
-      chr_bankhi[1] = data & 0x04;
-      chr_bankhi[0] = data & 0x02;
-      mirror = data & 0x01;
-      break;
-
-    case 0xa000:
-      prg_bank[1] = data & 0x0f;
-      break;
-
-    case 0xc000:
-      prg_bank[2] = data & 0x0f;
-      break;
-
-    case 0xe000:
-      chr_banklo[0] = data & 0x0f;
-      break;
-
-    case 0xf000:
-      chr_banklo[1] = data & 0x0f;
-      break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    for(auto& n : prg_bank) n = 0;
-    for(auto& n : chr_banklo) n = 0;
-    for(auto& n : chr_bankhi) n = 0;
-    mirror = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    for(auto& n : prg_bank) s.integer(n);
-    for(auto& n : chr_banklo) s.integer(n);
-    for(auto& n : chr_bankhi) s.integer(n);
-    s.integer(mirror);
-  }
-
-  uint4 prg_bank[3];
-  uint4 chr_banklo[2];
-  bool chr_bankhi[2];
-  bool mirror;
-};

fc/cartridge/chip/vrc2.cpp

@@ -1,108 +0,0 @@
-struct VRC2 : Chip {
-  VRC2(Board& board) : Chip(board) {
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    uint bank;
-    switch(addr & 0xe000) {
-    case 0x8000: bank = prg_bank[0]; break;
-    case 0xa000: bank = prg_bank[1]; break;
-    case 0xc000: bank = 0x1e; break;
-    case 0xe000: bank = 0x1f; break;
-    }
-    return (bank * 0x2000) + (addr & 0x1fff);
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    uint bank = chr_bank[addr / 0x0400];
-    return (bank * 0x0400) + (addr & 0x03ff);
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    switch(mirror) {
-    case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff);  //vertical mirroring
-    case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff);  //horizontal mirroring
-    case 2: return 0x0000 | (addr & 0x03ff);                  //one-screen mirroring (first)
-    case 3: return 0x0400 | (addr & 0x03ff);                  //one-screen mirroring (second)
-    }
-    throw;
-  }
-
-  auto ram_read(uint addr) -> uint8 {
-    if(board.prgram.size == 0) {
-      if((addr & 0xf000) == 0x6000) return cpu.mdr() | latch;
-      return cpu.mdr();
-    }
-    return board.prgram.read(addr & 0x1fff);
-  }
-
-  auto ram_write(uint addr, uint8 data) -> void {
-    if(board.prgram.size == 0) {
-      if((addr & 0xf000) == 0x6000) latch = data & 0x01;
-      return;
-    }
-    return board.prgram.write(addr & 0x1fff, data);
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr) {
-    case 0x8000: case 0x8001: case 0x8002: case 0x8003:
-      prg_bank[0] = data & 0x1f;
-      break;
-
-    case 0x9000: case 0x9001: case 0x9002: case 0x9003:
-      mirror = data & 0x03;
-      break;
-
-    case 0xa000: case 0xa001: case 0xa002: case 0xa003:
-      prg_bank[1] = data & 0x1f;
-      break;
-
-    case 0xb000: chr_bank[0] = (chr_bank[0] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xb001: chr_bank[0] = (chr_bank[0] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xb002: chr_bank[1] = (chr_bank[1] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xb003: chr_bank[1] = (chr_bank[1] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xc000: chr_bank[2] = (chr_bank[2] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xc001: chr_bank[2] = (chr_bank[2] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xc002: chr_bank[3] = (chr_bank[3] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xc003: chr_bank[3] = (chr_bank[3] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xd000: chr_bank[4] = (chr_bank[4] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xd001: chr_bank[4] = (chr_bank[4] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xd002: chr_bank[5] = (chr_bank[5] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xd003: chr_bank[5] = (chr_bank[5] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xe000: chr_bank[6] = (chr_bank[6] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xe001: chr_bank[6] = (chr_bank[6] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xe002: chr_bank[7] = (chr_bank[7] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xe003: chr_bank[7] = (chr_bank[7] & 0x0f) | ((data & 0x0f) << 4); break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    for(auto& n : prg_bank) n = 0;
-    for(auto& n : chr_bank) n = 0;
-    mirror = 0;
-    latch = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    for(auto& n : prg_bank) s.integer(n);
-    for(auto& n : chr_bank) s.integer(n);
-    s.integer(mirror);
-    s.integer(latch);
-  }
-
-  uint5 prg_bank[2];
-  uint8 chr_bank[8];
-  uint2 mirror;
-  bool latch;
-};

fc/cartridge/chip/vrc3.cpp

@@ -1,98 +0,0 @@
-struct VRC3 : Chip {
-  VRC3(Board& board) : Chip(board) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_enable) {
-        if(irq_mode == 0) {  //16-bit
-          if(++irq_counter.w == 0) {
-            irq_line = 1;
-            irq_enable = irq_acknowledge;
-            irq_counter.w = irq_latch;
-          }
-        }
-        if(irq_mode == 1) {  //8-bit
-          if(++irq_counter.l == 0) {
-            irq_line = 1;
-            irq_enable = irq_acknowledge;
-            irq_counter.l = irq_latch;
-          }
-        }
-      }
-
-      cpu.set_irq_line(irq_line);
-      tick();
-    }
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    uint bank = (addr < 0xc000 ? (uint)prg_bank : 0x0f);
-    return (bank * 0x4000) + (addr & 0x3fff);
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr & 0xf000) {
-    case 0x8000: irq_latch = (irq_latch & 0xfff0) | ((data & 0x0f) <<  0); break;
-    case 0x9000: irq_latch = (irq_latch & 0xff0f) | ((data & 0x0f) <<  4); break;
-    case 0xa000: irq_latch = (irq_latch & 0xf0ff) | ((data & 0x0f) <<  8); break;
-    case 0xb000: irq_latch = (irq_latch & 0x0fff) | ((data & 0x0f) << 12); break;
-
-    case 0xc000:
-      irq_mode = data & 0x04;
-      irq_enable = data & 0x02;
-      irq_acknowledge = data & 0x01;
-      if(irq_enable) irq_counter.w = irq_latch;
-      break;
-
-    case 0xd000:
-      irq_line = 0;
-      irq_enable = irq_acknowledge;
-      break;
-
-    case 0xf000:
-      prg_bank = data & 0x0f;
-      break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_bank = 0;
-    irq_mode = 0;
-    irq_enable = 0;
-    irq_acknowledge = 0;
-    irq_latch = 0;
-    irq_counter.w = 0;
-    irq_line = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.integer(prg_bank);
-    s.integer(irq_mode);
-    s.integer(irq_enable);
-    s.integer(irq_acknowledge);
-    s.integer(irq_latch);
-    s.integer(irq_counter.w);
-    s.integer(irq_line);
-  }
-
-  uint4 prg_bank;
-  bool irq_mode;
-  bool irq_enable;
-  bool irq_acknowledge;
-  uint16 irq_latch;
-  struct {
-    union {
-      uint16 w;
-      struct { uint8 order_lsb2(l, h); };
-    };
-  } irq_counter;
-  bool irq_line;
-};

fc/cartridge/chip/vrc4.cpp

@@ -1,182 +0,0 @@
-struct VRC4 : Chip {
-  VRC4(Board& board) : Chip(board) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_enable) {
-        if(irq_mode == 0) {
-          irq_scalar -= 3;
-          if(irq_scalar <= 0) {
-            irq_scalar += 341;
-            if(irq_counter == 0xff) {
-              irq_counter = irq_latch;
-              irq_line = 1;
-            } else {
-              irq_counter++;
-            }
-          }
-        }
-
-        if(irq_mode == 1) {
-          if(irq_counter == 0xff) {
-            irq_counter = irq_latch;
-            irq_line = 1;
-          } else {
-            irq_counter++;
-          }
-        }
-      }
-
-      cpu.set_irq_line(irq_line);
-      tick();
-    }
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    uint bank = 0, banks = board.prgrom.size / 0x2000;
-    switch(addr & 0xe000) {
-    case 0x8000: bank = prg_mode == 0 ? (unsigned)prg_bank[0] : banks - 2; break;
-    case 0xa000: bank = prg_bank[1]; break;
-    case 0xc000: bank = prg_mode == 0 ? banks - 2 : (unsigned)prg_bank[0]; break;
-    case 0xe000: bank = banks - 1; break;
-    }
-    return (bank * 0x2000) + (addr & 0x1fff);
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    uint bank = chr_bank[addr / 0x0400];
-    return (bank * 0x0400) + (addr & 0x03ff);
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    switch(mirror) {
-    case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff);  //vertical mirroring
-    case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff);  //horizontal mirroring
-    case 2: return 0x0000 | (addr & 0x03ff);                  //one-screen mirroring (first)
-    case 3: return 0x0400 | (addr & 0x03ff);                  //one-screen mirroring (second)
-    }
-    throw;
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr) {
-    case 0x8000: case 0x8001: case 0x8002: case 0x8003:
-      prg_bank[0] = data & 0x1f;
-      break;
-
-    case 0x9000: case 0x9001:
-      mirror = data & 0x03;
-      break;
-
-    case 0x9002: case 0x9003:
-      prg_mode = data & 0x02;
-      break;
-
-    case 0xa000: case 0xa001: case 0xa002: case 0xa003:
-      prg_bank[1] = data & 0x1f;
-      break;
-
-    case 0xb000: chr_bank[0] = (chr_bank[0] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xb001: chr_bank[0] = (chr_bank[0] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xb002: chr_bank[1] = (chr_bank[1] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xb003: chr_bank[1] = (chr_bank[1] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xc000: chr_bank[2] = (chr_bank[2] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xc001: chr_bank[2] = (chr_bank[2] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xc002: chr_bank[3] = (chr_bank[3] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xc003: chr_bank[3] = (chr_bank[3] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xd000: chr_bank[4] = (chr_bank[4] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xd001: chr_bank[4] = (chr_bank[4] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xd002: chr_bank[5] = (chr_bank[5] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xd003: chr_bank[5] = (chr_bank[5] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xe000: chr_bank[6] = (chr_bank[6] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xe001: chr_bank[6] = (chr_bank[6] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xe002: chr_bank[7] = (chr_bank[7] & 0xf0) | ((data & 0x0f) << 0); break;
-    case 0xe003: chr_bank[7] = (chr_bank[7] & 0x0f) | ((data & 0x0f) << 4); break;
-
-    case 0xf000:
-      irq_latch = (irq_latch & 0xf0) | ((data & 0x0f) << 0);
-      break;
-
-    case 0xf001:
-      irq_latch = (irq_latch & 0x0f) | ((data & 0x0f) << 4);
-      break;
-
-    case 0xf002:
-      irq_mode = data & 0x04;
-      irq_enable = data & 0x02;
-      irq_acknowledge = data & 0x01;
-      if(irq_enable) {
-        irq_counter = irq_latch;
-        irq_scalar = 341;
-      }
-      irq_line = 0;
-      break;
-
-    case 0xf003:
-      irq_enable = irq_acknowledge;
-      irq_line = 0;
-      break;
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    prg_mode = 0;
-    for(auto& n : prg_bank) n = 0;
-    mirror = 0;
-    for(auto& n : chr_bank) n = 0;
-
-    irq_latch = 0;
-    irq_mode = 0;
-    irq_enable = 0;
-    irq_acknowledge = 0;
-
-    irq_counter = 0;
-    irq_scalar = 0;
-    irq_line = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.integer(prg_mode);
-    for(auto& n : prg_bank) s.integer(n);
-    s.integer(mirror);
-    for(auto& n : chr_bank) s.integer(n);
-
-    s.integer(irq_latch);
-    s.integer(irq_mode);
-    s.integer(irq_enable);
-    s.integer(irq_acknowledge);
-
-    s.integer(irq_counter);
-    s.integer(irq_scalar);
-    s.integer(irq_line);
-  }
-
-  bool prg_mode;
-  uint5 prg_bank[2];
-  uint2 mirror;
-  uint8 chr_bank[8];
-
-  uint8 irq_latch;
-  bool irq_mode;
-  bool irq_enable;
-  bool irq_acknowledge;
-
-  uint8 irq_counter;
-  int irq_scalar;
-  bool irq_line;
-};

fc/cartridge/chip/vrc7.cpp

@@ -1,152 +0,0 @@
-//Konami VRC7
-//Yamaha YM2413 OPLL audio - not emulated
-
-struct VRC7 : Chip {
-  VRC7(Board& board) : Chip(board) {
-  }
-
-  auto main() -> void {
-    while(true) {
-      if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-        scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-      }
-
-      if(irq_enable) {
-        if(irq_mode == 0) {
-          irq_scalar -= 3;
-          if(irq_scalar <= 0) {
-            irq_scalar += 341;
-            if(irq_counter == 0xff) {
-              irq_counter = irq_latch;
-              irq_line = 1;
-            } else {
-              irq_counter++;
-            }
-          }
-        }
-
-        if(irq_mode == 1) {
-          if(irq_counter == 0xff) {
-            irq_counter = irq_latch;
-            irq_line = 1;
-          } else {
-            irq_counter++;
-          }
-        }
-      }
-      cpu.set_irq_line(irq_line);
-
-      tick();
-    }
-  }
-
-  auto reg_write(uint addr, uint8 data) -> void {
-    switch(addr) {
-    case 0x8000: prg_bank[0] = data; break;
-    case 0x8010: prg_bank[1] = data; break;
-    case 0x9000: prg_bank[2] = data; break;
-    case 0x9010: break;  //APU addr port
-    case 0x9030: break;  //APU data port
-    case 0xa000: chr_bank[0] = data; break;
-    case 0xa010: chr_bank[1] = data; break;
-    case 0xb000: chr_bank[2] = data; break;
-    case 0xb010: chr_bank[3] = data; break;
-    case 0xc000: chr_bank[4] = data; break;
-    case 0xc010: chr_bank[5] = data; break;
-    case 0xd000: chr_bank[6] = data; break;
-    case 0xd010: chr_bank[7] = data; break;
-    case 0xe000: mirror = data & 0x03; break;
-
-    case 0xe010:
-      irq_latch = data;
-      break;
-
-    case 0xf000:
-      irq_mode = data & 0x04;
-      irq_enable = data & 0x02;
-      irq_acknowledge = data & 0x01;
-      if(irq_enable) {
-        irq_counter = irq_latch;
-        irq_scalar = 341;
-      }
-      irq_line = 0;
-      break;
-
-    case 0xf010:
-      irq_enable = irq_acknowledge;
-      irq_line = 0;
-      break;
-    }
-  }
-
-  auto prg_addr(uint addr) const -> uint {
-    uint bank = 0;
-    switch(addr & 0xe000) {
-    case 0x8000: bank = prg_bank[0]; break;
-    case 0xa000: bank = prg_bank[1]; break;
-    case 0xc000: bank = prg_bank[2]; break;
-    case 0xe000: bank = 0xff; break;
-    }
-    return (bank * 0x2000) + (addr & 0x1fff);
-  }
-
-  auto chr_addr(uint addr) const -> uint {
-    uint bank = chr_bank[addr / 0x0400];
-    return (bank * 0x0400) + (addr & 0x03ff);
-  }
-
-  auto ciram_addr(uint addr) const -> uint {
-    switch(mirror) {
-    case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff);  //vertical mirroring
-    case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff);  //horizontal mirroring
-    case 2: return 0x0000 | (addr & 0x03ff);                  //one-screen mirroring (first)
-    case 3: return 0x0400 | (addr & 0x03ff);                  //one-screen mirroring (second)
-    }
-  }
-
-  auto power() -> void {
-  }
-
-  auto reset() -> void {
-    for(auto& n : prg_bank) n = 0;
-    for(auto& n : chr_bank) n = 0;
-    mirror = 0;
-
-    irq_latch = 0;
-    irq_mode = 0;
-    irq_enable = 0;
-    irq_acknowledge = 0;
-
-    irq_counter = 0;
-    irq_scalar = 0;
-    irq_line = 0;
-  }
-
-  auto serialize(serializer& s) -> void {
-    s.array(prg_bank);
-    s.array(chr_bank);
-    s.integer(mirror);
-
-    s.integer(irq_latch);
-    s.integer(irq_mode);
-    s.integer(irq_enable);
-    s.integer(irq_acknowledge);
-
-    s.integer(irq_counter);
-    s.integer(irq_scalar);
-    s.integer(irq_line);
-  }
-
-  uint8 prg_bank[3];
-  uint8 chr_bank[8];
-  uint2 mirror;
-
-  uint8 irq_latch;
-  bool irq_mode;
-  bool irq_enable;
-  bool irq_acknowledge;
-
-  uint8 irq_counter;
-  int irq_scalar;
-  bool irq_line;
-};

fc/cpu/cpu.cpp

@@ -1,111 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "timing.cpp"
-#include "serialization.cpp"
-CPU cpu;
-
-auto CPU::Enter() -> void {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    cpu.main();
-  }
-}
-
-auto CPU::main() -> void {
-  if(status.interrupt_pending) {
-    interrupt();
-    return;
-  }
-
-  exec();
-}
-
-auto CPU::add_clocks(uint clocks) -> void {
-  apu.clock -= clocks;
-  if(apu.clock < 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(apu.thread);
-
-  ppu.clock -= clocks;
-  if(ppu.clock < 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(ppu.thread);
-
-  cartridge.clock -= clocks;
-  if(cartridge.clock < 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(cartridge.thread);
-}
-
-auto CPU::power() -> void {
-  R6502::power();
-
-  for(auto addr : range(0x0800)) ram[addr] = 0xff;
-  ram[0x0008] = 0xf7;
-  ram[0x0009] = 0xef;
-  ram[0x000a] = 0xdf;
-  ram[0x000f] = 0xbf;
-}
-
-auto CPU::reset() -> void {
-  R6502::reset();
-  create(CPU::Enter, 21477272);
-
-  regs.pc  = bus.read(0xfffc) << 0;
-  regs.pc |= bus.read(0xfffd) << 8;
-
-  status.interrupt_pending = false;
-  status.nmi_pending = false;
-  status.nmi_line = 0;
-  status.irq_line = 0;
-  status.irq_apu_line = 0;
-
-  status.rdy_line = 1;
-  status.rdy_addr_valid = false;
-  status.rdy_addr_value = 0x0000;
-
-  status.oam_dma_pending = false;
-  status.oam_dma_page = 0x00;
-
-  status.controller_latch = false;
-  status.controller_port0 = 0;
-  status.controller_port1 = 0;
-}
-
-auto CPU::debugger_read(uint16 addr) -> uint8 {
-  return bus.read(addr);
-}
-
-auto CPU::ram_read(uint16 addr) -> uint8 {
-  return ram[addr & 0x07ff];
-}
-
-auto CPU::ram_write(uint16 addr, uint8 data) -> void {
-  ram[addr & 0x07ff] = data;
-}
-
-auto CPU::read(uint16 addr) -> uint8 {
-  if(addr == 0x4016) {
-    return (mdr() & 0xc0) | input.data(0);
-  }
-
-  if(addr == 0x4017) {
-    return (mdr() & 0xc0) | input.data(1);
-  }
-
-  return apu.read(addr);
-}
-
-auto CPU::write(uint16 addr, uint8 data) -> void {
-  if(addr == 0x4014) {
-    status.oam_dma_page = data;
-    status.oam_dma_pending = true;
-  }
-
-  if(addr == 0x4016) {
-    input.latch(data & 0x01);
-  }
-
-  return apu.write(addr, data);
-}
-
-}

fc/cpu/cpu.hpp

@@ -1,57 +0,0 @@
-struct CPU : Processor::R6502, Thread {
-  static auto Enter() -> void;
-  auto main() -> void;
-  auto add_clocks(uint clocks) -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto debugger_read(uint16 addr) -> uint8;
-
-  auto ram_read(uint16 addr) -> uint8;
-  auto ram_write(uint16 addr, uint8 data) -> void;
-
-  auto read(uint16 addr) -> uint8;
-  auto write(uint16 addr, uint8 data) -> void;
-
-  auto serialize(serializer&) -> void;
-
-  //timing.cpp
-  auto op_read(uint16 addr) -> uint8;
-  auto op_write(uint16 addr, uint8 data) -> void;
-  auto last_cycle() -> void;
-  auto nmi(uint16& vector) -> void;
-
-  auto oam_dma() -> void;
-
-  auto set_nmi_line(bool) -> void;
-  auto set_irq_line(bool) -> void;
-  auto set_irq_apu_line(bool) -> void;
-
-  auto set_rdy_line(bool) -> void;
-  auto set_rdy_addr(bool valid, uint16 value = 0) -> void;
-
-//protected:
-  uint8 ram[0x0800];
-
-  struct Status {
-    bool interrupt_pending;
-    bool nmi_pending;
-    bool nmi_line;
-    bool irq_line;
-    bool irq_apu_line;
-
-    bool rdy_line;
-    bool rdy_addr_valid;
-    uint16 rdy_addr_value;
-
-    bool oam_dma_pending;
-    uint8 oam_dma_page;
-
-    bool controller_latch;
-    uint controller_port0;
-    uint controller_port1;
-  } status;
-};
-
-extern CPU cpu;

fc/cpu/serialization.cpp

@@ -1,23 +0,0 @@
-auto CPU::serialize(serializer& s) -> void {
-  R6502::serialize(s);
-  Thread::serialize(s);
-
-  s.array(ram);
-
-  s.integer(status.interrupt_pending);
-  s.integer(status.nmi_pending);
-  s.integer(status.nmi_line);
-  s.integer(status.irq_line);
-  s.integer(status.irq_apu_line);
-
-  s.integer(status.rdy_line);
-  s.integer(status.rdy_addr_valid);
-  s.integer(status.rdy_addr_value);
-
-  s.integer(status.oam_dma_pending);
-  s.integer(status.oam_dma_page);
-
-  s.integer(status.controller_latch);
-  s.integer(status.controller_port0);
-  s.integer(status.controller_port1);
-}

fc/cpu/timing.cpp

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

fc/input/input.cpp

@@ -1,53 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "serialization.cpp"
-Input input;
-
-auto Input::latch(bool data) -> void {
-  latchdata = data;
-
-  if(latchdata == 1) {
-    counter1 = 0;
-    counter2 = 0;
-  }
-}
-
-auto Input::data(bool port) -> bool {
-  bool result = 0;
-
-  if(port == 0) {
-    if(port1 == Device::Joypad) {
-      if(counter1 >= 8) return 1;
-      result = interface->inputPoll(0, 0u, counter1);
-      if(latchdata == 0) counter1++;
-    }
-  }
-
-  if(port == 1) {
-    if(port2 == Device::Joypad) {
-      if(counter2 >= 8) return 1;
-      result = interface->inputPoll(1, 0u, counter2);
-      if(latchdata == 0) counter2++;
-    }
-  }
-
-  return result;
-}
-
-auto Input::connect(bool port, Device device) -> void {
-  if(port == 0) port1 = device, counter1 = 0;
-  if(port == 1) port2 = device, counter2 = 0;
-}
-
-auto Input::power() -> void {
-}
-
-auto Input::reset() -> void {
-  latchdata = 0;
-  counter1 = 0;
-  counter2 = 0;
-}
-
-}

fc/input/input.hpp

@@ -1,25 +0,0 @@
-struct Input {
-  enum class Device : uint {
-    Joypad,
-    None,
-  };
-
-  auto latch(bool data) -> void;
-  auto data(bool port) -> bool;
-  auto connect(bool port, Device device) -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto serialize(serializer&) -> void;
-
-private:
-  Device port1;
-  Device port2;
-
-  bool latchdata;
-  uint counter1;
-  uint counter2;
-};
-
-extern Input input;

fc/input/serialization.cpp

@@ -1,8 +0,0 @@
-auto Input::serialize(serializer& s) -> void {
-  s.integer((uint&)port1);
-  s.integer((uint&)port2);
-
-  s.integer(latchdata);
-  s.integer(counter1);
-  s.integer(counter2);
-}

fc/interface/interface.cpp

@@ -1,173 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-Interface* interface = nullptr;
-
-Interface::Interface() {
-  interface = this;
-
-  information.name        = "Famicom";
-  information.width       = 256;
-  information.height      = 240;
-  information.overscan    = true;
-  information.aspectRatio = 8.0 / 7.0;
-  information.resettable  = true;
-  information.capability.states = true;
-  information.capability.cheats = true;
-
-  media.append({ID::Famicom, "Famicom", "fc", true});
-
-  { Device device{0, ID::Port1 | ID::Port2, "Controller"};
-    device.input.append({0, 0, "A"     });
-    device.input.append({1, 0, "B"     });
-    device.input.append({2, 0, "Select"});
-    device.input.append({3, 0, "Start" });
-    device.input.append({4, 0, "Up"    });
-    device.input.append({5, 0, "Down"  });
-    device.input.append({6, 0, "Left"  });
-    device.input.append({7, 0, "Right" });
-    device.order = {4, 5, 6, 7, 1, 0, 2, 3};
-    this->device.append(device);
-  }
-
-  port.append({0, "Port 1"});
-  port.append({1, "Port 2"});
-
-  for(auto& device : this->device) {
-    for(auto& port : this->port) {
-      if(device.portmask & (1 << port.id)) {
-        port.device.append(device);
-      }
-    }
-  }
-}
-
-auto Interface::manifest() -> string {
-  return cartridge.manifest();
-}
-
-auto Interface::title() -> string {
-  return cartridge.title();
-}
-
-auto Interface::videoFrequency() -> double {
-  return 21477272.0 / (262.0 * 1364.0 - 4.0);
-}
-
-auto Interface::audioFrequency() -> double {
-  return 21477272.0 / 12.0;
-}
-
-auto Interface::loaded() -> bool {
-  return cartridge.loaded();
-}
-
-auto Interface::sha256() -> string {
-  return cartridge.sha256();
-}
-
-auto Interface::group(uint id) -> uint {
-  switch(id) {
-  case ID::SystemManifest:
-    return 0;
-  case ID::Manifest:
-  case ID::ProgramROM:
-  case ID::ProgramRAM:
-  case ID::CharacterROM:
-  case ID::CharacterRAM:
-    return 1;
-  }
-
-  throw;
-}
-
-auto Interface::load(uint id) -> void {
-  cartridge.load();
-}
-
-auto Interface::save() -> void {
-  for(auto& memory : cartridge.memory) {
-    saveRequest(memory.id, memory.name);
-  }
-}
-
-auto Interface::load(uint id, const stream& stream) -> void {
-  if(id == ID::SystemManifest) {
-    system.information.manifest = stream.text();
-  }
-
-  if(id == ID::Manifest) {
-    cartridge.information.markup = stream.text();
-  }
-
-  if(id == ID::ProgramROM) {
-    stream.read(cartridge.board->prgrom.data, min(cartridge.board->prgrom.size, stream.size()));
-  }
-
-  if(id == ID::ProgramRAM) {
-    stream.read(cartridge.board->prgram.data, min(cartridge.board->prgram.size, stream.size()));
-  }
-
-  if(id == ID::CharacterROM) {
-    stream.read(cartridge.board->chrrom.data, min(cartridge.board->chrrom.size, stream.size()));
-  }
-
-  if(id == ID::CharacterRAM) {
-    stream.read(cartridge.board->chrram.data, min(cartridge.board->chrram.size, stream.size()));
-  }
-}
-
-auto Interface::save(uint id, const stream& stream) -> void {
-  if(id == ID::ProgramRAM) {
-    stream.write(cartridge.board->prgram.data, cartridge.board->prgram.size);
-  }
-
-  if(id == ID::CharacterRAM) {
-    stream.write(cartridge.board->chrram.data, cartridge.board->chrram.size);
-  }
-}
-
-auto Interface::unload() -> void {
-  save();
-  cartridge.unload();
-}
-
-auto Interface::power() -> void {
-  system.power();
-}
-
-auto Interface::reset() -> void {
-  system.reset();
-}
-
-auto Interface::run() -> void {
-  system.run();
-}
-
-auto Interface::serialize() -> serializer {
-  system.runtosave();
-  return system.serialize();
-}
-
-auto Interface::unserialize(serializer& s) -> bool {
-  return system.unserialize(s);
-}
-
-auto Interface::cheatSet(const lstring& list) -> void {
-  cheat.reset();
-  for(auto& codeset : list) {
-    lstring codes = codeset.split("+");
-    for(auto& code : codes) {
-      lstring part = code.split("/");
-      if(part.size() == 2) cheat.append(hex(part[0]), hex(part[1]));
-      if(part.size() == 3) cheat.append(hex(part[0]), hex(part[1]), hex(part[2]));
-    }
-  }
-}
-
-auto Interface::paletteUpdate(PaletteMode mode) -> void {
-  video.generate_palette(mode);
-}
-
-}

fc/interface/interface.hpp

@@ -1,63 +0,0 @@
-#ifndef FC_HPP
-namespace Famicom {
-#endif
-
-struct ID {
-  enum : uint {
-    System,
-    Famicom,
-  };
-
-  enum : uint {
-    SystemManifest,
-
-    Manifest,
-    ProgramROM,
-    ProgramRAM,
-    CharacterROM,
-    CharacterRAM,
-  };
-
-  enum : uint {
-    Port1 = 1,
-    Port2 = 2,
-  };
-};
-
-struct Interface : Emulator::Interface {
-  Interface();
-
-  auto manifest() -> string;
-  auto title() -> string;
-  auto videoFrequency() -> double;
-  auto audioFrequency() -> double;
-
-  auto loaded() -> bool;
-  auto sha256() -> string;
-  auto group(uint id) -> uint;
-  auto load(uint id) -> void;
-  auto save() -> void;
-  auto load(uint id, const stream& stream) -> void;
-  auto save(uint id, const stream& stream) -> void;
-  auto unload() -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-  auto run() -> void;
-
-  auto serialize() -> serializer;
-  auto unserialize(serializer&) -> bool;
-
-  auto cheatSet(const lstring&) -> void;
-
-  auto paletteUpdate(PaletteMode mode) -> void;
-
-private:
-  vector<Device> device;
-};
-
-extern Interface* interface;
-
-#ifndef FC_HPP
-}
-#endif

fc/ppu/ppu.cpp

@@ -1,487 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "serialization.cpp"
-PPU ppu;
-
-auto PPU::Main() -> void {
-  ppu.main();
-}
-
-auto PPU::main() -> void {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::PPU) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    raster_scanline();
-  }
-}
-
-auto PPU::tick() -> void {
-  if(status.ly == 240 && status.lx == 340) status.nmi_hold = 1;
-  if(status.ly == 241 && status.lx ==   0) status.nmi_flag = status.nmi_hold;
-  if(status.ly == 241 && status.lx ==   2) cpu.set_nmi_line(status.nmi_enable && status.nmi_flag);
-
-  if(status.ly == 260 && status.lx == 340) status.sprite_zero_hit = 0, status.sprite_overflow = 0;
-
-  if(status.ly == 260 && status.lx == 340) status.nmi_hold = 0;
-  if(status.ly == 261 && status.lx ==   0) status.nmi_flag = status.nmi_hold;
-  if(status.ly == 261 && status.lx ==   2) cpu.set_nmi_line(status.nmi_enable && status.nmi_flag);
-
-  clock += 4;
-  if(clock >= 0) co_switch(cpu.thread);
-
-  status.lx++;
-}
-
-auto PPU::scanline() -> void {
-  status.lx = 0;
-  if(++status.ly == 262) {
-    status.ly = 0;
-    frame();
-  }
-  cartridge.scanline(status.ly);
-}
-
-auto PPU::frame() -> void {
-  status.field ^= 1;
-  scheduler.exit(Scheduler::ExitReason::FrameEvent);
-}
-
-auto PPU::power() -> void {
-}
-
-auto PPU::reset() -> void {
-  create(PPU::Main, 21477272);
-
-  status.mdr = 0x00;
-  status.field = 0;
-  status.ly = 0;
-  status.bus_data = 0x00;
-  status.address_latch = 0;
-
-  status.vaddr = 0x0000;
-  status.taddr = 0x0000;
-  status.xaddr = 0x00;
-
-  status.nmi_hold = 0;
-  status.nmi_flag = 0;
-
-  //$2000
-  status.nmi_enable = false;
-  status.master_select = 0;
-  status.sprite_size = 0;
-  status.bg_addr = 0x0000;
-  status.sprite_addr = 0x0000;
-  status.vram_increment = 1;
-
-  //$2001
-  status.emphasis = 0;
-  status.sprite_enable = false;
-  status.bg_enable = false;
-  status.sprite_edge_enable = false;
-  status.bg_edge_enable = false;
-  status.grayscale = false;
-
-  //$2002
-  status.sprite_zero_hit = false;
-  status.sprite_overflow = false;
-
-  //$2003
-  status.oam_addr = 0x00;
-
-  for(auto& n : buffer) n = 0;
-  for(auto& n : ciram ) n = 0;
-  for(auto& n : cgram ) n = 0;
-  for(auto& n : oam   ) n = 0;
-}
-
-auto PPU::read(uint16 addr) -> uint8 {
-  uint8 result = 0x00;
-
-  switch(addr & 7) {
-  case 2:  //PPUSTATUS
-    result |= status.nmi_flag << 7;
-    result |= status.sprite_zero_hit << 6;
-    result |= status.sprite_overflow << 5;
-    result |= status.mdr & 0x1f;
-    status.address_latch = 0;
-    status.nmi_hold = 0;
-    cpu.set_nmi_line(status.nmi_flag = 0);
-    break;
-  case 4:  //OAMDATA
-    result = oam[status.oam_addr];
-    if((status.oam_addr & 3) == 3) result &= 0xe3;
-    break;
-  case 7:  //PPUDATA
-    if(raster_enable() && (status.ly <= 240 || status.ly == 261)) return 0x00;
-
-    addr = status.vaddr & 0x3fff;
-    if(addr <= 0x1fff) {
-      result = status.bus_data;
-      status.bus_data = cartridge.chr_read(addr);
-    } else if(addr <= 0x3eff) {
-      result = status.bus_data;
-      status.bus_data = cartridge.chr_read(addr);
-    } else if(addr <= 0x3fff) {
-      result = cgram_read(addr);
-      status.bus_data = cartridge.chr_read(addr);
-    }
-    status.vaddr += status.vram_increment;
-    break;
-  }
-
-  return result;
-}
-
-auto PPU::write(uint16 addr, uint8 data) -> void {
-  status.mdr = data;
-
-  switch(addr & 7) {
-  case 0:  //PPUCTRL
-    status.nmi_enable = data & 0x80;
-    status.master_select = data & 0x40;
-    status.sprite_size = data & 0x20;
-    status.bg_addr = (data & 0x10) ? 0x1000 : 0x0000;
-    status.sprite_addr = (data & 0x08) ? 0x1000 : 0x0000;
-    status.vram_increment = (data & 0x04) ? 32 : 1;
-    status.taddr = (status.taddr & 0x73ff) | ((data & 0x03) << 10);
-    cpu.set_nmi_line(status.nmi_enable && status.nmi_hold && status.nmi_flag);
-    return;
-  case 1:  //PPUMASK
-    status.emphasis = data >> 5;
-    status.sprite_enable = data & 0x10;
-    status.bg_enable = data & 0x08;
-    status.sprite_edge_enable = data & 0x04;
-    status.bg_edge_enable = data & 0x02;
-    status.grayscale = data & 0x01;
-    return;
-  case 2:  //PPUSTATUS
-    return;
-  case 3:  //OAMADDR
-    status.oam_addr = data;
-    return;
-  case 4:  //OAMDATA
-    oam[status.oam_addr++] = data;
-    return;
-  case 5:  //PPUSCROLL
-    if(status.address_latch == 0) {
-      status.xaddr = data & 0x07;
-      status.taddr = (status.taddr & 0x7fe0) | (data >> 3);
-    } else {
-      status.taddr = (status.taddr & 0x0c1f) | ((data & 0x07) << 12) | ((data >> 3) << 5);
-    }
-    status.address_latch ^= 1;
-    return;
-  case 6:  //PPUADDR
-    if(status.address_latch == 0) {
-      status.taddr = (status.taddr & 0x00ff) | ((data & 0x3f) << 8);
-    } else {
-      status.taddr = (status.taddr & 0x7f00) | data;
-      status.vaddr = status.taddr;
-    }
-    status.address_latch ^= 1;
-    return;
-  case 7:  //PPUDATA
-    if(raster_enable() && (status.ly <= 240 || status.ly == 261)) return;
-
-    addr = status.vaddr & 0x3fff;
-    if(addr <= 0x1fff) {
-      cartridge.chr_write(addr, data);
-    } else if(addr <= 0x3eff) {
-      cartridge.chr_write(addr, data);
-    } else if(addr <= 0x3fff) {
-      cgram_write(addr, data);
-    }
-    status.vaddr += status.vram_increment;
-    return;
-  }
-}
-
-auto PPU::ciram_read(uint16 addr) -> uint8 {
-  return ciram[addr & 0x07ff];
-}
-
-auto PPU::ciram_write(uint16 addr, uint8 data) -> void {
-  ciram[addr & 0x07ff] = data;
-}
-
-auto PPU::cgram_read(uint16 addr) -> uint8 {
-  if((addr & 0x13) == 0x10) addr &= ~0x10;
-  uint8 data = cgram[addr & 0x1f];
-  if(status.grayscale) data &= 0x30;
-  return data;
-}
-
-auto PPU::cgram_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0x13) == 0x10) addr &= ~0x10;
-  cgram[addr & 0x1f] = data;
-}
-
-//
-
-//vaddr = 0yyy VHYY  YYYX XXXX
-//yyy = fine Yscroll (y:d0-d2)
-//V = V nametable (y:d8)
-//H = H nametable (x:d8)
-//YYYYY = Y nametable (y:d3-d7)
-//XXXXX = X nametable (x:d3-d7)
-
-auto PPU::raster_enable() const -> bool {
-  return (status.bg_enable || status.sprite_enable);
-}
-
-auto PPU::nametable_addr() const -> uint {
-  return 0x2000 + (status.vaddr & 0x0c00);
-}
-
-auto PPU::scrollx() const -> uint {
-  return ((status.vaddr & 0x1f) << 3) | status.xaddr;
-}
-
-auto PPU::scrolly() const -> uint {
-  return (((status.vaddr >> 5) & 0x1f) << 3) | ((status.vaddr >> 12) & 7);
-}
-
-auto PPU::sprite_height() const -> uint {
-  return status.sprite_size == 0 ? 8 : 16;
-}
-
-//
-
-auto PPU::chr_load(uint16 addr) -> uint8 {
-  if(raster_enable() == false) return 0x00;
-  return cartridge.chr_read(addr);
-}
-
-//
-
-auto PPU::scrollx_increment() -> void {
-  if(raster_enable() == false) return;
-  status.vaddr = (status.vaddr & 0x7fe0) | ((status.vaddr + 0x0001) & 0x001f);
-  if((status.vaddr & 0x001f) == 0x0000) {
-    status.vaddr ^= 0x0400;
-  }
-}
-
-auto PPU::scrolly_increment() -> void {
-  if(raster_enable() == false) return;
-  status.vaddr = (status.vaddr & 0x0fff) | ((status.vaddr + 0x1000) & 0x7000);
-  if((status.vaddr & 0x7000) == 0x0000) {
-    status.vaddr = (status.vaddr & 0x7c1f) | ((status.vaddr + 0x0020) & 0x03e0);
-    if((status.vaddr & 0x03e0) == 0x03c0) {  //0x03c0 == 30 << 5; 30 * 8 = 240
-      status.vaddr &= 0x7c1f;
-      status.vaddr ^= 0x0800;
-    }
-  }
-}
-
-//
-
-auto PPU::raster_pixel() -> void {
-  uint32* output = buffer + status.ly * 256;
-
-  uint mask = 0x8000 >> (status.xaddr + (status.lx & 7));
-  uint palette = 0, object_palette = 0;
-  bool object_priority = 0;
-  palette |= (raster.tiledatalo & mask) ? 1 : 0;
-  palette |= (raster.tiledatahi & mask) ? 2 : 0;
-  if(palette) {
-    uint attr = raster.attribute;
-    if(mask >= 256) attr >>= 2;
-    palette |= (attr & 3) << 2;
-  }
-
-  if(status.bg_enable == false) palette = 0;
-  if(status.bg_edge_enable == false && status.lx < 8) palette = 0;
-
-  if(status.sprite_enable == true)
-  for(int sprite = 7; sprite >= 0; sprite--) {
-    if(status.sprite_edge_enable == false && status.lx < 8) continue;
-    if(raster.oam[sprite].id == 64) continue;
-
-    uint spritex = status.lx - raster.oam[sprite].x;
-    if(spritex >= 8) continue;
-
-    if(raster.oam[sprite].attr & 0x40) spritex ^= 7;
-    uint mask = 0x80 >> spritex;
-    uint sprite_palette = 0;
-    sprite_palette |= (raster.oam[sprite].tiledatalo & mask) ? 1 : 0;
-    sprite_palette |= (raster.oam[sprite].tiledatahi & mask) ? 2 : 0;
-    if(sprite_palette == 0) continue;
-
-    if(raster.oam[sprite].id == 0 && palette && status.lx != 255) status.sprite_zero_hit = 1;
-    sprite_palette |= (raster.oam[sprite].attr & 3) << 2;
-
-    object_priority = raster.oam[sprite].attr & 0x20;
-    object_palette = 16 + sprite_palette;
-  }
-
-  if(object_palette) {
-    if(palette == 0 || object_priority == 0) palette = object_palette;
-  }
-
-  if(raster_enable() == false) palette = 0;
-  output[status.lx] = (status.emphasis << 6) | cgram_read(palette);
-}
-
-auto PPU::raster_sprite() -> void {
-  if(raster_enable() == false) return;
-
-  uint n = raster.oam_iterator++;
-  int ly = (status.ly == 261 ? -1 : status.ly);
-  uint y = ly - oam[(n * 4) + 0];
-
-  if(y >= sprite_height()) return;
-  if(raster.oam_counter == 8) {
-    status.sprite_overflow = 1;
-    return;
-  }
-
-  raster.soam[raster.oam_counter].id   = n;
-  raster.soam[raster.oam_counter].y    = oam[(n * 4) + 0];
-  raster.soam[raster.oam_counter].tile = oam[(n * 4) + 1];
-  raster.soam[raster.oam_counter].attr = oam[(n * 4) + 2];
-  raster.soam[raster.oam_counter].x    = oam[(n * 4) + 3];
-  raster.oam_counter++;
-}
-
-auto PPU::raster_scanline() -> void {
-  if((status.ly >= 240 && status.ly <= 260)) {
-    for(auto x : range(341)) tick();
-    return scanline();
-  }
-
-  raster.oam_iterator = 0;
-  raster.oam_counter = 0;
-
-  for(auto n : range(8)) {
-    raster.soam[n].id   = 64;
-    raster.soam[n].y    = 0xff;
-    raster.soam[n].tile = 0xff;
-    raster.soam[n].attr = 0xff;
-    raster.soam[n].x    = 0xff;
-    raster.soam[n].tiledatalo = 0;
-    raster.soam[n].tiledatahi = 0;
-  }
-
-  for(uint tile : range(32)) {  //  0-255
-    uint nametable = chr_load(0x2000 | (status.vaddr & 0x0fff));
-    uint tileaddr = status.bg_addr + (nametable << 4) + (scrolly() & 7);
-    raster_pixel();
-    tick();
-
-    raster_pixel();
-    tick();
-
-    uint attribute = chr_load(0x23c0 | (status.vaddr & 0x0fc0) | ((scrolly() >> 5) << 3) | (scrollx() >> 5));
-    if(scrolly() & 16) attribute >>= 4;
-    if(scrollx() & 16) attribute >>= 2;
-    raster_pixel();
-    tick();
-
-    scrollx_increment();
-    if(tile == 31) scrolly_increment();
-    raster_pixel();
-    raster_sprite();
-    tick();
-
-    uint tiledatalo = chr_load(tileaddr + 0);
-    raster_pixel();
-    tick();
-
-    raster_pixel();
-    tick();
-
-    uint tiledatahi = chr_load(tileaddr + 8);
-    raster_pixel();
-    tick();
-
-    raster_pixel();
-    raster_sprite();
-    tick();
-
-    raster.nametable = (raster.nametable << 8) | nametable;
-    raster.attribute = (raster.attribute << 2) | (attribute & 3);
-    raster.tiledatalo = (raster.tiledatalo << 8) | tiledatalo;
-    raster.tiledatahi = (raster.tiledatahi << 8) | tiledatahi;
-  }
-
-  for(auto n : range(8)) raster.oam[n] = raster.soam[n];
-
-  for(uint sprite : range(8)) {  //256-319
-    uint nametable = chr_load(0x2000 | (status.vaddr & 0x0fff));
-    tick();
-
-    if(raster_enable() && sprite == 0) status.vaddr = (status.vaddr & 0x7be0) | (status.taddr & 0x041f);  //257
-    tick();
-
-    uint attribute = chr_load(0x23c0 | (status.vaddr & 0x0fc0) | ((scrolly() >> 5) << 3) | (scrollx() >> 5));
-    uint tileaddr = (sprite_height() == 8)
-    ? status.sprite_addr + raster.oam[sprite].tile * 16
-    : ((raster.oam[sprite].tile & ~1) * 16) + ((raster.oam[sprite].tile & 1) * 0x1000);
-    tick();
-    tick();
-
-    uint spritey = (status.ly - raster.oam[sprite].y) & (sprite_height() - 1);
-    if(raster.oam[sprite].attr & 0x80) spritey ^= (sprite_height() - 1);
-    tileaddr += spritey + (spritey & 8);
-
-    raster.oam[sprite].tiledatalo = chr_load(tileaddr + 0);
-    tick();
-    tick();
-
-    raster.oam[sprite].tiledatahi = chr_load(tileaddr + 8);
-    tick();
-    tick();
-
-    if(raster_enable() && sprite == 6 && status.ly == 261) status.vaddr = status.taddr;  //304
-  }
-
-  for(uint tile : range(2)) {  //320-335
-    uint nametable = chr_load(0x2000 | (status.vaddr & 0x0fff));
-    uint tileaddr = status.bg_addr + (nametable << 4) + (scrolly() & 7);
-    tick();
-    tick();
-
-    uint attribute = chr_load(0x23c0 | (status.vaddr & 0x0fc0) | ((scrolly() >> 5) << 3) | (scrollx() >> 5));
-    if(scrolly() & 16) attribute >>= 4;
-    if(scrollx() & 16) attribute >>= 2;
-    tick();
-
-    scrollx_increment();
-    tick();
-
-    uint tiledatalo = chr_load(tileaddr + 0);
-    tick();
-    tick();
-
-    uint tiledatahi = chr_load(tileaddr + 8);
-    tick();
-    tick();
-
-    raster.nametable = (raster.nametable << 8) | nametable;
-    raster.attribute = (raster.attribute << 2) | (attribute & 3);
-    raster.tiledatalo = (raster.tiledatalo << 8) | tiledatalo;
-    raster.tiledatahi = (raster.tiledatahi << 8) | tiledatahi;
-  }
-
-  //336-339
-  chr_load(0x2000 | (status.vaddr & 0x0fff));
-  tick();
-  bool skip = (raster_enable() && status.field == 1 && status.ly == 261);
-  tick();
-
-  chr_load(0x2000 | (status.vaddr & 0x0fff));
-  tick();
-  tick();
-
-  //340
-  if(skip == false) tick();
-
-  return scanline();
-}
-
-}

fc/ppu/ppu.hpp

@@ -1,107 +0,0 @@
-struct PPU : Thread {
-  static auto Main() -> void;
-  auto main() -> void;
-  auto tick() -> void;
-
-  auto scanline() -> void;
-  auto frame() -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto read(uint16 addr) -> uint8;
-  auto write(uint16 addr, uint8 data) -> void;
-
-  auto ciram_read(uint16 addr) -> uint8;
-  auto ciram_write(uint16 addr, uint8 data) -> void;
-
-  auto cgram_read(uint16 addr) -> uint8;
-  auto cgram_write(uint16 addr, uint8 data) -> void;
-
-  auto raster_enable() const -> bool;
-  auto nametable_addr() const -> uint;
-  auto scrollx() const -> uint;
-  auto scrolly() const -> uint;
-  auto sprite_height() const -> uint;
-
-  auto chr_load(uint16 addr) -> uint8;
-
-  auto scrollx_increment() -> void;
-  auto scrolly_increment() -> void;
-
-  auto raster_pixel() -> void;
-  auto raster_sprite() -> void;
-  auto raster_scanline() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  struct Status {
-    uint8 mdr;
-
-    bool field;
-    uint lx;
-    uint ly;
-
-    uint8 bus_data;
-
-    bool address_latch;
-
-    uint15 vaddr;
-    uint15 taddr;
-    uint8 xaddr;
-
-    bool nmi_hold;
-    bool nmi_flag;
-
-    //$2000
-    bool nmi_enable;
-    bool master_select;
-    bool sprite_size;
-    uint bg_addr;
-    uint sprite_addr;
-    uint vram_increment;
-
-    //$2001
-    uint3 emphasis;
-    bool sprite_enable;
-    bool bg_enable;
-    bool sprite_edge_enable;
-    bool bg_edge_enable;
-    bool grayscale;
-
-    //$2002
-    bool sprite_zero_hit;
-    bool sprite_overflow;
-
-    //$2003
-    uint8 oam_addr;
-  } status;
-
-  struct Raster {
-    uint16 nametable;
-    uint16 attribute;
-    uint16 tiledatalo;
-    uint16 tiledatahi;
-
-    uint oam_iterator;
-    uint oam_counter;
-
-    struct OAM {
-      uint8 id;
-      uint8 y;
-      uint8 tile;
-      uint8 attr;
-      uint8 x;
-
-      uint8 tiledatalo;
-      uint8 tiledatahi;
-    } oam[8], soam[8];
-  } raster;
-
-  uint32 buffer[256 * 262];
-  uint8 ciram[2048];
-  uint8 cgram[32];
-  uint8 oam[256];
-};
-
-extern PPU ppu;

fc/ppu/serialization.cpp

@@ -1,74 +0,0 @@
-auto PPU::serialize(serializer& s) -> void {
-  Thread::serialize(s);
-
-  s.integer(status.mdr);
-
-  s.integer(status.field);
-  s.integer(status.lx);
-  s.integer(status.ly);
-
-  s.integer(status.bus_data);
-
-  s.integer(status.address_latch);
-
-  s.integer(status.vaddr);
-  s.integer(status.taddr);
-  s.integer(status.xaddr);
-
-  s.integer(status.nmi_hold);
-  s.integer(status.nmi_flag);
-
-  s.integer(status.nmi_enable);
-  s.integer(status.master_select);
-  s.integer(status.sprite_size);
-  s.integer(status.bg_addr);
-  s.integer(status.sprite_addr);
-  s.integer(status.vram_increment);
-
-  s.integer(status.emphasis);
-  s.integer(status.sprite_enable);
-  s.integer(status.bg_enable);
-  s.integer(status.sprite_edge_enable);
-  s.integer(status.bg_edge_enable);
-  s.integer(status.grayscale);
-
-  s.integer(status.sprite_zero_hit);
-  s.integer(status.sprite_overflow);
-
-  s.integer(status.oam_addr);
-
-  s.integer(raster.nametable);
-  s.integer(raster.attribute);
-  s.integer(raster.tiledatalo);
-  s.integer(raster.tiledatahi);
-
-  s.integer(raster.oam_iterator);
-  s.integer(raster.oam_counter);
-
-  for(auto n : range(8)) {
-    s.integer(raster.oam[n].id);
-    s.integer(raster.oam[n].y);
-    s.integer(raster.oam[n].tile);
-    s.integer(raster.oam[n].attr);
-    s.integer(raster.oam[n].x);
-
-    s.integer(raster.oam[n].tiledatalo);
-    s.integer(raster.oam[n].tiledatahi);
-  }
-
-  for(auto n : range(8)) {
-    s.integer(raster.soam[n].id);
-    s.integer(raster.soam[n].y);
-    s.integer(raster.soam[n].tile);
-    s.integer(raster.soam[n].attr);
-    s.integer(raster.soam[n].x);
-
-    s.integer(raster.soam[n].tiledatalo);
-    s.integer(raster.soam[n].tiledatahi);
-  }
-
-  s.array(buffer);
-  s.array(ciram);
-  s.array(cgram);
-  s.array(oam);
-}

fc/scheduler/scheduler.cpp

@@ -1,28 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-Scheduler scheduler;
-
-auto Scheduler::enter() -> void {
-  host_thread = co_active();
-  co_switch(thread);
-}
-
-auto Scheduler::exit(ExitReason reason) -> void {
-  exit_reason = reason;
-  thread = co_active();
-  co_switch(host_thread);
-}
-
-auto Scheduler::power() -> void {
-}
-
-auto Scheduler::reset() -> void {
-  host_thread = co_active();
-  thread = cpu.thread;
-  sync = SynchronizeMode::None;
-  exit_reason = ExitReason::UnknownEvent;
-}
-
-}

fc/scheduler/scheduler.hpp

@@ -1,16 +0,0 @@
-struct Scheduler : property<Scheduler> {
-  enum class SynchronizeMode : uint { None, PPU, All } sync;
-  enum class ExitReason : uint { UnknownEvent, FrameEvent, SynchronizeEvent };
-
-  auto enter() -> void;
-  auto exit(ExitReason) -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-
-  cothread_t host_thread;  //program thread (used to exit emulation)
-  cothread_t thread;       //active emulation thread (used to enter emulation)
-  readonly<ExitReason> exit_reason;
-};
-
-extern Scheduler scheduler;

fc/system/serialization.cpp

@@ -1,60 +0,0 @@
-auto System::serialize() -> serializer {
-  serializer s(serialize_size);
-
-  uint signature = 0x31545342, version = Info::SerializerVersion;
-  char hash[64], description[512];
-  memcpy(&hash, (const char*)cartridge.sha256(), 64);
-  memset(&description, 0, sizeof description);
-
-  s.integer(signature);
-  s.integer(version);
-  s.array(hash);
-  s.array(description);
-
-  serialize_all(s);
-  return s;
-}
-
-auto System::unserialize(serializer& s) -> bool {
-  uint signature, version;
-  char hash[64], description[512];
-
-  s.integer(signature);
-  s.integer(version);
-  s.array(hash);
-  s.array(description);
-
-  if(signature != 0x31545342) return false;
-  if(version != Info::SerializerVersion) return false;
-
-  power();
-  serialize_all(s);
-  return true;
-}
-
-auto System::serialize(serializer& s) -> void {
-}
-
-auto System::serialize_all(serializer& s) -> void {
-  system.serialize(s);
-  input.serialize(s);
-  cartridge.serialize(s);
-  cpu.serialize(s);
-  apu.serialize(s);
-  ppu.serialize(s);
-}
-
-auto System::serialize_init() -> void {
-  serializer s;
-
-  uint signature = 0, version = 0;
-  char hash[64], description[512];
-
-  s.integer(signature);
-  s.integer(version);
-  s.array(hash);
-  s.array(description);
-
-  serialize_all(s);
-  serialize_size = s.size();
-}

fc/system/system.cpp

@@ -1,79 +0,0 @@
-#include <fc/fc.hpp>
-
-namespace Famicom {
-
-#include "serialization.cpp"
-System system;
-
-auto System::run() -> void {
-  scheduler.enter();
-  if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
-    interface->videoRefresh(video.palette, ppu.buffer, 4 * 256, 256, 240);
-  }
-}
-
-auto System::runtosave() -> void {
-  scheduler.sync = Scheduler::SynchronizeMode::PPU;
-  runthreadtosave();
-
-  scheduler.sync = Scheduler::SynchronizeMode::All;
-  scheduler.thread = cpu.thread;
-  runthreadtosave();
-
-  scheduler.sync = Scheduler::SynchronizeMode::All;
-  scheduler.thread = apu.thread;
-  runthreadtosave();
-
-  scheduler.sync = Scheduler::SynchronizeMode::All;
-  scheduler.thread = cartridge.thread;
-  runthreadtosave();
-
-  scheduler.sync = Scheduler::SynchronizeMode::None;
-}
-
-auto System::runthreadtosave() -> void {
-  while(true) {
-    scheduler.enter();
-    if(scheduler.exit_reason() == Scheduler::ExitReason::SynchronizeEvent) break;
-    if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
-      interface->videoRefresh(video.palette, ppu.buffer, 4 * 256, 256, 240);
-    }
-  }
-}
-
-auto System::load() -> void {
-  interface->loadRequest(ID::SystemManifest, "manifest.bml", true);
-  auto document = BML::unserialize(information.manifest);
-
-  serialize_init();
-}
-
-auto System::power() -> void {
-  cartridge.power();
-  cpu.power();
-  apu.power();
-  ppu.power();
-  input.reset();
-  scheduler.power();
-  reset();
-}
-
-auto System::reset() -> void {
-  cartridge.reset();
-  cpu.reset();
-  apu.reset();
-  ppu.reset();
-  input.reset();
-  scheduler.reset();
-}
-
-auto System::init() -> void {
-  assert(interface != 0);
-  input.connect(0, Input::Device::Joypad);
-  input.connect(1, Input::Device::None);
-}
-
-auto System::term() -> void {
-}
-
-}

fc/system/system.hpp

@@ -1,27 +0,0 @@
-struct System {
-  auto run() -> void;
-  auto runtosave() -> void;
-  auto runthreadtosave() -> void;
-
-  auto load() -> void;
-  auto power() -> void;
-  auto reset() -> void;
-
-  auto init() -> void;
-  auto term() -> void;
-
-  auto serialize() -> serializer;
-  auto unserialize(serializer&) -> bool;
-
-  auto serialize(serializer&) -> void;
-  auto serialize_all(serializer&) -> void;
-  auto serialize_init() -> void;
-
-  struct Information {
-    string manifest;
-  } information;
-
-  uint serialize_size;
-};
-
-extern System system;

fc/video/video.cpp

@@ -1,85 +0,0 @@
-#include <fc/fc.hpp>
-#include <cmath>
-
-#define VIDEO_CPP
-namespace Famicom {
-
-Video video;
-
-Video::Video() {
-  palette = new uint32_t[1 << 9]();
-}
-
-Video::~Video() {
-  delete[] palette;
-}
-
-auto Video::generate_palette(Emulator::Interface::PaletteMode mode) -> void {
-  for(auto color : range(1 << 9)) {
-    if(mode == Emulator::Interface::PaletteMode::Literal) {
-      palette[color] = color;
-    } else if(mode == Emulator::Interface::PaletteMode::Channel) {
-      uint emphasis = (color >> 6) &  7;
-      uint luma     = (color >> 4) &  3;
-      uint chroma   = (color >> 0) & 15;
-      emphasis = image::normalize(emphasis, 3, 16);
-      luma     = image::normalize(luma,     2, 16);
-      chroma   = image::normalize(chroma,   4, 16);
-      palette[color] = interface->videoColor(color, 0, emphasis, luma, chroma);
-    } else if(mode == Emulator::Interface::PaletteMode::Standard) {
-      palette[color] = generate_color(color, 2.0, 0.0, 1.0, 1.0, 2.2);
-    } else if(mode == Emulator::Interface::PaletteMode::Emulation) {
-      palette[color] = generate_color(color, 2.0, 0.0, 1.0, 1.0, 1.8);
-    }
-  }
-}
-
-auto Video::generate_color(
-  uint n, double saturation, double hue,
-  double contrast, double brightness, double gamma
-) -> uint32 {
-  int color = (n & 0x0f), level = color < 0xe ? (n >> 4) & 3 : 1;
-
-  static const double black = 0.518, white = 1.962, attenuation = 0.746;
-  static const double levels[8] = {
-    0.350, 0.518, 0.962, 1.550,
-    1.094, 1.506, 1.962, 1.962,
-  };
-
-  double lo_and_hi[2] = {
-    levels[level + 4 * (color == 0x0)],
-    levels[level + 4 * (color <  0xd)],
-  };
-
-  double y = 0.0, i = 0.0, q = 0.0;
-  auto wave = [](int p, int color) { return (color + p + 8) % 12 < 6; };
-  for(int p : range(12)) {
-    double spot = lo_and_hi[wave(p, color)];
-
-    if(((n & 0x040) && wave(p, 12))
-    || ((n & 0x080) && wave(p,  4))
-    || ((n & 0x100) && wave(p,  8))
-    ) spot *= attenuation;
-
-    double v = (spot - black) / (white - black);
-
-    v = (v - 0.5) * contrast + 0.5;
-    v *= brightness / 12.0;
-
-    y += v;
-    i += v * std::cos((3.141592653 / 6.0) * (p + hue));
-    q += v * std::sin((3.141592653 / 6.0) * (p + hue));
-  }
-
-  i *= saturation;
-  q *= saturation;
-
-  auto gammaAdjust = [=](double f) { return f < 0.0 ? 0.0 : std::pow(f, 2.2 / gamma); };
-  uint r = 65535.0 * gammaAdjust(y +  0.946882 * i +  0.623557 * q);
-  uint g = 65535.0 * gammaAdjust(y + -0.274788 * i + -0.635691 * q);
-  uint b = 65535.0 * gammaAdjust(y + -1.108545 * i +  1.709007 * q);
-
-  return interface->videoColor(n, 0, uclamp<16>(r), uclamp<16>(g), uclamp<16>(b));
-}
-
-}

fc/video/video.hpp

@@ -1,13 +0,0 @@
-struct Video {
-  Video();
-  ~Video();
-
-  auto generate_palette(Emulator::Interface::PaletteMode mode) -> void;
-
-  uint32* palette = nullptr;
-
-private:
-  auto generate_color(uint, double, double, double, double, double) -> uint32;
-};
-
-extern Video video;

gb/GNUmakefile

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

gb/apu/apu.cpp

@@ -1,115 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-#include "square1/square1.cpp"
-#include "square2/square2.cpp"
-#include "wave/wave.cpp"
-#include "noise/noise.cpp"
-#include "master/master.cpp"
-#include "serialization.cpp"
-APU apu;
-
-auto APU::Main() -> void {
-  apu.main();
-}
-
-auto APU::main() -> void {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    if(sequencer_base == 0) {  //512hz
-      if(sequencer_step == 0 || sequencer_step == 2 || sequencer_step == 4 || sequencer_step == 6) {  //256hz
-        square1.clock_length();
-        square2.clock_length();
-        wave.clock_length();
-        noise.clock_length();
-      }
-      if(sequencer_step == 2 || sequencer_step == 6) {  //128hz
-        square1.clock_sweep();
-      }
-      if(sequencer_step == 7) {  //64hz
-        square1.clock_envelope();
-        square2.clock_envelope();
-        noise.clock_envelope();
-      }
-      sequencer_step++;
-    }
-    sequencer_base++;
-
-    square1.run();
-    square2.run();
-    wave.run();
-    noise.run();
-    master.run();
-
-    hipass(master.center, master.center_bias);
-    hipass(master.left, master.left_bias);
-    hipass(master.right, master.right_bias);
-
-    interface->audioSample(master.left, master.right);
-
-    clock += cpu.frequency;
-    if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(scheduler.active_thread = cpu.thread);
-  }
-}
-
-auto APU::hipass(int16& sample, int64& bias) -> void {
-  bias += ((((int64)sample << 16) - (bias >> 16)) * 57593) >> 16;
-  sample = sclamp<16>(sample - (bias >> 32));
-}
-
-auto APU::power() -> void {
-  create(Main, 2 * 1024 * 1024);
-  for(uint n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
-
-  for(auto& n : mmio_data) n = 0x00;
-  sequencer_base = 0;
-  sequencer_step = 0;
-
-  square1.power();
-  square2.power();
-  wave.power();
-  noise.power();
-  master.power();
-}
-
-auto APU::mmio_read(uint16 addr) -> uint8 {
-  static const uint8 table[48] = {
-    0x80, 0x3f, 0x00, 0xff, 0xbf,                          //square1
-    0xff, 0x3f, 0x00, 0xff, 0xbf,                          //square2
-    0x7f, 0xff, 0x9f, 0xff, 0xbf,                          //wave
-    0xff, 0xff, 0x00, 0x00, 0xbf,                          //noise
-    0x00, 0x00, 0x70,                                      //master
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  //unmapped
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
-  };
-
-  if(addr == 0xff26) {
-    uint8 data = master.enable << 7;
-    if(square1.enable) data |= 0x01;
-    if(square2.enable) data |= 0x02;
-    if(   wave.enable) data |= 0x04;
-    if(  noise.enable) data |= 0x08;
-    return data | table[addr - 0xff10];
-  }
-
-  if(addr >= 0xff10 && addr <= 0xff3f) return mmio_data[addr - 0xff10] | table[addr - 0xff10];
-  return 0xff;
-}
-
-auto APU::mmio_write(uint16 addr, uint8 data) -> void {
-  if(addr >= 0xff10 && addr <= 0xff3f) mmio_data[addr - 0xff10] = data;
-
-  if(addr >= 0xff10 && addr <= 0xff14) return square1.write        (addr - 0xff10, data);
-  if(addr >= 0xff15 && addr <= 0xff19) return square2.write        (addr - 0xff15, data);
-  if(addr >= 0xff1a && addr <= 0xff1e) return    wave.write        (addr - 0xff1a, data);
-  if(addr >= 0xff1f && addr <= 0xff23) return   noise.write        (addr - 0xff1f, data);
-  if(addr >= 0xff24 && addr <= 0xff26) return  master.write        (addr - 0xff24, data);
-  if(addr >= 0xff30 && addr <= 0xff3f) return    wave.write_pattern(addr - 0xff30, data);
-}
-
-}

gb/apu/apu.hpp

@@ -1,29 +0,0 @@
-struct APU : Thread, MMIO {
-  static auto Main() -> void;
-  auto main() -> void;
-  auto hipass(int16& sample, int64& bias) -> void;
-  auto power() -> void;
-
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-
-  auto serialize(serializer&) -> void;
-
-  #include "square1/square1.hpp"
-  #include "square2/square2.hpp"
-  #include "wave/wave.hpp"
-  #include "noise/noise.hpp"
-  #include "master/master.hpp"
-
-  uint8 mmio_data[48];
-  uint12 sequencer_base;
-  uint3 sequencer_step;
-
-  Square1 square1;
-  Square2 square2;
-  Wave wave;
-  Noise noise;
-  Master master;
-};
-
-extern APU apu;

gb/apu/master/master.cpp

@@ -1,112 +0,0 @@
-auto APU::Master::run() -> void {
-  if(enable == false) {
-    center = 0;
-    left   = 0;
-    right  = 0;
-
-    center_bias = left_bias = right_bias = 0;
-    return;
-  }
-
-  int sample = 0;
-  sample += apu.square1.output;
-  sample += apu.square2.output;
-  sample +=    apu.wave.output;
-  sample +=   apu.noise.output;
-  center = (sample * 512) - 16384;
-
-  sample = 0;
-  if(channel1_left_enable) sample += apu.square1.output;
-  if(channel2_left_enable) sample += apu.square2.output;
-  if(channel3_left_enable) sample +=    apu.wave.output;
-  if(channel4_left_enable) sample +=   apu.noise.output;
-  sample = (sample * 512) - 16384;
-  sample = (sample * (left_volume + 1)) / 8;
-  left = sample;
-
-  sample = 0;
-  if(channel1_right_enable) sample += apu.square1.output;
-  if(channel2_right_enable) sample += apu.square2.output;
-  if(channel3_right_enable) sample +=    apu.wave.output;
-  if(channel4_right_enable) sample +=   apu.noise.output;
-  sample = (sample * 512) - 16384;
-  sample = (sample * (right_volume + 1)) / 8;
-  right = sample;
-
-  //reduce audio volume
-  center >>= 1;
-  left   >>= 1;
-  right  >>= 1;
-}
-
-auto APU::Master::write(uint r, uint8 data) -> void {
-  if(r == 0) {  //$ff24  NR50
-    left_in_enable  = data & 0x80;
-    left_volume     = (data >> 4) & 7;
-    right_in_enable = data & 0x08;
-    right_volume    = (data >> 0) & 7;
-  }
-
-  if(r == 1) {  //$ff25  NR51
-    channel4_left_enable  = data & 0x80;
-    channel3_left_enable  = data & 0x40;
-    channel2_left_enable  = data & 0x20;
-    channel1_left_enable  = data & 0x10;
-    channel4_right_enable = data & 0x08;
-    channel3_right_enable = data & 0x04;
-    channel2_right_enable = data & 0x02;
-    channel1_right_enable = data & 0x01;
-  }
-
-  if(r == 2) {  //$ff26  NR52
-    enable = data & 0x80;
-  }
-}
-
-auto APU::Master::power() -> void {
-  left_in_enable = 0;
-  left_volume = 0;
-  right_in_enable = 0;
-  right_volume = 0;
-  channel4_left_enable  = 0;
-  channel3_left_enable  = 0;
-  channel2_left_enable  = 0;
-  channel1_left_enable  = 0;
-  channel4_right_enable = 0;
-  channel3_right_enable = 0;
-  channel2_right_enable = 0;
-  channel1_right_enable = 0;
-  enable = 0;
-
-  center = 0;
-  left   = 0;
-  right  = 0;
-
-  center_bias = 0;
-  left_bias = 0;
-  right_bias = 0;
-}
-
-auto APU::Master::serialize(serializer& s) -> void {
-  s.integer(left_in_enable);
-  s.integer(left_volume);
-  s.integer(right_in_enable);
-  s.integer(right_volume);
-  s.integer(channel4_left_enable);
-  s.integer(channel3_left_enable);
-  s.integer(channel2_left_enable);
-  s.integer(channel1_left_enable);
-  s.integer(channel4_right_enable);
-  s.integer(channel3_right_enable);
-  s.integer(channel2_right_enable);
-  s.integer(channel1_right_enable);
-  s.integer(enable);
-
-  s.integer(center);
-  s.integer(left);
-  s.integer(right);
-
-  s.integer(center_bias);
-  s.integer(left_bias);
-  s.integer(right_bias);
-}

gb/apu/master/master.hpp

@@ -1,29 +0,0 @@
-struct Master {
-  auto run() -> void;
-  auto write(uint r, uint8 data) -> void;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  bool left_in_enable;
-  uint3 left_volume;
-  bool right_in_enable;
-  uint3 right_volume;
-  bool channel4_left_enable;
-  bool channel3_left_enable;
-  bool channel2_left_enable;
-  bool channel1_left_enable;
-  bool channel4_right_enable;
-  bool channel3_right_enable;
-  bool channel2_right_enable;
-  bool channel1_right_enable;
-  bool enable;
-
-  int16 center;
-  int16 left;
-  int16 right;
-
-  int64 center_bias;
-  int64 left_bias;
-  int64 right_bias;
-};

gb/apu/noise/noise.cpp

@@ -1,103 +0,0 @@
-auto APU::Noise::dac_enable() const -> bool {
-  return (envelope_volume || envelope_direction);
-}
-
-auto APU::Noise::run() -> void {
-  if(period && --period == 0) {
-    period = divisor << frequency;
-    if(frequency < 14) {
-      bool bit = (lfsr ^ (lfsr >> 1)) & 1;
-      lfsr = (lfsr >> 1) ^ (bit << (narrow_lfsr ? 6 : 14));
-    }
-  }
-
-  uint4 sample = (lfsr & 1) ? (uint4)0 : volume;
-  if(enable == false) sample = 0;
-
-  output = sample;
-}
-
-auto APU::Noise::clock_length() -> void {
-  if(enable && counter) {
-    if(++length == 0) enable = false;
-  }
-}
-
-auto APU::Noise::clock_envelope() -> void {
-  if(enable && envelope_frequency && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-auto APU::Noise::write(uint r, uint8 data) -> void {
-  if(r == 1) {  //$ff20  NR41
-    length = data & 0x3f;
-  }
-
-  if(r == 2) {  //$ff21  NR42
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-    if(dac_enable() == false) enable = false;
-  }
-
-  if(r == 3) {  //$ff22  NR43
-    frequency = data >> 4;
-    narrow_lfsr = data & 0x08;
-    divisor = (data & 0x07) << 3;
-    if(divisor == 0) divisor = 4;
-    period = divisor << frequency;
-  }
-
-  if(r == 4) {  //$ff34  NR44
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-
-    if(initialize) {
-      enable = dac_enable();
-      lfsr = -1;
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-    }
-  }
-}
-
-auto APU::Noise::power() -> void {
-  enable = 0;
-
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  narrow_lfsr = 0;
-  divisor = 0;
-  counter = 0;
-
-  output = 0;
-  length = 0;
-  envelope_period = 0;
-  volume = 0;
-  period = 0;
-  lfsr = 0;
-}
-
-auto APU::Noise::serialize(serializer& s) -> void {
-  s.integer(enable);
-
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(narrow_lfsr);
-  s.integer(divisor);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(length);
-  s.integer(envelope_period);
-  s.integer(volume);
-  s.integer(period);
-  s.integer(lfsr);
-}

gb/apu/noise/noise.hpp

@@ -1,28 +0,0 @@
-struct Noise {
-  auto dac_enable() const -> bool;
-
-  auto run() -> void;
-  auto clock_length() -> void;
-  auto clock_envelope() -> void;
-  auto write(uint r, uint8 data) -> void;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  bool enable;
-
-  uint4 envelope_volume;
-  bool envelope_direction;
-  uint3 envelope_frequency;
-  uint4 frequency;
-  bool narrow_lfsr;
-  uint divisor;
-  bool counter;
-
-  int16 output;
-  uint6 length;
-  uint3 envelope_period;
-  uint4 volume;
-  uint period;
-  uint15 lfsr;
-};

gb/apu/square1/square1.cpp

@@ -1,154 +0,0 @@
-auto APU::Square1::dac_enable() const -> bool {
-  return (envelope_volume || envelope_direction);
-}
-
-auto APU::Square1::run() -> void {
-  if(period && --period == 0) {
-    period = 2 * (2048 - frequency);
-    phase++;
-    switch(duty) {
-    case 0: duty_output = (phase == 6); break;  //______-_
-    case 1: duty_output = (phase >= 6); break;  //______--
-    case 2: duty_output = (phase >= 4); break;  //____----
-    case 3: duty_output = (phase <= 5); break;  //------__
-    }
-  }
-
-  uint4 sample = (duty_output ? volume : (uint4)0);
-  if(enable == false) sample = 0;
-
-  output = sample;
-}
-
-auto APU::Square1::sweep(bool update) -> void {
-  if(sweep_enable == false) return;
-
-  sweep_negate = sweep_direction;
-  uint delta = frequency_shadow >> sweep_shift;
-  int freq = frequency_shadow + (sweep_negate ? -delta : delta);
-
-  if(freq > 2047) {
-    enable = false;
-  } else if(sweep_shift && update) {
-    frequency_shadow = freq;
-    frequency = freq & 2047;
-    period = 2 * (2048 - frequency);
-  }
-}
-
-auto APU::Square1::clock_length() -> void {
-  if(counter && enable) {
-    if(++length == 0) enable = false;
-  }
-}
-
-auto APU::Square1::clock_sweep() -> void {
-  if(enable && sweep_frequency && --sweep_period == 0) {
-    sweep_period = sweep_frequency;
-    sweep(1);
-    sweep(0);
-  }
-}
-
-auto APU::Square1::clock_envelope() -> void {
-  if(enable && envelope_frequency && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-auto APU::Square1::write(uint r, uint8 data) -> void {
-  if(r == 0) {  //$ff10  NR10
-    if(sweep_negate && sweep_direction && !(data & 0x08)) enable = false;
-    sweep_frequency = (data >> 4) & 7;
-    sweep_direction = data & 0x08;
-    sweep_shift = data & 0x07;
-  }
-
-  if(r == 1) {  //$ff11  NR11
-    duty = data >> 6;
-    length = data & 0x3f;
-  }
-
-  if(r == 2) {  //$ff12  NR12
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-    if(dac_enable() == false) enable = false;
-  }
-
-  if(r == 3) {  //$ff13  NR13
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {  //$ff14  NR14
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize) {
-      enable = dac_enable();
-      period = 2 * (2048 - frequency);
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-      frequency_shadow = frequency;
-      sweep_period = sweep_frequency;
-      sweep_enable = sweep_period || sweep_shift;
-      sweep_negate = false;
-      if(sweep_shift) sweep(0);
-    }
-  }
-}
-
-auto APU::Square1::power() -> void {
-  enable = 0;
-
-  sweep_frequency = 0;
-  sweep_direction = 0;
-  sweep_shift = 0;
-  sweep_negate = 0;
-  duty = 0;
-  length = 0;
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  counter = 0;
-
-  output = 0;
-  duty_output = 0;
-  phase = 0;
-  period = 0;
-  envelope_period = 0;
-  sweep_period = 0;
-  frequency_shadow = 0;
-  sweep_enable = 0;
-  volume = 0;
-}
-
-auto APU::Square1::serialize(serializer& s) -> void {
-  s.integer(enable);
-
-  s.integer(sweep_frequency);
-  s.integer(sweep_direction);
-  s.integer(sweep_shift);
-  s.integer(sweep_negate);
-  s.integer(duty);
-  s.integer(length);
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(duty_output);
-  s.integer(phase);
-  s.integer(period);
-  s.integer(envelope_period);
-  s.integer(sweep_period);
-  s.integer(frequency_shadow);
-  s.integer(sweep_enable);
-  s.integer(volume);
-}

gb/apu/square1/square1.hpp

@@ -1,37 +0,0 @@
-struct Square1 {
-  auto dac_enable() const -> bool;
-
-  auto run() -> void;
-  auto sweep(bool update) -> void;
-  auto clock_length() -> void;
-  auto clock_sweep() -> void;
-  auto clock_envelope() -> void;
-  auto write(uint r, uint8 data) -> void;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  bool enable;
-
-  uint3 sweep_frequency;
-  bool sweep_direction;
-  uint3 sweep_shift;
-  bool sweep_negate;
-  uint2 duty;
-  uint6 length;
-  uint4 envelope_volume;
-  bool envelope_direction;
-  uint3 envelope_frequency;
-  uint11 frequency;
-  bool counter;
-
-  int16 output;
-  bool duty_output;
-  uint3 phase;
-  uint period;
-  uint3 envelope_period;
-  uint3 sweep_period;
-  int frequency_shadow;
-  bool sweep_enable;
-  uint4 volume;
-};

gb/apu/square2/square2.cpp

@@ -1,104 +0,0 @@
-auto APU::Square2::dac_enable() const -> bool {
-  return (envelope_volume || envelope_direction);
-}
-
-auto APU::Square2::run() -> void {
-  if(period && --period == 0) {
-    period = 2 * (2048 - frequency);
-    phase++;
-    switch(duty) {
-    case 0: duty_output = (phase == 6); break;  //______-_
-    case 1: duty_output = (phase >= 6); break;  //______--
-    case 2: duty_output = (phase >= 4); break;  //____----
-    case 3: duty_output = (phase <= 5); break;  //------__
-    }
-  }
-
-  uint4 sample = (duty_output ? volume : (uint4)0);
-  if(enable == false) sample = 0;
-
-  output = sample;
-}
-
-auto APU::Square2::clock_length() -> void {
-  if(counter && enable) {
-    if(++length == 0) enable = false;
-  }
-}
-
-auto APU::Square2::clock_envelope() -> void {
-  if(enable && envelope_frequency && --envelope_period == 0) {
-    envelope_period = envelope_frequency;
-    if(envelope_direction == 0 && volume >  0) volume--;
-    if(envelope_direction == 1 && volume < 15) volume++;
-  }
-}
-
-auto APU::Square2::write(uint r, uint8 data) -> void {
-  if(r == 1) {  //$ff16  NR21
-    duty = data >> 6;
-    length = (data & 0x3f);
-  }
-
-  if(r == 2) {  //$ff17  NR22
-    envelope_volume = data >> 4;
-    envelope_direction = data & 0x08;
-    envelope_frequency = data & 0x07;
-    if(dac_enable() == false) enable = false;
-  }
-
-  if(r == 3) {  //$ff18  NR23
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {  //$ff19  NR24
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize) {
-      enable = dac_enable();
-      period = 2 * (2048 - frequency);
-      envelope_period = envelope_frequency;
-      volume = envelope_volume;
-    }
-  }
-}
-
-auto APU::Square2::power() -> void {
-  enable = 0;
-
-  duty = 0;
-  length = 0;
-  envelope_volume = 0;
-  envelope_direction = 0;
-  envelope_frequency = 0;
-  frequency = 0;
-  counter = 0;
-
-  output = 0;
-  duty_output = 0;
-  phase = 0;
-  period = 0;
-  envelope_period = 0;
-  volume = 0;
-}
-
-auto APU::Square2::serialize(serializer& s) -> void {
-  s.integer(enable);
-
-  s.integer(duty);
-  s.integer(length);
-  s.integer(envelope_volume);
-  s.integer(envelope_direction);
-  s.integer(envelope_frequency);
-  s.integer(frequency);
-  s.integer(counter);
-
-  s.integer(output);
-  s.integer(duty_output);
-  s.integer(phase);
-  s.integer(period);
-  s.integer(envelope_period);
-  s.integer(volume);
-}

gb/apu/square2/square2.hpp

@@ -1,28 +0,0 @@
-struct Square2 {
-  auto dac_enable() const -> bool;
-
-  auto run() -> void;
-  auto clock_length() -> void;
-  auto clock_envelope() -> void;
-  auto write(uint r, uint8 data) -> void;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  bool enable;
-
-  uint2 duty;
-  uint6 length;
-  uint4 envelope_volume;
-  bool envelope_direction;
-  uint3 envelope_frequency;
-  uint11 frequency;
-  bool counter;
-
-  int16 output;
-  bool duty_output;
-  uint3 phase;
-  uint period;
-  uint3 envelope_period;
-  uint4 volume;
-};

gb/apu/wave/wave.cpp

@@ -1,93 +0,0 @@
-auto APU::Wave::run() -> void {
-  if(period && --period == 0) {
-    period = 1 * (2048 - frequency);
-    pattern_sample = pattern[++pattern_offset];
-  }
-
-  uint4 sample = pattern_sample >> volume_shift;
-  if(enable == false) sample = 0;
-
-  output = sample;
-}
-
-auto APU::Wave::clock_length() -> void {
-  if(enable && counter) {
-    if(++length == 0) enable = false;
-  }
-}
-
-auto APU::Wave::write(uint r, uint8 data) -> void {
-  if(r == 0) {  //$ff1a  NR30
-    dac_enable = data & 0x80;
-    if(dac_enable == false) enable = false;
-  }
-
-  if(r == 1) {  //$ff1b  NR31
-    length = data;
-  }
-
-  if(r == 2) {  //$ff1c  NR32
-    switch((data >> 5) & 3) {
-      case 0: volume_shift = 4; break;  //  0%
-      case 1: volume_shift = 0; break;  //100%
-      case 2: volume_shift = 1; break;  // 50%
-      case 3: volume_shift = 2; break;  // 25%
-    }
-  }
-
-  if(r == 3) {  //$ff1d  NR33
-    frequency = (frequency & 0x0700) | data;
-  }
-
-  if(r == 4) {  //$ff1e  NR34
-    bool initialize = data & 0x80;
-    counter = data & 0x40;
-    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
-
-    if(initialize) {
-      enable = dac_enable;
-      period = 1 * (2048 - frequency);
-      pattern_offset = 0;
-    }
-  }
-}
-
-auto APU::Wave::write_pattern(uint p, uint8 data) -> void {
-  p <<= 1;
-  pattern[p + 0] = (data >> 4) & 15;
-  pattern[p + 1] = (data >> 0) & 15;
-}
-
-auto APU::Wave::power() -> void {
-  enable = 0;
-
-  dac_enable = 0;
-  volume_shift = 0;
-  frequency = 0;
-  counter = 0;
-
-  LinearFeedbackShiftRegisterGenerator r;
-  for(auto& n : pattern) n = r() & 15;
-
-  output = 0;
-  length = 0;
-  period = 0;
-  pattern_offset = 0;
-  pattern_sample = 0;
-}
-
-auto APU::Wave::serialize(serializer& s) -> void {
-  s.integer(enable);
-
-  s.integer(dac_enable);
-  s.integer(volume_shift);
-  s.integer(frequency);
-  s.integer(counter);
-  s.array(pattern);
-
-  s.integer(output);
-  s.integer(length);
-  s.integer(period);
-  s.integer(pattern_offset);
-  s.integer(pattern_sample);
-}

gb/apu/wave/wave.hpp

@@ -1,23 +0,0 @@
-struct Wave {
-  auto run() -> void;
-  auto clock_length() -> void;
-  auto write(uint r, uint8 data) -> void;
-  auto write_pattern(uint p, uint8 data) -> void;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  bool enable;
-
-  bool dac_enable;
-  uint volume_shift;
-  uint11 frequency;
-  bool counter;
-  uint8 pattern[32];
-
-  int16 output;
-  uint8 length;
-  uint period;
-  uint5 pattern_offset;
-  uint4 pattern_sample;
-};

gb/cartridge/cartridge.cpp

@@ -1,185 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-#include "mbc0/mbc0.cpp"
-#include "mbc1/mbc1.cpp"
-#include "mbc2/mbc2.cpp"
-#include "mbc3/mbc3.cpp"
-#include "mbc5/mbc5.cpp"
-#include "mmm01/mmm01.cpp"
-#include "huc1/huc1.cpp"
-#include "huc3/huc3.cpp"
-#include "serialization.cpp"
-Cartridge cartridge;
-
-Cartridge::Cartridge() {
-  loaded = false;
-  sha256 = "";
-}
-
-Cartridge::~Cartridge() {
-  unload();
-}
-
-auto Cartridge::manifest() const -> string {
-  return information.markup;
-}
-
-auto Cartridge::title() const -> string {
-  return information.title;
-}
-
-//intended for use with Super Game Boy for when no Game Boy cartridge is inserted
-auto Cartridge::load_empty(System::Revision revision) -> void {
-  unload();
-  romsize = 32768;
-  romdata = allocate<uint8>(romsize, 0xff);
-  ramsize = 0;
-  mapper = &mbc0;
-  sha256 = Hash::SHA256(romdata, romsize).digest();
-  loaded = true;
-  system.load(revision);
-}
-
-auto Cartridge::load(System::Revision revision) -> void {
-  unload();
-
-  system.revision = revision;  //needed for ID::Manifest to return correct group ID
-  if(revision != System::Revision::SuperGameBoy) {
-    interface->loadRequest(ID::Manifest, "manifest.bml", true);
-  }
-
-  information.mapper = Mapper::Unknown;
-  information.ram = false;
-  information.battery = false;
-  information.rtc = false;
-  information.rumble = false;
-
-  information.romsize = 0;
-  information.ramsize = 0;
-
-  auto document = BML::unserialize(information.markup);
-  information.title = document["information/title"].text();
-
-  auto mapperid = document["board/mapper"].text();
-  if(mapperid == "none" ) information.mapper = Mapper::MBC0;
-  if(mapperid == "MBC1" ) information.mapper = Mapper::MBC1;
-  if(mapperid == "MBC2" ) information.mapper = Mapper::MBC2;
-  if(mapperid == "MBC3" ) information.mapper = Mapper::MBC3;
-  if(mapperid == "MBC5" ) information.mapper = Mapper::MBC5;
-  if(mapperid == "MMM01") information.mapper = Mapper::MMM01;
-  if(mapperid == "HuC1" ) information.mapper = Mapper::HuC1;
-  if(mapperid == "HuC3" ) information.mapper = Mapper::HuC3;
-
-  information.rtc = false;
-  information.rumble = false;
-
-  auto rom = document["board/rom"];
-  auto ram = document["board/ram"];
-
-  romsize = rom["size"].natural();
-  romdata = allocate<uint8>(romsize, 0xff);
-
-  ramsize = ram["size"].natural();
-  ramdata = allocate<uint8>(ramsize, 0xff);
-
-  //Super Game Boy core loads memory from Super Famicom core
-  if(revision != System::Revision::SuperGameBoy) {
-    if(auto name = rom["name"].text()) interface->loadRequest(ID::ROM, name, true);
-    if(auto name = ram["name"].text()) interface->loadRequest(ID::RAM, name, false);
-    if(auto name = ram["name"].text()) memory.append({ID::RAM, name});
-  }
-
-  information.romsize = rom["size"].natural();
-  information.ramsize = ram["size"].natural();
-  information.battery = (bool)ram["name"];
-
-  switch(information.mapper) { default:
-  case Mapper::MBC0:  mapper = &mbc0;  break;
-  case Mapper::MBC1:  mapper = &mbc1;  break;
-  case Mapper::MBC2:  mapper = &mbc2;  break;
-  case Mapper::MBC3:  mapper = &mbc3;  break;
-  case Mapper::MBC5:  mapper = &mbc5;  break;
-  case Mapper::MMM01: mapper = &mmm01; break;
-  case Mapper::HuC1:  mapper = &huc1;  break;
-  case Mapper::HuC3:  mapper = &huc3;  break;
-  }
-
-  sha256 = Hash::SHA256(romdata, romsize).digest();
-  loaded = true;
-  system.load(revision);
-}
-
-auto Cartridge::unload() -> void {
-  if(romdata) { delete[] romdata; romdata = nullptr; romsize = 0; }
-  if(ramdata) { delete[] ramdata; ramdata = nullptr; ramsize = 0; }
-  loaded = false;
-}
-
-auto Cartridge::rom_read(uint addr) -> uint8 {
-  if(addr >= romsize) addr %= romsize;
-  return romdata[addr];
-}
-
-auto Cartridge::rom_write(uint addr, uint8 data) -> void {
-  if(addr >= romsize) addr %= romsize;
-  romdata[addr] = data;
-}
-
-auto Cartridge::ram_read(uint addr) -> uint8 {
-  if(ramsize == 0) return 0x00;
-  if(addr >= ramsize) addr %= ramsize;
-  return ramdata[addr];
-}
-
-auto Cartridge::ram_write(uint addr, uint8 data) -> void {
-  if(ramsize == 0) return;
-  if(addr >= ramsize) addr %= ramsize;
-  ramdata[addr] = data;
-}
-
-auto Cartridge::mmio_read(uint16 addr) -> uint8 {
-  if(addr == 0xff50) return 0x00;
-
-  if(bootrom_enable) {
-    const uint8* data = nullptr;
-    switch(system.revision) { default:
-    case System::Revision::GameBoy: data = system.bootROM.dmg; break;
-    case System::Revision::SuperGameBoy: data = system.bootROM.sgb; break;
-    case System::Revision::GameBoyColor: data = system.bootROM.cgb; break;
-    }
-    if(addr >= 0x0000 && addr <= 0x00ff) return data[addr];
-    if(addr >= 0x0200 && addr <= 0x08ff && system.cgb()) return data[addr - 256];
-  }
-
-  return mapper->mmio_read(addr);
-}
-
-auto Cartridge::mmio_write(uint16 addr, uint8 data) -> void {
-  if(bootrom_enable && addr == 0xff50) {
-    bootrom_enable = false;
-    return;
-  }
-
-  mapper->mmio_write(addr, data);
-}
-
-auto Cartridge::power() -> void {
-  bootrom_enable = true;
-
-  mbc0.power();
-  mbc1.power();
-  mbc2.power();
-  mbc3.power();
-  mbc5.power();
-  mmm01.power();
-  huc1.power();
-  huc3.power();
-
-  for(uint n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = this;
-  for(uint n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = this;
-  bus.mmio[0xff50] = this;
-}
-
-}

gb/cartridge/cartridge.hpp

@@ -1,78 +0,0 @@
-struct Cartridge : MMIO, property<Cartridge> {
-  Cartridge();
-  ~Cartridge();
-
-  auto load_empty(System::Revision revision) -> void;
-  auto load(System::Revision revision) -> void;
-  auto unload() -> void;
-
-  auto rom_read(uint addr) -> uint8;
-  auto rom_write(uint addr, uint8 data) -> void;
-  auto ram_read(uint addr) -> uint8;
-  auto ram_write(uint addr, uint8 data) -> void;
-
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  #include "mbc0/mbc0.hpp"
-  #include "mbc1/mbc1.hpp"
-  #include "mbc2/mbc2.hpp"
-  #include "mbc3/mbc3.hpp"
-  #include "mbc5/mbc5.hpp"
-  #include "mmm01/mmm01.hpp"
-  #include "huc1/huc1.hpp"
-  #include "huc3/huc3.hpp"
-
-  enum Mapper : uint {
-    MBC0,
-    MBC1,
-    MBC2,
-    MBC3,
-    MBC5,
-    MMM01,
-    HuC1,
-    HuC3,
-    Unknown,
-  };
-
-  struct Information {
-    string markup;
-    string title;
-
-    Mapper mapper;
-    bool ram;
-    bool battery;
-    bool rtc;
-    bool rumble;
-
-    uint romsize;
-    uint ramsize;
-  } information;
-
-  auto manifest() const -> string;
-  auto title() const -> string;
-
-  struct Memory {
-    uint id;
-    string name;
-  };
-  vector<Memory> memory;
-
-  readonly<bool> loaded;
-  readonly<string> sha256;
-
-  uint8* romdata = nullptr;
-  uint romsize = 0;
-
-  uint8* ramdata = nullptr;
-  uint ramsize = 0;
-
-  MMIO* mapper = nullptr;
-  bool bootrom_enable = true;
-};
-
-extern Cartridge cartridge;

gb/cartridge/huc1/huc1.cpp

@@ -1,50 +0,0 @@
-auto Cartridge::HuC1::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::HuC1::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    ram_writable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    rom_select = data;
-    if(rom_select == 0) rom_select = 1;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    ram_select = data;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
-    model = data & 0x01;
-    return;
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_writable == false) return;
-    return cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-  }
-}
-
-auto Cartridge::HuC1::power() -> void {
-  ram_writable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-  model = 0;
-}

gb/cartridge/huc1/huc1.hpp

@@ -1,10 +0,0 @@
-struct HuC1 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool ram_writable;  //$0000-1fff
-  uint8 rom_select;   //$2000-3fff
-  uint8 ram_select;   //$4000-5fff
-  bool model;         //$6000-7fff
-} huc1;

gb/cartridge/huc3/huc3.cpp

@@ -1,49 +0,0 @@
-auto Cartridge::HuC3::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::HuC3::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    rom_select = data;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    ram_select = data;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
-    //unknown purpose
-    return;
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
-  }
-}
-
-auto Cartridge::HuC3::power() -> void {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-}

gb/cartridge/huc3/huc3.hpp

@@ -1,9 +0,0 @@
-struct HuC3 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool ram_enable;   //$0000-1fff
-  uint8 rom_select;  //$2000-3fff
-  uint8 ram_select;  //$4000-5fff
-} huc3;

gb/cartridge/mbc0/mbc0.cpp

@@ -1,21 +0,0 @@
-auto Cartridge::MBC0::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0x8000) == 0x0000) {  //$0000-7fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    return cartridge.ram_read(addr & 0x1fff);
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MBC0::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    cartridge.ram_write(addr & 0x1fff, data);
-    return;
-  }
-}
-
-auto Cartridge::MBC0::power() -> void {
-}

gb/cartridge/mbc0/mbc0.hpp

@@ -1,5 +0,0 @@
-struct MBC0 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-} mbc0;

gb/cartridge/mbc1/mbc1.cpp

@@ -1,66 +0,0 @@
-auto Cartridge::MBC1::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    if(mode_select == 0) {
-      return cartridge.rom_read((ram_select << 19) | (rom_select << 14) | (addr & 0x3fff));
-    } else {
-      return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-    }
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) {
-      if(mode_select == 0) {
-        return cartridge.ram_read(addr & 0x1fff);
-      } else {
-        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-      }
-    }
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MBC1::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    rom_select = (data & 0x1f) + ((data & 0x1f) == 0);
-    return;
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    ram_select = data & 0x03;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
-    mode_select = data & 0x01;
-    return;
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) {
-      if(mode_select == 0) {
-        cartridge.ram_write(addr & 0x1fff, data);
-      } else {
-        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-      }
-    }
-    return;
-  }
-}
-
-auto Cartridge::MBC1::power() -> void {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-  mode_select = 0;
-}

gb/cartridge/mbc1/mbc1.hpp

@@ -1,10 +0,0 @@
-struct MBC1 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool  ram_enable;   //$0000-1fff
-  uint8 rom_select;   //$2000-3fff
-  uint8 ram_select;   //$4000-5fff
-  bool  mode_select;  //$6000-7fff
-} mbc1;

gb/cartridge/mbc2/mbc2.cpp

@@ -1,38 +0,0 @@
-auto Cartridge::MBC2::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if((addr & 0xee00) == 0xa000) {  //$a000-a1ff
-    if(ram_enable) return cartridge.ram_read(addr & 0x1ff);
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MBC2::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    if(!(addr & 0x0100)) ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    if( (addr & 0x0100)) rom_select = (data & 0x0f) + ((data & 0x0f) == 0);
-    return;
-  }
-
-  if((addr & 0xee00) == 0xa000) {  //$a000-a1ff
-    if(ram_enable) cartridge.ram_write(addr & 0x1ff, data & 0x0f);
-    return;
-  }
-}
-
-auto Cartridge::MBC2::power() -> void {
-  ram_enable = false;
-  rom_select = 0x01;
-}

gb/cartridge/mbc2/mbc2.hpp

@@ -1,8 +0,0 @@
-struct MBC2 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool  ram_enable;  //$0000-1fff
-  uint8 rom_select;  //$2000-3fff
-} mbc2;

gb/cartridge/mbc3/mbc3.cpp

@@ -1,116 +0,0 @@
-auto Cartridge::MBC3::second() -> void {
-  if(rtc_halt == false) {
-    if(++rtc_second >= 60) {
-      rtc_second = 0;
-      if(++rtc_minute >= 60) {
-        rtc_minute = 0;
-        if(++rtc_hour >= 24) {
-          rtc_hour = 0;
-          if(++rtc_day >= 512) {
-            rtc_day = 0;
-            rtc_day_carry = true;
-          }
-        }
-      }
-    }
-  }
-}
-
-auto Cartridge::MBC3::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) {
-      if(ram_select >= 0x00 && ram_select <= 0x03) {
-        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-      }
-      if(ram_select == 0x08) return rtc_latch_second;
-      if(ram_select == 0x09) return rtc_latch_minute;
-      if(ram_select == 0x0a) return rtc_latch_hour;
-      if(ram_select == 0x0b) return rtc_latch_day;
-      if(ram_select == 0x0c) return (rtc_latch_day_carry << 7) | (rtc_latch_day >> 8);
-    }
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MBC3::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    rom_select = (data & 0x7f) + ((data & 0x7f) == 0);
-    return;
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    ram_select = data;
-    return;
-  }
-
-  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
-    if(rtc_latch == 0 && data == 1) {
-      rtc_latch_second = rtc_second;
-      rtc_latch_minute = rtc_minute;
-      rtc_latch_hour = rtc_hour;
-      rtc_latch_day = rtc_day;
-      rtc_latch_day_carry = rtc_day_carry;
-    }
-    rtc_latch = data;
-    return;
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) {
-      if(ram_select >= 0x00 && ram_select <= 0x03) {
-        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-      } else if(ram_select == 0x08) {
-        if(data >= 60) data = 0;
-        rtc_second = data;
-      } else if(ram_select == 0x09) {
-        if(data >= 60) data = 0;
-        rtc_minute = data;
-      } else if(ram_select == 0x0a) {
-        if(data >= 24) data = 0;
-        rtc_hour = data;
-      } else if(ram_select == 0x0b) {
-        rtc_day = (rtc_day & 0x0100) | data;
-      } else if(ram_select == 0x0c) {
-        rtc_day = ((data & 1) << 8) | (rtc_day & 0xff);
-        rtc_halt = data & 0x40;
-        rtc_day_carry = data & 0x80;
-      }
-    }
-    return;
-  }
-}
-
-auto Cartridge::MBC3::power() -> void {
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-  rtc_latch = 0;
-
-  rtc_halt = true;
-  rtc_second = 0;
-  rtc_minute = 0;
-  rtc_hour = 0;
-  rtc_day = 0;
-  rtc_day_carry = false;
-
-  rtc_latch_second = 0;
-  rtc_latch_minute = 0;
-  rtc_latch_hour = 0;
-  rtc_latch_day = 0;
-  rtc_latch_day_carry = false;
-}

gb/cartridge/mbc3/mbc3.hpp

@@ -1,24 +0,0 @@
-struct MBC3 : MMIO {
-  auto second() -> void;
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool  ram_enable;  //$0000-1fff
-  uint8 rom_select;  //$2000-3fff
-  uint8 ram_select;  //$4000-5fff
-  bool rtc_latch;    //$6000-7fff
-
-  bool rtc_halt;
-  uint rtc_second;
-  uint rtc_minute;
-  uint rtc_hour;
-  uint rtc_day;
-  bool rtc_day_carry;
-
-  uint rtc_latch_second;
-  uint rtc_latch_minute;
-  uint rtc_latch_hour;
-  uint rtc_latch_day;
-  uint rtc_latch_day_carry;
-} mbc3;

gb/cartridge/mbc5/mbc5.cpp

@@ -1,49 +0,0 @@
-auto Cartridge::MBC5::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MBC5::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    ram_enable = (data & 0x0f) == 0x0a;
-    return;
-  }
-
-  if((addr & 0xf000) == 0x2000) {  //$2000-2fff
-    rom_select = (rom_select & 0x0100) | data;
-    return;
-  }
-
-  if((addr & 0xf000) == 0x3000) {  //$3000-3fff
-    rom_select = ((data & 1) << 8) | (rom_select & 0x00ff);
-    return;
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    ram_select = data & 0x0f;
-    return;
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
-  }
-}
-
-auto Cartridge::MBC5::power() -> void {
-  ram_enable = false;
-  rom_select = 0x001;
-  ram_select = 0x00;
-}

gb/cartridge/mbc5/mbc5.hpp

@@ -1,9 +0,0 @@
-struct MBC5 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool ram_enable;    //$0000-1fff
-  uint16 rom_select;  //$2000-2fff + $3000-3fff
-  uint8 ram_select;   //$4000-5fff
-} mbc5;

gb/cartridge/mmm01/mmm01.cpp

@@ -1,61 +0,0 @@
-auto Cartridge::MMM01::mmio_read(uint16 addr) -> uint8 {
-  if((addr & 0x8000) == 0x0000) {  //$0000-7fff
-    if(rom_mode == 0) return cartridge.rom_read(addr);
-  }
-
-  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
-    return cartridge.rom_read(0x8000 + (rom_base << 14) + (addr & 0x3fff));
-  }
-
-  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
-    return cartridge.rom_read(0x8000 + (rom_base << 14) + (rom_select << 14) + (addr & 0x3fff));
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) + (addr & 0x1fff));
-    return 0x00;
-  }
-
-  return 0x00;
-}
-
-auto Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) -> void {
-  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
-    if(rom_mode == 0) {
-      rom_mode = 1;
-    } else {
-      ram_enable = (data & 0x0f) == 0x0a;
-    }
-  }
-
-  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
-    if(rom_mode == 0) {
-      rom_base = data & 0x3f;
-    } else {
-      rom_select = data;
-    }
-  }
-
-  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
-    if(rom_mode == 1) {
-      ram_select = data;
-    }
-  }
-
-  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
-    //unknown purpose
-  }
-
-  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
-    if(ram_enable) cartridge.ram_write((ram_select << 13) + (addr & 0x1fff), data);
-  }
-}
-
-auto Cartridge::MMM01::power() -> void {
-  rom_mode = 0;
-  rom_base = 0;
-
-  ram_enable = false;
-  rom_select = 0x01;
-  ram_select = 0x00;
-}

gb/cartridge/mmm01/mmm01.hpp

@@ -1,12 +0,0 @@
-struct MMM01 : MMIO {
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-  auto power() -> void;
-
-  bool rom_mode;
-  uint8 rom_base;
-
-  bool ram_enable;
-  uint8 rom_select;
-  uint8 ram_select;
-} mmm01;

gb/cartridge/serialization.cpp

@@ -1,50 +0,0 @@
-auto Cartridge::serialize(serializer& s) -> void {
-  if(information.battery) s.array(ramdata, ramsize);
-  s.integer(bootrom_enable);
-
-  s.integer(mbc1.ram_enable);
-  s.integer(mbc1.rom_select);
-  s.integer(mbc1.ram_select);
-  s.integer(mbc1.mode_select);
-
-  s.integer(mbc2.ram_enable);
-  s.integer(mbc2.rom_select);
-
-  s.integer(mbc3.ram_enable);
-  s.integer(mbc3.rom_select);
-  s.integer(mbc3.ram_select);
-  s.integer(mbc3.rtc_latch);
-
-  s.integer(mbc3.rtc_halt);
-  s.integer(mbc3.rtc_second);
-  s.integer(mbc3.rtc_minute);
-  s.integer(mbc3.rtc_hour);
-  s.integer(mbc3.rtc_day);
-  s.integer(mbc3.rtc_day_carry);
-
-  s.integer(mbc3.rtc_latch_second);
-  s.integer(mbc3.rtc_latch_minute);
-  s.integer(mbc3.rtc_latch_hour);
-  s.integer(mbc3.rtc_latch_day);
-  s.integer(mbc3.rtc_latch_day_carry);
-
-  s.integer(mbc5.ram_enable);
-  s.integer(mbc5.rom_select);
-  s.integer(mbc5.ram_select);
-
-  s.integer(mmm01.rom_mode);
-  s.integer(mmm01.rom_base);
-
-  s.integer(mmm01.ram_enable);
-  s.integer(mmm01.rom_select);
-  s.integer(mmm01.ram_select);
-
-  s.integer(huc1.ram_writable);
-  s.integer(huc1.rom_select);
-  s.integer(huc1.ram_select);
-  s.integer(huc1.model);
-
-  s.integer(huc3.ram_enable);
-  s.integer(huc3.rom_select);
-  s.integer(huc3.ram_select);
-}

gb/cpu/cpu.cpp

@@ -1,208 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-#include "mmio.cpp"
-#include "memory.cpp"
-#include "timing.cpp"
-#include "serialization.cpp"
-CPU cpu;
-
-auto CPU::Main() -> void {
-  cpu.main();
-}
-
-auto CPU::main() -> void {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::CPU) {
-      scheduler.sync = Scheduler::SynchronizeMode::All;
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    interrupt_test();
-    exec();
-  }
-}
-
-auto CPU::interrupt_raise(CPU::Interrupt id) -> void {
-  if(id == Interrupt::Vblank) {
-    status.interrupt_request_vblank = 1;
-    if(status.interrupt_enable_vblank) r.halt = false;
-  }
-
-  if(id == Interrupt::Stat) {
-    status.interrupt_request_stat = 1;
-    if(status.interrupt_enable_stat) r.halt = false;
-  }
-
-  if(id == Interrupt::Timer) {
-    status.interrupt_request_timer = 1;
-    if(status.interrupt_enable_timer) r.halt = false;
-  }
-
-  if(id == Interrupt::Serial) {
-    status.interrupt_request_serial = 1;
-    if(status.interrupt_enable_serial) r.halt = false;
-  }
-
-  if(id == Interrupt::Joypad) {
-    status.interrupt_request_joypad = 1;
-    if(status.interrupt_enable_joypad) r.halt = r.stop = false;
-  }
-}
-
-auto CPU::interrupt_test() -> void {
-  if(r.ime) {
-    if(status.interrupt_request_vblank && status.interrupt_enable_vblank) {
-      status.interrupt_request_vblank = 0;
-      return interrupt_exec(0x0040);
-    }
-
-    if(status.interrupt_request_stat && status.interrupt_enable_stat) {
-      status.interrupt_request_stat = 0;
-      return interrupt_exec(0x0048);
-    }
-
-    if(status.interrupt_request_timer && status.interrupt_enable_timer) {
-      status.interrupt_request_timer = 0;
-      return interrupt_exec(0x0050);
-    }
-
-    if(status.interrupt_request_serial && status.interrupt_enable_serial) {
-      status.interrupt_request_serial = 0;
-      return interrupt_exec(0x0058);
-    }
-
-    if(status.interrupt_request_joypad && status.interrupt_enable_joypad) {
-      status.interrupt_request_joypad = 0;
-      return interrupt_exec(0x0060);
-    }
-  }
-}
-
-auto CPU::interrupt_exec(uint16 pc) -> void {
-  r.ime = 0;
-  op_write(--r[SP], r[PC] >> 8);
-  op_write(--r[SP], r[PC] >> 0);
-  r[PC] = pc;
-  op_io();
-  op_io();
-  op_io();
-}
-
-auto CPU::stop() -> bool {
-  if(status.speed_switch) {
-    status.speed_switch = 0;
-    status.speed_double ^= 1;
-    if(status.speed_double == 0) frequency = 4 * 1024 * 1024;
-    if(status.speed_double == 1) frequency = 8 * 1024 * 1024;
-    return true;
-  }
-  return false;
-}
-
-auto CPU::power() -> void {
-  create(Main, 4 * 1024 * 1024);
-  LR35902::power();
-
-  for(uint n = 0xc000; n <= 0xdfff; n++) bus.mmio[n] = this;  //WRAM
-  for(uint n = 0xe000; n <= 0xfdff; n++) bus.mmio[n] = this;  //WRAM (mirror)
-  for(uint n = 0xff80; n <= 0xfffe; n++) bus.mmio[n] = this;  //HRAM
-
-  bus.mmio[0xff00] = this;  //JOYP
-  bus.mmio[0xff01] = this;  //SB
-  bus.mmio[0xff02] = this;  //SC
-  bus.mmio[0xff04] = this;  //DIV
-  bus.mmio[0xff05] = this;  //TIMA
-  bus.mmio[0xff06] = this;  //TMA
-  bus.mmio[0xff07] = this;  //TAC
-  bus.mmio[0xff0f] = this;  //IF
-  bus.mmio[0xff46] = this;  //DMA
-  bus.mmio[0xffff] = this;  //IE
-
-  if(system.cgb()) {
-  bus.mmio[0xff4d] = this;  //KEY1
-  bus.mmio[0xff51] = this;  //HDMA1
-  bus.mmio[0xff52] = this;  //HDMA2
-  bus.mmio[0xff53] = this;  //HDMA3
-  bus.mmio[0xff54] = this;  //HDMA4
-  bus.mmio[0xff55] = this;  //HDMA5
-  bus.mmio[0xff56] = this;  //RP
-  bus.mmio[0xff6c] = this;  //???
-  bus.mmio[0xff70] = this;  //SVBK
-  bus.mmio[0xff72] = this;  //???
-  bus.mmio[0xff73] = this;  //???
-  bus.mmio[0xff74] = this;  //???
-  bus.mmio[0xff75] = this;  //???
-  bus.mmio[0xff76] = this;  //???
-  bus.mmio[0xff77] = this;  //???
-  }
-
-  for(auto& n : wram) n = 0x00;
-  for(auto& n : hram) n = 0x00;
-
-  r[PC] = 0x0000;
-  r[SP] = 0x0000;
-  r[AF] = 0x0000;
-  r[BC] = 0x0000;
-  r[DE] = 0x0000;
-  r[HL] = 0x0000;
-
-  status.clock = 0;
-
-  status.p15 = 0;
-  status.p14 = 0;
-  status.joyp = 0;
-  status.mlt_req = 0;
-
-  status.serial_data = 0;
-  status.serial_bits = 0;
-
-  status.serial_transfer = 0;
-  status.serial_clock = 0;
-
-  status.div = 0;
-
-  status.tima = 0;
-
-  status.tma = 0;
-
-  status.timer_enable = 0;
-  status.timer_clock = 0;
-
-  status.interrupt_request_joypad = 0;
-  status.interrupt_request_serial = 0;
-  status.interrupt_request_timer = 0;
-  status.interrupt_request_stat = 0;
-  status.interrupt_request_vblank = 0;
-
-  status.speed_double = 0;
-  status.speed_switch = 0;
-
-  status.dma_source = 0;
-  status.dma_target = 0;
-
-  status.dma_mode = 0;
-  status.dma_length = 0;
-  status.dma_completed = true;
-
-  status.ff6c = 0;
-  status.ff72 = 0;
-  status.ff73 = 0;
-  status.ff74 = 0;
-  status.ff75 = 0;
-
-  status.wram_bank = 1;
-
-  status.interrupt_enable_joypad = 0;
-  status.interrupt_enable_serial = 0;
-  status.interrupt_enable_timer = 0;
-  status.interrupt_enable_stat = 0;
-  status.interrupt_enable_vblank = 0;
-
-  oamdma.active = false;
-  oamdma.bank = 0;
-  oamdma.offset = 0;
-}
-
-}

gb/cpu/cpu.hpp

@@ -1,120 +0,0 @@
-struct CPU : Processor::LR35902, Thread, MMIO {
-  enum class Interrupt : uint { Vblank, Stat, Timer, Serial, Joypad };
-
-  static auto Main() -> void;
-  auto main() -> void;
-  auto interrupt_raise(Interrupt id) -> void;
-  auto interrupt_test() -> void;
-  auto interrupt_exec(uint16 pc) -> void;
-  auto stop() -> bool;
-  auto power() -> void;
-
-  auto serialize(serializer&) -> void;
-
-  //mmio.cpp
-  auto wram_addr(uint16 addr) const -> uint;
-  auto mmio_joyp_poll() -> void;
-  auto mmio_read(uint16 addr) -> uint8;
-  auto mmio_write(uint16 addr, uint8 data) -> void;
-
-  //memory.cpp
-  auto op_io() -> void;
-  auto op_read(uint16 addr) -> uint8;
-  auto op_write(uint16 addr, uint8 data) -> void;
-  auto cycle_edge() -> void;
-  auto dma_read(uint16 addr) -> uint8;
-  auto dma_write(uint16 addr, uint8 data) -> void;
-  auto debugger_read(uint16 addr) -> uint8;
-
-  //timing.cpp
-  auto add_clocks(uint clocks) -> void;
-  auto timer_262144hz() -> void;
-  auto timer_65536hz() -> void;
-  auto timer_16384hz() -> void;
-  auto timer_8192hz() -> void;
-  auto timer_4096hz() -> void;
-  auto hblank() -> void;
-
-  struct Status {
-    uint clock;
-
-    //$ff00  JOYP
-    bool p15;
-    bool p14;
-    uint8 joyp;
-    uint8 mlt_req;
-
-    //$ff01  SB
-    uint8 serial_data;
-    uint serial_bits;
-
-    //$ff02  SC
-    bool serial_transfer;
-    bool serial_clock;
-
-    //$ff04  DIV
-    uint8 div;
-
-    //$ff05  TIMA
-    uint8 tima;
-
-    //$ff06  TMA
-    uint8 tma;
-
-    //$ff07  TAC
-    bool timer_enable;
-    uint timer_clock;
-
-    //$ff0f  IF
-    bool interrupt_request_joypad;
-    bool interrupt_request_serial;
-    bool interrupt_request_timer;
-    bool interrupt_request_stat;
-    bool interrupt_request_vblank;
-
-    //$ff4d  KEY1
-    bool speed_double;
-    bool speed_switch;
-
-    //$ff51,$ff52  HDMA1,HDMA2
-    uint16 dma_source;
-
-    //$ff53,$ff54  HDMA3,HDMA4
-    uint16 dma_target;
-
-    //$ff55  HDMA5
-    bool dma_mode;
-    uint16 dma_length;
-    bool dma_completed;
-
-    //$ff6c  ???
-    uint8 ff6c;
-
-    //$ff70  SVBK
-    uint3 wram_bank;
-
-    //$ff72-$ff75  ???
-    uint8 ff72;
-    uint8 ff73;
-    uint8 ff74;
-    uint8 ff75;
-
-    //$ffff  IE
-    bool interrupt_enable_joypad;
-    bool interrupt_enable_serial;
-    bool interrupt_enable_timer;
-    bool interrupt_enable_stat;
-    bool interrupt_enable_vblank;
-  } status;
-
-  struct OAMDMA {
-    bool active;
-    uint8 bank;
-    uint8 offset;
-  } oamdma;
-
-  uint8 wram[32768];  //GB=8192, GBC=32768
-  uint8 hram[128];
-};
-
-extern CPU cpu;

gb/cpu/memory.cpp

@@ -1,43 +0,0 @@
-auto CPU::op_io() -> void {
-  cycle_edge();
-  add_clocks(4);
-}
-
-auto CPU::op_read(uint16 addr) -> uint8 {
-  cycle_edge();
-  add_clocks(4);
-  if(oamdma.active && (addr < 0xff80 || addr == 0xffff)) return 0x00;
-  return bus.read(addr);
-}
-
-auto CPU::op_write(uint16 addr, uint8 data) -> void {
-  cycle_edge();
-  add_clocks(4);
-  if(oamdma.active && (addr < 0xff80 || addr == 0xffff)) return;
-  bus.write(addr, data);
-}
-
-auto CPU::cycle_edge() -> void {
-  if(r.ei) {
-    r.ei = false;
-    r.ime = 1;
-  }
-}
-
-//VRAM DMA source can only be ROM or RAM
-auto CPU::dma_read(uint16 addr) -> uint8 {
-  if(addr < 0x8000) return bus.read(addr);  //0000-7fff
-  if(addr < 0xa000) return 0x00;            //8000-9fff
-  if(addr < 0xe000) return bus.read(addr);  //a000-dfff
-  return 0x00;                              //e000-ffff
-}
-
-//VRAM DMA target is always VRAM
-auto CPU::dma_write(uint16 addr, uint8 data) -> void {
-  addr = 0x8000 | (addr & 0x1fff);  //8000-9fff
-  return bus.write(addr, data);
-}
-
-auto CPU::debugger_read(uint16 addr) -> uint8 {
-  return bus.read(addr);
-}

gb/cpu/serialization.cpp

@@ -1,60 +0,0 @@
-auto CPU::serialize(serializer& s) -> void {
-  LR35902::serialize(s);
-  Thread::serialize(s);
-
-  s.array(wram);
-  s.array(hram);
-
-  s.integer(status.clock);
-
-  s.integer(status.p15);
-  s.integer(status.p14);
-  s.integer(status.joyp);
-  s.integer(status.mlt_req);
-
-  s.integer(status.serial_data);
-  s.integer(status.serial_bits);
-
-  s.integer(status.serial_transfer);
-  s.integer(status.serial_clock);
-
-  s.integer(status.div);
-  s.integer(status.tima);
-  s.integer(status.tma);
-  s.integer(status.timer_enable);
-  s.integer(status.timer_clock);
-
-  s.integer(status.interrupt_request_joypad);
-  s.integer(status.interrupt_request_serial);
-  s.integer(status.interrupt_request_timer);
-  s.integer(status.interrupt_request_stat);
-  s.integer(status.interrupt_request_vblank);
-
-  s.integer(status.speed_double);
-  s.integer(status.speed_switch);
-
-  s.integer(status.dma_source);
-  s.integer(status.dma_target);
-  s.integer(status.dma_mode);
-  s.integer(status.dma_length);
-  s.integer(status.dma_completed);
-
-  s.integer(status.ff6c);
-
-  s.integer(status.wram_bank);
-
-  s.integer(status.ff72);
-  s.integer(status.ff73);
-  s.integer(status.ff74);
-  s.integer(status.ff75);
-
-  s.integer(status.interrupt_enable_joypad);
-  s.integer(status.interrupt_enable_serial);
-  s.integer(status.interrupt_enable_timer);
-  s.integer(status.interrupt_enable_stat);
-  s.integer(status.interrupt_enable_vblank);
-
-  s.integer(oamdma.active);
-  s.integer(oamdma.bank);
-  s.integer(oamdma.offset);
-}

gb/cpu/timing.cpp

@@ -1,94 +0,0 @@
-//70224 clocks/frame
-//  456 clocks/scanline
-//  154 scanlines/frame
-
-auto CPU::add_clocks(uint clocks) -> void {
-  if(oamdma.active) {
-    for(uint n = 0; n < 4 * clocks; n++) {
-      bus.write(0xfe00 + oamdma.offset, bus.read((oamdma.bank << 8) + oamdma.offset));
-      if(++oamdma.offset == 160) {
-        oamdma.active = false;
-        break;
-      }
-    }
-  }
-
-  system.clocks_executed += clocks;
-  if(system.sgb()) scheduler.exit(Scheduler::ExitReason::StepEvent);
-
-  status.clock += clocks;
-  if(status.clock >= 4 * 1024 * 1024) {
-    status.clock -= 4 * 1024 * 1024;
-    cartridge.mbc3.second();
-  }
-
-  //4MHz / N(hz) - 1 = mask
-  if((status.clock &   15) == 0) timer_262144hz();
-  if((status.clock &   63) == 0)  timer_65536hz();
-  if((status.clock &  255) == 0)  timer_16384hz();
-  if((status.clock &  511) == 0)   timer_8192hz();
-  if((status.clock & 1023) == 0)   timer_4096hz();
-
-  ppu.clock -= clocks * ppu.frequency;
-  if(ppu.clock < 0) co_switch(scheduler.active_thread = ppu.thread);
-
-  apu.clock -= clocks * apu.frequency;
-  if(apu.clock < 0) co_switch(scheduler.active_thread = apu.thread);
-}
-
-auto CPU::timer_262144hz() -> void {
-  if(status.timer_enable && status.timer_clock == 1) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-auto CPU::timer_65536hz() -> void {
-  if(status.timer_enable && status.timer_clock == 2) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-auto CPU::timer_16384hz() -> void {
-  if(status.timer_enable && status.timer_clock == 3) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-
-  status.div++;
-}
-
-auto CPU::timer_8192hz() -> void {
-  if(status.serial_transfer && status.serial_clock) {
-    if(--status.serial_bits == 0) {
-      status.serial_transfer = 0;
-      interrupt_raise(Interrupt::Serial);
-    }
-  }
-}
-
-auto CPU::timer_4096hz() -> void {
-  if(status.timer_enable && status.timer_clock == 0) {
-    if(++status.tima == 0) {
-      status.tima = status.tma;
-      interrupt_raise(Interrupt::Timer);
-    }
-  }
-}
-
-auto CPU::hblank() -> void {
-  if(status.dma_mode == 1 && status.dma_length && ppu.status.ly < 144) {
-    for(auto n : range(16)) {
-      dma_write(status.dma_target++, dma_read(status.dma_source++));
-    }
-    add_clocks(8 << status.speed_double);
-    status.dma_length -= 16;
-  }
-}

gb/interface/interface.cpp

@@ -1,186 +0,0 @@
-#include <gb/gb.hpp>
-
-namespace GameBoy {
-
-Interface* interface = nullptr;
-
-Interface::Interface() {
-  interface = this;
-  hook = nullptr;
-
-  information.name        = "Game Boy";
-  information.width       = 160;
-  information.height      = 144;
-  information.overscan    = false;
-  information.aspectRatio = 1.0;
-  information.resettable  = false;
-  information.capability.states = true;
-  information.capability.cheats = true;
-
-  media.append({ID::GameBoy,      "Game Boy",       "gb" , true});
-  media.append({ID::GameBoyColor, "Game Boy Color", "gbc", true});
-
-  {
-    Device device{0, ID::Device, "Controller"};
-    device.input.append({0, 0, "Up"    });
-    device.input.append({1, 0, "Down"  });
-    device.input.append({2, 0, "Left"  });
-    device.input.append({3, 0, "Right" });
-    device.input.append({4, 0, "B"     });
-    device.input.append({5, 0, "A"     });
-    device.input.append({6, 0, "Select"});
-    device.input.append({7, 0, "Start" });
-    device.order = {0, 1, 2, 3, 4, 5, 6, 7};
-    this->device.append(device);
-  }
-
-  port.append({0, "Device", {device[0]}});
-}
-
-auto Interface::manifest() -> string {
-  return cartridge.manifest();
-}
-
-auto Interface::title() -> string {
-  return cartridge.title();
-}
-
-auto Interface::videoFrequency() -> double {
-  return 4194304.0 / (154.0 * 456.0);
-}
-
-auto Interface::audioFrequency() -> double {
-  return 4194304.0 / 2.0;
-}
-
-auto Interface::loaded() -> bool {
-  return cartridge.loaded();
-}
-
-auto Interface::sha256() -> string {
-  return cartridge.sha256();
-}
-
-auto Interface::group(uint id) -> uint {
-  switch(id) {
-  case ID::SystemManifest:
-  case ID::GameBoyBootROM:
-  case ID::SuperGameBoyBootROM:
-  case ID::GameBoyColorBootROM:
-    return 0;
-  case ID::Manifest:
-  case ID::ROM:
-  case ID::RAM:
-    switch(system.revision) {
-    case System::Revision::GameBoy: return ID::GameBoy;
-    case System::Revision::SuperGameBoy: return ID::SuperGameBoy;
-    case System::Revision::GameBoyColor: return ID::GameBoyColor;
-    }
-    throw;
-  }
-  throw;
-}
-
-auto Interface::load(uint id) -> void {
-  if(id == ID::GameBoy) cartridge.load(System::Revision::GameBoy);
-  if(id == ID::SuperGameBoy) cartridge.load(System::Revision::SuperGameBoy);
-  if(id == ID::GameBoyColor) cartridge.load(System::Revision::GameBoyColor);
-}
-
-auto Interface::save() -> void {
-  for(auto& memory : cartridge.memory) {
-    interface->saveRequest(memory.id, memory.name);
-  }
-}
-
-auto Interface::load(uint id, const stream& stream) -> void {
-  if(id == ID::SystemManifest) {
-    system.information.manifest = stream.text();
-  }
-
-  if(id == ID::GameBoyBootROM) {
-    stream.read(system.bootROM.dmg, min( 256u, stream.size()));
-  }
-
-  if(id == ID::SuperGameBoyBootROM) {
-    stream.read(system.bootROM.sgb, min( 256u, stream.size()));
-  }
-
-  if(id == ID::GameBoyColorBootROM) {
-    stream.read(system.bootROM.cgb, min(2048u, stream.size()));
-  }
-
-  if(id == ID::Manifest) {
-    cartridge.information.markup = stream.text();
-  }
-
-  if(id == ID::ROM) {
-    stream.read(cartridge.romdata, min(cartridge.romsize, stream.size()));
-  }
-
-  if(id == ID::RAM) {
-    stream.read(cartridge.ramdata, min(stream.size(), cartridge.ramsize));
-  }
-}
-
-auto Interface::save(uint id, const stream& stream) -> void {
-  if(id == ID::RAM) {
-    stream.write(cartridge.ramdata, cartridge.ramsize);
-  }
-}
-
-auto Interface::unload() -> void {
-  save();
-  cartridge.unload();
-}
-
-auto Interface::power() -> void {
-  system.power();
-}
-
-auto Interface::reset() -> void {
-  system.power();
-}
-
-auto Interface::run() -> void {
-  system.run();
-}
-
-auto Interface::serialize() -> serializer {
-  system.runtosave();
-  return system.serialize();
-}
-
-auto Interface::unserialize(serializer& s) -> bool {
-  return system.unserialize(s);
-}
-
-auto Interface::cheatSet(const lstring& list) -> void {
-  cheat.reset();
-  for(auto& codeset : list) {
-    lstring codes = codeset.split("+");
-    for(auto& code : codes) {
-      lstring part = code.split("/");
-      if(part.size() == 2) cheat.append(hex(part[0]), hex(part[1]));
-      if(part.size() == 3) cheat.append(hex(part[0]), hex(part[1]), hex(part[2]));
-    }
-  }
-}
-
-auto Interface::paletteUpdate(PaletteMode mode) -> void {
-  video.generate_palette(mode);
-}
-
-auto Interface::lcdScanline() -> void {
-  if(hook) hook->lcdScanline();
-}
-
-auto Interface::lcdOutput(uint2 color) -> void {
-  if(hook) hook->lcdOutput(color);
-}
-
-auto Interface::joypWrite(bool p15, bool p14) -> void {
-  if(hook) hook->joypWrite(p15, p14);
-}
-
-}

gb/interface/interface.hpp

@@ -1,77 +0,0 @@
-#ifndef GB_HPP
-namespace GameBoy {
-#endif
-
-struct ID {
-  enum : uint {
-    System,
-    GameBoy,
-    SuperGameBoy,
-    GameBoyColor,
-  };
-
-  enum : uint {
-    SystemManifest,
-    GameBoyBootROM,
-    SuperGameBoyBootROM,
-    GameBoyColorBootROM,
-
-    Manifest,
-    ROM,
-    RAM,
-  };
-
-  enum : uint {
-    Device = 1,
-  };
-};
-
-struct Interface : Emulator::Interface {
-  Interface();
-
-  auto manifest() -> string;
-  auto title() -> string;
-  auto videoFrequency() -> double;
-  auto audioFrequency() -> double;
-
-  auto loaded() -> bool;
-  auto sha256() -> string;
-  auto group(uint id) -> uint;
-  auto load(uint id) -> void;
-  auto save() -> void;
-  auto load(uint id, const stream& stream) -> void;
-  auto save(uint id, const stream& stream) -> void;
-  auto unload() -> void;
-
-  auto power() -> void;
-  auto reset() -> void;
-  auto run() -> void;
-
-  auto serialize() -> serializer;
-  auto unserialize(serializer&) -> bool;
-
-  auto cheatSet(const lstring&) -> void;
-
-  auto paletteUpdate(PaletteMode mode) -> void;
-
-  //Super Game Boy bindings
-  struct Hook {
-    virtual auto lcdScanline() -> void {}
-    virtual auto lcdOutput(uint2 color) -> void {}
-    virtual auto joypWrite(bool p15, bool p14) -> void {}
-  };
-  Hook* hook = nullptr;
-
-  auto lcdScanline() -> void;
-  auto lcdOutput(uint2 color) -> void;
-  auto joypWrite(bool p15, bool p14) -> void;
-
-private:
-  vector<Device> device;
-};
-
-extern Interface* interface;
-
-#ifndef GB_HPP
-}
-#endif

gb/ppu/mmio.cpp

@@ -1,199 +0,0 @@
-auto PPU::vram_addr(uint16 addr) const -> uint {
-  return (status.vram_bank * 0x2000) + (addr & 0x1fff);
-}
-
-auto PPU::mmio_read(uint16 addr) -> uint8 {
-  if(addr >= 0x8000 && addr <= 0x9fff) return vram[vram_addr(addr)];
-  if(addr >= 0xfe00 && addr <= 0xfe9f) return oam[addr & 0xff];
-
-  if(addr == 0xff40) {  //LCDC
-    return (status.display_enable << 7)
-         | (status.window_tilemap_select << 6)
-         | (status.window_display_enable << 5)
-         | (status.bg_tiledata_select << 4)
-         | (status.bg_tilemap_select << 3)
-         | (status.ob_size << 2)
-         | (status.ob_enable << 1)
-         | (status.bg_enable << 0);
-  }
-
-  if(addr == 0xff41) {  //STAT
-    uint mode;
-    if(status.ly >= 144) mode = 1;  //Vblank
-    else if(status.lx < 80) mode = 2;  //OAM
-    else if(status.lx < 252) mode = 3;  //LCD
-    else mode = 0;  //Hblank
-
-    return (status.interrupt_lyc << 6)
-         | (status.interrupt_oam << 5)
-         | (status.interrupt_vblank << 4)
-         | (status.interrupt_hblank << 3)
-         | ((status.ly == status.lyc) << 2)
-         | (mode << 0);
-  }
-
-  if(addr == 0xff42) {  //SCY
-    return status.scy;
-  }
-
-  if(addr == 0xff43) {  //SCX
-    return status.scx;
-  }
-
-  if(addr == 0xff44) {  //LY
-    return status.ly;
-  }
-
-  if(addr == 0xff45) {  //LYC
-    return status.lyc;
-  }
-
-  if(addr == 0xff47) {  //BGP
-    return (bgp[3] << 6)
-         | (bgp[2] << 4)
-         | (bgp[1] << 2)
-         | (bgp[0] << 0);
-  }
-
-  if(addr == 0xff48) {  //OBP0
-    return (obp[0][3] << 6)
-         | (obp[0][2] << 4)
-         | (obp[0][1] << 2)
-         | (obp[0][0] << 0);
-  }
-
-  if(addr == 0xff49) {  //OBP1
-    return (obp[1][3] << 6)
-         | (obp[1][2] << 4)
-         | (obp[1][1] << 2)
-         | (obp[1][0] << 0);
-  }
-
-  if(addr == 0xff4a) {  //WY
-    return status.wy;
-  }
-
-  if(addr == 0xff4b) {  //WX
-    return status.wx;
-  }
-
-  if(addr == 0xff69) { //BGPD
-    return bgpd[status.bgpi];
-  }
-
-  if(addr == 0xff6b) {  //OBPD
-    return obpd[status.obpi];
-  }
-
-  return 0x00;
-}
-
-auto PPU::mmio_write(uint16 addr, uint8 data) -> void {
-  if(addr >= 0x8000 && addr <= 0x9fff) { vram[vram_addr(addr)] = data; return; }
-  if(addr >= 0xfe00 && addr <= 0xfe9f) { oam[addr & 0xff] = data; return; }
-
-  if(addr == 0xff40) {  //LCDC
-    if(status.display_enable == false && (data & 0x80)) {
-      status.lx = 0;  //unverified behavior; fixes Super Mario Land 2 - Tree Zone
-    }
-
-    status.display_enable = data & 0x80;
-    status.window_tilemap_select = data & 0x40;
-    status.window_display_enable = data & 0x20;
-    status.bg_tiledata_select = data & 0x10;
-    status.bg_tilemap_select = data & 0x08;
-    status.ob_size = data & 0x04;
-    status.ob_enable = data & 0x02;
-    status.bg_enable = data & 0x01;
-    return;
-  }
-
-  if(addr == 0xff41) {  //STAT
-    status.interrupt_lyc = data & 0x40;
-    status.interrupt_oam = data & 0x20;
-    status.interrupt_vblank = data & 0x10;
-    status.interrupt_hblank = data & 0x08;
-    return;
-  }
-
-  if(addr == 0xff42) {  //SCY
-    status.scy = data;
-    return;
-  }
-
-  if(addr == 0xff43) {  //SCX
-    status.scx = data;
-    return;
-  }
-
-  if(addr == 0xff44) {  //LY
-    status.ly = 0;
-    return;
-  }
-
-  if(addr == 0xff45) {  //LYC
-    status.lyc = data;
-    return;
-  }
-
-  if(addr == 0xff47) {  //BGP
-    bgp[3] = (data >> 6) & 3;
-    bgp[2] = (data >> 4) & 3;
-    bgp[1] = (data >> 2) & 3;
-    bgp[0] = (data >> 0) & 3;
-    return;
-  }
-
-  if(addr == 0xff48) {  //OBP0
-    obp[0][3] = (data >> 6) & 3;
-    obp[0][2] = (data >> 4) & 3;
-    obp[0][1] = (data >> 2) & 3;
-    obp[0][0] = (data >> 0) & 3;
-    return;
-  }
-
-  if(addr == 0xff49) {  //OBP1
-    obp[1][3] = (data >> 6) & 3;
-    obp[1][2] = (data >> 4) & 3;
-    obp[1][1] = (data >> 2) & 3;
-    obp[1][0] = (data >> 0) & 3;
-    return;
-  }
-
-  if(addr == 0xff4a) {  //WY
-    status.wy = data;
-    return;
-  }
-
-  if(addr == 0xff4b) {  //WX
-    status.wx = data;
-    return;
-  }
-
-  if(addr == 0xff4f) {  //VBK
-    status.vram_bank = data & 1;
-    return;
-  }
-
-  if(addr == 0xff68) {  //BGPI
-    status.bgpi_increment = data & 0x80;
-    status.bgpi = data & 0x3f;
-    return;
-  }
-
-  if(addr == 0xff69) {  //BGPD
-    bgpd[status.bgpi] = data;
-    if(status.bgpi_increment) status.bgpi++;
-    return;
-  }
-
-  if(addr == 0xff6a) {  //OBPI
-    status.obpi_increment = data & 0x80;
-    status.obpi = data & 0x3f;
-  }
-
-  if(addr == 0xff6b) {  //OBPD
-    obpd[status.obpi] = data;
-    if(status.obpi_increment) status.obpi++;
-  }
-}