Update to bsnes v025 release.

bsnes is exactly three years old today. I've posted a new version which adds DSP-3 and DSP-4 special chip support. The DSP-3 is used by SD Gundam GX, and the DSP-4 is used by Top Gear 3000. Please note that the DSP-3 is not fully emulated, thusly SD Gundam GX is not fully playable. Also, due to lack of timing emulation with the DSP-4, the Top Gear 3000 track sometimes flickers in split screen mode. However, it is believed that Top Gear 3000 is fully playable. I should also note that I have started on SuperFX emulation, as some will inevitably see said code in my source releases. What I have now is nothing more than a skeleton implementation, and absolutely nothing using it is playable yet. I am making absolutely no promises that I will ever be able to emulate this chip. It will take at least several months of work, and even then, the speed will probably be too slow to reach 60fps on any system, but ... I'm working on it. While I have no way to run tests on the actual SuperFX hardware, I will do the best I can to emulate the chip accurately. I will be emulating the caching and cycle delays as best I can, but the information I have on this chip is extremely limited, so don't expect miracles. Lastly, as promised, I have released the special chips I have personally emulated to the public domain. See license.txt for more information if interested. I cannot release the special chips whose code I did not write to the public domain, but all of that is already available under the GPLv2 (from ZSNES) or the SNES9x license. Changelog: - Added DSP-3 support, thanks to John Weidman, Kris Bleakley, Lancer, z80 gaiden - Added DSP-4 support, thanks to Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden - Started on support for SuperFX, no games playable as chip emulation is less than 1% complete - Unsupported special chips will now display an alert - Missing stbios.bin file when loading Sufami Turbo cartridges will now display an alert - Video settings now saved separately for windowed and fullscreen mode - Advanced option video<.mode>.synchronize can be enabled for vsync, but will cause sound crackling - Added menu option to toggle FPS counter - Minor source code cleanup
Update to bsnes v024r01? release.
2026-11-10 17:02:56 -10:00 · 2007-10-15 10:03:36 +00:00 · 2007-10-12 06:55:00 +00:00 · 2007-10-01 09:03:44 +00:00 · 2007-09-25 14:20:00 +00:00 · 2007-09-16 19:30:35 +00:00
148 changed files with 7646 additions and 2773 deletions
@@ -0,0 +1,86 @@
+bsnes (TM) Open Source Reference License
+Copyright (C) 2004 - 2007 byuu
+All rights reserved
+
+1. Definitions
+
+The terms "reproduce", "reproduction", "distribute" and "distribution" have the
+same meaning here as under U.S. copyright law.
+
+"The software" means this software package as a whole, including, but not
+limited to, this license, binaries, source code, documentation, and data.
+
+"You" means the licensee of the software.
+
+"The licensor" means the copyright holder of the software, byuu.
+
+2. Grant of Rights
+
+Subject to the terms of this license, the licensor grants you a
+non-transferable, non-exclusive, worldwide, royalty-free copyright license to
+reproduce the software for non-commercial use only, provided the software
+remains unmodified, and there is no charge for the software itself, its' use,
+nor for the medium upon which the software is distributed. The reproduction of
+modified or derivative works of the software is strictly prohibited, except when
+transmitted solely to the licensor.
+
+3. Limitations
+
+This license does not grant you any rights to use the licensor's name, logo or
+trademarks.
+
+The software is provided "as is", and any express or implied warranties,
+including, but not limited to, the implied warranties of merchantability and
+fitness for a particular purpose are disclaimed. In no event shall the licensor
+be liable for any direct, indirect, incidental, special, exemplary, or
+consequential damages (including, but not limited to, procurement of substitute
+goods or services; loss of use, data, or profits; or business interruption)
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence or otherwise) arising in any way out of
+the use of the software, even if advised of the possibility of such damage.
+
+In the event that this license is determined to be invalid or unenforceable, the
+Grant of Rights will become null and void, and no rights shall be granted to the
+licensee, within the scope of U.S. copyright law.
+
+4. Exemptions
+
+The software includes the work of other copyright holders, which is licensed
+under different agreements, and exempt from this license. Below is a complete
+list of all such software, and their respective copyright holders and licenses.
+Further, respective source code files are labeled with their correct licensing
+information in the header. The lack of such a header indicates said file falls
+under the bsnes license.
+
+HQ2x filter, author: MaxST, license: LGPL
+JMA decompressor, author: NSRT Team, license: GPL (*)
+NTSC filter, author: blargg, license: LGPL
+zlib decompressor, license: zlib license
+
+(*) bsnes has received an exemption from the copyright holder to use this work.
+
+The software also includes works which have been released to the public domain,
+which are not bound to any licensing agreements. Below is a complete list of all
+such software.
+
+libco, author: byuu
+libui, author: byuu
+OBC-1 emu, author: byuu
+S-DD1 emu, author: Andreas Naive
+S-RTC emu, author: byuu
+
+Any software listed above as exemptions may be relicensed individually from
+bsnes under their respective terms. However, no bsnes licensed portions can be
+combined with such a derivative work.
+
+The software also includes the work of other copyright holders, which is
+licensed under the terms of the bsnes license, with permission to do so from the
+respective authors. Below is a complete list of all such software.
+
+Cx4 emu, authors: anomie, Overload, zsKnight, Nach
+DSP-1 emu, authors: Overload, John Weidman, Neviksti, Andreas Naive
+DSP-2 emu, author: Overload
+DSP-3 emu, authors: John Weidman, Kris Bleakley, Lancer, z80 gaiden
+DSP-4 emu, authors: Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden
+S-DSP emu, author: blargg
+ST-010 emu, authors: John Weidman, Matthew Kendora, Overload, Feather
@@ -0,0 +1,91 @@
+bsnes
+Version 0.025
+Author: byuu
+
+--------
+General:
+--------
+bsnes is a Super Nintendo / Super Famicom emulator that began on
+October 14th, 2004.
+
+The latest version can be downloaded from:
+http://byuu.org/
+
+Please see license.txt for important licensing information.
+
+--------------
+Shortcut Keys:
+--------------
+Esc - Toggle menubar visibility
+F11 - Toggle fullscreen mode
+
+------------------
+Known Limitations:
+------------------
+S-CPU
+- Invalid DMA / HDMA transfers not fully emulated
+- Multiply / Divide register delays not implemented
+
+S-PPU
+- Uses scanline-based renderer. This is very inaccurate, but few (if any)
+  games rely on mid-scanline writes to function correctly
+- Does not support FirstSprite+Y priority
+- OAM / CGRAM accesses during active display not supported correctly
+- RTO flags are not calculated on frames that are skipped when frameskipping
+  is enabled. This provides a major speedup, however it will cause in issues
+  in games that test these flags, eg the SNES Test Program Electronics Test.
+  Turning frameskipping off will allow RTO flag calculation on every frame
+
+Hardware Bugs
+- S-CPU.r1 HDMA crashing bug not emulated
+- S-CPU<>S-SMP communication bus conflicts not emulated
+
+---------------------
+Unsupported Hardware:
+---------------------
+SA-1
+Coprocessor used in many popular games, including:
+- Dragon Ball Z Hyper Dimension
+- Kirby Super Star
+- Kirby's Dreamland 3
+- Marvelous
+- SD Gundam G-NEXT
+- Super Mario RPG
+
+Super FX
+Coprocessor used in many popular games, including:
+- Doom
+- Star Fox
+- Star Fox 2 (unreleased beta)
+- Super Mario World 2: Yoshi's Island
+
+SPC7110
+Coprocessor used only by the following games:
+- Far East of Eden Zero
+- Far East of Eden Zero: Shounen Jump no Shou
+- Momotarou Densetsu Happy
+- Super Power League 4
+
+ST-011
+SETA DSP used only by Quick-move Shogi Match with Nidan Rank-holder Morita
+
+ST-018
+SETA RISC CPU used only by Quick-move Shogi Match with Nidan Rank-holder Morita 2
+
+BS-X (Broadcast Satellite)
+Add-on unit sold only in Japan that played specially-made games that were
+downloaded via satellite
+
+BS-X Flashcart
+Flash cartridge used by BS-X, as well as some standalone games by Asciisoft
+
+Super Gameboy
+Cartridge passthrough used for playing Gameboy games
+
+------------------------
+Unsupported Controllers:
+------------------------
+Mouse
+Super Scope
+Justifier
+Multitap (4-port and 5-port)
@@ -13,7 +13,7 @@ endif
 ifeq ($(PLATFORM),x-gcc-lui)
 OS = unix
 CC = gcc
-CFLAGS = -O3 -fomit-frame-pointer -ffast-math -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86 -DUI_LUI `pkg-config --cflags gtk+-2.0`
+CFLAGS = -O3 -fomit-frame-pointer -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86 -DUI_LUI `pkg-config --cflags gtk+-2.0`
 AS = nasm
 ASFLAGS = -f elf
 LIBS = `pkg-config --libs gtk+-2.0` -lXv -lao
@@ -24,7 +24,7 @@ endif
 ifeq ($(PLATFORM),x-gcc-lui-x64)
 OS = unix
 CC = gcc
-CFLAGS = -O3 -fomit-frame-pointer -ffast-math -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86_64 -DUI_LUI `pkg-config --cflags gtk+-2.0`
+CFLAGS = -O3 -fomit-frame-pointer -DPLATFORM_X -DCOMPILER_GCC -DPROCESSOR_X86_64 -DUI_LUI `pkg-config --cflags gtk+-2.0`
 AS = yasm
 ASFLAGS = -f elf64
 LIBS = `pkg-config --libs gtk+-2.0` -lXv -lao
@@ -38,7 +38,7 @@ CC = cl
 CFLAGS = /nologo /wd4996 /O2 /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
 AS = nasm
 ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
+LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib kernel32.lib user32.lib gdi32.lib shell32.lib winmm.lib comdlg32.lib comctl32.lib
 LIBCO = libco_x86
 LIBUI = libui_win
 endif
@@ -49,7 +49,7 @@ CC = cl
 CFLAGS = /nologo /wd4996 /O2 /GL /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
 AS = nasm
 ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
+LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib kernel32.lib user32.lib gdi32.lib shell32.lib winmm.lib comdlg32.lib comctl32.lib
 LINK = /link /PGD:bsnes.pgd /LTCG:PGINSTRUMENT
 LIBCO = libco_x86
 LIBUI = libui_win
@@ -61,12 +61,34 @@ CC = cl
 CFLAGS = /nologo /wd4996 /O2 /GL /EHsc /DPLATFORM_WIN /DCOMPILER_VISUALC /DPROCESSOR_X86 /DUI_LUI
 AS = nasm
 ASFLAGS = -f win32 -DWIN32
-LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
+LIBS = d3d9.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib kernel32.lib user32.lib gdi32.lib shell32.lib winmm.lib comdlg32.lib comctl32.lib
 LINK = /link /PGD:bsnes.pgd /LTCG:PGOPTIMIZE
 LIBCO = libco_x86
 LIBUI = libui_win
 endif

+ifeq ($(PLATFORM),win-mingw-lui)
+OS = win
+CC = mingw32-gcc
+CFLAGS = -mwindows -O3 -fomit-frame-pointer -DPLATFORM_WIN -DCOMPILER_GCC -DPROCESSOR_X86 -DUI_LUI
+AS = nasm
+ASFLAGS = -f win32 -DWIN32
+LIBS = -ld3d9 -lddraw -ldsound -ldinput8 -ldxguid -luuid -lkernel32 -luser32 -lgdi32 -lshell32 -lwinmm -lcomdlg32 -lcomctl32
+LIBCO = libco_x86
+LIBUI = libui_win
+endif
+
+ifeq ($(PLATFORM),win-mingw4-lui)
+OS = win
+CC = mingw32-gcc-sjlj
+CFLAGS = -mconsole -O3 -fomit-frame-pointer -DPLATFORM_WIN -DCOMPILER_GCC -DPROCESSOR_X86 -DUI_LUI
+AS = nasm
+ASFLAGS = -f win32 -DWIN32
+LIBS = -ld3d9 -lddraw -ldsound -ldinput8 -ldxguid -luuid -lkernel32 -luser32 -lgdi32 -lshell32 -lwinmm -lcomdlg32 -lcomctl32
+LIBCO = libco_x86
+LIBUI = libui_win
+endif
+
 #####################################
 ### compiler / assembler switches ###
 #####################################
@@ -79,6 +101,22 @@ CARGS = -c $< -o $@
 DEFINE = -D
 endif

+ifeq ($(CC),mingw32-gcc)
+OUT = -obsnes
+CPP = mingw32-g++
+OBJ = o
+CARGS = -c $< -o $@
+DEFINE = -D
+endif
+
+ifeq ($(CC),mingw32-gcc-sjlj)
+OUT = -obsnes
+CPP = mingw32-g++-sjlj
+OBJ = o
+CARGS = -c $< -o $@
+DEFINE = -D
+endif
+
 ifeq ($(CC),cl)
 OUT = /Febsnes
 CPP = cl
@@ -106,7 +144,6 @@ endif
 ifeq ($(OS),win)
 OUT := $(OUT).exe
 RM = del
-LIBS += kernel32.lib user32.lib gdi32.lib shell32.lib winmm.lib comdlg32.lib comctl32.lib
 endif

 ####################################
@@ -117,8 +154,8 @@ OBJECTS = main.$(OBJ) $(LIBCO).$(OBJ) $(LIBUI).$(OBJ) \
  libstring.$(OBJ) \
  reader.$(OBJ) cart.$(OBJ) cheat.$(OBJ) memory.$(OBJ) bmemory.$(OBJ) \
  cpu.$(OBJ) scpu.$(OBJ) smp.$(OBJ) ssmp.$(OBJ) bdsp.$(OBJ) ppu.$(OBJ) \
-  bppu.$(OBJ) snes.$(OBJ) srtc.$(OBJ) sdd1.$(OBJ) c4.$(OBJ) dsp1.$(OBJ) \
-  dsp2.$(OBJ) obc1.$(OBJ)
+  bppu.$(OBJ) snes.$(OBJ) superfx.$(OBJ) srtc.$(OBJ) sdd1.$(OBJ) c4.$(OBJ) \
+  dsp1.$(OBJ) dsp2.$(OBJ) dsp3.$(OBJ) dsp4.$(OBJ) obc1.$(OBJ) st010.$(OBJ)

 ifeq ($(GZIP_SUPPORT),true)
  OBJECTS += adler32.$(OBJ) compress.$(OBJ) crc32.$(OBJ) deflate.$(OBJ) \
@@ -222,12 +259,16 @@ snes.$(OBJ): snes/snes.cpp snes/* snes/scheduler/* snes/video/* snes/audio/* sne
 #####################
 ### special chips ###
 #####################
-srtc.$(OBJ): chip/srtc/srtc.cpp chip/srtc/*
-sdd1.$(OBJ): chip/sdd1/sdd1.cpp chip/sdd1/*
-c4.$(OBJ)  : chip/c4/c4.cpp chip/c4/*
-dsp1.$(OBJ): chip/dsp1/dsp1.cpp chip/dsp1/*
-dsp2.$(OBJ): chip/dsp2/dsp2.cpp chip/dsp2/*
-obc1.$(OBJ): chip/obc1/obc1.cpp chip/obc1/*
+superfx.$(OBJ): chip/superfx/superfx.cpp chip/superfx/* chip/superfx/core/* chip/superfx/memory/*
+srtc.$(OBJ)   : chip/srtc/srtc.cpp chip/srtc/*
+sdd1.$(OBJ)   : chip/sdd1/sdd1.cpp chip/sdd1/*
+c4.$(OBJ)     : chip/c4/c4.cpp chip/c4/*
+dsp1.$(OBJ)   : chip/dsp1/dsp1.cpp chip/dsp1/*
+dsp2.$(OBJ)   : chip/dsp2/dsp2.cpp chip/dsp2/*
+dsp3.$(OBJ)   : chip/dsp3/dsp3.cpp chip/dsp3/*
+dsp4.$(OBJ)   : chip/dsp4/dsp4.cpp chip/dsp4/*
+obc1.$(OBJ)   : chip/obc1/obc1.cpp chip/obc1/*
+st010.$(OBJ)  : chip/st010/st010.cpp chip/st010/*

 ############
 ### zlib ###
@@ -1,4 +1,4 @@
-#define BSNES_VERSION "0.020"
+#define BSNES_VERSION "0.025"
 #define BSNES_TITLE   "bsnes v" BSNES_VERSION

 #define MEMCORE bMemBus
@@ -31,18 +31,17 @@
  #error "unsupported processor"
 #endif

-#include "lib/libinterp.h"
+#include "lib/libfunctor.h"
 #include "lib/libsort.h"
 #include "lib/libarray.h"
 #include "lib/libvector.h"
-#include "lib/libfile.h"
 #include "lib/libstring.h"
 #include "lib/libconfig.h"

 //platform-specific global functions
-void alert(char*, ...);
-void dprintf(char*, ...);
-void dprintf(uint, char*, ...);
+void alert(const char*, ...);
+void dprintf(const char*, ...);
+void dprintf(uint, const char*, ...);

 namespace source {
  enum {
@@ -10,17 +10,24 @@

 Cartridge cartridge;

-void Cartridge::load_begin(uint cart_type) {
+void Cartridge::load_begin(CartridgeType cart_type) {
  if(loaded() == true)return;

  info.type = cart_type;

-  info.srtc = false;
-  info.sdd1 = false;
-  info.c4   = false;
-  info.dsp1 = false;
-  info.dsp2 = false;
-  info.obc1 = false;
+  info.superfx = false;
+  info.sa1     = false;
+  info.srtc    = false;
+  info.sdd1    = false;
+  info.c4      = false;
+  info.dsp1    = false;
+  info.dsp2    = false;
+  info.dsp3    = false;
+  info.dsp4    = false;
+  info.obc1    = false;
+  info.st010   = false;
+  info.st011   = false;
+  info.st018   = false;

  info.dsp1_mapper = 0;

@@ -29,7 +36,6 @@ void Cartridge::load_begin(uint cart_type) {
  strcpy(info.name, "");
  strcpy(info.pcb,  "");
  info.region = NTSC;
-  info.cart_mmio = false;

  info.rom_size = 0;
  info.ram_size = 0;
@@ -92,15 +98,15 @@ bool Cartridge::load_end() {
  }

  switch(info.type) {
-  case CART_NORMAL: {
+  case CartridgeNormal: {
    load_rom_normal();
    load_ram_normal();
  } break;
-  case CART_ST: {
+  case CartridgeSufamiTurbo: {
    load_rom_st();
    load_ram_st();
  } break;
-  case CART_STDUAL: {
+  case CartridgeSufamiTurboDual: {
    load_rom_stdual();
    load_ram_stdual();
  } break;
@@ -117,13 +123,13 @@ bool Cartridge::unload() {
  r_mem->unload_cart();

  switch(info.type) {
-  case CART_NORMAL: {
+  case CartridgeNormal: {
    save_ram_normal();
  } break;
-  case CART_ST: {
+  case CartridgeSufamiTurbo: {
    save_ram_st();
  } break;
-  case CART_STDUAL: {
+  case CartridgeSufamiTurboDual: {
    save_ram_stdual();
  } break;
  }
@@ -15,10 +15,10 @@ db_item dbi;

 //

-enum {
-  CART_NORMAL,
-  CART_ST,
-  CART_STDUAL,
+enum CartridgeType {
+  CartridgeNormal,
+  CartridgeSufamiTurbo,
+  CartridgeSufamiTurboDual,
 };

 bool cart_loaded;
@@ -33,7 +33,7 @@ enum {
  ROM_SIZE  = 0x17,
  RAM_SIZE  = 0x18,
  REGION    = 0x19,
-  LICENSE   = 0x1a,
+  COMPANY   = 0x1a,
  VERSION   = 0x1b,
  ICKSUM    = 0x1c,
  CKSUM     = 0x1e,
@@ -78,15 +78,19 @@ struct {
  uint   rom_size;
  uint   ram_size;

-//set to true for games that need cart MMIO mapping (c4, dsp-n, ...),
-//for games that map outside the standard MMIO range of $2000-$5fff
-  bool   cart_mmio;
+  bool   superfx;
+  bool   sa1;
  bool   srtc;
  bool   sdd1;
  bool   c4;
  bool   dsp1;
  bool   dsp2;
+  bool   dsp3;
+  bool   dsp4;
  bool   obc1;
+  bool   st010;
+  bool   st011;
+  bool   st018;

  uint   dsp1_mapper;

@@ -113,7 +117,7 @@ struct {
  void read_header();

  bool loaded() { return cart_loaded; }
-  void load_begin(uint cart_type);
+  void load_begin(CartridgeType cart_type);
  void load(const char *rom_fn);
  bool load_end();
  bool unload();
@@ -13,6 +13,7 @@ bool Cartridge::load_file(const char *fn, uint8 *&data, uint &size) {
  dprintf("* Loading \"%s\"...", fn);

  if(fexists(fn) == false) {
+    alert("Error: file '%s' not found!", fn);
    return false;
  }

@@ -1,13 +1,4 @@
 void Cartridge::read_header() {
-  info.srtc = false;
-  info.sdd1 = false;
-  info.c4   = false;
-  info.dsp1 = false;
-  info.dsp2 = false;
-  info.obc1 = false;
-
-  info.dsp1_mapper = 0;
-
  if(info.header_index == 0x7fc0 && info.rom_size >= 0x401000) {
    info.mapper = EXLOROM;
    strcpy(info.pcb, "UNL-EXLOROM");
@@ -27,6 +18,16 @@ void Cartridge::read_header() {

 uint8 mapper   = rom[info.header_index + MAPPER];
 uint8 rom_type = rom[info.header_index + ROM_TYPE];
+uint8 company  = rom[info.header_index + COMPANY];
+
+  if(mapper == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
+    info.superfx = true;
+  }
+
+  if(mapper == 0x23 && (rom_type == 0x34 || rom_type == 0x35)) {
+    info.sa1 = true;
+  }
+
  if(mapper == 0x35 && rom_type == 0x55) {
    info.srtc = true;
  }
@@ -43,7 +44,7 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
    info.dsp1 = true;
  }

-  if(mapper == 0x30 && rom_type == 0x05) {
+  if(mapper == 0x30 && rom_type == 0x05 && company != 0xb2) {
    info.dsp1 = true;
  }

@@ -65,11 +66,28 @@ uint8 rom_type = rom[info.header_index + ROM_TYPE];
    info.dsp2 = true;
  }

+  if(mapper == 0x30 && rom_type == 0x05 && company == 0xb2) {
+    info.dsp3 = true;
+  }
+
+  if(mapper == 0x30 && rom_type == 0x03) {
+    info.dsp4 = true;
+  }
+
  if(mapper == 0x30 && rom_type == 0x25) {
    info.obc1 = true;
  }

-  info.cart_mmio = info.c4 | info.dsp1 | info.dsp2 | info.obc1;
+  if(mapper == 0x30 && rom_type == 0xf6) {
+  //TODO: both ST010 and ST011 share the same mapper + rom_type
+  //need way to determine which is which
+  //for now, default to supported ST010
+    info.st010 = true;
+  }
+
+  if(mapper == 0x30 && rom_type == 0xf5) {
+    info.st018 = true;
+  }

  if(rom[info.header_index + RAM_SIZE] & 7) {
    info.ram_size = 1024 << (rom[info.header_index + RAM_SIZE] & 7);
@@ -113,8 +131,8 @@ int32 score_lo = 0,
  if(rom[0x7fc0 + REGION] < 14)score_lo++;
  if(rom[0xffc0 + REGION] < 14)score_hi++;

-  if(rom[0x7fc0 + LICENSE] < 3)score_lo++;
-  if(rom[0xffc0 + LICENSE] < 3)score_hi++;
+  if(rom[0x7fc0 + COMPANY] < 3)score_lo++;
+  if(rom[0xffc0 + COMPANY] < 3)score_hi++;

  if(rom[0x7fc0 + RESH] & 0x80)score_lo += 2;
  if(rom[0xffc0 + RESH] & 0x80)score_hi += 2;
@@ -20,21 +20,11 @@ uint offset = 0;
  info.crc32 = crc32_calculate(rom, info.rom_size);

  if(read_database() == true) {
-    info.srtc = false;
-    info.sdd1 = false;
-    info.c4   = false;
-    info.dsp1 = false;
-    info.dsp2 = false;
-    info.obc1 = false;
-
-    info.dsp1_mapper = 0;
-
    info.header_index = 0xffc0;
    info.mapper = PCB;
    strcpy(info.name, dbi.name);
    strcpy(info.pcb,  dbi.pcb);
    info.region = NTSC;
-    info.cart_mmio = false;

    info.rom_size = dbi.rom;
    info.ram_size = dbi.ram;
@@ -106,6 +106,12 @@ pcb  = "BSC-1A7M-10"
 rom  =  24mbit
 ram  = 512kbit

+[0xcf98ddaa]
+name = "Super Mario World 2: Yoshi's Island (USA)"
+pcb  = "SHVC-1CB5B-01"
+rom  =  16mbit
+ram  = 256kbit
+
 [0x64a91e64]
 name = "Wanderers from Ys (USA) [!]"
 pcb  = "SHVC-1A3B-12"
@@ -53,9 +53,9 @@ db_item dbi;
  dbi.ram   = 0;

  for(int i = 1; i < count(line); i++) {
-  uint pos;
-    if(strpos(line[i], ";", pos) == true) {
-      strset(line[i], pos, 0);
+  int pos = strpos(line[i], ";");
+    if(pos >= 0) {
+      strptr(line[i])[pos] = 0;
    }

    if(line[i] == "")continue;
@@ -1,3 +1,5 @@
-@make -r PLATFORM=win-visualc-lui
+::@make -r PLATFORM=win-mingw4-lui
+::@make -r PLATFORM=win-visualc-lui
+@make -r PLATFORM=win-visualc-lui GZIP_SUPPORT=true JMA_SUPPORT=true
@move bsnes.exe ../bsnes.exe>nul
@pause
@@ -7,8 +7,6 @@

 #include "../../base.h"

-C4 *c4;
-
 #include "c4data.cpp"
 #include "c4fn.cpp"
 #include "c4oam.cpp"
@@ -93,4 +93,4 @@ public:
  C4();
 };

-extern C4 *c4;
+extern C4 c4;
@@ -1,7 +1,5 @@
 #include "../../base.h"

-DSP1 *dsp1;
-
 #include "dsp1emu.cpp"

 void DSP1::init() {}
@@ -15,4 +15,4 @@ public:
  void   write(uint16 addr, uint8 data);
 };

-extern DSP1 *dsp1;
+extern DSP1 dsp1;
@@ -1,7 +1,5 @@
 #include "../../base.h"

-DSP2 *dsp2;
-
 #include "dsp2_op.cpp"

 void DSP2::init() {}
@@ -1,5 +1,4 @@
-class DSP2 {
-public:
+class DSP2 { public:
 struct {
  bool   waiting_for_command;
  uint   command;
@@ -40,4 +39,4 @@ struct {
  ~DSP2();
 };

-extern DSP2 *dsp2;
+extern DSP2 dsp2;
@@ -0,0 +1,33 @@
+#include "../../base.h"
+
+namespace DSP3i {
+  #define bool8 bool
+  #include "dsp3emu.c"
+  #undef bool8
+};
+
+void DSP3::init() {
+}
+
+void DSP3::enable() {
+}
+
+void DSP3::power() {
+  reset();
+}
+
+void DSP3::reset() {
+  DSP3i::DSP3_Reset();
+}
+
+uint8 DSP3::read(uint16 addr) {
+  DSP3i::dsp3_address = addr;
+  DSP3i::DSP3GetByte();
+  return DSP3i::dsp3_byte;
+}
+
+void DSP3::write(uint16 addr, uint8 data) {
+  DSP3i::dsp3_address = addr;
+  DSP3i::dsp3_byte = data;
+  DSP3i::DSP3SetByte();
+}
@@ -0,0 +1,11 @@
+class DSP3 { public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint16 addr);
+  void  write(uint16 addr, uint8 data);
+};
+
+extern DSP3 dsp3;
@@ -0,0 +1,51 @@
+#include "../../base.h"
+
+namespace DSP4i {
+  inline uint16 READ_WORD(uint8 *addr) {
+    return (addr[0]) + (addr[1] << 8);
+  }
+
+  inline uint32 READ_DWORD(uint8 *addr) {
+    return (addr[0]) + (addr[1] << 8) + (addr[2] << 16) + (addr[3] << 24);
+  }
+
+  inline void WRITE_WORD(uint8 *addr, uint16 data) {
+    addr[0] = data;
+    addr[1] = data >> 8;
+  }
+
+  #define bool8 bool
+  #include "dsp4emu.c"
+  #undef bool8
+};
+
+void DSP4::init() {
+}
+
+void DSP4::enable() {
+}
+
+void DSP4::power() {
+  reset();
+}
+
+void DSP4::reset() {
+  DSP4i::InitDSP4();
+}
+
+uint8 DSP4::read(uint16 addr) {
+  if(addr < 0xc000) {
+    DSP4i::dsp4_address = addr;
+    DSP4i::DSP4GetByte();
+    return DSP4i::dsp4_byte;
+  }
+  return 0x80;
+}
+
+void DSP4::write(uint16 addr, uint8 data) {
+  if(addr < 0xc000) {
+    DSP4i::dsp4_address = addr;
+    DSP4i::dsp4_byte = data;
+    DSP4i::DSP4SetByte();
+  }
+}
@@ -0,0 +1,11 @@
+class DSP4 { public:
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint16 addr);
+  void  write(uint16 addr, uint8 data);
+};
+
+extern DSP4 dsp4;
@@ -0,0 +1,108 @@
+//DSP-4 emulator code
+//Copyright (c) 2004-2006 Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden
+
+#ifndef DSP4EMU_H
+#define DSP4EMU_H
+
+#undef TRUE
+#undef FALSE
+#define TRUE  true
+#define FALSE false
+
+struct DSP4_t
+{
+  bool8 waiting4command;
+  bool8 half_command;
+  uint16 command;
+  uint32 in_count;
+  uint32 in_index;
+  uint32 out_count;
+  uint32 out_index;
+  uint8 parameters[512];
+  uint8 output[512];
+};
+
+extern struct DSP4_t DSP4;
+
+struct DSP4_vars_t
+{
+  // op control
+  int8 DSP4_Logic;            // controls op flow
+
+
+  // projection format
+  int16 lcv;                  // loop-control variable
+  int16 distance;             // z-position into virtual world
+  int16 raster;               // current raster line
+  int16 segments;             // number of raster lines drawn
+
+  // 1.15.16 or 1.15.0 [sign, integer, fraction]
+  int32 world_x;              // line of x-projection in world
+  int32 world_y;              // line of y-projection in world
+  int32 world_dx;             // projection line x-delta
+  int32 world_dy;             // projection line y-delta
+  int16 world_ddx;            // x-delta increment
+  int16 world_ddy;            // y-delta increment
+  int32 world_xenv;           // world x-shaping factor
+  int16 world_yofs;           // world y-vertical scroll
+
+  int16 view_x1;              // current viewer-x
+  int16 view_y1;              // current viewer-y
+  int16 view_x2;              // future viewer-x
+  int16 view_y2;              // future viewer-y
+  int16 view_dx;              // view x-delta factor
+  int16 view_dy;              // view y-delta factor
+  int16 view_xofs1;           // current viewer x-vertical scroll
+  int16 view_yofs1;           // current viewer y-vertical scroll
+  int16 view_xofs2;           // future viewer x-vertical scroll
+  int16 view_yofs2;           // future viewer y-vertical scroll
+  int16 view_yofsenv;         // y-scroll shaping factor
+  int16 view_turnoff_x;       // road turnoff data
+  int16 view_turnoff_dx;      // road turnoff delta factor
+
+
+  // drawing area
+
+  int16 viewport_cx;          // x-center of viewport window
+  int16 viewport_cy;          // y-center of render window
+  int16 viewport_left;        // x-left of viewport
+  int16 viewport_right;       // x-right of viewport
+  int16 viewport_top;         // y-top of viewport
+  int16 viewport_bottom;      // y-bottom of viewport
+
+
+  // sprite structure
+
+  int16 sprite_x;             // projected x-pos of sprite
+  int16 sprite_y;             // projected y-pos of sprite
+  int16 sprite_attr;          // obj attributes
+  bool8 sprite_size;          // sprite size: 8x8 or 16x16
+  int16 sprite_clipy;         // visible line to clip pixels off
+  int16 sprite_count;
+
+  // generic projection variables designed for
+  // two solid polygons + two polygon sides
+
+  int16 poly_clipLf[2][2];    // left clip boundary
+  int16 poly_clipRt[2][2];    // right clip boundary
+  int16 poly_ptr[2][2];       // HDMA structure pointers
+  int16 poly_raster[2][2];    // current raster line below horizon
+  int16 poly_top[2][2];       // top clip boundary
+  int16 poly_bottom[2][2];    // bottom clip boundary
+  int16 poly_cx[2][2];        // center for left/right points
+  int16 poly_start[2];        // current projection points
+  int16 poly_plane[2];        // previous z-plane distance
+
+
+  // OAM
+  int16 OAM_attr[16];         // OAM (size,MSB) data
+  int16 OAM_index;            // index into OAM table
+  int16 OAM_bits;             // offset into OAM table
+
+  int16 OAM_RowMax;           // maximum number of tiles per 8 aligned pixels (row)
+  int16 OAM_Row[32];          // current number of tiles per row
+};
+
+extern struct DSP4_vars_t DSP4_vars;
+
+#endif
@@ -1,7 +1,5 @@
 #include "../../base.h"

-OBC1 *obc1;
-
 void OBC1::init() {}
 void OBC1::enable() {}

@@ -17,4 +17,4 @@ struct {
  ~OBC1();
 };

-extern OBC1 *obc1;
+extern OBC1 obc1;
@@ -1,7 +1,5 @@
 #include "../../base.h"

-SDD1 *sdd1;
-
 #include "sdd1emu.cpp"

 void SDD1::init() {}
@@ -43,10 +41,10 @@ uint8 b = (addr >> 16) & 0xff;
 uint8 SDD1::mmio_read(uint16 addr) {
  switch(addr) {
  //>>20 == 0x100000 == 1mb
-  case 0x4804:return (sdd1.index[0] >> 20) & 7;
-  case 0x4805:return (sdd1.index[1] >> 20) & 7;
-  case 0x4806:return (sdd1.index[2] >> 20) & 7;
-  case 0x4807:return (sdd1.index[3] >> 20) & 7;
+  case 0x4804: return (sdd1.index[0] >> 20) & 7;
+  case 0x4805: return (sdd1.index[1] >> 20) & 7;
+  case 0x4806: return (sdd1.index[2] >> 20) & 7;
+  case 0x4807: return (sdd1.index[3] >> 20) & 7;
  }

  return r_cpu->regs.mdr;
@@ -60,10 +58,10 @@ void SDD1::mmio_write(uint16 addr, uint8 data) {
    }
    break;
  //<<20 == 0x100000 == 1mb
-  case 0x4804:sdd1.index[0] = (data & 7) << 20;break;
-  case 0x4805:sdd1.index[1] = (data & 7) << 20;break;
-  case 0x4806:sdd1.index[2] = (data & 7) << 20;break;
-  case 0x4807:sdd1.index[3] = (data & 7) << 20;break;
+  case 0x4804: sdd1.index[0] = (data & 7) << 20; break;
+  case 0x4805: sdd1.index[1] = (data & 7) << 20; break;
+  case 0x4806: sdd1.index[2] = (data & 7) << 20; break;
+  case 0x4807: sdd1.index[3] = (data & 7) << 20; break;
  }
 }

@@ -29,4 +29,4 @@ struct {
  SDD1();
 };

-extern SDD1 *sdd1;
+extern SDD1 sdd1;
@@ -52,8 +52,6 @@

 #include "../../base.h"

-SRTC *srtc;
-
 void SRTC::set_time() {
 time_t rawtime;
 tm *t;
@@ -49,4 +49,4 @@ struct {
  SRTC();
 };

-extern SRTC *srtc;
+extern SRTC srtc;
@@ -0,0 +1,84 @@
+#include "../../base.h"
+#include "st010_data.h"
+#include "st010_op.cpp"
+
+int16 ST010::sin(int16 theta) {
+  return sin_table[(theta >> 8) & 0xff];
+}
+
+int16 ST010::cos(int16 theta) {
+  return sin_table[((theta + 0x4000) >> 8) & 0xff];
+}
+
+uint8 ST010::readb(uint16 addr) {
+  return ram[addr & 0xfff];
+}
+
+uint16 ST010::readw(uint16 addr) {
+  return (readb(addr + 0) <<  0) |
+         (readb(addr + 1) <<  8);
+}
+
+uint32 ST010::readd(uint16 addr) {
+  return (readb(addr + 0) <<  0) |
+         (readb(addr + 1) <<  8) |
+         (readb(addr + 2) << 16) |
+         (readb(addr + 3) << 24);
+}
+
+void ST010::writeb(uint16 addr, uint8 data) {
+  ram[addr & 0xfff] = data;
+}
+
+void ST010::writew(uint16 addr, uint16 data) {
+  writeb(addr + 0, data);
+  writeb(addr + 1, data >> 8);
+}
+
+void ST010::writed(uint16 addr, uint32 data) {
+  writeb(addr + 0, data);
+  writeb(addr + 1, data >> 8);
+  writeb(addr + 2, data >> 16);
+  writeb(addr + 3, data >> 24);
+}
+
+//
+
+void ST010::init() {
+}
+
+void ST010::enable() {
+}
+
+void ST010::power() {
+  reset();
+}
+
+void ST010::reset() {
+  memset(ram, 0x00, sizeof ram);
+}
+
+//
+
+uint8 ST010::read(uint16 addr) {
+  return readb(addr);
+}
+
+void ST010::write(uint16 addr, uint8 data) {
+  writeb(addr, data);
+
+  if(addr == 0x0021 && data & 0x80) {
+    switch(ram[0x0020]) {
+    case 0x01: op_01(); break;
+    case 0x02: op_02(); break;
+    case 0x03: op_03(); break;
+    case 0x04: op_04(); break;
+    case 0x05: op_05(); break;
+    case 0x06: op_06(); break;
+    case 0x07: op_07(); break;
+    case 0x08: op_08(); break;
+    }
+
+    ram[0x0021] &= ~0x80;
+  }
+}
@@ -0,0 +1,40 @@
+class ST010 { public:
+uint8 ram[0x1000];
+static const int16 sin_table[256];
+static const int16 mode7_scale[176];
+static const uint8 arctan[32][32];
+//interfaces to sin table
+  int16 sin(int16 theta);
+  int16 cos(int16 theta);
+
+//interfaces to ram buffer
+  uint8  readb (uint16 addr);
+  uint16 readw (uint16 addr);
+  uint32 readd (uint16 addr);
+  void   writeb(uint16 addr, uint8  data);
+  void   writew(uint16 addr, uint16 data);
+  void   writed(uint16 addr, uint32 data);
+
+//opcodes
+  void op_01();
+  void op_02();
+  void op_03();
+  void op_04();
+  void op_05();
+  void op_06();
+  void op_07();
+  void op_08();
+
+  void op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta);
+
+//base
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 read (uint16 addr);
+  void  write(uint16 addr, uint8 data);
+};
+
+extern ST010 st010;
@@ -0,0 +1,126 @@
+const int16 ST010::sin_table[256] = {
+   0x0000,  0x0324,  0x0648,  0x096a,  0x0c8c,  0x0fab,  0x12c8,  0x15e2,
+   0x18f9,  0x1c0b,  0x1f1a,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,
+   0x30fb,  0x33df,  0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,
+   0x471c,  0x49b4,  0x4c3f,  0x4ebf,  0x5133,  0x539b,  0x55f5,  0x5842,
+   0x5a82,  0x5cb3,  0x5ed7,  0x60eb,  0x62f1,  0x64e8,  0x66cf,  0x68a6,
+   0x6a6d,  0x6c23,  0x6dc9,  0x6f5e,  0x70e2,  0x7254,  0x73b5,  0x7504,
+   0x7641,  0x776b,  0x7884,  0x7989,  0x7a7c,  0x7b5c,  0x7c29,  0x7ce3,
+   0x7d89,  0x7e1d,  0x7e9c,  0x7f09,  0x7f61,  0x7fa6,  0x7fd8,  0x7ff5,
+   0x7fff,  0x7ff5,  0x7fd8,  0x7fa6,  0x7f61,  0x7f09,  0x7e9c,  0x7e1d,
+   0x7d89,  0x7ce3,  0x7c29,  0x7b5c,  0x7a7c,  0x7989,  0x7884,  0x776b,
+   0x7641,  0x7504,  0x73b5,  0x7254,  0x70e2,  0x6f5e,  0x6dc9,  0x6c23,
+   0x6a6d,  0x68a6,  0x66cf,  0x64e8,  0x62f1,  0x60eb,  0x5ed7,  0x5cb3,
+   0x5a82,  0x5842,  0x55f5,  0x539b,  0x5133,  0x4ebf,  0x4c3f,  0x49b4,
+   0x471c,  0x447a,  0x41ce,  0x3f17,  0x3c56,  0x398c,  0x36ba,  0x33df,
+   0x30fb,  0x2e11,  0x2b1f,  0x2826,  0x2528,  0x2223,  0x1f1a,  0x1c0b,
+   0x18f8,  0x15e2,  0x12c8,  0x0fab,  0x0c8c,  0x096a,  0x0648,  0x0324,
+   0x0000, -0x0324, -0x0648, -0x096b, -0x0c8c, -0x0fab, -0x12c8, -0x15e2,
+  -0x18f9, -0x1c0b, -0x1f1a, -0x2223, -0x2528, -0x2826, -0x2b1f, -0x2e11,
+  -0x30fb, -0x33df, -0x36ba, -0x398d, -0x3c56, -0x3f17, -0x41ce, -0x447a,
+  -0x471c, -0x49b4, -0x4c3f, -0x4ebf, -0x5133, -0x539b, -0x55f5, -0x5842,
+  -0x5a82, -0x5cb3, -0x5ed7, -0x60ec, -0x62f1, -0x64e8, -0x66cf, -0x68a6,
+  -0x6a6d, -0x6c23, -0x6dc9, -0x6f5e, -0x70e2, -0x7254, -0x73b5, -0x7504,
+  -0x7641, -0x776b, -0x7884, -0x7989, -0x7a7c, -0x7b5c, -0x7c29, -0x7ce3,
+  -0x7d89, -0x7e1d, -0x7e9c, -0x7f09, -0x7f61, -0x7fa6, -0x7fd8, -0x7ff5,
+  -0x7fff, -0x7ff5, -0x7fd8, -0x7fa6, -0x7f61, -0x7f09, -0x7e9c, -0x7e1d,
+  -0x7d89, -0x7ce3, -0x7c29, -0x7b5c, -0x7a7c, -0x7989, -0x7883, -0x776b,
+  -0x7641, -0x7504, -0x73b5, -0x7254, -0x70e2, -0x6f5e, -0x6dc9, -0x6c23,
+  -0x6a6d, -0x68a6, -0x66cf, -0x64e8, -0x62f1, -0x60eb, -0x5ed7, -0x5cb3,
+  -0x5a82, -0x5842, -0x55f5, -0x539a, -0x5133, -0x4ebf, -0x4c3f, -0x49b3,
+  -0x471c, -0x447a, -0x41cd, -0x3f17, -0x3c56, -0x398c, -0x36b9, -0x33de,
+  -0x30fb, -0x2e10, -0x2b1f, -0x2826, -0x2527, -0x2223, -0x1f19, -0x1c0b,
+  -0x18f8, -0x15e2, -0x12c8, -0x0fab, -0x0c8b, -0x096a, -0x0647, -0x0324
+};
+
+const int16 ST010::mode7_scale[176] = {
+  0x0380,  0x0325,  0x02da,  0x029c,  0x0268,  0x023b,  0x0215,  0x01f3,
+  0x01d5,  0x01bb,  0x01a3,  0x018e,  0x017b,  0x016a,  0x015a,  0x014b,
+  0x013e,  0x0132,  0x0126,  0x011c,  0x0112,  0x0109,  0x0100,  0x00f8,
+  0x00f0,  0x00e9,  0x00e3,  0x00dc,  0x00d6,  0x00d1,  0x00cb,  0x00c6,
+  0x00c1,  0x00bd,  0x00b8,  0x00b4,  0x00b0,  0x00ac,  0x00a8,  0x00a5,
+  0x00a2,  0x009e,  0x009b,  0x0098,  0x0095,  0x0093,  0x0090,  0x008d,
+  0x008b,  0x0088,  0x0086,  0x0084,  0x0082,  0x0080,  0x007e,  0x007c,
+  0x007a,  0x0078,  0x0076,  0x0074,  0x0073,  0x0071,  0x006f,  0x006e,
+  0x006c,  0x006b,  0x0069,  0x0068,  0x0067,  0x0065,  0x0064,  0x0063,
+  0x0062,  0x0060,  0x005f,  0x005e,  0x005d,  0x005c,  0x005b,  0x005a,
+  0x0059,  0x0058,  0x0057,  0x0056,  0x0055,  0x0054,  0x0053,  0x0052,
+  0x0051,  0x0051,  0x0050,  0x004f,  0x004e,  0x004d,  0x004d,  0x004c,
+  0x004b,  0x004b,  0x004a,  0x0049,  0x0048,  0x0048,  0x0047,  0x0047,
+  0x0046,  0x0045,  0x0045,  0x0044,  0x0044,  0x0043,  0x0042,  0x0042,
+  0x0041,  0x0041,  0x0040,  0x0040,  0x003f,  0x003f,  0x003e,  0x003e,
+  0x003d,  0x003d,  0x003c,  0x003c,  0x003b,  0x003b,  0x003a,  0x003a,
+  0x003a,  0x0039,  0x0039,  0x0038,  0x0038,  0x0038,  0x0037,  0x0037,
+  0x0036,  0x0036,  0x0036,  0x0035,  0x0035,  0x0035,  0x0034,  0x0034,
+  0x0034,  0x0033,  0x0033,  0x0033,  0x0032,  0x0032,  0x0032,  0x0031,
+  0x0031,  0x0031,  0x0030,  0x0030,  0x0030,  0x0030,  0x002f,  0x002f,
+  0x002f,  0x002e,  0x002e,  0x002e,  0x002e,  0x002d,  0x002d,  0x002d,
+  0x002d,  0x002c,  0x002c,  0x002c,  0x002c,  0x002b,  0x002b,  0x002b
+};
+
+const uint8 ST010::arctan[32][32] = {
+  { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
+  { 0x80, 0xa0, 0xad, 0xb3, 0xb6, 0xb8, 0xb9, 0xba, 0xbb, 0xbb, 0xbc, 0xbc, 0xbd, 0xbd, 0xbd, 0xbd,
+    0xbd, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbf, 0xbf, 0xbf, 0xbf },
+  { 0x80, 0x93, 0xa0, 0xa8, 0xad, 0xb0, 0xb3, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xba, 0xbb,
+    0xbb, 0xbb, 0xbb, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd },
+  { 0x80, 0x8d, 0x98, 0xa0, 0xa6, 0xaa, 0xad, 0xb0, 0xb1, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb7, 0xb8,
+    0xb8, 0xb9, 0xb9, 0xba, 0xba, 0xba, 0xba, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbc, 0xbc, 0xbc, 0xbc },
+  { 0x80, 0x8a, 0x93, 0x9a, 0xa0, 0xa5, 0xa8, 0xab, 0xad, 0xaf, 0xb0, 0xb2, 0xb3, 0xb4, 0xb5, 0xb5,
+    0xb6, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8, 0xb9, 0xb9, 0xb9, 0xba, 0xba, 0xba, 0xba, 0xba, 0xbb, 0xbb },
+  { 0x80, 0x88, 0x90, 0x96, 0x9b, 0xa0, 0xa4, 0xa7, 0xa9, 0xab, 0xad, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+    0xb4, 0xb4, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9 },
+  { 0x80, 0x87, 0x8d, 0x93, 0x98, 0x9c, 0xa0, 0xa3, 0xa6, 0xa8, 0xaa, 0xac, 0xad, 0xae, 0xb0, 0xb0,
+    0xb1, 0xb2, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7, 0xb7, 0xb8, 0xb8, 0xb8 },
+  { 0x80, 0x86, 0x8b, 0x90, 0x95, 0x99, 0x9d, 0xa0, 0xa3, 0xa5, 0xa7, 0xa9, 0xaa, 0xac, 0xad, 0xae,
+    0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb6, 0xb7, 0xb7 },
+  { 0x80, 0x85, 0x8a, 0x8f, 0x93, 0x97, 0x9a, 0x9d, 0xa0, 0xa2, 0xa5, 0xa6, 0xa8, 0xaa, 0xab, 0xac,
+    0xad, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb5, 0xb5 },
+  { 0x80, 0x85, 0x89, 0x8d, 0x91, 0x95, 0x98, 0x9b, 0x9e, 0xa0, 0xa0, 0xa4, 0xa6, 0xa7, 0xa9, 0xaa,
+    0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb1, 0xb2, 0xb2, 0xb3, 0xb3, 0xb4, 0xb4, 0xb4 },
+  { 0x80, 0x84, 0x88, 0x8c, 0x90, 0x93, 0x96, 0x99, 0x9b, 0x9e, 0xa0, 0xa2, 0xa4, 0xa5, 0xa7, 0xa8,
+    0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xaf, 0xb0, 0xb0, 0xb1, 0xb2, 0xb2, 0xb2, 0xb3, 0xb3 },
+  { 0x80, 0x84, 0x87, 0x8b, 0x8e, 0x91, 0x94, 0x97, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa3, 0xa5, 0xa6,
+    0xa7, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xb0, 0xb0, 0xb1, 0xb1, 0xb2, 0xb2 },
+  { 0x80, 0x83, 0x87, 0x8a, 0x8d, 0x90, 0x93, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa3, 0xa5,
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xb0, 0xb0, 0xb0, 0xb1 },
+  { 0x80, 0x83, 0x86, 0x89, 0x8c, 0x8f, 0x92, 0x94, 0x96, 0x99, 0x9b, 0x9d, 0x9e, 0xa0, 0xa2, 0xa3,
+    0xa4, 0xa5, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xaf, 0xb0 },
+  { 0x80, 0x83, 0x86, 0x89, 0x8b, 0x8e, 0x90, 0x93, 0x95, 0x97, 0x99, 0x9b, 0x9d, 0x9e, 0xa0, 0xa1,
+    0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xac, 0xad, 0xad, 0xae, 0xae, 0xaf },
+  { 0x80, 0x83, 0x85, 0x88, 0x8b, 0x8d, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9b, 0x9d, 0x9f, 0xa0,
+    0xa1, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa, 0xab, 0xab, 0xac, 0xad, 0xad, 0xae },
+  { 0x80, 0x83, 0x85, 0x88, 0x8a, 0x8c, 0x8f, 0x91, 0x93, 0x95, 0x97, 0x99, 0x9a, 0x9c, 0x9d, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa5, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xab, 0xac, 0xad },
+  { 0x80, 0x82, 0x85, 0x87, 0x89, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x97, 0x99, 0x9b, 0x9c, 0x9d,
+    0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xac },
+  { 0x80, 0x82, 0x85, 0x87, 0x89, 0x8b, 0x8d, 0x8f, 0x91, 0x93, 0x95, 0x96, 0x98, 0x99, 0x9b, 0x9c,
+    0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x95, 0x97, 0x98, 0x9a, 0x9b,
+    0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7, 0xa8, 0xa8, 0xa9, 0xaa },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97, 0x99, 0x9a,
+    0x9b, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5, 0xa6, 0xa7, 0xa7, 0xa8, 0xa9 },
+  { 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8b, 0x8d, 0x8f, 0x90, 0x92, 0x94, 0x95, 0x97, 0x98, 0x99,
+    0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7, 0xa8 },
+  { 0x80, 0x82, 0x84, 0x86, 0x87, 0x89, 0x8b, 0x8d, 0x8e, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97, 0x98,
+    0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa3, 0xa4, 0xa5, 0xa6, 0xa6, 0xa7 },
+  { 0x80, 0x82, 0x84, 0x85, 0x87, 0x89, 0x8a, 0x8c, 0x8e, 0x8f, 0x91, 0x92, 0x94, 0x95, 0x96, 0x98,
+    0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5, 0xa6 },
+  { 0x80, 0x82, 0x83, 0x85, 0x87, 0x88, 0x8a, 0x8c, 0x8d, 0x8f, 0x90, 0x92, 0x93, 0x94, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa5, 0xa5 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x88, 0x8a, 0x8b, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4, 0xa4 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x88, 0x89, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94, 0x95,
+    0x96, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa4 },
+  { 0x80, 0x82, 0x83, 0x85, 0x86, 0x87, 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x93, 0x95,
+    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa1, 0xa2, 0xa3 },
+  { 0x80, 0x81, 0x83, 0x84, 0x86, 0x87, 0x89, 0x8a, 0x8b, 0x8d, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94,
+    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9e, 0x9f, 0xa0, 0xa1, 0xa1, 0xa2 },
+  { 0x80, 0x81, 0x83, 0x84, 0x86, 0x87, 0x88, 0x8a, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93,
+    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0, 0xa1, 0xa1 },
+  { 0x80, 0x81, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8b, 0x8c, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x93,
+    0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0, 0xa1 },
+  { 0x80, 0x81, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92,
+    0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0 }
+};
@@ -0,0 +1,257 @@
+//ST-010 emulation code - Copyright (C) 2003 The Dumper, Matthew Kendora, Overload, Feather
+//bsnes port - Copyright (C) 2007 byuu
+
+void ST010::op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta) {
+  if((x0 < 0) && (y0 < 0)) {
+    x1 = -x0;
+    y1 = -y0;
+    quadrant = -0x8000;
+  } else if(x0 < 0) {
+    x1 = y0;
+    y1 = -x0;
+    quadrant = -0x4000;
+  } else if(y0 < 0) {
+    x1 = -y0;
+    y1 = x0;
+    quadrant = 0x4000;
+  } else {
+    x1 = x0;
+    y1 = y0;
+    quadrant = 0x0000;
+  }
+
+  while((x1 > 0x1f) || (y1 > 0x1f)) {
+    if(x1 > 1) { x1 >>= 1; }
+    if(y1 > 1) { y1 >>= 1; }
+  }
+
+  if(y1 == 0) { quadrant += 0x4000; }
+
+  theta = (arctan[y1][x1] << 8) ^ quadrant;
+}
+
+//
+
+void ST010::op_01() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 x1, y1, quadrant, theta;
+
+  op_01(x0, y0, x1, y1, quadrant, theta);
+
+  writew(0x0000, x1);
+  writew(0x0002, y1);
+  writew(0x0004, quadrant);
+//writew(0x0006, y0); //Overload's docs note this write occurs, SNES9x disagrees
+  writew(0x0010, theta);
+}
+
+void ST010::op_02() {
+int16 positions = readw(0x0024);
+uint16 *places  = (uint16*)(ram + 0x0040);
+uint16 *drivers = (uint16*)(ram + 0x0080);
+
+bool sorted;
+uint16 temp;
+  if(positions > 1) {
+    do {
+      sorted = true;
+      for(int i = 0; i < positions - 1; i++) {
+        if(places[i] < places[i + 1]) {
+          temp = places[i + 1];
+          places[i + 1] = places[i];
+          places[i] = temp;
+
+          temp = drivers[i + 1];
+          drivers[i + 1] = drivers[i];
+          drivers[i] = temp;
+
+          sorted = false;
+        }
+      }
+      positions--;
+    } while(!sorted);
+  }
+}
+
+void ST010::op_03() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 multiplier = readw(0x0004);
+int32 x1, y1;
+
+  x1 = x0 * multiplier << 1;
+  y1 = y0 * multiplier << 1;
+
+  writed(0x0010, x1);
+  writed(0x0014, y1);
+}
+
+void ST010::op_04() {
+int16 x = readw(0x0000);
+int16 y = readw(0x0002);
+int16 square;
+//calculate the vector length of (x,y)
+  square = (int16)sqrt((double)(y * y + x * x));
+
+  writew(0x0010, square);
+}
+
+void ST010::op_05() {
+int32 dx, dy;
+int16 a1, b1, c1;
+uint16 o1;
+bool wrap = false;
+
+//target (x,y) coordinates
+int16 ypos_max = readw(0x00c0);
+int16 xpos_max = readw(0x00c2);
+
+//current coordinates and direction
+int32 ypos = readd(0x00c4);
+int32 xpos = readd(0x00c8);
+uint16 rot = readw(0x00cc);
+
+//physics
+uint16 speed = readw(0x00d4);
+uint16 accel = readw(0x00d6);
+uint16 speed_max = readw(0x00d8);
+
+//special condition acknowledgement
+int16 system = readw(0x00da);
+int16 flags = readw(0x00dc);
+
+//new target coordinates
+int16 ypos_new = readw(0x00de);
+int16 xpos_new = readw(0x00e0);
+
+//mask upper bit
+  xpos_new &= 0x7fff;
+
+//get the current distance
+  dx = xpos_max - (xpos >> 16);
+  dy = ypos_max - (ypos >> 16);
+
+//quirk: clear and move in9
+  writew(0x00d2, 0xffff);
+  writew(0x00da, 0x0000);
+
+//grab the target angle
+  op_01(dy, dx, a1, b1, c1, (int16&)o1);
+
+//check for wrapping
+  if(abs(o1 - rot) > 0x8000) {
+    o1 += 0x8000;
+    rot += 0x8000;
+    wrap = true;
+  }
+
+uint16 old_speed = speed;
+
+//special case
+  if(abs(o1 - rot) == 0x8000) {
+    speed = 0x100;
+  }
+
+//slow down for sharp curves
+  else if(abs(o1 - rot) >= 0x1000) {
+  uint32 slow = abs(o1 - rot);
+    slow >>= 4; //scaling
+    speed -= slow;
+  }
+
+//otherwise accelerate
+  else {
+    speed += accel;
+    if(speed > speed_max) {
+      speed = speed_max; //clip speed
+    }
+  }
+
+//prevent negative/positive overflow
+  if(abs(old_speed - speed) > 0x8000) {
+    if(old_speed < speed) { speed = 0; }
+    else speed = 0xff00;
+  }
+
+//adjust direction by so many degrees
+//be careful of negative adjustments
+  if((o1 > rot && (o1 - rot) > 0x80) || (o1 < rot && (rot - o1) >= 0x80)) {
+    if(o1 < rot) { rot -= 0x280; }
+    else if(o1 > rot) { rot += 0x280; }
+  }
+
+//turn of wrapping
+  if(wrap) { rot -= 0x8000; }
+
+//now check the distances (store for later)
+  dx = (xpos_max << 16) - xpos;
+  dy = (ypos_max << 16) - ypos;
+  dx >>= 16;
+  dy >>= 16;
+
+//if we're in so many units of the target, signal it
+  if((system && (dy <= 6 && dy >= -8) && (dx <= 126 && dx >= -128)) || (!system && (dx <= 6 && dx >= -8) && (dy <= 126 && dy >= -128))) {
+  //announce our new destination and flag it
+    xpos_max = xpos_new & 0x7fff;
+    ypos_max = ypos_new;
+    flags |= 0x08;
+  }
+
+//update position
+  xpos -= (cos(rot) * 0x400 >> 15) * (speed >> 8) << 1;
+  ypos -= (sin(rot) * 0x400 >> 15) * (speed >> 8) << 1;
+
+//quirk: mask upper byte
+  xpos &= 0x1fffffff;
+  ypos &= 0x1fffffff;
+
+  writew(0x00c0, ypos_max);
+  writew(0x00c2, xpos_max);
+  writed(0x00c4, ypos);
+  writed(0x00c8, xpos);
+  writew(0x00cc, rot);
+  writew(0x00d4, speed);
+  writew(0x00dc, flags);
+}
+
+void ST010::op_06() {
+int16 multiplicand = readw(0x0000);
+int16 multiplier = readw(0x0002);
+int32 product;
+
+  product = multiplicand * multiplier << 1;
+
+  writed(0x0010, product);
+}
+
+void ST010::op_07() {
+int16 theta = readw(0x0000);
+
+int16 data;
+  for(int i = 0, offset = 0; i < 176; i++) {
+    data = mode7_scale[i] * cos(theta) >> 15;
+    writew(0x00f0 + offset, data);
+    writew(0x0510 + offset, data);
+
+    data = mode7_scale[i] * sin(theta) >> 15;
+    writew(0x0250 + offset, data);
+    if(data) { data = ~data; }
+    writew(0x03b0 + offset, data);
+
+    offset += 2;
+  }
+}
+
+void ST010::op_08() {
+int16 x0 = readw(0x0000);
+int16 y0 = readw(0x0002);
+int16 theta = readw(0x0004);
+int16 x1, y1;
+
+  x1 = (y0 * sin(theta) >> 15) + (x0 * cos(theta) >> 15);
+  y1 = (y0 * cos(theta) >> 15) - (x0 * sin(theta) >> 15);
+
+  writew(0x0010, x1);
+  writew(0x0012, y1);
+}
@@ -0,0 +1,3 @@
+void op_unknown() {}
+
+void op_00();
@@ -0,0 +1,7 @@
+//STOP
+void SuperFX::op_00() {
+  regs.sfr.g = 0;
+  regs.sfr.b = 0;
+  regs.sfr.alt1 = 0;
+  regs.sfr.alt2 = 0;
+}
@@ -0,0 +1,64 @@
+uint8 SuperFX::mmio_read(uint16 addr) {
+  switch(addr) {
+  case 0x3000: return regs.r0.l;
+  case 0x3001: return regs.r0.h;
+  case 0x3002: return regs.r1.l;
+  case 0x3003: return regs.r1.h;
+  case 0x3004: return regs.r2.l;
+  case 0x3005: return regs.r2.h;
+  case 0x3006: return regs.r3.l;
+  case 0x3007: return regs.r3.h;
+  case 0x3008: return regs.r4.l;
+  case 0x3009: return regs.r4.h;
+  case 0x300a: return regs.r5.l;
+  case 0x300b: return regs.r5.h;
+  case 0x300c: return regs.r6.l;
+  case 0x300d: return regs.r6.h;
+  case 0x300e: return regs.r7.l;
+  case 0x300f: return regs.r7.h;
+
+  case 0x3010: return regs.r8.l;
+  case 0x3011: return regs.r8.h;
+  case 0x3012: return regs.r9.l;
+  case 0x3013: return regs.r9.h;
+  case 0x3014: return regs.r10.l;
+  case 0x3015: return regs.r10.h;
+  case 0x3016: return regs.r11.l;
+  case 0x3017: return regs.r11.h;
+  case 0x3018: return regs.r12.l;
+  case 0x3019: return regs.r12.h;
+  case 0x301a: return regs.r13.l;
+  case 0x301b: return regs.r13.h;
+  case 0x301c: return regs.r14.l;
+  case 0x301d: return regs.r14.h;
+  case 0x301e: return regs.r15.l;
+  case 0x301f: return regs.r15.h;
+
+//0x3020 - 0x302f unused
+
+  case 0x3030: return regs.sfr;
+  case 0x3031: return regs.sfr >> 8;
+  case 0x3032: return 0x00; //unused
+  case 0x3033: return 0x00; //BRAMR (write only)
+  case 0x3034: return regs.pbr;
+  case 0x3035: return 0x00; //unused
+  case 0x3036: return regs.rombr;
+  case 0x3037: return 0x00; //CFGR (write only)
+  case 0x3038: return 0x00; //SCBR (write only)
+  case 0x3039: return 0x00; //CLSR (write only)
+  case 0x303a: return 0x00; //SCMR (write only)
+  case 0x303b: return regs.vcr;
+  case 0x303c: return regs.rambr;
+  case 0x303d: return 0x00; //unused
+  case 0x303e: return regs.cbr;
+  case 0x303f: return regs.cbr >> 8;
+
+//0x3040 - 0x30ff unused
+  }
+
+  if(addr >= 0x3100 && addr <= 0x32ff) {
+    return cache[addr - 0x3100];
+  }
+
+  return 0x00;
+}
@@ -0,0 +1,63 @@
+void SuperFX::mmio_write(uint16 addr, uint8 data) {
+  switch(addr) {
+  case 0x3000: regs.r0.l  = data; return;
+  case 0x3001: regs.r0.h  = data; return;
+  case 0x3002: regs.r1.l  = data; return;
+  case 0x3003: regs.r1.h  = data; return;
+  case 0x3004: regs.r2.l  = data; return;
+  case 0x3005: regs.r2.h  = data; return;
+  case 0x3006: regs.r3.l  = data; return;
+  case 0x3007: regs.r3.h  = data; return;
+  case 0x3008: regs.r4.l  = data; return;
+  case 0x3009: regs.r4.h  = data; return;
+  case 0x300a: regs.r5.l  = data; return;
+  case 0x300b: regs.r5.h  = data; return;
+  case 0x300c: regs.r6.l  = data; return;
+  case 0x300d: regs.r6.h  = data; return;
+  case 0x300e: regs.r7.l  = data; return;
+  case 0x300f: regs.r7.h  = data; return;
+
+  case 0x3010: regs.r8.l  = data; return;
+  case 0x3011: regs.r8.h  = data; return;
+  case 0x3012: regs.r9.l  = data; return;
+  case 0x3013: regs.r9.h  = data; return;
+  case 0x3014: regs.r10.l = data; return;
+  case 0x3015: regs.r10.h = data; return;
+  case 0x3016: regs.r11.l = data; return;
+  case 0x3017: regs.r11.h = data; return;
+  case 0x3018: regs.r12.l = data; return;
+  case 0x3019: regs.r12.h = data; return;
+  case 0x301a: regs.r13.l = data; return;
+  case 0x301b: regs.r13.h = data; return;
+  case 0x301c: regs.r14.l = data; return;
+  case 0x301d: regs.r14.h = data; return;
+  case 0x301e: regs.r15.l = data; return;
+  case 0x301f: regs.r15.h = data; return;
+
+//0x3020 - 0x302f unused
+
+  case 0x3030: regs.sfr.l = data & 0x7e; return; //mask invalid bits
+  case 0x3031: regs.sfr.h = data & 0x9f; return; //mask invalid bits
+  case 0x3032: return; //unused
+  case 0x3033: regs.bramr = data; return;
+  case 0x3034: regs.pbr = data; return;
+  case 0x3035: return; //unused
+  case 0x3036: return; //ROMBR (read only)
+  case 0x3037: regs.cfgr = data; return;
+  case 0x3038: regs.scbr = data; return;
+  case 0x3039: regs.clsr = data; return;
+  case 0x303a: regs.scmr = data; return;
+  case 0x303b: return; //VCR (read only)
+  case 0x303c: return; //RAMBR (read only)
+  case 0x303d: return; //unused
+  case 0x303e: return; //CBR low (read only)
+  case 0x303f: return; //CBR high (read only)
+
+//0x3040 - 0x30ff unused
+  }
+
+  if(addr >= 0x3100 && addr <= 0x32ff) {
+    cache[addr - 0x3100] = data;
+    return;
+  }
+}
@@ -0,0 +1,174 @@
+struct Reg16 {
+  union {
+    uint16 w;
+    struct { uint8 order_lsb2(l, h); };
+  };
+
+  inline operator unsigned() const { return w; }
+  inline unsigned operator=(const unsigned i) { return w = i; }
+
+  Reg16() : w(0) {}
+};
+
+template<int bit> struct RegFlag8 {
+  uint8 data;
+
+  inline operator bool() const { return data & bit; }
+  inline bool operator=(const bool i) { i ? data |= bit : data &= ~bit; return i; }
+};
+
+template<int bit> struct RegFlag16 {
+  uint16 data;
+
+  inline operator bool() const { return data & bit; }
+  inline bool operator=(const bool i) { i ? data |= bit : data &= ~bit; return i; }
+};
+
+struct SFR {
+  union {
+    uint16 w;
+    struct { uint8 order_lsb2(l, h); };
+    RegFlag16<0x0002> z;    //zero flag
+    RegFlag16<0x0004> c;    //carry flag
+    RegFlag16<0x0008> s;    //sign flag
+    RegFlag16<0x0010> v;    //overflow flag
+    RegFlag16<0x0020> g;    //go flag
+    RegFlag16<0x0040> r;    //ROM read using r14 flag
+    RegFlag16<0x0100> alt1; //alternate instruction 1 flag
+    RegFlag16<0x0200> alt2; //alternate instruction 2 flag
+    RegFlag16<0x0400> il;   //immediate lower 8-bit flag
+    RegFlag16<0x0800> ih;   //immediate upper 8-bit flag
+    RegFlag16<0x1000> b;    //WITH instruction flag
+    RegFlag16<0x8000> irq;  //interrupt flag
+  };
+
+  inline operator unsigned() const { return w & 0x9f7e; } //invalid flag bits always return 0 when read
+  inline unsigned operator=(const unsigned i) { return w = i & 0x9f7e; }
+
+  SFR() : w(0) {}
+};
+
+struct RAMBR {
+  union {
+    uint8 b;
+    RegFlag8<0x01> bank;
+  };
+
+  inline operator unsigned() const { return b & 0x01; }
+  inline unsigned operator=(const unsigned i) { return b = i & 0x01; }
+
+  RAMBR() : b(0) {}
+};
+
+struct CBR {
+  uint16 w;
+
+  inline operator unsigned() const { return w & 0xfff0; }
+  inline unsigned operator=(const unsigned i) { return w = i & 0xfff0; }
+
+  CBR() : w(0) {}
+};
+
+struct SCMR {
+  union {
+    uint8 b;
+    RegFlag8<0x01> md0; //color mode low
+    RegFlag8<0x02> md1; //color mode high
+    RegFlag8<0x04> ht0; //height low
+    RegFlag8<0x08> ran; //ram enable
+    RegFlag8<0x10> ron; //rom enable
+    RegFlag8<0x20> ht1; //height high
+  };
+
+  inline operator unsigned() const { return b; }
+  inline unsigned operator=(const unsigned i) { return b = i; }
+
+  SCMR() : b(0) {}
+};
+
+struct BRAMR {
+  union {
+    uint8 b;
+    RegFlag8<0x01> flag;
+  };
+
+  inline operator unsigned() const { return b; }
+  inline unsigned operator=(const unsigned i) { return b = i; }
+
+  BRAMR() : b(0) {}
+};
+
+struct CFGR {
+  union {
+    uint8 b;
+    RegFlag8<0x20> ms0; //multiplier speed selection
+    RegFlag8<0x80> irq; //irq mask flag
+  };
+
+  inline operator unsigned() const { return b; }
+  inline unsigned operator=(const unsigned i) { return b = i; }
+
+  CFGR() : b(0) {}
+};
+
+struct CLSR {
+  union {
+    uint8 b;
+    RegFlag8<0x01> flag;
+  };
+
+  inline operator unsigned() const { return b; }
+  inline unsigned operator=(const unsigned i) { return b = i; }
+
+  CLSR() : b(0) {}
+};
+
+struct POR {
+  union {
+    uint8 b;
+    RegFlag8<0x01> transparent; //transparent flag
+    RegFlag8<0x02> dither;      //dither flag
+    RegFlag8<0x04> highnibble;  //high nibble flag
+    RegFlag8<0x08> freezehigh;  //freeze high flag
+    RegFlag8<0x10> obj;         //OBJ flag
+  };
+
+  inline operator unsigned() const { return b; }
+  inline unsigned operator=(const unsigned i) { return b = i; }
+
+  POR() : b(0) {}
+};
+
+struct Regs {
+  Reg16  r0;    //default source/destination register
+  Reg16  r1;    //pixel plot X position register
+  Reg16  r2;    //pixel plot Y position register
+  Reg16  r3;
+  Reg16  r4;    //lower 16-bit result of lmult
+  Reg16  r5;
+  Reg16  r6;    //multiplier for fmult and lmult
+  Reg16  r7;    //fixed point texel X position for merge
+  Reg16  r8;    //fixed point texel Y position for merge
+  Reg16  r9;
+  Reg16  r10;
+  Reg16  r11;   //return address set by link
+  Reg16  r12;   //loop counter
+  Reg16  r13;   //loop point address
+  Reg16  r14;   //rom address for getb, getbh, getbl, getbs
+  Reg16  r15;   //program counter
+
+  SFR    sfr;   //status/flag register
+  uint8  pbr;   //program bank register
+  uint8  rombr; //rom bank register
+  RAMBR  rambr; //ram bank register
+  CBR    cbr;   //cache base register
+  uint8  scbr;  //screen base register
+  SCMR   scmr;  //screen mode register
+  BRAMR  bramr; //backup ram register
+  uint8  vcr;   //version code register
+  CFGR   cfgr;  //config register
+  CLSR   clsr;  //clock select register
+
+  uint8  colr;  //color register
+  POR    por;   //plot option register
+} regs;
@@ -0,0 +1,42 @@
+#include "../../base.h"
+
+#include "core/op0x.cpp"
+
+#include "memory/read.cpp"
+#include "memory/write.cpp"
+
+void SuperFX::init() {
+}
+
+void SuperFX::enable() {
+  for(uint i = 0x3000; i <= 0x32ff; i++) {
+    r_mem->set_mmio_mapper(i, this);
+  }
+}
+
+void SuperFX::power() {
+  reset();
+}
+
+void SuperFX::reset() {
+  regs.r0  = 0;
+  regs.r1  = 0;
+  regs.r2  = 0;
+  regs.r3  = 0;
+  regs.r4  = 0;
+  regs.r5  = 0;
+  regs.r6  = 0;
+  regs.r7  = 0;
+  regs.r8  = 0;
+  regs.r9  = 0;
+  regs.r10 = 0;
+  regs.r11 = 0;
+  regs.r12 = 0;
+  regs.r13 = 0;
+  regs.r14 = 0;
+  regs.r15 = 0;
+
+  regs.sfr = 0;
+
+  memset(cache, 0, sizeof cache);
+}
@@ -0,0 +1,17 @@
+class SuperFX : public MMIO { public:
+  #include "core/core.h"
+
+  void init();
+  void enable();
+  void power();
+  void reset();
+
+  uint8 mmio_read (uint16 addr);
+  void  mmio_write(uint16 addr, uint8 data);
+
+private:
+  #include "regs.h"
+  uint8 cache[512]; //cache RAM
+};
+
+extern SuperFX superfx;
@@ -1 +1,2 @@
+::@make PLATFORM=win-mingw4-lui clean
@make PLATFORM=win-visualc-lui clean
@@ -1,7 +1,10 @@
-Config config_file;
-
 namespace config {

+Config& config() {
+static Config config;
+  return config;
+}
+
 string file_updatepath(const char *req_file, const char *req_path) {
 string file(req_file);
  replace(file, "\\", "/");
@@ -27,68 +30,83 @@ stringarray part;

 StringSetting Path::base(0, "fs.base_path",
  "Path that bsnes resides in", "");
-StringSetting Path::rom(&config_file, "path.rom",
+StringSetting Path::rom(&config(), "path.rom",
  "Default path to look for ROM files in (\"\" = use default directory)", "");
-StringSetting Path::save(&config_file, "path.save",
+StringSetting Path::save(&config(), "path.save",
  "Default path for all save RAM and cheat files (\"\" = use current directory)", "");
-StringSetting Path::bios(&config_file, "path.bios",
+StringSetting Path::bios(&config(), "path.bios",
  "Path where BIOS file(s) are located\n"
  "Supported BIOS files:\n"
  "stbios.bin - Bandai Sufami Turbo"
  "", "./bios");

-StringSetting Path::save_ext(&config_file, "path.save_ext",
+StringSetting Path::save_ext(&config(), "path.save_ext",
  "Extension to be used for all save RAM files", "srm");

-IntegerSetting SNES::gamma_ramp(&config_file, "snes.colorfilter.gamma_ramp",
+IntegerSetting SNES::gamma_ramp(&config(), "snes.colorfilter.gamma_ramp",
  "Use precalculated TV-style gamma ramp", IntegerSetting::Boolean, true);
-IntegerSetting SNES::sepia(&config_file, "snes.colorfilter.sepia",
+IntegerSetting SNES::sepia(&config(), "snes.colorfilter.sepia",
  "Convert color to sepia tone", IntegerSetting::Boolean, false);
-IntegerSetting SNES::grayscale(&config_file, "snes.colorfilter.grayscale",
+IntegerSetting SNES::grayscale(&config(), "snes.colorfilter.grayscale",
  "Convert color to grayscale tone", IntegerSetting::Boolean, false);
-IntegerSetting SNES::invert(&config_file, "snes.colorfilter.invert",
+IntegerSetting SNES::invert(&config(), "snes.colorfilter.invert",
  "Invert output image colors", IntegerSetting::Boolean, false);
-IntegerSetting SNES::contrast(&config_file, "snes.colorfilter.contrast",
+IntegerSetting SNES::contrast(&config(), "snes.colorfilter.contrast",
  "Contrast", IntegerSetting::Decimal, 0);
-IntegerSetting SNES::brightness(&config_file, "snes.colorfilter.brightness",
+IntegerSetting SNES::brightness(&config(), "snes.colorfilter.brightness",
  "Brightness", IntegerSetting::Decimal, 0);
-IntegerSetting SNES::gamma(&config_file, "snes.colorfilter.gamma",
+IntegerSetting SNES::gamma(&config(), "snes.colorfilter.gamma",
  "Gamma", IntegerSetting::Decimal, 80);

-IntegerSetting SNES::ntsc_merge_fields(&config_file, "snes.ntsc_merge_fields",
+IntegerSetting SNES::ntsc_merge_fields(&config(), "snes.ntsc_merge_fields",
  "Merge fields in NTSC video filter\n"
  "Set to true if using filter at any refresh rate other than 60hz\n"
  "", IntegerSetting::Boolean, true);

-IntegerSetting SNES::mute(&config_file, "snes.mute", "Mutes SNES audio output when enabled",
+IntegerSetting SNES::mute(&config(), "snes.mute", "Mutes SNES audio output when enabled",
  IntegerSetting::Boolean, false);

-IntegerSetting SNES::controller_port0(&config_file, "snes.controller_port_1",
+IntegerSetting SNES::controller_port0(&config(), "snes.controller_port_1",
  "Controller attached to SNES port 1", IntegerSetting::Decimal, ::SNES::DEVICEID_JOYPAD1);
-IntegerSetting SNES::controller_port1(&config_file, "snes.controller_port_2",
+IntegerSetting SNES::controller_port1(&config(), "snes.controller_port_2",
  "Controller attached to SNES port 2", IntegerSetting::Decimal, ::SNES::DEVICEID_JOYPAD2);

-IntegerSetting CPU::ntsc_clock_rate(&config_file, "cpu.ntsc_clock_rate",
+IntegerSetting CPU::ntsc_clock_rate(&config(), "cpu.ntsc_clock_rate",
  "NTSC S-CPU clock rate (in hz)", IntegerSetting::Decimal, 21477272);
-IntegerSetting CPU::pal_clock_rate(&config_file, "cpu.pal_clock_rate",
+IntegerSetting CPU::pal_clock_rate(&config(), "cpu.pal_clock_rate",
  "PAL S-CPU clock rate (in hz)", IntegerSetting::Decimal, 21281370);

 IntegerSetting CPU::hdma_enable(0, "cpu.hdma_enable",
  "Enable HDMA effects", IntegerSetting::Boolean, true);

-IntegerSetting SMP::ntsc_clock_rate(&config_file, "smp.ntsc_clock_rate",
+IntegerSetting SMP::ntsc_clock_rate(&config(), "smp.ntsc_clock_rate",
  "NTSC S-SMP clock rate (in hz)", IntegerSetting::Decimal, 24606720);
-IntegerSetting SMP::pal_clock_rate(&config_file, "smp.pal_clock_rate",
+IntegerSetting SMP::pal_clock_rate(&config(), "smp.pal_clock_rate",
  "PAL S-SMP clock rate (in hz)", IntegerSetting::Decimal, 24606720);

-IntegerSetting PPU::Hack::render_scanline_position(&config_file, "ppu.hack.render_scanline_position",
+IntegerSetting PPU::Hack::render_scanline_position(&config(), "ppu.hack.render_scanline_position",
  "Approximate HCLOCK position to render at for scanline-based renderers",
  IntegerSetting::Decimal, 512);
-IntegerSetting PPU::Hack::obj_cache(&config_file, "ppu.hack.obj_cache",
+IntegerSetting PPU::Hack::obj_cache(&config(), "ppu.hack.obj_cache",
  "Cache OAM OBJ attributes one scanline before rendering\n"
  "This is technically closer to the actual operation of the SNES,\n"
  "but can cause problems in some games if enabled",
  IntegerSetting::Boolean, false);
+IntegerSetting PPU::Hack::oam_address_invalidation(&config(), "ppu.hack.oam_address_invalidation",
+  "OAM access address changes during active display, as the S-PPU reads\n"
+  "data to render the display. Thusly, the address retrieved when accessing\n"
+  "OAM during active display is unpredictable. Unfortunately, the exact\n"
+  "algorithm for this is completely unknown at this time. It is more hardware\n"
+  "accurate to enable this setting, but one must *not* rely on the actual\n"
+  "address to match hardware under emulation.",
+  IntegerSetting::Boolean, true);
+IntegerSetting PPU::Hack::cgram_address_invalidation(&config(), "ppu.hack.cgram_address_invalidation",
+  "CGRAM access address changes during active display (excluding hblank), as\n"
+  "the S-PPU reads data to render the display. Thusly, as with OAM, the access\n"
+  "address is unpredictable. Again, enabling this setting is more hardware\n"
+  "accurate, but one must *not* rely on the actual address to match hardware\n"
+  "under emulation.",
+  IntegerSetting::Boolean, true);

 IntegerSetting PPU::opt_enable(0, "ppu.opt_enable", "Enable offset-per-tile effects", IntegerSetting::Boolean, true);
 IntegerSetting PPU::bg1_pri0_enable(0, "ppu.bg1_pri0_enable", "Enable BG1 Priority 0", IntegerSetting::Boolean, true);
@@ -1,7 +1,7 @@
-extern Config config_file;
-
 namespace config {

+extern Config& config();
+
 string file_updatepath(const char *, const char *);

 extern struct Path {
@@ -30,6 +30,8 @@ extern struct PPU {
  struct Hack {
    static IntegerSetting render_scanline_position;
    static IntegerSetting obj_cache;
+    static IntegerSetting oam_address_invalidation;
+    static IntegerSetting cgram_address_invalidation;
  } hack;

  static IntegerSetting opt_enable;
@@ -83,8 +83,8 @@ inline uint32 sCPU::hdma_iaddr(uint8 i) {
 *****/

 void sCPU::dma_transfertobusb(uint8 i, uint8 bbus) {
-  if(cartridge.info.sdd1 == true && sdd1->dma_active() == true) {
-    r_mem->write(0x2100 | bbus, sdd1->dma_read());
+  if(cartridge.info.sdd1 == true && sdd1.dma_active() == true) {
+    r_mem->write(0x2100 | bbus, sdd1.dma_read());
  } else {
    dma_transfer(0, bbus, dma_addr(i));
  }
@@ -111,8 +111,7 @@ void sCPU::dma_run() {
    dma_add_clocks(8);

    if(cartridge.info.sdd1 == true) {
-      sdd1->dma_begin(i, (channel[i].srcbank << 16) | (channel[i].srcaddr),
-        channel[i].xfersize);
+      sdd1.dma_begin(i, (channel[i].srcbank << 16) | (channel[i].srcaddr), channel[i].xfersize);
    }

    if(tracer.enabled() == true && tracer.cpudma_enabled() == true) {
@@ -1,8 +1,6 @@
-class sCPU : public CPU {
-public:
+class sCPU : public CPU { public:
  void enter();

-public:
 #include "core/core.h"
 #include "dma/dma.h"
 #include "memory/memory.h"
@@ -662,7 +662,9 @@ void bDSP::power()
 {
 	ram = (uint8*) r_smp->get_spcram_handle();
 	memset( &m, 0, sizeof m );
-	memcpy( m.regs, initial_regs, sizeof m.regs );
+	//memcpy( m.regs, initial_regs, sizeof m.regs );
+	memset(m.regs, 0, sizeof m.regs);
+	REG(flg) = 0xe0;
 	
 	// Internal state
 	for ( int i = voice_count; --i >= 0; )
@@ -33,12 +33,16 @@

 #include "snes/snes.h"

+#include "chip/superfx/superfx.h"
 #include "chip/srtc/srtc.h"
 #include "chip/sdd1/sdd1.h"
 #include "chip/c4/c4.h"
 #include "chip/dsp1/dsp1.h"
 #include "chip/dsp2/dsp2.h"
+#include "chip/dsp3/dsp3.h"
+#include "chip/dsp4/dsp4.h"
 #include "chip/obc1/obc1.h"
+#include "chip/st010/st010.h"

 extern MMIO mmio_unmapped;
 #ifdef POLYMORPHISM
@@ -1,9 +1,9 @@
 /*
-  libarray : version 0.08 ~byuu (2006-12-16)
+  libarray : version 0.09 ~byuu (2007-03-06)
 */

-#ifndef __LIBARRAY
-#define __LIBARRAY
+#ifndef LIBARRAY_H
+#define LIBARRAY_H

 template<typename T> class array {
 protected:
@@ -1,5 +1,5 @@
 /*
-  libbase : version 0.10 ~byuu (2007-05-27)
+  libbase : version 0.11 ~byuu (2007-09-08)
  license: public domain
 */

@@ -16,7 +16,9 @@
 #include <time.h>
 #include <math.h>

-#if defined(_MSC_VER)
+#include <new>
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
  #include <io.h>
  #include <direct.h>
  #include <shlobj.h>
@@ -32,6 +34,10 @@

  #define NOMINMAX
  #define PATH_MAX  _MAX_PATH
+  #define va_copy(dst, src) ((dst) = (src))
+#endif
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
  #define getcwd    _getcwd
  #define ftruncate _chsize
  #define mkdir     _mkdir
@@ -39,11 +45,10 @@
  #define rmdir     _rmdir
  #define vsnprintf _vsnprintf

-  #define va_copy(dst, src) ((dst) = (src))
  static char *realpath(const char *file_name, char *resolved_name) {
    return _fullpath(resolved_name, file_name, PATH_MAX);
  }
-#elif defined(__GNUC__)
+#else
  #define mkdir(path) (mkdir)(path, 0755);
 #endif

@@ -55,17 +60,14 @@
  #define noinline      __declspec(noinline)
  #define inline        inline
  #define alwaysinline  __forceinline
-  #define fastcall      __fastcall
 #elif defined(__GNUC__)
  #define noinline      __attribute__((noinline))
  #define inline        inline
  #define alwaysinline  __attribute__((always_inline))
-  #define fastcall      __attribute__((fastcall))
 #else
  #define noinline
  #define inline        inline
  #define alwaysinline  inline
-  #define fastcall
 #endif

 /*****
@@ -91,13 +93,13 @@ typedef int64_t  int64;
 //userpath(output) retrieves path to user's home folder
 //output must be at least as large as PATH_MAX

-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__)
 static char *userpath(char *output) {
  strcpy(output, "."); //failsafe
  SHGetFolderPath(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, output);
  return output;
 }
-#elif defined(__GNUC__)
+#else
 static char *userpath(char *output) {
  strcpy(output, "."); //failsafe
 struct passwd *userinfo = getpwuid(getuid());
@@ -137,14 +139,10 @@ T z = x;
  y = z;
 }

-#ifdef min
 #undef min
-#endif
 #define min(x, y) (((x) < (y)) ? (x) : (y))

-#ifdef max
 #undef max
-#endif
 #define max(x, y) (((x) > (y)) ? (x) : (y))

 template<int min, int max, typename T> inline T minmax(const T x) {
@@ -171,6 +169,8 @@ enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
  return ((x & m) ^ b) - b;
 }

+//bit shifting functions are deprecated
+
 template<int n, typename T> inline T rol(const T x) {
 enum { s = (sizeof(T) << 3) - n };
  return (x << n) | (x >> s);
@@ -1,14 +1,14 @@
 ;*****
-;libco_x86 : version 0.10 ~byuu (2007-04-18)
+;libco_x86 : version 0.10 ~byuu (2007-09-08)
 ;cross-platform x86 implementation of libco
 ;special thanks to Aaron Giles and Joel Yliluoma for various optimizations
 ;
 ;[ABI compatibility]
-;- visual c++; windows-x86
-;- mingw; windows-x86
-;- gcc; osx86
-;- gcc; linux-x86
-;- gcc; freebsd-x86
+;- visual c++; windows; x86
+;- mingw; windows; x86
+;- gcc; mac os x; x86
+;- gcc; linux; x86
+;- gcc; freebsd; x86
 ;
 ;[nonvolatile registers]
 ;- esp, ebp, edi, esi, ebx
@@ -28,7 +28,7 @@
 %define free       _free

 %define co_active  @co_active@0
-%define co_create  @co_create@12
+%define co_create  @co_create@8
 %define co_delete  @co_delete@4
 %define co_switch  @co_switch@4
 %endif
@@ -76,11 +76,10 @@ co_active:
    ret

 ;*****
-;extern "C" cothread_t fastcall co_create(unsigned int heapsize, void (*coentry)(void *data), void *data);
-;ecx     = heapsize
-;edx     = coentry
-;[esp+4] = data
-;return  = eax
+;extern "C" cothread_t fastcall co_create(unsigned int heapsize, void (*coentry)());
+;ecx    = heapsize
+;edx    = coentry
+;return = eax
 ;*****

 align 16
@@ -101,7 +100,7 @@ co_create:
    and    ecx,-16                          ;force 16-byte alignment of stack heap

 ;store thread entry point + registers, so that first call to co_switch will execute coentry
-    mov    dword[ecx-4],co_entrypoint       ;entry point
+    mov    dword[ecx-4],edx                 ;entry point
    mov    dword[ecx-8],0                   ;ebp
    mov    dword[ecx-12],0                  ;esi
    mov    dword[ecx-16],0                  ;edi
@@ -109,11 +108,8 @@ co_create:
    sub    ecx,20

 ;initialize context memory heap and return
-    mov    [eax],ecx                        ;cothread_t[ 0- 3] = stack heap pointer (esp)
-    mov    [eax+4],edx                      ;cothread_t[ 4- 7] = coentry
-    mov    ecx,[esp+4]
-    mov    [eax+8],ecx                      ;cothread_t[ 8-11] = data
-    ret    4                                ;return allocated memory block as thread handle
+    mov    [eax],ecx                        ;*cothread_t = stack heap pointer (esp)
+    ret                                     ;return allocated memory block as thread handle

 ;*****
 ;extern "C" void fastcall co_delete(cothread_t cothread);
@@ -150,18 +146,3 @@ co_switch:
    pop    ebp

    ret
-
-;*****
-;void fastcall co_entrypoint();
-;*****
-
-align 16
-co_entrypoint:
-    mov    ebp,esp
-.loop
-    mov    eax,[co_active_context]
-    mov    ecx,[eax+8]                      ;fastcall
-    push   ecx                              ;stdcall
-    call   [eax+4]
-    mov    esp,ebp                          ;cdecl
-    jmp    .loop
@@ -1,16 +1,26 @@
 /*
-  libco_x86 : version 0.10 ~byuu (2007-04-18)
+  libco_x86 : version 0.10 ~byuu (2007-09-08)
+  license: public domain
 */

 #ifndef LIBCO_H
 #define LIBCO_H

-#define cocall fastcall
-typedef void (*cothread_t);
+#if !defined(fastcall)
+  #if defined(_MSC_VER)
+    #define fastcall __fastcall
+  #elif defined(__GNUC__)
+    #define fastcall __attribute__((fastcall))
+  #else
+    #error "fastcall undefined"
+  #endif
+#endif

-extern "C" cothread_t cocall co_active();
-extern "C" cothread_t cocall co_create(unsigned int heapsize, void (cocall *coentry)(void *data), void *data);
-extern "C" void       cocall co_delete(cothread_t cothread);
-extern "C" void       cocall co_switch(cothread_t cothread);
+typedef void *cothread_t;
+
+extern "C" cothread_t fastcall co_active();
+extern "C" cothread_t fastcall co_create(unsigned int heapsize, void (*coentry)());
+extern "C" void       fastcall co_delete(cothread_t cothread);
+extern "C" void       fastcall co_switch(cothread_t cothread);

 #endif
@@ -1,12 +1,12 @@
 ;*****
-;libco_x86_64 : version 0.10 ~byuu (2007-04-18)
+;libco_x86_64 : version 0.10 ~byuu (2007-09-08)
 ;cross-platform x86-64 implementation of libco
 ;special thanks to Aaron Giles and Joel Yliluoma for various optimizations
 ;
 ;[ABI compatibility]
 ;- SystemV ( http://refspecs.freestandards.org/elf/x86_64-SysV-psABI.pdf )
-;- gcc; linux-x86-64
-;- gcc; freebsd-x86-64
+;- gcc; linux; x86-64
+;- gcc; freebsd; x86-64
 ;
 ;[nonvolatile registers]
 ;- rsp, rbp, rbx, r12, r13, r14, r15
@@ -50,10 +50,9 @@ co_active:
    ret

 ;*****
-;extern "C" cothread_t co_create(unsigned int heapsize, void (*coentry)(void *data), void *data);
+;extern "C" cothread_t co_create(unsigned int heapsize, void (*coentry)());
 ;rdi    = heapsize
 ;rsi    = coentry
-;rdx    = data
 ;return = rax
 ;*****

@@ -63,11 +62,9 @@ co_create:
    add    rdi,512                          ;allocate extra memory for contextual info
    push   rdi
    push   rsi
-    push   rdx

    call   malloc                           ;rax = malloc(rdi)

-    pop    rdx
    pop    rsi
    pop    rdi

@@ -75,7 +72,7 @@ co_create:
    and    rdi,-16                          ;force 16-byte alignment of stack heap

 ;store thread entry point + registers, so that first call to co_switch will execute coentry
-    mov    qword[rdi-8],co_entrypoint       ;entry point
+    mov    qword[rdi-8],rsi                 ;entry point
    mov    qword[rdi-16],0                  ;r15
    mov    qword[rdi-24],0                  ;r14
    mov    qword[rdi-32],0                  ;r13
@@ -85,9 +82,7 @@ co_create:
    sub    rdi,56

 ;initialize context memory heap and return
-    mov    [rax],rdi                        ;cothread_t[ 0- 7] = stack heap pointer (rsp)
-    mov    [rax+8],rsi                      ;cothread_t[ 8-15] = coentry
-    mov    [rax+16],rdx                     ;cothread_t[16-23] = data
+    mov    [rax],rdi                        ;*cothread_t = stack heap pointer (rsp)
    ret                                     ;return allocated memory block as thread handle

 ;*****
@@ -126,14 +121,3 @@ co_switch:
    pop    rbp

    ret
-
-;*****
-;void co_entrypoint();
-;*****
-
-align 16
-co_entrypoint:
-    mov    rax,[co_active_context wrt rip]
-    mov    rdi,[rax+16]
-    call   [rax+8]
-    jmp    co_entrypoint
@@ -1,15 +1,15 @@
 /*
-  libco_x86_64 : version 0.10 ~byuu (2007-04-18)
+  libco_x86_64 : version 0.10 ~byuu (2007-09-08)
+  license: public domain
 */

 #ifndef LIBCO_H
 #define LIBCO_H

-#define cocall
-typedef void (*cothread_t);
+typedef void *cothread_t;

 extern "C" cothread_t co_active();
-extern "C" cothread_t co_create(unsigned int heapsize, void (cocall *coentry)(void *data), void *data);
+extern "C" cothread_t co_create(unsigned int heapsize, void (*coentry)());
 extern "C" void       co_delete(cothread_t cothread);
 extern "C" void       co_switch(cothread_t cothread);

@@ -1,5 +1,5 @@
 /*
-  libconfig : version 0.14 ~byuu (2007-05-27)
+  libconfig : version 0.14 ~byuu (2007-06-12)
  license: public domain
 */

@@ -72,7 +72,7 @@ enum Format {
  template<typename T> bool operator<=(T x) { return (T(data) <= x); }
  template<typename T> bool operator< (T x) { return (T(data) <  x); }

-  IntegerSetting(Config *parent, char *r_name, char *r_desc, uint r_format, uint r_data) {
+  IntegerSetting(Config *parent, const char *r_name, const char *r_desc, uint r_format, uint r_data) {
    type = Setting::Integer;
    name = strdup(r_name);
    desc = strdup(r_desc);
@@ -103,7 +103,7 @@ string data;
  bool operator==(const char *x) { return !strcmp(data, x); }
  bool operator!=(const char *x) { return  strcmp(data, x); }

-  StringSetting(Config *parent, char *r_name, char *r_desc, char *r_data) {
+  StringSetting(Config *parent, const char *r_name, const char *r_desc, const char *r_data) {
    type = Setting::String;
    name = strdup(r_name);
    desc = strdup(r_desc);
@@ -1,455 +0,0 @@
-/*
-  libfile : version 0.07 ~byuu (2007-03-01)
-*/
-
-#ifndef __LIBFILE
-#define __LIBFILE
-
-//FreeBSD fix: do not use defines for libc functions
-#undef feof
-#undef ferror
-
-/*****
- * file object
- *****/
-
-class file {
-public:
-enum { mode_read, mode_write, mode_readwrite, mode_writeread };
-enum { seek_start, seek_end, seek_back, seek_forward };
-  virtual void   read(uint8 *data, uint length) = 0;
-  virtual uint8  read() = 0;
-
-  virtual void   write(uint8 *data, uint length) = 0;
-  virtual void   write(uint8 data) = 0;
-
-  virtual uint32 crc32();
-
-  virtual void   seek(uint offset, uint mode = seek_start) = 0;
-  virtual void   resize(uint size) = 0;
-  virtual uint   offset() = 0;
-  virtual uint   size() = 0;
-  virtual bool   eof() = 0;
-
-  virtual bool   open(const char *filename, uint mode) = 0;
-  virtual bool   open() = 0;
-  virtual bool   flush() = 0;
-  virtual bool   close() = 0;
-};
-
-inline uint32 file::crc32() {
-uint pos = offset(), i = size();
-  seek(0);
-uint32 crc32 = 0xffffffff;
-  while(i--) {
-    crc32 = crc32_adjust(crc32, read());
-  }
-  seek(pos);
-  return ~crc32;
-}
-
-/*****
- * c++ wrappers
- *****/
-
-inline void   fread(file &s, uint8 *data, uint length) { s.read(data, length); }
-inline uint8  fread(file &s) { return s.read(); }
-inline uint8  fgetc(file &s) { return s.read(); }
-inline uint   fgetb(file &s) { return s.read(); }
-
-inline void   fwrite(file &s, uint8 *data, uint length) { s.write(data, length); }
-inline void   fwrite(file &s, uint8 data) { s.write(data); }
-inline void   fputc(uint8 data, file &s) { s.write(data); }
-inline void   fputb(file &s, uint8 data) { s.write(data); }
-
-inline uint32 fcrc32(file &s) { return s.crc32(); }
-
-inline void   fseek(file &s, uint offset, uint mode = file::seek_start) { s.seek(offset, mode); }
-inline void   fresize(file &s, uint size) { s.resize(size); }
-inline uint   ftell(file &s) { return s.offset(); }
-inline uint   fsize(file &s) { return s.size(); }
-inline bool   feof(file &s) { return s.eof(); }
-
-inline bool   fopen(file &s, const char *filename, uint mode) { return s.open(filename, mode); }
-inline bool   fopen(file &s) { return s.open(); }
-inline bool   fflush(file &s) { return s.flush(); }
-inline bool   fclose(file &s) { return s.close(); }
-
-
-/*****
- * endian wrappers
- *****/
-
-inline uint8 fgetlb(file &s) { return fgetc(s); }
-inline uint8 fgetmb(file &s) { return fgetc(s); }
-
-inline uint16 fgetlw(file &s) {
-  return (fgetc(s)) | (fgetc(s) << 8);
-}
-
-inline uint16 fgetmw(file &s) {
-  return (fgetc(s) << 8) | (fgetc(s) << 8);
-}
-
-inline uint32 fgetld(file &s) {
-  return (fgetc(s)) | (fgetc(s) << 8) | (fgetc(s) << 16) | (fgetc(s) << 24);
-}
-
-inline uint32 fgetmd(file &s) {
-  return (fgetc(s) << 24) | (fgetc(s) << 16) | (fgetc(s) << 8) | (fgetc(s));
-}
-
-inline uint64 fgetlq(file &s) {
-  return ((uint64)fgetc(s) <<  0) | ((uint64)fgetc(s) <<  8) |
-         ((uint64)fgetc(s) << 16) | ((uint64)fgetc(s) << 24) |
-         ((uint64)fgetc(s) << 32) | ((uint64)fgetc(s) << 40) |
-         ((uint64)fgetc(s) << 48) | ((uint64)fgetc(s) << 56);
-}
-
-inline uint64 fgetmq(file &s) {
-  return ((uint64)fgetc(s) << 56) | ((uint64)fgetc(s) << 48) |
-         ((uint64)fgetc(s) << 40) | ((uint64)fgetc(s) << 32) |
-         ((uint64)fgetc(s) << 24) | ((uint64)fgetc(s) << 16) |
-         ((uint64)fgetc(s) <<  8) | ((uint64)fgetc(s) <<  0);
-}
-
-inline void fputlb(file &s, uint8 data) { fputc(data, s); }
-inline void fputmb(file &s, uint8 data) { fputc(data, s); }
-
-inline void fputlw(file &s, uint16 data) {
-  fputc(data >> 0, s);
-  fputc(data >> 8, s);
-}
-
-inline void fputmw(file &s, uint16 data) {
-  fputc(data >> 8, s);
-  fputc(data >> 0, s);
-}
-
-inline void fputld(file &s, uint32 data) {
-  fputc(data >>  0, s);
-  fputc(data >>  8, s);
-  fputc(data >> 16, s);
-  fputc(data >> 24, s);
-}
-
-inline void fputmd(file &s, uint32 data) {
-  fputc(data >> 24, s);
-  fputc(data >> 16, s);
-  fputc(data >>  8, s);
-  fputc(data >>  0, s);
-}
-
-inline void fputlq(file &s, uint64 data) {
-  fputc(data >>  0, s);
-  fputc(data >>  8, s);
-  fputc(data >> 16, s);
-  fputc(data >> 24, s);
-  fputc(data >> 32, s);
-  fputc(data >> 40, s);
-  fputc(data >> 48, s);
-  fputc(data >> 56, s);
-}
-
-inline void fputmq(file &s, uint64 data) {
-  fputc(data >> 56, s);
-  fputc(data >> 48, s);
-  fputc(data >> 40, s);
-  fputc(data >> 32, s);
-  fputc(data >> 24, s);
-  fputc(data >> 16, s);
-  fputc(data >>  8, s);
-  fputc(data >>  0, s);
-}
-
-/*****
- * ramfile
- *****/
-
-class ramfile : public file {
-private:
-FILE *fp;
-array<uint8> filedata;
-char filename[1024];
-uint filepos;
-uint filesize;
-uint filemode;
-bool fileopen;
-bool filevirtual;
-
-public:
-  void read(uint8 *data, uint length) {
-    if(!fileopen || filemode == mode_write) { return; }
-
-    memcpy(data, filedata.get(filepos + length) + filepos, length);
-    filepos += length;
-    if(filepos > filesize)filepos = filesize;
-  }
-
-  uint8 read() {
-    if(!fileopen || filemode == mode_write) { return 0; }
-
-    if(eof() == true) { return 0xff; }
-    return filedata[filepos++];
-  }
-
-  void write(uint8 *data, uint length) {
-    if(!fileopen || filemode == mode_read) { return; }
-
-    memcpy(filedata.get(filepos + length) + filepos, data, length);
-    filepos += length;
-    if(filepos > filesize)filesize = filepos;
-  }
-
-  void write(uint8 data) {
-    if(!fileopen || filemode == mode_read) { return; }
-
-    filedata[filepos++] = data;
-    if(filepos > filesize)filesize = filepos;
-  }
-
-  void seek(uint offset, uint mode = seek_start) {
-    if(!fileopen) { return; }
-
-    switch(mode) {
-    case seek_start:   filepos  = offset;            break;
-    case seek_end:     filepos  = filesize + offset; break;
-    case seek_back:    filepos -= offset;            break;
-    case seek_forward: filepos += offset;            break;
-    }
-
-    if(filemode == mode_read) {
-      if(filepos > filesize)filepos = filesize;
-    } else {
-      if(filepos > filesize)filesize = filepos;
-    }
-  }
-
-  void resize(uint size) {
-    filesize = size;
-    if(filepos > filesize)filepos = filesize;
-  }
-
-  uint offset() {
-    if(!fileopen) { return 0; }
-
-    return filepos;
-  }
-
-  uint size() {
-    if(!fileopen) { return 0; }
-
-    return filesize;
-  }
-
-  bool eof() {
-    if(!fileopen) { return true; }
-
-    return (filepos >= filesize);
-  }
-
-  bool open(const char *fn, uint mode) {
-    if(fileopen) { return false; }
-
-    strcpy(filename, fn ? fn : "");
-    filevirtual = (*filename == 0);
-    filemode = mode;
-    switch(filemode) {
-    case mode_read:
-    case mode_readwrite:
-      if(filevirtual == true) {
-        filesize = 0;
-      } else {
-        fp = fopen(filename, "rb");
-        if(!fp) { return false; }
-        filesize = fsize(fp);
-        fread(filedata.get(filesize), 1, filesize, fp);
-        fclose(fp);
-      }
-      break;
-    default:
-      filesize = 0;
-      break;
-    }
-    filepos  = 0;
-    fileopen = true;
-    return true;
-  }
-
-  bool open() {
-    return fileopen;
-  }
-
-  bool flush() {
-    if(!fileopen) { return false; }
-
-    switch(filemode) {
-    case mode_readwrite:
-    case mode_write:
-    case mode_writeread:
-      if(filevirtual == false) {
-        fp = fopen(filename, "wb");
-        if(!fp) { return false; }
-        fwrite(filedata.get(filesize), 1, filesize, fp);
-        fclose(fp);
-      }
-      break;
-    }
-    return true;
-  }
-
-  bool close() {
-    if(!fileopen) { return false; }
-
-  bool result = flush();
-    fileopen = false;
-    filedata.reset();
-    return result;
-  }
-
-  ramfile() {
-    fileopen = false;
-  }
-
-  ~ramfile() {
-    if(fileopen) { close(); }
-  }
-};
-
-/*****
- * diskfile
- *****/
-
-class diskfile : public file {
-private:
-FILE *fp;
-uint filemode;
-
-public:
-  void read(uint8 *data, uint length) {
-    if(!fp || filemode == mode_write) { return; }
-
-    fread(data, 1, length, fp);
-  }
-
-  uint8 read() {
-    if(!fp || filemode == mode_write) { return 0; }
-
-    if(eof() == true) { return 0xff; }
-    return fgetc(fp);
-  }
-
-  void write(uint8 *data, uint length) {
-    if(!fp || filemode == mode_read) { return; }
-
-    fwrite(data, 1, length, fp);
-  }
-
-  void write(uint8 data) {
-    if(!fp || filemode == mode_read) { return; }
-
-    fputc(data, fp);
-  }
-
-  void seek(uint offset, uint mode = seek_start) {
-    if(!fp) { return; }
-
-    switch(mode) {
-    default:
-    case seek_start:   fseek(fp, offset, SEEK_SET); break;
-    case seek_end:     fseek(fp, offset, SEEK_END); break;
-    case seek_back:    fseek(fp, offset, SEEK_CUR); break;
-    case seek_forward: fseek(fp, offset, SEEK_CUR); break;
-    }
-  }
-
-  void resize(uint size) {
-    if(!fp) { return; }
-
-    fresize(fp, size);
-  }
-
-  uint offset() {
-    if(!fp) { return 0; }
-
-    return ftell(fp);
-  }
-
-  uint size() {
-    if(!fp) { return 0; }
-
-  uint pos = ftell(fp);
-    fseek(fp, 0, SEEK_END);
-  uint filesize = ftell(fp);
-    fseek(fp, pos, SEEK_SET);
-    return filesize;
-  }
-
-  bool eof() {
-    if(!fp) { return true; }
-
-    if(feof(fp)) {
-      seek(size(), seek_start);
-      return true;
-    }
-
-    return false;
-  }
-
-  bool open(const char *filename, uint mode) {
-    if(fp) { return false; }
-
-    filemode = mode;
-  char m[8];
-    switch(filemode) {
-    default:
-    case mode_read:      strcpy(m, "rb");  break;
-    case mode_write:     strcpy(m, "wb");  break;
-    case mode_readwrite: strcpy(m, "rb+"); break;
-    case mode_writeread: strcpy(m, "wb+"); break;
-    }
-    fp = fopen(filename, m);
-    if(!fp) { return false; }
-    return true;
-  }
-
-  bool open() {
-    return (fp != 0);
-  }
-
-  bool flush() {
-    if(!fp) { return false; }
-
-    fflush(fp);
-    return true;
-  }
-
-  bool close() {
-    if(!fp) { return false; }
-
-    fclose(fp);
-    fp = 0;
-    return true;
-  }
-
-  diskfile() {
-    fp = 0;
-  }
-
-  ~diskfile() {
-    if(fp) { fclose(fp); }
-  }
-};
-
-/*****
- * directory object
- *****/
-
-class directory {
-public:
-  void open(const char *path) {}
-  void close() {}
-  uint read(char *filename, uint maxlength) { return 0; }
-};
-
-#endif
@@ -1,341 +1,100 @@
 /*
-  libfunctor : version 0.01 ~byuu (2007-01-04)
+  libfunctor : version 0.05 ~byuu (2007-09-08)
+  license: public domain
 */

-#ifndef __LIBFUNCTOR
-#define __LIBFUNCTOR
+#ifndef LIBFUNCTOR_H
+#define LIBFUNCTOR_H

-template<typename T> struct functor;
-template<typename T> struct functor_t;
+//prologue

-/*****
- * macros
- *****/
+#define TN typename

-#define base_functor \
-functor *f; \
-  virtual operator bool() const { return f && (bool)(*f); } \
-  virtual functor *copy() const { return f->copy(); } \
-  functor &operator=(const functor *source) { if(f) { delete f; } f = (source->f) ? source->copy() : 0; return *this; } \
-  functor &operator=(const functor &source) { if(f) { delete f; } f = (source.f)  ? source.copy()  : 0; return *this; } \
-  functor(const functor &source) { /* ........................ */ f = (source.f)  ? source.copy()  : 0; } \
-  functor() : f(0) {} \
-  ~functor() { if(f && f != this) { delete f; } }
+template<typename T> class functor;

-#define base_global_functor \
-  operator bool() const { return proc; } \
-  functor_t *copy() const { return new functor_t(*this); } \
-  functor_t(const functor_t &source) { proc = source.proc; }
+//parameters = 0

-#define base_member_functor \
-  operator bool() const { return obj && proc; } \
-  functor_t *copy() const { return new functor_t(*this); } \
-  functor_t(const functor_t &source) { obj = source.obj; proc = source.proc; } \
-C *obj;
+#define cat(n)  n
+#define TL typename R
+#define PL
+#define CL

-/*****
- * parameters = 0
- *****/
+#include "libfunctor_impl.h"

-template<typename R>
-struct functor<R (*)()> { base_functor
-  virtual R operator()() const { return (*f)(); }
-};
+//parameters = 1

-template<typename R>
-struct functor_t<R (*)()> : public functor<R (*)()> { base_global_functor
-R (*proc)();
-  R operator()() const { return (*proc)(); }
-  functor_t(R (*_proc)()) : proc(_proc) { this->f = this; }
-};
+#define cat(n)  , n
+#define TL TN R, TN P1
+#define PL P1 p1
+#define CL p1

-template<typename C, typename R>
-struct functor_t<R (C::*)()> : public functor<R (*)()> { base_member_functor
-R (C::*proc)();
-  R operator()() const { return (obj->*proc)(); }
-  functor_t(C *_obj, R (C::*_proc)()) : obj(_obj), proc(_proc) { this->f = this; }
-};
+#include "libfunctor_impl.h"

-template<typename R>
-functor_t<R (*)()> make_functor(R (*proc)()) {
-  return functor_t<R (*)()>(proc);
-}
+//parameters = 2

-template<typename C, typename R>
-functor_t<R (C::*)()> make_functor(C *obj, R (C::*proc)()) {
-  return functor_t<R (C::*)()>(obj, proc);
-}
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2
+#define PL P1 p1, P2 p2
+#define CL p1, p2

-/*****
- * parameters = 1
- *****/
+#include "libfunctor_impl.h"

-template<typename R, typename P1>
-struct functor<R (*)(P1)> { base_functor
-  virtual R operator()(P1 p1) const { return (*f)(p1); }
-};
+//parameters = 3

-template<typename R, typename P1>
-struct functor_t<R (*)(P1)> : public functor<R (*)(P1)> { base_global_functor
-R (*proc)(P1);
-  R operator()(P1 p1) const { return (*proc)(p1); }
-  functor_t(R (*_proc)(P1)) : proc(_proc) { this->f = this; }
-};
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3
+#define PL P1 p1, P2 p2, P3 p3
+#define CL p1, p2, p3

-template<typename C, typename R, typename P1>
-struct functor_t<R (C::*)(P1)> : public functor<R (*)(P1)> { base_member_functor
-R (C::*proc)(P1);
-  R operator()(P1 p1) const { return (obj->*proc)(p1); }
-  functor_t(C *_obj, R (C::*_proc)(P1)) : obj(_obj), proc(_proc) { this->f = this; }
-};
+#include "libfunctor_impl.h"

-template<typename R, typename P1>
-functor_t<R (*)(P1)> make_functor(R (*proc)(P1)) {
-  return functor_t<R (*)(P1)>(proc);
-}
+//parameters = 4

-template<typename C, typename R, typename P1>
-functor_t<R (C::*)(P1)> make_functor(C *obj, R (C::*proc)(P1)) {
-  return functor_t<R (C::*)(P1)>(obj, proc);
-}
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3, TN P4
+#define PL P1 p1, P2 p2, P3 p3, P4 p4
+#define CL p1, p2, p3, p4

-/*****
- * parameters = 2
- *****/
+#include "libfunctor_impl.h"

-template<typename R, typename P1, typename P2>
-struct functor<R (*)(P1, P2)> { base_functor
-  virtual R operator()(P1 p1, P2 p2) const { return (*f)(p1, p2); }
-};
+//parameters = 5

-template<typename R, typename P1, typename P2>
-struct functor_t<R (*)(P1, P2)> : public functor<R (*)(P1, P2)> { base_global_functor
-R (*proc)(P1, P2);
-  R operator()(P1 p1, P2 p2) const { return (*proc)(p1, p2); }
-  functor_t(R (*_proc)(P1, P2)) : proc(_proc) { this->f = this; }
-};
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3, TN P4, TN P5
+#define PL P1 p1, P2 p2, P3 p3, P4 p4, P5 p5
+#define CL p1, p2, p3, p4, p5

-template<typename C, typename R, typename P1, typename P2>
-struct functor_t<R (C::*)(P1, P2)> : public functor<R (*)(P1, P2)> { base_member_functor
-R (C::*proc)(P1, P2);
-  R operator()(P1 p1, P2 p2) const { return (obj->*proc)(p1, p2); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2)) : obj(_obj), proc(_proc) { this->f = this; }
-};
+#include "libfunctor_impl.h"

-template<typename R, typename P1, typename P2>
-functor_t<R (*)(P1, P2)> make_functor(R (*proc)(P1, P2)) {
-  return functor_t<R (*)(P1, P2)>(proc);
-}
+//parameters = 6

-template<typename C, typename R, typename P1, typename P2>
-functor_t<R (C::*)(P1, P2)> make_functor(C *obj, R (C::*proc)(P1, P2)) {
-  return functor_t<R (C::*)(P1, P2)>(obj, proc);
-}
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3, TN P4, TN P5, TN P6
+#define PL P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6
+#define CL p1, p2, p3, p4, p5, p6

-/*****
- * parameters = 3
- *****/
+#include "libfunctor_impl.h"

-template<typename R, typename P1, typename P2, typename P3>
-struct functor<R (*)(P1, P2, P3)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3) const { return (*f)(p1, p2, p3); }
-};
+//parameters = 7

-template<typename R, typename P1, typename P2, typename P3>
-struct functor_t<R (*)(P1, P2, P3)> : public functor<R (*)(P1, P2, P3)> { base_global_functor
-R (*proc)(P1, P2, P3);
-  R operator()(P1 p1, P2 p2, P3 p3) const { return (*proc)(p1, p2, p3); }
-  functor_t(R (*_proc)(P1, P2, P3)) : proc(_proc) { this->f = this; }
-};
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3, TN P4, TN P5, TN P6, TN P7
+#define PL P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7
+#define CL p1, p2, p3, p4, p5, p6, p7

-template<typename C, typename R, typename P1, typename P2, typename P3>
-struct functor_t<R (C::*)(P1, P2, P3)> : public functor<R (*)(P1, P2, P3)> { base_member_functor
-R (C::*proc)(P1, P2, P3);
-  R operator()(P1 p1, P2 p2, P3 p3) const { return (obj->*proc)(p1, p2, p3); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3)) : obj(_obj), proc(_proc) { this->f = this; }
-};
+#include "libfunctor_impl.h"

-template<typename R, typename P1, typename P2, typename P3>
-functor_t<R (*)(P1, P2, P3)> make_functor(R (*proc)(P1, P2, P3)) {
-  return functor_t<R (*)(P1, P2, P3)>(proc);
-}
+//parameters = 8

-template<typename C, typename R, typename P1, typename P2, typename P3>
-functor_t<R (C::*)(P1, P2, P3)> make_functor(C *obj, R (C::*proc)(P1, P2, P3)) {
-  return functor_t<R (C::*)(P1, P2, P3)>(obj, proc);
-}
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2, TN P3, TN P4, TN P5, TN P6, TN P7, TN P8
+#define PL P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8
+#define CL p1, p2, p3, p4, p5, p6, p7, p8

-/*****
- * parameters = 4
- *****/
+#include "libfunctor_impl.h"

-template<typename R, typename P1, typename P2, typename P3, typename P4>
-struct functor<R (*)(P1, P2, P3, P4)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4) const { return (*f)(p1, p2, p3, p4); }
-};
+//epilogue

-template<typename R, typename P1, typename P2, typename P3, typename P4>
-struct functor_t<R (*)(P1, P2, P3, P4)> : public functor<R (*)(P1, P2, P3, P4)> { base_global_functor
-R (*proc)(P1, P2, P3, P4);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4) const { return (*proc)(p1, p2, p3, p4); }
-  functor_t(R (*_proc)(P1, P2, P3, P4)) : proc(_proc) { this->f = this; }
-};
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4>
-struct functor_t<R (C::*)(P1, P2, P3, P4)> : public functor<R (*)(P1, P2, P3, P4)> { base_member_functor
-R (C::*proc)(P1, P2, P3, P4);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4) const { return (obj->*proc)(p1, p2, p3, p4); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3, P4)) : obj(_obj), proc(_proc) { this->f = this; }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4>
-functor_t<R (*)(P1, P2, P3, P4)> make_functor(R (*proc)(P1, P2, P3, P4)) {
-  return functor_t<R (*)(P1, P2, P3, P4)>(proc);
-}
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4>
-functor_t<R (C::*)(P1, P2, P3, P4)> make_functor(C *obj, R (C::*proc)(P1, P2, P3, P4)) {
-  return functor_t<R (C::*)(P1, P2, P3, P4)>(obj, proc);
-}
-
-/*****
- * parameters = 5
- *****/
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
-struct functor<R (*)(P1, P2, P3, P4, P5)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const { return (*f)(p1, p2, p3, p4, p5); }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
-struct functor_t<R (*)(P1, P2, P3, P4, P5)> : public functor<R (*)(P1, P2, P3, P4, P5)> { base_global_functor
-R (*proc)(P1, P2, P3, P4, P5);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const { return (*proc)(p1, p2, p3, p4, p5); }
-  functor_t(R (*_proc)(P1, P2, P3, P4, P5)) : proc(_proc) { this->f = this; }
-};
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
-struct functor_t<R (C::*)(P1, P2, P3, P4, P5)> : public functor<R (*)(P1, P2, P3, P4, P5)> { base_member_functor
-R (C::*proc)(P1, P2, P3, P4, P5);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const { return (obj->*proc)(p1, p2, p3, p4, p5); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3, P4, P5)) : obj(_obj), proc(_proc) { this->f = this; }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
-functor_t<R (*)(P1, P2, P3, P4, P5)> make_functor(R (*proc)(P1, P2, P3, P4, P5)) {
-  return functor_t<R (*)(P1, P2, P3, P4, P5)>(proc);
-}
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
-functor_t<R (C::*)(P1, P2, P3, P4, P5)> make_functor(C *obj, R (C::*proc)(P1, P2, P3, P4, P5)) {
-  return functor_t<R (C::*)(P1, P2, P3, P4, P5)>(obj, proc);
-}
-
-/*****
- * parameters = 6
- *****/
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-struct functor<R (*)(P1, P2, P3, P4, P5, P6)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const { return (*f)(p1, p2, p3, p4, p5, p6); }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-struct functor_t<R (*)(P1, P2, P3, P4, P5, P6)> : public functor<R (*)(P1, P2, P3, P4, P5, P6)> { base_global_functor
-R (*proc)(P1, P2, P3, P4, P5, P6);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const { return (*proc)(p1, p2, p3, p4, p5, p6); }
-  functor_t(R (*_proc)(P1, P2, P3, P4, P5, P6)) : proc(_proc) { this->f = this; }
-};
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-struct functor_t<R (C::*)(P1, P2, P3, P4, P5, P6)> : public functor<R (*)(P1, P2, P3, P4, P5, P6)> { base_member_functor
-R (C::*proc)(P1, P2, P3, P4, P5, P6);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const { return (obj->*proc)(p1, p2, p3, p4, p5, p6); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3, P4, P5, P6)) : obj(_obj), proc(_proc) { this->f = this; }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-functor_t<R (*)(P1, P2, P3, P4, P5, P6)> make_functor(R (*proc)(P1, P2, P3, P4, P5, P6)) {
-  return functor_t<R (*)(P1, P2, P3, P4, P5, P6)>(proc);
-}
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-functor_t<R (C::*)(P1, P2, P3, P4, P5, P6)> make_functor(C *obj, R (C::*proc)(P1, P2, P3, P4, P5, P6)) {
-  return functor_t<R (C::*)(P1, P2, P3, P4, P5, P6)>(obj, proc);
-}
-
-/*****
- * parameters = 7
- *****/
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-struct functor<R (*)(P1, P2, P3, P4, P5, P6, P7)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const { return (*f)(p1, p2, p3, p4, p5, p6, p7); }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-struct functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7)> : public functor<R (*)(P1, P2, P3, P4, P5, P6, P7)> { base_global_functor
-R (*proc)(P1, P2, P3, P4, P5, P6, P7);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const { return (*proc)(p1, p2, p3, p4, p5, p6, p7); }
-  functor_t(R (*_proc)(P1, P2, P3, P4, P5, P6, P7)) : proc(_proc) { this->f = this; }
-};
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-struct functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7)> : public functor<R (*)(P1, P2, P3, P4, P5, P6, P7)> { base_member_functor
-R (C::*proc)(P1, P2, P3, P4, P5, P6, P7);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const { return (obj->*proc)(p1, p2, p3, p4, p5, p6, p7); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3, P4, P5, P6, P7)) : obj(_obj), proc(_proc) { this->f = this; }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7)> make_functor(R (*proc)(P1, P2, P3, P4, P5, P6, P7)) {
-  return functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7)>(proc);
-}
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7)> make_functor(C *obj, R (C::*proc)(P1, P2, P3, P4, P5, P6, P7)) {
-  return functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7)>(obj, proc);
-}
-
-/*****
- * parameters = 8
- *****/
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-struct functor<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)> { base_functor
-  virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const { return (*f)(p1, p2, p3, p4, p5, p6, p7, p8); }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-struct functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)> : public functor<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)> { base_global_functor
-R (*proc)(P1, P2, P3, P4, P5, P6, P7, P8);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const { return (*proc)(p1, p2, p3, p4, p5, p6, p7, p8); }
-  functor_t(R (*_proc)(P1, P2, P3, P4, P5, P6, P7, P8)) : proc(_proc) { this->f = this; }
-};
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-struct functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7, P8)> : public functor<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)> { base_member_functor
-R (C::*proc)(P1, P2, P3, P4, P5, P6, P7, P8);
-  R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const { return (obj->*proc)(p1, p2, p3, p4, p5, p6, p7, p8); }
-  functor_t(C *_obj, R (C::*_proc)(P1, P2, P3, P4, P5, P6, P7, P8)) : obj(_obj), proc(_proc) { this->f = this; }
-};
-
-template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)> make_functor(R (*proc)(P1, P2, P3, P4, P5, P6, P7, P8)) {
-  return functor_t<R (*)(P1, P2, P3, P4, P5, P6, P7, P8)>(proc);
-}
-
-template<typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7, P8)> make_functor(C *obj, R (C::*proc)(P1, P2, P3, P4, P5, P6, P7, P8)) {
-  return functor_t<R (C::*)(P1, P2, P3, P4, P5, P6, P7, P8)>(obj, proc);
-}
-
-/*****
- * epilogue
- *****/
-
-#undef base_functor
-#undef base_global_functor
-#undef base_member_functor
+#undef TN

 #endif
@@ -0,0 +1,81 @@
+#ifdef LIBFUNCTOR_H
+
+template<TL>
+class functor<R (PL)> {
+private:
+  struct base1 { virtual void func1(PL) {} };
+  struct base2 { virtual void func2(PL) {} };
+  struct derived : base1, virtual base2 {};
+
+  struct data_t {
+    R (*fn_call)(const data_t& cat(PL));
+    union {
+      R (*fn_global)(PL);
+      struct {
+        R (derived::*fn_member)(PL);
+        void *object;
+      };
+    };
+  } data;
+
+  static R fn_call_global(const data_t &d cat(PL)) {
+    return d.fn_global(CL);
+  }
+
+  template<typename C>
+  static R fn_call_member(const data_t &d cat(PL)) {
+    return (((C*)d.object)->*((R (C::*&)(PL))d.fn_member))(CL);
+  }
+
+public:
+  R operator()(PL) const { return data.fn_call(data cat(CL)); }
+  operator bool() const { return data.fn_call; }
+
+  functor() { data.fn_call = 0; }
+
+  functor(R (*fn)(PL)) {
+    data.fn_call = &fn_call_global;
+    data.fn_global = fn;
+  }
+
+  template<typename C>
+  functor(R (C::*fn)(PL), C *obj) {
+    data.fn_call = &fn_call_member<C>;
+    (R (C::*&)(PL))data.fn_member = fn;
+    assert(sizeof data.fn_member >= sizeof fn);
+    data.object = obj;
+  }
+
+  template<typename C>
+  functor(R (C::*fn)(PL) const, C *obj) {
+    data.fn_call = &fn_call_member<C>;
+    (R (C::*&)(PL))data.fn_member = (R (C::*&)(PL))fn;
+    assert(sizeof data.fn_member >= sizeof fn);
+    data.object = obj;
+  }
+
+  functor &operator=(const functor &source) { memcpy(&data, &source.data, sizeof(data_t)); return *this; }
+  functor(const functor &source) { memcpy(&data, &source.data, sizeof(data_t)); }
+};
+
+template<TL>
+functor<R (PL)> bind(R (*fn)(PL)) {
+  return functor<R (PL)>(fn);
+}
+
+template<typename C, TL>
+functor<R (PL)> bind(R (C::*fn)(PL), C *obj) {
+  return functor<R (PL)>(fn, obj);
+}
+
+template<typename C, TL>
+functor<R (PL)> bind(R (C::*fn)(PL) const, C *obj) {
+  return functor<R (PL)>(fn, obj);
+}
+
+#undef cat
+#undef TL
+#undef PL
+#undef CL
+
+#endif
@@ -1,73 +0,0 @@
-/*
-  libinterp : version 0.01 ~byuu (2007-02-03)
-*/
-
-#ifndef __LIBINTERP
-#define __LIBINTERP
-
-static inline
-double interpolate_point(
-  double mu,
-  double y0, double y1
-) {
-  return mu < 0.5 ? y0 : y1;
-}
-
-static inline
-double interpolate_linear(
-  double mu,
-  double y0, double y1
-) {
-  return y0 + mu * (y1 - y0);
-}
-
-static inline
-double interpolate_cosine(
-  double mu,
-  double y0, double y1
-) {
-  mu = (1.0 - cos(mu * 3.14159265)) / 2.0;
-  return y0 + mu * (y1 - y0);
-}
-
-static inline
-double interpolate_cubic(
-  double mu,
-  double y0, double y1, double y2, double y3
-) {
-double a0 = y3 - y2 - y0 + y1;
-double a1 = y0 - y1 - a0;
-double a2 = y2 - y0;
-double a3 = y1;
-  return a0 * mu * mu * mu +
-         a1 * mu * mu +
-         a2 * mu +
-         a3;
-}
-
-/*
-  tension: (0 = normal, -1 = low, +1 = high)
-  bias: (0 = even, -n = left, +n = right)
-*/
-static inline
-double interpolate_hermite(
-  double mu, double tension, double bias,
-  double y0, double y1, double y2, double y3
-) {
-double mu0 = ( (y1 - y0) * (1.0 + bias) * (1.0 - tension) / 2.0 ) +
-             ( (y2 - y1) * (1.0 - bias) * (1.0 - tension) / 2.0 );
-double mu1 = ( (y2 - y1) * (1.0 + bias) * (1.0 - tension) / 2.0 ) +
-             ( (y3 - y2) * (1.0 - bias) * (1.0 - tension) / 2.0 );
-double mu2 = mu * mu;
-double mu3 = mu * mu * mu;
-double a0  =  2.0 * mu3 - 3.0 * mu2 + 1.0;
-double a1  =        mu3 - 2.0 * mu2 + mu;
-double a2  =        mu3 -       mu2;
-double a3  = -2.0 * mu3 + 3.0 * mu2;
-  return a0 * y1 +
-         a1 * mu0 +
-         a2 * mu1 +
-         a3 * y2;
-}
-
-#endif
@@ -7,6 +7,28 @@

 namespace keymap {

+//TODO: use lookup table for find() functions
+static char keytable[][64] = {
+  "none",
+  "esc",
+  "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12",
+  "print_screen", "sys_req", "scroll_lock", "pause", "brk",
+  "grave", "tilde",
+  "num_1", "exclamation",
+  "num_2", "at",
+  "num_3", "pound",
+  "num_4", "dollar",
+  "num_5", "percent",
+  "num_6", "power",
+  "num_7", "ampersand",
+  "num_8", "asterisk",
+  "num_9", "lparenthesis",
+  "num_0", "rparenthesis",
+  "minus", "underscore",
+  "equal", "plus",
+  "backspace",
+};
+
 enum {
  none = 0x0000,

@@ -108,6 +130,8 @@ enum {
  rsuper,
  menu,

+  limit, //not an actual key -- marks the end of linear key entries
+
  joypad_flag    = 0x8000,
  joypad_nummask = 0x7f00,
  joypad_keymask = 0x00ff,
@@ -2,8 +2,8 @@
  libsort : version 0.01 ~byuu (2006-11-15)
 */

-#ifndef __LIBSORT
-#define __LIBSORT
+#ifndef LIBSORT_H
+#define LIBSORT_H

 template<typename T>
 void sort(T list[], uint length) {
@@ -1,9 +1,9 @@
 /*
-  libstring : version 0.17 ~byuu (2007-05-20)
+  libstring : version 0.18 ~byuu (2007-06-06)
 */

-#ifndef __LIBSTRING
-#define __LIBSTRING
+#ifndef LIBSTRING_H
+#define LIBSTRING_H

 #include "libbase.h"
 #include "libvector.h"
@@ -189,35 +189,32 @@ uint size;

  ~string() { safe_free(s); }

-  const char *operator()();
-  char &operator[](const uint);
-  string &operator= (const int);
-  string &operator= (const char *);
-  string &operator= (const string &);
-  string &operator+=(const int);
-  string &operator+=(const char *);
-  string &operator+=(const string &);
-  bool operator==(const char *);
-  bool operator==(const string &);
-  bool operator!=(const char *);
-  bool operator!=(const string &);
-  bool operator< (const char *);
-  bool operator< (const string &);
-  bool operator<=(const char *);
-  bool operator<=(const string &);
-  bool operator> (const char *);
-  bool operator> (const string &);
-  bool operator>=(const char *);
-  bool operator>=(const string &);
+  operator const char*()   const { return s; }
+  const char* operator()() const { return s; }
+  char& operator[](const uint);

-  string operator+(const int);
-  string operator+(const char *);
-  string operator+(const string &);
+  string& operator=(const int);
+  string& operator=(const char*);
+  string& operator=(const string&);
+
+  string& operator<<(const int);
+  string& operator<<(const char*);
+  string& operator<<(const string&);
+
+  bool operator==(const char*);
+  bool operator==(const string&);
+  bool operator!=(const char*);
+  bool operator!=(const string&);
+  bool operator< (const char*);
+  bool operator< (const string&);
+  bool operator<=(const char*);
+  bool operator<=(const string&);
+  bool operator> (const char*);
+  bool operator> (const string&);
+  bool operator>=(const char*);
+  bool operator>=(const string&);
 };

-string operator+(const int,    const string &);
-string operator+(const char *, const string &);
-
 inline void swap(string &x, string &y) { x.swap(y); }

-#endif //__LIBSTRING
+#endif //LIBSTRING_H
@@ -1,7 +1,3 @@
-const char *string::operator()() {
-  return s;
-}
-
 char &string::operator[](const uint index) {
  reserve(index);
  return s[index];
@@ -22,17 +18,17 @@ string &string::operator=(const string &str) {
  return *this;
 }

-string &string::operator+=(const int num) {
+string& string::operator<<(const int num) {
  strcat(*this, strfmt("%d", num));
  return *this;
 }

-string &string::operator+=(const char *str) {
+string& string::operator<<(const char* str) {
  strcat(*this, str);
  return *this;
 }

-string &string::operator+=(const string &str) {
+string& string::operator<<(const string& str) {
  strcat(*this, str);
  return *this;
 }
@@ -49,35 +45,3 @@ bool string::operator> (const char   *str) { return strcmp(strptr(*this), str)
 bool string::operator> (const string &str) { return strcmp(strptr(*this), strptr(str))  > 0; }
 bool string::operator>=(const char   *str) { return strcmp(strptr(*this), str)         >= 0; }
 bool string::operator>=(const string &str) { return strcmp(strptr(*this), strptr(str)) >= 0; }
-
-string string::operator+(const int num) {
-string temp(*this);
-  strcat(temp, strfmt("%d", num));
-  return temp;
-}
-
-string string::operator+(const char *str) {
-string temp(*this);
-  strcat(temp, str);
-  return temp;
-}
-
-string string::operator+(const string &str) {
-string temp(*this);
-  strcat(temp, str);
-  return temp;
-}
-
-//
-
-string operator+(const int x, const string &y) {
-string temp(strfmt("%d", x));
-  strcat(temp, y);
-  return temp;
-}
-
-string operator+(const char *x, const string &y) {
-string temp(x);
-  strcat(temp, y);
-  return temp;
-}
@@ -40,13 +40,14 @@ uint get_screen_height() { return gdk_screen_height(); }

 //

-noinline bool gtk_file_load(Window &owner, char *filename, const char *filter, const char *path) {
+bool file_load(Window *owner, char *filename, const char *filter, const char *path) {
  strcpy(filename, "");

 GtkWidget *dialog = gtk_file_chooser_dialog_new("Load File",
-  GTK_WINDOW(owner.info.window), GTK_FILE_CHOOSER_ACTION_OPEN,
+  owner ? GTK_WINDOW(owner->info.window) : (GtkWindow*)0,
+  GTK_FILE_CHOOSER_ACTION_OPEN,
  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 0);
+  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (const gchar*)0);

  if(path && strcmp(path, "")) {
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
@@ -62,13 +63,14 @@ GtkWidget *dialog = gtk_file_chooser_dialog_new("Load File",
  return strcmp(filename, ""); //return true if filename != ""
 }

-noinline bool gtk_file_save(Window &owner, char *filename, const char *filter, const char *path) {
+bool file_save(Window *owner, char *filename, const char *filter, const char *path) {
  strcpy(filename, "");

 GtkWidget *dialog = gtk_file_chooser_dialog_new("Save File",
-  GTK_WINDOW(owner.info.window), GTK_FILE_CHOOSER_ACTION_SAVE,
+  owner ? GTK_WINDOW(owner->info.window) : (GtkWindow*)0,
+  GTK_FILE_CHOOSER_ACTION_SAVE,
  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, 0);
+  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, (const gchar*)0);

  if(path && strcmp(path, "")) {
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
@@ -85,19 +87,6 @@ GtkWidget *dialog = gtk_file_chooser_dialog_new("Save File",
  return strcmp(filename, ""); //return true if filename != ""
 }

-//FreeBSD 6.2-amd64 bug workaround for file_load() + file_save()
-//gdb reveals stack corruption when calling gtk_file_chooset_dialog_new() from inside
-//a member function. however, calling function with nesting sidesteps the bug ...
-//gdb shows that the corruption occurs inside a GTK+ internal library function ...
-
-bool file_load(Window &owner, char *filename, const char *filter, const char *path) {
-  return gtk_file_load(owner, filename, filter, path);
-}
-
-bool file_save(Window &owner, char *filename, const char *filter, const char *path) {
-  return gtk_file_save(owner, filename, filter, path);
-}
-
 //

 uint16 translate_key(uint key) {
@@ -1,5 +1,5 @@
 /*
-  libui_gtk ~byuu (2007-05-27)
+  libui_gtk ~byuu (2007-06-06)
  license: public domain
 */

@@ -28,8 +28,8 @@ bool events_pending();
 uint get_screen_width();
 uint get_screen_height();

-bool file_load(Window &owner, char *filename, const char *filter, const char *path = "");
-bool file_save(Window &owner, char *filename, const char *filter, const char *path = "");
+bool file_load(Window *owner, char *filename, const char *filter, const char *path = "");
+bool file_save(Window *owner, char *filename, const char *filter, const char *path = "");

 uint16 translate_key(uint key);

@@ -53,20 +53,22 @@ enum Style {

 MenuBar menu;
  void create(uint style, uint width, uint height, const char *caption = "");
-  void set_text(const char *str, ...);
+  void set_text(const char *str);
  void set_background_color(uint8 r, uint8 g, uint8 b);
  void focus();
+  bool focused();
  void move(uint x, uint y);
  void resize(uint width, uint height);
  virtual void show();
  virtual void hide();
-  virtual bool close() { return true; }
-  virtual void keydown(uint16 key) {}
-  virtual void keyup(uint16 key) {}
+  void show(bool state);
+  bool visible();
+  void fullscreen();
+  void unfullscreen();
+  void fullscreen(bool state);
+  bool is_fullscreen();

-  virtual int message(uint id, void *param = 0) {}
-  virtual void clicked(Control&) {}
-  virtual void changed(Control&) {}
+  virtual bool message(uint id, uintptr_t param = 0) { return true; }

 //private:
 struct {
@@ -321,13 +321,8 @@ void Label::create(Window &r_owner, uint style, uint x, uint y, uint width, uint
  gtk_widget_show(widget);
 }

-void Label::set_text(const char *str, ...) {
-va_list args;
-  va_start(args, str);
-string temp;
-  vsprintf(temp, str, args);
-  va_end(args);
-  gtk_label_set_label(GTK_LABEL(widget), strptr(temp));
+void Label::set_text(const char *str) {
+  gtk_label_set_label(GTK_LABEL(widget), str);
 }

 /*****
@@ -345,13 +340,8 @@ void Button::create(Window &r_owner, uint style, uint x, uint y, uint width, uin
  g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK(libui_control_clicked), (gpointer)this);
 }

-void Button::set_text(const char *str, ...) {
-va_list args;
-  va_start(args, str);
-string temp;
-  vsprintf(temp, str, args);
-  va_end(args);
-  gtk_button_set_label(GTK_BUTTON(widget), strptr(temp));
+void Button::set_text(const char *str) {
+  gtk_button_set_label(GTK_BUTTON(widget), str);
 }

 /*****
@@ -447,17 +437,11 @@ void Editbox::create(Window &r_owner, uint style, uint x, uint y, uint width, ui
  gtk_widget_show(widget);
 }

-void Editbox::set_text(const char *str, ...) {
-va_list args;
-  va_start(args, str);
-string temp;
-  vsprintf(temp, str, args);
-  va_end(args);
-
+void Editbox::set_text(const char *str) {
  if(multiline == false) {
-    gtk_entry_set_text(GTK_ENTRY(widget), strptr(temp));
+    gtk_entry_set_text(GTK_ENTRY(widget), str);
  } else {
-    gtk_text_buffer_set_text(buffer, strptr(temp), -1);
+    gtk_text_buffer_set_text(buffer, str, -1);
  }
 }

@@ -539,28 +523,16 @@ void Listbox::set_column_width(uint column, uint width) {
  gtk_tree_view_column_set_max_width(column_list[column], width);
 }

-void Listbox::add_item(const char *data, ...) {
-va_list args;
-  va_start(args, data);
-string temp;
-  vsprintf(temp, data, args);
-  va_end(args);
-
+void Listbox::add_item(const char *data) {
 stringarray part;
-  split(part, "|", temp);
+  split(part, "|", data);
  gtk_list_store_append(store, &iter);
  for(uint i = 0; i < count(part); i++) {
    gtk_list_store_set(store, &iter, i, strptr(part[i]), -1);
  }
 }

-void Listbox::set_item(uint index, const char *data, ...) {
-va_list args;
-  va_start(args, data);
-string temp;
-  vsprintf(temp, data, args);
-  va_end(args);
-
+void Listbox::set_item(uint index, const char *data) {
 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(subwidget));
  for(uint i = 0; i <= index; i++) {
    (i == 0) ?
@@ -569,14 +541,14 @@ GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(subwidget));
  }

 stringarray part;
-  split(part, "|", temp);
+  split(part, "|", data);
  for(uint i = 0; i < count(part); i++) {
    gtk_list_store_set(store, &iter, i, strptr(part[i]), -1);
  }
 }

-int Listbox::get_selection() {
 //... because gtk_tree_view_get_selected_row(GTK_TREE_VIEW(subwidget)) would be too easy ...
+int Listbox::get_selection() {
 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(subwidget));
 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(subwidget));
  if(gtk_tree_model_get_iter_first(model, &iter) == false) { return -1; }
@@ -588,18 +560,21 @@ GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(subwidget));
  return -1;
 }

-void Listbox::set_selection(int index) {
 //... because gtk_tree_view_set_selected_row(GTK_TREE_VIEW(subwidget), index) would be too easy ...
+void Listbox::set_selection(int index) {
+int current = get_selection();
 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(subwidget));
 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(subwidget));
  gtk_tree_selection_unselect_all(selection);
-  if(index < 0) { return; }
-  if(gtk_tree_model_get_iter_first(model, &iter) == false) { return; }
-  if(index == 0) { gtk_tree_selection_select_iter(selection, &iter); return; }
+  if(index < 0) { goto end; }
+  if(gtk_tree_model_get_iter_first(model, &iter) == false) { goto end; }
+  if(index == 0) { gtk_tree_selection_select_iter(selection, &iter); goto end; }
  for(uint i = 1; i < 100000; i++) {
-    if(gtk_tree_model_iter_next(model, &iter) == false) { return; }
-    if(index == i) { gtk_tree_selection_select_iter(selection, &iter); return; }
+    if(gtk_tree_model_iter_next(model, &iter) == false) { goto end; }
+    if(index == i) { gtk_tree_selection_select_iter(selection, &iter); goto end; }
  }
+end:
+  if(current != index) { owner->message(Message::Changed, (uintptr_t)this); }
 }

 void Listbox::reset() {
@@ -147,16 +147,19 @@ class Frame : public Control { public:
 };

 class Label : public Control { public:
+enum { ideal_height = 18 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
-  void set_text(const char *str, ...);
+  void set_text(const char *str);
 };

 class Button : public Control { public:
+enum { ideal_height = 30 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
-  void set_text(const char *str, ...);
+  void set_text(const char *str);
 };

 class Checkbox : public Control { public:
+enum { ideal_height = 18 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
  void check();
  void uncheck();
@@ -165,12 +168,14 @@ class Checkbox : public Control { public:
 };

 class Radiobox : public Control { public:
+enum { ideal_height = 18 };
  void create(Window &owner, ControlGroup &group, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
  void check();
  bool checked();
 };

 class Editbox : public Control { public:
+enum { ideal_height = 30 };
 enum {
  Multiline = (1 << 1),
  Readonly  = (1 << 2),
@@ -185,7 +190,7 @@ enum {
 };

  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
-  void set_text(const char *str, ...);
+  void set_text(const char *str);
  uint get_text(char *str, uint length);

 private:
@@ -210,8 +215,8 @@ enum {
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *columns = "");
  void autosize_columns();
  void set_column_width(uint column, uint width);
-  void add_item(const char *data, ...);
-  void set_item(uint index, const char *data, ...);
+  void add_item(const char *data);
+  void set_item(uint index, const char *data);
  int  get_selection();
  void set_selection(int index);
  void reset();
@@ -226,6 +231,7 @@ GtkTreeIter iter;
 };

 class Combobox : public Control { public:
+enum { ideal_height = 30 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height);
  void add_item(const char *data);
  int  get_selection();
@@ -237,12 +243,14 @@ uint counter;
 };

 class Progressbar : public Control { public:
+enum { ideal_height = 30 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height);
  void set_progress(uint progress);
  uint get_progress();
 };

 class Slider : public Control { public:
+enum { ideal_height = 25 };
 enum {
  Horizontal = 0,
  Vertical   = 1,
@@ -6,25 +6,25 @@ gint libui_window_close(GtkWidget *w, GdkEventAny *any, Window *window) {
 }

 gint libui_window_keydown(GtkWidget *w, GdkEventKey *key, Window *window) {
-  if(window) { window->message(Message::KeyDown, (void*)libui::translate_key(key->keyval)); }
+  if(window) { window->message(Message::KeyDown, libui::translate_key(key->keyval)); }
  return FALSE;
 }

 gint libui_window_keyup(GtkWidget *w, GdkEventKey *key, Window *window) {
-  if(window) { window->message(Message::KeyUp, (void*)libui::translate_key(key->keyval)); }
+  if(window) { window->message(Message::KeyUp, libui::translate_key(key->keyval)); }
  return FALSE;
 }

 void libui_control_clicked(Control *control) {
-  if(control && control->owner) { control->owner->message(Message::Clicked, control); }
+  if(control && control->owner) { control->owner->message(Message::Clicked, (uintptr_t)control); }
 }

 void libui_control_changed(Control *control) {
-  if(control && control->owner) { control->owner->message(Message::Changed, control); }
+  if(control && control->owner) { control->owner->message(Message::Changed, (uintptr_t)control); }
 }

 void libui_control_double_clicked(Control *control) {
-  if(control && control->owner) { control->owner->message(Message::DoubleClicked, control); }
+  if(control && control->owner) { control->owner->message(Message::DoubleClicked, (uintptr_t)control); }
 }

 void Window::create(uint style, uint width, uint height, const char *caption) {
@@ -56,6 +56,10 @@ void Window::focus() {
  gtk_window_present(GTK_WINDOW(info.window));
 }

+bool Window::focused() {
+  return GTK_WIDGET_HAS_FOCUS(info.window);
+}
+
 void Window::move(uint x, uint y) {
 //if window was centered before, GTK+ will ignore move requests,
 //therfore we must turn off auto-centering.
@@ -75,13 +79,32 @@ void Window::hide() {
  gtk_widget_hide(info.window);
 }

-void Window::set_text(const char *str, ...) {
-va_list args;
-  va_start(args, str);
-string temp;
-  vsprintf(temp, str, args);
-  va_end(args);
-  gtk_window_set_title(GTK_WINDOW(info.window), strptr(temp));
+void Window::show(bool state) {
+  (state == true) ? show() : hide();
+}
+
+bool Window::visible() {
+  return GTK_WIDGET_VISIBLE(info.window);
+}
+
+void Window::fullscreen() {
+  gtk_window_fullscreen(GTK_WINDOW(info.window));
+}
+
+void Window::unfullscreen() {
+  gtk_window_unfullscreen(GTK_WINDOW(info.window));
+}
+
+void Window::fullscreen(bool state) {
+  (state == true) ? fullscreen() : unfullscreen();
+}
+
+bool Window::is_fullscreen() {
+  return false;
+};
+
+void Window::set_text(const char *str) {
+  gtk_window_set_title(GTK_WINDOW(info.window), str);
 }

 void Window::set_background_color(uint8 r, uint8 g, uint8 b) {
@@ -1,3 +1,5 @@
+#define _WIN32_IE 0x0600
+
 #include "libui_win.h"
 #include "libui_win_window.cpp"
 #include "libui_win_control.cpp"
@@ -81,7 +83,7 @@ uint get_screen_height() { return GetSystemMetrics(SM_CYSCREEN); }

 //

-bool file_load(Window &owner, char *filename, const char *filter, const char *path) {
+bool file_load(Window *owner, char *filename, const char *filter, const char *path) {
 string dir, f;
  strcpy(dir, path ? path : "");
  replace(dir, "/", "\\");
@@ -111,7 +113,7 @@ OPENFILENAME ofn;
  strcpy(filename, "");
  memset(&ofn, 0, sizeof(ofn));
  ofn.lStructSize     = sizeof(ofn);
-  ofn.hwndOwner       = owner.info.hwnd;
+  ofn.hwndOwner       = owner ? owner->info.hwnd : 0;
  ofn.lpstrFilter     = pf;
  ofn.lpstrInitialDir = strptr(dir);
  ofn.lpstrFile       = filename;
@@ -122,7 +124,7 @@ OPENFILENAME ofn;
  return GetOpenFileName(&ofn);
 }

-bool file_save(Window &owner, char *filename, const char *filter, const char *path) {
+bool file_save(Window *owner, char *filename, const char *filter, const char *path) {
 string dir, f;
  strcpy(dir, path ? path : "");
  replace(dir, "/", "\\");
@@ -152,7 +154,7 @@ OPENFILENAME ofn;
  strcpy(filename, "");
  memset(&ofn, 0, sizeof(ofn));
  ofn.lStructSize     = sizeof(ofn);
-  ofn.hwndOwner       = owner.info.hwnd;
+  ofn.hwndOwner       = owner ? owner->info.hwnd : 0;
  ofn.lpstrFilter     = pf;
  ofn.lpstrInitialDir = strptr(dir);
  ofn.lpstrFile       = filename;
@@ -170,6 +172,19 @@ uint16 translate_key(uint key) {

  case VK_ESCAPE: return keymap::esc;

+  case VK_F1:     return keymap::f1;
+  case VK_F2:     return keymap::f2;
+  case VK_F3:     return keymap::f3;
+  case VK_F4:     return keymap::f4;
+  case VK_F5:     return keymap::f5;
+  case VK_F6:     return keymap::f6;
+  case VK_F7:     return keymap::f7;
+  case VK_F8:     return keymap::f8;
+  case VK_F9:     return keymap::f9;
+  case VK_F10:    return keymap::f10;
+  case VK_F11:    return keymap::f11;
+  case VK_F12:    return keymap::f12;
+
  case VK_TAB:    return keymap::tab;
  case VK_RETURN: return keymap::enter;
  case VK_SPACE:  return keymap::space;
@@ -1,5 +1,5 @@
 /*
-  libui_win ~byuu (2007-05-28)
+  libui_win ~byuu (2007-06-10)
  license: public domain
 */

@@ -32,8 +32,8 @@ bool events_pending();
 uint get_screen_width();
 uint get_screen_height();

-bool file_load(Window &owner, char *filename, const char *filter, const char *path = "");
-bool file_save(Window &owner, char *filename, const char *filter, const char *path = "");
+bool file_load(Window *owner, char *filename, const char *filter, const char *path = "");
+bool file_save(Window *owner, char *filename, const char *filter, const char *path = "");

 uint16 translate_key(uint key);

@@ -60,12 +60,19 @@ MenuBar menu;
  void set_text(const char *str, ...);
  void set_background_color(uint8 r, uint8 g, uint8 b);
  void focus();
+  bool focused();
  void move(uint x, uint y);
  void resize(uint width, uint height);
  virtual void show();
  virtual void hide();
+  void show(bool state);
+  bool visible();
+  void fullscreen();
+  void unfullscreen();
+  void fullscreen(bool state);
+  bool is_fullscreen();

-  virtual int message(uint id, void *param = 0) { return 0; }
+  virtual bool message(uint id, uintptr_t param = 0) { return true; }

  void move(Control &control, uint x, uint y);
  void attach(Control &control);
@@ -78,6 +85,7 @@ MenuBar menu;
 //private:
 struct {
  uint width, height;
+  bool fullscreen;

  HWND hwnd;
  HWND hwnd_resize;
@@ -4,6 +4,10 @@ namespace libui {
 * Control
 *****/

+void Control::move(uint x, uint y) {
+  SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
 void Control::resize(uint width, uint height) {
  SetWindowPos(hwnd, 0, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE);
 }
@@ -137,13 +141,13 @@ void MenuCheckItem::create(MenuGroup &r_owner, const char *caption) {
 void MenuCheckItem::check() {
  if(checked() == true)return;
  CheckMenuItem(parent, id, MF_CHECKED);
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 void MenuCheckItem::uncheck() {
  if(checked() == false)return;
  CheckMenuItem(parent, id, MF_UNCHECKED);
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 void MenuCheckItem::check(bool state) {
@@ -180,7 +184,7 @@ void MenuRadioItem::check() {
  for(uint i = 0; i < group.count(); i++) {
    CheckMenuItem(parent, group[i].id, (id == group[i].id) ? MF_CHECKED : MF_UNCHECKED);
  }
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 bool MenuRadioItem::checked() {
@@ -355,11 +359,20 @@ long __stdcall label_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
    BeginPaint(hwnd, &ps);
  RECT rc;
  char t[4096];
-    GetWindowText(hwnd, t, 4095);
+    GetWindowText(hwnd, t, 4095); //TODO: use internal buffer, so length is not limited ...
    GetClientRect(hwnd, &rc);
    SetTextColor(ps.hdc, RGB(0, 0, 0));
    SetBkMode(ps.hdc, TRANSPARENT);
    SelectObject(ps.hdc, (HGDIOBJ)libui::font.variable);
+  //center text if text height < control height, otherwise draw from top left corner
+  RECT trc;
+    GetClientRect(hwnd, &trc);
+    DrawText(ps.hdc, t, strlen(t), &trc, DT_CALCRECT);
+    if(trc.bottom < rc.bottom) {
+      rc.top = (rc.bottom - trc.bottom) / 2;
+      rc.bottom = rc.top + trc.bottom;
+    }
+  //
    DrawText(ps.hdc, t, strlen(t), &rc, DT_END_ELLIPSIS | DT_NOPREFIX);
    EndPaint(hwnd, &ps);
  } break;
@@ -419,13 +432,13 @@ void Checkbox::create(Window &r_owner, uint style, uint x, uint y, uint width, u
 void Checkbox::check() {
  if(checked() == true)return;
  SendMessage(hwnd, BM_SETCHECK, (WPARAM)TRUE, 0);
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 void Checkbox::uncheck() {
  if(checked() == false)return;
  SendMessage(hwnd, BM_SETCHECK, (WPARAM)FALSE, 0);
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 void Checkbox::check(bool state) {
@@ -456,7 +469,7 @@ void Radiobox::check() {
  for(uint i = 0; i < group.count(); i++) {
    SendMessage(group[i].hwnd, BM_SETCHECK, (group[i].hwnd == hwnd) ? (WPARAM)TRUE : (WPARAM)FALSE, 0);
  }
-  owner->message(Message::Clicked, this);
+  owner->message(Message::Clicked, (uintptr_t)this);
 }

 bool Radiobox::checked() {
@@ -25,6 +25,7 @@ namespace ControlType {

 class Control { public:
 uint type;
+  void move(uint x, uint y);
  void resize(uint width, uint height);

  void focus();
@@ -156,15 +157,18 @@ class Frame : public Control { public:
 };

 class Label : public Control { public:
+enum { ideal_height = 16 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
  void set_text(const char *str, ...);
 };

 class Button : public Control { public:
+enum { ideal_height = 21 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
 };

 class Checkbox : public Control { public:
+enum { ideal_height = 15 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
  void check();
  void uncheck();
@@ -173,6 +177,7 @@ class Checkbox : public Control { public:
 };

 class Radiobox : public Control { public:
+enum { ideal_height = 15 };
  void create(Window &owner, ControlGroup &list, uint style, uint x, uint y, uint width, uint height, const char *caption = "");
  void check();
  bool checked();
@@ -182,6 +187,7 @@ ControlGroup group;
 };

 class Editbox : public Control { public:
+enum { ideal_height = 21 };
 enum {
  Multiline = (1 << 1),
  Readonly  = (1 << 2),
@@ -234,6 +240,7 @@ uint column_count;
 };

 class Combobox : public Control { public:
+enum { ideal_height = 21 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height);
  void add_item(const char *data);
  void set_selection(int index);
@@ -242,12 +249,14 @@ class Combobox : public Control { public:
 };

 class Progressbar : public Control { public:
+enum { ideal_height = 30 };
  void create(Window &owner, uint style, uint x, uint y, uint width, uint height);
  void set_progress(uint progress);
  uint get_progress();
 };

 class Slider : public Control { public:
+enum { ideal_height = 25 };
 enum Style {
  Horizontal = 0,
  Vertical   = 1,
@@ -33,11 +33,11 @@ long Window::wndproc(HWND hwnd, uint msg, WPARAM wparam, LPARAM lparam) {
  } break;

  case WM_KEYDOWN: {
-    message(Message::KeyDown, (void*)libui::translate_key(wparam));
+    message(Message::KeyDown, libui::translate_key(wparam));
  } break;

  case WM_KEYUP: {
-    message(Message::KeyUp,   (void*)libui::translate_key(wparam));
+    message(Message::KeyUp,   libui::translate_key(wparam));
  } break;

  case WM_COMMAND: {
@@ -68,7 +68,7 @@ long Window::wndproc(HWND hwnd, uint msg, WPARAM wparam, LPARAM lparam) {
  //emit Message::Clicked message directly
    case ControlType::MenuItem:
    case ControlType::Button: {
-      message(Message::Clicked, &control);
+      message(Message::Clicked, (uintptr_t)&control);
    } break;

    }
@@ -84,7 +84,7 @@ long Window::wndproc(HWND hwnd, uint msg, WPARAM wparam, LPARAM lparam) {
    switch(control.type) {

    case ControlType::Slider: {
-      message(Message::Changed, &control);
+      message(Message::Changed, (uintptr_t)&control);
    } break;

    }
@@ -104,12 +104,12 @@ long Window::wndproc(HWND hwnd, uint msg, WPARAM wparam, LPARAM lparam) {
        if(((LPNMLISTVIEW)lparam)->uChanged & LVIF_STATE) {
          if(ListView_GetItemState(listbox.hwnd, ((LPNMLISTVIEW)lparam)->iItem, LVIS_FOCUSED)) {
            if(ListView_GetItemState(listbox.hwnd, ((LPNMLISTVIEW)lparam)->iItem, LVIS_SELECTED)) {
-              message(Message::Changed, &control);
+              message(Message::Changed, (uintptr_t)&control);
            }
          }
        }
      } else if(((LPNMHDR)lparam)->code == LVN_ITEMACTIVATE) {
-        message(Message::DoubleClicked, &control);
+        message(Message::DoubleClicked, (uintptr_t)&control);
      }
    } break;

@@ -131,10 +131,14 @@ void Window::attach(Control &control) {
 }

 void Window::focus() {
-  show();
+  if(!visible()) { show(); }
  SetFocus(info.hwnd);
 }

+bool Window::focused() {
+  return (GetForegroundWindow() == info.hwnd);
+}
+
 void Window::move(Control &control, uint x, uint y) {
  SetWindowPos(control.hwnd, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
 }
@@ -180,6 +184,13 @@ RECT rc;
 }

 void Window::resize(uint width, uint height) {
+  if(info.fullscreen == true) {
+    info.width  = GetSystemMetrics(SM_CXSCREEN);
+    info.height = GetSystemMetrics(SM_CYSCREEN);
+    SetWindowPos(info.hwnd, 0, 0, 0, info.width, info.height, SWP_NOZORDER);
+    return;
+  }
+
  info.width  = width;
  info.height = height;

@@ -212,6 +223,36 @@ void Window::hide() {
  ShowWindow(info.hwnd, SW_HIDE);
 }

+void Window::show(bool state) {
+  (state == true) ? show() : hide();
+}
+
+bool Window::visible() {
+  return GetWindowLong(info.hwnd, GWL_STYLE) & WS_VISIBLE;
+}
+
+void Window::fullscreen() {
+  if(info.fullscreen)return;
+  info.fullscreen = true;
+  SetWindowLong(info.hwnd, GWL_STYLE, WS_VISIBLE | WS_POPUP);
+  resize(get_screen_width(), get_screen_height());
+}
+
+void Window::unfullscreen() {
+  if(!info.fullscreen)return;
+  info.fullscreen = false;
+  SetWindowLong(info.hwnd, GWL_STYLE, WS_POPUP | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX | WS_VISIBLE);
+  resize(info.width, info.height);
+}
+
+void Window::fullscreen(bool state) {
+  (state == true) ? fullscreen() : unfullscreen();
+}
+
+bool Window::is_fullscreen() {
+  return info.fullscreen;
+}
+
 //

 void Window::set_text(const char *str, ...) {
@@ -234,6 +275,7 @@ HBRUSH old_brush = info.background;
 //

 Window::Window() {
+  info.fullscreen    = false;
  info.background    = 0;
  info.center        = false;
  info.control_index = 1;
@@ -64,10 +64,8 @@
 * and speed is less critical.
 *****/

-#ifndef __LIBVECTOR
-#define __LIBVECTOR
-
-#include <new>
+#ifndef LIBVECTOR_H
+#define LIBVECTOR_H

 template<typename T> class linear_vector {
 protected:
@@ -27,11 +27,14 @@ void bMemBus::load_cart() {
    return;
  }

-  if(cartridge.info.sdd1)cart_map_sdd1();
-  if(cartridge.info.c4)  cart_map_c4();
-  if(cartridge.info.dsp1)cart_map_dsp1();
-  if(cartridge.info.dsp2)cart_map_dsp2();
-  if(cartridge.info.obc1)cart_map_obc1();
+  if(cartridge.info.sdd1) cart_map_sdd1();
+  if(cartridge.info.c4)   cart_map_c4();
+  if(cartridge.info.dsp1) cart_map_dsp1();
+  if(cartridge.info.dsp2) cart_map_dsp2();
+  if(cartridge.info.dsp3) cart_map_dsp3();
+  if(cartridge.info.dsp4) cart_map_dsp4();
+  if(cartridge.info.obc1) cart_map_obc1();
+  if(cartridge.info.st010)cart_map_st010();

  cart_map_system();

@@ -57,12 +60,19 @@ char t[256];
  dprintf("* Region   : %s", (cartridge.info.region == Cartridge::NTSC) ? "NTSC" : "PAL");

  strcpy(t, "");
-  if(cartridge.info.srtc)strcat(t, "S-RTC, ");
-  if(cartridge.info.sdd1)strcat(t, "S-DD1, ");
-  if(cartridge.info.c4)  strcat(t, "Cx4, ");
-  if(cartridge.info.dsp1)strcat(t, "DSP-1, ");
-  if(cartridge.info.dsp2)strcat(t, "DSP-2, ");
-  if(cartridge.info.obc1)strcat(t, "OBC-1, ");
+  if(cartridge.info.superfx)strcat(t, "SuperFX, ");
+  if(cartridge.info.sa1)    strcat(t, "SA-1, ");
+  if(cartridge.info.srtc)   strcat(t, "S-RTC, ");
+  if(cartridge.info.sdd1)   strcat(t, "S-DD1, ");
+  if(cartridge.info.c4)     strcat(t, "Cx4, ");
+  if(cartridge.info.dsp1)   strcat(t, "DSP-1, ");
+  if(cartridge.info.dsp2)   strcat(t, "DSP-2, ");
+  if(cartridge.info.dsp3)   strcat(t, "DSP-3, ");
+  if(cartridge.info.dsp4)   strcat(t, "DSP-4, ");
+  if(cartridge.info.obc1)   strcat(t, "OBC-1, ");
+  if(cartridge.info.st010)  strcat(t, "ST010, ");
+  if(cartridge.info.st011)  strcat(t, "ST011, ");
+  if(cartridge.info.st018)  strcat(t, "ST018, ");
  strrtrim(t, ", ");
  dprintf("* Coprocessor(s) : %s", (strlen(t) == 0) ? "None" : t);
  dprintf("* Reset:%0.4x NMI[n]:%0.4x IRQ[n]:%0.4x BRK[n]:%0.4x COP[n]:%0.4x",
@@ -39,8 +39,14 @@ enum { TYPE_WRAM, TYPE_MMIO, TYPE_CART };
  void   write_dsp1    (uint32 addr, uint8 data);
  uint8  read_dsp2     (uint32 addr);
  void   write_dsp2    (uint32 addr, uint8 data);
+  uint8  read_dsp3     (uint32 addr);
+  void   write_dsp3    (uint32 addr, uint8 data);
+  uint8  read_dsp4     (uint32 addr);
+  void   write_dsp4    (uint32 addr, uint8 data);
  uint8  read_obc1     (uint32 addr);
  void   write_obc1    (uint32 addr, uint8 data);
+  uint8  read_st010    (uint32 addr);
+  void   write_st010   (uint32 addr, uint8 data);

  void   cart_map_reset();
  void   cart_map_system();
@@ -50,7 +56,10 @@ enum { TYPE_WRAM, TYPE_MMIO, TYPE_CART };
  void   cart_map_c4();
  void   cart_map_dsp1();
  void   cart_map_dsp2();
+  void   cart_map_dsp3();
+  void   cart_map_dsp4();
  void   cart_map_obc1();
+  void   cart_map_st010();

  void   power();
  void   reset();
@@ -167,6 +167,30 @@ void bMemBus::cart_map_dsp2() {
  }
 }

+void bMemBus::cart_map_dsp3() {
+//$[20-3f|a0-bf]:[8000-ffff]
+  for(uint bank = 0x20; bank <= 0x3f; bank++) {
+    for(uint page = 0x80; page <= 0xff; page++) {
+      page_read [0x0000 + (bank << 8) + page] = &bMemBus::read_dsp3;
+      page_read [0x8000 + (bank << 8) + page] = &bMemBus::read_dsp3;
+      page_write[0x0000 + (bank << 8) + page] = &bMemBus::write_dsp3;
+      page_write[0x8000 + (bank << 8) + page] = &bMemBus::write_dsp3;
+    }
+  }
+}
+
+void bMemBus::cart_map_dsp4() {
+//$[30-3f|b0-bf]:[8000-ffff]
+  for(uint bank = 0x30; bank <= 0x3f; bank++) {
+    for(uint page = 0x80; page <= 0xff; page++) {
+      page_read [0x0000 + (bank << 8) + page] = &bMemBus::read_dsp4;
+      page_read [0x8000 + (bank << 8) + page] = &bMemBus::read_dsp4;
+      page_write[0x0000 + (bank << 8) + page] = &bMemBus::write_dsp4;
+      page_write[0x8000 + (bank << 8) + page] = &bMemBus::write_dsp4;
+    }
+  }
+}
+
 void bMemBus::cart_map_obc1() {
 //$[00-3f|80-bf]:[6000-7fff]
  for(uint bank = 0x00; bank <= 0x3f; bank++) {
@@ -178,3 +202,15 @@ void bMemBus::cart_map_obc1() {
    }
  }
 }
+
+void bMemBus::cart_map_st010() {
+//$[68-6f|e8-ef]:[0000-0fff]
+  for(uint bank = 0x68; bank <= 0x6f; bank++) {
+    for(uint page = 0x00; page <= 0x0f; page++) {
+      page_read [0x0000 + (bank << 8) + page] = &bMemBus::read_st010;
+      page_read [0x8000 + (bank << 8) + page] = &bMemBus::read_st010;
+      page_write[0x0000 + (bank << 8) + page] = &bMemBus::write_st010;
+      page_write[0x8000 + (bank << 8) + page] = &bMemBus::write_st010;
+    }
+  }
+}
@@ -39,26 +39,35 @@ void bMemBus::write_ram(uint32 addr, uint8 data) {
 //

 uint8 bMemBus::read_sdd1(uint32 addr) {
-  addr = sdd1->offset(addr) % cartridge.info.rom_size;
+  addr = sdd1.offset(addr) % cartridge.info.rom_size;
  return cartridge.rom[addr];
 }

 void bMemBus::write_sdd1(uint32 addr, uint8 data) {
  if(cart_write_protect_enabled == true)return;
-  addr = sdd1->offset(addr) % cartridge.info.rom_size;
+  addr = sdd1.offset(addr) % cartridge.info.rom_size;
  cartridge.rom[addr] = data;
 }

 //

-uint8 bMemBus::read_c4 (uint32 addr) { return c4->read(addr); }
-void  bMemBus::write_c4(uint32 addr, uint8 data) { c4->write(addr, data); }
+uint8 bMemBus::read_c4 (uint32 addr) { return c4.read(addr); }
+void  bMemBus::write_c4(uint32 addr, uint8 data) { c4.write(addr, data); }

-uint8 bMemBus::read_dsp1 (uint32 addr) { return dsp1->read(addr); }
-void  bMemBus::write_dsp1(uint32 addr, uint8 data) { dsp1->write(addr, data); }
+uint8 bMemBus::read_dsp1 (uint32 addr) { return dsp1.read(addr); }
+void  bMemBus::write_dsp1(uint32 addr, uint8 data) { dsp1.write(addr, data); }

-uint8 bMemBus::read_dsp2 (uint32 addr) { return dsp2->read(addr); }
-void  bMemBus::write_dsp2(uint32 addr, uint8 data) { dsp2->write(addr, data); }
+uint8 bMemBus::read_dsp2 (uint32 addr) { return dsp2.read(addr); }
+void  bMemBus::write_dsp2(uint32 addr, uint8 data) { dsp2.write(addr, data); }

-uint8 bMemBus::read_obc1 (uint32 addr) { return obc1->read(addr); }
-void  bMemBus::write_obc1(uint32 addr, uint8 data) { obc1->write(addr, data); }
+uint8 bMemBus::read_dsp3 (uint32 addr) { return dsp3.read(addr); }
+void  bMemBus::write_dsp3(uint32 addr, uint8 data) { dsp3.write(addr, data); }
+
+uint8 bMemBus::read_dsp4 (uint32 addr) { return dsp4.read(addr); }
+void  bMemBus::write_dsp4(uint32 addr, uint8 data) { dsp4.write(addr, data); }
+
+uint8 bMemBus::read_obc1 (uint32 addr) { return obc1.read(addr); }
+void  bMemBus::write_obc1(uint32 addr, uint8 data) { obc1.write(addr, data); }
+
+uint8 bMemBus::read_st010 (uint32 addr) { return st010.read(addr); }
+void  bMemBus::write_st010(uint32 addr, uint8 data) { st010.write(addr, data); }
@@ -1,30 +1,33 @@
 bool bMemBus::cart_map_pcb(const char *pcb) {
-  if(!strcmp(pcb, "SHVC-1A3B-01")) { cart_map_shvc_1a3b_13(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3B-11")) { cart_map_shvc_1a3b_13(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3B-12")) { cart_map_shvc_1a3b_13(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3B-13")) { cart_map_shvc_1a3b_13(); return true; }
+  if(!strcmp(pcb, "SHVC-1CB5B-01")) { cart_map_shvc_1cb5b_20(); return true; }
+  if(!strcmp(pcb, "SHVC-1CB5B-20")) { cart_map_shvc_1cb5b_20(); return true; }

-  if(!strcmp(pcb, "SHVC-1A3B-20")) { cart_map_shvc_1a3b_20(); return true; }
+  if(!strcmp(pcb, "SHVC-1A3B-01"))  { cart_map_shvc_1a3b_13();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3B-11"))  { cart_map_shvc_1a3b_13();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3B-12"))  { cart_map_shvc_1a3b_13();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3B-13"))  { cart_map_shvc_1a3b_13();  return true; }

-  if(!strcmp(pcb, "SHVC-1A3M-10")) { cart_map_shvc_1a3m_30(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3M-20")) { cart_map_shvc_1a3m_30(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3M-21")) { cart_map_shvc_1a3m_30(); return true; }
-  if(!strcmp(pcb, "SHVC-1A3M-30")) { cart_map_shvc_1a3m_30(); return true; }
+  if(!strcmp(pcb, "SHVC-1A3B-20"))  { cart_map_shvc_1a3b_20();  return true; }

-  if(!strcmp(pcb, "SHVC-1J3M-01")) { cart_map_shvc_1j3m_20(); return true; }
-  if(!strcmp(pcb, "SHVC-1J3M-10")) { cart_map_shvc_1j3m_20(); return true; }
-  if(!strcmp(pcb, "SHVC-1J3M-11")) { cart_map_shvc_1j3m_20(); return true; }
-  if(!strcmp(pcb, "SHVC-1J3M-20")) { cart_map_shvc_1j3m_20(); return true; }
+  if(!strcmp(pcb, "SHVC-1A3M-10"))  { cart_map_shvc_1a3m_30();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3M-20"))  { cart_map_shvc_1a3m_30();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3M-21"))  { cart_map_shvc_1a3m_30();  return true; }
+  if(!strcmp(pcb, "SHVC-1A3M-30"))  { cart_map_shvc_1a3m_30();  return true; }

-  if(!strcmp(pcb, "BSC-1A5M-01"))  { cart_map_bsc_1a5m_01();  return true; }
+  if(!strcmp(pcb, "SHVC-1J3M-01"))  { cart_map_shvc_1j3m_20();  return true; }
+  if(!strcmp(pcb, "SHVC-1J3M-10"))  { cart_map_shvc_1j3m_20();  return true; }
+  if(!strcmp(pcb, "SHVC-1J3M-11"))  { cart_map_shvc_1j3m_20();  return true; }
+  if(!strcmp(pcb, "SHVC-1J3M-20"))  { cart_map_shvc_1j3m_20();  return true; }

-  if(!strcmp(pcb, "BSC-1A7M-01"))  { cart_map_bsc_1a7m_01();  return true; }
+  if(!strcmp(pcb, "BSC-1A5M-01"))   { cart_map_bsc_1a5m_01();   return true; }

-  if(!strcmp(pcb, "BSC-1A7M-10"))  { cart_map_bsc_1a7m_10();  return true; }
+  if(!strcmp(pcb, "BSC-1A7M-01"))   { cart_map_bsc_1a7m_01();   return true; }

-  if(!strcmp(pcb, "STC-SOLO"))     { cart_map_stc_solo();     return true; }
+  if(!strcmp(pcb, "BSC-1A7M-10"))   { cart_map_bsc_1a7m_10();   return true; }

-  if(!strcmp(pcb, "STC-DUAL"))     { cart_map_stc_dual();     return true; }
+  if(!strcmp(pcb, "STC-SOLO"))      { cart_map_stc_solo();      return true; }
+
+  if(!strcmp(pcb, "STC-DUAL"))      { cart_map_stc_dual();      return true; }

  return false;
 }
@@ -19,6 +19,7 @@ enum {
  void cart_map_range(uint mode, uint8 bank_lo, uint8 bank_hi, uint16 addr_lo, uint16 addr_hi, uint type, uint offset = 0);

 #define mapper(name) void cart_map_##name()
+  mapper(shvc_1cb5b_20);
  mapper(shvc_1a3b_13);
  mapper(shvc_1a3b_20);
  mapper(shvc_1a3m_30);
@@ -1,3 +1,15 @@
+//SHVC-1CB5B-01
+//SHVC-1CB5B-20
+mapper(shvc_1cb5b_20) {
+  cartridge.info.superfx = true; //TODO: make this more elegant
+
+  map(LINEAR, 0x00, 0x3f, 0x6000, 0x7fff, MAP_RAM);
+  map(LINEAR, 0x00, 0x3f, 0x8000, 0xffff, MAP_ROM);
+  map(LINEAR, 0x40, 0x5f, 0x0000, 0xffff, MAP_ROM);
+  map(LINEAR, 0x70, 0x71, 0x0000, 0xffff, MAP_RAM);
+  map(LINEAR, 0x80, 0xbf, 0x6000, 0x7fff, MAP_RAM);
+}
+
 //SHVC-1A3B-01
 //SHVC-1A3B-11
 //SHVC-1A3B-12
@@ -148,8 +148,12 @@ struct {
  void   cgram_write(uint16 addr, uint8 value);

  uint16 get_vram_address();
-  uint8  vram_mmio_read (uint16 addr);
-  void   vram_mmio_write(uint16 addr, uint8 data);
+  uint8  vram_mmio_read  (uint16 addr);
+  void   vram_mmio_write (uint16 addr, uint8 data);
+  uint8  oam_mmio_read   (uint16 addr);
+  void   oam_mmio_write  (uint16 addr, uint8 data);
+  uint8  cgram_mmio_read (uint16 addr);
+  void   cgram_mmio_write(uint16 addr, uint8 data);

  void   mmio_w2100(uint8 value); //INIDISP
  void   mmio_w2101(uint8 value); //OBSEL
@@ -8,7 +8,7 @@ uint16 bPPU::get_vram_address() {
 uint16 addr;
  addr = regs.vram_addr;
  switch(regs.vram_mapping) {
-  case 0: break;
+  case 0: break; //direct
  case 1: addr = (addr & 0xff00) | ((addr & 0x001f) << 3) | ((addr >> 5) & 7); break;
  case 2: addr = (addr & 0xfe00) | ((addr & 0x003f) << 3) | ((addr >> 6) & 7); break;
  case 3: addr = (addr & 0xfc00) | ((addr & 0x007f) << 3) | ((addr >> 7) & 7); break;
@@ -16,6 +16,11 @@ uint16 addr;
  return (addr << 1);
 }

+//NOTE: all VRAM writes during active display are invalid. Unlike OAM and CGRAM, they will
+//not be written anywhere at all. The below address ranges for where writes are invalid have
+//been validated on hardware, as has the edge case where the S-CPU MDR can be written if the
+//write occurs during the very last clock cycle of vblank.
+
 uint8 bPPU::vram_mmio_read(uint16 addr) {
  if(regs.display_disabled == true) {
    return vram_read(addr);
@@ -46,20 +51,17 @@ uint16 ls = (r_cpu->region_scanlines() >> 1) - 1;

 void bPPU::vram_mmio_write(uint16 addr, uint8 data) {
  if(regs.display_disabled == true) {
-    vram_write(addr, data);
-    return;
+    return vram_write(addr, data);
  }

 uint16 v  = r_cpu->vcounter();
 uint16 hc = r_cpu->hclock();
  if(v == 0) {
    if(hc <= 4) {
-      vram_write(addr, data);
-      return;
+      return vram_write(addr, data);
    }
    if(hc == 6) {
-      vram_write(addr, r_cpu->regs.mdr);
-      return;
+      return vram_write(addr, r_cpu->regs.mdr);
    }
    return;
  }
@@ -72,13 +74,87 @@ uint16 hc = r_cpu->hclock();
    if(hc <= 4) {
      return;
    }
-    vram_write(addr, data);
-    return;
+    return vram_write(addr, data);
  }

  vram_write(addr, data);
 }

+//NOTE: OAM accesses during active display are rerouted to 0x0218 ... this can be considered
+//a hack. The actual address varies during rendering, as the S-PPU reads in data itself for
+//processing. Unfortunately, we have yet to determine how this works. The algorithm cannot be
+//reverse engineered using a scanline renderer such as this, and at this time, there does not
+//exist a more accurate SNES PPU emulator to work from. The only known game to actually access
+//OAM during active display is Uniracers. It expects accesses to map to offset 0x0218.
+//It was decided by public consensus to map writes to this address to match Uniracers, primarily
+//because it is the only game observed to do this, but also because mapping to this address does
+//not contradict any of our findings, because we have no findings whatsoever on this behavior.
+//Think of this what you will, I openly admit that this is a hack. But it is more accurate than
+//writing to the 'expected' address set by $2102,$2103, and will catch problems in software that
+//accidentally accesses OAM during active display by virtue of not returning the expected data.
+//You may disable this behavior by setting config::ppu.hack.oam_address_invalidation to false,
+//or by changing the address from 0x0218 to 0x0000 below if it bothers you that greatly.
+
+uint8 bPPU::oam_mmio_read(uint16 addr) {
+  if(config::ppu.hack.oam_address_invalidation == false || regs.display_disabled == true) {
+    return oam_read(addr);
+  }
+
+uint16 v = r_cpu->vcounter();
+  if(v < (!r_cpu->overscan() ? 225 : 240)) {
+    return oam_read(0x0218);
+  }
+
+  return oam_read(addr);
+}
+
+void bPPU::oam_mmio_write(uint16 addr, uint8 data) {
+  if(config::ppu.hack.oam_address_invalidation == false || regs.display_disabled == true) {
+    return oam_write(addr, data);
+  }
+
+uint16 v = r_cpu->vcounter();
+  if(v < (!r_cpu->overscan() ? 225 : 240)) {
+    return oam_write(0x0218, data);
+  }
+
+  oam_write(addr, data);
+}
+
+//NOTE: CGRAM writes during hblank are valid. During active display, the actual address the
+//data is written to varies, as the S-PPU itself changes the address. Like OAM, we do not know
+//the exact algorithm used, but we have zero known examples of any commercial software that
+//attempts to do this. Therefore, the addresses are mapped to 0x01ff. There is nothing special
+//about this address, it is simply more accurate to invalidate the 'expected' address than not.
+
+uint8 bPPU::cgram_mmio_read(uint16 addr) {
+  if(config::ppu.hack.cgram_address_invalidation == false || regs.display_disabled == true) {
+    return cgram_read(addr);
+  }
+
+uint16 v  = r_cpu->vcounter();
+uint16 hc = r_cpu->hclock();
+  if(v < (!r_cpu->overscan() ? 225 : 240) && hc >= 72 && hc < 1096) {
+    return cgram_read(0x01ff);
+  }
+
+  return cgram_read(addr);
+}
+
+void bPPU::cgram_mmio_write(uint16 addr, uint8 data) {
+  if(config::ppu.hack.cgram_address_invalidation == false || regs.display_disabled == true) {
+    return cgram_write(addr, data);
+  }
+
+uint16 v  = r_cpu->vcounter();
+uint16 hc = r_cpu->hclock();
+  if(v < (!r_cpu->overscan() ? 225 : 240) && hc >= 72 && hc < 1096) {
+    return cgram_write(0x01ff, data);
+  }
+
+  cgram_write(addr, data);
+}
+
 //INIDISP
 void bPPU::mmio_w2100(uint8 value) {
  if(regs.display_disabled == true && r_cpu->vcounter() == (!r_cpu->overscan() ? 225 : 240)) {
@@ -117,12 +193,12 @@ void bPPU::mmio_w2103(uint8 data) {
 //OAMDATA
 void bPPU::mmio_w2104(uint8 data) {
  if(regs.oam_addr & 0x0200) {
-    oam_write(regs.oam_addr, data);
+    oam_mmio_write(regs.oam_addr, data);
  } else if((regs.oam_addr & 1) == 0) {
    regs.oam_latchdata = data;
  } else {
-    oam_write((regs.oam_addr & ~1) + 0, regs.oam_latchdata);
-    oam_write((regs.oam_addr & ~1) + 1, data);
+    oam_mmio_write((regs.oam_addr & ~1) + 0, regs.oam_latchdata);
+    oam_mmio_write((regs.oam_addr & ~1) + 1, data);
  }

  regs.oam_addr++;
@@ -353,8 +429,8 @@ void bPPU::mmio_w2122(uint8 value) {
  if(!(regs.cgram_addr & 1)) {
    regs.cgram_latchdata = value;
  } else {
-    cgram_write((regs.cgram_addr & 0x01fe),     regs.cgram_latchdata);
-    cgram_write((regs.cgram_addr & 0x01fe) + 1, value & 0x7f);
+    cgram_mmio_write((regs.cgram_addr & 0x01fe),     regs.cgram_latchdata);
+    cgram_mmio_write((regs.cgram_addr & 0x01fe) + 1, value & 0x7f);
  }
  regs.cgram_addr++;
  regs.cgram_addr &= 0x01ff;
@@ -540,7 +616,7 @@ uint8 bPPU::mmio_r2137() {

 //OAMDATAREAD
 uint8 bPPU::mmio_r2138() {
-  regs.ppu1_mdr = oam_read(regs.oam_addr);
+  regs.ppu1_mdr = oam_mmio_read(regs.oam_addr);

  regs.oam_addr++;
  regs.oam_addr &= 0x03ff;
@@ -581,10 +657,10 @@ uint16 addr = get_vram_address() + 1;
 //update bit 7 of the PPU2 MDR.
 uint8 bPPU::mmio_r213b() {
  if(!(regs.cgram_addr & 1)) {
-    regs.ppu2_mdr  = cgram_read(regs.cgram_addr) & 0xff;
+    regs.ppu2_mdr  = cgram_mmio_read(regs.cgram_addr) & 0xff;
  } else {
    regs.ppu2_mdr &= 0x80;
-    regs.ppu2_mdr |= cgram_read(regs.cgram_addr) & 0x7f;
+    regs.ppu2_mdr |= cgram_mmio_read(regs.cgram_addr) & 0x7f;
  }
  regs.cgram_addr++;
  regs.cgram_addr &= 0x01ff;
@@ -27,7 +27,9 @@ uint16 bPPU::bg_get_tile(uint8 bg, uint16 x, uint16 y) {
 uint16 pos = ((y & 0x1f) << 5) + (x & 0x1f);
  if(y & 0x20)pos += bg_info[bg].scy;
  if(x & 0x20)pos += bg_info[bg].scx;
-  return read16(vram, regs.bg_scaddr[bg] + (pos << 1));
+
+uint16 addr = regs.bg_scaddr[bg] + (pos << 1);
+  return (vram_read(addr + 0) << 0) | (vram_read(addr + 1) << 8);
 }

 #define setpixel_main(x) \
@@ -61,14 +61,14 @@ tclr_addr_a(0x4e, &~) {
 5:op_writeaddr(dp, rd $1 regs.a);
 }

-incw_dp(0x3a, rd++),
-decw_dp(0x1a, rd--) {
+incw_dp(0x3a, ++),
+decw_dp(0x1a, --) {
 1:dp = op_readpc();
 2:rd = op_readdp(dp);
-  $1;
+  rd$1;
 3:op_writedp(dp++, rd);
 4:rd += op_readdp(dp) << 8;
-5:op_write(dp, rd >> 8);
+5:op_writedp(dp, rd >> 8);
  regs.p.n = !!(rd & 0x8000);
  regs.p.z = (rd == 0);
 }
@@ -212,7 +212,7 @@ void sSMP::op_incw_dp() {
  rd++;
  op_writedp(dp++, rd);
  rd += op_readdp(dp) << 8;
-  op_write(dp, rd >> 8);
+  op_writedp(dp, rd >> 8);
  regs.p.n = !!(rd & 0x8000);
  regs.p.z = (rd == 0);
 }
@@ -223,7 +223,7 @@ void sSMP::op_decw_dp() {
  rd--;
  op_writedp(dp++, rd);
  rd += op_readdp(dp) << 8;
-  op_write(dp, rd >> 8);
+  op_writedp(dp, rd >> 8);
  regs.p.n = !!(rd & 0x8000);
  regs.p.z = (rd == 0);
 }
@@ -12,6 +12,7 @@ class SNESInterface { public:

  void audio_sample(uint16 l_sample, uint16 r_sample);

+functor<bool ()> input_ready;
  void input_poll();
  bool input_poll(uint deviceid, uint button);

@@ -2,10 +2,10 @@ Scheduler scheduler;

 //

-void cocall threadentry_cpu(void*) { r_cpu->enter(); }
-void cocall threadentry_smp(void*) { r_smp->enter(); }
-void cocall threadentry_ppu(void*) {} //currently unused
-void cocall threadentry_dsp(void*) { r_dsp->enter(); }
+void threadentry_cpu() { r_cpu->enter(); }
+void threadentry_smp() { r_smp->enter(); }
+void threadentry_ppu() {                 } //currently unused
+void threadentry_dsp() { r_dsp->enter(); }

 //

@@ -41,10 +41,10 @@ void Scheduler::init() {
  if(thread_dsp)co_delete(thread_dsp);

  thread_snes = co_active();
-  thread_cpu  = co_create(sizeof(void*) * 64 * 1024, threadentry_cpu, 0);
-  thread_smp  = co_create(sizeof(void*) * 64 * 1024, threadentry_smp, 0);
-  thread_ppu  = co_create(sizeof(void*) * 64 * 1024, threadentry_ppu, 0);
-  thread_dsp  = co_create(sizeof(void*) * 64 * 1024, threadentry_dsp, 0);
+  thread_cpu  = co_create(sizeof(void*) * 64 * 1024, threadentry_cpu);
+  thread_smp  = co_create(sizeof(void*) * 64 * 1024, threadentry_smp);
+  thread_ppu  = co_create(sizeof(void*) * 64 * 1024, threadentry_ppu);
+  thread_dsp  = co_create(sizeof(void*) * 64 * 1024, threadentry_dsp);
 }

 //
@@ -1,6 +1,16 @@
 #include "../base.h"

 SNES snes;
+SuperFX superfx;
+SRTC srtc;
+SDD1 sdd1;
+C4 c4;
+DSP1 dsp1;
+DSP2 dsp2;
+DSP3 dsp3;
+DSP4 dsp4;
+OBC1 obc1;
+ST010 st010;

 #include "scheduler/scheduler.cpp"
 #include "tracer/tracer.cpp"
@@ -16,19 +26,16 @@ void SNES::runtoframe() {
 }

 void SNES::init() {
-  srtc = new SRTC();
-  sdd1 = new SDD1();
-  c4   = new C4();
-  dsp1 = new DSP1();
-  dsp2 = new DSP2();
-  obc1 = new OBC1();
-
-  srtc->init();
-  sdd1->init();
-  c4->init();
-  dsp1->init();
-  dsp2->init();
-  obc1->init();
+  superfx.init();
+  srtc.init();
+  sdd1.init();
+  c4.init();
+  dsp1.init();
+  dsp2.init();
+  dsp3.init();
+  dsp4.init();
+  obc1.init();
+  st010.init();

  video_init();
  audio_init();
@@ -50,12 +57,16 @@ void SNES::power() {
  r_ppu->power();
  r_mem->power();

-  if(cartridge.info.srtc)srtc->power();
-  if(cartridge.info.sdd1)sdd1->power();
-  if(cartridge.info.c4)  c4->power();
-  if(cartridge.info.dsp1)dsp1->power();
-  if(cartridge.info.dsp2)dsp2->power();
-  if(cartridge.info.obc1)obc1->power();
+  if(cartridge.info.superfx)superfx.power();
+  if(cartridge.info.srtc)   srtc.power();
+  if(cartridge.info.sdd1)   sdd1.power();
+  if(cartridge.info.c4)     c4.power();
+  if(cartridge.info.dsp1)   dsp1.power();
+  if(cartridge.info.dsp2)   dsp2.power();
+  if(cartridge.info.dsp3)   dsp3.power();
+  if(cartridge.info.dsp4)   dsp4.power();
+  if(cartridge.info.obc1)   obc1.power();
+  if(cartridge.info.st010)  st010.power();

  r_mem->flush_mmio_mappers();
  for(int i = 0x2100; i <= 0x213f; i++)r_mem->set_mmio_mapper(i, r_ppu);
@@ -65,12 +76,16 @@ void SNES::power() {
  for(int i = 0x4200; i <= 0x421f; i++)r_mem->set_mmio_mapper(i, r_cpu);
  for(int i = 0x4300; i <= 0x437f; i++)r_mem->set_mmio_mapper(i, r_cpu);

-  if(cartridge.info.srtc)srtc->enable();
-  if(cartridge.info.sdd1)sdd1->enable();
-  if(cartridge.info.c4)  c4->enable();
-  if(cartridge.info.dsp1)dsp1->enable();
-  if(cartridge.info.dsp2)dsp2->enable();
-  if(cartridge.info.obc1)obc1->enable();
+  if(cartridge.info.superfx)superfx.enable();
+  if(cartridge.info.srtc)   srtc.enable();
+  if(cartridge.info.sdd1)   sdd1.enable();
+  if(cartridge.info.c4)     c4.enable();
+  if(cartridge.info.dsp1)   dsp1.enable();
+  if(cartridge.info.dsp2)   dsp2.enable();
+  if(cartridge.info.dsp3)   dsp3.enable();
+  if(cartridge.info.dsp4)   dsp4.enable();
+  if(cartridge.info.obc1)   obc1.enable();
+  if(cartridge.info.st010)  st010.enable();

  video_update();
 }
@@ -84,12 +99,16 @@ void SNES::reset() {
  r_ppu->reset();
  r_mem->reset();

-  if(cartridge.info.srtc)srtc->reset();
-  if(cartridge.info.sdd1)sdd1->reset();
-  if(cartridge.info.c4)  c4->reset();
-  if(cartridge.info.dsp1)dsp1->reset();
-  if(cartridge.info.dsp2)dsp2->reset();
-  if(cartridge.info.obc1)obc1->reset();
+  if(cartridge.info.superfx)superfx.reset();
+  if(cartridge.info.srtc)   srtc.reset();
+  if(cartridge.info.sdd1)   sdd1.reset();
+  if(cartridge.info.c4)     c4.reset();
+  if(cartridge.info.dsp1)   dsp1.reset();
+  if(cartridge.info.dsp2)   dsp2.reset();
+  if(cartridge.info.dsp3)   dsp3.reset();
+  if(cartridge.info.dsp4)   dsp4.reset();
+  if(cartridge.info.obc1)   obc1.reset();
+  if(cartridge.info.st010)  st010.reset();

  video_update();
 }
@@ -1,6 +1,6 @@
 Tracer tracer;

-void tprintf(char *s, ...) {
+void tprintf(const char *s, ...) {
  if(tracer.enabled() == false) { return; }

 char str[4096];
@@ -1,4 +1,4 @@
-void tprintf(char *s, ...);
+void tprintf(const char *s, ...);

 class Tracer {
 private:
@@ -43,7 +43,7 @@ public:
  Tracer();
  ~Tracer();

-  friend void tprintf(char *s, ...);
+  friend void tprintf(const char *s, ...);
 };

 extern Tracer tracer;
@@ -1,5 +1,4 @@
-#define SNES_NTSC_IN_FORMAT SNES_NTSC_BGR15
-#include "filter_ntsc_core.cpp"
+#include "ntsc/snes_ntsc.c"

 NtscVideoFilter::NtscVideoFilter() {
  ntsc = 0;
@@ -1,4 +1,4 @@
-#include "filter_ntsc_core.h"
+#include "ntsc/snes_ntsc.h"

 class NtscVideoFilter : public VideoFilter {
 private:
@@ -1,598 +0,0 @@
-/* snes_ntsc 0.2.1. http://www.slack.net/~ant/ */
-
-/* compilable in C or C++; just change the file extension */
-
-//#include "snes_ntsc.h"
-
-#include <assert.h>
-#include <math.h>
-
-/* Based on algorithm by NewRisingSun */
-/* Copyright (C) 2006 Shay Green. This module is free software; you
-can redistribute it and/or modify it under the terms of the GNU Lesser
-General Public License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version. This
-module is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
-more details. You should have received a copy of the GNU Lesser General
-Public License along with this module; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
-
-enum { disable_correction = 0 }; /* for debugging */
-
-/* macro constants are used instead of enum in some places to work around compiler bug */
-
-/* half normal range to allow for doubled hires pixels */
-#define rgb_unit 0x80
-
-/* begin mostly common NES/SNES/SMS code */
-
-snes_ntsc_setup_t const snes_ntsc_monochrome = { 0,-1, 0, 0,.2,  0,.2,-.2,-.2,-1, 0, 1, 0, 0 };
-snes_ntsc_setup_t const snes_ntsc_composite  = { 0, 0, 0, 0, 0,  0, 0,  0,  0, 0, 0, 1, 0, 0 };
-snes_ntsc_setup_t const snes_ntsc_svideo     = { 0, 0, 0, 0,.2,  0,.2, -1, -1, 0, 0, 1, 0, 0 };
-snes_ntsc_setup_t const snes_ntsc_rgb        = { 0, 0, 0, 0,.2,  0,.7, -1, -1,-1, 0, 1, 0, 0 };
-
-enum { alignment_count = 3 }; /* different pixel alignments with respect to yiq quads */
-
-enum { kernel_half = 16 };
-enum { kernel_size = kernel_half * 2 + 1 };
-#define rescale_in 8
-enum { rescale_out = 7 };
-
-struct ntsc_impl_t
-{
-	float to_rgb [snes_ntsc_burst_count] [6];
-	float brightness;
-	float contrast;
-	float artifacts;
-	float fringing;
-	float hue_warping;
-	float kernel [rescale_out * kernel_size * 2];
-};
-
-#define PI 3.14159265358979323846f
-
-static void init_ntsc_impl( struct ntsc_impl_t* impl, snes_ntsc_setup_t const* setup )
-{
-	float kernels [kernel_size * 2];
-	
-	impl->brightness  = (float) setup->brightness * (0.4f * rgb_unit);
-	impl->contrast    = (float) setup->contrast * 0.4f + 1.0f;
-	impl->hue_warping = (float) setup->hue_warping;
-	
-	impl->artifacts   = (float) setup->artifacts;
-	if ( impl->artifacts > 0 )
-		impl->artifacts *= 0.5f;
-	impl->artifacts += 1.0f;
-	
-	impl->fringing   = (float) setup->fringing;
-	if ( impl->fringing > 0 )
-		impl->fringing *= 0.5f;
-	impl->fringing += 1.0f;
-	
-	/* generate luma (y) filter using sinc kernel */
-	{
-		/* sinc with rolloff (dsf) */
-		/* double precision avoids instability */
-		double const rolloff = 1 + setup->sharpness * 0.004;
-		double const maxh = 256;
-		double const pow_a_n = pow( rolloff, maxh );
-		float sum;
-		int i;
-		/* quadratic mapping to reduce negative (blurring) range */
-		double to_angle = setup->resolution + 1;
-		to_angle = PI / maxh * 0.20 * (to_angle * to_angle + 1);
-		
-		kernels [kernel_size * 3 / 2] = (float) maxh;
-		for ( i = 0; i < kernel_half * 2 + 1; i++ )
-		{
-			int x = i - kernel_half;
-			double angle = x * to_angle;
-			/* instability occurs at center point with rolloff very close to 1.0 */
-			if ( x || pow_a_n > 1.01 || pow_a_n < 0.99 )
-			{
-				double rolloff_cos_a = rolloff * cos( angle );
-				double num = 1 - rolloff_cos_a -
-						pow_a_n * cos( maxh * angle ) +
-						pow_a_n * rolloff * cos( (maxh - 1) * angle );
-				double den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff;
-				double dsf = num / den;
-				kernels [kernel_size * 3 / 2 - kernel_half + i] = (float) dsf;
-			}
-		}
-		
-		/* apply blackman window and find sum */
-		sum = 0;
-		for ( i = 0; i < kernel_half * 2 + 1; i++ )
-		{
-			float x = PI * 2 / (kernel_half * 2) * i;
-			float blackman = 0.42f - 0.5f * (float) cos( x ) + 0.08f * (float) cos( x * 2 );
-			sum += (kernels [kernel_size * 3 / 2 - kernel_half + i] *= blackman);
-		}
-		
-		/* normalize kernel */
-		sum = 1.0f / sum;
-		for ( i = 0; i < kernel_half * 2 + 1; i++ )
-		{
-			int x = kernel_size * 3 / 2 - kernel_half + i;
-			kernels [x] *= sum;
-			assert( kernels [x] == kernels [x] ); /* catch numerical instability */
-		}
-	}
-	
-	/* generate chroma (iq) filter using gaussian kernel */
-	{
-		float const cutoff_factor = -0.03125f;
-		float cutoff = (float) setup->bleed;
-		int i;
-		
-		if ( cutoff < 0 )
-		{
-			/* keep extreme value accessible only near upper end of scale (1.0) */
-			cutoff *= cutoff;
-			cutoff *= cutoff;
-			cutoff *= cutoff;
-			cutoff *= -30.0f / 0.65f;
-		}
-		cutoff = cutoff_factor - 0.65f * cutoff_factor * cutoff;
-		
-		for ( i = -kernel_half; i <= kernel_half; i++ )
-			kernels [kernel_size / 2 + i] = (float) exp( i * i * cutoff );
-		
-		/* normalize even and odd phases separately */
-		for ( i = 0; i < 2; i++ )
-		{
-			float sum = 0;
-			int x;
-			for ( x = i; x < kernel_size; x += 2 )
-				sum += kernels [x];
-			
-			sum = 1.0f / sum;
-			for ( x = i; x < kernel_size; x += 2 )
-			{
-				kernels [x] *= sum;
-				assert( kernels [x] == kernels [x] ); /* catch numerical instability */
-			}
-		}
-	}
-	
-	/* generate linear rescale kernels */
-	{
-		int i;
-		for ( i = 0; i < rescale_out; i++ )
-		{
-			float* out = &impl->kernel [i * kernel_size * 2];
-			float second = 1.0f / rescale_in * (i + 1);
-			float first  = 1.0f - second;
-			int x;
-			*out++ = kernels [0] * first;
-			for ( x = 1; x < kernel_size * 2; x++ )
-				*out++ = kernels [x] * first + kernels [x - 1] * second;
-		}
-	}
-	
-	/* setup decoder matricies */
-	{
-		static float const default_decoder [6] =
-			{ 0.956f, 0.621f, -0.272f, -0.647f, -1.105f, 1.702f };
-		float hue = (float) setup->hue * PI;
-		float sat = (float) setup->saturation + 1.0f;
-		float const* decoder = setup->decoder_matrix;
-		int i;
-		if ( !decoder )
-			decoder = default_decoder;
-		else
-			hue += PI / 180 * 15;
-		
-		for ( i = 0; i < snes_ntsc_burst_count; i++ )
-		{
-			float s = (float) sin( hue ) * sat;
-			float c = (float) cos( hue ) * sat;
-			float const* in = decoder;
-			float* out = impl->to_rgb [i];
-			int n;
-			for ( n = 3; n; --n )
-			{
-				float i = *in++;
-				float q = *in++;
-				*out++ = i * c - q * s;
-				*out++ = i * s + q * c;
-			}
-			hue -= PI / 180 * 120;
-		}
-	}
-}
-
-/* kernel generation */
-
-enum { rgb_kernel_size = snes_ntsc_burst_size / alignment_count };
-
-static float const rgb_offset = rgb_unit * 2 + 0.5f;
-static ntsc_rgb_t const ntsc_rgb_bias = rgb_unit * 2 * ntsc_rgb_builder;
-
-#define TO_RGB( y, i, q, to_rgb ) ( \
-	((int) (y + to_rgb [0] * i + to_rgb [1] * q) << 21) +\
-	((int) (y + to_rgb [2] * i + to_rgb [3] * q) << 11) +\
-	((int) (y + to_rgb [4] * i + to_rgb [5] * q) <<  1)\
-)
-
-typedef struct pixel_info_t
-{
-	int offset;
-	float negate;
-	float kernel [4];
-} pixel_info_t;
-
-#define PIXEL_OFFSET_( ntsc, scaled ) \
-	(kernel_size / 2 + ntsc + (scaled != 0) + (rescale_out - scaled) % rescale_out + \
-			(kernel_size * 2 * scaled))
-
-#define PIXEL_OFFSET( ntsc, scaled ) \
-	PIXEL_OFFSET_( ((ntsc) - (scaled) / rescale_out * rescale_in),\
-			(((scaled) + rescale_out * 10) % rescale_out) ),\
-	(1.0f - (((ntsc) + 100) & 2))
-
-/* Generate pixel at all burst phases and column alignments */
-static void gen_kernel( struct ntsc_impl_t* impl, float y, float i, float q, ntsc_rgb_t* out )
-{
-	/* generate for each scanline burst phase */
-	float const* to_rgb = impl->to_rgb [0];
-	do
-	{
-		static pixel_info_t const pixels [alignment_count] = {
-			{ PIXEL_OFFSET( -4, -9 ), { 1.0000f, 1.0000f,  .6667f,  .0000f } },
-			{ PIXEL_OFFSET( -2, -7 ), {  .3333f, 1.0000f, 1.0000f,  .3333f } },
-			{ PIXEL_OFFSET(  0, -5 ), {  .0000f,  .6667f, 1.0000f, 1.0000f } },
-		};
-		
-		/* Encode yiq into *two* composite signals (to allow control over artifacting).
-		Convolve these with kernels which: filter respective components, apply
-		sharpening, and rescale horizontally. Convert resulting yiq to rgb and pack
-		into integer. */
-		pixel_info_t const* pixel = pixels;
-		do
-		{
-			/* negate is -1 when composite starts at odd multiple of 2 */
-			float const yy = y * impl->fringing * pixel->negate;
-			float const ic0 = (i + yy) * pixel->kernel [0];
-			float const qc1 = (q + yy) * pixel->kernel [1];
-			float const ic2 = (i - yy) * pixel->kernel [2];
-			float const qc3 = (q - yy) * pixel->kernel [3];
-			
-			float const factor = impl->artifacts * pixel->negate;
-			float const ii = i * factor;
-			float const yc0 = (y + ii) * pixel->kernel [0];
-			float const yc2 = (y - ii) * pixel->kernel [2];
-			
-			float const qq = q * factor;
-			float const yc1 = (y + qq) * pixel->kernel [1];
-			float const yc3 = (y - qq) * pixel->kernel [3];
-			
-			float const* k = &impl->kernel [pixel->offset];
-			int n;
-			for ( n = rgb_kernel_size; n; --n )
-			{
-				float i = k[0]*ic0 + k[2]*ic2;
-				float q = k[1]*qc1 + k[3]*qc3;
-				float y = k[kernel_size+0]*yc0 + k[kernel_size+1]*yc1 +
-				          k[kernel_size+2]*yc2 + k[kernel_size+3]*yc3 + rgb_offset;
-				if ( k >= &impl->kernel [kernel_size * 2 * (rescale_out - 1)] )
-					k -= kernel_size * 2 * (rescale_out - 1) + 2;
-				else
-					k += kernel_size * 2 - 1;
-				*out++ = TO_RGB( y, i, q, to_rgb ) - ntsc_rgb_bias;
-			}
-		}
-		while ( pixel++ < &pixels [alignment_count - 1] );
-		
-		to_rgb += 6;
-		
-		/* rotate -120 degrees */
-		{
-			float const sin_b = -0.866025f;
-			float const cos_b = -0.5f;
-			float t;
-			t = i * cos_b - q * sin_b;
-			q = i * sin_b + q * cos_b;
-			i = t;
-		}
-	}
-	while ( to_rgb < impl->to_rgb [snes_ntsc_burst_count] );
-}
-
-static void merge_fields( ntsc_rgb_t* io )
-{
-	int n;
-	for ( n = snes_ntsc_burst_size; n; --n )
-	{
-		ntsc_rgb_t p0 = io [snes_ntsc_burst_size * 0] + ntsc_rgb_bias;
-		ntsc_rgb_t p1 = io [snes_ntsc_burst_size * 1] + ntsc_rgb_bias;
-		ntsc_rgb_t p2 = io [snes_ntsc_burst_size * 2] + ntsc_rgb_bias;
-		/* merge fields without losing precision */
-		io [snes_ntsc_burst_size * 0] =
-				((p0 + p1 - ((p0 ^ p1) & ntsc_rgb_builder)) >> 1) - ntsc_rgb_bias;
-		io [snes_ntsc_burst_size * 1] =
-				((p1 + p2 - ((p1 ^ p2) & ntsc_rgb_builder)) >> 1) - ntsc_rgb_bias;
-		io [snes_ntsc_burst_size * 2] =
-				((p2 + p0 - ((p2 ^ p0) & ntsc_rgb_builder)) >> 1) - ntsc_rgb_bias;
-		++io;
-	}
-}
-
-static void correct_errors( ntsc_rgb_t color, ntsc_rgb_t* out )
-{
-	int burst;
-	for ( burst = 0; burst < snes_ntsc_burst_count; burst++ )
-	{
-		int i;
-		for ( i = 0; i < rgb_kernel_size / 2; i++ )
-		{
-			ntsc_rgb_t error = color -
-					out [i           ] -
-					out [i + 3    +28] -
-					out [i + 5    +14] -
-					out [i + 7       ] -
-					out [(i+10)%14+28] -
-					out [(i+12)%14+14];
-			
-			/* distribute error among four kernels */
-			ntsc_rgb_t fourth = (error + 2 * ntsc_rgb_builder) >> 2;
-			fourth &= (ntsc_rgb_bias >> 1) - ntsc_rgb_builder;
-			fourth -= ntsc_rgb_bias >> 2;
-			if ( disable_correction ) { out [i] += ntsc_rgb_bias; continue; }
-			out [i + 3 +28] += fourth;
-			out [i + 5 +14] += fourth;
-			out [i + 7    ] += fourth;
-			out [i        ] += error - (fourth * 3);
-		}
-		out += alignment_count * rgb_kernel_size;
-	}
-}
-/* end common code */
-
-void snes_ntsc_init( snes_ntsc_t* ntsc, snes_ntsc_setup_t const* setup )
-{
-	float to_float [32];
-	int entry;
-	struct ntsc_impl_t impl;
-	if ( !setup )
-		setup = &snes_ntsc_composite;
-	init_ntsc_impl( &impl, setup );
-	
-	{
-		double gamma = 1 - setup->gamma * (setup->gamma > 0 ? 0.5f : 1.5f);
-		int i;
-		for ( i = 0; i < 32; i++ )
-			to_float [i] = (float) pow( (1 / 31.0) * i, gamma ) * rgb_unit;
-	}
-	
-	for ( entry = 0; entry < snes_ntsc_color_count; entry++ )
-	{
-		/* Reduce number of significant bits of source color. Clearing the
-		low bits of R and B were least notictable. Modifying green was too
-		noticeable. */
-		int ir = entry >> 8 & 0x1E;
-		int ig = entry >> 4 & 0x1F;
-		int ib = entry << 1 & 0x1E;
-		
-		if ( setup->bsnes_colortbl )
-		{
-			int bgr15 = (ib << 10) | (ig << 5) | ir;
-			unsigned long rgb16 = setup->bsnes_colortbl [bgr15];
-			ir = rgb16 >> 11 & 0x1E;
-			ig = rgb16 >>  6 & 0x1F;
-			ib = rgb16       & 0x1E;
-		}
-		
-		{
-			float r = to_float [ir];
-			float g = to_float [ig];
-			float b = to_float [ib];
-			
-			float y = r * 0.299f + g * 0.587f + b * 0.114f;
-			float i = r * 0.596f - g * 0.275f - b * 0.321f;
-			float q = r * 0.212f - g * 0.523f + b * 0.311f;
-			
-			float iq = i * q;
-			if ( impl.hue_warping && q && iq <= 0 )
-			{
-				float factor = (iq * impl.hue_warping) / (i * i + q * q);
-				i -= i * factor;
-				q += q * factor;
-			}
-			
-			y = y * impl.contrast + impl.brightness;
-			
-			{
-				float yy = y + rgb_offset;
-				ntsc_rgb_t rgb = TO_RGB( yy, i, q, impl.to_rgb [0] );
-				ntsc_rgb_t* out = ntsc->table [entry];
-				
-				gen_kernel( &impl, y, i, q, out );
-				
-				if ( setup->merge_fields )
-					merge_fields( out );
-				
-				correct_errors( rgb, out );
-			}
-		}
-	}
-}
-
-/* Disable 'restrict' keyword by default. If your compiler supports it, put
-
-	#define restrict restrict
-
-somewhere in a config header, or the equivalent in the command-line:
-
-	-Drestrict=restrict
-
-If your compiler supports a non-standard version, like __restrict, do this:
-
-	#define restrict __restrict
-
-Enabling this if your compiler supports it will allow better optimization. */
-#ifndef restrict
-	#define restrict
-#endif
-
-/* Default to 16-bit RGB input and output */
-#ifndef SNES_NTSC_IN_FORMAT
-	#define SNES_NTSC_IN_FORMAT SNES_NTSC_RGB16
-#endif
-
-#ifndef SNES_NTSC_OUT_DEPTH
-	#define SNES_NTSC_OUT_DEPTH 16
-#endif
-
-#include <limits.h>
-
-#if SNES_NTSC_OUT_DEPTH > 16
-	#if UINT_MAX == 0xFFFFFFFF
-		typedef unsigned int  snes_ntsc_out_t;
-	#elif ULONG_MAX == 0xFFFFFFFF
-		typedef unsigned long snes_ntsc_out_t;
-	#else
-		#error "Need 32-bit int type"
-	#endif
-#else
-	#if USHRT_MAX == 0xFFFF
-		typedef unsigned short snes_ntsc_out_t;
-	#else
-		#error "Need 16-bit int type"
-	#endif
-#endif
-
-/* useful if you have a linker which doesn't remove unused code from executable */
-#ifndef SNES_NTSC_NO_BLITTERS
-
-/* Use this as a starting point for writing your own blitter. To allow easy upgrades
-to new versions of this library, put your blitter in a separate source file rather
-than modifying this one directly. */
-
-void snes_ntsc_blit( snes_ntsc_t const* ntsc, unsigned short const* snes_in,
-		long in_row_width, int burst_phase, int in_width, int in_height,
-		void* rgb_out, long out_pitch )
-{
-	int chunk_count = (in_width - 1) / snes_ntsc_in_chunk;
-	for ( ; in_height; --in_height )
-	{
-		/* begin row and read first input pixel */
-		unsigned short const* line_in = snes_in;
-		SNES_NTSC_LORES_ROW( ntsc, burst_phase,
-				snes_ntsc_black, snes_ntsc_black, *line_in++ );
-		snes_ntsc_out_t* restrict line_out = (snes_ntsc_out_t*) rgb_out;
-		int n;
-		
-		/* blit main chunks, each using 3 input pixels to generate 7 output pixels */
-		for ( n = chunk_count; n; --n )
-		{
-			/* order of input and output pixels must not be altered */
-			SNES_NTSC_PIXEL_IN( 0, line_in [0] );
-			SNES_NTSC_LORES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
-			SNES_NTSC_LORES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 1, line_in [1] );
-			SNES_NTSC_LORES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
-			SNES_NTSC_LORES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 2, line_in [2] );
-			SNES_NTSC_LORES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
-			SNES_NTSC_LORES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
-			SNES_NTSC_LORES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
-			
-			line_in  += 3;
-			line_out += 7;
-		}
-		
-		/* you can eliminate the need for the final chunk below by padding
-		input with three extra black pixels at the end of each row */
-		
-		/* finish final pixels without starting any new ones */
-		SNES_NTSC_PIXEL_IN( 0, snes_ntsc_black );
-		SNES_NTSC_LORES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
-		SNES_NTSC_LORES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 1, snes_ntsc_black );
-		SNES_NTSC_LORES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
-		SNES_NTSC_LORES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 2, snes_ntsc_black );
-		SNES_NTSC_LORES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
-		SNES_NTSC_LORES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
-		SNES_NTSC_LORES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
-		
-		/* advance burst phase and line pointers */
-		burst_phase = (burst_phase + 1) % snes_ntsc_burst_count;
-		snes_in += in_row_width;
-		rgb_out = (char*) rgb_out + out_pitch;
-	}
-}
-
-void snes_ntsc_blit_hires( snes_ntsc_t const* ntsc, unsigned short const* snes_in,
-		long in_row_width, int burst_phase, int in_width, int in_height,
-		void* rgb_out, long out_pitch )
-{
-	int chunk_count = (in_width - 2) / (snes_ntsc_in_chunk * 2);
-	for ( ; in_height; --in_height )
-	{
-		unsigned short const* line_in = snes_in;
-		SNES_NTSC_HIRES_ROW( ntsc, burst_phase,
-				snes_ntsc_black, snes_ntsc_black, snes_ntsc_black, line_in [0], line_in [1] );
-		snes_ntsc_out_t* restrict line_out = (snes_ntsc_out_t*) rgb_out;
-		int n;
-		line_in += 2;
-		
-		for ( n = chunk_count; n; --n )
-		{
-			SNES_NTSC_PIXEL_IN( 0, line_in [0] );
-			SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 1, line_in [1] );
-			SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 2, line_in [2] );
-			SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 3, line_in [3] );
-			SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 4, line_in [4] );
-			SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
-			
-			SNES_NTSC_PIXEL_IN( 5, line_in [5] );
-			SNES_NTSC_HIRES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
-			SNES_NTSC_HIRES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
-			
-			line_in  += 6;
-			line_out += 7;
-		}
-		
-		SNES_NTSC_PIXEL_IN( 0, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 1, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 2, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 3, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 4, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
-		
-		SNES_NTSC_PIXEL_IN( 5, snes_ntsc_black );
-		SNES_NTSC_HIRES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
-		SNES_NTSC_HIRES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
-		
-		burst_phase = (burst_phase + 1) % snes_ntsc_burst_count;
-		snes_in += in_row_width;
-		rgb_out = (char*) rgb_out + out_pitch;
-	}
-}
-
-#endif
-
@@ -1,192 +0,0 @@
-/* SNES NTSC composite video to RGB emulator/blitter */
-
-/* snes_ntsc 0.2.1 */
-
-#ifndef SNES_NTSC_H
-#define SNES_NTSC_H
-
-/* Image parameters, ranging from -1.0 to 1.0 */
-typedef struct snes_ntsc_setup_t
-{
-	/* Basic parameters */
-	double hue;        /* -1 = -180 degrees, +1 = +180 degrees */
-	double saturation; /* -1 = grayscale, +1 = oversaturated colors */
-	double contrast;
-	double brightness;
-	double sharpness;  /* edge contrast enhancement/blurring */
-	
-	/* Advanced parameters */
-	double gamma;
-	double resolution; /* image resolution */
-	double artifacts;  /* artifacts caused by color changes */
-	double fringing;   /* color artifacts caused by brightness changes */
-	double bleed;      /* color bleed (color resolution reduction) */
-	double hue_warping;/* -1 = expand purple & green, +1 = expand orange & cyan */
-	int merge_fields;  /* if 1, merges even and odd fields together to reduce flicker */
-	float const* decoder_matrix; /* optional RGB decoder matrix, 6 elements */
-	
-	unsigned long const* bsnes_colortbl; /* temporary feature for bsnes only; set to 0 */
-} snes_ntsc_setup_t;
-
-/* Video format presets */
-extern snes_ntsc_setup_t const snes_ntsc_composite; /* color bleeding + artifacts */
-extern snes_ntsc_setup_t const snes_ntsc_svideo;    /* color bleeding only */
-extern snes_ntsc_setup_t const snes_ntsc_rgb;       /* crisp image */
-extern snes_ntsc_setup_t const snes_ntsc_monochrome;/* desaturated + artifacts */
-
-/* Initialize and adjust parameters. Can be called multiple times on the same
-snes_ntsc_t object. Caller must allocate memory for snes_ntsc_t. Can pass 0
-for either parameter. */
-typedef struct snes_ntsc_t snes_ntsc_t;
-void snes_ntsc_init( snes_ntsc_t*, snes_ntsc_setup_t const* setup );
-
-/* Blit one or more rows of pixels. Input pixel format is set by SNES_NTSC_IN_FORMAT
-and output RGB depth is set by NES_NTSC_OUT_DEPTH. Both default to 16-bit RGB.
-In_row_width is the number of pixels to get to the next input row. Out_pitch
-is the number of *bytes* to get to the next output row. */
-void snes_ntsc_blit( snes_ntsc_t const*, unsigned short const* snes_in,
-		long in_row_width, int burst_phase, int in_width, int in_height,
-		void* rgb_out, long out_pitch );
-
-void snes_ntsc_blit_hires( snes_ntsc_t const*, unsigned short const* snes_in,
-		long in_row_width, int burst_phase, int in_width, int in_height,
-		void* rgb_out, long out_pitch );
-
-/* Number of output pixels written by low-res blitter for given input width. Width
-might be rounded down slightly; use SNES_NTSC_IN_WIDTH() on result to find rounded
-value. Guaranteed not to round 256 down at all. */
-#define SNES_NTSC_OUT_WIDTH( in_width ) \
-	(((in_width) - 1) / snes_ntsc_in_chunk * snes_ntsc_out_chunk + snes_ntsc_out_chunk)
-
-/* Number of low-res input pixels that will fit within given output width. Might be
-rounded down slightly; use SNES_NTSC_OUT_WIDTH() on result to find rounded
-value. */
-#define SNES_NTSC_IN_WIDTH( out_width ) \
-	((out_width) / snes_ntsc_out_chunk * snes_ntsc_in_chunk - snes_ntsc_in_chunk + 1)
-
-
-/* Interface for user-defined custom blitters */
-
-enum { snes_ntsc_in_chunk    = 3  }; /* number of snes pixels read per chunk */
-enum { snes_ntsc_out_chunk   = 7  }; /* number of output pixels generated per chunk */
-enum { snes_ntsc_black       = 0  }; /* palette index for black */
-enum { snes_ntsc_burst_count = 3  }; /* burst phase cycles through 0, 1, and 2 */
-
-/* Begin outputting row and start three pixels. First pixel will be cut off a bit.
-Use snes_ntsc_black for unused pixels. Declares variables, so must be before first
-statement in a block (unless you're using C++). */
-#define SNES_NTSC_LORES_ROW( ntsc, burst, pixel0, pixel1, pixel2 ) \
-	char const* ktable = (char*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (ntsc_rgb_t));\
-	int const snes_pixel0_ = (pixel0);\
-	ntsc_rgb_t const* kernel0  = SNES_NTSC_IN_FORMAT( snes_pixel0_ );\
-	int const snes_pixel1_ = (pixel1);\
-	ntsc_rgb_t const* kernel1  = SNES_NTSC_IN_FORMAT( snes_pixel1_ );\
-	int const snes_pixel2_ = (pixel2);\
-	ntsc_rgb_t const* kernel2  = SNES_NTSC_IN_FORMAT( snes_pixel2_ );\
-	ntsc_rgb_t const* kernelx0;\
-	ntsc_rgb_t const* kernelx1 = kernel0;\
-	ntsc_rgb_t const* kernelx2 = kernel0
-
-/* Begin input pixel */
-#define SNES_NTSC_PIXEL_IN( in_index, color_in ) {\
-	unsigned n;\
-	kernelx##in_index = kernel##in_index;\
-	kernel##in_index = (n = (color_in), SNES_NTSC_IN_FORMAT( n ));\
-}
-
-/* Generate output pixel. Bits can be 24, 16, 15, or 32 (treated as 24):
-24: RRRRRRRR GGGGGGGG BBBBBBBB
-16:          RRRRRGGG GGGBBBBB
-15:           RRRRRGG GGGBBBBB
- 0: xxxRRRRR RRRxxGGG GGGGGxxB BBBBBBBx (raw format; x = junk bits) */
-#define SNES_NTSC_LORES_OUT( x, rgb_out, bits ) {\
-	ntsc_rgb_t raw =\
-		kernel0  [x       ] + kernel1  [(x+12)%7+14] + kernel2  [(x+10)%7+28] +\
-		kernelx0 [(x+7)%14] + kernelx1 [(x+ 5)%7+21] + kernelx2 [(x+ 3)%7+35];\
-	SNES_NTSC_CLAMP_( raw, 1 );\
-	SNES_NTSC_OUT_( rgb_out, (bits), raw, 1 );\
-}
-
-/* Hires equivalents */
-#define SNES_NTSC_HIRES_ROW( ntsc, burst, pixel1, pixel2, pixel3, pixel4, pixel5 ) \
-	char const* ktable = (char*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (ntsc_rgb_t));\
-	int const snes_pixel1_ = (pixel1);\
-	ntsc_rgb_t const* kernel1  = SNES_NTSC_IN_FORMAT( snes_pixel1_ );\
-	int const snes_pixel2_ = (pixel2);\
-	ntsc_rgb_t const* kernel2  = SNES_NTSC_IN_FORMAT( snes_pixel2_ );\
-	int const snes_pixel3_ = (pixel3);\
-	ntsc_rgb_t const* kernel3  = SNES_NTSC_IN_FORMAT( snes_pixel3_ );\
-	int const snes_pixel4_ = (pixel4);\
-	ntsc_rgb_t const* kernel4  = SNES_NTSC_IN_FORMAT( snes_pixel4_ );\
-	int const snes_pixel5_ = (pixel5);\
-	ntsc_rgb_t const* kernel5  = SNES_NTSC_IN_FORMAT( snes_pixel5_ );\
-	ntsc_rgb_t const* kernel0 = kernel1;\
-	ntsc_rgb_t const* kernelx0;\
-	ntsc_rgb_t const* kernelx1 = kernel1;\
-	ntsc_rgb_t const* kernelx2 = kernel1;\
-	ntsc_rgb_t const* kernelx3 = kernel1;\
-	ntsc_rgb_t const* kernelx4 = kernel1;\
-	ntsc_rgb_t const* kernelx5 = kernel1
-
-#define SNES_NTSC_HIRES_OUT( x, rgb_out, bits ) {\
-	ntsc_rgb_t raw =\
-		kernel0  [ x       ] + kernel2  [(x+5)%7+14] + kernel4  [(x+3)%7+28] +\
-		kernelx0 [(x+7)%7+7] + kernelx2 [(x+5)%7+21] + kernelx4 [(x+3)%7+35] +\
-		kernel1  [(x+6)%7  ] + kernel3  [(x+4)%7+14] + kernel5  [(x+2)%7+28] +\
-		kernelx1 [(x+6)%7+7] + kernelx3 [(x+4)%7+21] + kernelx5 [(x+2)%7+35];\
-	SNES_NTSC_CLAMP_( raw, 0 );\
-	SNES_NTSC_OUT_( rgb_out, (bits), raw, 0 );\
-}
-
-
-/* private */
-
-enum { snes_ntsc_entry_size = 128 };
-enum { snes_ntsc_color_count = 0x2000 };
-typedef unsigned long ntsc_rgb_t;
-struct snes_ntsc_t
-{
-	ntsc_rgb_t table [snes_ntsc_color_count] [snes_ntsc_entry_size];
-};
-enum { snes_ntsc_burst_size = snes_ntsc_entry_size / snes_ntsc_burst_count };
-
-enum { ntsc_rgb_builder = (1L << 21) | (1 << 11) | (1 << 1) };
-enum { snes_ntsc_clamp_mask = ntsc_rgb_builder * 3 / 2 };
-enum { snes_ntsc_clamp_add  = ntsc_rgb_builder * 0x101 };
-
-#define SNES_NTSC_RGB16( n ) \
-	(ntsc_rgb_t*) (ktable + ((n & 0x001E) | (n >> 1 & 0x03E0) | (n >> 2 & 0x3C00)) * \
-			(snes_ntsc_entry_size / 2 * sizeof (ntsc_rgb_t)))
-
-#define SNES_NTSC_BGR15( n ) \
-	(ntsc_rgb_t*) (ktable + ((n << 9 & 0x3C00) | (n & 0x03E0) | (n >> 10 & 0x001E)) * \
-			(snes_ntsc_entry_size / 2 * sizeof (ntsc_rgb_t)))
-
-#define SNES_NTSC_CLAMP_( io, shift ) {\
-	ntsc_rgb_t sub = io >> (9-shift) & snes_ntsc_clamp_mask;\
-	ntsc_rgb_t clamp = snes_ntsc_clamp_add - sub;\
-	io |= clamp;\
-	clamp -= sub;\
-	io &= clamp;\
-}
-
-#define SNES_NTSC_OUT_( rgb_out, bits, raw, x ) {\
-	if ( bits == 16 ) {\
-		rgb_out = (raw>>(13-x)& 0xF800)|(raw>>(8-x)&0x07E0)|(raw>>(4-x)&0x001F);\
-		rgb_out = ((rgb_out&0xf800)>>11)|((rgb_out&0x07c0)>>1)|((rgb_out&0x001f)<<10);\
-		rgb_out = snes.color_lookup_table[rgb_out];\
-	} else if ( bits == 24 || bits == 32 ) {\
-		rgb_out = (raw>>(5-x)&0xFF0000)|(raw>>(3-x)&0xFF00)|(raw>>(1-x)&0xFF);\
-		rgb_out = ((rgb_out&0xf80000)>>19)|((rgb_out&0x00f800)>>6)|((rgb_out&0x0000f8)<<7);\
-		rgb_out = snes.color_lookup_table[rgb_out];\
-	} else if ( bits == 15 ) {\
-		rgb_out = (raw>>(14-x)& 0x7C00)|(raw>>(9-x)&0x03E0)|(raw>>(4-x)&0x001F);\
-		rgb_out = ((rgb_out&0x7c00)>>10)|((rgb_out&0x03e0))|((rgb_out&0x001f)<<10);\
-		rgb_out = snes.color_lookup_table[rgb_out];\
-	} else {\
-		rgb_out = raw;\
-	}\
-}
-
-#endif
-