Update to v083 release.

byuu says:

This release adds preliminary Nintendo / Famicom emulation. It's only
a week or two old, so a lot of work still needs to be done before it can
compete with the most popular NES emulators.

It's important to clarify: bsnes is primarily an SNES emulator. That
will always be its forte and my core focus. I have added Game Boy
support previously for Super Game Boy emulation, and I've added NES
support mostly for something fun to work on to break up the monotony of
working on one system for seven years now. Obviously, I'd like the
emulation to be accurate and highly compatible, but I simply cannot
afford to invest the same amount of time and money into any other
systems.

Still, either way the NES and GB emulation serve as fun side-diversions,
and allow for a unified emulator interface with all of bsnes' unique
features applied to all systems. My personal favorite feature is
mightymo's extended built-in cheat code database that now also includes
NES and Game Boy codes. And it even works in Super Game Boy mode now,
too!

I'm also not worried about speed at all: so long as NES/GB are faster
than SNES/compatibility, it's fine by me. Note that due to the NES audio
running at 1.78MHz, and Game Boy audio at 4MHz stereo, a more
sophisticated audio resampler was needed: Ryphecha (Mednafen author) has
graciously written a first-rate resampler: it is a band-limited
Kaiser-windowed polyphase sinc resampler. It is combined with two
highpass filters to remove DC bias. The filter itself is SSE optimized,
but even still, approximately 50% of CPU usage for NES/GB emulation goes
to the audio filtering alone. However, you now have the best sound
possible for NES and Game Boy emulation as a result.

The GUI has also been heavily re-structured to accommodate multiple
emulators from the same interface. As such, it's quite likely a few bugs
are still lurking here and there. Please report them and I'll iron them
out for the next release.

Changelog:
- license is now GPLv3
- re-structured GUI as a multi-system emulator
- added NES emulation [byuu, Ryphecha]
- added NES ICs: MMC1, MMC2, MMC3, MMC4, MMC5, VRC4, VRC6+audio, VRC7,
  Sunsoft-5B+audio, Bandai-LZ93D50
- added NES boards: AxROM, BNROM, CNROM, ExROM, FxROM, GxROM, NROM,
  PxROM, SxROM, TxROM, UxROM
- Game Boy emulation improvements [Jonas Quinn]
- SNES core outputs full 19-bit color (4-bit luma included) for more
  accurate color reproduction (~5% speed hit)
- audio resampler is now a band-limited polyphase resampler [Ryphecha]
- cheat database includes NES+GB codes as well [mightymo, tukuyomi]
- lots of other changes

bsnes/Makefile

@@ -1,10 +1,12 @@
 include nall/Makefile
 
+nes := nes
 snes := snes
 gameboy := gameboy
 profile := accuracy
 ui := ui
 
+# options += console
 # options += debugger
 
 # compiler
@@ -25,21 +27,22 @@ else ifeq ($(pgo),optimize)
   flags += -fprofile-use
 endif
 
-flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
-
 # platform
 ifeq ($(platform),x)
+  # tree vectorization causes code generation errors with Linux/GCC 4.6.1
+  flags += -fno-tree-vectorize
   link += -s -ldl -lX11 -lXext
 else ifeq ($(platform),osx)
 else ifeq ($(platform),win)
-  link += -mwindows
-# link += -mconsole
+  link += $(if $(findstring console,$(options)),-mconsole,-mwindows)
   link += -mthreads -s -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32
-  link += -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
+  link += -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
 else
   unknown_platform: help;
 endif
 
+flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
+
 # implicit rules
 compile = \
   $(strip \
@@ -74,6 +77,6 @@ clean:
 	-@$(call delete,*.manifest)
 
 archive-all:
-	tar -cjf bsnes.tar.bz2 data gameboy libco nall obj out phoenix ruby snes ui ui-gameboy ui-libsnes Makefile cc.bat clean.bat sync.sh
+	tar -cjf bsnes.tar.bz2 data gameboy libco nall nes obj out phoenix ruby snes ui ui-libsnes Makefile cc.bat clean.bat sync.sh
 
 help:;

bsnes/gameboy/Makefile

@@ -1,8 +1,10 @@
-gameboy_objects := gameboy-system gameboy-scheduler
+gameboy_objects := gameboy-interface gameboy-system gameboy-scheduler
 gameboy_objects += gameboy-memory gameboy-cartridge
 gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd
+gameboy_objects += gameboy-cheat
 objects += $(gameboy_objects)
 
+obj/gameboy-interface.o: $(gameboy)/interface/interface.cpp $(call rwildcard,$(gameboy)/interface/)
 obj/gameboy-system.o: $(gameboy)/system/system.cpp $(call rwildcard,$(gameboy)/system/)
 obj/gameboy-scheduler.o: $(gameboy)/scheduler/scheduler.cpp $(call rwildcard,$(gameboy)/scheduler/)
 obj/gameboy-cartridge.o: $(gameboy)/cartridge/cartridge.cpp $(call rwildcard,$(gameboy)/cartridge/)
@@ -10,3 +12,4 @@ obj/gameboy-memory.o: $(gameboy)/memory/memory.cpp $(call rwildcard,$(gameboy)/m
 obj/gameboy-cpu.o: $(gameboy)/cpu/cpu.cpp $(call rwildcard,$(gameboy)/cpu/)
 obj/gameboy-apu.o: $(gameboy)/apu/apu.cpp $(call rwildcard,$(gameboy)/apu/)
 obj/gameboy-lcd.o: $(gameboy)/lcd/lcd.cpp $(call rwildcard,$(gameboy)/lcd/)
+obj/gameboy-cheat.o: $(gameboy)/cheat/cheat.cpp $(call rwildcard,$(gameboy)/cheat/)

bsnes/gameboy/apu/apu.cpp

@@ -46,7 +46,7 @@ void APU::main() {
     noise.run();
     master.run();
 
-    system.interface->audio_sample(master.center, master.left, master.right);
+    interface->audioSample(master.center, master.left, master.right);
     if(++clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
   }
 }
@@ -55,7 +55,7 @@ void APU::power() {
   create(Main, 4194304);
   for(unsigned n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
 
-  foreach(n, mmio_data) n = 0x00;
+  for(auto &n : mmio_data) n = 0x00;
   sequencer_base = 0;
   sequencer_step = 0;
 
@@ -80,10 +80,10 @@ uint8 APU::mmio_read(uint16 addr) {
 
   if(addr == 0xff26) {
     uint8 data = master.enable << 7;
-    if(square1.counter && square1.length) data |= 0x01;
-    if(square2.counter && square2.length) data |= 0x02;
-    if(   wave.counter &&    wave.length) data |= 0x04;
-    if(  noise.counter &&   noise.length) data |= 0x08;
+    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];
   }
 

bsnes/gameboy/apu/master/master.cpp

@@ -1,6 +1,11 @@
 #ifdef APU_CPP
 
 void APU::Master::run() {
+  static int16_t volume[] = {
+    -16384, -14336, -12288, -10240,  -8192,  -6144,  -4096,  -2048,
+     +2048,  +4096,  +6144,  +8192, +10240, +12288, +14336, +16384,
+  };
+
   if(enable == false) {
     center = 0;
     left   = 0;
@@ -14,13 +19,7 @@ void APU::Master::run() {
   sample +=    apu.wave.output;
   sample +=   apu.noise.output;
   sample >>= 2;
-  center = sclamp<16>(sample);
-
-  if(left_enable == false && right_enable == false) {
-    left  = center;
-    right = center;
-    return;
-  }
+  center = volume[sample];
 
   sample = 0;
   channels = 0;
@@ -29,7 +28,7 @@ void APU::Master::run() {
   if(channel3_left_enable) { sample +=    apu.wave.output; channels++; }
   if(channel4_left_enable) { sample +=   apu.noise.output; channels++; }
   if(channels) sample /= channels;
-  left = sclamp<16>(sample);
+  left = volume[sample];
 
   switch(left_volume) {
     case 0: left >>= 3;                       break;  // 12.5%
@@ -41,7 +40,6 @@ void APU::Master::run() {
     case 6: left -= (left >> 3);              break;  // 87.5%
   //case 7:                                   break;  //100.0%
   }
-  if(left_enable == false) left = 0;
 
   sample = 0;
   channels = 0;
@@ -50,7 +48,7 @@ void APU::Master::run() {
   if(channel3_right_enable) { sample +=    apu.wave.output; channels++; }
   if(channel4_right_enable) { sample +=   apu.noise.output; channels++; }
   if(channels) sample /= channels;
-  right = sclamp<16>(sample);
+  right = volume[sample];
 
   switch(right_volume) {
     case 0: right >>= 3;                         break;  // 12.5%
@@ -62,18 +60,17 @@ void APU::Master::run() {
     case 6: right -= (right >> 3);               break;  // 87.5%
   //case 7:                                      break;  //100.0%
   }
-  if(right_enable == false) right = 0;
 }
 
 void APU::Master::write(unsigned r, uint8 data) {
-  if(r == 0) {
-    left_enable  = data & 0x80;
-    left_volume  = (data >> 4) & 7;
-    right_enable = data & 0x08;
-    right_volume = (data >> 0) & 7;
+  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) {
+  if(r == 1) {  //$ff25  NR51
     channel4_left_enable  = data & 0x80;
     channel3_left_enable  = data & 0x40;
     channel2_left_enable  = data & 0x20;
@@ -84,15 +81,15 @@ void APU::Master::write(unsigned r, uint8 data) {
     channel1_right_enable = data & 0x01;
   }
 
-  if(r == 2) {
+  if(r == 2) {  //$ff26  NR52
     enable = data & 0x80;
   }
 }
 
 void APU::Master::power() {
-  left_enable = 0;
+  left_in_enable = 0;
   left_volume = 0;
-  right_enable = 0;
+  right_in_enable = 0;
   right_volume = 0;
   channel4_left_enable  = 0;
   channel3_left_enable  = 0;
@@ -110,9 +107,9 @@ void APU::Master::power() {
 }
 
 void APU::Master::serialize(serializer &s) {
-  s.integer(left_enable);
+  s.integer(left_in_enable);
   s.integer(left_volume);
-  s.integer(right_enable);
+  s.integer(right_in_enable);
   s.integer(right_volume);
   s.integer(channel4_left_enable);
   s.integer(channel3_left_enable);

bsnes/gameboy/apu/master/master.hpp

@@ -1,8 +1,8 @@
 struct Master {
-  bool left_enable;
-  unsigned left_volume;
-  bool right_enable;
-  unsigned right_volume;
+  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;

bsnes/gameboy/apu/noise/noise.cpp

@@ -1,5 +1,9 @@
 #ifdef APU_CPP
 
+bool APU::Noise::dac_enable() {
+  return (envelope_volume || envelope_direction);
+}
+
 void APU::Noise::run() {
   if(period && --period == 0) {
     period = divisor << frequency;
@@ -9,18 +13,20 @@ void APU::Noise::run() {
     }
   }
 
-  uint4 sample = (lfsr & 1) ? 0 : volume;
-  if(counter && length == 0) sample = 0;
+  uint4 sample = (lfsr & 1) ? (uint4)0 : volume;
+  if(enable == false) sample = 0;
 
-  output = (sample * 4369) - 32768;
+  output = sample;
 }
 
 void APU::Noise::clock_length() {
-  if(counter && length) length--;
+  if(counter && length) {
+    if(--length == 0) enable = false;
+  }
 }
 
 void APU::Noise::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
+  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++;
@@ -28,18 +34,18 @@ void APU::Noise::clock_envelope() {
 }
 
 void APU::Noise::write(unsigned r, uint8 data) {
-  if(r == 1) {
-    initial_length = 64 - (data & 0x3f);
-    length = initial_length;
+  if(r == 1) {  //$ff20  NR41
+    length = 64 - (data & 0x3f);
   }
 
-  if(r == 2) {
+  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) {
+  if(r == 3) {  //$ff22  NR43
     frequency = data >> 4;
     narrow_lfsr = data & 0x08;
     divisor = (data & 0x07) << 4;
@@ -47,20 +53,23 @@ void APU::Noise::write(unsigned r, uint8 data) {
     period = divisor << frequency;
   }
 
-  if(r == 4) {
+  if(r == 4) {  //$ff34  NR44
     bool initialize = data & 0x80;
     counter = data & 0x40;
 
     if(initialize) {
+      enable = dac_enable();
       lfsr = ~0U;
-      length = initial_length;
       envelope_period = envelope_frequency;
       volume = envelope_volume;
+      if(length == 0) length = 64;
     }
   }
 }
 
 void APU::Noise::power() {
+  enable = 0;
+
   envelope_volume = 0;
   envelope_direction = 0;
   envelope_frequency = 0;
@@ -70,7 +79,6 @@ void APU::Noise::power() {
   counter = 0;
 
   output = 0;
-  initial_length = 0;
   length = 0;
   envelope_period = 0;
   volume = 0;
@@ -79,6 +87,8 @@ void APU::Noise::power() {
 }
 
 void APU::Noise::serialize(serializer &s) {
+  s.integer(enable);
+
   s.integer(envelope_volume);
   s.integer(envelope_direction);
   s.integer(envelope_frequency);
@@ -88,7 +98,6 @@ void APU::Noise::serialize(serializer &s) {
   s.integer(counter);
 
   s.integer(output);
-  s.integer(initial_length);
   s.integer(length);
   s.integer(envelope_period);
   s.integer(volume);

bsnes/gameboy/apu/noise/noise.hpp

@@ -1,20 +1,23 @@
 struct Noise {
-  unsigned envelope_volume;
+  bool enable;
+
+  uint4 envelope_volume;
   bool envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
+  uint3 envelope_frequency;
+  uint4 frequency;
   bool narrow_lfsr;
   unsigned divisor;
   bool counter;
 
   int16 output;
-  unsigned initial_length;
   unsigned length;
-  unsigned envelope_period;
-  unsigned volume;
+  uint3 envelope_period;
+  uint4 volume;
   unsigned period;
   uint15 lfsr;
 
+  bool dac_enable();
+
   void run();
   void clock_length();
   void clock_envelope();

bsnes/gameboy/apu/square1/square1.cpp

@@ -1,9 +1,13 @@
 #ifdef APU_CPP
 
+bool APU::Square1::dac_enable() {
+  return (envelope_volume || envelope_direction);
+}
+
 void APU::Square1::run() {
   if(period && --period == 0) {
     period = 4 * (2048 - frequency);
-    phase = (phase + 1) & 7;
+    phase++;
     switch(duty) {
       case 0: duty_output = (phase == 6); break;  //______-_
       case 1: duty_output = (phase >= 6); break;  //______--
@@ -12,45 +16,44 @@ void APU::Square1::run() {
     }
   }
 
-  uint4 sample = (duty_output ? volume : 0);
-  if(counter && length == 0) sample = 0;
+  uint4 sample = (duty_output ? volume : (uint4)0);
+  if(enable == false) sample = 0;
 
-  output = (sample * 4369) - 32768;
+  output = sample;
 }
 
-void APU::Square1::sweep() {
-  if(enable == false) return;
+void APU::Square1::sweep(bool update) {
+  if(sweep_enable == false) return;
 
-  signed offset = frequency_shadow >> sweep_shift;
-  if(sweep_direction) offset = -offset;
-  frequency_shadow += offset;
+  sweep_negate = sweep_direction;
+  unsigned delta = frequency_shadow >> sweep_shift;
+  signed freq = frequency_shadow + (sweep_negate ? -delta : delta);
 
-  if(frequency_shadow < 0) {
-    frequency_shadow = 0;
-  } else if(frequency_shadow > 2047) {
-    frequency_shadow = 2048;
+  if(freq > 2047) {
     enable = false;
-  }
-
-  if(frequency_shadow <= 2047 && sweep_shift) {
-    frequency = frequency_shadow;
+  } else if(sweep_shift && update) {
+    frequency_shadow = freq;
+    frequency = freq & 2047;
     period = 4 * (2048 - frequency);
   }
 }
 
 void APU::Square1::clock_length() {
-  if(counter && length) length--;
+  if(counter && length) {
+    if(--length == 0) enable = false;
+  }
 }
 
 void APU::Square1::clock_sweep() {
-  if(sweep_frequency && sweep_period && --sweep_period == 0) {
+  if(enable && sweep_frequency && --sweep_period == 0) {
     sweep_period = sweep_frequency;
-    sweep();
+    sweep(1);
+    sweep(0);
   }
 }
 
 void APU::Square1::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
+  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++;
@@ -58,41 +61,44 @@ void APU::Square1::clock_envelope() {
 }
 
 void APU::Square1::write(unsigned r, uint8 data) {
-  if(r == 0) {
+  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) {
+  if(r == 1) {  //$ff11  NR11
     duty = data >> 6;
-    initial_length = 64 - (data & 0x3f);
-    length = initial_length;
+    length = 64 - (data & 0x3f);
   }
 
-  if(r == 2) {
+  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) {
+  if(r == 3) {  //$ff13  NR13
     frequency = (frequency & 0x0700) | data;
   }
 
-  if(r == 4) {
+  if(r == 4) {  //$ff14  NR14
     bool initialize = data & 0x80;
     counter = data & 0x40;
     frequency = ((data & 7) << 8) | (frequency & 0x00ff);
 
     if(initialize) {
-      length = initial_length;
+      enable = dac_enable();
       envelope_period = envelope_frequency;
       volume = envelope_volume;
       frequency_shadow = frequency;
       sweep_period = sweep_frequency;
-      enable = sweep_period || sweep_shift;
-      if(sweep_shift) sweep();
+      sweep_enable = sweep_period || sweep_shift;
+      sweep_negate = false;
+      if(sweep_shift) sweep(0);
+      if(length == 0) length = 64;
     }
   }
 
@@ -100,11 +106,13 @@ void APU::Square1::write(unsigned r, uint8 data) {
 }
 
 void APU::Square1::power() {
+  enable = 0;
+
   sweep_frequency = 0;
   sweep_direction = 0;
   sweep_shift = 0;
+  sweep_negate = 0;
   duty = 0;
-  initial_length = 0;
   length = 0;
   envelope_volume = 0;
   envelope_direction = 0;
@@ -119,16 +127,18 @@ void APU::Square1::power() {
   envelope_period = 0;
   sweep_period = 0;
   frequency_shadow = 0;
-  enable = 0;
+  sweep_enable = 0;
   volume = 0;
 }
 
 void APU::Square1::serialize(serializer &s) {
+  s.integer(enable);
+
   s.integer(sweep_frequency);
   s.integer(sweep_direction);
   s.integer(sweep_shift);
+  s.integer(sweep_negate);
   s.integer(duty);
-  s.integer(initial_length);
   s.integer(length);
   s.integer(envelope_volume);
   s.integer(envelope_direction);
@@ -143,7 +153,7 @@ void APU::Square1::serialize(serializer &s) {
   s.integer(envelope_period);
   s.integer(sweep_period);
   s.integer(frequency_shadow);
-  s.integer(enable);
+  s.integer(sweep_enable);
   s.integer(volume);
 }
 

bsnes/gameboy/apu/square1/square1.hpp

@@ -1,28 +1,32 @@
 struct Square1 {
-  unsigned sweep_frequency;
-  unsigned sweep_direction;
-  unsigned sweep_shift;
-  unsigned duty;
-  unsigned initial_length;
+  bool enable;
+
+  uint3 sweep_frequency;
+  bool sweep_direction;
+  uint3 sweep_shift;
+  bool sweep_negate;
+  uint2 duty;
   unsigned length;
-  unsigned envelope_volume;
-  unsigned envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
-  unsigned counter;
+  uint4 envelope_volume;
+  bool envelope_direction;
+  uint3 envelope_frequency;
+  uint11 frequency;
+  bool counter;
 
   int16 output;
   bool duty_output;
-  unsigned phase;
+  uint3 phase;
   unsigned period;
-  unsigned envelope_period;
-  unsigned sweep_period;
+  uint3 envelope_period;
+  uint3 sweep_period;
   signed frequency_shadow;
-  bool enable;
-  unsigned volume;
+  bool sweep_enable;
+  uint4 volume;
+
+  bool dac_enable();
 
   void run();
-  void sweep();
+  void sweep(bool update);
   void clock_length();
   void clock_sweep();
   void clock_envelope();

bsnes/gameboy/apu/square2/square2.cpp

@@ -1,9 +1,13 @@
 #ifdef APU_CPP
 
+bool APU::Square2::dac_enable() {
+  return (envelope_volume || envelope_direction);
+}
+
 void APU::Square2::run() {
   if(period && --period == 0) {
     period = 4 * (2048 - frequency);
-    phase = (phase + 1) & 7;
+    phase++;
     switch(duty) {
       case 0: duty_output = (phase == 6); break;  //______-_
       case 1: duty_output = (phase >= 6); break;  //______--
@@ -12,18 +16,20 @@ void APU::Square2::run() {
     }
   }
 
-  uint4 sample = (duty_output ? volume : 0);
-  if(counter && length == 0) sample = 0;
+  uint4 sample = (duty_output ? volume : (uint4)0);
+  if(enable == false) sample = 0;
 
-  output = (sample * 4369) - 32768;
+  output = sample;
 }
 
 void APU::Square2::clock_length() {
-  if(counter && length) length--;
+  if(counter && length) {
+    if(--length == 0) enable = false;
+  }
 }
 
 void APU::Square2::clock_envelope() {
-  if(envelope_period && --envelope_period == 0) {
+  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++;
@@ -31,31 +37,32 @@ void APU::Square2::clock_envelope() {
 }
 
 void APU::Square2::write(unsigned r, uint8 data) {
-  if(r == 1) {
+  if(r == 1) {  //$ff16  NR21
     duty = data >> 6;
-    initial_length = 64 - (data & 0x3f);
-    length = initial_length;
+    length = 64 - (data & 0x3f);
   }
 
-  if(r == 2) {
+  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) {
+  if(r == 3) {  //$ff18  NR23
     frequency = (frequency & 0x0700) | data;
   }
 
-  if(r == 4) {
+  if(r == 4) {  //$ff19  NR24
     bool initialize = data & 0x80;
     counter = data & 0x40;
     frequency = ((data & 7) << 8) | (frequency & 0x00ff);
 
     if(initialize) {
-      length = initial_length;
+      enable = dac_enable();
       envelope_period = envelope_frequency;
       volume = envelope_volume;
+      if(length == 0) length = 64;
     }
   }
 
@@ -63,8 +70,9 @@ void APU::Square2::write(unsigned r, uint8 data) {
 }
 
 void APU::Square2::power() {
+  enable = 0;
+
   duty = 0;
-  initial_length = 0;
   length = 0;
   envelope_volume = 0;
   envelope_direction = 0;
@@ -81,8 +89,9 @@ void APU::Square2::power() {
 }
 
 void APU::Square2::serialize(serializer &s) {
+  s.integer(enable);
+
   s.integer(duty);
-  s.integer(initial_length);
   s.integer(length);
   s.integer(envelope_volume);
   s.integer(envelope_direction);

bsnes/gameboy/apu/square2/square2.hpp

@@ -1,19 +1,22 @@
 struct Square2 {
-  unsigned duty;
-  unsigned initial_length;
+  bool enable;
+
+  uint2 duty;
   unsigned length;
-  unsigned envelope_volume;
-  unsigned envelope_direction;
-  unsigned envelope_frequency;
-  unsigned frequency;
-  unsigned counter;
+  uint4 envelope_volume;
+  bool envelope_direction;
+  uint3 envelope_frequency;
+  uint11 frequency;
+  bool counter;
 
   int16 output;
   bool duty_output;
-  unsigned phase;
+  uint3 phase;
   unsigned period;
-  unsigned envelope_period;
-  unsigned volume;
+  uint3 envelope_period;
+  uint4 volume;
+
+  bool dac_enable();
 
   void run();
   void clock_length();

bsnes/gameboy/apu/wave/wave.cpp

@@ -3,56 +3,53 @@
 void APU::Wave::run() {
   if(period && --period == 0) {
     period = 2 * (2048 - frequency);
-    pattern_offset = (pattern_offset + 1) & 31;
-    pattern_sample = pattern[pattern_offset];
+    pattern_sample = pattern[++pattern_offset];
   }
 
-  uint4 sample = pattern_sample;
-  if(counter && length == 0) sample = 0;
+  uint4 sample = pattern_sample >> volume_shift;
   if(enable == false) sample = 0;
 
-  output = (sample * 4369) - 32768;
-  output >>= volume;
+  output = sample;
 }
 
 void APU::Wave::clock_length() {
-  if(counter && length) length--;
+  if(counter && length) {
+    if(--length == 0) enable = false;
+  }
 }
 
 void APU::Wave::write(unsigned r, uint8 data) {
-  if(r == 0) {
+  if(r == 0) {  //$ff1a  NR30
     dac_enable = data & 0x80;
-
     if(dac_enable == false) enable = false;
   }
 
-  if(r == 1) {
-    initial_length = 256 - data;
-    length = initial_length;
+  if(r == 1) {  //$ff1b  NR31
+    length = 256 - data;
   }
 
-  if(r == 2) {
+  if(r == 2) {  //$ff1c  NR32
     switch((data >> 5) & 3) {
-      case 0: volume = 16; break;  //  0%
-      case 1: volume =  0; break;  //100%
-      case 2: volume =  1; break;  // 50%
-      case 3: volume =  2; break;  // 25%
+      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) {
+  if(r == 3) {  //$ff1d  NR33
     frequency = (frequency & 0x0700) | data;
   }
 
-  if(r == 4) {
+  if(r == 4) {  //$ff1e  NR34
     bool initialize = data & 0x80;
     counter = data & 0x40;
     frequency = ((data & 7) << 8) | (frequency & 0x00ff);
 
-    if(initialize && dac_enable) {
-      enable = true;
+    if(initialize) {
+      enable = dac_enable;
       pattern_offset = 0;
-      length = initial_length;
+      if(length == 0) length = 256;
     }
   }
 
@@ -66,17 +63,17 @@ void APU::Wave::write_pattern(unsigned p, uint8 data) {
 }
 
 void APU::Wave::power() {
+  enable = 0;
+
   dac_enable = 0;
-  volume = 0;
+  volume_shift = 0;
   frequency = 0;
   counter = 0;
 
   random_lfsr r;
-  foreach(n, pattern) n = r() & 15;
+  for(auto &n : pattern) n = r() & 15;
 
   output = 0;
-  enable = 0;
-  initial_length = 0;
   length = 0;
   period = 0;
   pattern_offset = 0;
@@ -84,15 +81,15 @@ void APU::Wave::power() {
 }
 
 void APU::Wave::serialize(serializer &s) {
+  s.integer(enable);
+
   s.integer(dac_enable);
-  s.integer(volume);
+  s.integer(volume_shift);
   s.integer(frequency);
   s.integer(counter);
   s.array(pattern);
 
   s.integer(output);
-  s.integer(enable);
-  s.integer(initial_length);
   s.integer(length);
   s.integer(period);
   s.integer(pattern_offset);

bsnes/gameboy/apu/wave/wave.hpp

@@ -1,17 +1,17 @@
 struct Wave {
+  bool enable;
+
   bool dac_enable;
-  unsigned volume;
-  unsigned frequency;
+  unsigned volume_shift;
+  uint11 frequency;
   bool counter;
   uint8 pattern[32];
 
   int16 output;
-  bool enable;
-  unsigned initial_length;
   unsigned length;
   unsigned period;
-  unsigned pattern_offset;
-  unsigned pattern_sample;
+  uint5 pattern_offset;
+  uint4 pattern_sample;
 
   void run();
   void clock_length();

bsnes/gameboy/cartridge/cartridge.cpp

@@ -16,7 +16,7 @@ namespace GameBoy {
 #include "serialization.cpp"
 Cartridge cartridge;
 
-void Cartridge::load(const string &xml, const uint8_t *data, unsigned size) {
+void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
   if(size == 0) size = 32768;
   romdata = allocate<uint8>(romsize = size, 0xff);
   if(data) memcpy(romdata, data, size);
@@ -33,42 +33,24 @@ void Cartridge::load(const string &xml, const uint8_t *data, unsigned size) {
   info.romsize = 0;
   info.ramsize = 0;
 
-  xml_element document = xml_parse(xml);
-  foreach(head, document.element) {
-    if(head.name == "cartridge") {
-      foreach(attr, head.attribute) {
-        if(attr.name == "mapper") {
-          if(attr.content == "none")  info.mapper = Mapper::MBC0;
-          if(attr.content == "MBC1")  info.mapper = Mapper::MBC1;
-          if(attr.content == "MBC2")  info.mapper = Mapper::MBC2;
-          if(attr.content == "MBC3")  info.mapper = Mapper::MBC3;
-          if(attr.content == "MBC5")  info.mapper = Mapper::MBC5;
-          if(attr.content == "MMM01") info.mapper = Mapper::MMM01;
-          if(attr.content == "HuC1")  info.mapper = Mapper::HuC1;
-          if(attr.content == "HuC3")  info.mapper = Mapper::HuC3;
-        }
+  BML::Document document(markup);
 
-        if(attr.name == "rtc") info.rtc = (attr.content == "true" ? true : false);
-        if(attr.name == "rumble") info.rumble = (attr.content == "true" ? true : false);
-      }
+  auto &mapperid = document["cartridge"]["mapper"].value;
+  if(mapperid == "none" ) info.mapper = Mapper::MBC0;
+  if(mapperid == "MBC1" ) info.mapper = Mapper::MBC1;
+  if(mapperid == "MBC2" ) info.mapper = Mapper::MBC2;
+  if(mapperid == "MBC3" ) info.mapper = Mapper::MBC3;
+  if(mapperid == "MBC5" ) info.mapper = Mapper::MBC5;
+  if(mapperid == "MMM01") info.mapper = Mapper::MMM01;
+  if(mapperid == "HuC1" ) info.mapper = Mapper::HuC1;
+  if(mapperid == "HuC3" ) info.mapper = Mapper::HuC3;
 
-      foreach(elem, head.element) {
-        if(elem.name == "rom") {
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.romsize = hex(attr.content);
-          }
-        }
+  info.rtc = document["cartridge"]["rtc"].exists();
+  info.rumble = document["cartridge"]["rumble"].exists();
 
-        if(elem.name == "ram") {
-          info.ram = true;
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.ramsize = hex(attr.content);
-            if(attr.name == "battery") info.battery = (attr.content == "true" ? true : false);
-          }
-        }
-      }
-    }
-  }
+  info.romsize = hex(document["cartridge"]["rom"]["size"].value);
+  info.ramsize = hex(document["cartridge"]["ram"]["size"].value);
+  info.battery = document["cartridge"]["ram"]["non-volatile"].exists();
 
   switch(info.mapper) { default:
     case Mapper::MBC0:  mapper = &mbc0;  break;
@@ -83,7 +65,9 @@ void Cartridge::load(const string &xml, const uint8_t *data, unsigned size) {
 
   ramdata = new uint8_t[ramsize = info.ramsize]();
   system.load();
+
   loaded = true;
+  sha256 = nall::sha256(romdata, romsize);
 }
 
 void Cartridge::unload() {

bsnes/gameboy/cartridge/cartridge.hpp

@@ -34,6 +34,7 @@ struct Cartridge : MMIO, property<Cartridge> {
   } info;
 
   readonly<bool> loaded;
+  readonly<string> sha256;
 
   uint8_t *romdata;
   unsigned romsize;
@@ -44,7 +45,7 @@ struct Cartridge : MMIO, property<Cartridge> {
   MMIO *mapper;
   bool bootrom_enable;
 
-  void load(const string &xml, const uint8_t *data, unsigned size);
+  void load(const string &markup, const uint8_t *data, unsigned size);
   void unload();
 
   uint8 rom_read(unsigned addr);

bsnes/gameboy/cheat/cheat.cpp

@@ -0,0 +1,91 @@
+#include <gameboy/gameboy.hpp>
+
+namespace GameBoy {
+
+Cheat cheat;
+
+bool Cheat::decode(const string &code_, unsigned &addr, unsigned &data, unsigned &comp) {
+  static bool initialize = false;
+  static uint8 mapProActionReplay[256], mapGameGenie[256];
+
+  if(initialize == false) {
+    initialize = true;
+
+    for(auto &n : mapProActionReplay) n = ~0;
+    mapProActionReplay['0'] =  0; mapProActionReplay['1'] =  1; mapProActionReplay['2'] =  2; mapProActionReplay['3'] =  3;
+    mapProActionReplay['4'] =  4; mapProActionReplay['5'] =  5; mapProActionReplay['6'] =  6; mapProActionReplay['7'] =  7;
+    mapProActionReplay['8'] =  8; mapProActionReplay['9'] =  9; mapProActionReplay['A'] = 10; mapProActionReplay['B'] = 11;
+    mapProActionReplay['C'] = 12; mapProActionReplay['D'] = 13; mapProActionReplay['E'] = 14; mapProActionReplay['F'] = 15;
+
+    for(auto &n : mapGameGenie) n = ~0;
+    mapGameGenie['0'] =  0; mapGameGenie['1'] =  1; mapGameGenie['2'] =  2; mapGameGenie['3'] =  3;
+    mapGameGenie['4'] =  4; mapGameGenie['5'] =  5; mapGameGenie['6'] =  6; mapGameGenie['7'] =  7;
+    mapGameGenie['8'] =  8; mapGameGenie['9'] =  9; mapGameGenie['A'] = 10; mapGameGenie['B'] = 11;
+    mapGameGenie['C'] = 12; mapGameGenie['D'] = 13; mapGameGenie['E'] = 14; mapGameGenie['F'] = 15;
+  }
+
+  string code = code_;
+  code.upper();
+  unsigned length = code.length(), bits = 0;
+
+  if(code.wildcard("????:??")) {
+    code = { substr(code, 0, 4), substr(code, 5, 2) };
+    for(unsigned n = 0; n < 6; n++) if(mapProActionReplay[code[n]] > 15) return false;
+    bits = hex(code);
+    addr = (bits >> 8) & 0xffff;
+    data = (bits >> 0) & 0xff;
+    comp = ~0;
+    return true;
+  }
+
+  if(code.wildcard("????:??:??")) {
+    code = { substr(code, 0, 4), substr(code, 5, 2), substr(code, 8, 2) };
+    for(unsigned n = 0; n < 8; n++) if(mapProActionReplay[code[n]] > 15) return false;
+    bits = hex(code);
+    addr = (bits >> 16) & 0xffff;
+    data = (bits >>  8) & 0xff;
+    comp = (bits >>  0) & 0xff;
+    return true;
+  }
+
+  if(code.wildcard("???" "-" "???")) {
+    code = { substr(code, 0, 3), substr(code, 4, 3) };
+    for(unsigned n = 0; n < 6; n++) if(mapGameGenie[code[n]] > 15) return false;
+    for(unsigned n = 0; n < 6; n++) bits |= mapGameGenie[code[n]] << (20 - n * 4);
+
+    addr = (bits >>  0) & 0xffff;
+    data = (bits >> 16) & 0xff;
+    comp = ~0;
+
+    addr = (((addr >> 4) | (addr << 12)) & 0xffff) ^ 0xf000;
+
+    return true;
+  }
+
+  if(code.wildcard("???" "-" "???" "-" "???")) {
+    code = { substr(code, 0, 3), substr(code, 4, 3), substr(code, 8, 1), substr(code, 10, 1) };
+    for(unsigned n = 0; n < 8; n++) if(mapGameGenie[code[n]] > 15) return false;
+    for(unsigned n = 0; n < 8; n++) bits |= mapGameGenie[code[n]] << (28 - n * 4);
+
+    addr = (bits >>  8) & 0xffff;
+    data = (bits >> 24) & 0xff;
+    comp = (bits >>  0) & 0xff;
+
+    addr = (((addr >> 4) | (addr << 12)) & 0xffff) ^ 0xf000;
+    comp = (((comp >> 2) | (comp << 6)) & 0xff) ^ 0xba;
+
+    return true;
+  }
+
+  return false;
+}
+
+void Cheat::synchronize() {
+  for(auto &n : override) n = false;
+
+  for(unsigned n = 0; n < size(); n++) {
+    override[operator[](n).addr] = true;
+  }
+}
+
+}

bsnes/gameboy/cheat/cheat.hpp

@@ -0,0 +1,14 @@
+struct CheatCode {
+  unsigned addr;
+  unsigned data;
+  unsigned comp;
+};
+
+struct Cheat : public linear_vector<CheatCode> {
+  static bool decode(const string &code, unsigned &addr, unsigned &data, unsigned &comp);
+
+  void synchronize();
+  bool override[65536];
+};
+
+extern Cheat cheat;

bsnes/gameboy/cpu/mmio/mmio.cpp

@@ -3,15 +3,15 @@
 void CPU::mmio_joyp_poll() {
   unsigned button = 0, dpad = 0;
 
-  button |= system.interface->input_poll((unsigned)Input::Start) << 3;
-  button |= system.interface->input_poll((unsigned)Input::Select) << 2;
-  button |= system.interface->input_poll((unsigned)Input::B) << 1;
-  button |= system.interface->input_poll((unsigned)Input::A) << 0;
+  button |= interface->inputPoll((unsigned)Input::Start) << 3;
+  button |= interface->inputPoll((unsigned)Input::Select) << 2;
+  button |= interface->inputPoll((unsigned)Input::B) << 1;
+  button |= interface->inputPoll((unsigned)Input::A) << 0;
 
-  dpad |= system.interface->input_poll((unsigned)Input::Down) << 3;
-  dpad |= system.interface->input_poll((unsigned)Input::Up) << 2;
-  dpad |= system.interface->input_poll((unsigned)Input::Left) << 1;
-  dpad |= system.interface->input_poll((unsigned)Input::Right) << 0;
+  dpad |= interface->inputPoll((unsigned)Input::Down) << 3;
+  dpad |= interface->inputPoll((unsigned)Input::Up) << 2;
+  dpad |= interface->inputPoll((unsigned)Input::Left) << 1;
+  dpad |= interface->inputPoll((unsigned)Input::Right) << 0;
 
   status.joyp = 0x0f;
   if(status.p15 == 1 && status.p14 == 1) status.joyp -= status.mlt_req;
@@ -84,7 +84,7 @@ void CPU::mmio_write(uint16 addr, uint8 data) {
   if(addr == 0xff00) {  //JOYP
     status.p15 = data & 0x20;
     status.p14 = data & 0x10;
-    system.interface->joyp_write(status.p15, status.p14);
+    interface->joypWrite(status.p15, status.p14);
     mmio_joyp_poll();
     return;
   }

bsnes/gameboy/gameboy.hpp

@@ -1,18 +1,22 @@
-//bgameboy
-//author: byuu
-//project started: 2010-12-27
+#ifndef GAMEBOY_HPP
+#define GAMEBOY_HPP
 
 namespace GameBoy {
   namespace Info {
     static const char Name[] = "bgameboy";
-    static const char Version[] = "000.21";
-    static unsigned SerializerVersion = 2;
+    static const unsigned SerializerVersion = 2;
   }
 }
 
+/*
+  bgameboy - Game Boy emulator
+  author: byuu
+  license: GPLv3
+  project started: 2010-12-27
+*/
+
 #include <libco/libco.h>
 
-#include <nall/foreach.hpp>
 #include <nall/platform.hpp>
 #include <nall/property.hpp>
 #include <nall/random.hpp>
@@ -83,7 +87,7 @@ namespace GameBoy {
       clock = 0;
     }
 
-    inline Processor() : thread(0) {}
+    inline Processor() : thread(nullptr) {}
   };
 
   #include <gameboy/memory/memory.hpp>
@@ -93,4 +97,7 @@ namespace GameBoy {
   #include <gameboy/cpu/cpu.hpp>
   #include <gameboy/apu/apu.hpp>
   #include <gameboy/lcd/lcd.hpp>
+  #include <gameboy/cheat/cheat.hpp>
 };
+
+#endif

bsnes/gameboy/interface/interface.cpp

@@ -0,0 +1,89 @@
+#include <gameboy/gameboy.hpp>
+
+namespace GameBoy {
+
+Interface *interface = 0;
+
+void Interface::lcdScanline() {
+}
+
+void Interface::joypWrite(bool p15, bool p14) {
+}
+
+void Interface::videoRefresh(const uint8_t *data) {
+}
+
+void Interface::audioSample(int16_t center, int16_t left, int16_t right) {
+}
+
+bool Interface::inputPoll(unsigned id) {
+  return false;
+}
+
+void Interface::initialize(Interface *derived_interface) {
+  interface = derived_interface;
+  system.init();
+}
+
+bool Interface::cartridgeLoaded() {
+  return cartridge.loaded();
+}
+
+void Interface::loadCartridge(const string &markup, const uint8_t *data, unsigned size) {
+  cartridge.load(markup, data, size);
+  system.power();
+}
+
+void Interface::unloadCartridge() {
+  cartridge.unload();
+}
+
+unsigned Interface::memorySize(Memory memory) {
+  if(memory == Memory::RAM) return cartridge.ramsize;
+  return 0u;
+}
+
+uint8_t* Interface::memoryData(Memory memory) {
+  if(memory == Memory::RAM) return cartridge.ramdata;
+  return 0u;
+}
+
+void Interface::power() {
+  system.power();
+}
+
+void Interface::run() {
+  do {
+    system.run();
+  } while(scheduler.exit_reason() != Scheduler::ExitReason::FrameEvent);
+}
+
+serializer Interface::serialize() {
+  system.runtosave();
+  return system.serialize();
+}
+
+bool Interface::unserialize(serializer &s) {
+  return system.unserialize(s);
+}
+
+void Interface::setCheats(const lstring &list) {
+  cheat.reset();
+  for(auto &code : list) {
+    lstring codelist;
+    codelist.split("+", code);
+    for(auto &part : codelist) {
+      unsigned addr, data, comp;
+      if(Cheat::decode(part, addr, data, comp)) {
+        cheat.append({ addr, data, comp });
+      }
+    }
+  }
+  cheat.synchronize();
+}
+
+void Interface::message(const string &text) {
+  print(text, "\n");
+}
+
+}

bsnes/gameboy/interface/interface.hpp

@@ -1,12 +1,34 @@
 class Interface {
 public:
-  virtual void lcd_scanline() {}
-  virtual void joyp_write(bool p15, bool p14) {}
+  virtual void lcdScanline();
+  virtual void joypWrite(bool p15, bool p14);
 
-  virtual void video_refresh(const uint8_t *data) {}
-  virtual void audio_sample(int16_t center, int16_t left, int16_t right) {}
-  virtual void input_poll() {}
-  virtual bool input_poll(unsigned id) {}
+  virtual void videoRefresh(const uint8_t *data);
+  virtual void audioSample(int16_t center, int16_t left, int16_t right);
+  virtual bool inputPoll(unsigned id);
 
-  virtual void message(const string &text) { print(text, "\n"); }
+  virtual void initialize(Interface*);
+
+  virtual bool cartridgeLoaded();
+  virtual void loadCartridge(const string &markup, const uint8_t *data, unsigned size);
+  virtual void unloadCartridge();
+
+  enum class Memory : unsigned {
+    RAM,
+  };
+
+  virtual unsigned memorySize(Memory);
+  virtual uint8_t* memoryData(Memory);
+
+  virtual void power();
+  virtual void run();
+
+  virtual serializer serialize();
+  virtual bool unserialize(serializer&);
+
+  virtual void setCheats(const lstring &list = lstring{});
+
+  virtual void message(const string &text);
 };
+
+extern Interface *interface;

bsnes/gameboy/lcd/lcd.cpp

@@ -7,6 +7,8 @@ namespace GameBoy {
 #include "serialization.cpp"
 LCD lcd;
 
+static unsigned linectr;
+
 void LCD::Main() {
   lcd.main();
 }
@@ -55,11 +57,11 @@ void LCD::scanline() {
 }
 
 void LCD::frame() {
-  system.interface->video_refresh(screen);
-  system.interface->input_poll();
+  interface->videoRefresh(screen);
   cpu.mmio_joyp_poll();
 
   status.ly = 0;
+  status.wyc = 0;
   scheduler.exit(Scheduler::ExitReason::FrameEvent);
 }
 
@@ -76,8 +78,8 @@ void LCD::render() {
   }
 
   uint8_t *output = screen + status.ly * 160;
-  for(unsigned n = 0; n < 160; n++) output[n] = (3 - line[n]) * 0x55;
-  system.interface->lcd_scanline();
+  for(unsigned n = 0; n < 160; n++) output[n] = line[n];
+  interface->lcdScanline();
 }
 
 uint16 LCD::read_tile(bool select, unsigned x, unsigned y) {
@@ -112,8 +114,9 @@ void LCD::render_bg() {
 }
 
 void LCD::render_window() {
-  if(status.ly - status.wy >= 144U) return;
-  unsigned iy = status.ly - status.wy;
+  if(status.ly - status.wy >= 144u) return;
+  if(status.wx >= 167u) return;
+  unsigned iy = status.wyc++;
   unsigned ix = (7 - status.wx) & 255, tx = ix & 7;
   unsigned data = read_tile(status.window_tilemap_select, ix, iy);
 
@@ -215,6 +218,7 @@ void LCD::power() {
   for(unsigned n = 0; n < 160 * 144; n++) screen[n] = 0x00;
 
   status.lx = 0;
+  status.wyc = 0;
 
   status.display_enable = 0;
   status.window_tilemap_select = 0;

bsnes/gameboy/lcd/lcd.hpp

@@ -3,6 +3,7 @@ struct LCD : Processor, MMIO {
 
   struct Status {
     unsigned lx;
+    unsigned wyc;
 
     //$ff40  LCDC
     bool display_enable;

bsnes/gameboy/lcd/serialization.cpp

@@ -2,6 +2,7 @@
 
 void LCD::serialize(serializer &s) {
   s.integer(status.lx);
+  s.integer(status.wyc);
 
   s.integer(status.display_enable);
   s.integer(status.window_tilemap_select);

bsnes/gameboy/memory/memory.cpp

@@ -42,7 +42,20 @@ Memory::~Memory() {
 //
 
 uint8 Bus::read(uint16 addr) {
-  return mmio[addr]->mmio_read(addr);
+  uint8 data = mmio[addr]->mmio_read(addr);
+
+  if(cheat.override[addr]) {
+    for(unsigned n = 0; n < cheat.size(); n++) {
+      if(cheat[n].addr == addr) {
+        if(cheat[n].comp > 255 || cheat[n].comp == data) {
+          data = cheat[n].data;
+          break;
+        }
+      }
+    }
+  }
+
+  return data;
 }
 
 void Bus::write(uint16 addr, uint8 data) {

bsnes/gameboy/system/system.cpp

@@ -33,8 +33,8 @@ void System::runthreadtosave() {
   }
 }
 
-void System::init(Interface *interface_) {
-  interface = interface_;
+void System::init() {
+  assert(interface != 0);
 }
 
 void System::load() {

bsnes/gameboy/system/system.hpp

@@ -14,11 +14,10 @@ struct System {
   void runtosave();
   void runthreadtosave();
 
-  void init(Interface*);
+  void init();
   void load();
   void power();
 
-  Interface *interface;
   unsigned clocks_executed;
 
   //serialization.cpp

bsnes/nall/Makefile

@@ -32,9 +32,9 @@ ifeq ($(compiler),)
   ifeq ($(platform),win)
     compiler := gcc
   else ifeq ($(platform),osx)
-    compiler := gcc-mp-4.5
+    compiler := gcc-mp-4.6
   else
-    compiler := gcc-4.5
+    compiler := gcc-4.6
   endif
 endif
 

bsnes/nall/array.hpp

@@ -2,13 +2,12 @@
 #define NALL_ARRAY_HPP
 
 #include <stdlib.h>
+#include <algorithm>
 #include <initializer_list>
 #include <type_traits>
 #include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
-#include <nall/concept.hpp>
-#include <nall/foreach.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -26,7 +25,7 @@ namespace nall {
 
     void reset() {
       if(pool) free(pool);
-      pool = 0;
+      pool = nullptr;
       poolsize = 0;
       buffersize = 0;
     }
@@ -54,21 +53,14 @@ namespace nall {
       operator[](buffersize) = data;
     }
 
+    void append(const T data[], unsigned length) {
+      for(unsigned n = 0; n < length; n++) operator[](buffersize) = data[n];
+    }
+
     void remove() {
       if(size > 0) resize(size - 1);  //remove last element only
     }
 
-    template<typename U> void insert(unsigned index, const U list) {
-      unsigned listsize = container_size(list);
-      resize(buffersize + listsize);
-      memmove(pool + index + listsize, pool + index, (buffersize - index) * sizeof(T));
-      foreach(item, list) pool[index++] = item;
-    }
-
-    void insert(unsigned index, const T item) {
-      insert(index, array<T>{ item });
-    }
-
     void remove(unsigned index, unsigned count = 1) {
       for(unsigned i = index; count + i < buffersize; i++) {
         pool[i] = pool[count + i];
@@ -86,10 +78,10 @@ namespace nall {
       memset(pool, 0, buffersize * sizeof(T));
     }
 
-    array() : pool(0), poolsize(0), buffersize(0) {
+    array() : pool(nullptr), poolsize(0), buffersize(0) {
     }
 
-    array(std::initializer_list<T> list) : pool(0), poolsize(0), buffersize(0) {
+    array(std::initializer_list<T> list) : pool(nullptr), poolsize(0), buffersize(0) {
       for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
     }
 
@@ -107,7 +99,7 @@ namespace nall {
       return *this;
     }
 
-    array(const array &source) : pool(0), poolsize(0), buffersize(0) {
+    array(const array &source) : pool(nullptr), poolsize(0), buffersize(0) {
       operator=(source);
     }
 
@@ -117,12 +109,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       buffersize = source.buffersize;
-      source.pool = 0;
+      source.pool = nullptr;
       source.reset();
       return *this;
     }
 
-    array(array &&source) : pool(0), poolsize(0), buffersize(0) {
+    array(array &&source) : pool(nullptr), poolsize(0), buffersize(0) {
       operator=(std::move(source));
     }
 
@@ -144,8 +136,6 @@ namespace nall {
     const T* begin() const { return &pool[0]; }
     const T* end() const { return &pool[buffersize]; }
   };
-
-  template<typename T> struct has_size<array<T>> { enum { value = true }; };
 }
 
 #endif

bsnes/nall/atoi.hpp

@@ -0,0 +1,88 @@
+#ifndef NALL_ATOI_HPP
+#define NALL_ATOI_HPP
+
+namespace nall {
+
+//note: this header is intended to form the base for user-defined literals;
+//once they are supported by GCC. eg:
+//unsigned operator "" b(const char *s) { return binary(s); }
+//-> signed data = 1001b;
+//(0b1001 is nicer, but is not part of the C++ standard)
+
+constexpr inline uintmax_t binary_(const char *s, uintmax_t sum = 0) {
+  return (
+    *s == '0' || *s == '1' ? binary_(s + 1, (sum << 1) | *s - '0') :
+    sum
+  );
+}
+
+constexpr inline uintmax_t octal_(const char *s, uintmax_t sum = 0) {
+  return (
+    *s >= '0' && *s <= '7' ? octal_(s + 1, (sum << 3) | *s - '0') :
+    sum
+  );
+}
+
+constexpr inline uintmax_t decimal_(const char *s, uintmax_t sum = 0) {
+  return (
+    *s >= '0' && *s <= '9' ? decimal_(s + 1, (sum * 10) + *s - '0') :
+    sum
+  );
+}
+
+constexpr inline uintmax_t hex_(const char *s, uintmax_t sum = 0) {
+  return (
+    *s >= 'A' && *s <= 'F' ? hex_(s + 1, (sum << 4) | *s - 'A' + 10) :
+    *s >= 'a' && *s <= 'f' ? hex_(s + 1, (sum << 4) | *s - 'a' + 10) :
+    *s >= '0' && *s <= '9' ? hex_(s + 1, (sum << 4) | *s - '0') :
+    sum
+  );
+}
+
+//
+
+constexpr inline uintmax_t binary(const char *s) {
+  return (
+    *s == '0' && *(s + 1) == 'B' ? binary_(s + 2) :
+    *s == '0' && *(s + 1) == 'b' ? binary_(s + 2) :
+    *s == '%' ? binary_(s + 1) :
+    binary_(s)
+  );
+}
+
+constexpr inline uintmax_t octal(const char *s) {
+  return (
+    octal_(s)
+  );
+}
+
+constexpr inline intmax_t integer(const char *s) {
+  return (
+    *s == '+' ? +decimal_(s + 1) :
+    *s == '-' ? -decimal_(s + 1) :
+    decimal_(s)
+  );
+}
+
+constexpr inline uintmax_t decimal(const char *s) {
+  return (
+    decimal_(s)
+  );
+}
+
+constexpr inline uintmax_t hex(const char *s) {
+  return (
+    *s == '0' && *(s + 1) == 'X' ? hex_(s + 2) :
+    *s == '0' && *(s + 1) == 'x' ? hex_(s + 2) :
+    *s == '$' ? hex_(s + 1) :
+    hex_(s)
+  );
+}
+
+inline double fp(const char *s) {
+  return atof(s);
+}
+
+}
+
+#endif

bsnes/nall/base64.hpp

@@ -5,8 +5,7 @@
 #include <nall/stdint.hpp>
 
 namespace nall {
-  class base64 {
-  public:
+  struct base64 {
     static bool encode(char *&output, const uint8_t* input, unsigned inlength) {
       output = new char[inlength * 8 / 6 + 6]();
 

bsnes/nall/bit.hpp

@@ -2,39 +2,39 @@
 #define NALL_BIT_HPP
 
 namespace nall {
-  template<int bits> inline unsigned uclamp(const unsigned x) {
+  template<int bits> constexpr inline unsigned uclamp(const unsigned x) {
     enum { y = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
     return y + ((x - y) & -(x < y));  //min(x, y);
   }
 
-  template<int bits> inline unsigned uclip(const unsigned x) {
+  template<int bits> constexpr inline unsigned uclip(const unsigned x) {
     enum { m = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
     return (x & m);
   }
 
-  template<int bits> inline signed sclamp(const signed x) {
+  template<int bits> constexpr inline signed sclamp(const signed x) {
     enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
     return (x > m) ? m : (x < -b) ? -b : x;
   }
 
-  template<int bits> inline signed sclip(const signed x) {
+  template<int bits> constexpr inline signed sclip(const signed x) {
     enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
     return ((x & m) ^ b) - b;
   }
 
   namespace bit {
     //lowest(0b1110) == 0b0010
-    template<typename T> inline T lowest(const T x) {
+    template<typename T> constexpr inline T lowest(const T x) {
       return x & -x;
     }
 
     //clear_lowest(0b1110) == 0b1100
-    template<typename T> inline T clear_lowest(const T x) {
+    template<typename T> constexpr inline T clear_lowest(const T x) {
       return x & (x - 1);
     }
 
     //set_lowest(0b0101) == 0b0111
-    template<typename T> inline T set_lowest(const T x) {
+    template<typename T> constexpr inline T set_lowest(const T x) {
       return x | (x + 1);
     }
 

bsnes/nall/bps/delta.hpp

@@ -24,7 +24,7 @@ protected:
   struct Node {
     unsigned offset;
     Node *next;
-    inline Node() : offset(0), next(0) {}
+    inline Node() : offset(0), next(nullptr) {}
     inline ~Node() { if(next) delete next; }
   };
 

bsnes/nall/compositor.hpp

@@ -1,7 +1,7 @@
 #ifndef NALL_COMPOSITOR_HPP
 #define NALL_COMPOSITOR_HPP
 
-#include <nall/detect.hpp>
+#include <nall/intrinsics.hpp>
 
 namespace nall {
 
@@ -35,7 +35,7 @@ bool compositor::enable(bool status) {
   return true;
 }
 
-#elif defined(PLATFORM_WIN)
+#elif defined(PLATFORM_WINDOWS)
 
 bool compositor::enabled() {
   HMODULE module = GetModuleHandleW(L"dwmapi");

bsnes/nall/concept.hpp

@@ -1,34 +0,0 @@
-#ifndef NALL_CONCEPT_HPP
-#define NALL_CONCEPT_HPP
-
-#include <nall/static.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  //unsigned count() const;
-  template<typename T> struct has_count { enum { value = false }; };
-
-  //unsigned length() const;
-  template<typename T> struct has_length { enum { value = false }; };
-
-  //unsigned size() const;
-  template<typename T> struct has_size { enum { value = false }; };
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_count<T>>::type = 0) {
-    return object.count();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_length<T>>::type = 0) {
-    return object.length();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_size<T>>::type = 0) {
-    return object.size();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<std::is_array<T>>::type = 0) {
-    return sizeof(T) / sizeof(typename std::remove_extent<T>::type);
-  }
-}
-
-#endif

bsnes/nall/config.hpp

@@ -70,7 +70,7 @@ namespace nall {
       else list[n].type = unknown_t;
     }
 
-    virtual bool load(const char *filename) {
+    virtual bool load(const string &filename) {
       string data;
       if(data.readfile(filename) == true) {
         data.replace("\r", "");
@@ -100,7 +100,7 @@ namespace nall {
       }
     }
 
-    virtual bool save(const char *filename) const {
+    virtual bool save(const string &filename) const {
       file fp;
       if(fp.open(filename, file::mode::write)) {
         for(unsigned i = 0; i < list.size(); i++) {

bsnes/nall/detect.hpp

@@ -1,30 +0,0 @@
-#ifndef NALL_DETECT_HPP
-#define NALL_DETECT_HPP
-
-/* Compiler detection */
-
-#if defined(__GNUC__)
-  #define COMPILER_GCC
-#elif defined(_MSC_VER)
-  #define COMPILER_VISUALC
-#endif
-
-/* Platform detection */
-
-#if defined(_WIN32)
-  #define PLATFORM_WIN
-#elif defined(__APPLE__)
-  #define PLATFORM_OSX
-#elif defined(linux) || defined(__sun__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-  #define PLATFORM_X
-#endif
-
-/* Endian detection */
-
-#if defined(__i386__) || defined(__amd64__) || defined(_M_IX86) || defined(_M_AMD64)
-  #define ARCH_LSB
-#elif defined(__powerpc__) || defined(_M_PPC) || defined(__BIG_ENDIAN__)
-  #define ARCH_MSB
-#endif
-
-#endif

bsnes/nall/directory.hpp

@@ -1,11 +1,12 @@
 #ifndef NALL_DIRECTORY_HPP
 #define NALL_DIRECTORY_HPP
 
-#include <nall/foreach.hpp>
+#include <nall/intrinsics.hpp>
 #include <nall/sort.hpp>
 #include <nall/string.hpp>
+#include <nall/vector.hpp>
 
-#if defined(_WIN32)
+#if defined(PLATFORM_WINDOWS)
   #include <nall/windows/utf8.hpp>
 #else
   #include <dirent.h>
@@ -22,7 +23,7 @@ struct directory {
   static lstring contents(const string &pathname, const string &pattern = "*");
 };
 
-#if defined(_WIN32)
+#if defined(PLATFORM_WINDOWS)
   inline bool directory::exists(const string &pathname) {
     DWORD result = GetFileAttributes(utf16_t(pathname));
     if(result == INVALID_FILE_ATTRIBUTES) return false;
@@ -56,7 +57,7 @@ struct directory {
       FindClose(handle);
     }
     if(list.size() > 0) sort(&list[0], list.size());
-    foreach(name, list) name.append("/");  //must append after sorting
+    for(auto &name : list) name.append("/");  //must append after sorting
     return list;
   }
 
@@ -89,7 +90,7 @@ struct directory {
   inline lstring directory::contents(const string &pathname, const string &pattern) {
     lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
     lstring files = directory::files(pathname, pattern);
-    foreach(file, files) folders.append(file);
+    for(auto &file : files) folders.append(file);
     return folders;
   }
 #else
@@ -116,7 +117,7 @@ struct directory {
       closedir(dp);
     }
     if(list.size() > 0) sort(&list[0], list.size());
-    foreach(name, list) name.append("/");  //must append after sorting
+    for(auto &name : list) name.append("/");  //must append after sorting
     return list;
   }
 
@@ -142,7 +143,7 @@ struct directory {
   inline lstring directory::contents(const string &pathname, const string &pattern) {
     lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
     lstring files = directory::files(pathname, pattern);
-    foreach(file, files) folders.append(file);
+    for(auto &file : files) folders.append(file);
     return folders;
   }
 #endif

bsnes/nall/dl.hpp

@@ -3,14 +3,14 @@
 
 //dynamic linking support
 
-#include <nall/detect.hpp>
+#include <nall/intrinsics.hpp>
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 #include <nall/utility.hpp>
 
 #if defined(PLATFORM_X) || defined(PLATFORM_OSX)
   #include <dlfcn.h>
-#elif defined(PLATFORM_WIN)
+#elif defined(PLATFORM_WINDOWS)
   #include <windows.h>
   #include <nall/windows/utf8.hpp>
 #endif
@@ -81,7 +81,7 @@ namespace nall {
     dlclose((void*)handle);
     handle = 0;
   }
-  #elif defined(PLATFORM_WIN)
+  #elif defined(PLATFORM_WINDOWS)
   inline bool library::open(const char *name, const char *path) {
     if(handle) close();
     string filepath(path, *path && !strend(path, "/") && !strend(path, "\\") ? "\\" : "", name, ".dll");

bsnes/nall/dsp.hpp

@@ -1,6 +1,11 @@
 #ifndef NALL_DSP_HPP
 #define NALL_DSP_HPP
 
+#include <algorithm>
+#ifdef __SSE__
+  #include <xmmintrin.h>
+#endif
+
 #define NALL_DSP_INTERNAL_HPP
 #include <nall/dsp/core.hpp>
 #undef NALL_DSP_INTERNAL_HPP

bsnes/nall/dsp/buffer.hpp

@@ -1,35 +1,50 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
 struct Buffer {
-  double *sample[2];
+  double **sample;
   uint16_t rdoffset;
   uint16_t wroffset;
+  unsigned channels;
 
-  inline double& read(bool channel, signed offset = 0) {
+  void setChannels(unsigned channels) {
+    for(unsigned c = 0; c < this->channels; c++) {
+      if(sample[c]) delete[] sample[c];
+    }
+    if(sample) delete[] sample;
+
+    this->channels = channels;
+    if(channels == 0) return;
+
+    sample = new double*[channels];
+    for(unsigned c = 0; c < channels; c++) {
+      sample[c] = new double[65536]();
+    }
+  }
+
+  inline double& read(unsigned channel, signed offset = 0) {
     return sample[channel][(uint16_t)(rdoffset + offset)];
   }
 
-  inline double& write(bool channel, signed offset = 0) {
+  inline double& write(unsigned channel, signed offset = 0) {
     return sample[channel][(uint16_t)(wroffset + offset)];
   }
 
   inline void clear() {
-    for(unsigned n = 0; n < 65536; n++) {
-      sample[0][n] = 0;
-      sample[1][n] = 0;
+    for(unsigned c = 0; c < channels; c++) {
+      for(unsigned n = 0; n < 65536; n++) {
+        sample[c][n] = 0;
+      }
     }
     rdoffset = 0;
     wroffset = 0;
   }
 
   Buffer() {
-    sample[0] = new double[65536];
-    sample[1] = new double[65536];
+    channels = 0;
   }
 
   ~Buffer() {
-    delete[] sample[0];
-    delete[] sample[1];
+    setChannels(0);
   }
 };
 

bsnes/nall/dsp/core.hpp

@@ -5,59 +5,72 @@
 
 namespace nall {
 
+//precision: can be float, double or long double
+#define real float
+
+struct DSP;
+
+struct Resampler {
+  DSP &dsp;
+  real frequency;
+
+  virtual void setFrequency() = 0;
+  virtual void clear() = 0;
+  virtual void sample() = 0;
+  Resampler(DSP &dsp) : dsp(dsp) {}
+};
+
 struct DSP {
-  enum class Resampler : unsigned {
-    Point,
+  enum class ResampleEngine : unsigned {
+    Nearest,
     Linear,
     Cosine,
     Cubic,
     Hermite,
     Average,
+    Sinc,
   };
 
+  inline void setChannels(unsigned channels);
   inline void setPrecision(unsigned precision);
-  inline void setFrequency(double frequency);  //inputFrequency
-  inline void setVolume(double volume);
-  inline void setBalance(double balance);
+  inline void setFrequency(real frequency);  //inputFrequency
+  inline void setVolume(real volume);
+  inline void setBalance(real balance);
 
-  inline void setResampler(Resampler resampler);
-  inline void setResamplerFrequency(double frequency);  //outputFrequency
+  inline void setResampler(ResampleEngine resamplingEngine);
+  inline void setResamplerFrequency(real frequency);  //outputFrequency
 
-  inline void sample(signed lchannel, signed rchannel);
+  inline void sample(signed channel[]);
   inline bool pending();
-  inline void read(signed &lchannel, signed &rchannel);
+  inline void read(signed channel[]);
 
   inline void clear();
   inline DSP();
   inline ~DSP();
 
 protected:
+  friend class ResampleNearest;
+  friend class ResampleLinear;
+  friend class ResampleCosine;
+  friend class ResampleCubic;
+  friend class ResampleAverage;
+  friend class ResampleHermite;
+  friend class ResampleSinc;
+
   struct Settings {
+    unsigned channels;
     unsigned precision;
-    double frequency;
-    double volume;
-    double balance;
+    real frequency;
+    real volume;
+    real balance;
+
     //internal
-    double intensity;
+    real intensity;
+    real intensityInverse;
   } settings;
 
-  struct ResamplerSettings {
-    Resampler engine;
-    double frequency;
-    //internal
-    double fraction;
-    double step;
-  } resampler;
-
-  inline void resamplerRun();
-  inline void resamplerWrite(double lchannel, double rchannel);
-
-  inline void resamplePoint();
-  inline void resampleLinear();
-  inline void resampleCosine();
-  inline void resampleCubic();
-  inline void resampleHermite();
-  inline void resampleAverage();
+  Resampler *resampler;
+  inline void write(real channel[]);
 
   #include "buffer.hpp"
   Buffer buffer;
@@ -68,58 +81,52 @@ protected:
   inline signed clamp(const unsigned bits, const signed x);
 };
 
+#include "resample/nearest.hpp"
+#include "resample/linear.hpp"
+#include "resample/cosine.hpp"
+#include "resample/cubic.hpp"
+#include "resample/hermite.hpp"
+#include "resample/average.hpp"
+#include "resample/sinc.hpp"
 #include "settings.hpp"
 
-void DSP::sample(signed lchannel, signed rchannel) {
-  buffer.write(0) = (double)lchannel / settings.intensity;
-  buffer.write(1) = (double)rchannel / settings.intensity;
+void DSP::sample(signed channel[]) {
+  for(unsigned c = 0; c < settings.channels; c++) {
+    buffer.write(c) = (real)channel[c] * settings.intensityInverse;
+  }
   buffer.wroffset++;
-  resamplerRun();
+  resampler->sample();
 }
 
 bool DSP::pending() {
   return output.rdoffset != output.wroffset;
 }
 
-void DSP::read(signed &lchannel, signed &rchannel) {
+void DSP::read(signed channel[]) {
   adjustVolume();
   adjustBalance();
 
-  lchannel = clamp(settings.precision, output.read(0) * settings.intensity);
-  rchannel = clamp(settings.precision, output.read(1) * settings.intensity);
+  for(unsigned c = 0; c < settings.channels; c++) {
+    channel[c] = clamp(settings.precision, output.read(c) * settings.intensity);
+  }
   output.rdoffset++;
 }
 
-void DSP::resamplerRun() {
-  switch(resampler.engine) {
-  case Resampler::Point:   return resamplePoint();
-  case Resampler::Linear:  return resampleLinear();
-  case Resampler::Cosine:  return resampleCosine();
-  case Resampler::Cubic:   return resampleCubic();
-  case Resampler::Hermite: return resampleHermite();
-  case Resampler::Average: return resampleAverage();
+void DSP::write(real channel[]) {
+  for(unsigned c = 0; c < settings.channels; c++) {
+    output.write(c) = channel[c];
   }
-}
-
-void DSP::resamplerWrite(double lchannel, double rchannel) {
-  output.write(0) = lchannel;
-  output.write(1) = rchannel;
   output.wroffset++;
 }
 
-#include "resample/point.hpp"
-#include "resample/linear.hpp"
-#include "resample/cosine.hpp"
-#include "resample/cubic.hpp"
-#include "resample/hermite.hpp"
-#include "resample/average.hpp"
-
 void DSP::adjustVolume() {
-  output.read(0) *= settings.volume;
-  output.read(1) *= settings.volume;
+  for(unsigned c = 0; c < settings.channels; c++) {
+    output.read(c) *= settings.volume;
+  }
 }
 
 void DSP::adjustBalance() {
+  if(settings.channels != 2) return;  //TODO: support > 2 channels
   if(settings.balance < 0.0) output.read(1) *= 1.0 + settings.balance;
   if(settings.balance > 0.0) output.read(0) *= 1.0 - settings.balance;
 }
@@ -131,24 +138,30 @@ signed DSP::clamp(const unsigned bits, const signed x) {
 }
 
 void DSP::clear() {
-  resampler.fraction = 0.0;
   buffer.clear();
   output.clear();
+  resampler->clear();
 }
 
 DSP::DSP() {
+  setResampler(ResampleEngine::Hermite);
+  setResamplerFrequency(44100.0);
+
+  setChannels(2);
   setPrecision(16);
   setFrequency(44100.0);
   setVolume(1.0);
   setBalance(0.0);
-  setResampler(Resampler::Hermite);
-  setResamplerFrequency(44100.0);
+
   clear();
 }
 
 DSP::~DSP() {
+  if(resampler) delete resampler;
 }
 
+#undef real
+
 }
 
 #endif

bsnes/nall/dsp/resample/average.hpp

@@ -1,28 +1,72 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
-void DSP::resampleAverage() {
+struct ResampleAverage : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  inline void sampleLinear();
+  ResampleAverage(DSP &dsp) : Resampler(dsp) {}
+
+  real fraction;
+  real step;
+};
+
+void ResampleAverage::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
+
+void ResampleAverage::clear() {
+  fraction = 0.0;
+}
+
+void ResampleAverage::sample() {
   //can only average if input frequency >= output frequency
-  if(resampler.step < 1.0) return resampleHermite();
+  if(step < 1.0) return sampleLinear();
 
-  resampler.fraction += 1.0;
+  fraction += 1.0;
 
-  double scalar = 1.0;
-  if(resampler.fraction > resampler.step) scalar = 1.0 - (resampler.fraction - resampler.step);
+  real scalar = 1.0;
+  if(fraction > step) scalar = 1.0 - (fraction - step);
 
-  output.write(0) += buffer.read(0) * scalar;
-  output.write(1) += buffer.read(1) * scalar;
-
-  if(resampler.fraction >= resampler.step) {
-    output.write(0) /= resampler.step;
-    output.write(1) /= resampler.step;
-    output.wroffset++;
-
-    resampler.fraction -= resampler.step;
-    output.write(0) = buffer.read(0) * resampler.fraction;
-    output.write(1) = buffer.read(1) * resampler.fraction;
+  for(unsigned c = 0; c < dsp.settings.channels; c++) {
+    dsp.output.write(c) += dsp.buffer.read(c) * scalar;
   }
 
-  buffer.rdoffset++;
+  if(fraction >= step) {
+    for(unsigned c = 0; c < dsp.settings.channels; c++) {
+      dsp.output.write(c) /= step;
+    }
+    dsp.output.wroffset++;
+
+    fraction -= step;
+    for(unsigned c = 0; c < dsp.settings.channels; c++) {
+      dsp.output.write(c) = dsp.buffer.read(c) * fraction;
+    }
+  }
+
+  dsp.buffer.rdoffset++;
+}
+
+void ResampleAverage::sampleLinear() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -1);
+      real b = dsp.buffer.read(n, -0);
+
+      real mu = fraction;
+
+      channel[n] = a * (1.0 - mu) + b * mu;
+    }
+
+    dsp.write(channel);
+    fraction += step;
+  }
+
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
 }
 
 #endif

bsnes/nall/dsp/resample/cosine.hpp

@@ -1,25 +1,44 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
-void DSP::resampleCosine() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
+struct ResampleCosine : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  ResampleCosine(DSP &dsp) : Resampler(dsp) {}
 
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -1);
-      double b = buffer.read(n, -0);
+  real fraction;
+  real step;
+};
 
-      double mu = resampler.fraction;
+void ResampleCosine::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
+
+void ResampleCosine::clear() {
+  fraction = 0.0;
+}
+
+void ResampleCosine::sample() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -1);
+      real b = dsp.buffer.read(n, -0);
+
+      real mu = fraction;
       mu = (1.0 - cos(mu * 3.14159265)) / 2.0;
 
       channel[n] = a * (1.0 - mu) + b * mu;
     }
 
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
+    dsp.write(channel);
+    fraction += step;
   }
 
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
 }
 
 #endif

bsnes/nall/dsp/resample/cubic.hpp

@@ -1,31 +1,50 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
-void DSP::resampleCubic() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
+struct ResampleCubic : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  ResampleCubic(DSP &dsp) : Resampler(dsp) {}
 
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -3);
-      double b = buffer.read(n, -2);
-      double c = buffer.read(n, -1);
-      double d = buffer.read(n, -0);
+  real fraction;
+  real step;
+};
 
-      double mu = resampler.fraction;
+void ResampleCubic::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
 
-      double A = d - c - a + b;
-      double B = a - b - A;
-      double C = c - a;
-      double D = b;
+void ResampleCubic::clear() {
+  fraction = 0.0;
+}
+
+void ResampleCubic::sample() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -3);
+      real b = dsp.buffer.read(n, -2);
+      real c = dsp.buffer.read(n, -1);
+      real d = dsp.buffer.read(n, -0);
+
+      real mu = fraction;
+
+      real A = d - c - a + b;
+      real B = a - b - A;
+      real C = c - a;
+      real D = b;
 
       channel[n] = A * (mu * 3) + B * (mu * 2) + C * mu + D;
     }
 
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
+    dsp.write(channel);
+    fraction += step;
   }
 
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
 }
 
 #endif

bsnes/nall/dsp/resample/hermite.hpp

@@ -1,21 +1,40 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
-void DSP::resampleHermite() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
+struct ResampleHermite : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  ResampleHermite(DSP &dsp) : Resampler(dsp) {}
 
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -3);
-      double b = buffer.read(n, -2);
-      double c = buffer.read(n, -1);
-      double d = buffer.read(n, -0);
+  real fraction;
+  real step;
+};
 
-      const double tension = 0.0;  //-1 = low, 0 = normal, +1 = high
-      const double bias = 0.0;  //-1 = left, 0 = even, +1 = right
+void ResampleHermite::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
 
-      double mu1, mu2, mu3, m0, m1, a0, a1, a2, a3;
+void ResampleHermite::clear() {
+  fraction = 0.0;
+}
 
-      mu1 = resampler.fraction;
+void ResampleHermite::sample() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -3);
+      real b = dsp.buffer.read(n, -2);
+      real c = dsp.buffer.read(n, -1);
+      real d = dsp.buffer.read(n, -0);
+
+      const real tension = 0.0;  //-1 = low, 0 = normal, +1 = high
+      const real bias = 0.0;  //-1 = left, 0 = even, +1 = right
+
+      real mu1, mu2, mu3, m0, m1, a0, a1, a2, a3;
+
+      mu1 = fraction;
       mu2 = mu1 * mu1;
       mu3 = mu2 * mu1;
 
@@ -32,12 +51,12 @@ void DSP::resampleHermite() {
       channel[n] = (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
     }
 
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
+    dsp.write(channel);
+    fraction += step;
   }
 
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
 }
 
 #endif

bsnes/nall/dsp/resample/lib/sinc.hpp

@@ -0,0 +1,600 @@
+// If these types are changed to anything other than "float", you should comment out the SSE detection directives below
+// so that the SSE code is not used.
+
+typedef float resample_coeff_t;	// note: sizeof(resample_coeff_t) must be == to a power of 2, and not larger than 16
+typedef float resample_samp_t;
+
+
+// ...but don't comment this single RESAMPLE_SSEREGPARM define out when disabling SSE.
+#define RESAMPLE_SSEREGPARM	
+
+#if defined(__SSE__)
+  #define SINCRESAMPLE_USE_SSE 1
+  #ifndef __x86_64__
+    #undef RESAMPLE_SSEREGPARM
+    #define RESAMPLE_SSEREGPARM __attribute__((sseregparm))
+  #endif
+#else
+  // TODO: altivec here
+#endif
+
+namespace ResampleUtility
+{
+ inline void kaiser_window(double* io, int count, double beta);
+ inline void gen_sinc(double* out, int size, double cutoff, double kaiser);
+ inline void gen_sinc_os(double* out, int size, double cutoff, double kaiser);
+ inline void normalize(double* io, int size, double gain = 1.0);
+
+ inline void* make_aligned(void* ptr, unsigned boundary);	// boundary must be a power of 2
+}
+
+class SincResampleHR
+{
+ private:
+
+ inline void Init(unsigned ratio_arg, double desired_bandwidth, double beta, double d);
+
+ inline void write(resample_samp_t sample) RESAMPLE_SSEREGPARM;
+ inline resample_samp_t read(void) RESAMPLE_SSEREGPARM;
+ inline bool output_avail(void);
+
+ private:
+
+ inline resample_samp_t mac(const resample_samp_t *wave, const resample_coeff_t *coeff, unsigned count);
+
+ unsigned ratio;
+ unsigned num_convolutions;
+
+ resample_coeff_t *coeffs;
+ std::vector<unsigned char> coeffs_mem;
+
+ // second half of ringbuffer should be copy of first half.
+ resample_samp_t *rb;
+ std::vector<unsigned char> rb_mem;
+
+ signed rb_readpos;
+ signed rb_writepos;
+ signed rb_in;
+ signed rb_eff_size;
+
+ friend class SincResample;
+};
+
+class SincResample
+{
+ public:
+
+ enum
+ {
+  QUALITY_LOW = 0,
+  QUALITY_MEDIUM = 2,
+  QUALITY_HIGH = 4
+ };
+
+ inline SincResample(double input_rate, double output_rate, double desired_bandwidth, unsigned quality = QUALITY_HIGH);
+
+ inline void write(resample_samp_t sample) RESAMPLE_SSEREGPARM;
+ inline resample_samp_t read(void) RESAMPLE_SSEREGPARM;
+ inline bool output_avail(void);
+
+ private:
+
+ inline void Init(double input_rate, double output_rate, double desired_bandwidth, double beta, double d, unsigned pn_nume, unsigned phases_min);
+
+ inline resample_samp_t mac(const resample_samp_t *wave, const resample_coeff_t *coeffs_a, const resample_coeff_t *coeffs_b, const double ffract, unsigned count) RESAMPLE_SSEREGPARM;
+
+ unsigned num_convolutions;
+ unsigned num_phases;
+
+ unsigned step_int;
+ double step_fract;
+
+ double input_pos_fract;
+
+
+ std::vector<resample_coeff_t *> coeffs;	// Pointers into coeff_mem.
+ std::vector<unsigned char> coeff_mem;
+
+
+ std::vector<resample_samp_t> rb;	// second half should be copy of first half.
+ signed rb_readpos;
+ signed rb_writepos;
+ signed rb_in;
+
+ bool hr_used;
+ SincResampleHR hr;
+};
+
+
+//
+// Code:
+//
+//#include "resample.hpp"
+
+#if 0
+namespace bit
+{
+    inline unsigned round(unsigned x) {
+      if((x & (x - 1)) == 0) return x;
+      while(x & (x - 1)) x &= x - 1;
+      return x << 1;
+    }
+}
+#endif
+
+void SincResampleHR::Init(unsigned ratio_arg, double desired_bandwidth, double beta, double d)
+{
+ const unsigned align_boundary = 16;
+ std::vector<double> coeffs_tmp;
+ double cutoff;	// 1.0 = f/2
+
+ ratio = ratio_arg;
+
+ //num_convolutions = ((unsigned)ceil(d / ((1.0 - desired_bandwidth) / ratio)) + 1) &~ 1;	// round up to be even
+ num_convolutions = ((unsigned)ceil(d / ((1.0 - desired_bandwidth) / ratio)) | 1);
+
+ cutoff = (1.0 / ratio) - (d / num_convolutions);
+
+//printf("%d %d %.20f\n", ratio, num_convolutions, cutoff);
+ assert(num_convolutions > ratio);
+
+
+ // Generate windowed sinc of POWER
+ coeffs_tmp.resize(num_convolutions);
+ //ResampleUtility::gen_sinc(&coeffs_tmp[0], num_convolutions, cutoff, beta);
+ ResampleUtility::gen_sinc_os(&coeffs_tmp[0], num_convolutions, cutoff, beta);
+ ResampleUtility::normalize(&coeffs_tmp[0], num_convolutions);
+
+ // Copy from coeffs_tmp to coeffs~
+ // We multiply many coefficients at a time in the mac loop, so make sure the last few that don't really
+ // exist are allocated, zero'd mem.
+
+ coeffs_mem.resize(((num_convolutions + 7) &~ 7) * sizeof(resample_coeff_t) + (align_boundary - 1));
+ coeffs = (resample_coeff_t *)ResampleUtility::make_aligned(&coeffs_mem[0], align_boundary);
+
+
+ for(unsigned i = 0; i < num_convolutions; i++)
+  coeffs[i] = coeffs_tmp[i];
+
+ rb_eff_size = nall::bit::round(num_convolutions * 2) >> 1;
+ rb_readpos = 0;
+ rb_writepos = 0;
+ rb_in = 0;
+
+ rb_mem.resize(rb_eff_size * 2 * sizeof(resample_samp_t) + (align_boundary - 1));
+ rb = (resample_samp_t *)ResampleUtility::make_aligned(&rb_mem[0], align_boundary);
+}
+
+
+inline bool SincResampleHR::output_avail(void)
+{
+ return(rb_in >= (signed)num_convolutions);
+}
+
+inline void SincResampleHR::write(resample_samp_t sample)
+{
+ assert(!output_avail());
+
+ rb[rb_writepos] = sample;
+ rb[rb_writepos + rb_eff_size] = sample;
+ rb_writepos = (rb_writepos + 1) & (rb_eff_size - 1);
+ rb_in++;
+}
+
+resample_samp_t SincResampleHR::mac(const resample_samp_t *wave, const resample_coeff_t *coeff, unsigned count)
+{
+#if SINCRESAMPLE_USE_SSE
+ __m128 accum_veca[2] = { _mm_set1_ps(0), _mm_set1_ps(0) };
+ 
+ resample_samp_t accum;
+
+ for(unsigned c = 0; c < count; c += 8)
+ {
+  for(unsigned i = 0; i < 2; i++)
+  {
+   __m128 co[2];
+   __m128 w[2];
+
+   co[i] = _mm_load_ps(&coeff[c + i * 4]);
+   w[i] = _mm_load_ps(&wave[c + i * 4]);
+
+   w[i] = _mm_mul_ps(w[i], co[i]);
+
+   accum_veca[i] = _mm_add_ps(w[i], accum_veca[i]);
+  }
+ }
+
+ __m128 accum_vec = _mm_add_ps(accum_veca[0], accum_veca[1]); //_mm_add_ps(_mm_add_ps(accum_veca[0], accum_veca[1]), _mm_add_ps(accum_veca[2], accum_veca[3]));
+
+ accum_vec = _mm_add_ps(accum_vec, _mm_shuffle_ps(accum_vec, accum_vec, (3 << 0) | (2 << 2) | (1 << 4) | (0 << 6)));
+ accum_vec = _mm_add_ps(accum_vec, _mm_shuffle_ps(accum_vec, accum_vec, (1 << 0) | (0 << 2) | (1 << 4) | (0 << 6)));
+
+ _mm_store_ss(&accum, accum_vec);
+
+ return accum;
+#else
+ resample_samp_t accum[4] = { 0, 0, 0, 0 };
+
+ for(unsigned c = 0; c < count; c+= 4)
+ {
+  accum[0] += wave[c + 0] * coeff[c + 0];
+  accum[1] += wave[c + 1] * coeff[c + 1];
+  accum[2] += wave[c + 2] * coeff[c + 2];
+  accum[3] += wave[c + 3] * coeff[c + 3];
+ }
+
+ return (accum[0] + accum[1]) + (accum[2] + accum[3]);	// don't mess with parentheses(assuming compiler doesn't already, which it may...
+
+#endif
+}
+
+
+resample_samp_t SincResampleHR::read(void)
+{
+ assert(output_avail());
+ resample_samp_t ret;
+
+ ret = mac(&rb[rb_readpos], &coeffs[0], num_convolutions);
+
+ rb_readpos = (rb_readpos + ratio) & (rb_eff_size - 1);
+ rb_in -= ratio;
+
+ return ret;
+}
+
+
+SincResample::SincResample(double input_rate, double output_rate, double desired_bandwidth, unsigned quality)
+{
+ const struct
+ {
+  double beta;
+  double d;
+  unsigned pn_nume;
+  unsigned phases_min;
+ } qtab[5] =
+ {
+  { 5.658, 3.62, 4096, 4 },
+  { 6.764, 4.32, 8192, 4 },
+  { 7.865, 5.0, 16384, 8 },
+  { 8.960, 5.7, 32768, 16 },
+  { 10.056, 6.4, 65536, 32 }
+ };
+
+ // Sanity checks
+ assert(ceil(input_rate) > 0);
+ assert(ceil(output_rate) > 0);
+ assert(ceil(input_rate / output_rate) <= 1024);
+ assert(ceil(output_rate / input_rate) <= 1024);
+
+ // The simplistic number-of-phases calculation code doesn't work well enough for when desired_bandwidth is close to 1.0 and when
+ // upsampling.
+ assert(desired_bandwidth >= 0.25 && desired_bandwidth < 0.96);
+ assert(quality >= 0 && quality <= 4);
+
+ hr_used = false;
+
+#if 1
+ // Round down to the nearest multiple of 4(so wave buffer remains aligned)
+ // It also adjusts the effective intermediate sampling rate up slightly, so that the upper frequencies below f/2
+ // aren't overly attenuated so much.  In the future, we might want to do an FFT or something to choose the intermediate rate more accurately
+ // to virtually eliminate over-attenuation.
+ unsigned ioratio_rd = (unsigned)floor(input_rate / (output_rate * (1.0 + (1.0 - desired_bandwidth) / 2) )) & ~3;
+
+ if(ioratio_rd >= 8)
+ {
+  hr.Init(ioratio_rd, desired_bandwidth, qtab[quality].beta, qtab[quality].d); //10.056, 6.4); 
+  hr_used = true;
+
+  input_rate /= ioratio_rd;
+ }
+#endif
+
+ Init(input_rate, output_rate, desired_bandwidth, qtab[quality].beta, qtab[quality].d, qtab[quality].pn_nume, qtab[quality].phases_min);
+}
+
+void SincResample::Init(double input_rate, double output_rate, double desired_bandwidth, double beta, double d, unsigned pn_nume, unsigned phases_min)
+{
+ const unsigned max_mult_atatime = 8;	// multiply "granularity".  must be power of 2.
+ const unsigned max_mult_minus1 = (max_mult_atatime - 1);
+ const unsigned conv_alignment_bytes = 16;	// must be power of 2
+ const double input_to_output_ratio = input_rate / output_rate;
+ const double output_to_input_ratio = output_rate / input_rate;
+ double cutoff;		// 1.0 = input_rate / 2
+ std::vector<double> coeff_init_buffer;
+
+ // Round up num_convolutions to be even.
+ if(output_rate > input_rate)
+  num_convolutions = ((unsigned)ceil(d / (1.0 - desired_bandwidth)) + 1) & ~1;
+ else
+  num_convolutions = ((unsigned)ceil(d / (output_to_input_ratio * (1.0 - desired_bandwidth))) + 1) & ~1;
+
+ if(output_rate > input_rate)	// Upsampling
+  cutoff = desired_bandwidth;
+ else	// Downsampling
+  cutoff = output_to_input_ratio * desired_bandwidth;
+
+ // Round up to be even.
+ num_phases = (std::max<unsigned>(pn_nume / num_convolutions, phases_min) + 1) &~1;
+
+ // Adjust cutoff to account for the multiple phases.
+ cutoff = cutoff / num_phases;
+
+ assert((num_convolutions & 1) == 0);
+ assert((num_phases & 1) == 0);
+
+// fprintf(stderr, "num_convolutions=%u, num_phases=%u, total expected coeff byte size=%lu\n", num_convolutions, num_phases,
+//        (long)((num_phases + 2) * ((num_convolutions + max_mult_minus1) & ~max_mult_minus1) * sizeof(float) + conv_alignment_bytes));
+
+ coeff_init_buffer.resize(num_phases * num_convolutions);
+
+ coeffs.resize(num_phases + 1 + 1);
+
+ coeff_mem.resize((num_phases + 1 + 1) * ((num_convolutions + max_mult_minus1) &~ max_mult_minus1) * sizeof(resample_coeff_t) + conv_alignment_bytes);
+
+ // Assign aligned pointers into coeff_mem
+ {
+  resample_coeff_t *base_ptr = (resample_coeff_t *)ResampleUtility::make_aligned(&coeff_mem[0], conv_alignment_bytes);
+
+  for(unsigned phase = 0; phase < (num_phases + 1 + 1); phase++)
+  {
+   coeffs[phase] = base_ptr + (((num_convolutions + max_mult_minus1) & ~max_mult_minus1) * phase);
+  }
+ }
+
+ ResampleUtility::gen_sinc(&coeff_init_buffer[0], num_phases * num_convolutions, cutoff, beta);
+ ResampleUtility::normalize(&coeff_init_buffer[0], num_phases * num_convolutions, num_phases);
+
+ // Reorder coefficients to allow for more efficient convolution.
+ for(int phase = -1; phase < ((int)num_phases + 1); phase++)
+ {
+  for(int conv = 0; conv < (int)num_convolutions; conv++)
+  {
+   double coeff;
+
+   if(phase == -1 && conv == 0)
+    coeff = 0;
+   else if(phase == (int)num_phases && conv == ((int)num_convolutions - 1))
+    coeff = 0;
+   else
+    coeff = coeff_init_buffer[conv * num_phases + phase];
+
+   coeffs[phase + 1][conv] = coeff;
+  }
+ }
+
+ // Free a bit of mem
+ coeff_init_buffer.resize(0);
+
+ step_int = floor(input_to_output_ratio);
+ step_fract = input_to_output_ratio - step_int;
+
+ input_pos_fract = 0;
+
+ // Do NOT use rb.size() later in the code, since it'll include the padding.
+ // We should only need one "max_mult_minus1" here, not two, since it won't matter if it over-reads(due to doing "max_mult_atatime" multiplications at a time
+ // rather than just 1, in which case this over-read wouldn't happen), from the first half into the duplicated half,
+ // since those corresponding coefficients will be zero anyway; this is just to handle the case of reading off the end of the duplicated half to
+ // prevent illegal memory accesses.
+ rb.resize(num_convolutions * 2 + max_mult_minus1);
+
+ rb_readpos = 0;
+ rb_writepos = 0;
+ rb_in = 0;
+}
+
+resample_samp_t SincResample::mac(const resample_samp_t *wave, const resample_coeff_t *coeffs_a, const resample_coeff_t *coeffs_b, const double ffract, unsigned count)
+{
+ resample_samp_t accum = 0;
+#if SINCRESAMPLE_USE_SSE
+ __m128 accum_vec_a[2] = { _mm_set1_ps(0), _mm_set1_ps(0) };
+ __m128 accum_vec_b[2] = { _mm_set1_ps(0), _mm_set1_ps(0) };
+
+ for(unsigned c = 0; c < count; c += 8) //8) //4)
+ {
+  __m128 coeff_a[2];
+  __m128 coeff_b[2];
+  __m128 w[2];
+  __m128 result_a[2], result_b[2];
+
+  for(unsigned i = 0; i < 2; i++)
+  {
+   coeff_a[i] = _mm_load_ps(&coeffs_a[c + (i * 4)]);
+   coeff_b[i] = _mm_load_ps(&coeffs_b[c + (i * 4)]);
+   w[i] = _mm_loadu_ps(&wave[c + (i * 4)]);
+
+   result_a[i] = _mm_mul_ps(coeff_a[i], w[i]);
+   result_b[i] = _mm_mul_ps(coeff_b[i], w[i]);
+
+   accum_vec_a[i] = _mm_add_ps(result_a[i], accum_vec_a[i]);
+   accum_vec_b[i] = _mm_add_ps(result_b[i], accum_vec_b[i]);
+  }
+ }
+
+ __m128 accum_vec, av_a, av_b;
+ __m128 mult_a_vec = _mm_set1_ps(1.0 - ffract);
+ __m128 mult_b_vec = _mm_set1_ps(ffract);
+
+ av_a = _mm_mul_ps(mult_a_vec, /*accum_vec_a[0]);*/ _mm_add_ps(accum_vec_a[0], accum_vec_a[1]));
+ av_b = _mm_mul_ps(mult_b_vec, /*accum_vec_b[0]);*/ _mm_add_ps(accum_vec_b[0], accum_vec_b[1]));
+
+ accum_vec = _mm_add_ps(av_a, av_b);
+
+ accum_vec = _mm_add_ps(accum_vec, _mm_shuffle_ps(accum_vec, accum_vec, (3 << 0) | (2 << 2) | (1 << 4) | (0 << 6)));
+ accum_vec = _mm_add_ps(accum_vec, _mm_shuffle_ps(accum_vec, accum_vec, (1 << 0) | (0 << 2) | (1 << 4) | (0 << 6)));
+
+ _mm_store_ss(&accum, accum_vec);
+#else
+ resample_coeff_t mult_a = 1.0 - ffract;
+ resample_coeff_t mult_b = ffract;
+
+ for(unsigned c = 0; c < count; c += 4)
+ {
+  accum += wave[c + 0] * (coeffs_a[c + 0] * mult_a + coeffs_b[c + 0] * mult_b);
+  accum += wave[c + 1] * (coeffs_a[c + 1] * mult_a + coeffs_b[c + 1] * mult_b);
+  accum += wave[c + 2] * (coeffs_a[c + 2] * mult_a + coeffs_b[c + 2] * mult_b);
+  accum += wave[c + 3] * (coeffs_a[c + 3] * mult_a + coeffs_b[c + 3] * mult_b);
+ }
+#endif
+
+ return accum;
+}
+
+inline bool SincResample::output_avail(void)
+{
+ return(rb_in >= (int)num_convolutions);
+}
+
+resample_samp_t SincResample::read(void)
+{
+ assert(output_avail());
+ double phase = input_pos_fract * num_phases - 0.5;
+ signed phase_int = (signed)floor(phase);
+ double phase_fract = phase - phase_int;
+ unsigned phase_a = num_phases - 1 - phase_int;
+ unsigned phase_b = phase_a - 1;
+ resample_samp_t ret;
+
+ ret = mac(&rb[rb_readpos], &coeffs[phase_a + 1][0], &coeffs[phase_b + 1][0], phase_fract, num_convolutions);
+
+ unsigned int_increment = step_int;
+
+ input_pos_fract += step_fract;
+ int_increment += floor(input_pos_fract);
+ input_pos_fract -= floor(input_pos_fract);
+
+ rb_readpos = (rb_readpos + int_increment) % num_convolutions;
+ rb_in -= int_increment;
+
+ return ret;
+}
+
+inline void SincResample::write(resample_samp_t sample)
+{
+ assert(!output_avail());
+
+ if(hr_used)
+ {
+  hr.write(sample);
+
+  if(hr.output_avail())
+  {
+   sample = hr.read();
+  }
+  else
+  {
+   return;
+  }
+ }
+
+ rb[rb_writepos + 0 * num_convolutions] = sample;
+ rb[rb_writepos + 1 * num_convolutions] = sample;
+ rb_writepos = (rb_writepos + 1) % num_convolutions;
+ rb_in++;
+}
+
+void ResampleUtility::kaiser_window( double* io, int count, double beta)
+{
+        int const accuracy = 24; //16; //12;
+
+        double* end = io + count;
+
+        double beta2    = beta * beta * (double) -0.25;
+        double to_fract = beta2 / ((double) count * count);
+        double i        = 0;
+        double rescale = 0; // Doesn't need an initializer, to shut up gcc
+
+        for ( ; io < end; ++io, i += 1 )
+        {
+                double x = i * i * to_fract - beta2;
+                double u = x;
+                double k = x + 1;
+
+                double n = 2;
+                do
+                {
+                        u *= x / (n * n);
+                        n += 1;
+                        k += u;
+                }
+                while ( k <= u * (1 << accuracy) );
+
+                if ( !i )
+                        rescale = 1 / k; // otherwise values get large
+
+                *io *= k * rescale;
+        }
+}
+
+void ResampleUtility::gen_sinc(double* out, int size, double cutoff, double kaiser)
+{
+        assert( size % 2 == 0 ); // size must be even
+ 
+        int const half_size = size / 2;
+        double* const mid = &out [half_size];
+ 
+        // Generate right half of sinc
+        for ( int i = 0; i < half_size; i++ )
+        {
+                double angle = (i * 2 + 1) * (M_PI / 2);
+                mid [i] = sin( angle * cutoff ) / angle;
+        }
+ 
+        kaiser_window( mid, half_size, kaiser );
+ 
+        // Mirror for left half
+        for ( int i = 0; i < half_size; i++ )
+                out [i] = mid [half_size - 1 - i];
+}
+
+void ResampleUtility::gen_sinc_os(double* out, int size, double cutoff, double kaiser)
+{
+        assert( size % 2 == 1); // size must be odd
+ 
+	for(int i = 0; i < size; i++)
+	{
+         if(i == (size / 2))
+          out[i] = 2 * M_PI * (cutoff / 2); //0.078478; //1.0; //sin(2 * M_PI * (cutoff / 2) * (i - size / 2)) / (i - (size / 2));
+	 else
+ 	  out[i] = sin(2 * M_PI * (cutoff / 2) * (i - size / 2)) / (i - (size / 2));
+
+//	 out[i] *= 0.3635819 - 0.4891775 * cos(2 * M_PI * i / (size - 1)) + 0.1365995 * cos(4 * M_PI * i / (size - 1)) - 0.0106411 * cos(6 * M_PI * i / (size - 1));
+//0.42 - 0.5 * cos(2 * M_PI * i / (size - 1)) + 0.08 * cos(4 * M_PI * i / (size - 1));
+
+//         printf("%d %f\n", i, out[i]);
+	}
+
+	kaiser_window(&out[size / 2], size / 2 + 1, kaiser);
+
+        // Mirror for left half
+        for ( int i = 0; i < size / 2; i++ )
+                out [i] = out [size - 1 - i];
+
+}
+
+void ResampleUtility::normalize(double* io, int size, double gain)
+{
+        double sum = 0;
+        for ( int i = 0; i < size; i++ )
+                sum += io [i];
+
+        double scale = gain / sum;
+        for ( int i = 0; i < size; i++ )
+                io [i] *= scale;
+}
+
+void* ResampleUtility::make_aligned(void* ptr, unsigned boundary)
+{
+ unsigned char* null_ptr = (unsigned char *)NULL;
+ unsigned char* uc_ptr = (unsigned char *)ptr;
+
+ uc_ptr += (boundary - ((uc_ptr - null_ptr) & (boundary - 1))) & (boundary - 1);
+
+ //while((uc_ptr - null_ptr) & (boundary - 1))
+ // uc_ptr++;
+
+ //printf("%16llx %16llx\n", (unsigned long long)ptr, (unsigned long long)uc_ptr);
+
+ assert((uc_ptr - (unsigned char *)ptr) < boundary && (uc_ptr >= (unsigned char *)ptr));
+
+ return uc_ptr;
+}

bsnes/nall/dsp/resample/linear.hpp

@@ -1,24 +1,43 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
-void DSP::resampleLinear() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
+struct ResampleLinear : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  ResampleLinear(DSP &dsp) : Resampler(dsp) {}
 
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -1);
-      double b = buffer.read(n, -0);
+  real fraction;
+  real step;
+};
 
-      double mu = resampler.fraction;
+void ResampleLinear::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
+
+void ResampleLinear::clear() {
+  fraction = 0.0;
+}
+
+void ResampleLinear::sample() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -1);
+      real b = dsp.buffer.read(n, -0);
+
+      real mu = fraction;
 
       channel[n] = a * (1.0 - mu) + b * mu;
     }
 
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
+    dsp.write(channel);
+    fraction += step;
   }
 
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
 }
 
 #endif

bsnes/nall/dsp/resample/nearest.hpp

@@ -0,0 +1,43 @@
+#ifdef NALL_DSP_INTERNAL_HPP
+
+struct ResampleNearest : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  ResampleNearest(DSP &dsp) : Resampler(dsp) {}
+
+  real fraction;
+  real step;
+};
+
+void ResampleNearest::setFrequency() {
+  fraction = 0.0;
+  step = dsp.settings.frequency / frequency;
+}
+
+void ResampleNearest::clear() {
+  fraction = 0.0;
+}
+
+void ResampleNearest::sample() {
+  while(fraction <= 1.0) {
+    real channel[dsp.settings.channels];
+
+    for(unsigned n = 0; n < dsp.settings.channels; n++) {
+      real a = dsp.buffer.read(n, -1);
+      real b = dsp.buffer.read(n, -0);
+
+      real mu = fraction;
+
+      channel[n] = mu < 0.5 ? a : b;
+    }
+
+    dsp.write(channel);
+    fraction += step;
+  }
+
+  dsp.buffer.rdoffset++;
+  fraction -= 1.0;
+}
+
+#endif

bsnes/nall/dsp/resample/sinc.hpp

@@ -0,0 +1,54 @@
+#ifdef NALL_DSP_INTERNAL_HPP
+
+#include "lib/sinc.hpp"
+
+struct ResampleSinc : Resampler {
+  inline void setFrequency();
+  inline void clear();
+  inline void sample();
+  inline ResampleSinc(DSP &dsp);
+
+private:
+  inline void remakeSinc();
+  SincResample *sinc_resampler[8];
+};
+
+void ResampleSinc::setFrequency() {
+  remakeSinc();
+}
+
+void ResampleSinc::clear() {
+  remakeSinc();
+}
+
+void ResampleSinc::sample() {
+  for(unsigned c = 0; c < dsp.settings.channels; c++) {
+    sinc_resampler[c]->write(dsp.buffer.read(c));
+  }
+
+  if(sinc_resampler[0]->output_avail()) {
+    do {
+      for(unsigned c = 0; c < dsp.settings.channels; c++) {
+        dsp.output.write(c) = sinc_resampler[c]->read();
+      }
+      dsp.output.wroffset++;
+    } while(sinc_resampler[0]->output_avail());
+  }
+
+  dsp.buffer.rdoffset++;
+}
+
+ResampleSinc::ResampleSinc(DSP &dsp) : Resampler(dsp) {
+  for(unsigned n = 0; n < 8; n++) sinc_resampler[n] = 0;
+}
+
+void ResampleSinc::remakeSinc() {
+  assert(dsp.settings.channels < 8);
+
+  for(unsigned c = 0; c < dsp.settings.channels; c++) {
+    if(sinc_resampler[c]) delete sinc_resampler[c];
+    sinc_resampler[c] = new SincResample(dsp.settings.frequency, frequency, 0.85, SincResample::QUALITY_HIGH);
+  }
+}
+
+#endif

bsnes/nall/dsp/settings.hpp

@@ -1,32 +1,50 @@
 #ifdef NALL_DSP_INTERNAL_HPP
 
+void DSP::setChannels(unsigned channels) {
+  assert(channels > 0);
+  buffer.setChannels(channels);
+  output.setChannels(channels);
+  settings.channels = channels;
+}
+
 void DSP::setPrecision(unsigned precision) {
   settings.precision = precision;
   settings.intensity = 1 << (settings.precision - 1);
+  settings.intensityInverse = 1.0 / settings.intensity;
 }
 
-void DSP::setFrequency(double frequency) {
+void DSP::setFrequency(real frequency) {
   settings.frequency = frequency;
-  resampler.fraction = 0;
-  resampler.step = settings.frequency / resampler.frequency;
+  resampler->setFrequency();
 }
 
-void DSP::setVolume(double volume) {
+void DSP::setVolume(real volume) {
   settings.volume = volume;
 }
 
-void DSP::setBalance(double balance) {
+void DSP::setBalance(real balance) {
   settings.balance = balance;
 }
 
-void DSP::setResampler(Resampler engine) {
-  resampler.engine = engine;
+void DSP::setResampler(ResampleEngine engine) {
+  if(resampler) delete resampler;
+
+  switch(engine) {
+  case ResampleEngine::Nearest: resampler = new ResampleNearest(*this); return;
+  case ResampleEngine::Linear:  resampler = new ResampleLinear (*this); return;
+  case ResampleEngine::Cosine:  resampler = new ResampleCosine (*this); return;
+  case ResampleEngine::Cubic:   resampler = new ResampleCubic  (*this); return;
+  case ResampleEngine::Hermite: resampler = new ResampleHermite(*this); return;
+  case ResampleEngine::Average: resampler = new ResampleAverage(*this); return;
+  case ResampleEngine::Sinc:    resampler = new ResampleSinc   (*this); return;
+  }
+
+  throw;
 }
 
-void DSP::setResamplerFrequency(double frequency) {
-  resampler.frequency = frequency;
-  resampler.fraction = 0;
-  resampler.step = settings.frequency / resampler.frequency;
+void DSP::setResamplerFrequency(real frequency) {
+  resampler->frequency = frequency;
+  resampler->setFrequency();
 }
 
 #endif

bsnes/nall/endian.hpp

@@ -1,7 +1,9 @@
 #ifndef NALL_ENDIAN_HPP
 #define NALL_ENDIAN_HPP
 
-#if !defined(ARCH_MSB)
+#include <nall/intrinsics.hpp>
+
+#if defined(ENDIAN_LSB)
   //little-endian: uint8_t[] { 0x01, 0x02, 0x03, 0x04 } == 0x04030201
   #define order_lsb2(a,b)             a,b
   #define order_lsb3(a,b,c)           a,b,c
@@ -17,7 +19,7 @@
   #define order_msb6(a,b,c,d,e,f)     f,e,d,c,b,a
   #define order_msb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
   #define order_msb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
-#else
+#elif defined(ENDIAN_MSB)
   //big-endian:    uint8_t[] { 0x01, 0x02, 0x03, 0x04 } == 0x01020304
   #define order_lsb2(a,b)             b,a
   #define order_lsb3(a,b,c)           c,b,a
@@ -33,6 +35,8 @@
   #define order_msb6(a,b,c,d,e,f)     a,b,c,d,e,f
   #define order_msb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
   #define order_msb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
+#else
+  #error "Unknown endian. Please specify in nall/intrinsics.hpp"
 #endif
 
 #endif

bsnes/nall/file.hpp

@@ -23,6 +23,7 @@ namespace nall {
     enum class time : unsigned { create, modify, access };
 
     static bool read(const string &filename, uint8_t *&data, unsigned &size) {
+      data = 0;
       file fp;
       if(fp.open(filename, mode::read) == false) return false;
       size = fp.size();

bsnes/nall/foreach.hpp

@@ -1,18 +0,0 @@
-#ifndef NALL_FOREACH_HPP
-#define NALL_FOREACH_HPP
-
-#include <type_traits>
-#include <nall/concept.hpp>
-
-#undef foreach
-
-#define foreach2(iter, object) foreach3(iter, object, foreach_counter)
-#define foreach3(iter, object, foreach_counter) \
-  for(unsigned foreach_counter = 0, foreach_limit = container_size(object), foreach_once = 0, foreach_broken = 0; foreach_counter < foreach_limit && foreach_broken == 0; foreach_counter++, foreach_once = 0) \
-    for(auto &iter = object[foreach_counter]; foreach_once == 0 && (foreach_broken = 1); foreach_once++, foreach_broken = 0)
-
-#define foreach_impl(...) foreach_decl(__VA_ARGS__, foreach3(__VA_ARGS__), foreach2(__VA_ARGS__), foreach_too_few_arguments)
-#define foreach_decl(_1, _2, _3, N, ...) N
-#define foreach(...) foreach_impl(__VA_ARGS__)
-
-#endif

bsnes/nall/function.hpp

@@ -36,19 +36,19 @@ namespace nall {
   public:
     operator bool() const { return callback; }
     R operator()(P... p) const { return (*callback)(std::forward<P>(p)...); }
-    void reset() { if(callback) { delete callback; callback = 0; } }
+    void reset() { if(callback) { delete callback; callback = nullptr; } }
 
     function& operator=(const function &source) {
       if(this != &source) {
-        if(callback) { delete callback; callback = 0; }
+        if(callback) { delete callback; callback = nullptr; }
         if(source.callback) callback = source.callback->copy();
       }
       return *this;
     }
 
-    function(const function &source) : callback(0) { operator=(source); }
-    function() : callback(0) {}
-    function(void *function) : callback(0) { if(function) callback = new global((R (*)(P...))function); }
+    function(const function &source) : callback(nullptr) { operator=(source); }
+    function() : callback(nullptr) {}
+    function(void *function) : callback(nullptr) { if(function) callback = new global((R (*)(P...))function); }
     function(R (*function)(P...)) { callback = new global(function); }
     template<typename C> function(R (C::*function)(P...), C *object) { callback = new member<C>(function, object); }
     template<typename C> function(R (C::*function)(P...) const, C *object) { callback = new member<C>((R (C::*)(P...))function, object); }

bsnes/nall/gameboy/cartridge.hpp

@@ -5,7 +5,7 @@ namespace nall {
 
 class GameBoyCartridge {
 public:
-  string xml;
+  string markup;
   inline GameBoyCartridge(uint8_t *data, unsigned size);
 
 //private:
@@ -22,7 +22,7 @@ public:
 };
 
 GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
-  xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  markup = "";
   if(romsize < 0x4000) return;
 
   info.mapper = "unknown";
@@ -100,18 +100,15 @@ GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
 
   if(info.mapper == "MBC2") info.ramsize = 512;  //512 x 4-bit
 
-  xml.append("<cartridge mapper='", info.mapper, "'");
-  if(info.rtc) xml.append(" rtc='true'");
-  if(info.rumble) xml.append(" rumble='true'");
-  xml.append(">\n");
+  markup.append("cartridge mapper=", info.mapper);
+  if(info.rtc) markup.append(" rtc");
+  if(info.rumble) markup.append(" rumble");
+  markup.append("\n");
 
-  xml.append("  <rom size='", hex(romsize), "'/>\n");  //TODO: trust/check info.romsize?
+  markup.append("\t" "rom size=", hex(romsize), "\n");  //TODO: trust/check info.romsize?
 
   if(info.ramsize > 0)
-  xml.append("  <ram size='", hex(info.ramsize), "' battery='", info.battery, "'/>\n");
-
-  xml.append("</cartridge>\n");
-  xml.transform("'", "\"");
+  markup.append("\t" "ram size=", hex(info.ramsize), info.battery ? " non-volatile\n" : "\n");
 }
 
 }

bsnes/nall/gzip.hpp

@@ -75,7 +75,7 @@ bool gzip::decompress(const uint8_t *data, unsigned size) {
   return inflate(this->data, this->size, data + p, size - p - 8);
 }
 
-gzip::gzip() : data(0) {
+gzip::gzip() : data(nullptr) {
 }
 
 gzip::~gzip() {

bsnes/nall/inflate.hpp

@@ -199,17 +199,17 @@ inline int codes(state *s, huffman *lencode, huffman *distcode) {
       symbol = decode(s, distcode);
       if(symbol < 0) return symbol;
       dist = dists[symbol] + bits(s, dext[symbol]);
-#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
+      #ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
       if(dist > s->outcnt) return -11;
-#endif
+      #endif
 
       if(s->out != 0) {
         if(s->outcnt + len > s->outlen) return 1;
         while(len--) {
           s->out[s->outcnt] =
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
+          #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
           dist > s->outcnt ? 0 :
-#endif
+          #endif
           s->out[s->outcnt - dist];
           s->outcnt++;
         }

bsnes/nall/intrinsics.hpp

@@ -0,0 +1,60 @@
+#ifndef NALL_INTRINSICS_HPP
+#define NALL_INTRINSICS_HPP
+
+struct Intrinsics {
+  enum class Compiler : unsigned { GCC, VisualC, Unknown };
+  enum class Platform : unsigned { X, OSX, Windows, Unknown };
+  enum class Endian : unsigned { LSB, MSB, Unknown };
+
+  static inline Compiler compiler();
+  static inline Platform platform();
+  static inline Endian endian();
+};
+
+/* Compiler detection */
+
+#if defined(__GNUC__)
+  #define COMPILER_GCC
+  Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::GCC; }
+#elif defined(_MSC_VER)
+  #define COMPILER_VISUALC
+  Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::VisualC; }
+#else
+  #define COMPILER_UNKNOWN
+  Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::Unknown; }
+#endif
+
+/* Platform detection */
+
+#if defined(linux) || defined(__sun__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
+  #define PLATFORM_X
+  Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::X; }
+#elif defined(__APPLE__)
+  #define PLATFORM_OSX
+  Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::OSX; }
+#elif defined(_WIN32)
+  #define PLATFORM_WINDOWS
+  #define PLATFORM_WIN
+  Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Windows; }
+#else
+  #define PLATFORM_UNKNOWN
+  
+#endif
+
+/* Endian detection */
+
+#if defined(__i386__) || defined(__amd64__) || defined(_M_IX86) || defined(_M_AMD64)
+  #define ENDIAN_LSB
+  #define ARCH_LSB
+  Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::LSB; }
+#elif defined(__powerpc__) || defined(_M_PPC) || defined(__BIG_ENDIAN__)
+  #define ENDIAN_MSB
+  #define ARCH_MSB
+  Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::MSB; }
+#else
+  #define ENDIAN_UNKNOWN
+  #define ARCH_UNKNOWN
+  Intrinsics::Endian Intrinsics::endia() { return Intrinsics::Endian::Unknown; }
+#endif
+
+#endif

bsnes/nall/ips.hpp

@@ -76,7 +76,7 @@ bool ips::apply() {
   }
 
   delete[] data;
-  data = 0;
+  data = nullptr;
   return false;
 }
 
@@ -96,7 +96,7 @@ bool ips::modify(const string &filename) {
   return file::read(filename, modifyData, modifySize);
 }
 
-ips::ips() : data(0), sourceData(0), modifyData(0) {
+ips::ips() : data(nullptr), sourceData(nullptr), modifyData(nullptr) {
 }
 
 ips::~ips() {

bsnes/nall/lzss.hpp

@@ -25,7 +25,7 @@ protected:
   struct Node {
     unsigned offset;
     Node *next;
-    inline Node() : offset(0), next(0) {}
+    inline Node() : offset(0), next(nullptr) {}
     inline ~Node() { if(next) delete next; }
   } *tree[65536];
 
@@ -34,7 +34,7 @@ protected:
   unsigned sourceSize;
 
 public:
-  inline lzss() : sourceData(0), sourceSize(0) {}
+  inline lzss() : sourceData(nullptr), sourceSize(0) {}
 };
 
 void lzss::source(const uint8_t *data, unsigned size) {

bsnes/nall/platform.hpp

@@ -104,6 +104,8 @@
     SHGetFolderPathW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, fp);
     strcpy(path, nall::utf8_t(fp));
     for(unsigned n = 0; path[n]; n++) if(path[n] == '\\') path[n] = '/';
+    unsigned length = strlen(path);
+    if(path[length] != '/') strcpy(path + length, "/");
     return path;
   }
 
@@ -112,6 +114,8 @@
     _wgetcwd(fp, _MAX_PATH);
     strcpy(path, nall::utf8_t(fp));
     for(unsigned n = 0; path[n]; n++) if(path[n] == '\\') path[n] = '/';
+    unsigned length = strlen(path);
+    if(path[length] != '/') strcpy(path + length, "/");
     return path;
   }
 #else
@@ -121,11 +125,16 @@
     *path = 0;
     struct passwd *userinfo = getpwuid(getuid());
     if(userinfo) strcpy(path, userinfo->pw_dir);
+    unsigned length = strlen(path);
+    if(path[length] != '/') strcpy(path + length, "/");
     return path;
   }
 
   inline char *getcwd(char *path) {
-    return getcwd(path, PATH_MAX);
+    auto unused = getcwd(path, PATH_MAX);
+    unsigned length = strlen(path);
+    if(path[length] != '/') strcpy(path + length, "/");
+    return path;
   }
 #endif
 

bsnes/nall/png.hpp

@@ -46,9 +46,9 @@ protected:
     IEND = 0x49454e44,
   };
 
-  static const unsigned interlace[7][4];
   unsigned bitpos;
 
+  inline unsigned interlace(unsigned pass, unsigned index);
   inline unsigned inflateSize();
   inline bool deinterlace(const uint8_t *&inputData, unsigned pass);
   inline bool filter(uint8_t *outputData, const uint8_t *inputData, unsigned width, unsigned height);
@@ -172,16 +172,19 @@ bool png::decode(const uint8_t *sourceData, unsigned sourceSize) {
   return true;
 }
 
-const unsigned png::interlace[7][4] = {
-  //x-distance, y-distance, x-origin, y-origin
-  { 8, 8, 0, 0 },
-  { 8, 8, 4, 0 },
-  { 4, 8, 0, 4 },
-  { 4, 4, 2, 0 },
-  { 2, 4, 0, 2 },
-  { 2, 2, 1, 0 },
-  { 1, 2, 0, 1 },
-};
+unsigned png::interlace(unsigned pass, unsigned index) {
+  static const unsigned data[7][4] = {
+    //x-distance, y-distance, x-origin, y-origin
+    { 8, 8, 0, 0 },
+    { 8, 8, 4, 0 },
+    { 4, 8, 0, 4 },
+    { 4, 4, 2, 0 },
+    { 2, 4, 0, 2 },
+    { 2, 2, 1, 0 },
+    { 1, 2, 0, 1 },
+  };
+  return data[pass][index];
+}
 
 unsigned png::inflateSize() {
   if(info.interlaceMethod == 0) {
@@ -190,8 +193,8 @@ unsigned png::inflateSize() {
 
   unsigned size = 0;
   for(unsigned pass = 0; pass < 7; pass++) {
-    unsigned xd = interlace[pass][0], yd = interlace[pass][1];
-    unsigned xo = interlace[pass][2], yo = interlace[pass][3];
+    unsigned xd = interlace(pass, 0), yd = interlace(pass, 1);
+    unsigned xo = interlace(pass, 2), yo = interlace(pass, 3);
     unsigned width  = (info.width  + (xd - xo - 1)) / xd;
     unsigned height = (info.height + (yd - yo - 1)) / yd;
     if(width == 0 || height == 0) continue;
@@ -201,8 +204,8 @@ unsigned png::inflateSize() {
 }
 
 bool png::deinterlace(const uint8_t *&inputData, unsigned pass) {
-  unsigned xd = interlace[pass][0], yd = interlace[pass][1];
-  unsigned xo = interlace[pass][2], yo = interlace[pass][3];
+  unsigned xd = interlace(pass, 0), yd = interlace(pass, 1);
+  unsigned xo = interlace(pass, 2), yo = interlace(pass, 3);
   unsigned width  = (info.width  + (xd - xo - 1)) / xd;
   unsigned height = (info.height + (yd - yo - 1)) / yd;
   if(width == 0 || height == 0) return true;
@@ -410,7 +413,7 @@ void png::alphaTransform(uint32_t rgb) {
   }
 }
 
-png::png() : data(0), rawData(0) {
+png::png() : data(nullptr), rawData(nullptr) {
 }
 
 png::~png() {

bsnes/nall/priorityqueue.hpp

@@ -12,7 +12,7 @@ namespace nall {
   //priority queue implementation using binary min-heap array;
   //does not require normalize() function.
   //O(1)     find   (tick)
-  //O(log n) insert (enqueue)
+  //O(log n) append (enqueue)
   //O(log n) remove (dequeue)
   template<typename type_t> class priority_queue {
   public:

bsnes/nall/property.hpp

@@ -22,7 +22,7 @@
 //  readwrite<int> y;
 //};
 
-//return types are const T& (byref) instead fo T (byval) to avoid major speed
+//return types are const T& (byref) instead of T (byval) to avoid major speed
 //penalties for objects with expensive copy constructors
 
 //operator-> provides access to underlying object type:

bsnes/nall/reference_array.hpp

@@ -1,9 +1,9 @@
 #ifndef NALL_REFERENCE_ARRAY_HPP
 #define NALL_REFERENCE_ARRAY_HPP
 
+#include <algorithm>
 #include <type_traits>
 #include <nall/bit.hpp>
-#include <nall/concept.hpp>
 
 namespace nall {
   template<typename T> struct reference_array {
@@ -18,7 +18,7 @@ namespace nall {
 
     void reset() {
       if(pool) free(pool);
-      pool = 0;
+      pool = nullptr;
       poolsize = 0;
       buffersize = 0;
     }
@@ -36,13 +36,29 @@ namespace nall {
       buffersize = newsize;
     }
 
-    void append(const T data) {
+    bool append(const T data) {
+      for(unsigned index = 0; index < buffersize; index++) {
+        if(pool[index] == &data) return false;
+      }
+
       unsigned index = buffersize++;
       if(index >= poolsize) resize(index + 1);
       pool[index] = &data;
+      return true;
     }
 
-    template<typename... Args> reference_array(Args&... args) : pool(0), poolsize(0), buffersize(0) {
+    bool remove(const T data) {
+      for(unsigned index = 0; index < buffersize; index++) {
+        if(pool[index] == &data) {
+          for(unsigned i = index; i < buffersize - 1; i++) pool[i] = pool[i + 1];
+          resize(buffersize - 1);
+          return true;
+        }
+      }
+      return false;
+    }
+
+    template<typename... Args> reference_array(Args&... args) : pool(nullptr), poolsize(0), buffersize(0) {
       construct(args...);
     }
 
@@ -64,7 +80,7 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       buffersize = source.buffersize;
-      source.pool = 0;
+      source.pool = nullptr;
       source.reset();
       return *this;
     }
@@ -79,6 +95,22 @@ namespace nall {
       return *pool[index];
     }
 
+    //iteration
+    struct iterator {
+      bool operator!=(const iterator &source) const { return index != source.index; }
+      T& operator*() { return array.operator[](index); }
+      iterator& operator++() { index++; return *this; }
+      iterator(const reference_array &array, unsigned index) : array(array), index(index) {}
+    private:
+      const reference_array &array;
+      unsigned index;
+    };
+
+    iterator begin() { return iterator(*this, 0); }
+    iterator end() { return iterator(*this, buffersize); }
+    const iterator begin() const { return iterator(*this, 0); }
+    const iterator end() const { return iterator(*this, buffersize); }
+
   private:
     void construct() {
     }
@@ -96,8 +128,6 @@ namespace nall {
       construct(args...);
     }
   };
-
-  template<typename T> struct has_size<reference_array<T>> { enum { value = true }; };
 }
 
 #endif

bsnes/nall/snes/cartridge.hpp

@@ -3,10 +3,10 @@
 
 namespace nall {
 
-class SNESCartridge {
+class SnesCartridge {
 public:
-  string xmlMemoryMap;
-  inline SNESCartridge(const uint8_t *data, unsigned size);
+  string markup;
+  inline SnesCartridge(const uint8_t *data, unsigned size);
 
 //private:
   inline void read_header(const uint8_t *data, unsigned size);
@@ -105,436 +105,346 @@ public:
   bool has_st018;
 };
 
-SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
+#define T "\t"
+
+SnesCartridge::SnesCartridge(const uint8_t *data, unsigned size) {
   read_header(data, size);
 
-  string xml = "<?xml version='1.0' encoding='UTF-8'?>\n";
+  string xml;
+  markup = "";
 
   if(type == TypeBsx) {
-    xml.append("<cartridge/>");
-    xmlMemoryMap = xml.transform("'", "\"");
+    markup.append("cartridge");
     return;
   }
 
   if(type == TypeSufamiTurbo) {
-    xml.append("<cartridge/>");
-    xmlMemoryMap = xml.transform("'", "\"");
+    markup.append("cartridge");
     return;
   }
 
   if(type == TypeGameBoy) {
-    xml.append("<cartridge rtc='", gameboy_has_rtc(data, size), "'>\n");
+    markup.append("cartridge rtc=", gameboy_has_rtc(data, size), "\n");
     if(gameboy_ram_size(data, size) > 0) {
-      xml.append("  <ram size='0x", hex(gameboy_ram_size(data, size)), "'/>\n");
+      markup.append(T "ram size=0x", hex(gameboy_ram_size(data, size)), "\n");
     }
-    xml.append("</cartridge>\n");
-    xmlMemoryMap = xml.transform("'", "\"");
     return;
   }
 
-  xml.append("<cartridge");
-  if(region == NTSC) {
-    xml.append(" region='NTSC'");
-  } else {
-    xml.append(" region='PAL'");
-  }
-  xml.append(">\n");
+  markup.append("cartridge region=", region == NTSC ? "NTSC\n" : "PAL\n");
 
   if(type == TypeSuperGameBoy1Bios) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-7f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='80-ff:8000-ffff'/>\n");
-    xml.append("  </rom>\n");
-    xml.append("  <icd2 revision='1'>\n");
-    xml.append("    <map address='00-3f:6000-7fff'/>\n");
-    xml.append("    <map address='80-bf:6000-7fff'/>\n");
-    xml.append("  </icd2>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
+    markup.append(T "icd2 revision=1\n");
+    markup.append(T T "map address=00-3f:6000-7fff\n");
+    markup.append(T T "map address=80-bf:6000-7fff\n");
   } else if(type == TypeSuperGameBoy2Bios) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-7f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='80-ff:8000-ffff'/>\n");
-    xml.append("  </rom>\n");
-    xml.append("  <icd2 revision='2'>\n");
-    xml.append("    <map address='00-3f:6000-7fff'/>\n");
-    xml.append("    <map address='80-bf:6000-7fff'/>\n");
-    xml.append("  </icd2>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
+    markup.append(T "icd2 revision=1\n");
+    markup.append(T T "map address=00-3f:6000-7fff\n");
+    markup.append(T T "map address=80-bf:6000-7fff\n");
   } else if(has_cx4) {
-    xml.append("  <hitachidsp model='HG51B169' frequency='20000000' firmware='cx4.bin' sha256='ae8d4d1961b93421ff00b3caa1d0f0ce7783e749772a3369c36b3dbf0d37ef18'>\n");
-    xml.append("    <rom>\n");
-    xml.append("      <map mode='linear' address='00-7f:8000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='80-ff:8000-ffff'/>\n");
-    xml.append("    </rom>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:6000-7fff'/>\n");
-    xml.append("      <map address='80-bf:6000-7fff'/>\n");
-    xml.append("    </mmio>\n");
-    xml.append("  </hitachidsp>\n");
+    markup.append(T "hitachidsp model=HG51B169 frequency=20000000 firmware=cx4.bin sha256=ae8d4d1961b93421ff00b3caa1d0f0ce7783e749772a3369c36b3dbf0d37ef18\n");
+    markup.append(T T "rom\n");
+    markup.append(T T T "map mode=linear address=00-7f:8000-ffff\n");
+    markup.append(T T T "map mode=linear address=80-ff:8000-ffff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:6000-7fff\n");
+    markup.append(T T T "map address=80-bf:6000-7fff\n");
   } else if(has_spc7110) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='shadow' address='00-0f:8000-ffff'/>\n");
-    xml.append("    <map mode='shadow' address='80-bf:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='c0-cf:0000-ffff'/>\n");
-    xml.append("  </rom>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=shadow address=00-0f:8000-ffff\n");
+    markup.append(T T "map mode=shadow address=80-bf:8000-ffff\n");
+    markup.append(T T "map mode=linear address=c0-cf:0000-ffff\n");
 
-    xml.append("  <spc7110>\n");
-    xml.append("    <mcu>\n");
-    xml.append("      <map address='d0-ff:0000-ffff' offset='0x100000' size='0x", hex(size - 0x100000), "'/>\n");
-    xml.append("    </mcu>\n");
-    xml.append("    <ram size='0x", hex(ram_size), "'>\n");
-    xml.append("      <map mode='linear' address='00:6000-7fff'/>\n");
-    xml.append("      <map mode='linear' address='30:6000-7fff'/>\n");
-    xml.append("    </ram>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:4800-483f'/>\n");
-    xml.append("      <map address='80-bf:4800-483f'/>\n");
-    xml.append("    </mmio>\n");
+    markup.append(T "spc7110\n");
+    markup.append(T T "mcu\n");
+    markup.append(T T T "map address=d0-ff:0000-ffff offset=0x100000 size=0x", hex(size - 0x100000), "\n");
+    markup.append(T T "ram size=0x", hex(ram_size), "\n");
+    markup.append(T T T "map mode=linear address=00:6000-7fff\n");
+    markup.append(T T T "map mode=linear address=30:6000-7fff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:4800-483f\n");
+    markup.append(T T T "map address=80-bf:4800-483f\n");
     if(has_spc7110rtc) {
-      xml.append("    <rtc>\n");
-      xml.append("      <map address='00-3f:4840-4842'/>\n");
-      xml.append("      <map address='80-bf:4840-4842'/>\n");
-      xml.append("    </rtc>\n");
+      markup.append(T T "rtc\n");
+      markup.append(T T T "map address=00-3f:4840-4842\n");
+      markup.append(T T T "map address=80-bf:4840-4842\n");
     }
-    xml.append("    <dcu>\n");
-    xml.append("      <map address='50:0000-ffff'/>\n");
-    xml.append("    </dcu>\n");
-    xml.append("  </spc7110>\n");
+    markup.append(T T "dcu\n");
+    markup.append(T T T "map address=50:0000-ffff\n");
   } else if(mapper == LoROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-7f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='80-ff:8000-ffff'/>\n");
-    xml.append("  </rom>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
 
     if(ram_size > 0) {
-      xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-      xml.append("    <map mode='linear' address='20-3f:6000-7fff'/>\n");
-      xml.append("    <map mode='linear' address='a0-bf:6000-7fff'/>\n");
+      markup.append(T "ram size=0x", hex(ram_size), "\n");
+      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
+      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
       if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml.append("    <map mode='linear' address='70-7f:0000-7fff'/>\n");
-        xml.append("    <map mode='linear' address='f0-ff:0000-7fff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
+        markup.append(T T "map mode=linear address=f0-ff:0000-7fff\n");
       } else {
-        xml.append("    <map mode='linear' address='70-7f:0000-ffff'/>\n");
-        xml.append("    <map mode='linear' address='f0-ff:0000-ffff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
+        markup.append(T T "map mode=linear address=f0-ff:0000-ffff\n");
       }
-      xml.append("  </ram>\n");
     }
   } else if(mapper == HiROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='shadow' address='00-3f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='40-7f:0000-ffff'/>\n");
-    xml.append("    <map mode='shadow' address='80-bf:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='c0-ff:0000-ffff'/>\n");
-    xml.append("  </rom>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=shadow address=00-3f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=40-7f:0000-ffff\n");
+    markup.append(T T "map mode=shadow address=80-bf:8000-ffff\n");
+    markup.append(T T "map mode=linear address=c0-ff:0000-ffff\n");
 
     if(ram_size > 0) {
-      xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-      xml.append("    <map mode='linear' address='20-3f:6000-7fff'/>\n");
-      xml.append("    <map mode='linear' address='a0-bf:6000-7fff'/>\n");
+      markup.append(T "ram size=0x", hex(ram_size), "\n");
+      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
+      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
       if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml.append("    <map mode='linear' address='70-7f:0000-7fff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
       } else {
-        xml.append("    <map mode='linear' address='70-7f:0000-ffff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
       }
-      xml.append("  </ram>\n");
     }
   } else if(mapper == ExLoROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-3f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='40-7f:0000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='80-bf:8000-ffff'/>\n");
-    xml.append("  </rom>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-3f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=40-7f:0000-ffff\n");
+    markup.append(T T "map mode=linear address=80-bf:8000-ffff\n");
 
     if(ram_size > 0) {
-      xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-      xml.append("    <map mode='linear' address='20-3f:6000-7fff'/>\n");
-      xml.append("    <map mode='linear' address='a0-bf:6000-7fff'/>\n");
-      xml.append("    <map mode='linear' address='70-7f:0000-7fff'/>\n");
-      xml.append("  </ram>\n");
+      markup.append(T "ram size=0x", hex(ram_size), "\n");
+      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
+      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
+      markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
     }
   } else if(mapper == ExHiROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='shadow' address='00-3f:8000-ffff' offset='0x400000'/>\n");
-    xml.append("    <map mode='linear' address='40-7f:0000-ffff' offset='0x400000'/>\n");
-    xml.append("    <map mode='shadow' address='80-bf:8000-ffff' offset='0x000000'/>\n");
-    xml.append("    <map mode='linear' address='c0-ff:0000-ffff' offset='0x000000'/>\n");
-    xml.append("  </rom>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=shadow address=00-3f:8000-ffff offset=0x400000\n");
+    markup.append(T T "map mode=linear address=40-7f:0000-ffff offset=0x400000\n");
+    markup.append(T T "map mode=shadow address=80-bf:8000-ffff offset=0x000000\n");
+    markup.append(T T "map mode=linear address=c0-ff:0000-ffff offset=0x000000\n");
 
     if(ram_size > 0) {
-      xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-      xml.append("    <map mode='linear' address='20-3f:6000-7fff'/>\n");
-      xml.append("    <map mode='linear' address='a0-bf:6000-7fff'/>\n");
+      markup.append(T "ram size=0x", hex(ram_size), "\n");
+      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
+      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
       if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml.append("    <map mode='linear' address='70-7f:0000-7fff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
       } else {
-        xml.append("    <map mode='linear' address='70-7f:0000-ffff'/>\n");
+        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
       }
-      xml.append("  </ram>\n");
     }
   } else if(mapper == SuperFXROM) {
-    xml.append("  <superfx revision='2'>\n");
-    xml.append("    <rom>\n");
-    xml.append("      <map mode='linear' address='00-3f:8000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='40-5f:0000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='80-bf:8000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='c0-df:0000-ffff'/>\n");
-    xml.append("    </rom>\n");
-    xml.append("    <ram size='0x", hex(ram_size), "'>\n");
-    xml.append("      <map mode='linear' address='00-3f:6000-7fff' size='0x2000'/>\n");
-    xml.append("      <map mode='linear' address='60-7f:0000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='80-bf:6000-7fff' size='0x2000'/>\n");
-    xml.append("      <map mode='linear' address='e0-ff:0000-ffff'/>\n");
-    xml.append("    </ram>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:3000-32ff'/>\n");
-    xml.append("      <map address='80-bf:3000-32ff'/>\n");
-    xml.append("    </mmio>\n");
-    xml.append("  </superfx>\n");
+    markup.append(T "superfx revision=2\n");
+    markup.append(T T "rom\n");
+    markup.append(T T T "map mode=linear address=00-3f:8000-ffff\n");
+    markup.append(T T T "map mode=linear address=40-5f:0000-ffff\n");
+    markup.append(T T T "map mode=linear address=80-bf:8000-ffff\n");
+    markup.append(T T T "map mode=linear address=c0-df:0000-ffff\n");
+    markup.append(T T "ram size=0x", hex(ram_size), "\n");
+    markup.append(T T T "map mode=linear address=00-3f:6000-7fff size=0x2000\n");
+    markup.append(T T T "map mode=linear address=60-7f:0000-ffff\n");
+    markup.append(T T T "map mode=linear address=80-bf:6000-7fff size=0x2000\n");
+    markup.append(T T T "map mode=linear address=e0-ff:0000-ffff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:3000-32ff\n");
+    markup.append(T T T "map address=80-bf:3000-32ff\n");
   } else if(mapper == SA1ROM) {
-    xml.append("  <sa1>\n");
-    xml.append("    <mcu>\n");
-    xml.append("      <rom>\n");
-    xml.append("        <map mode='direct' address='00-3f:8000-ffff'/>\n");
-    xml.append("        <map mode='direct' address='80-bf:8000-ffff'/>\n");
-    xml.append("        <map mode='direct' address='c0-ff:0000-ffff'/>\n");
-    xml.append("      </rom>\n");
-    xml.append("      <ram>\n");
-    xml.append("        <map mode='direct' address='00-3f:6000-7fff'/>\n");
-    xml.append("        <map mode='direct' address='80-bf:6000-7fff'/>\n");
-    xml.append("      </ram>\n");
-    xml.append("    </mcu>\n");
-    xml.append("    <iram size='0x800'>\n");
-    xml.append("      <map mode='linear' address='00-3f:3000-37ff'/>\n");
-    xml.append("      <map mode='linear' address='80-bf:3000-37ff'/>\n");
-    xml.append("    </iram>\n");
-    xml.append("    <bwram size='0x", hex(ram_size), "'>\n");
-    xml.append("      <map mode='linear' address='40-4f:0000-ffff'/>\n");
-    xml.append("    </bwram>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:2200-23ff'/>\n");
-    xml.append("      <map address='80-bf:2200-23ff'/>\n");
-    xml.append("    </mmio>\n");
-    xml.append("  </sa1>\n");
+    markup.append(T "sa1\n");
+    markup.append(T T "mcu\n");
+    markup.append(T T T "rom\n");
+    markup.append(T T T T "map mode=direct address=00-3f:8000-ffff\n");
+    markup.append(T T T T "map mode=direct address=80-bf:8000-ffff\n");
+    markup.append(T T T T "map mode=direct address=c0-ff:0000-ffff\n");
+    markup.append(T T T "ram\n");
+    markup.append(T T T T "map mode=direct address=00-3f:6000-7fff\n");
+    markup.append(T T T T "map mode=direct address=80-bf:6000-7fff\n");
+    markup.append(T T "iram size=0x800\n");
+    markup.append(T T T "map mode=linear address=00-3f:3000-37ff\n");
+    markup.append(T T T "map mode=linear address=80-bf:3000-37ff\n");
+    markup.append(T T "bwram size=0x", hex(ram_size), "\n");
+    markup.append(T T T "map mode=linear address=40-4f:0000-ffff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:2200-23ff\n");
+    markup.append(T T T "map address=80-bf:2200-23ff\n");
   } else if(mapper == BSCLoROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-1f:8000-ffff' offset='0x000000'/>\n");
-    xml.append("    <map mode='linear' address='20-3f:8000-ffff' offset='0x100000'/>\n");
-    xml.append("    <map mode='linear' address='80-9f:8000-ffff' offset='0x200000'/>\n");
-    xml.append("    <map mode='linear' address='a0-bf:8000-ffff' offset='0x100000'/>\n");
-    xml.append("  </rom>\n");
-    xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-    xml.append("    <map mode='linear' address='70-7f:0000-7fff'/>\n");
-    xml.append("    <map mode='linear' address='f0-ff:0000-7fff'/>\n");
-    xml.append("  </ram>\n");
-    xml.append("  <bsx>\n");
-    xml.append("    <slot>\n");
-    xml.append("      <map mode='linear' address='c0-ef:0000-ffff'/>\n");
-    xml.append("    </slot>\n");
-    xml.append("  </bsx>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-1f:8000-ffff offset=0x000000\n");
+    markup.append(T T "map mode=linear address=20-3f:8000-ffff offset=0x100000\n");
+    markup.append(T T "map mode=linear address=80-9f:8000-ffff offset=0x200000\n");
+    markup.append(T T "map mode=linear address=a0-bf:8000-ffff offset=0x100000\n");
+    markup.append(T "ram size=0x", hex(ram_size), "\n");
+    markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
+    markup.append(T T "map mode=linear address=f0-ff:0000-7fff\n");
+    markup.append(T "bsx\n");
+    markup.append(T T "slot\n");
+    markup.append(T T T "map mode=linear address=c0-ef:0000-ffff\n");
   } else if(mapper == BSCHiROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='shadow' address='00-1f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='40-5f:0000-ffff'/>\n");
-    xml.append("    <map mode='shadow' address='80-9f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='c0-df:0000-ffff'/>\n");
-    xml.append("  </rom>\n");
-    xml.append("  <ram size='0x", hex(ram_size), "'>\n");
-    xml.append("    <map mode='linear' address='20-3f:6000-7fff'/>\n");
-    xml.append("    <map mode='linear' address='a0-bf:6000-7fff'/>\n");
-    xml.append("  </ram>\n");
-    xml.append("  <bsx>\n");
-    xml.append("    <slot>\n");
-    xml.append("      <map mode='shadow' address='20-3f:8000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='60-7f:0000-ffff'/>\n");
-    xml.append("      <map mode='shadow' address='a0-bf:8000-ffff'/>\n");
-    xml.append("      <map mode='linear' address='e0-ff:0000-ffff'/>\n");
-    xml.append("    </slot>\n");
-    xml.append("  </bsx>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=shadow address=00-1f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=40-5f:0000-ffff\n");
+    markup.append(T T "map mode=shadow address=80-9f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=c0-df:0000-ffff\n");
+    markup.append(T "ram size=0x", hex(ram_size), "\n");
+    markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
+    markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
+    markup.append(T "bsx\n");
+    markup.append(T T "slot\n");
+    markup.append(T T T "map mode=shadow address=20-3f:8000-ffff\n");
+    markup.append(T T T "map mode=linear address=60-7f:0000-ffff\n");
+    markup.append(T T T "map mode=shadow address=a0-bf:8000-ffff\n");
+    markup.append(T T T "map mode=linear address=e0-ff:0000-ffff\n");
   } else if(mapper == BSXROM) {
-    xml.append("  <bsx>\n");
-    xml.append("    <mcu>\n");
-    xml.append("      <map address='00-3f:8000-ffff'/>\n");
-    xml.append("      <map address='80-bf:8000-ffff'/>\n");
-    xml.append("      <map address='40-7f:0000-ffff'/>\n");
-    xml.append("      <map address='c0-ff:0000-ffff'/>\n");
-    xml.append("      <map address='20-3f:6000-7fff'/>\n");
-    xml.append("    </mcu>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:5000-5fff'/>\n");
-    xml.append("      <map address='80-bf:5000-5fff'/>\n");
-    xml.append("    </mmio>\n");
-    xml.append("  </bsx>\n");
+    markup.append(T "bsx\n");
+    markup.append(T T "mcu\n");
+    markup.append(T T T "map address=00-3f:8000-ffff\n");
+    markup.append(T T T "map address=80-bf:8000-ffff\n");
+    markup.append(T T T "map address=40-7f:0000-ffff\n");
+    markup.append(T T T "map address=c0-ff:0000-ffff\n");
+    markup.append(T T T "map address=20-3f:6000-7fff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:5000-5fff\n");
+    markup.append(T T T "map address=80-bf:5000-5fff\n");
   } else if(mapper == STROM) {
-    xml.append("  <rom>\n");
-    xml.append("    <map mode='linear' address='00-1f:8000-ffff'/>\n");
-    xml.append("    <map mode='linear' address='80-9f:8000-ffff'/>\n");
-    xml.append("  </rom>\n");
-    xml.append("  <sufamiturbo>\n");
-    xml.append("    <slot id='A'>\n");
-    xml.append("      <rom>\n");
-    xml.append("        <map mode='linear' address='20-3f:8000-ffff'/>\n");
-    xml.append("        <map mode='linear' address='a0-bf:8000-ffff'/>\n");
-    xml.append("      </rom>\n");
-    xml.append("      <ram size='0x20000'>\n");
-    xml.append("        <map mode='linear' address='60-63:8000-ffff'/>\n");
-    xml.append("        <map mode='linear' address='e0-e3:8000-ffff'/>\n");
-    xml.append("      </ram>\n");
-    xml.append("    </slot>\n");
-    xml.append("    <slot id='B'>\n");
-    xml.append("      <rom>\n");
-    xml.append("        <map mode='linear' address='40-5f:8000-ffff'/>\n");
-    xml.append("        <map mode='linear' address='c0-df:8000-ffff'/>\n");
-    xml.append("      </rom>\n");
-    xml.append("      <ram size='0x20000'>\n");
-    xml.append("        <map mode='linear' address='70-73:8000-ffff'/>\n");
-    xml.append("        <map mode='linear' address='f0-f3:8000-ffff'/>\n");
-    xml.append("      </ram>\n");
-    xml.append("    </slot>\n");
-    xml.append("  </sufamiturbo>\n");
+    markup.append(T "rom\n");
+    markup.append(T T "map mode=linear address=00-1f:8000-ffff\n");
+    markup.append(T T "map mode=linear address=80-9f:8000-ffff\n");
+    markup.append(T "sufamiturbo\n");
+    markup.append(T T "slot id=A\n");
+    markup.append(T T T "rom\n");
+    markup.append(T T T T "map mode=linear address=20-3f:8000-ffff\n");
+    markup.append(T T T T "map mode=linear address=a0-bf:8000-ffff\n");
+    markup.append(T T T "ram size=0x20000\n");
+    markup.append(T T T T "map mode=linear address=60-63:8000-ffff\n");
+    markup.append(T T T T "map mode=linear address=e0-e3:8000-ffff\n");
+    markup.append(T T "slot id=B\n");
+    markup.append(T T T "rom\n");
+    markup.append(T T T T "map mode=linear address=40-5f:8000-ffff\n");
+    markup.append(T T T T "map mode=linear address=c0-df:8000-ffff\n");
+    markup.append(T T T "ram size=0x20000\n");
+    markup.append(T T T T "map mode=linear address=70-73:8000-ffff\n");
+    markup.append(T T T T "map mode=linear address=f0-f3:8000-ffff\n");
   }
 
   if(has_srtc) {
-    xml.append("  <srtc>\n");
-    xml.append("    <map address='00-3f:2800-2801'/>\n");
-    xml.append("    <map address='80-bf:2800-2801'/>\n");
-    xml.append("  </srtc>\n");
+    markup.append(T "srtc\n");
+    markup.append(T T "map address=00-3f:2800-2801\n");
+    markup.append(T T "map address=80-bf:2800-2801\n");
   }
 
   if(has_sdd1) {
-    xml.append("  <sdd1>\n");
-    xml.append("    <mcu>\n");
-    xml.append("      <map address='c0-ff:0000-ffff'/>\n");
-    xml.append("    </mcu>\n");
-    xml.append("    <mmio>\n");
-    xml.append("      <map address='00-3f:4800-4807'/>\n");
-    xml.append("      <map address='80-bf:4800-4807'/>\n");
-    xml.append("    </mmio>\n");
-    xml.append("  </sdd1>\n");
+    markup.append(T "sdd1\n");
+    markup.append(T T "mcu\n");
+    markup.append(T T T "map address=c0-ff:0000-ffff\n");
+    markup.append(T T "mmio\n");
+    markup.append(T T T "map address=00-3f:4800-4807\n");
+    markup.append(T T T "map address=80-bf:4800-4807\n");
   }
 
   if(has_dsp1) {
-    xml.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp1b.bin' sha256='4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c'>\n");
+    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp1b.bin sha256=4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c\n");
     if(dsp1_mapper == DSP1LoROM1MB) {
-      xml.append("    <dr>\n");
-      xml.append("      <map address='20-3f:8000-bfff'/>\n");
-      xml.append("      <map address='a0-bf:8000-bfff'/>\n");
-      xml.append("    </dr>\n");
-      xml.append("    <sr>\n");
-      xml.append("      <map address='20-3f:c000-ffff'/>\n");
-      xml.append("      <map address='a0-bf:c000-ffff'/>\n");
-      xml.append("    </sr>\n");
+      markup.append(T T "dr\n");
+      markup.append(T T T "map address=20-3f:8000-bfff\n");
+      markup.append(T T T "map address=a0-bf:8000-bfff\n");
+      markup.append(T T "sr\n");
+      markup.append(T T T "map address=20-3f:c000-ffff\n");
+      markup.append(T T T "map address=a0-bf:c000-ffff\n");
     } else if(dsp1_mapper == DSP1LoROM2MB) {
-      xml.append("    <dr>\n");
-      xml.append("      <map address='60-6f:0000-3fff'/>\n");
-      xml.append("      <map address='e0-ef:0000-3fff'/>\n");
-      xml.append("    </dr>\n");
-      xml.append("    <sr>\n");
-      xml.append("      <map address='60-6f:4000-7fff'/>\n");
-      xml.append("      <map address='e0-ef:4000-7fff'/>\n");
-      xml.append("    </sr>\n");
+      markup.append(T T "dr\n");
+      markup.append(T T T "map address=60-6f:0000-3fff\n");
+      markup.append(T T T "map address=e0-ef:0000-3fff\n");
+      markup.append(T T "sr\n");
+      markup.append(T T T "map address=60-6f:4000-7fff\n");
+      markup.append(T T T "map address=e0-ef:4000-7fff\n");
     } else if(dsp1_mapper == DSP1HiROM) {
-      xml.append("    <dr>\n");
-      xml.append("      <map address='00-1f:6000-6fff'/>\n");
-      xml.append("      <map address='80-9f:6000-6fff'/>\n");
-      xml.append("    </dr>\n");
-      xml.append("    <sr>\n");
-      xml.append("      <map address='00-1f:7000-7fff'/>\n");
-      xml.append("      <map address='80-9f:7000-7fff'/>\n");
-      xml.append("    </sr>\n");
+      markup.append(T T "dr\n");
+      markup.append(T T T "map address=00-1f:6000-6fff\n");
+      markup.append(T T T "map address=80-9f:6000-6fff\n");
+      markup.append(T T "sr\n");
+      markup.append(T T T "map address=00-1f:7000-7fff\n");
+      markup.append(T T T "map address=80-9f:7000-7fff\n");
     }
-    xml.append("  </necdsp>\n");
   }
 
   if(has_dsp2) {
-    xml.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp2.bin' sha256='5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1'>\n");
-    xml.append("    <dr>\n");
-    xml.append("      <map address='20-3f:8000-bfff'/>\n");
-    xml.append("      <map address='a0-bf:8000-bfff'/>\n");
-    xml.append("    </dr>\n");
-    xml.append("    <sr>\n");
-    xml.append("      <map address='20-3f:c000-ffff'/>\n");
-    xml.append("      <map address='a0-bf:c000-ffff'/>\n");
-    xml.append("    </sr>\n");
-    xml.append("  </necdsp>\n");
+    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp2.bin sha256=5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1\n");
+    markup.append(T T "dr\n");
+    markup.append(T T T "map address=20-3f:8000-bfff\n");
+    markup.append(T T T "map address=a0-bf:8000-bfff\n");
+    markup.append(T T "sr\n");
+    markup.append(T T T "map address=20-3f:c000-ffff\n");
+    markup.append(T T T "map address=a0-bf:c000-ffff\n");
   }
 
   if(has_dsp3) {
-    xml.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp3.bin' sha256='2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90'>\n");
-    xml.append("    <dr>\n");
-    xml.append("      <map address='20-3f:8000-bfff'/>\n");
-    xml.append("      <map address='a0-bf:8000-bfff'/>\n");
-    xml.append("    </dr>\n");
-    xml.append("    <sr>\n");
-    xml.append("      <map address='20-3f:c000-ffff'/>\n");
-    xml.append("      <map address='a0-bf:c000-ffff'/>\n");
-    xml.append("    </sr>\n");
-    xml.append("  </necdsp>\n");
+    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp3.bin sha256=2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90\n");
+    markup.append(T T "dr\n");
+    markup.append(T T T "map address=20-3f:8000-bfff\n");
+    markup.append(T T T "map address=a0-bf:8000-bfff\n");
+    markup.append(T T "sr\n");
+    markup.append(T T T "map address=20-3f:c000-ffff\n");
+    markup.append(T T T "map address=a0-bf:c000-ffff\n");
   }
 
   if(has_dsp4) {
-    xml.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp4.bin' sha256='63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a'>\n");
-    xml.append("    <dr>\n");
-    xml.append("      <map address='30-3f:8000-bfff'/>\n");
-    xml.append("      <map address='b0-bf:8000-bfff'/>\n");
-    xml.append("    </dr>\n");
-    xml.append("    <sr>\n");
-    xml.append("      <map address='30-3f:c000-ffff'/>\n");
-    xml.append("      <map address='b0-bf:c000-ffff'/>\n");
-    xml.append("    </sr>\n");
-    xml.append("  </necdsp>\n");
+    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp4.bin sha256=63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a\n");
+    markup.append(T T "dr\n");
+    markup.append(T T T "map address=30-3f:8000-bfff\n");
+    markup.append(T T T "map address=b0-bf:8000-bfff\n");
+    markup.append(T T "sr\n");
+    markup.append(T T T "map address=30-3f:c000-ffff\n");
+    markup.append(T T T "map address=b0-bf:c000-ffff\n");
   }
 
   if(has_obc1) {
-    xml.append("  <obc1>\n");
-    xml.append("    <map address='00-3f:6000-7fff'/>\n");
-    xml.append("    <map address='80-bf:6000-7fff'/>\n");
-    xml.append("  </obc1>\n");
+    markup.append(T "obc1\n");
+    markup.append(T T "map address=00-3f:6000-7fff\n");
+    markup.append(T T "map address=80-bf:6000-7fff\n");
   }
 
   if(has_st010) {
-    xml.append("  <necdsp model='uPD96050' frequency='10000000' firmware='st0010.bin' sha256='55c697e864562445621cdf8a7bf6e84ae91361e393d382a3704e9aa55559041e'>\n");
-    xml.append("    <dr>\n");
-    xml.append("      <map address='60:0000'/>\n");
-    xml.append("      <map address='e0:0000'/>\n");
-    xml.append("    </dr>\n");
-    xml.append("    <sr>\n");
-    xml.append("      <map address='60:0001'/>\n");
-    xml.append("      <map address='e0:0001'/>\n");
-    xml.append("    </sr>\n");
-    xml.append("    <dp>\n");
-    xml.append("      <map address='68-6f:0000-0fff'/>\n");
-    xml.append("      <map address='e8-ef:0000-0fff'/>\n");
-    xml.append("    </dp>\n");
-    xml.append("  </necdsp>\n");
+    markup.append(T "necdsp model=uPD96050 frequency=10000000 firmware=st0010.bin sha256=55c697e864562445621cdf8a7bf6e84ae91361e393d382a3704e9aa55559041e\n");
+    markup.append(T T "dr\n");
+    markup.append(T T T "map address=60:0000\n");
+    markup.append(T T T "map address=e0:0000\n");
+    markup.append(T T "sr\n");
+    markup.append(T T T "map address=60:0001\n");
+    markup.append(T T T "map address=e0:0001\n");
+    markup.append(T T "dp\n");
+    markup.append(T T T "map address=68-6f:0000-0fff\n");
+    markup.append(T T T "map address=e8-ef:0000-0fff\n");
   }
 
   if(has_st011) {
-    xml.append("  <necdsp model='uPD96050' frequency='15000000' firmware='st0011.bin' sha256='651b82a1e26c4fa8dd549e91e7f923012ed2ca54c1d9fd858655ab30679c2f0e'>\n");
-    xml.append("    <dr>\n");
-    xml.append("      <map address='60:0000'/>\n");
-    xml.append("      <map address='e0:0000'/>\n");
-    xml.append("    </dr>\n");
-    xml.append("    <sr>\n");
-    xml.append("      <map address='60:0001'/>\n");
-    xml.append("      <map address='e0:0001'/>\n");
-    xml.append("    </sr>\n");
-    xml.append("    <dp>\n");
-    xml.append("      <map address='68-6f:0000-0fff'/>\n");
-    xml.append("      <map address='e8-ef:0000-0fff'/>\n");
-    xml.append("    </dp>\n");
-    xml.append("  </necdsp>\n");
+    markup.append(T "necdsp model=uPD96050 frequency=15000000 firmware=st0011.bin sha256=651b82a1e26c4fa8dd549e91e7f923012ed2ca54c1d9fd858655ab30679c2f0e\n");
+    markup.append(T T "dr\n");
+    markup.append(T T T "map address=60:0000\n");
+    markup.append(T T T "map address=e0:0000\n");
+    markup.append(T T "sr\n");
+    markup.append(T T T "map address=60:0001\n");
+    markup.append(T T T "map address=e0:0001\n");
+    markup.append(T T "dp\n");
+    markup.append(T T T "map address=68-6f:0000-0fff\n");
+    markup.append(T T T "map address=e8-ef:0000-0fff\n");
   }
 
   if(has_st018) {
-    xml.append("  <setarisc firmware='ST-0018'>\n");
-    xml.append("    <map address='00-3f:3800-38ff'/>\n");
-    xml.append("    <map address='80-bf:3800-38ff'/>\n");
-    xml.append("  </setarisc>\n");
+    markup.append(T "setarisc firmware=ST-0018\n");
+    markup.append(T T "map address=00-3f:3800-38ff\n");
+    markup.append(T T "map address=80-bf:3800-38ff\n");
   }
-
-  xml.append("</cartridge>\n");
-  xmlMemoryMap = xml.transform("'", "\"");
 }
 
-void SNESCartridge::read_header(const uint8_t *data, unsigned size) {
+#undef T
+
+void SnesCartridge::read_header(const uint8_t *data, unsigned size) {
   type        = TypeUnknown;
   mapper      = LoROM;
   dsp1_mapper = DSP1Unmapped;
@@ -762,7 +672,7 @@ void SNESCartridge::read_header(const uint8_t *data, unsigned size) {
   }
 }
 
-unsigned SNESCartridge::find_header(const uint8_t *data, unsigned size) {
+unsigned SnesCartridge::find_header(const uint8_t *data, unsigned size) {
   unsigned score_lo = score_header(data, size, 0x007fc0);
   unsigned score_hi = score_header(data, size, 0x00ffc0);
   unsigned score_ex = score_header(data, size, 0x40ffc0);
@@ -777,7 +687,7 @@ unsigned SNESCartridge::find_header(const uint8_t *data, unsigned size) {
   }
 }
 
-unsigned SNESCartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) {
+unsigned SnesCartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) {
   if(size < addr + 64) return 0;  //image too small to contain header at this location?
   int score = 0;
 
@@ -858,7 +768,7 @@ unsigned SNESCartridge::score_header(const uint8_t *data, unsigned size, unsigne
   return score;
 }
 
-unsigned SNESCartridge::gameboy_ram_size(const uint8_t *data, unsigned size) {
+unsigned SnesCartridge::gameboy_ram_size(const uint8_t *data, unsigned size) {
   if(size < 512) return 0;
   switch(data[0x0149]) {
     case 0x00: return   0 * 1024;
@@ -871,7 +781,7 @@ unsigned SNESCartridge::gameboy_ram_size(const uint8_t *data, unsigned size) {
   }
 }
 
-bool SNESCartridge::gameboy_has_rtc(const uint8_t *data, unsigned size) {
+bool SnesCartridge::gameboy_has_rtc(const uint8_t *data, unsigned size) {
   if(size < 512) return false;
   if(data[0x0147] == 0x0f ||data[0x0147] == 0x10) return true;
   return false;

bsnes/nall/stack.hpp

@@ -1,7 +1,6 @@
 #ifndef NALL_STACK_HPP
 #define NALL_STACK_HPP
 
-#include <nall/concept.hpp>
 #include <nall/vector.hpp>
 
 namespace nall {
@@ -22,8 +21,6 @@ namespace nall {
       return linear_vector<T>::operator[](linear_vector<T>::size() - 1);
     }
   };
-
-  template<typename T> struct has_size<stack<T>> { enum { value = true }; };
 }
 
 #endif

bsnes/nall/string.hpp

@@ -1,18 +1,34 @@
 #ifndef NALL_STRING_HPP
 #define NALL_STRING_HPP
 
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
 #include <initializer_list>
+
 #include <nall/array.hpp>
+#include <nall/atoi.hpp>
+#include <nall/function.hpp>
 #include <nall/platform.hpp>
 #include <nall/sha256.hpp>
+#include <nall/stdint.hpp>
 #include <nall/utility.hpp>
+#include <nall/vector.hpp>
 
+#include <nall/windows/utf8.hpp>
+
+#define NALL_STRING_INTERNAL_HPP
 #include <nall/string/base.hpp>
+#include <nall/string/bml.hpp>
 #include <nall/string/bsv.hpp>
 #include <nall/string/core.hpp>
 #include <nall/string/cast.hpp>
 #include <nall/string/compare.hpp>
 #include <nall/string/convert.hpp>
+#include <nall/string/cstring.hpp>
 #include <nall/string/filename.hpp>
 #include <nall/string/math.hpp>
 #include <nall/string/platform.hpp>
@@ -25,10 +41,6 @@
 #include <nall/string/variadic.hpp>
 #include <nall/string/wrapper.hpp>
 #include <nall/string/xml.hpp>
-
-namespace nall {
-  template<> struct has_length<string> { enum { value = true }; };
-  template<> struct has_size<lstring> { enum { value = true }; };
-}
+#undef NALL_STRING_INTERNAL_HPP
 
 #endif

bsnes/nall/string/base.hpp

@@ -1,23 +1,27 @@
-#ifndef NALL_STRING_BASE_HPP
-#define NALL_STRING_BASE_HPP
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <nall/concept.hpp>
-#include <nall/function.hpp>
-#include <nall/stdint.hpp>
-#include <nall/vector.hpp>
-#include <nall/windows/utf8.hpp>
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
-  class string;
-  class lstring;
+  struct cstring;
+  struct string;
+  struct lstring;
   template<typename T> inline const char* to_string(T);
 
-  class string {
-  public:
+  struct cstring {
+    inline operator const char*() const;
+    inline unsigned length() const;
+    inline bool operator==(const char*) const;
+    inline bool operator!=(const char*) const;
+    inline optional<unsigned> position(const char *key) const;
+    inline optional<unsigned> iposition(const char *key) const;
+    inline cstring& operator=(const char *data);
+    inline cstring(const char *data);
+    inline cstring();
+
+  protected:
+    const char *data;
+  };
+
+  struct string {
     inline void reserve(unsigned);
 
     template<typename... Args> inline string& assign(Args&&... args);
@@ -77,6 +81,11 @@ namespace nall {
     inline string(string&&);
     inline ~string();
 
+    inline char* begin() { return &data[0]; }
+    inline char* end() { return &data[length()]; }
+    inline const char* begin() const { return &data[0]; }
+    inline const char* end() const { return &data[length()]; }
+
     //internal functions
     inline string& assign_(const char*);
     inline string& append_(const char*);
@@ -93,8 +102,7 @@ namespace nall {
   #endif
   };
 
-  class lstring : public linear_vector<string> {
-  public:
+  struct lstring : public linear_vector<string> {
     template<typename T> inline lstring& operator<<(T value);
 
     inline optional<unsigned> find(const char*) const;
@@ -103,8 +111,11 @@ namespace nall {
     template<unsigned Limit = 0> inline lstring& qsplit(const char*, const char*);
     template<unsigned Limit = 0> inline lstring& iqsplit(const char*, const char*);
 
-    lstring();
-    lstring(std::initializer_list<string>);
+    inline bool operator==(const lstring&) const;
+    inline bool operator!=(const lstring&) const;
+
+    inline lstring();
+    inline lstring(std::initializer_list<string>);
 
   protected:
     template<unsigned Limit, bool Insensitive, bool Quoted> inline lstring& usplit(const char*, const char*);
@@ -127,11 +138,6 @@ namespace nall {
   inline char* qstrlower(char *str);
   inline char* qstrupper(char *str);
   inline char* strtr(char *dest, const char *before, const char *after);
-  inline uintmax_t hex(const char *str);
-  inline intmax_t integer(const char *str);
-  inline uintmax_t decimal(const char *str);
-  inline uintmax_t binary(const char *str);
-  inline double fp(const char *str);
 
   //math.hpp
   inline bool strint(const char *str, int &result);

bsnes/nall/string/bml.hpp

@@ -0,0 +1,151 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+//BML v1.0 parser
+//revision 0.05
+
+namespace nall {
+namespace BML {
+
+inline static string indent(const char *s, unsigned depth) {
+  array<char> output;
+  do {
+    for(unsigned n = 0; n < depth; n++) output.append('\t');
+    do output.append(*s); while(*s && *s++ != '\n');
+  } while(*s);
+  return output.get();
+}
+
+struct Node {
+  cstring name;
+  cstring value;
+
+private:
+  linear_vector<Node> children;
+
+  inline bool valid(char p) const {  //A-Za-z0-9-.
+    return p - 'A' < 26u | p - 'a' < 26u | p - '0' < 10u | p - '-' < 2u;
+  }
+
+  inline unsigned parseDepth(char *&p) {
+    while(*p == '\n' || *p == '#') {
+      while(*p != '\n') *p++ = 0;
+      *p++ = 0;  //'\n'
+    }
+    unsigned depth = 0;
+    while(p[depth] == '\t') depth++;
+    return depth;
+  }
+
+  inline void parseName(char *&p) {
+    if(valid(*p) == false) throw "Missing node name";
+    name = p;
+    while(valid(*p)) p++;
+  }
+
+  inline void parseValue(char *&p) {
+    char terminal = *p == ':' ? '\n' : ' ';  //':' or '='
+    *p++ = 0;
+    value = p;
+    while(*p && *p != terminal && *p != '\n') p++;
+  }
+
+  inline void parseBlock(char *&p, unsigned depth) {
+    value = p;
+    char *w = p;
+    while(parseDepth(p) > depth) {
+      p += depth + 1;
+      while(*p && *p != '\n') *w++ = *p++;
+      if(*p && *p != '\n') throw "Multi-line value missing line feed";
+      *w++ = *p;
+    }
+    *(w - 1) = 0;  //'\n'
+  }
+
+  inline void parseLine(char *&p) {
+    unsigned depth = parseDepth(p);
+    while(*p == '\t') p++;
+
+    parseName(p);
+    bool multiLine = *p == '~';
+    if(multiLine) *p++ = 0;
+    else if(*p == ':' || *p == '=') parseValue(p);
+    if(*p && *p != ' ' && *p != '\n') throw "Invalid character encountered";
+
+    while(*p == ' ') {
+      *p++ = 0;
+      Node node;
+      node.parseName(p);
+      if(*p == ':' || *p == '=') node.parseValue(p);
+      if(*p && *p != ' ' && *p != '\n') throw "Invalid character after node";
+      if(*p == '\n') *p++ = 0;
+      children.append(node);
+    }
+
+    if(multiLine) return parseBlock(p, depth);
+
+    while(parseDepth(p) > depth) {
+      Node node;
+      node.parseLine(p);
+      children.append(node);
+    }
+  }
+
+  inline void parse(char *&p) {
+    while(*p) {
+      Node node;
+      node.parseLine(p);
+      children.append(node);
+    }
+  }
+
+public:
+  inline Node& operator[](const char *name) {
+    for(auto &node : children) {
+      if(node.name == name) return node;
+    }
+    static Node node;
+    node.name = nullptr;
+    return node;
+  }
+
+  inline bool exists() const { return name; }
+  unsigned size() const { return children.size(); }
+  Node* begin() { return children.begin(); }
+  Node* end() { return children.end(); }
+  const Node* begin() const { return children.begin(); }
+  const Node* end() const { return children.end(); }
+  inline Node() : name(""), value("") {}
+  friend class Document;
+};
+
+struct Document : Node {
+  cstring error;
+
+  inline bool load(const char *document) {
+    if(document == nullptr) return false;
+    this->document = strdup(document);
+    char *p = this->document;
+    try {
+      this->error = nullptr;
+      parse(p);
+    } catch(const char *error) {
+      this->error = error;
+      free(this->document);
+      this->document = nullptr;
+      children.reset();
+      return false;
+    }
+    return true;
+  }
+
+  inline Document(const char *document = "") : document(nullptr), error(nullptr) { if(*document) load(document); }
+  inline ~Document() { if(document) free(document); }
+
+private:
+  char *document;
+};
+
+}
+}
+
+#endif

bsnes/nall/string/bsv.hpp

@@ -1,74 +1,75 @@
-#ifndef NALL_STRING_BSV_HPP
-#define NALL_STRING_BSV_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
-//BSV parser
-//version 0.01
+//BSV v1.0 parser
+//revision 0.02
 
 namespace nall {
 
-inline string bsv_decode(const char *input) {
-  string output;
-  unsigned offset = 0;
-  while(*input) {
-    //illegal characters
-    if(*input == '}' ) return "";
-    if(*input == '\r') return "";
-    if(*input == '\n') return "";
+struct BSV {
+  static inline string decode(const char *input) {
+    string output;
+    unsigned offset = 0;
+    while(*input) {
+      //illegal characters
+      if(*input == '}' ) return "";
+      if(*input == '\r') return "";
+      if(*input == '\n') return "";
 
-    //normal characters
-    if(*input != '{') { output[offset++] = *input++;  continue; }
+      //normal characters
+      if(*input != '{') { output[offset++] = *input++;  continue; }
 
-    //entities
-    if(strbegin(input, "{lf}")) { output[offset++] = '\n'; input += 4; continue; }
-    if(strbegin(input, "{lb}")) { output[offset++] = '{';  input += 4; continue; }
-    if(strbegin(input, "{rb}")) { output[offset++] = '}';  input += 4; continue; }
+      //entities
+      if(strbegin(input, "{lf}")) { output[offset++] = '\n'; input += 4; continue; }
+      if(strbegin(input, "{lb}")) { output[offset++] = '{';  input += 4; continue; }
+      if(strbegin(input, "{rb}")) { output[offset++] = '}';  input += 4; continue; }
 
-    //illegal entities
-    return "";
+      //illegal entities
+      return "";
+    }
+    output[offset] = 0;
+    return output;
   }
-  output[offset] = 0;
-  return output;
-}
 
-inline string bsv_encode(const char *input) {
-  string output;
-  unsigned offset = 0;
-  while(*input) {
-    //illegal characters
-    if(*input == '\r') return "";
+  static inline string encode(const char *input) {
+    string output;
+    unsigned offset = 0;
+    while(*input) {
+      //illegal characters
+      if(*input == '\r') return "";
 
-    if(*input == '\n') {
-      output[offset++] = '{';
-      output[offset++] = 'l';
-      output[offset++] = 'f';
-      output[offset++] = '}';
-      input++;
-      continue;
+      if(*input == '\n') {
+        output[offset++] = '{';
+        output[offset++] = 'l';
+        output[offset++] = 'f';
+        output[offset++] = '}';
+        input++;
+        continue;
+      }
+
+      if(*input == '{') {
+        output[offset++] = '{';
+        output[offset++] = 'l';
+        output[offset++] = 'b';
+        output[offset++] = '}';
+        input++;
+        continue;
+      }
+
+      if(*input == '}') {
+        output[offset++] = '{';
+        output[offset++] = 'r';
+        output[offset++] = 'b';
+        output[offset++] = '}';
+        input++;
+        continue;
+      }
+
+      output[offset++] = *input++;
     }
-
-    if(*input == '{') {
-      output[offset++] = '{';
-      output[offset++] = 'l';
-      output[offset++] = 'b';
-      output[offset++] = '}';
-      input++;
-      continue;
-    }
-
-    if(*input == '}') {
-      output[offset++] = '{';
-      output[offset++] = 'r';
-      output[offset++] = 'b';
-      output[offset++] = '}';
-      input++;
-      continue;
-    }
-
-    output[offset++] = *input++;
+    output[offset] = 0;
+    return output;
   }
-  output[offset] = 0;
-  return output;
-}
+};
 
 }
 

bsnes/nall/string/cast.hpp

@@ -1,19 +1,20 @@
-#ifndef NALL_STRING_CAST_HPP
-#define NALL_STRING_CAST_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 
 //this is needed, as C++0x does not support explicit template specialization inside classes
-template<> inline const char* to_string<bool>         (bool v)          { return v ? "true" : "false"; }
-template<> inline const char* to_string<signed int>   (signed int v)    { static char temp[256]; snprintf(temp, 255, "%+d", v); return temp; }
-template<> inline const char* to_string<unsigned int> (unsigned int v)  { static char temp[256]; snprintf(temp, 255, "%u", v); return temp; }
-template<> inline const char* to_string<intmax_t>     (intmax_t v)      { static char temp[256]; snprintf(temp, 255, "%+lld", (long long)v); return temp; }
-template<> inline const char* to_string<uintmax_t>    (uintmax_t v)     { static char temp[256]; snprintf(temp, 255, "%llu", (unsigned long long)v); return temp; }
-template<> inline const char* to_string<double>       (double v)        { static char temp[256]; snprintf(temp, 255, "%f", v); return temp; }
-template<> inline const char* to_string<char*>        (char *v)         { return v; }
-template<> inline const char* to_string<const char*>  (const char *v)   { return v; }
-template<> inline const char* to_string<string>       (string v)        { return v; }
-template<> inline const char* to_string<const string&>(const string &v) { return v; }
+template<> inline const char* to_string<bool>          (bool v)           { return v ? "true" : "false"; }
+template<> inline const char* to_string<signed int>    (signed int v)     { static char temp[256]; snprintf(temp, 255, "%+d", v); return temp; }
+template<> inline const char* to_string<unsigned int>  (unsigned int v)   { static char temp[256]; snprintf(temp, 255, "%u", v); return temp; }
+template<> inline const char* to_string<intmax_t>      (intmax_t v)       { static char temp[256]; snprintf(temp, 255, "%+lld", (long long)v); return temp; }
+template<> inline const char* to_string<uintmax_t>     (uintmax_t v)      { static char temp[256]; snprintf(temp, 255, "%llu", (unsigned long long)v); return temp; }
+template<> inline const char* to_string<double>        (double v)         { static char temp[256]; snprintf(temp, 255, "%f", v); return temp; }
+template<> inline const char* to_string<char*>         (char *v)          { return v; }
+template<> inline const char* to_string<const char*>   (const char *v)    { return v; }
+template<> inline const char* to_string<string>        (string v)         { return v; }
+template<> inline const char* to_string<const string&> (const string &v)  { return v; }
+template<> inline const char* to_string<cstring>       (cstring v)        { return v; }
+template<> inline const char* to_string<const cstring&>(const cstring &v) { return v; }
 
 template<typename T> lstring& lstring::operator<<(T value) {
   operator[](size()).assign(to_string<T>(value));

bsnes/nall/string/compare.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_COMPARE_HPP
-#define NALL_STRING_COMPARE_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/convert.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_CONVERT_HPP
-#define NALL_STRING_CONVERT_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 
@@ -60,86 +59,6 @@ char* strtr(char *dest, const char *before, const char *after) {
   return dest;
 }
 
-uintmax_t hex(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  //skip hex identifiers 0x and $, if present
-  if(*str == '0' && (*(str + 1) == 'X' || *(str + 1) == 'x')) str += 2;
-  else if(*str == '$') str++;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else if(x >= 'A' && x <= 'F') x -= 'A' - 10;
-    else if(x >= 'a' && x <= 'f') x -= 'a' - 10;
-    else break;  //stop at first invalid character
-    result = result * 16 + x;
-  }
-
-  return result;
-}
-
-intmax_t integer(const char *str) {
-  if(!str) return 0;
-  intmax_t result = 0;
-  bool negate = false;
-
-  //check for sign
-  if(*str == '+') {
-    negate = false;
-    str++;
-  } else if(*str == '-') {
-    negate = true;
-    str++;
-  }
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 10 + x;
-  }
-
-  return !negate ? result : -result;
-}
-
-uintmax_t decimal(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 10 + x;
-  }
-
-  return result;
-}
-
-uintmax_t binary(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  //skip bin identifiers 0b and %, if present
-  if(*str == '0' && (*(str + 1) == 'B' || *(str + 1) == 'b')) str += 2;
-  else if(*str == '%') str++;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x == '0' || x == '1') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 2 + x;
-  }
-
-  return result;
-}
-
-double fp(const char *str) {
-  return atof(str);
-}
-
 }
 
 #endif

bsnes/nall/string/core.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_CORE_HPP
-#define NALL_STRING_CORE_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 
@@ -66,15 +65,17 @@ bool string::operator> (const char *str) const { return strcmp(data, str)  > 0;
 bool string::operator>=(const char *str) const { return strcmp(data, str) >= 0; }
 
 string& string::operator=(const string &value) {
+  if(&value == this) return *this;
   assign(value);
   return *this;
 }
 
 string& string::operator=(string &&source) {
+  if(&source == this) return *this;
   if(data) free(data);
   size = source.size;
   data = source.data;
-  source.data = 0;
+  source.data = nullptr;
   source.size = 0;
   return *this;
 }
@@ -87,14 +88,16 @@ template<typename... Args> string::string(Args&&... args) {
 }
 
 string::string(const string &value) {
+  if(&value == this) return;
   size = strlen(value);
   data = strdup(value);
 }
 
 string::string(string &&source) {
+  if(&source == this) return;
   size = source.size;
   data = source.data;
-  source.data = 0;
+  source.data = nullptr;
 }
 
 string::~string() {
@@ -131,6 +134,19 @@ optional<unsigned> lstring::find(const char *key) const {
   return { false, 0 };
 }
 
+bool lstring::operator==(const lstring &source) const {
+  if(this == &source) return true;
+  if(size() != source.size()) return false;
+  for(unsigned n = 0; n < size(); n++) {
+    if(operator[](n) != source[n]) return false;
+  }
+  return true;
+}
+
+bool lstring::operator!=(const lstring &source) const {
+  return !operator==(source);
+}
+
 inline lstring::lstring() {
 }
 

bsnes/nall/string/cstring.hpp

@@ -0,0 +1,21 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+//const string:
+//bind a const char* pointer to an object that has various testing functionality;
+//yet lacks the memory allocation and modification functionality of the string class
+
+namespace nall {
+
+cstring::operator const char*() const { return data; }
+unsigned cstring::length() const { return strlen(data); }
+bool cstring::operator==(const char *s) const { return !strcmp(data, s); }
+bool cstring::operator!=(const char *s) const { return  strcmp(data, s); }
+optional<unsigned> cstring::position (const char *key) const { return  strpos(data, key); }
+optional<unsigned> cstring::iposition(const char *key) const { return istrpos(data, key); }
+cstring& cstring::operator=(const char *data) { this->data = data; return *this; }
+cstring::cstring(const char *data) : data(data) {}
+cstring::cstring() : data("") {}
+
+}
+
+#endif

bsnes/nall/string/filename.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_FILENAME_HPP
-#define NALL_FILENAME_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/math.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_MATH_HPP
-#define NALL_STRING_MATH_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/platform.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_PLATFORM_HPP
-#define NALL_STRING_PLATFORM_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/replace.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_REPLACE_HPP
-#define NALL_STRING_REPLACE_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/split.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_SPLIT_HPP
-#define NALL_STRING_SPLIT_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/strl.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_STRL_HPP
-#define NALL_STRING_STRL_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/strpos.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_STRPOS_HPP
-#define NALL_STRING_STRPOS_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 //usage example:
 //if(auto position = strpos(str, key)) print(position(), "\n");

bsnes/nall/string/trim.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_TRIM_HPP
-#define NALL_STRING_TRIM_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/utility.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_UTILITY_HPP
-#define NALL_STRING_UTILITY_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 
@@ -65,7 +64,7 @@ string sha256(const uint8_t *data, unsigned size) {
   sha256_final(&sha);
   sha256_hash(&sha, hash);
   string result;
-  foreach(byte, hash) result.append(hex<2>(byte));
+  for(auto &byte : hash) result.append(hex<2>(byte));
   return result;
 }
 

bsnes/nall/string/variadic.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_VARIADIC_HPP
-#define NALL_STRING_VARIADIC_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/wrapper.hpp

@@ -1,5 +1,4 @@
-#ifndef NALL_STRING_WRAPPER_HPP
-#define NALL_STRING_WRAPPER_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
 namespace nall {
 

bsnes/nall/string/xml.hpp

@@ -1,8 +1,7 @@
-#ifndef NALL_STRING_XML_HPP
-#define NALL_STRING_XML_HPP
+#ifdef NALL_STRING_INTERNAL_HPP
 
-//XML subset parser
-//version 0.05
+//XML v1.0 subset parser
+//revision 0.05
 
 namespace nall {
 

bsnes/nall/utility.hpp

@@ -21,12 +21,14 @@ namespace nall {
   };
 
   template<typename T> class optional {
+  public:
     bool valid;
     T value;
   public:
     inline operator bool() const { return valid; }
     inline const T& operator()() const { if(!valid) throw; return value; }
     inline optional<T>& operator=(const optional<T> &source) { valid = source.valid; value = source.value; return *this; }
+    inline optional() : valid(false) {}
     inline optional(bool valid, const T &value) : valid(valid), value(value) {}
   };
 

bsnes/nall/varint.hpp

@@ -30,6 +30,9 @@ namespace nall {
 
     inline uint_t() : data(0) {}
     inline uint_t(const unsigned i) : data(uclip<bits>(i)) {}
+
+    template<int s> inline unsigned operator=(const uint_t<s> &i) { return data = uclip<bits>((unsigned)i); }
+    template<int s> inline uint_t(const uint_t<s> &i) : data(uclip<bits>(i)) {}
   };
 
   template<unsigned bits> class int_t {

bsnes/nall/vector.hpp

@@ -1,14 +1,13 @@
 #ifndef NALL_VECTOR_HPP
 #define NALL_VECTOR_HPP
 
+#include <algorithm>
 #include <initializer_list>
 #include <new>
 #include <type_traits>
 #include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
-#include <nall/concept.hpp>
-#include <nall/foreach.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -38,7 +37,7 @@ namespace nall {
         for(unsigned i = 0; i < objectsize; i++) pool[i].~T();
         free(pool);
       }
-      pool = 0;
+      pool = nullptr;
       poolsize = 0;
       objectsize = 0;
     }
@@ -77,7 +76,7 @@ namespace nall {
     template<typename U> void insert(unsigned index, const U list) {
       linear_vector<T> merged;
       for(unsigned i = 0; i < index; i++) merged.append(pool[i]);
-      foreach(item, list) merged.append(item);
+      for(auto &item : list) merged.append(item);
       for(unsigned i = index; i < objectsize; i++) merged.append(pool[i]);
       operator=(merged);
     }
@@ -94,10 +93,10 @@ namespace nall {
       else resize(objectsize - count);
     }
 
-    linear_vector() : pool(0), poolsize(0), objectsize(0) {
+    linear_vector() : pool(nullptr), poolsize(0), objectsize(0) {
     }
 
-    linear_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+    linear_vector(std::initializer_list<T> list) : pool(nullptr), poolsize(0), objectsize(0) {
       for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
     }
 
@@ -114,7 +113,7 @@ namespace nall {
       return *this;
     }
 
-    linear_vector(const linear_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
+    linear_vector(const linear_vector<T> &source) : pool(nullptr), poolsize(0), objectsize(0) {
       operator=(source);
     }
 
@@ -124,12 +123,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       objectsize = source.objectsize;
-      source.pool = 0;
+      source.pool = nullptr;
       source.reset();
       return *this;
     }
 
-    linear_vector(linear_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+    linear_vector(linear_vector<T> &&source) : pool(nullptr), poolsize(0), objectsize(0) {
       operator=(std::move(source));
     }
 
@@ -175,7 +174,7 @@ namespace nall {
         for(unsigned i = 0; i < objectsize; i++) { if(pool[i]) delete pool[i]; }
         free(pool);
       }
-      pool = 0;
+      pool = nullptr;
       poolsize = 0;
       objectsize = 0;
     }
@@ -211,7 +210,7 @@ namespace nall {
     template<typename U> void insert(unsigned index, const U list) {
       pointer_vector<T> merged;
       for(unsigned i = 0; i < index; i++) merged.append(*pool[i]);
-      foreach(item, list) merged.append(item);
+      for(auto &item : list) merged.append(item);
       for(unsigned i = index; i < objectsize; i++) merged.append(*pool[i]);
       operator=(merged);
     }
@@ -228,10 +227,10 @@ namespace nall {
       else resize(objectsize - count);
     }
 
-    pointer_vector() : pool(0), poolsize(0), objectsize(0) {
+    pointer_vector() : pool(nullptr), poolsize(0), objectsize(0) {
     }
 
-    pointer_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+    pointer_vector(std::initializer_list<T> list) : pool(nullptr), poolsize(0), objectsize(0) {
       for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
     }
 
@@ -248,7 +247,7 @@ namespace nall {
       return *this;
     }
 
-    pointer_vector(const pointer_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
+    pointer_vector(const pointer_vector<T> &source) : pool(nullptr), poolsize(0), objectsize(0) {
       operator=(source);
     }
 
@@ -258,12 +257,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       objectsize = source.objectsize;
-      source.pool = 0;
+      source.pool = nullptr;
       source.reset();
       return *this;
     }
 
-    pointer_vector(pointer_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+    pointer_vector(pointer_vector<T> &&source) : pool(nullptr), poolsize(0), objectsize(0) {
       operator=(std::move(source));
     }
 
@@ -284,18 +283,17 @@ namespace nall {
       bool operator!=(const iterator &source) const { return index != source.index; }
       T& operator*() { return vector.operator[](index); }
       iterator& operator++() { index++; return *this; }
-      iterator(pointer_vector &vector, unsigned index) : vector(vector), index(index) {}
+      iterator(const pointer_vector &vector, unsigned index) : vector(vector), index(index) {}
     private:
-      pointer_vector &vector;
+      const pointer_vector &vector;
       unsigned index;
     };
 
     iterator begin() { return iterator(*this, 0); }
     iterator end() { return iterator(*this, objectsize); }
+    const iterator begin() const { return iterator(*this, 0); }
+    const iterator end() const { return iterator(*this, objectsize); }
   };
-
-  template<typename T> struct has_size<linear_vector<T>> { enum { value = true }; };
-  template<typename T> struct has_size<pointer_vector<T>> { enum { value = true }; };
 }
 
 #endif

bsnes/nes/Makefile

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

bsnes/nes/apu/apu.cpp

@@ -0,0 +1,329 @@
+#include <nes/nes.hpp>
+
+namespace NES {
+
+#include "envelope.cpp"
+#include "sweep.cpp"
+#include "pulse.cpp"
+#include "triangle.cpp"
+#include "noise.cpp"
+#include "dmc.cpp"
+#include "serialization.cpp"
+APU apu;
+
+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,
+};
+
+void APU::Main() {
+  apu.main();
+}
+
+void APU::main() {
+  while(true) {
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
+    }
+
+    unsigned 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();
+
+    signed 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);
+
+    tick();
+  }
+}
+
+void APU::tick() {
+  clock += 12;
+  if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) co_switch(cpu.thread);
+}
+
+void APU::set_irq_line() {
+  cpu.set_irq_apu_line(frame.irq_pending || dmc.irq_pending);
+}
+
+void APU::set_sample(int16 sample) {
+  cartridge_sample = sample;
+}
+
+void APU::power() {
+  filter.hipass_strong = 0;
+  filter.hipass_weak = 0;
+  filter.lopass = 0;
+
+  pulse[0].power();
+  pulse[1].power();
+  triangle.power();
+  noise.power();
+  dmc.power();
+}
+
+void APU::reset() {
+  Processor::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();
+}
+
+uint8 APU::read(uint16 addr) {
+  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();
+}
+
+void APU::write(uint16 addr, uint8 data) {
+  const unsigned 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;
+  }
+}
+
+signed APU::Filter::run_hipass_strong(signed sample) {
+  hipass_strong += ((((int64)sample << 16) - (hipass_strong >> 16)) * HiPassStrong) >> 16;
+  return sample - (hipass_strong >> 32);
+}
+
+signed APU::Filter::run_hipass_weak(signed sample) {
+  hipass_weak += ((((int64)sample << 16) - (hipass_weak >> 16)) * HiPassWeak) >> 16;
+  return sample - (hipass_weak >> 32);
+}
+
+signed APU::Filter::run_lopass(signed sample) {
+  lopass += ((((int64)sample << 16) - (lopass >> 16)) * LoPass) >> 16;
+  return (lopass >> 32);
+}
+
+void APU::clock_frame_counter() {
+  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();
+    }
+  }
+}
+
+void APU::clock_frame_counter_divider() {
+  frame.divider -= 2;
+  if(frame.divider <= 0) {
+    clock_frame_counter();
+    frame.divider += FrameCounter::NtscPeriod;
+  }
+}
+
+APU::APU() {
+  for(unsigned amp = 0; amp < 32; amp++) {
+    if(amp == 0) {
+      pulse_dac[amp] = 0;
+    } else {
+      pulse_dac[amp] = 16384.0 * 95.88 / (8128.0 / amp + 100.0);
+    }
+  }
+
+  for(unsigned dmc_amp = 0; dmc_amp < 128; dmc_amp++) {
+    for(unsigned triangle_amp = 0; triangle_amp < 16; triangle_amp++) {
+      for(unsigned noise_amp = 0; noise_amp < 16; noise_amp++) {
+        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));
+        }
+      }
+    }
+  }
+}
+
+}

bsnes/nes/apu/apu.hpp

@@ -0,0 +1,65 @@
+struct APU : Processor {
+  static void Main();
+  void main();
+  void tick();
+  void set_irq_line();
+  void set_sample(int16 sample);
+
+  void power();
+  void reset();
+
+  uint8 read(uint16 addr);
+  void write(uint16 addr, uint8 data);
+
+  void serialize(serializer&);
+  APU();
+
+  struct Filter {
+    enum : signed { HiPassStrong = 225574, HiPassWeak = 57593, LoPass = 86322413 };
+
+    int64 hipass_strong;
+    int64 hipass_weak;
+    int64 lopass;
+
+    signed run_hipass_strong(signed sample);
+    signed run_hipass_weak(signed sample);
+    signed run_lopass(signed sample);
+    void serialize(serializer&);
+  } filter;
+
+  #include "envelope.hpp"
+  #include "sweep.hpp"
+  #include "pulse.hpp"
+  #include "triangle.hpp"
+  #include "noise.hpp"
+  #include "dmc.hpp"
+
+  struct FrameCounter {
+    enum : unsigned { NtscPeriod = 14915 };  //~(21.477MHz / 6 / 240hz)
+
+    bool irq_pending;
+
+    uint2 mode;
+    uint2 counter;
+    signed divider;
+
+    void serialize(serializer&);
+  } frame;
+
+  void clock_frame_counter();
+  void clock_frame_counter_divider();
+
+  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;

bsnes/nes/apu/dmc.cpp

@@ -0,0 +1,117 @@
+void APU::DMC::start() {
+  if(length_counter == 0) {
+    read_addr = 0x4000 + (addr_latch << 6);
+    length_counter = (length_latch << 4) + 1;
+  }
+}
+
+void APU::DMC::stop() {
+  length_counter = 0;
+  dma_delay_counter = 0;
+  cpu.set_rdy_line(1);
+  cpu.set_rdy_addr({ false, 0u });
+}
+
+uint8 APU::DMC::clock() {
+  uint8 result = dac_latch;
+
+  if(dma_delay_counter > 0) {
+    dma_delay_counter--;
+
+    if(dma_delay_counter == 1) {
+      cpu.set_rdy_addr({ true, uint16(0x8000 | read_addr) });
+    } else if(dma_delay_counter == 0) {
+      cpu.set_rdy_line(1);
+      cpu.set_rdy_addr({ false, 0u });
+
+      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) {
+      signed delta = (((sample >> bit_counter) & 1) << 2) - 2;
+      unsigned 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;
+}
+
+void APU::DMC::power() {
+}
+
+void APU::DMC::reset() {
+  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;
+}
+
+void APU::DMC::serialize(serializer &s) {
+  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);
+}

bsnes/nes/apu/dmc.hpp

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