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

license.txt

@@ -52,12 +52,35 @@ 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, author: NSRT Team, license: GPL *
-libco, author: byuu, license: public domain
-libui, author: byuu, license: public domain
-NTSC Filter, author: blargg, license: LGPL
-S-DD1, author: Andreas Naive, license: public domain
-zlib, license: zlib 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.
+(*) 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

readme.txt

@@ -1,8 +1,8 @@
 bsnes
-Version 0.021
+Version 0.025
 Author: byuu
 
-
+--------
 General:
 --------
 bsnes is a Super Nintendo / Super Famicom emulator that began on
@@ -13,16 +13,22 @@ 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 (eg WRAM<>WRAM) not fully emulated
+- Invalid DMA / HDMA transfers not fully emulated
 - Multiply / Divide register delays not implemented
 
 S-PPU
-- Uses scanline-based renderer. This is very inaccurate, but very few games
-  rely on mid-scanline writes to function correctly
+- 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
@@ -31,10 +37,10 @@ S-PPU
   Turning frameskipping off will allow RTO flag calculation on every frame
 
 Hardware Bugs
-- CPUr1 HDMA crashing bug not emulated
-- CPU<>APU communication bus conflicts not emulated
-
+- S-CPU.r1 HDMA crashing bug not emulated
+- S-CPU<>S-SMP communication bus conflicts not emulated
 
+---------------------
 Unsupported Hardware:
 ---------------------
 SA-1
@@ -60,14 +66,11 @@ Coprocessor used only by the following games:
 - Momotarou Densetsu Happy
 - Super Power League 4
 
-DSP-3
-Coprocessor used only by SD Gundam GX
+ST-011
+SETA DSP used only by Quick-move Shogi Match with Nidan Rank-holder Morita
 
-DSP-4
-Coprocessor used only by Top Gear 3000
-
-ST010 / ST011 / ST018
-SETA coprocessors used by very few games
+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
@@ -79,7 +82,7 @@ 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

src/Makefile

@@ -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 ###

src/base.h

@@ -1,4 +1,4 @@
-#define BSNES_VERSION "0.021"
+#define BSNES_VERSION "0.025"
 #define BSNES_TITLE   "bsnes v" BSNES_VERSION
 
 #define MEMCORE bMemBus
@@ -31,6 +31,7 @@
   #error "unsupported processor"
 #endif
 
+#include "lib/libfunctor.h"
 #include "lib/libsort.h"
 #include "lib/libarray.h"
 #include "lib/libvector.h"
@@ -38,9 +39,9 @@
 #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 {

src/cart/cart.cpp

@@ -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;
   }

src/cart/cart.h

@@ -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();

src/cart/cart_file.cpp

@@ -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;
   }
 

src/cart/cart_header.cpp

@@ -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;

src/cart/cart_normal.cpp

@@ -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;

src/cart/db/cartdb.txt

@@ -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"

src/cart/db/dbcreate.cpp

@@ -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;

src/cc.bat

@@ -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

src/chip/c4/c4.cpp

@@ -7,8 +7,6 @@
 
 #include "../../base.h"
 
-C4 *c4;
-
 #include "c4data.cpp"
 #include "c4fn.cpp"
 #include "c4oam.cpp"

src/chip/c4/c4.h

@@ -93,4 +93,4 @@ public:
   C4();
 };
 
-extern C4 *c4;
+extern C4 c4;

src/chip/dsp1/dsp1.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-DSP1 *dsp1;
-
 #include "dsp1emu.cpp"
 
 void DSP1::init() {}

src/chip/dsp1/dsp1.h

@@ -15,4 +15,4 @@ public:
   void   write(uint16 addr, uint8 data);
 };
 
-extern DSP1 *dsp1;
+extern DSP1 dsp1;

src/chip/dsp2/dsp2.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-DSP2 *dsp2;
-
 #include "dsp2_op.cpp"
 
 void DSP2::init() {}

src/chip/dsp2/dsp2.h

@@ -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;

src/chip/dsp3/dsp3.cpp

@@ -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();
+}

src/chip/dsp3/dsp3.h

@@ -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;

src/chip/dsp4/dsp4.cpp

@@ -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();
+  }
+}

src/chip/dsp4/dsp4.h

@@ -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;

src/chip/dsp4/dsp4emu.h

@@ -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

src/chip/obc1/obc1.cpp

@@ -1,7 +1,5 @@
 #include "../../base.h"
 
-OBC1 *obc1;
-
 void OBC1::init() {}
 void OBC1::enable() {}
 

src/chip/obc1/obc1.h

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

src/chip/sdd1/sdd1.cpp

@@ -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;
   }
 }
 

src/chip/sdd1/sdd1.h

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

src/chip/srtc/srtc.cpp

@@ -52,8 +52,6 @@
 
 #include "../../base.h"
 
-SRTC *srtc;
-
 void SRTC::set_time() {
 time_t rawtime;
 tm *t;

src/chip/srtc/srtc.h

@@ -49,4 +49,4 @@ struct {
   SRTC();
 };
 
-extern SRTC *srtc;
+extern SRTC srtc;

src/chip/st010/st010.cpp

@@ -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;
+  }
+}

src/chip/st010/st010.h

@@ -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;

src/chip/st010/st010_data.h

@@ -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 }
+};

src/chip/st010/st010_op.cpp

@@ -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);
+}

src/chip/superfx/core/core.h

@@ -0,0 +1,3 @@
+void op_unknown() {}
+
+void op_00();

src/chip/superfx/core/op0x.cpp

@@ -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;
+}

src/chip/superfx/memory/read.cpp

@@ -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;
+}

src/chip/superfx/memory/write.cpp

@@ -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;
+  }
+}

src/chip/superfx/regs.h

@@ -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;

src/chip/superfx/superfx.cpp

@@ -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);
+}

src/chip/superfx/superfx.h

@@ -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;

src/clean.bat

@@ -1 +1,2 @@
+::@make PLATFORM=win-mingw4-lui clean
 @make PLATFORM=win-visualc-lui clean

src/config/config.cpp

@@ -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);

src/config/config.h

@@ -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;

src/cpu/scpu/dma/dma.cpp

@@ -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) {

src/cpu/scpu/scpu.h

@@ -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"

src/interface.h

@@ -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

src/lib/libbase.h

@@ -1,5 +1,5 @@
 /*
-  libbase : version 0.10 ~byuu (2007-06-04)
+  libbase : version 0.11 ~byuu (2007-09-08)
   license: public domain
 */
 
@@ -18,7 +18,7 @@
 
 #include <new>
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__)
   #include <io.h>
   #include <direct.h>
   #include <shlobj.h>
@@ -34,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
@@ -41,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
 
@@ -90,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());
@@ -136,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) {
@@ -170,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);

src/lib/libco_x86.asm

@@ -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

src/lib/libco_x86.h

@@ -1,26 +1,26 @@
 /*
-  libco_x86 : version 0.10 ~byuu (2007-06-04)
+  libco_x86 : version 0.10 ~byuu (2007-09-08)
   license: public domain
 */
 
 #ifndef LIBCO_H
 #define LIBCO_H
 
-#undef fastcall
-#if defined(_MSC_VER)
-  #define fastcall __fastcall
-#elif defined(__GNUC__)
-  #define fastcall __attribute__((fastcall))
-#else
-  #error "fastcall undefined"
+#if !defined(fastcall)
+  #if defined(_MSC_VER)
+    #define fastcall __fastcall
+  #elif defined(__GNUC__)
+    #define fastcall __attribute__((fastcall))
+  #else
+    #error "fastcall undefined"
+  #endif
 #endif
 
-#define cocall fastcall
-typedef void (*cothread_t);
+typedef void *cothread_t;
 
-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);
+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

src/lib/libco_x86_64.asm

@@ -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

src/lib/libco_x86_64.h

@@ -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);
 

src/lib/libconfig.h

@@ -1,5 +1,5 @@
 /*
-  libconfig : version 0.14 ~byuu (2007-06-10)
+  libconfig : version 0.14 ~byuu (2007-06-12)
   license: public domain
 */
 
@@ -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, const char *r_name, const 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);

src/lib/libfunctor.h

@@ -0,0 +1,100 @@
+/*
+  libfunctor : version 0.05 ~byuu (2007-09-08)
+  license: public domain
+*/
+
+#ifndef LIBFUNCTOR_H
+#define LIBFUNCTOR_H
+
+//prologue
+
+#define TN typename
+
+template<typename T> class functor;
+
+//parameters = 0
+
+#define cat(n)  n
+#define TL typename R
+#define PL
+#define CL
+
+#include "libfunctor_impl.h"
+
+//parameters = 1
+
+#define cat(n)  , n
+#define TL TN R, TN P1
+#define PL P1 p1
+#define CL p1
+
+#include "libfunctor_impl.h"
+
+//parameters = 2
+
+#define cat(n)  , n
+#define TL TN R, TN P1, TN P2
+#define PL P1 p1, P2 p2
+#define CL p1, p2
+
+#include "libfunctor_impl.h"
+
+//parameters = 3
+
+#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
+
+#include "libfunctor_impl.h"
+
+//parameters = 4
+
+#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
+
+#include "libfunctor_impl.h"
+
+//parameters = 5
+
+#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
+
+#include "libfunctor_impl.h"
+
+//parameters = 6
+
+#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
+
+#include "libfunctor_impl.h"
+
+//parameters = 7
+
+#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
+
+#include "libfunctor_impl.h"
+
+//parameters = 8
+
+#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
+
+#include "libfunctor_impl.h"
+
+//epilogue
+
+#undef TN
+
+#endif

src/lib/libfunctor_impl.h

@@ -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

src/lib/libui_gtk_control.h

@@ -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);
 };
 
 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);
 };
 
 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),
@@ -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,

src/lib/libui_win.cpp

@@ -1,3 +1,5 @@
+#define _WIN32_IE 0x0600
+
 #include "libui_win.h"
 #include "libui_win_window.cpp"
 #include "libui_win_control.cpp"

src/lib/libui_win_control.h

@@ -157,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();
@@ -174,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();
@@ -183,6 +187,7 @@ ControlGroup group;
 };
 
 class Editbox : public Control { public:
+enum { ideal_height = 21 };
 enum {
   Multiline = (1 << 1),
   Readonly  = (1 << 2),
@@ -235,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);
@@ -243,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,

src/memory/bmemory/bmemory.cpp

@@ -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",

src/memory/bmemory/bmemory.h

@@ -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();

src/memory/bmemory/bmemory_mapper_generic.cpp

@@ -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;
+    }
+  }
+}

src/memory/bmemory/bmemory_rw.cpp

@@ -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); }

src/memory/bmemory/mapper/mapper.cpp

@@ -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;
 }

src/memory/bmemory/mapper/mapper.h

@@ -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);

src/memory/bmemory/mapper/mapper_pcb.cpp

@@ -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

src/ppu/bppu/bppu.h

@@ -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

src/ppu/bppu/bppu_mmio.cpp

@@ -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;

src/ppu/bppu/bppu_render_bg.cpp

@@ -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) \

src/smp/ssmp/core/op_rmw.b

@@ -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);
 }

src/smp/ssmp/core/op_rmw.cpp

@@ -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);
 }

src/snes/interface/interface.h

@@ -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);
 

src/snes/scheduler/scheduler.cpp

@@ -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);
 }
 
 //

src/snes/snes.cpp

@@ -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();
 }

src/snes/tracer/tracer.cpp

@@ -1,6 +1,6 @@
 Tracer tracer;
 
-void tprintf(char *s, ...) {
+void tprintf(const char *s, ...) {
   if(tracer.enabled() == false) { return; }
 
 char str[4096];

src/snes/tracer/tracer.h

@@ -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;

src/snes/video/filter_ntsc.cpp

@@ -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;

src/snes/video/filter_ntsc.h

@@ -1,4 +1,4 @@
-#include "filter_ntsc_core.h"
+#include "ntsc/snes_ntsc.h"
 
 class NtscVideoFilter : public VideoFilter {
 private:

src/snes/video/filter_ntsc_core.cpp

@@ -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
-

src/snes/video/filter_ntsc_core.h

@@ -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
-

src/snes/video/ntsc/snes_ntsc.c

@@ -0,0 +1,251 @@
+/* snes_ntsc 0.2.2. http://www.slack.net/~ant/ */
+
+#include "snes_ntsc.h"
+
+/* Copyright (C) 2006-2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
+
+snes_ntsc_setup_t const snes_ntsc_monochrome = { 0,-1, 0, 0,.2,  0,.2,-.2,-.2,-1,  1, 0, 0 };
+snes_ntsc_setup_t const snes_ntsc_composite  = { 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,  1, 0, 0 };
+snes_ntsc_setup_t const snes_ntsc_rgb        = { 0, 0, 0, 0,.2,  0,.7, -1, -1,-1,  1, 0, 0 };
+
+#define alignment_count 3
+#define burst_count     3
+#define rescale_in      8
+#define rescale_out     7
+
+#define artifacts_mid   1.0f
+#define fringing_mid    1.0f
+#define std_decoder_hue 0
+
+#define rgb_bits        7 /* half normal range to allow for doubled hires pixels */
+#define gamma_size      32
+
+#include "snes_ntsc_impl.h"
+
+/* 3 input pixels -> 8 composite samples */
+pixel_info_t const snes_ntsc_pixels [alignment_count] = {
+	{ PIXEL_OFFSET( -4, -9 ), { 1, 1, .6667f, 0 } },
+	{ PIXEL_OFFSET( -2, -7 ), {       .3333f, 1, 1, .3333f } },
+	{ PIXEL_OFFSET(  0, -5 ), {                  0, .6667f, 1, 1 } },
+};
+
+static void merge_kernel_fields( snes_ntsc_rgb_t* io )
+{
+	int n;
+	for ( n = burst_size; n; --n )
+	{
+		snes_ntsc_rgb_t p0 = io [burst_size * 0] + rgb_bias;
+		snes_ntsc_rgb_t p1 = io [burst_size * 1] + rgb_bias;
+		snes_ntsc_rgb_t p2 = io [burst_size * 2] + rgb_bias;
+		/* merge colors without losing precision */
+		io [burst_size * 0] =
+				((p0 + p1 - ((p0 ^ p1) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		io [burst_size * 1] =
+				((p1 + p2 - ((p1 ^ p2) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		io [burst_size * 2] =
+				((p2 + p0 - ((p2 ^ p0) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		++io;
+	}
+}
+
+static void correct_errors( snes_ntsc_rgb_t color, snes_ntsc_rgb_t* out )
+{
+	int n;
+	for ( n = burst_count; n; --n )
+	{
+		unsigned i;
+		for ( i = 0; i < rgb_kernel_size / 2; i++ )
+		{
+			snes_ntsc_rgb_t error = color -
+					out [i    ] - out [(i+12)%14+14] - out [(i+10)%14+28] -
+					out [i + 7] - out [i + 5    +14] - out [i + 3    +28];
+			DISTRIBUTE_ERROR( i+3+28, i+5+14, i+7 );
+		}
+		out += alignment_count * rgb_kernel_size;
+	}
+}
+
+void snes_ntsc_init( snes_ntsc_t* ntsc, snes_ntsc_setup_t const* setup )
+{
+	int merge_fields;
+	int entry;
+	init_t impl;
+	if ( !setup )
+		setup = &snes_ntsc_composite;
+	init( &impl, setup );
+	
+	merge_fields = setup->merge_fields;
+	if ( setup->artifacts <= -1 && setup->fringing <= -1 )
+		merge_fields = 1;
+	
+	for ( entry = 0; entry < snes_ntsc_palette_size; 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 SNES_NTSC_BSNES_COLORTBL
+			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;
+			}
+		#endif
+		
+		{
+			float rr = impl.to_float [ir];
+			float gg = impl.to_float [ig];
+			float bb = impl.to_float [ib];
+			
+			float y, i, q = RGB_TO_YIQ( rr, gg, bb, y, i );
+			
+			int r, g, b = YIQ_TO_RGB( y, i, q, impl.to_rgb, int, r, g );
+			snes_ntsc_rgb_t rgb = PACK_RGB( r, g, b );
+			
+			snes_ntsc_rgb_t* out = ntsc->table [entry];
+			gen_kernel( &impl, y, i, q, out );
+			if ( merge_fields )
+				merge_kernel_fields( out );
+			correct_errors( rgb, out );
+		}
+	}
+}
+
+#ifndef SNES_NTSC_NO_BLITTERS
+
+void snes_ntsc_blit( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input, 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 )
+	{
+		SNES_NTSC_IN_T const* line_in = input;
+		SNES_NTSC_BEGIN_ROW( ntsc, burst_phase,
+				snes_ntsc_black, snes_ntsc_black, SNES_NTSC_ADJ_IN( *line_in ) );
+		snes_ntsc_out_t* restrict line_out = (snes_ntsc_out_t*) rgb_out;
+		int n;
+		++line_in;
+		
+		for ( n = chunk_count; n; --n )
+		{
+			/* order of input and output pixels must not be altered */
+			SNES_NTSC_COLOR_IN( 0, SNES_NTSC_ADJ_IN( line_in [0] ) );
+			SNES_NTSC_RGB_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 1, SNES_NTSC_ADJ_IN( line_in [1] ) );
+			SNES_NTSC_RGB_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 2, SNES_NTSC_ADJ_IN( line_in [2] ) );
+			SNES_NTSC_RGB_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+			
+			line_in  += 3;
+			line_out += 7;
+		}
+		
+		/* finish final pixels */
+		SNES_NTSC_COLOR_IN( 0, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 1, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 2, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+		
+		burst_phase = (burst_phase + 1) % snes_ntsc_burst_count;
+		input += in_row_width;
+		rgb_out = (char*) rgb_out + out_pitch;
+	}
+}
+
+void snes_ntsc_blit_hires( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input, 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 )
+	{
+		SNES_NTSC_IN_T const* line_in = input;
+		SNES_NTSC_HIRES_ROW( ntsc, burst_phase,
+				snes_ntsc_black, snes_ntsc_black, snes_ntsc_black,
+				SNES_NTSC_ADJ_IN( line_in [0] ),
+				SNES_NTSC_ADJ_IN( 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 )
+		{
+			/* twice as many input pixels per chunk */
+			SNES_NTSC_COLOR_IN( 0, SNES_NTSC_ADJ_IN( line_in [0] ) );
+			SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 1, SNES_NTSC_ADJ_IN( line_in [1] ) );
+			SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 2, SNES_NTSC_ADJ_IN( line_in [2] ) );
+			SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 3, SNES_NTSC_ADJ_IN( line_in [3] ) );
+			SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 4, SNES_NTSC_ADJ_IN( line_in [4] ) );
+			SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 5, SNES_NTSC_ADJ_IN( 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_COLOR_IN( 0, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 1, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 2, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 3, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 4, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_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;
+		input += in_row_width;
+		rgb_out = (char*) rgb_out + out_pitch;
+	}
+}
+
+#endif

src/snes/video/ntsc/snes_ntsc.h

@@ -0,0 +1,228 @@
+/* SNES NTSC video filter */
+
+/* snes_ntsc 0.2.2 */
+#ifndef SNES_NTSC_H
+#define SNES_NTSC_H
+
+#include "snes_ntsc_config.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+/* Image parameters, ranging from -1.0 to 1.0. Actual internal values shown
+in parenthesis and should remain fairly stable in future versions. */
+typedef struct snes_ntsc_setup_t
+{
+	/* Basic parameters */
+	double hue;        /* -1 = -180 degrees     +1 = +180 degrees */
+	double saturation; /* -1 = grayscale (0.0)  +1 = oversaturated colors (2.0) */
+	double contrast;   /* -1 = dark (0.5)       +1 = light (1.5) */
+	double brightness; /* -1 = dark (0.5)       +1 = light (1.5) */
+	double sharpness;  /* edge contrast enhancement/blurring */
+	
+	/* Advanced parameters */
+	double gamma;      /* -1 = dark (1.5)       +1 = light (0.5) */
+	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) */
+	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; /* undocumented; 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 */
+
+/* Initializes and adjusts parameters. Can be called multiple times on the same
+snes_ntsc_t object. Can pass NULL for either parameter. */
+typedef struct snes_ntsc_t snes_ntsc_t;
+void snes_ntsc_init( snes_ntsc_t* ntsc, snes_ntsc_setup_t const* setup );
+
+/* Filters one or more rows of pixels. Input pixel format is set by SNES_NTSC_IN_FORMAT
+and output RGB depth is set by SNES_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* ntsc, SNES_NTSC_IN_T const* input,
+		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* ntsc, SNES_NTSC_IN_T const* input,
+		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 + 1) * 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 - 1) * snes_ntsc_in_chunk + 1)
+
+
+/* Interface for user-defined custom blitters */
+
+enum { snes_ntsc_in_chunk    = 3  }; /* number of input 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 */
+
+/* Begins outputting row and starts 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_BEGIN_ROW( ntsc, burst, pixel0, pixel1, pixel2 ) \
+	char const* ktable = \
+		(char const*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (snes_ntsc_rgb_t));\
+	SNES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, SNES_NTSC_IN_FORMAT, ktable )
+
+/* Begins input pixel */
+#define SNES_NTSC_COLOR_IN( index, color ) \
+	SNES_NTSC_COLOR_IN_( index, color, SNES_NTSC_IN_FORMAT, ktable )
+
+/* Generates output pixel. Bits can be 24, 16, 15, 14, 32 (treated as 24), or 0:
+24:          RRRRRRRR GGGGGGGG BBBBBBBB (8-8-8 RGB)
+16:                   RRRRRGGG GGGBBBBB (5-6-5 RGB)
+15:                    RRRRRGG GGGBBBBB (5-5-5 RGB)
+14:                    BBBBBGG GGGRRRRR (5-5-5 BGR, native SNES format)
+ 0: xxxRRRRR RRRxxGGG GGGGGxxB BBBBBBBx (native internal format; x = junk bits) */
+#define SNES_NTSC_RGB_OUT( index, rgb_out, bits ) \
+	SNES_NTSC_RGB_OUT_14_( index, rgb_out, bits, 1 )
+
+/* Hires equivalents */
+#define SNES_NTSC_HIRES_ROW( ntsc, burst, pixel1, pixel2, pixel3, pixel4, pixel5 ) \
+	char const* ktable = \
+		(char const*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (snes_ntsc_rgb_t));\
+	unsigned const snes_ntsc_pixel1_ = (pixel1);\
+	snes_ntsc_rgb_t const* kernel1  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel1_ );\
+	unsigned const snes_ntsc_pixel2_ = (pixel2);\
+	snes_ntsc_rgb_t const* kernel2  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel2_ );\
+	unsigned const snes_ntsc_pixel3_ = (pixel3);\
+	snes_ntsc_rgb_t const* kernel3  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel3_ );\
+	unsigned const snes_ntsc_pixel4_ = (pixel4);\
+	snes_ntsc_rgb_t const* kernel4  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel4_ );\
+	unsigned const snes_ntsc_pixel5_ = (pixel5);\
+	snes_ntsc_rgb_t const* kernel5  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel5_ );\
+	snes_ntsc_rgb_t const* kernel0 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx0;\
+	snes_ntsc_rgb_t const* kernelx1 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx2 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx3 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx4 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx5 = kernel1
+
+#define SNES_NTSC_HIRES_OUT( x, rgb_out, bits ) {\
+	snes_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_RGB_OUT_( rgb_out, (bits), 0 );\
+}
+
+
+/* private */
+enum { snes_ntsc_entry_size = 128 };
+enum { snes_ntsc_palette_size = 0x2000 };
+typedef unsigned long snes_ntsc_rgb_t;
+struct snes_ntsc_t {
+	snes_ntsc_rgb_t table [snes_ntsc_palette_size] [snes_ntsc_entry_size];
+};
+enum { snes_ntsc_burst_size = snes_ntsc_entry_size / snes_ntsc_burst_count };
+
+#define SNES_NTSC_RGB16( ktable, n ) \
+	(snes_ntsc_rgb_t const*) (ktable + ((n & 0x001E) | (n >> 1 & 0x03E0) | (n >> 2 & 0x3C00)) * \
+			(snes_ntsc_entry_size / 2 * sizeof (snes_ntsc_rgb_t)))
+
+#define SNES_NTSC_BGR15( ktable, n ) \
+	(snes_ntsc_rgb_t const*) (ktable + ((n << 9 & 0x3C00) | (n & 0x03E0) | (n >> 10 & 0x001E)) * \
+			(snes_ntsc_entry_size / 2 * sizeof (snes_ntsc_rgb_t)))
+
+/* common 3->7 ntsc macros */
+#define SNES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, ENTRY, table ) \
+	unsigned const snes_ntsc_pixel0_ = (pixel0);\
+	snes_ntsc_rgb_t const* kernel0  = ENTRY( table, snes_ntsc_pixel0_ );\
+	unsigned const snes_ntsc_pixel1_ = (pixel1);\
+	snes_ntsc_rgb_t const* kernel1  = ENTRY( table, snes_ntsc_pixel1_ );\
+	unsigned const snes_ntsc_pixel2_ = (pixel2);\
+	snes_ntsc_rgb_t const* kernel2  = ENTRY( table, snes_ntsc_pixel2_ );\
+	snes_ntsc_rgb_t const* kernelx0;\
+	snes_ntsc_rgb_t const* kernelx1 = kernel0;\
+	snes_ntsc_rgb_t const* kernelx2 = kernel0
+
+#define SNES_NTSC_RGB_OUT_14_( x, rgb_out, bits, shift ) {\
+	snes_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_, shift );\
+	SNES_NTSC_RGB_OUT_( rgb_out, bits, shift );\
+}
+
+/* common ntsc macros */
+#define snes_ntsc_rgb_builder    ((1L << 21) | (1 << 11) | (1 << 1))
+#define snes_ntsc_clamp_mask     (snes_ntsc_rgb_builder * 3 / 2)
+#define snes_ntsc_clamp_add      (snes_ntsc_rgb_builder * 0x101)
+#define SNES_NTSC_CLAMP_( io, shift ) {\
+	snes_ntsc_rgb_t sub = (io) >> (9-(shift)) & snes_ntsc_clamp_mask;\
+	snes_ntsc_rgb_t clamp = snes_ntsc_clamp_add - sub;\
+	io |= clamp;\
+	clamp -= sub;\
+	io &= clamp;\
+}
+
+#define SNES_NTSC_COLOR_IN_( index, color, ENTRY, table ) {\
+	unsigned color_;\
+	kernelx##index = kernel##index;\
+	kernel##index = (color_ = (color), ENTRY( table, color_ ));\
+}
+
+/* x is always zero except in snes_ntsc library */
+/* original routine */
+/*
+#define SNES_NTSC_RGB_OUT_( rgb_out, bits, x ) {\
+	if ( bits == 16 )\
+		rgb_out = (raw_>>(13-x)& 0xF800)|(raw_>>(8-x)&0x07E0)|(raw_>>(4-x)&0x001F);\
+	if ( bits == 24 || bits == 32 )\
+		rgb_out = (raw_>>(5-x)&0xFF0000)|(raw_>>(3-x)&0xFF00)|(raw_>>(1-x)&0xFF);\
+	if ( bits == 15 )\
+		rgb_out = (raw_>>(14-x)& 0x7C00)|(raw_>>(9-x)&0x03E0)|(raw_>>(4-x)&0x001F);\
+	if ( bits == 14 )\
+		rgb_out = (raw_>>(24-x)& 0x001F)|(raw_>>(9-x)&0x03E0)|(raw_<<(6+x)&0x7C00);\
+	if ( bits == 0 )\
+		rgb_out = raw_ << x;\
+}
+*/
+
+/* custom bsnes routine -- hooks into bsnes colortable */
+#define SNES_NTSC_RGB_OUT_( rgb_out, bits, 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_ << x;\
+	}\
+}
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif

src/snes/video/ntsc/snes_ntsc_config.h

@@ -0,0 +1,26 @@
+/* Configure library by modifying this file */
+
+#ifndef SNES_NTSC_CONFIG_H
+#define SNES_NTSC_CONFIG_H
+
+/* Format of source pixels */
+/* #define SNES_NTSC_IN_FORMAT SNES_NTSC_RGB16 */
+#define SNES_NTSC_IN_FORMAT SNES_NTSC_BGR15
+
+/* The following affect the built-in blitter only; a custom blitter can
+handle things however it wants. */
+
+/* Bits per pixel of output. Can be 15, 16, 32, or 24 (same as 32). */
+#define SNES_NTSC_OUT_DEPTH 16
+
+/* Type of input pixel values */
+#define SNES_NTSC_IN_T unsigned short
+
+/* Each raw pixel input value is passed through this. You might want to mask
+the pixel index if you use the high bits as flags, etc. */
+#define SNES_NTSC_ADJ_IN( in ) in
+
+/* For each pixel, this is the basic operation:
+output_color = SNES_NTSC_ADJ_IN( SNES_NTSC_IN_T ) */
+
+#endif

src/snes/video/ntsc/snes_ntsc_impl.h

@@ -0,0 +1,439 @@
+/* snes_ntsc 0.2.2. http://www.slack.net/~ant/ */
+
+/* Common implementation of NTSC filters */
+
+#include <assert.h>
+#include <math.h>
+
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#define DISABLE_CORRECTION 0
+
+#undef PI
+#define PI 3.14159265358979323846f
+
+#ifndef LUMA_CUTOFF
+	#define LUMA_CUTOFF 0.20
+#endif
+#ifndef gamma_size
+	#define gamma_size 1
+#endif
+#ifndef rgb_bits
+	#define rgb_bits 8
+#endif
+#ifndef artifacts_max
+	#define artifacts_max (artifacts_mid * 1.5f)
+#endif
+#ifndef fringing_max
+	#define fringing_max (fringing_mid * 2)
+#endif
+#ifndef STD_HUE_CONDITION
+	#define STD_HUE_CONDITION( setup ) 1
+#endif
+
+#define ext_decoder_hue     (std_decoder_hue + 15)
+#define rgb_unit            (1 << rgb_bits)
+#define rgb_offset          (rgb_unit * 2 + 0.5f)
+
+enum { burst_size  = snes_ntsc_entry_size / burst_count };
+enum { kernel_half = 16 };
+enum { kernel_size = kernel_half * 2 + 1 };
+
+typedef struct init_t
+{
+	float to_rgb [burst_count * 6];
+	float to_float [gamma_size];
+	float contrast;
+	float brightness;
+	float artifacts;
+	float fringing;
+	float kernel [rescale_out * kernel_size * 2];
+} init_t;
+
+#define ROTATE_IQ( i, q, sin_b, cos_b ) {\
+	float t;\
+	t = i * cos_b - q * sin_b;\
+	q = i * sin_b + q * cos_b;\
+	i = t;\
+}
+
+static void init_filters( init_t* impl, snes_ntsc_setup_t const* setup )
+{
+#if rescale_out > 1
+	float kernels [kernel_size * 2];
+#else
+	float* const kernels = impl->kernel;
+#endif
+
+	/* generate luma (y) filter using sinc kernel */
+	{
+		/* sinc with rolloff (dsf) */
+		float const rolloff = 1 + (float) setup->sharpness * (float) 0.032;
+		float const maxh = 32;
+		float const pow_a_n = (float) pow( rolloff, maxh );
+		float sum;
+		int i;
+		/* quadratic mapping to reduce negative (blurring) range */
+		float to_angle = (float) setup->resolution + 1;
+		to_angle = PI / maxh * (float) LUMA_CUTOFF * (to_angle * to_angle + 1);
+		
+		kernels [kernel_size * 3 / 2] = maxh; /* default center value */
+		for ( i = 0; i < kernel_half * 2 + 1; i++ )
+		{
+			int x = i - kernel_half;
+			float angle = x * to_angle;
+			/* instability occurs at center point with rolloff very close to 1.0 */
+			if ( x || pow_a_n > (float) 1.056 || pow_a_n < (float) 0.981 )
+			{
+				float rolloff_cos_a = rolloff * (float) cos( angle );
+				float num = 1 - rolloff_cos_a -
+						pow_a_n * (float) cos( maxh * angle ) +
+						pow_a_n * rolloff * (float) cos( (maxh - 1) * angle );
+				float den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff;
+				float dsf = num / den;
+				kernels [kernel_size * 3 / 2 - kernel_half + i] = dsf - (float) 0.5;
+			}
+		}
+		
+		/* 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 */
+			}
+		}
+	}
+	
+	/*
+	printf( "luma:\n" );
+	for ( i = kernel_size; i < kernel_size * 2; i++ )
+		printf( "%f\n", kernels [i] );
+	printf( "chroma:\n" );
+	for ( i = 0; i < kernel_size; i++ )
+		printf( "%f\n", kernels [i] );
+	*/
+	
+	/* generate linear rescale kernels */
+	#if rescale_out > 1
+	{
+		float weight = 1.0f;
+		float* out = impl->kernel;
+		int n = rescale_out;
+		do
+		{
+			float remain = 0;
+			int i;
+			weight -= 1.0f / rescale_in;
+			for ( i = 0; i < kernel_size * 2; i++ )
+			{
+				float cur = kernels [i];
+				float m = cur * weight;
+				*out++ = m + remain;
+				remain = cur - m;
+			}
+		}
+		while ( --n );
+	}
+	#endif
+}
+
+static float const default_decoder [6] =
+	{ 0.956f, 0.621f, -0.272f, -0.647f, -1.105f, 1.702f };
+
+static void init( init_t* impl, snes_ntsc_setup_t const* setup )
+{
+	impl->brightness = (float) setup->brightness * (0.5f * rgb_unit) + rgb_offset;
+	impl->contrast   = (float) setup->contrast   * (0.5f * rgb_unit) + rgb_unit;
+	#ifdef default_palette_contrast
+		if ( !setup->palette )
+			impl->contrast *= default_palette_contrast;
+	#endif
+	
+	impl->artifacts = (float) setup->artifacts;
+	if ( impl->artifacts > 0 )
+		impl->artifacts *= artifacts_max - artifacts_mid;
+	impl->artifacts = impl->artifacts * artifacts_mid + artifacts_mid;
+
+	impl->fringing = (float) setup->fringing;
+	if ( impl->fringing > 0 )
+		impl->fringing *= fringing_max - fringing_mid;
+	impl->fringing = impl->fringing * fringing_mid + fringing_mid;
+	
+	init_filters( impl, setup );
+	
+	/* generate gamma table */
+	if ( gamma_size > 1 )
+	{
+		float const to_float = 1.0f / (gamma_size - (gamma_size > 1));
+		float const gamma = 1.1333f - (float) setup->gamma * 0.5f;
+		/* match common PC's 2.2 gamma to TV's 2.65 gamma */
+		int i;
+		for ( i = 0; i < gamma_size; i++ )
+			impl->to_float [i] =
+					(float) pow( i * to_float, gamma ) * impl->contrast + impl->brightness;
+	}
+	
+	/* setup decoder matricies */
+	{
+		float hue = (float) setup->hue * PI + PI / 180 * ext_decoder_hue;
+		float sat = (float) setup->saturation + 1;
+		float const* decoder = setup->decoder_matrix;
+		if ( !decoder )
+		{
+			decoder = default_decoder;
+			if ( STD_HUE_CONDITION( setup ) )
+				hue += PI / 180 * (std_decoder_hue - ext_decoder_hue);
+		}
+		
+		{
+			float s = (float) sin( hue ) * sat;
+			float c = (float) cos( hue ) * sat;
+			float* out = impl->to_rgb;
+			int n;
+			
+			n = burst_count;
+			do
+			{
+				float const* in = decoder;
+				int n = 3;
+				do
+				{
+					float i = *in++;
+					float q = *in++;
+					*out++ = i * c - q * s;
+					*out++ = i * s + q * c;
+				}
+				while ( --n );
+				if ( burst_count <= 1 )
+					break;
+				ROTATE_IQ( s, c, 0.866025f, -0.5f ); /* +120 degrees */
+			}
+			while ( --n );
+		}
+	}
+}
+
+/* kernel generation */
+
+#define RGB_TO_YIQ( r, g, b, y, i ) (\
+	(y = (r) * 0.299f + (g) * 0.587f + (b) * 0.114f),\
+	(i = (r) * 0.596f - (g) * 0.275f - (b) * 0.321f),\
+	((r) * 0.212f - (g) * 0.523f + (b) * 0.311f)\
+)
+
+#define YIQ_TO_RGB( y, i, q, to_rgb, type, r, g ) (\
+	r = (type) (y + to_rgb [0] * i + to_rgb [1] * q),\
+	g = (type) (y + to_rgb [2] * i + to_rgb [3] * q),\
+	(type) (y + to_rgb [4] * i + to_rgb [5] * q)\
+)
+
+#define PACK_RGB( r, g, b ) ((r) << 21 | (g) << 11 | (b) << 1)
+
+enum { rgb_kernel_size = burst_size / alignment_count };
+enum { rgb_bias = rgb_unit * 2 * snes_ntsc_rgb_builder };
+
+typedef struct pixel_info_t
+{
+	int offset;
+	float negate;
+	float kernel [4];
+} pixel_info_t;
+
+#if rescale_in > 1
+	#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))
+#else
+	#define PIXEL_OFFSET( ntsc, scaled ) \
+		(kernel_size / 2 + (ntsc) - (scaled)),\
+		(1.0f - (((ntsc) + 100) & 2))
+#endif
+
+extern pixel_info_t const snes_ntsc_pixels [alignment_count];
+
+/* Generate pixel at all burst phases and column alignments */
+static void gen_kernel( init_t* impl, float y, float i, float q, snes_ntsc_rgb_t* out )
+{
+	/* generate for each scanline burst phase */
+	float const* to_rgb = impl->to_rgb;
+	int burst_remain = burst_count;
+	y -= rgb_offset;
+	do
+	{
+		/* 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. Based on algorithm by NewRisingSun. */
+		pixel_info_t const* pixel = snes_ntsc_pixels;
+		int alignment_remain = alignment_count;
+		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;
+			++pixel;
+			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 ( rescale_out <= 1 )
+					k--;
+				else if ( k < &impl->kernel [kernel_size * 2 * (rescale_out - 1)] )
+					k += kernel_size * 2 - 1;
+				else
+					k -= kernel_size * 2 * (rescale_out - 1) + 2;
+				{
+					int r, g, b = YIQ_TO_RGB( y, i, q, to_rgb, int, r, g );
+					*out++ = PACK_RGB( r, g, b ) - rgb_bias;
+				}
+			}
+		}
+		while ( alignment_count > 1 && --alignment_remain );
+		
+		if ( burst_count <= 1 )
+			break;
+		
+		to_rgb += 6;
+		
+		ROTATE_IQ( i, q, -0.866025f, -0.5f ); /* -120 degrees */
+	}
+	while ( --burst_remain );
+}
+
+static void correct_errors( snes_ntsc_rgb_t color, snes_ntsc_rgb_t* out );
+
+#if DISABLE_CORRECTION
+	#define CORRECT_ERROR( a ) { out [i] += rgb_bias; }
+	#define DISTRIBUTE_ERROR( a, b, c ) { out [i] += rgb_bias; }
+#else
+	#define CORRECT_ERROR( a ) { out [a] += error; }
+	#define DISTRIBUTE_ERROR( a, b, c ) {\
+		snes_ntsc_rgb_t fourth = (error + 2 * snes_ntsc_rgb_builder) >> 2;\
+		fourth &= (rgb_bias >> 1) - snes_ntsc_rgb_builder;\
+		fourth -= rgb_bias >> 2;\
+		out [a] += fourth;\
+		out [b] += fourth;\
+		out [c] += fourth;\
+		out [i] += error - (fourth * 3);\
+	}
+#endif
+
+#define RGB_PALETTE_OUT( rgb, out_ )\
+{\
+	unsigned char* out = (out_);\
+	snes_ntsc_rgb_t clamped = (rgb);\
+	SNES_NTSC_CLAMP_( clamped, (8 - rgb_bits) );\
+	out [0] = (unsigned char) (clamped >> 21);\
+	out [1] = (unsigned char) (clamped >> 11);\
+	out [2] = (unsigned char) (clamped >>  1);\
+}
+
+/* blitter related */
+
+#ifndef restrict
+	#if defined (__GNUC__)
+		#define restrict __restrict__
+	#elif defined (_MSC_VER) && _MSC_VER > 1300
+		#define restrict __restrict
+	#else
+		/* no support for restricted pointers */
+		#define restrict
+	#endif
+#endif
+
+#include <limits.h>
+
+#if SNES_NTSC_OUT_DEPTH <= 16
+	#if USHRT_MAX == 0xFFFF
+		typedef unsigned short snes_ntsc_out_t;
+	#else
+		#error "Need 16-bit int type"
+	#endif
+
+#else
+	#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
+
+#endif

src/ui/audio/audio.cpp

@@ -1,100 +1,4 @@
-/*
- * interpolation routines are located in: /src/lib/libinterp.h
- */
-
-/*
-
-inline uint Audio::bind_range(uint min, uint max, uint index) {
-  return index < min ? min : index > max ? max : index;
-}
-
-void Audio::resample_point(
-uint32 *output, uint32 *input, uint output_samples, uint input_samples
-) {
-double scalar = double(input_samples--) / double(output_samples--); //convert lengths to upper bounds
-double sindex = 0.0;
-  for(uint x = 0; x <= output_samples; x++) {
-  uint32 y0 = input[bind_range(0, input_samples, uint32(sindex) + 0)];
-  uint32 y1 = input[bind_range(0, input_samples, uint32(sindex) + 1)];
-  double mu = sindex - uint(sindex); //calculate fractional portion of step
-  uint16 yl = interpolate_point(mu, int16(y0 >>  0), int16(y1 >>  0));
-  uint16 yr = interpolate_point(mu, int16(y0 >> 16), int16(y1 >> 16));
-    output[x] = (yl << 0) + (yr << 16);
-    sindex += scalar;
-  }
-}
-
-void Audio::resample_linear(
-uint32 *output, uint32 *input, uint output_samples, uint input_samples
-) {
-double scalar = double(input_samples--) / double(output_samples--); //convert lengths to upper bounds
-double sindex = 0.0;
-  for(uint x = 0; x <= output_samples; x++) {
-  uint32 y0 = input[bind_range(0, input_samples, uint32(sindex) + 0)];
-  uint32 y1 = input[bind_range(0, input_samples, uint32(sindex) + 1)];
-  double mu = sindex - uint(sindex); //calculate fractional portion of step
-  uint16 yl = interpolate_linear(mu, int16(y0 >>  0), int16(y1 >>  0));
-  uint16 yr = interpolate_linear(mu, int16(y0 >> 16), int16(y1 >> 16));
-    output[x] = (yl << 0) + (yr << 16);
-    sindex += scalar;
-  }
-}
-
-void Audio::resample_cosine(
-uint32 *output, uint32 *input, uint output_samples, uint input_samples
-) {
-double scalar = double(input_samples--) / double(output_samples--); //convert lengths to upper bounds
-double sindex = 0.0;
-  for(uint x = 0; x <= output_samples; x++) {
-  uint32 y0 = input[bind_range(0, input_samples, uint32(sindex) + 0)];
-  uint32 y1 = input[bind_range(0, input_samples, uint32(sindex) + 1)];
-  double mu = sindex - uint(sindex); //calculate fractional portion of step
-  uint16 yl = interpolate_cosine(mu, int16(y0 >>  0), int16(y1 >>  0));
-  uint16 yr = interpolate_cosine(mu, int16(y0 >> 16), int16(y1 >> 16));
-    output[x] = (yl << 0) + (yr << 16);
-    sindex += scalar;
-  }
-}
-
-void Audio::resample_cubic(
-uint32 *output, uint32 *input, uint output_samples, uint input_samples
-) {
-double scalar = double(input_samples--) / double(output_samples--); //convert lengths to upper bounds
-double sindex = 0.0;
-  for(uint x = 0; x <= output_samples; x++) {
-  uint32 y0 = input[bind_range(0, input_samples, uint32(sindex) - 1)];
-  uint32 y1 = input[bind_range(0, input_samples, uint32(sindex) + 0)];
-  uint32 y2 = input[bind_range(0, input_samples, uint32(sindex) + 1)];
-  uint32 y3 = input[bind_range(0, input_samples, uint32(sindex) + 2)];
-  double mu = sindex - uint(sindex); //calculate fractional portion of step
-  uint16 yl = sclamp<16>( interpolate_cubic(mu, int16(y0 >>  0), int16(y1 >>  0), int16(y2 >>  0), int16(y3 >>  0)) );
-  uint16 yr = sclamp<16>( interpolate_cubic(mu, int16(y0 >> 16), int16(y1 >> 16), int16(y2 >> 16), int16(y3 >> 16)) );
-    output[x] = (yl << 0) + (yr << 16);
-    sindex += scalar;
-  }
-}
-
-void Audio::resample_hermite(
-uint32 *output, uint32 *input, uint output_samples, uint input_samples
-) {
-double scalar = double(input_samples--) / double(output_samples--); //convert lengths to upper bounds
-double sindex = 0.0;
-  for(uint x = 0; x <= output_samples; x++) {
-  uint32 y0 = input[bind_range(0, input_samples, uint32(sindex) - 1)];
-  uint32 y1 = input[bind_range(0, input_samples, uint32(sindex) + 0)];
-  uint32 y2 = input[bind_range(0, input_samples, uint32(sindex) + 1)];
-  uint32 y3 = input[bind_range(0, input_samples, uint32(sindex) + 2)];
-  double mu = sindex - uint(sindex); //calculate fractional portion of step
-  uint16 yl = sclamp<16>( interpolate_hermite(mu, 0.0, 0.0, int16(y0 >>  0), int16(y1 >>  0), int16(y2 >>  0), int16(y3 >>  0)) );
-  uint16 yr = sclamp<16>( interpolate_hermite(mu, 0.0, 0.0, int16(y0 >> 16), int16(y1 >> 16), int16(y2 >> 16), int16(y3 >> 16)) );
-    output[x] = (yl << 0) + (yr << 16);
-    sindex += scalar;
-  }
-}
-
-*/
-
-//
+#include "audio.h"
 
 void Audio::update_frequency() {
 uint freq  = config::audio.frequency;

src/ui/audio/audio.h

@@ -1,3 +1,6 @@
+#ifndef AUDIO_H
+#define AUDIO_H
+
 class Audio {
 public:
 uint frequency, latency;
@@ -7,14 +10,7 @@ uint frequency, latency;
   virtual void init() {}
   virtual void term() {}
 
-/*
-  uint bind_range(uint min, uint max, uint index);
-  void resample_point  (uint32 *output, uint32 *input, uint output_samples, uint input_samples);
-  void resample_linear (uint32 *output, uint32 *input, uint output_samples, uint input_samples);
-  void resample_cosine (uint32 *output, uint32 *input, uint output_samples, uint input_samples);
-  void resample_cubic  (uint32 *output, uint32 *input, uint output_samples, uint input_samples);
-  void resample_hermite(uint32 *output, uint32 *input, uint output_samples, uint input_samples);
-*/
-
   Audio();
 } *uiAudio;
+
+#endif

src/ui/audio/dsound.cpp

@@ -2,7 +2,7 @@ void AudioDS::sample(uint16 l_sample, uint16 r_sample) {
   data.buffer[data.buffer_pos++] = (l_sample << 0) + (r_sample << 16);
   if(data.buffer_pos < latency)return;
 
-uint32 ring_pos, pos, size;
+DWORD ring_pos, pos, size;
   for(;;) {
     dsb_b->GetCurrentPosition(&pos, 0);
     ring_pos = pos / data.ring_size;
@@ -30,7 +30,7 @@ void *output;
   data.buffer[data.buffer_pos++] = (l_sample << 0) + (r_sample << 16);
 //if(data.buffer_pos & 15)return;
 
-uint32 ring_pos, pos, size;
+DWORD ring_pos, pos, size;
   dsb_b->GetCurrentPosition(&pos, 0);
   ring_pos = pos / data.ring_size;
   if(ring_pos == data.ring_pos)return;
@@ -66,7 +66,7 @@ void AudioDS::clear_audio() {
   dsb_b->Stop();
   dsb_b->SetCurrentPosition(0);
 
-uint32 size;
+DWORD size;
 void  *output;
   dsb_b->Lock(0, data.ring_size * 3, &output, &size, 0, 0, 0);
   memset(output, 0, size);

src/ui/bsnes.rc

@@ -1,5 +1,3 @@
-#define IDI_APP_ICON   100
-#define IDI_CONTROLLER 101
+#define IDI_APP_ICON 100
 
-IDI_APP_ICON   ICON   DISCARDABLE "../data/bsnes.ico"
-IDI_CONTROLLER BITMAP DISCARDABLE "../data/snes_controller.bmp"
+IDI_APP_ICON ICON DISCARDABLE "../data/bsnes.ico"

src/ui/config.cpp

@@ -9,62 +9,88 @@ struct System {
   static IntegerSetting regulate_speed, speed;
   static IntegerSetting speed_slowest, speed_slow, speed_normal, speed_fast, speed_fastest;
 } system;
-StringSetting System::video(&config_file, "system.video", "Video hardware interface", "");
-StringSetting System::audio(&config_file, "system.audio", "Audio hardware interface", "");
-StringSetting System::input(&config_file, "system.input", "Input hardware interface", "");
+StringSetting System::video(&config(), "system.video", "Video hardware interface", "");
+StringSetting System::audio(&config(), "system.audio", "Audio hardware interface", "");
+StringSetting System::input(&config(), "system.input", "Input hardware interface", "");
 
-StringSetting System::video_flags(&config_file, "system.video_flags", "Video hardware interface flags", "");
-StringSetting System::audio_flags(&config_file, "system.audio_flags", "Audio hardware interface flags", "");
-StringSetting System::input_flags(&config_file, "system.input_flags", "Input hardware interface flags", "");
+StringSetting System::video_flags(&config(), "system.video_flags", "Video hardware interface flags", "");
+StringSetting System::audio_flags(&config(), "system.audio_flags", "Audio hardware interface flags", "");
+StringSetting System::input_flags(&config(), "system.input_flags", "Input hardware interface flags", "");
 
-IntegerSetting System::regulate_speed(&config_file, "system.regulate_speed", "Regulate speed to 60hz (NTSC) / 50hz (PAL)", IntegerSetting::Boolean, true);
+IntegerSetting System::regulate_speed(&config(), "system.regulate_speed", "Regulate speed to 60hz (NTSC) / 50hz (PAL)", IntegerSetting::Boolean, true);
 IntegerSetting System::speed         (0,            "system.speed",          "Current speed regulation setting (1-5)", IntegerSetting::Decimal, 3);
-IntegerSetting System::speed_slowest (&config_file, "system.speed_slowest",  "Slowest speed setting", IntegerSetting::Decimal,  50);
-IntegerSetting System::speed_slow    (&config_file, "system.speed_slow",     "Slow speed setting",    IntegerSetting::Decimal,  75);
-IntegerSetting System::speed_normal  (&config_file, "system.speed_normal",   "Normal speed setting",  IntegerSetting::Decimal, 100);
-IntegerSetting System::speed_fast    (&config_file, "system.speed_fast",     "Fast speed setting",    IntegerSetting::Decimal, 150);
-IntegerSetting System::speed_fastest (&config_file, "system.speed_fastest",  "Fastest speed setting", IntegerSetting::Decimal, 200);
+IntegerSetting System::speed_slowest (&config(), "system.speed_slowest",  "Slowest speed setting", IntegerSetting::Decimal,  50);
+IntegerSetting System::speed_slow    (&config(), "system.speed_slow",     "Slow speed setting",    IntegerSetting::Decimal,  75);
+IntegerSetting System::speed_normal  (&config(), "system.speed_normal",   "Normal speed setting",  IntegerSetting::Decimal, 100);
+IntegerSetting System::speed_fast    (&config(), "system.speed_fast",     "Fast speed setting",    IntegerSetting::Decimal, 150);
+IntegerSetting System::speed_fastest (&config(), "system.speed_fastest",  "Fastest speed setting", IntegerSetting::Decimal, 200);
 
 struct Video {
-  static IntegerSetting synchronize;
-  static IntegerSetting fullscreen;
-  static IntegerSetting multiplier, aspect_correction, region;
-  static IntegerSetting hardware_filter, software_filter;
+  static IntegerSetting mode;
+  struct Windowed {
+    static IntegerSetting synchronize, aspect_correction;
+    static IntegerSetting region, multiplier, hardware_filter, software_filter;
+  } windowed;
+  struct Fullscreen {
+    static IntegerSetting synchronize, aspect_correction;
+    static IntegerSetting region, multiplier, hardware_filter, software_filter;
+  } fullscreen;
+  static IntegerSetting aspect_ntsc_x, aspect_ntsc_y, aspect_pal_x, aspect_pal_y;
   static IntegerSetting frameskip;
   static IntegerSetting use_vram;
 } video;
-IntegerSetting Video::synchronize(&config_file, "video.synchronize", "Synchronize to video refresh rate.", IntegerSetting::Boolean, false);
-IntegerSetting Video::fullscreen(0, "video.fullscreen", "", IntegerSetting::Boolean, false);
-IntegerSetting Video::multiplier(&config_file, "video.multiplier", "Video output size multiplier (1-5x)\n"
-  "1 = 1x (~256x224)\n"
-  "2 = 2x (~512x448)\n"
-  "etc.",
-  IntegerSetting::Decimal, 2);
-IntegerSetting Video::aspect_correction(&config_file, "video.aspect_correction", "Correct video aspect ratio", IntegerSetting::Boolean, true);
-IntegerSetting Video::region(&config_file, "video.region", "Video output region\n"
+
+//0 = windowed, 1 = fullscreen, 2 = exclusive
+IntegerSetting Video::mode(0, "video.mode", "Active video mode", IntegerSetting::Decimal, 0);
+
+IntegerSetting Video::Windowed::synchronize(&config(), "video.windowed.synchronize", "Synchronize to video refresh rate", IntegerSetting::Boolean, false);
+IntegerSetting Video::Windowed::aspect_correction(&config(), "video.windowed.aspect_correction",
+  "Correct video aspect ratio\n"
+  "Defaults assume display pixels are perfectly square\n"
+  "Formula: width = width * video.aspect_<region>_x / video.aspect_<region>_y\n",
+  IntegerSetting::Boolean, true);
+IntegerSetting Video::Windowed::region(&config(), "video.windowed.region", "Video output region\n"
   "0 = NTSC, 1 = PAL",
   IntegerSetting::Decimal, 0);
-IntegerSetting Video::hardware_filter(&config_file, "video.hardware_filter", "Video hardware filter\n"
+IntegerSetting Video::Windowed::multiplier(&config(), "video.windowed.multiplier", "Video output size multiplier (1-5x)\n"
+  "1 = 1x (<= 320x240)\n"
+  "2 = 2x (<= 640x480)\n"
+  "etc.",
+  IntegerSetting::Decimal, 2);
+IntegerSetting Video::Windowed::hardware_filter(&config(), "video.windowed.hardware_filter", "Video hardware filter\n"
   "0 = Point\n"
   "1 = Linear\n",
   IntegerSetting::Decimal, 1);
-IntegerSetting Video::software_filter(&config_file, "video.software_filter", "Video software filter\n"
+IntegerSetting Video::Windowed::software_filter(&config(), "video.windowed.software_filter", "Video software filter\n"
   "0 = None\n"
   "1 = NTSC\n"
   "2 = HQ2x\n"
   "3 = Scale2x\n",
   IntegerSetting::Decimal, 0);
+
+IntegerSetting Video::Fullscreen::synchronize      (&config(), "video.fullscreen.synchronize",       "", IntegerSetting::Boolean, false);
+IntegerSetting Video::Fullscreen::aspect_correction(&config(), "video.fullscreen.aspect_correction", "", IntegerSetting::Boolean, true);
+IntegerSetting Video::Fullscreen::region           (&config(), "video.fullscreen.region",            "", IntegerSetting::Decimal, 0);
+IntegerSetting Video::Fullscreen::multiplier       (&config(), "video.fullscreen.multiplier",        "", IntegerSetting::Decimal, 2);
+IntegerSetting Video::Fullscreen::hardware_filter  (&config(), "video.fullscreen.hardware_filter",   "", IntegerSetting::Decimal, 1);
+IntegerSetting Video::Fullscreen::software_filter  (&config(), "video.fullscreen.software_filter",   "", IntegerSetting::Decimal, 0);
+
+IntegerSetting Video::aspect_ntsc_x(&config(), "video.aspect_ntsc_x", "", IntegerSetting::Decimal, 54);
+IntegerSetting Video::aspect_ntsc_y(&config(), "video.aspect_ntsc_y", "", IntegerSetting::Decimal, 47);
+IntegerSetting Video::aspect_pal_x (&config(), "video.aspect_pal_x",  "", IntegerSetting::Decimal, 32);
+IntegerSetting Video::aspect_pal_y (&config(), "video.aspect_pal_y",  "", IntegerSetting::Decimal, 23);
+
 IntegerSetting Video::frameskip(0, "video.frameskip", "Video frameskip", IntegerSetting::Decimal, 0);
-IntegerSetting Video::use_vram(&config_file, "video.use_vram", "Use Video RAM instead of System RAM", IntegerSetting::Boolean, true);
+IntegerSetting Video::use_vram(&config(), "video.use_vram", "Use Video RAM instead of System RAM when possible", IntegerSetting::Boolean, true);
 
 struct Audio {
   static IntegerSetting synchronize;
   static IntegerSetting frequency;
   static IntegerSetting latency;
 } audio;
-IntegerSetting Audio::synchronize(&config_file, "audio.synchronize", "Synchronize to audio sample rate.", IntegerSetting::Boolean, true);
-IntegerSetting Audio::frequency(&config_file, "audio.frequency", "Default audio playback frequency.", IntegerSetting::Decimal, 32000);
-IntegerSetting Audio::latency(&config_file, "audio.latency", "Audio playback latency in milliseconds.\n"
+IntegerSetting Audio::synchronize(&config(), "audio.synchronize", "Synchronize to audio sample rate.", IntegerSetting::Boolean, true);
+IntegerSetting Audio::frequency(&config(), "audio.frequency", "Default audio playback frequency.", IntegerSetting::Decimal, 32000);
+IntegerSetting Audio::latency(&config(), "audio.latency", "Audio playback latency in milliseconds.\n"
   "Specifies how long audio playback is delayed compared to a real SNES.\n"
   "A delay is necessary to allow smooth audio playback via buffering.\n"
   "Raising this value may help with audio playback problems, but will decrease\n"
@@ -84,7 +110,7 @@ struct Input {
   } joypad2;
 } input;
 
-IntegerSetting Input::axis_resistance(&config_file, "input.axis_resistance",
+IntegerSetting Input::axis_resistance(&config(), "input.axis_resistance",
   "Axis resistance for all analog joypads\n"
   "Affects responsiveness of analog stick movement by specifying what percentage\n"
   "in any given direction the axis must be pressed to trigger a button press.\n"
@@ -96,40 +122,40 @@ IntegerSetting Input::axis_resistance(&config_file, "input.axis_resistance",
   "Note: Values below 10 or above 90 are not recommended and may not work at all.",
   IntegerSetting::Decimal, 75);
 
-IntegerSetting Input::allow_invalid_input(&config_file, "input.allow_invalid_input",
+IntegerSetting Input::allow_invalid_input(&config(), "input.allow_invalid_input",
   "Allow up+down and left+right combinations (not recommended)",
   IntegerSetting::Boolean, false);
 
-StringSetting Input::Joypad1::up    (&config_file, "input.joypad1.up",     "", "up");
-StringSetting Input::Joypad1::down  (&config_file, "input.joypad1.down",   "", "down");
-StringSetting Input::Joypad1::left  (&config_file, "input.joypad1.left",   "", "left");
-StringSetting Input::Joypad1::right (&config_file, "input.joypad1.right",  "", "right");
-StringSetting Input::Joypad1::a     (&config_file, "input.joypad1.a",      "", "x");
-StringSetting Input::Joypad1::b     (&config_file, "input.joypad1.b",      "", "z");
-StringSetting Input::Joypad1::x     (&config_file, "input.joypad1.x",      "", "s");
-StringSetting Input::Joypad1::y     (&config_file, "input.joypad1.y",      "", "a");
-StringSetting Input::Joypad1::l     (&config_file, "input.joypad1.l",      "", "d");
-StringSetting Input::Joypad1::r     (&config_file, "input.joypad1.r",      "", "c");
-StringSetting Input::Joypad1::select(&config_file, "input.joypad1.select", "", "rshift");
-StringSetting Input::Joypad1::start (&config_file, "input.joypad1.start",  "", "enter");
+StringSetting Input::Joypad1::up    (&config(), "input.joypad1.up",     "", "up");
+StringSetting Input::Joypad1::down  (&config(), "input.joypad1.down",   "", "down");
+StringSetting Input::Joypad1::left  (&config(), "input.joypad1.left",   "", "left");
+StringSetting Input::Joypad1::right (&config(), "input.joypad1.right",  "", "right");
+StringSetting Input::Joypad1::a     (&config(), "input.joypad1.a",      "", "x");
+StringSetting Input::Joypad1::b     (&config(), "input.joypad1.b",      "", "z");
+StringSetting Input::Joypad1::x     (&config(), "input.joypad1.x",      "", "s");
+StringSetting Input::Joypad1::y     (&config(), "input.joypad1.y",      "", "a");
+StringSetting Input::Joypad1::l     (&config(), "input.joypad1.l",      "", "d");
+StringSetting Input::Joypad1::r     (&config(), "input.joypad1.r",      "", "c");
+StringSetting Input::Joypad1::select(&config(), "input.joypad1.select", "", "rshift");
+StringSetting Input::Joypad1::start (&config(), "input.joypad1.start",  "", "enter");
 
-StringSetting Input::Joypad2::up    (&config_file, "input.joypad2.up",     "", "t");
-StringSetting Input::Joypad2::down  (&config_file, "input.joypad2.down",   "", "g");
-StringSetting Input::Joypad2::left  (&config_file, "input.joypad2.left",   "", "f");
-StringSetting Input::Joypad2::right (&config_file, "input.joypad2.right",  "", "h");
-StringSetting Input::Joypad2::a     (&config_file, "input.joypad2.a",      "", "k");
-StringSetting Input::Joypad2::b     (&config_file, "input.joypad2.b",      "", "j");
-StringSetting Input::Joypad2::x     (&config_file, "input.joypad2.x",      "", "i");
-StringSetting Input::Joypad2::y     (&config_file, "input.joypad2.y",      "", "u");
-StringSetting Input::Joypad2::l     (&config_file, "input.joypad2.l",      "", "o");
-StringSetting Input::Joypad2::r     (&config_file, "input.joypad2.r",      "", "l");
-StringSetting Input::Joypad2::select(&config_file, "input.joypad2.select", "", "lbracket");
-StringSetting Input::Joypad2::start (&config_file, "input.joypad2.start",  "", "rbracket");
+StringSetting Input::Joypad2::up    (&config(), "input.joypad2.up",     "", "t");
+StringSetting Input::Joypad2::down  (&config(), "input.joypad2.down",   "", "g");
+StringSetting Input::Joypad2::left  (&config(), "input.joypad2.left",   "", "f");
+StringSetting Input::Joypad2::right (&config(), "input.joypad2.right",  "", "h");
+StringSetting Input::Joypad2::a     (&config(), "input.joypad2.a",      "", "k");
+StringSetting Input::Joypad2::b     (&config(), "input.joypad2.b",      "", "j");
+StringSetting Input::Joypad2::x     (&config(), "input.joypad2.x",      "", "i");
+StringSetting Input::Joypad2::y     (&config(), "input.joypad2.y",      "", "u");
+StringSetting Input::Joypad2::l     (&config(), "input.joypad2.l",      "", "o");
+StringSetting Input::Joypad2::r     (&config(), "input.joypad2.r",      "", "l");
+StringSetting Input::Joypad2::select(&config(), "input.joypad2.select", "", "lbracket");
+StringSetting Input::Joypad2::start (&config(), "input.joypad2.start",  "", "rbracket");
 
 struct Misc {
   static IntegerSetting show_frame_counter;
 } misc;
 
-IntegerSetting Misc::show_frame_counter(&config_file, "misc.show_frame_counter", "Display frame counter", IntegerSetting::Boolean, true);
+IntegerSetting Misc::show_frame_counter(&config(), "misc.show_frame_counter", "Display frame counter", IntegerSetting::Boolean, true);
 
 };

src/ui/input/dinput.cpp

@@ -1,10 +1,14 @@
 #include "dinput.h"
 
+void InputDI::clear_input() {
+  memset(keystate, 0, sizeof keystate);
+}
+
 void InputDI::poll() {
+  clear_input();
+
 HRESULT hr;
 DIJOYSTATE2 js;
-  memset(keystate, 0, sizeof(keystate));
-
   if(di_key) {
     hr = di_key->GetDeviceState(256, keystate);
     if(FAILED(hr)) {

src/ui/input/dinput.h

@@ -15,6 +15,7 @@ LPDIRECTINPUT8 di;
 LPDIRECTINPUTDEVICE8 di_key, di_joy[DIRECTINPUT_JOYMAX];
 uint32 di_joy_count;
 
+  void clear_input();
   void poll();
   void init();
   void term();

src/ui/input/input.cpp

@@ -0,0 +1 @@
+#include "input.h"

src/ui/input/input.h

@@ -5,9 +5,6 @@ class Input { public:
   virtual bool key_down(uint16 key) { return false; }
   virtual bool key_up  (uint16 key) { return !key_down(key); }
 
-  virtual void signal_key_down(uint16 key) {}
-  virtual void signal_key_up  (uint16 key) {}
-
   virtual void clear_input() {}
   virtual void poll() {}
   virtual void init() {}

src/ui/input/inputui.cpp

@@ -1 +0,0 @@
-#include "inputui.h"

src/ui/input/inputui.h

@@ -1,28 +0,0 @@
-/*****
- * InputUI
- *
- * Input wrapper to capture UI key presses. Useful for when OS does not
- * support direct input polling methods (eg Xorg, etc)
- *****/
-
-#ifndef INPUTUI_H
-#define INPUTUI_H
-
-class InputUI : public Input {
-private:
-bool keystate[65536];
-
-public:
-  void init() {
-    Input::init();
-    memset(keystate, 0, sizeof(keystate));
-  }
-
-  bool key_down(uint16 key) { return keystate[key]; }
-  void signal_key_down(uint16 key) { keystate[key] = true;  }
-  void signal_key_up  (uint16 key) { keystate[key] = false; }
-
-  void clear_input() { memset(keystate, 0, sizeof(keystate)); }
-};
-
-#endif

src/ui/input/xinput.cpp

@@ -0,0 +1,143 @@
+#include "xinput.h"
+
+bool InputX::key_down(uint16 key) {
+#define map(i) (keymap[i >> 3] & (1 << (i & 7)))
+  switch(key) {
+  case keymap::esc: return map(0x09);
+
+  case keymap::f1:  return map(0x43);
+  case keymap::f2:  return map(0x44);
+  case keymap::f3:  return map(0x45);
+  case keymap::f4:  return map(0x46);
+  case keymap::f5:  return map(0x47);
+  case keymap::f6:  return map(0x48);
+  case keymap::f7:  return map(0x49);
+  case keymap::f8:  return map(0x4a);
+  case keymap::f9:  return map(0x4b);
+  case keymap::f10: return map(0x4c);
+  case keymap::f11: return map(0x5f);
+  case keymap::f12: return map(0x60);
+
+  case keymap::print_screen: return map(0x6f);
+  case keymap::scroll_lock:  return map(0x4e);
+  case keymap::pause:        return map(0x6e);
+
+  case keymap::grave: return map(0x31);
+
+  case keymap::num_1: return map(0x0a);
+  case keymap::num_2: return map(0x0b);
+  case keymap::num_3: return map(0x0c);
+  case keymap::num_4: return map(0x0d);
+  case keymap::num_5: return map(0x0e);
+  case keymap::num_6: return map(0x0f);
+  case keymap::num_7: return map(0x10);
+  case keymap::num_8: return map(0x11);
+  case keymap::num_9: return map(0x12);
+  case keymap::num_0: return map(0x13);
+
+  case keymap::minus:     return map(0x14);
+  case keymap::equal:     return map(0x15);
+  case keymap::backspace: return map(0x16);
+
+  case keymap::ins:       return map(0x6a);
+  case keymap::del:       return map(0x6b);
+  case keymap::home:      return map(0x61);
+  case keymap::end:       return map(0x67);
+  case keymap::page_up:   return map(0x63);
+  case keymap::page_down: return map(0x69);
+
+  case keymap::a: return map(0x26);
+  case keymap::b: return map(0x38);
+  case keymap::c: return map(0x36);
+  case keymap::d: return map(0x28);
+  case keymap::e: return map(0x1a);
+  case keymap::f: return map(0x29);
+  case keymap::g: return map(0x2a);
+  case keymap::h: return map(0x2b);
+  case keymap::i: return map(0x1f);
+  case keymap::j: return map(0x2c);
+  case keymap::k: return map(0x2d);
+  case keymap::l: return map(0x2e);
+  case keymap::m: return map(0x3a);
+  case keymap::n: return map(0x39);
+  case keymap::o: return map(0x20);
+  case keymap::p: return map(0x21);
+  case keymap::q: return map(0x18);
+  case keymap::r: return map(0x1b);
+  case keymap::s: return map(0x27);
+  case keymap::t: return map(0x1c);
+  case keymap::u: return map(0x1e);
+  case keymap::v: return map(0x37);
+  case keymap::w: return map(0x19);
+  case keymap::x: return map(0x35);
+  case keymap::y: return map(0x1d);
+  case keymap::z: return map(0x34);
+
+  case keymap::lbracket:   return map(0x22);
+  case keymap::rbracket:   return map(0x23);
+  case keymap::backslash:  return map(0x33);
+  case keymap::semicolon:  return map(0x2f);
+  case keymap::apostrophe: return map(0x30);
+  case keymap::comma:      return map(0x3b);
+  case keymap::period:     return map(0x3c);
+  case keymap::slash:      return map(0x3d);
+
+  case keymap::kp_1: return map(0x57);
+  case keymap::kp_2: return map(0x58);
+  case keymap::kp_3: return map(0x59);
+  case keymap::kp_4: return map(0x53);
+  case keymap::kp_5: return map(0x54);
+  case keymap::kp_6: return map(0x55);
+  case keymap::kp_7: return map(0x4f);
+  case keymap::kp_8: return map(0x50);
+  case keymap::kp_9: return map(0x51);
+
+  case keymap::kp_plus:  return map(0x56);
+  case keymap::kp_minus: return map(0x52);
+  case keymap::kp_mul:   return map(0x3f);
+  case keymap::kp_div:   return map(0x70);
+  case keymap::kp_enter: return map(0x6c);
+
+  case keymap::num_lock:  return map(0x4d);
+  case keymap::caps_lock: return map(0x42);
+
+  case keymap::up:    return map(0x62);
+  case keymap::down:  return map(0x68);
+  case keymap::left:  return map(0x64);
+  case keymap::right: return map(0x66);
+
+  case keymap::tab:   return map(0x17);
+  case keymap::enter: return map(0x24);
+  case keymap::space: return map(0x41);
+
+  case keymap::lctrl:  return map(0x25);
+  case keymap::rctrl:  return map(0x6d);
+  case keymap::lalt:   return map(0x40);
+  case keymap::ralt:   return map(0x71);
+  case keymap::lshift: return map(0x32);
+  case keymap::rshift: return map(0x3e);
+  case keymap::lsuper: return map(0x73);
+  case keymap::rsuper: return map(0x74);
+  case keymap::menu:   return map(0x75);
+  }
+#undef map
+
+  return false;
+}
+
+void InputX::clear_input() {
+  memset(keymap, 0, sizeof keymap);
+}
+
+void InputX::poll() {
+  XQueryKeymap(display, keymap);
+}
+
+void InputX::init() {
+  Input::init();
+  display = XOpenDisplay(0);
+}
+
+void InputX::term() {
+  Input::term();
+}