Missing stuff.

Conflicts:
	Makefile.xenon

.gitignore

@@ -1,4 +1,6 @@
 *.o
+*.so
+*.dll
 ssnes
 /config.h
 /config.mk

AUTHORS

@@ -3,3 +3,10 @@ Hans-Kristian Arntzen - <[email protected]>
 
 Devin J. Pohly - <[email protected]>
    - Joypad axis support
+
+Chris Moeller - <[email protected]> 
+   - CoreAudio audio driver
+
+Daniel De Matteis - <[email protected]>
+   - PlayStation 3 port
+

Makefile

@@ -2,25 +2,34 @@ include config.mk
 
 TARGET = ssnes tools/ssnes-joyconfig
 
-OBJ = ssnes.o file.o driver.o settings.o dynamic.o message.o rewind.o movie.o autosave.o gfx/gfx_common.o ups.o
-JOYCONFIG_OBJ = tools/ssnes-joyconfig.o conf/config_file.o
+OBJ = ssnes.o file.o driver.o settings.o dynamic.o message.o rewind.o movie.o gfx/gfx_common.o ups.o bps.o strl.o getopt.o screenshot.o audio/hermite.o audio/utils.o
+JOYCONFIG_OBJ = tools/ssnes-joyconfig.o conf/config_file.o strl.o
 HEADERS = $(wildcard */*.h) $(wildcard *.h)
 
 LIBS = -lm
 DEFINES = -DHAVE_CONFIG_H
 
-ifneq ($(findstring Darwin,$(shell uname -a)),)
+ifneq ($(findstring Darwin,$(OS)),)
    OSX := 1
    LIBS += -framework AppKit
 else
    OSX := 0
 endif
 
-ifeq ($(HAVE_SRC), 1)
-   LIBS += $(SRC_LIBS)
-   DEFINES += $(SRC_CFLAGS)
-else
-   OBJ += audio/hermite.o
+BSD_LOCAL_INC =
+DYLIB_LIB = -ldl
+ifneq ($(findstring BSD,$(OS)),)
+   BSD_LOCAL_INC = -I/usr/local/include
+   DYLIB_LIB = -lc
+endif
+
+ifneq ($(findstring Linux,$(OS)),)
+   LIBS += -lrt
+endif
+
+ifeq ($(HAVE_THREADS), 1)
+   OBJ += autosave.o thread.o
+   LIBS += -lpthread
 endif
 
 ifeq ($(HAVE_CONFIGFILE), 1)
@@ -33,19 +42,29 @@ endif
 
 ifeq ($(HAVE_RSOUND), 1)
    OBJ += audio/rsound.o
-   LIBS += -lrsound
+   LIBS += $(RSOUND_LIBS)
+   DEFINES += $(RSOUND_CFLAGS)
 endif
 
 ifeq ($(HAVE_OSS), 1)
    OBJ += audio/oss.o
 endif
+ifeq ($(HAVE_OSS_BSD), 1)
+   OBJ += audio/oss.o
+endif
+ifeq ($(HAVE_OSS_LIB), 1)
+   LIBS += -lossaudio
+endif
+
 ifeq ($(HAVE_ALSA), 1)
    OBJ += audio/alsa.o
-   LIBS += -lasound
+   LIBS += $(ALSA_LIBS)
+   DEFINES += $(ALSA_CFLAGS)
 endif
 ifeq ($(HAVE_ROAR), 1)
    OBJ += audio/roar.o
-   LIBS += -lroar
+   LIBS += $(ROAR_LIBS)
+   DEFINES += $(ROAR_CFLAGS)
 endif
 ifeq ($(HAVE_AL), 1)
    OBJ += audio/openal.o
@@ -66,24 +85,30 @@ ifeq ($(HAVE_PULSE), 1)
    DEFINES += $(PULSE_CFLAGS)
 endif
 
-ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
-   DEFINES += $(SDL_CFLAGS)
-   LIBS += $(SDL_LIBS)
-ifeq ($(OSX),1)
-   LIBS += -framework OpenGL
-else
-   LIBS += -lGL
-endif
+ifeq ($(HAVE_COREAUDIO), 1)
+   OBJ += audio/coreaudio.o
+   LIBS += -framework CoreServices -framework CoreAudio -framework AudioUnit
 endif
 
-ifeq ($(HAVE_FBO), 1)
-   DEFINES += -DHAVE_FBO
+ifeq ($(HAVE_SDL), 1)
+   OBJ += gfx/sdl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
+   DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
+   LIBS += $(SDL_LIBS)
+
+ifeq ($(HAVE_OPENGL), 1)
+	OBJ += gfx/gl.o 
+ifeq ($(OSX),1)
+	LIBS += -framework OpenGL
+else
+	LIBS += -lGL
+endif
+endif
 endif
 
 ifeq ($(HAVE_XVIDEO), 1)
    OBJ += gfx/xvideo.o input/x11_input.o
-   LIBS += -lXv -lX11
+   LIBS += $(XVIDEO_LIBS) $(X11_LIBS) $(XEXT_LIBS)
+   DEFINES += $(XVIDEO_CFLAGS) $(X11_CFLAGS) $(XEXT_CFLAGS)
 endif
 
 ifeq ($(HAVE_CG), 1)
@@ -92,13 +117,24 @@ ifeq ($(HAVE_CG), 1)
 endif
 
 ifeq ($(HAVE_XML), 1)
-   OBJ += gfx/shader_glsl.o
+   OBJ += sha256.o cheats.o 
    LIBS += $(XML_LIBS)
    DEFINES += $(XML_CFLAGS)
+
+ifeq ($(HAVE_OPENGL), 1)
+   OBJ += gfx/shader_glsl.o 
+endif
 endif
 
-ifeq ($(HAVE_FILTER), 1)
-   LIBS += -ldl
+ifeq ($(HAVE_XML), 1)
+   OBJ += gfx/snes_state.o gfx/image.o 
+else ifeq ($(HAVE_CG), 1)
+   OBJ += gfx/snes_state.o gfx/image.o 
+endif
+
+ifeq ($(HAVE_DYLIB), 1)
+   OBJ += gfx/ext.o audio/ext.o
+   LIBS += $(DYLIB_LIB)
 endif
 
 ifeq ($(HAVE_FREETYPE), 1)
@@ -107,25 +143,41 @@ ifeq ($(HAVE_FREETYPE), 1)
    DEFINES += $(FREETYPE_CFLAGS)
 endif
 
+ifeq ($(HAVE_SDL_IMAGE), 1)
+   LIBS += $(SDL_IMAGE_LIBS)
+   DEFINES += $(SDL_IMAGE_CFLAGS)
+endif
+
 ifeq ($(HAVE_FFMPEG), 1)
    OBJ += record/ffemu.o
-   LIBS += $(AVCODEC_LIBS) $(AVCORE_LIBS) $(AVFORMAT_LIBS) $(AVUTIL_LIBS) $(SWSCALE_LIBS)
-   DEFINES += $(AVCODEC_CFLAGS) $(AVCORE_CFLAGS) $(AVFORMAT_CFLAGS) $(AVUTIL_CFLAGS) $(SWSCALE_CFLAGS)
+   LIBS += $(AVCODEC_LIBS) $(AVFORMAT_LIBS) $(AVUTIL_LIBS) $(SWSCALE_LIBS)
+   DEFINES += $(AVCODEC_CFLAGS) $(AVFORMAT_CFLAGS) $(AVUTIL_CFLAGS) $(SWSCALE_CFLAGS)
 endif
 
 ifeq ($(HAVE_DYNAMIC), 1)
-   LIBS += -ldl
+   LIBS += $(DYLIB_LIB)
 else
    LIBS += $(libsnes)
 endif
 
+ifeq ($(HAVE_PYTHON), 1)
+   DEFINES += $(PYTHON_CFLAGS) -Wno-unused-parameter
+   LIBS += $(PYTHON_LIBS)
+   OBJ += gfx/py_state/py_state.o
+endif
+
 ifneq ($(V),1)
    Q := @
 endif
 
-CFLAGS += -Wall -O3 -g -I.
+OPTIMIZE_FLAG = -O3
+ifeq ($(DEBUG), 1)
+   OPTIMIZE_FLAG = -O0
+endif
+
+CFLAGS += -Wall $(OPTIMIZE_FLAG) -g -I. -pedantic
 ifneq ($(findstring icc,$(CC)),)
-   CFLAGS += -std=c99
+   CFLAGS += -std=c99 -D_GNU_SOURCE
 else
    CFLAGS += -std=gnu99
 endif
@@ -137,11 +189,11 @@ config.mk: configure qb/*
 	@exit 1
 
 ssnes: $(OBJ)
-	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS)
+	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
 	@$(if $(Q), $(shell echo echo LD $@),)
 
 tools/ssnes-joyconfig: $(JOYCONFIG_OBJ)
-	$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS)
+	$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
 	@$(if $(Q), $(shell echo echo LD $@),)
 
 %.o: %.c config.h config.mk $(HEADERS)
@@ -149,9 +201,9 @@ tools/ssnes-joyconfig: $(JOYCONFIG_OBJ)
 	@$(if $(Q), $(shell echo echo CC $<),)
 
 install: $(TARGET)
-	mkdir -p $(DESTDIR)$(PREFIX)/bin
-	mkdir -p $(DESTDIR)/etc
-	mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1
+	mkdir -p $(DESTDIR)$(PREFIX)/bin 2>/dev/null || /bin/true
+	mkdir -p $(DESTDIR)/etc 2>/dev/null || /bin/true
+	mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1 2>/dev/null || /bin/true
 	install -m755 $(TARGET) $(DESTDIR)$(PREFIX)/bin 
 	install -m644 ssnes.cfg $(DESTDIR)/etc/ssnes.cfg
 	install -m644 docs/ssnes.1 $(DESTDIR)$(PREFIX)/share/man/man1
@@ -159,18 +211,20 @@ install: $(TARGET)
 	install -m755 ssnes-zip $(DESTDIR)$(PREFIX)/bin
 
 uninstall:
-	rm -f $(DESTDIR)$(PREFIX)/bin/{ssnes,ssnes-joyconfig,ssnes-zip}
+	rm -f $(DESTDIR)$(PREFIX)/bin/ssnes
+	rm -f $(DESTDIR)$(PREFIX)/bin/ssnes-joyconfig
+	rm -f $(DESTDIR)$(PREFIX)/bin/ssnes-zip
 	rm -f $(DESTDIR)/etc/ssnes.cfg
-	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/{ssnes,ssnes-joyconfig}.1
+	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/ssnes.1
+	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/ssnes-joyconfig.1
 
 clean:
 	rm -f *.o 
 	rm -f audio/*.o
 	rm -f conf/*.o
 	rm -f gfx/*.o
+	rm -f gfx/py_state/*.o
 	rm -f record/*.o
-	rm -f hqflt/*.o
-	rm -f hqflt/snes_ntsc/*.o
 	rm -f input/*.o
 	rm -f tools/*.o
 	rm -f $(TARGET)

Makefile.ps3

@@ -0,0 +1,84 @@
+###
+##
+# Makefile for SSNES PS3. Somewhat generic and avoids using the odd SDK examples.
+##
+###
+##
+DEBUG = 0
+CELL_BUILD_TOOLS = GCC
+
+## Platform detection from nall/Makefile. Only two applicable hosts for PS3 SDK.
+ifeq ($(platform),)
+  uname := $(shell uname -a)
+ifeq ($(uname),)
+    platform := win
+else
+    platform := linux
+endif
+endif
+
+CELL_SDK := /usr/local/cell
+ifeq ($(platform),win)
+   HOST_DIR := host-win32
+else
+   HOST_DIR := host-linux
+endif
+
+ifeq ($(CELL_BUILD_TOOLS),SNC)
+CC = $(CELL_SDK)/sn/ps3ppusnc
+CXX = $(CC)
+LD = $(CELL_SDK)/sn/ps3ppuld
+else
+CC = $(CELL_SDK)/$(HOST_DIR)/ppu/bin/ppu-lv2-gcc
+CXX = $(CELL_SDK)/$(HOST_DIR)/ppu/bin/ppu-lv2-g++
+LD = $(CELL_SDK)/$(HOST_DIR)/ppu/bin/ppu-lv2-g++
+endif
+STRIP = $(CELL_SDK)/$(HOST_DIR)/ppu/bin/ppu-lv2-strip
+
+PPU_TARGET := ssnes.elf
+
+LDDIRS = -L. -L$(CELL_SDK)/target/ppu/lib/PSGL/RSX/ultra-opt
+INCDIRS = -I. -Icommon
+
+MAKE_FSELF_NPDRM = $(CELL_SDK)/$(HOST_DIR)/bin/make_fself_npdrm
+MAKE_PACKAGE_NPDRM = $(CELL_SDK)/$(HOST_DIR)/bin/make_package_npdrm
+
+OBJ = fifo_buffer.o ps3/ps3_audio.o ps3/ps3_input.o ps3/pad_input.o getopt.o ssnes.o driver.o file.o settings.o message.o rewind.o movie.o gfx/gfx_common.o ps3/ps3_video_psgl.o gfx/shader_cg.o gfx/snes_state.o ups.o bps.o strl.o screenshot.o audio/hermite.o dynamic.o ps3/main.o audio/utils.o conf/config_file.o gfx/image.o
+
+LIBS = -ldbgfont -lPSGL -lPSGLcgc -lcgc -lgcm_cmd -lgcm_sys_stub -lsnes -lresc_stub -lm -lio_stub -lfs_stub -lsysutil_stub -lsysmodule_stub -laudio_stub -lnet_stub -lpthread
+
+DEFINES = -DHAVE_OPENGL=1 -DHAVE_CG=1 -DHAVE_FBO=1 -D__CELLOS_LV2__ -DHAVE_CONFIGFILE=1 -DPACKAGE_VERSION=\"0.9.3\" -Dmain=ssnes_main
+
+ifeq ($(DEBUG), 1)
+   PPU_OPTIMIZE_LV	:= -O0 -g
+else
+   PPU_OPTIMIZE_LV	:= -O3
+endif
+
+## Use this for new SDK!
+CFLAGS = $(PPU_OPTIMIZE_LV) $(DEFINES)
+CXXFLAGS = $(PPU_OPTIMIZE_LV) $(DEFINES)
+
+all: pkg
+
+$(PPU_TARGET): $(OBJ)
+	$(LD) -o $@ $(OBJ) $(LDFLAGS) $(LDDIRS) $(LIBS)
+	$(STRIP) $(PPU_TARGET)
+
+%.o: %.c config.h
+	$(CC) $(INCDIRS) $(CFLAGS) -c -o $@ $<
+
+%.o: %.cpp config.h
+	$(CXX) $(INCDIRS) $(CXXFLAGS) -c -o $@ $<
+
+pkg: $(PPU_TARGET)
+	$(MAKE_FSELF_NPDRM) $(PPU_TARGET) ps3/pkg/USRDIR/EBOOT.BIN
+	$(MAKE_PACKAGE_NPDRM) ps3/pkg/package.conf ps3/pkg
+
+clean:
+	rm -f $(PPU_TARGET)
+	rm -f $(OBJ)
+	rm -f *.pkg
+
+.PHONY: all clean pkg
+

Makefile.win

@@ -0,0 +1,199 @@
+TARGET = ssnes.exe
+JTARGET = ssnes-joyconfig.exe
+OBJ = ssnes.o file.o driver.o conf/config_file.o settings.o dynamic.o message.o rewind.o movie.o gfx/gfx_common.o bps.o ups.o strl.o screenshot.o audio/hermite.o getopt.o audio/utils.o
+JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o strl.o
+
+CC = gcc
+CXX = g++
+
+HAVE_DINPUT = 1
+HAVE_XAUDIO = 1
+HAVE_DSOUND = 1
+HAVE_SDL = 1
+HAVE_OPENGL = 1
+HAVE_DYLIB = 1
+HAVE_NETPLAY = 1
+HAVE_THREADS = 1
+DYNAMIC = 1
+
+ifeq ($(SLIM),)
+   HAVE_SDL_IMAGE = 1
+   HAVE_XML = 1
+   HAVE_FREETYPE = 1
+   HAVE_RSOUND = 1
+   HAVE_FBO = 1
+   HAVE_CG = 1
+   HAVE_PYTHON = 1
+   HAVE_FFMPEG = 1
+endif
+
+libsnes ?= -lsnes
+
+LIBS = -lm -lshlwapi
+DEFINES = -I. -DHAVE_CONFIGFILE -DPACKAGE_VERSION=\"0.9.3\"
+LDFLAGS = -L. -static-libgcc
+LDCXXFLAGS = -static-libstdc++ -s
+
+ifeq ($(HAVE_SDL), 1)
+   OBJ += gfx/sdl.o gfx/gl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
+   LIBS += -lSDL
+   DEFINES += -ISDL -DHAVE_SDL
+endif
+
+ifeq ($(HAVE_THREADS), 1)
+   OBJ += autosave.o thread.o
+   DEFINES += -DHAVE_THREADS
+endif
+
+ifeq ($(HAVE_OPENGL), 1)
+   DEFINES += -DHAVE_OPENGL
+   LIBS += -lopengl32
+endif
+
+ifeq ($(HAVE_SDL_IMAGE), 1)
+   LIBS += -lSDL_image
+   DEFINES += -DHAVE_SDL_IMAGE
+endif
+
+ifeq ($(HAVE_CG), 1)
+   OBJ += gfx/shader_cg.o
+   LIBS += -lcg -lcgGL
+   DEFINES += -DHAVE_CG
+endif
+
+ifeq ($(HAVE_XAUDIO), 1)
+   OBJ += audio/xaudio.o audio/xaudio-c/xaudio-c.o
+   DEFINES += -DHAVE_XAUDIO
+   LIBS += -lole32
+endif
+
+ifeq ($(HAVE_DSOUND), 1)
+   OBJ += audio/dsound.o
+   DEFINES += -DHAVE_DSOUND
+   LIBS += -ldxguid -ldsound
+endif
+
+ifeq ($(HAVE_RSOUND), 1)
+   OBJ += audio/rsound.o
+   DEFINES += -DHAVE_RSOUND
+   LIBS += -lrsound
+endif
+
+ifeq ($(HAVE_XML), 1)
+   OBJ += gfx/shader_glsl.o gfx/image.o gfx/snes_state.o sha256.o cheats.o
+   DEFINES += -Ilibxml2 -DHAVE_XML
+   LIBS += -lxml2 -liconv
+endif
+
+ifeq ($(HAVE_DYLIB), 1)
+   DEFINES += -DHAVE_DYLIB
+endif
+
+ifeq ($(HAVE_NETPLAY), 1)
+   DEFINES += -DHAVE_NETPLAY
+   OBJ += netplay.o
+   LIBS += -lws2_32
+endif
+
+ifeq ($(HAVE_FREETYPE), 1)
+   OBJ += gfx/fonts.o
+   DEFINES += -DHAVE_FREETYPE -Ifreetype2
+   LIBS += -lfreetype -lz
+endif
+
+ifeq ($(DYNAMIC), 1)
+   DEFINES += -DHAVE_DYNAMIC
+else
+   LIBS += $(libsnes)
+endif
+
+ifeq ($(HAVE_FBO), 1)
+   DEFINES += -DHAVE_FBO
+endif
+
+ifeq ($(HAVE_DYLIB), 1)
+   OBJ += gfx/ext.o audio/ext.o
+endif
+
+ifeq ($(HAVE_PYTHON), 1)
+   LIBS += -lpython32
+   DEFINES += -DHAVE_PYTHON -Ipython
+   OBJ += gfx/py_state/py_state.o
+endif
+
+ifeq ($(HAVE_DINPUT), 1)
+   LIBS += -ldinput8 -ldxguid -lole32
+   DEFINES += -DHAVE_DINPUT
+   OBJ += input/dinput.o
+endif
+
+ifeq ($(HAVE_FFMPEG), 1)
+   LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lz
+   DEFINES += -DHAVE_FFMPEG -Iffmpeg
+   DEFINES += -DHAVE_FFMPEG_ALLOC_CONTEXT3
+   DEFINES += -DHAVE_FFMPEG_AVCODEC_OPEN2
+   DEFINES += -DHAVE_FFMPEG_AVIO_OPEN
+   DEFINES += -DHAVE_FFMPEG_AVFORMAT_WRITE_HEADER
+   DEFINES += -DHAVE_FFMPEG_AVFORMAT_NEW_STREAM
+   DEFINES += -DHAVE_X264RGB
+   OBJ += record/ffemu.o
+endif
+
+ifneq ($(V),1)
+   Q := @
+endif
+
+CFLAGS += -Wall -O3 -std=gnu99 -I.
+CXXFLAGS += -Wall -O3 -pedantic -I.
+
+all: $(TARGET) $(JTARGET)
+
+$(TARGET): $(OBJ)
+	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS) $(LDCXXFLAGS)
+	@$(if $(Q), $(shell echo echo LD $@),)
+
+%.o: %.c
+	$(Q)$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+	@$(if $(Q), $(shell echo echo CC $<),)
+
+%.o: %.cpp
+	$(Q)$(CXX) $(CXXFLAGS) $(DEFINES) -c -o $@ $<
+	@$(if $(Q), $(shell echo echo CXX $<),)
+
+
+$(JTARGET): $(JOBJ)
+	$(Q)$(CC) -o $@ $(JOBJ) -lSDL $(LDFLAGS)
+	@$(if $(Q), $(shell echo echo LD $@),)
+
+clean:
+	rm -f *.o 
+	rm -f audio/*.o
+	rm -f audio/xaudio-c/*.o
+	rm -f conf/*.o
+	rm -f gfx/*.o
+	rm -f gfx/py_state/*.o
+	rm -f record/*.o
+	rm -f input/*.o
+	rm -f $(TARGET)
+	rm -f ssnes-joyconfig.exe
+	rm -f tools/*.o
+
+dist_x86: all
+	zip -r ssnes-win32-0.9.3.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+
+dist_x86_64: all
+	zip -r ssnes-win64-0.9.3.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+
+libs_x86:
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-libs.zip --no-check-certificate
+	unzip SSNES-win32-libs.zip
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-headers.zip --no-check-certificate
+	unzip SSNES-win32-headers.zip
+
+libs_x86_64:
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win64-libs.zip --no-check-certificate
+	unzip SSNES-win64-libs.zip
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win64-headers.zip --no-check-certificate
+	unzip SSNES-win64-headers.zip
+
+.PHONY: all install uninstall clean dist_x86 dist_x86_64 libs_x86 libs_x86_64

Makefile.win32

@@ -1,125 +0,0 @@
-TARGET = ssnes.exe
-JTARGET = ssnes-joyconfig.exe
-OBJ = ssnes.o file.o driver.o conf/config_file.o settings.o dynamic.o message.o rewind.o movie.o autosave.o gfx/gfx_common.o ups.o
-JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o
-
-CC = gcc
-CXX = g++
-
-HAVE_SRC = 0
-HAVE_SDL = 1
-HAVE_XML = 1
-HAVE_FREETYPE = 1
-HAVE_XAUDIO = 1
-HAVE_RSOUND = 1
-HAVE_FILTER = 1
-HAVE_NETPLAY = 1
-HAVE_FBO = 1
-libsnes ?= -lsnes
-
-LIBS = -lm
-DEFINES = -I. -DHAVE_CONFIGFILE
-LDFLAGS = -L. -static-libgcc -s
-
-SRC_LIBS = -lsamplerate-0
-SDL_LIBS = -lSDL
-SDL_CFLAGS = -ISDL
-
-ifeq ($(HAVE_SRC), 1)
-   LIBS += $(SRC_LIBS)
-   DEFINES += $(SRC_CFLAGS) -DHAVE_SRC
-else
-   OBJ += audio/hermite.o
-endif
-
-ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
-   LIBS += $(SDL_LIBS) -lopengl32
-   DEFINES += $(SDL_CFLAGS) -DHAVE_SDL
-endif
-
-ifeq ($(HAVE_XAUDIO), 1)
-   OBJ += audio/xaudio.o
-   DEFINES += -DHAVE_XAUDIO
-endif
-
-ifeq ($(HAVE_RSOUND), 1)
-   OBJ += audio/rsound.o
-   DEFINES += -DHAVE_RSOUND
-   LIBS += -lrsound
-endif
-
-ifeq ($(HAVE_XML), 1)
-   OBJ += gfx/shader_glsl.o
-   DEFINES += $(XML_CFLAGS) -DHAVE_XML
-   LIBS += -lxml2
-endif
-
-ifeq ($(HAVE_FILTER), 1)
-   DEFINES += -DHAVE_FILTER
-endif
-
-ifeq ($(HAVE_NETPLAY), 1)
-   DEFINES += -DHAVE_NETPLAY
-   OBJ += netplay.o
-   LIBS += -lws2_32
-endif
-
-ifeq ($(HAVE_FREETYPE), 1)
-   OBJ += gfx/fonts.o
-   DEFINES += -DHAVE_FREETYPE -Ifreetype2
-   LIBS += -lz -lfreetype6
-endif
-
-ifeq ($(DYNAMIC), 1)
-   DEFINES += -DHAVE_DYNAMIC
-else
-   LIBS += $(libsnes)
-endif
-
-ifeq ($(HAVE_FBO), 1)
-   DEFINES += -DHAVE_FBO
-endif
-
-ifneq ($(V),1)
-   Q := @
-endif
-
-
-CFLAGS = -Wall -O3 -std=gnu99 -I.
-
-all: $(TARGET) $(JTARGET)
-
-$(TARGET): $(OBJ)
-	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS)
-	@$(if $(Q), $(shell echo echo LD $@),)
-
-%.o: %.c
-	$(Q)$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
-	@$(if $(Q), $(shell echo echo CC $<),)
-
-$(JTARGET): $(JOBJ)
-	$(Q)$(CC) -o $@ $(JOBJ) $(SDL_LIBS) $(LDFLAGS)
-	@$(if $(Q), $(shell echo echo LD $@),)
-
-clean:
-	rm -f *.o 
-	rm -f audio/*.o
-	rm -f conf/*.o
-	rm -f gfx/*.o
-	rm -f record/*.o
-	rm -f hqflt/*.o
-	rm -f input/*.o
-	rm -f hqflt/snes_ntsc/*.o
-	rm -f $(TARGET)
-	rm -f ssnes-joyconfig.exe
-	rm -f tools/*.o
-
-dist: all
-	zip -r ssnes-win32-0.4-beta.zip $(TARGET) ssnes.cfg snes.dll libxml2.dll iconv.dll zlib1.dll SDL.dll freetype6.dll xaudio-c.dll rsound.dll pthreadGC2.dll README.win32.txt $(JTARGET)
-
-libs:
-	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-libs.zip --no-check-certificate
-	unzip SSNES-win32-libs.zip
-
-.PHONY: all install uninstall clean dist libs

Makefile.xenon

@@ -0,0 +1,55 @@
+###
+##
+# Makefile for SSNES libxenon.
+##
+###
+##
+
+DEBUG = 0
+
+CC = xenon-gcc
+CXX = xenon-g++
+OBJCOPY = xenon-objcopy
+STRIP = xenon-strip
+
+PPU_TARGET := ssnes-libxenon.elf
+PPU_TARGET_ADJUSTED := ssnes-libxenon.elf32
+
+LDDIRS = -L. -L$(DEVKITXENON)/usr/lib -L$(DEVKITXENON)/xenon/lib/32
+INCDIRS = -I. -I$(DEVKITXENON)/usr/include -I$(DEVKITXENON)/usr/include/SDL
+
+OBJ = fifo_buffer.o ssnes.o driver.o file.o settings.o message.o rewind.o movie.o input/sdl.o audio/sdl.o gfx/sdl.o gfx/sdlwrap.o gfx/gfx_common.o ups.o bps.o strl.o screenshot.o audio/hermite.o dynamic.o audio/utils.o conf/config_file.o
+
+LIBS = -lsnes -lSDL -lxenon -lm -lc
+DEFINES = -std=gnu99 -DHAVE_CONFIGFILE=1 -DHAVE_SDL=1 -DPACKAGE_VERSION=\"0.9.3\" -DHAVE_GETOPT_LONG=1
+DEFINES += -maltivec -mhard-float -m32 -mpowerpc64 -mcpu=cell -mtune=cell -fno-pic -g -Wall -DSDL -DXENON $(INCDIRS)
+DEFINES += -u read -u _start -u exc_base
+
+ifeq ($(DEBUG), 1)
+   OPTIMIZE_LV	:= -O0 -g
+else
+   OPTIMIZE_LV	:= -O3
+endif
+
+all: $(PPU_TARGET_ADJUSTED)
+
+CFLAGS := $(OPTIMIZE_LV) $(DEFINES)
+
+LDFLAGS := -m32 -n -T $(DEVKITXENON)/app.lds
+
+$(PPU_TARGET_ADJUSTED): $(PPU_TARGET)
+	$(OBJCOPY) -O elf32-powerpc --adjust-vma 0x80000000 $< $@
+	$(STRIP) $@
+
+$(PPU_TARGET): $(OBJ)
+	$(CXX) -o $@ $(OBJ) $(LDFLAGS) $(LDDIRS) $(LIBS)
+
+%.o: %.c config.h
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f $(PPU_TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean
+

README.md

@@ -7,6 +7,10 @@ SSNES is a simple frontend for the libsnes library.
 libsnes is the emulator core of [bSNES](http://www.byuu.org), the most accurate SNES emulator to date, in library form. The libsnes API has been implemented by SNES9x as well, allowing multiple different cores to be used for an emulator that supports libsnes.
 This enables the possibility of custom front-ends for the emulator.
 
+# Binaries
+
+Latest Windows binaries are currently hosted on my [homepage](http://themaister.net/ssnes.html).
+
 # Philosophy
 
 SSNES attempts to be very small and lean, while still having all the useful core features expected from an emulator. 

README.win32.txt

@@ -1,39 +0,0 @@
-===================================================
-   SSNES - Simple Super Nintendo Emulator System
-===================================================
-
-SSNES is a simplistic emulator frontend designed for use without any GUI. 
-It is used from command line, but is designed to play well with eventual GUI frontends, 
-as the configuration file format is very simple.
-
-This allows for great portability and focus on what matters in a frontend, such as video and audio performance.
-Its core libraries for video and input are OpenGL and SDL, with many different audio library supported.
-
-On first use you should get accustomed to how SSNES works.
-
--  SSNES emphasizes simplicity. It has no graphical user interface, and is primarily used through the command line.
-   It is recommended for experienced users.
-   It is possible though to create a GUI which can use SSNES.
-
--  SSNES isn't dependant on any emulator core, such as bSNES, SNES9x or ZSNES. 
-   SSNES only talks to the libsnes interface, 
-   which was created initially by bSNES but it has an implementation available for SNES9x as well.
-
--  SSNES is configured through a config file. In the Win32 distribution, there should be a ssnes.cfg included.
-   This config file serves as a base for your custom configuration file.
-   It is recommended that you go through the config file and alter any configurations you might use.
-   This is a good way to learn about the features SSNES have.
-   It is possible to pick which configuration file you want with the '-c' flag. 
-   E.g.: ssnes.exe -c myconfig.cfg rom.sfc.
-   
--  When unsure which command line flags to use, use the command: ssnes.exe --help.
-
--  When something is not working as expected, try using verbose logging first to see what is happening: 
-   E.g.: ssnes.exe -v romfile.sfc
-   If something is not working, and you want to file a bug report, 
-   please include console output with the -v flag turned on.
-
--  SSNES does not support zipped roms directly. It only supports roms with extentions .sfc and .smc.
-   However, SSNES can read roms from stdin, 
-   which makes it possible to create wrapper programs that can support every zip format under the sun.
-   This can also be performed by a GUI frontend.

audio/alsa.c

@@ -18,10 +18,10 @@
 
 #include "driver.h"
 #include <stdlib.h>
-#include <alsa/asoundlib.h>
+#include <asoundlib.h>
 #include "general.h"
 
-#define TRY_ALSA(x) if ( x < 0 ) { \
+#define TRY_ALSA(x) if (x < 0) { \
                   goto error; \
                }
 
@@ -32,7 +32,7 @@ typedef struct alsa
    bool has_float;
 } alsa_t;
 
-static bool __alsa_use_float(void *data)
+static bool alsa_use_float(void *data)
 {
    alsa_t *alsa = data;
    return alsa->has_float;
@@ -49,17 +49,17 @@ static bool find_float_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
    return false;
 }
 
-static void* __alsa_init(const char* device, int rate, int latency)
+static void *alsa_init(const char *device, unsigned rate, unsigned latency)
 {
    alsa_t *alsa = calloc(1, sizeof(alsa_t));
-   if ( alsa == NULL )
+   if (!alsa)
       return NULL;
 
    snd_pcm_hw_params_t *params = NULL;
    snd_pcm_sw_params_t *sw_params = NULL;
 
    const char *alsa_dev = "default";
-   if ( device != NULL )
+   if (device)
       alsa_dev = device;
 
    TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK));
@@ -117,7 +117,7 @@ error:
    return NULL;
 }
 
-static ssize_t __alsa_write(void* data, const void* buf, size_t size)
+static ssize_t alsa_write(void *data, const void *buf, size_t size)
 {
    alsa_t *alsa = data;
 
@@ -141,16 +141,16 @@ static ssize_t __alsa_write(void* data, const void* buf, size_t size)
 
       frames = snd_pcm_writei(alsa->pcm, (const char*)buf + written * 2 * (alsa->has_float ? sizeof(float) : sizeof(int16_t)), size - written);
 
-      if ( frames == -EPIPE || frames == -EINTR || frames == -ESTRPIPE )
+      if (frames == -EPIPE || frames == -EINTR || frames == -ESTRPIPE)
       {
-         if ( snd_pcm_recover(alsa->pcm, frames, 1) < 0 )
+         if (snd_pcm_recover(alsa->pcm, frames, 1) < 0)
             return -1;
 
          return 0;
       }
-      else if ( frames == -EAGAIN && alsa->nonblock )
+      else if (frames == -EAGAIN && alsa->nonblock)
          return 0;
-      else if ( frames < 0 )
+      else if (frames < 0)
          return -1;
 
       written += frames;
@@ -159,28 +159,28 @@ static ssize_t __alsa_write(void* data, const void* buf, size_t size)
    return snd_pcm_frames_to_bytes(alsa->pcm, size);
 }
 
-static bool __alsa_stop(void *data)
+static bool alsa_stop(void *data)
 {
    return true;
 }
 
-static void __alsa_set_nonblock_state(void *data, bool state)
+static void alsa_set_nonblock_state(void *data, bool state)
 {
    alsa_t *alsa = data;
    alsa->nonblock = state;
 }
 
-static bool __alsa_start(void *data)
+static bool alsa_start(void *data)
 {
    return true;
 }
 
-static void __alsa_free(void *data)
+static void alsa_free(void *data)
 {
    alsa_t *alsa = data;
-   if ( alsa )
+   if (alsa)
    {
-      if ( alsa->pcm )
+      if (alsa->pcm)
       {
          snd_pcm_drop(alsa->pcm);
          snd_pcm_close(alsa->pcm);
@@ -190,18 +190,13 @@ static void __alsa_free(void *data)
 }
 
 const audio_driver_t audio_alsa = {
-   .init = __alsa_init,
-   .write = __alsa_write,
-   .stop = __alsa_stop,
-   .start = __alsa_start,
-   .use_float = __alsa_use_float,
-   .set_nonblock_state = __alsa_set_nonblock_state,
-   .free = __alsa_free,
+   .init = alsa_init,
+   .write = alsa_write,
+   .stop = alsa_stop,
+   .start = alsa_start,
+   .use_float = alsa_use_float,
+   .set_nonblock_state = alsa_set_nonblock_state,
+   .free = alsa_free,
    .ident = "alsa"
 };
 
-   
-
-
-   
-   

audio/coreaudio.c

@@ -0,0 +1,281 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Chris Moeller
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "driver.h"
+#include "general.h"
+#include "fifo_buffer.h"
+#include <stdlib.h>
+#include <stdbool.h>
+#include <pthread.h>
+
+#include <CoreAudio/CoreAudio.h>
+#include <CoreServices/CoreServices.h>
+#include <AudioUnit/AudioUnit.h>
+#include <AudioUnit/AUComponent.h>
+
+typedef struct coreaudio
+{
+   pthread_mutex_t lock;
+   pthread_cond_t cond;
+
+   ComponentInstance dev;
+   bool dev_alive;
+
+   fifo_buffer_t *buffer;
+   bool nonblock;
+} coreaudio_t;
+
+static void coreaudio_free(void *data)
+{
+   coreaudio_t *dev = data;
+   if (!dev)
+      return;
+
+   if (dev->dev_alive)
+   {
+      AudioOutputUnitStop(dev->dev);
+      CloseComponent(dev->dev);
+   }
+
+   if (dev->buffer)
+      fifo_free(dev->buffer);
+
+   pthread_mutex_destroy(&dev->lock);
+   pthread_cond_destroy(&dev->cond);
+
+   free(dev);
+}
+
+static OSStatus audio_cb(void *userdata, AudioUnitRenderActionFlags *action_flags,
+      const AudioTimeStamp *time_stamp, UInt32 bus_number,
+      UInt32 number_frames, AudioBufferList *io_data)
+{
+   coreaudio_t *dev = userdata;
+   (void)time_stamp;
+   (void)bus_number;
+   (void)number_frames;
+
+   if (!io_data)
+      return noErr;
+   if (io_data->mNumberBuffers != 1)
+      return noErr;
+
+   unsigned write_avail = io_data->mBuffers[0].mDataByteSize;
+   void *outbuf = io_data->mBuffers[0].mData;
+
+   pthread_mutex_lock(&dev->lock);
+   if (fifo_read_avail(dev->buffer) < write_avail)
+   {
+      *action_flags = kAudioUnitRenderAction_OutputIsSilence;
+      memset(outbuf, 0, write_avail); // Seems to be needed.
+      pthread_mutex_unlock(&dev->lock);
+      pthread_cond_signal(&dev->cond); // Technically possible to deadlock without.
+      return noErr;
+   }
+
+   fifo_read(dev->buffer, outbuf, write_avail);
+   pthread_mutex_unlock(&dev->lock);
+   pthread_cond_signal(&dev->cond);
+   return noErr;
+}
+
+static void *coreaudio_init(const char *device, unsigned rate, unsigned latency)
+{
+   (void)device;
+
+   coreaudio_t *dev = calloc(1, sizeof(*dev));
+   if (!dev)
+      return NULL;
+
+   CFRunLoopRef run_loop = NULL;
+   AudioObjectPropertyAddress addr = {
+      kAudioHardwarePropertyRunLoop,
+      kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster
+   };
+
+   pthread_mutex_init(&dev->lock, NULL);
+   pthread_cond_init(&dev->cond, NULL);
+   AudioObjectSetPropertyData(kAudioObjectSystemObject, &addr, 0, NULL,
+         sizeof(CFRunLoopRef), &run_loop);
+
+   ComponentDescription desc = {
+      .componentType = kAudioUnitType_Output,
+      .componentSubType = kAudioUnitSubType_HALOutput,
+      .componentManufacturer = kAudioUnitManufacturer_Apple,
+   };
+
+   Component comp = FindNextComponent(NULL, &desc);
+   if (comp == NULL)
+      goto error;
+
+   OSStatus res = OpenAComponent(comp, &dev->dev);
+   if (res != noErr)
+      goto error;
+
+   dev->dev_alive = true;
+
+   AudioStreamBasicDescription stream_desc = {
+      .mSampleRate = rate,
+      .mBitsPerChannel = sizeof(float) * CHAR_BIT,
+      .mChannelsPerFrame = 2,
+      .mBytesPerPacket = 2 * sizeof(float),
+      .mBytesPerFrame = 2 * sizeof(float),
+      .mFramesPerPacket = 1,
+      .mFormatID = kAudioFormatLinearPCM,
+      .mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked | (is_little_endian() ? 0 : kAudioFormatFlagIsBigEndian),
+   };
+
+   res = AudioUnitSetProperty(dev->dev, kAudioUnitProperty_StreamFormat,
+         kAudioUnitScope_Input, 0, &stream_desc, sizeof(stream_desc));
+   if (res != noErr)
+      goto error;
+
+   AudioStreamBasicDescription real_desc;
+   UInt32 i_size = sizeof(real_desc);
+   res = AudioUnitGetProperty(dev->dev, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &real_desc, &i_size);
+   if (res != noErr)
+      goto error;
+
+   SSNES_LOG("[CoreAudio]: Using output sample rate of %.1f Hz\n", (float)real_desc.mSampleRate);
+   g_settings.audio.out_rate = real_desc.mSampleRate;
+
+   if (real_desc.mChannelsPerFrame != stream_desc.mChannelsPerFrame)
+      goto error;
+   if (real_desc.mBitsPerChannel != stream_desc.mBitsPerChannel)
+      goto error;
+   if (real_desc.mFormatFlags != stream_desc.mFormatFlags)
+      goto error;
+   if (real_desc.mFormatID != stream_desc.mFormatID)
+      goto error;
+
+   AudioChannelLayout layout = {
+      .mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelBitmap,
+      .mChannelBitmap = (1 << 2) - 1,
+   };
+
+   res = AudioUnitSetProperty(dev->dev, kAudioUnitProperty_AudioChannelLayout,
+         kAudioUnitScope_Input, 0, &layout, sizeof(layout));
+   if (res != noErr)
+      goto error;
+
+   AURenderCallbackStruct cb = {
+      .inputProc = audio_cb,
+      .inputProcRefCon = dev,
+   };
+
+   res = AudioUnitSetProperty(dev->dev, kAudioUnitProperty_SetRenderCallback,
+         kAudioUnitScope_Input, 0, &cb, sizeof(cb));
+   if (res != noErr)
+      goto error;
+
+   res = AudioUnitInitialize(dev->dev);
+   if (res != noErr)
+      goto error;
+
+   size_t fifo_size = (latency * g_settings.audio.out_rate) / 1000;
+   fifo_size *= 2 * sizeof(float);
+
+   dev->buffer = fifo_new(fifo_size);
+   if (!dev->buffer)
+      goto error;
+
+   SSNES_LOG("[CoreAudio]: Using buffer size of %u bytes: (latency = %u ms)\n", (unsigned)fifo_size, latency);
+
+   res = AudioOutputUnitStart(dev->dev);
+   if (res != noErr)
+      goto error;
+
+   return dev;
+
+error:
+   SSNES_ERR("[CoreAudio]: Failed to initialize driver ...\n");
+   coreaudio_free(dev);
+   return NULL;
+}
+
+static ssize_t coreaudio_write(void *data, const void *buf_, size_t size)
+{
+   coreaudio_t *dev = data;
+
+   const uint8_t *buf = buf_;
+   size_t written = 0;
+
+   while (size > 0)
+   {
+      pthread_mutex_lock(&dev->lock);
+
+      size_t write_avail = fifo_write_avail(dev->buffer);
+      if (write_avail > size)
+         write_avail = size;
+
+      fifo_write(dev->buffer, buf, write_avail);
+      buf += write_avail;
+      written += write_avail;
+      size -= write_avail;
+
+      if (dev->nonblock)
+      {
+         pthread_mutex_unlock(&dev->lock);
+         break;
+      }
+
+      if (write_avail == 0)
+         pthread_cond_wait(&dev->cond, &dev->lock);
+      pthread_mutex_unlock(&dev->lock);
+   }
+
+   return written;
+}
+
+static bool coreaudio_stop(void *data)
+{
+   coreaudio_t *dev = data;
+   return AudioOutputUnitStop(dev->dev) == noErr;
+}
+
+static void coreaudio_set_nonblock_state(void *data, bool state)
+{
+   coreaudio_t *dev = data;
+   dev->nonblock = state;
+}
+
+static bool coreaudio_start(void *data)
+{
+   coreaudio_t *dev = data;
+   return AudioOutputUnitStart(dev->dev) == noErr;
+}
+
+static bool coreaudio_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+const audio_driver_t audio_coreaudio = {
+   .init = coreaudio_init,
+   .write = coreaudio_write,
+   .stop = coreaudio_stop,
+   .start = coreaudio_start,
+   .set_nonblock_state = coreaudio_set_nonblock_state,
+   .free = coreaudio_free,
+   .use_float = coreaudio_use_float,
+   .ident = "coreaudio"
+};
+   

audio/dsound.c

@@ -0,0 +1,387 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "driver.h"
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <dsound.h>
+#include "fifo_buffer.h"
+#include "general.h"
+
+typedef struct dsound
+{
+   LPDIRECTSOUND ds;
+   LPDIRECTSOUNDBUFFER dsb;
+   HANDLE event;
+   bool nonblock;
+
+   fifo_buffer_t *buffer;
+   CRITICAL_SECTION crit;
+
+   volatile bool thread_alive;
+   HANDLE thread;
+   unsigned buffer_size;
+} dsound_t;
+
+static inline unsigned write_avail(unsigned read_ptr, unsigned write_ptr, unsigned buffer_size)
+{
+   return (read_ptr + buffer_size - write_ptr) % buffer_size;
+}
+
+static inline void get_positions(dsound_t *ds, DWORD *read_ptr, DWORD *write_ptr)
+{
+   IDirectSoundBuffer_GetCurrentPosition(ds->dsb, read_ptr, write_ptr);
+}
+
+#define CHUNK_SIZE 256
+
+struct audio_lock
+{
+   void *chunk1;
+   DWORD size1;
+   void *chunk2;
+   DWORD size2;
+};
+
+static inline bool grab_region(dsound_t *ds, DWORD write_ptr, struct audio_lock *region)
+{
+   HRESULT res = IDirectSoundBuffer_Lock(ds->dsb, write_ptr, CHUNK_SIZE, &region->chunk1, &region->size1, &region->chunk2, &region->size2, 0);
+   if (res == DSERR_BUFFERLOST)
+   {
+      res = IDirectSoundBuffer_Restore(ds->dsb);
+      if (res != DS_OK)
+         return false;
+
+      res = IDirectSoundBuffer_Lock(ds->dsb, write_ptr, CHUNK_SIZE, &region->chunk1, &region->size1, &region->chunk2, &region->size2, 0);
+      if (res != DS_OK)
+         return false;
+   }
+
+   const char *err;
+   switch (res)
+   {
+      case DSERR_BUFFERLOST:
+         err = "DSERR_BUFFERLOST";
+         break;
+      case DSERR_INVALIDCALL:
+         err = "DSERR_INVALIDCALL";
+         break;
+      case DSERR_INVALIDPARAM:
+         err = "DSERR_INVALIDPARAM";
+         break;
+      case DSERR_PRIOLEVELNEEDED:
+         err = "DSERR_PRIOLEVELNEEDED";
+         break;
+
+      default:
+         err = NULL;
+   }
+
+   if (err)
+   {
+      SSNES_WARN("[DirectSound error]: %s\n", err);
+      return false;
+   }
+
+   return true;
+}
+
+static inline void release_region(dsound_t *ds, const struct audio_lock *region)
+{
+   IDirectSoundBuffer_Unlock(ds->dsb, region->chunk1, region->size1, region->chunk2, region->size2);
+}
+
+static DWORD CALLBACK dsound_thread(PVOID data)
+{
+   dsound_t *ds = data;
+   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
+
+   DWORD write_ptr;
+   get_positions(ds, NULL, &write_ptr);
+   write_ptr = (write_ptr + ds->buffer_size / 2) % ds->buffer_size;
+
+   while (ds->thread_alive)
+   {
+      DWORD read_ptr;
+      get_positions(ds, &read_ptr, NULL);
+      
+      DWORD avail = write_avail(read_ptr, write_ptr, ds->buffer_size);
+
+      EnterCriticalSection(&ds->crit);
+      DWORD fifo_avail = fifo_read_avail(ds->buffer);
+      LeaveCriticalSection(&ds->crit);
+
+      // No space to write, or we don't have data in our fifo, but we can wait some time before it underruns ...
+      if (avail < CHUNK_SIZE || ((fifo_avail < CHUNK_SIZE) && (avail < ds->buffer_size / 2)))
+      {
+         Sleep(1);
+         // We could opt for using the notification interface,
+         // but it is not guaranteed to work, so use high priority sleeping patterns. :(
+      }
+      else if (fifo_avail < CHUNK_SIZE) // Got space to write, but nothing in FIFO (underrun), fill block with silence.
+      {
+         struct audio_lock region;
+         if (!grab_region(ds, write_ptr, &region))
+         {
+            ds->thread_alive = false;
+            SetEvent(ds->event);
+            break;
+         }
+
+         memset(region.chunk1, 0, region.size1);
+         memset(region.chunk2, 0, region.size2);
+
+         release_region(ds, &region);
+         write_ptr = (write_ptr + region.size1 + region.size2) % ds->buffer_size;
+      }
+      else // All is good. Pull from it and notify FIFO :D
+      {
+         struct audio_lock region;
+         if (!grab_region(ds, write_ptr, &region))
+         {
+            ds->thread_alive = false;
+            SetEvent(ds->event);
+            break;
+         }
+
+         EnterCriticalSection(&ds->crit);
+         if (region.chunk1)
+            fifo_read(ds->buffer, region.chunk1, region.size1);
+         if (region.chunk2)
+            fifo_read(ds->buffer, region.chunk2, region.size2);
+         LeaveCriticalSection(&ds->crit);
+
+         release_region(ds, &region);
+         write_ptr = (write_ptr + region.size1 + region.size2) % ds->buffer_size;
+
+         SetEvent(ds->event);
+      }
+   }
+
+   ExitThread(0);
+}
+
+static void dsound_stop_thread(dsound_t *ds)
+{
+   if (ds->thread)
+   {
+      ds->thread_alive = false;
+      WaitForSingleObject(ds->thread, INFINITE);
+      CloseHandle(ds->thread);
+      ds->thread = NULL;
+   }
+}
+
+static bool dsound_start_thread(dsound_t *ds)
+{
+   if (!ds->thread)
+   {
+      ds->thread_alive = true;
+      ds->thread = CreateThread(NULL, 0, dsound_thread, ds, 0, NULL);
+      if (ds->thread == NULL)
+         return false;
+   }
+
+   return true;
+}
+
+static void dsound_clear_buffer(dsound_t *ds)
+{
+   IDirectSoundBuffer_SetCurrentPosition(ds->dsb, 0);
+   void *ptr;
+   DWORD size;
+
+   if (IDirectSoundBuffer_Lock(ds->dsb, 0, 0, &ptr, &size, NULL, NULL, DSBLOCK_ENTIREBUFFER) == DS_OK)
+   {
+      memset(ptr, 0, size);
+      IDirectSoundBuffer_Unlock(ds->dsb, ptr, size, NULL, 0);
+   }
+}
+
+static void dsound_free(void *data)
+{
+   dsound_t *ds = data;
+   if (ds)
+   {
+      if (ds->thread)
+      {
+         ds->thread_alive = false;
+         WaitForSingleObject(ds->thread, INFINITE);
+         CloseHandle(ds->thread);
+      }
+
+      DeleteCriticalSection(&ds->crit);
+
+      if (ds->dsb)
+      {
+         IDirectSoundBuffer_Stop(ds->dsb);
+         IDirectSoundBuffer_Release(ds->dsb);
+      }
+
+      if (ds)
+         IDirectSound_Release(ds->ds);
+
+      if (ds->event)
+         CloseHandle(ds->event);
+
+      if (ds->buffer)
+         fifo_free(ds->buffer);
+
+      free(ds);
+   }
+}
+
+static void *dsound_init(const char *device, unsigned rate, unsigned latency)
+{
+   dsound_t *ds = calloc(1, sizeof(*ds));
+   if (!ds)
+      goto error;
+
+   InitializeCriticalSection(&ds->crit);
+
+   if (DirectSoundCreate(NULL, &ds->ds, NULL) != DS_OK)
+      goto error;
+
+   if (IDirectSound_SetCooperativeLevel(ds->ds, GetDesktopWindow(), DSSCL_PRIORITY) != DS_OK)
+      goto error;
+
+   WAVEFORMATEX wfx = {
+      .wFormatTag = WAVE_FORMAT_PCM,
+      .nChannels = 2,
+      .nSamplesPerSec = rate,
+      .wBitsPerSample = 16,
+      .nBlockAlign = 2 * sizeof(int16_t),
+      .nAvgBytesPerSec = rate * 2 * sizeof(int16_t),
+   };
+
+   ds->buffer_size = (latency * wfx.nAvgBytesPerSec) / 1000;
+   ds->buffer_size /= CHUNK_SIZE;
+   ds->buffer_size *= CHUNK_SIZE;
+   if (ds->buffer_size < 4 * CHUNK_SIZE)
+      ds->buffer_size = 4 * CHUNK_SIZE;
+
+   SSNES_LOG("[DirectSound]: Setting buffer size of %u bytes\n", ds->buffer_size);
+   SSNES_LOG("[DirectSound]: Latency = %u ms\n", (unsigned)((1000 * ds->buffer_size) / wfx.nAvgBytesPerSec));
+
+   DSBUFFERDESC bufdesc = {
+      .dwSize = sizeof(DSBUFFERDESC),
+      .dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS,
+      .dwBufferBytes = ds->buffer_size,
+      .lpwfxFormat = &wfx,
+   };
+
+   ds->event = CreateEvent(NULL, false, false, NULL);
+   if (!ds->event)
+      goto error;
+
+   ds->buffer = fifo_new(4 * 1024);
+   if (!ds->buffer)
+      goto error;
+
+   if (IDirectSound_CreateSoundBuffer(ds->ds, &bufdesc, &ds->dsb, 0) != DS_OK)
+      goto error;
+
+   IDirectSoundBuffer_SetCurrentPosition(ds->dsb, 0);
+
+   dsound_clear_buffer(ds);
+
+   if (IDirectSoundBuffer_Play(ds->dsb, 0, 0, DSBPLAY_LOOPING) != DS_OK)
+      goto error;
+
+   if (!dsound_start_thread(ds))
+      goto error;
+
+   return ds;
+
+error:
+   SSNES_ERR("[DirectSound] Error occured in init!\n");
+   dsound_free(ds);
+   return NULL;
+}
+
+static bool dsound_stop(void *data)
+{
+   dsound_t *ds = data;
+   dsound_stop_thread(ds);
+   return IDirectSoundBuffer_Stop(ds->dsb) == DS_OK;
+}
+
+static bool dsound_start(void *data)
+{
+   dsound_t *ds = data;
+   dsound_clear_buffer(ds);
+
+   if (!dsound_start_thread(ds))
+      return false;
+
+   return IDirectSoundBuffer_Play(ds->dsb, 0, 0, DSBPLAY_LOOPING) == DS_OK;
+}
+
+static void dsound_set_nonblock_state(void *data, bool state)
+{
+   dsound_t *ds = data;
+   ds->nonblock = state;
+}
+
+static ssize_t dsound_write(void *data, const void *buf_, size_t size)
+{
+   dsound_t *ds = data;
+   const uint8_t *buf = buf_;
+
+   if (!ds->thread_alive)
+      return -1;
+
+   size_t written = 0;
+   while (size > 0)
+   {
+      EnterCriticalSection(&ds->crit);
+      size_t avail = fifo_write_avail(ds->buffer);
+      if (avail > size)
+         avail = size;
+
+      fifo_write(ds->buffer, buf, avail);
+      LeaveCriticalSection(&ds->crit);
+
+      buf += avail;
+      size -= avail;
+      written += avail;
+
+      if (ds->nonblock || !ds->thread_alive)
+         break;
+
+      if (avail == 0)
+         WaitForSingleObject(ds->event, INFINITE);
+   }
+
+   return written;
+}
+
+
+const audio_driver_t audio_dsound = {
+   .init = dsound_init,
+   .write = dsound_write,
+   .stop = dsound_stop,
+   .start = dsound_start,
+   .set_nonblock_state = dsound_set_nonblock_state,
+   .free = dsound_free,
+   .ident = "dsound"
+};
+

audio/ext.c

@@ -0,0 +1,163 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ext/ssnes_audio.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "driver.h"
+#include "dynamic.h"
+#include "general.h"
+#include <sys/types.h>
+
+typedef struct audio_ext
+{
+   dylib_t lib;
+   const ssnes_audio_driver_t *driver;
+   void *handle;
+   bool is_float;
+} audio_ext_t;
+
+static void audio_ext_free(void *data)
+{
+   audio_ext_t *ext = data;
+   if (ext)
+   {
+      if (ext->driver && ext->handle)
+         ext->driver->free(ext->handle);
+      if (ext->lib)
+         dylib_close(ext->lib);
+      free(ext);
+   }
+}
+
+static void *audio_ext_init(const char *device, unsigned rate, unsigned latency)
+{
+   if (!(*g_settings.audio.external_driver))
+   {
+      SSNES_ERR("Please define an external audio driver.\n");
+      return NULL;
+   }
+
+   audio_ext_t *ext = calloc(1, sizeof(*ext));
+   if (!ext)
+      return NULL;
+
+   ext->lib = dylib_load(g_settings.audio.external_driver);
+   if (!ext->lib)
+   {
+      SSNES_ERR("Failed to load external library \"%s\"\n", g_settings.audio.external_driver);
+      goto error;
+   }
+
+   const ssnes_audio_driver_t* (*plugin_load)(void) = (const ssnes_audio_driver_t* (*)(void))dylib_proc(ext->lib, "ssnes_audio_driver_init");
+
+   if (!plugin_load)
+   {
+      SSNES_ERR("Failed to find symbol \"ssnes_audio_driver_init\" in plugin.\n");
+      goto error;
+   }
+
+   ext->driver = plugin_load();
+   if (!ext->driver)
+   {
+      SSNES_ERR("Received invalid driver from plugin.\n");
+      goto error;
+   }
+
+   SSNES_LOG("Loaded external audio driver: \"%s\"\n", ext->driver->ident ? ext->driver->ident : "Unknown");
+
+   if (ext->driver->api_version != SSNES_AUDIO_API_VERSION)
+   {
+      SSNES_ERR("API mismatch in external audio plugin. SSNES: %d, Plugin: %d ...\n", SSNES_AUDIO_API_VERSION, ext->driver->api_version);
+      goto error;
+   }
+
+   ssnes_audio_driver_info_t info = {
+      .device = device,
+      .sample_rate = rate,
+      .latency = latency
+   };
+
+   ext->handle = ext->driver->init(&info);
+   if (!ext->handle)
+   {
+      SSNES_ERR("Failed to init audio driver.\n");
+      goto error;
+   }
+
+   if (ext->driver->sample_rate)
+      g_settings.audio.out_rate = ext->driver->sample_rate(ext->handle);
+
+   if (!g_settings.audio.sync)
+      ext->driver->set_nonblock_state(ext->handle, SSNES_TRUE);
+
+   return ext;
+
+error:
+   audio_ext_free(ext);
+   return NULL;
+}
+
+static ssize_t audio_ext_write(void *data, const void *buf, size_t size)
+{
+   audio_ext_t *ext = data;
+   unsigned frame_size = ext->is_float ? (2 * sizeof(float)) : (2 * sizeof(int16_t));
+   size /= frame_size;
+
+   int ret = ext->driver->write(ext->handle, buf, size);
+   if (ret < 0)
+      return -1;
+   return ret * frame_size;
+}
+
+static bool audio_ext_start(void *data)
+{
+   audio_ext_t *ext = data;
+   return ext->driver->start(ext->handle);
+}
+
+static bool audio_ext_stop(void *data)
+{
+   audio_ext_t *ext = data;
+   return ext->driver->stop(ext->handle);
+}
+
+static void audio_ext_set_nonblock_state(void *data, bool toggle)
+{
+   audio_ext_t *ext = data;
+   ext->driver->set_nonblock_state(ext->handle, toggle);
+}
+
+static bool audio_ext_use_float(void *data)
+{
+   audio_ext_t *ext = data;
+   ext->is_float = ext->driver->use_float(ext->handle);
+   return ext->is_float;
+}
+
+
+const audio_driver_t audio_ext = {
+   .init = audio_ext_init,
+   .write = audio_ext_write,
+   .stop = audio_ext_stop,
+   .start = audio_ext_start,
+   .set_nonblock_state = audio_ext_set_nonblock_state,
+   .use_float = audio_ext_use_float,
+   .free = audio_ext_free,
+   .ident = "ext"
+};

audio/ext/Makefile

@@ -0,0 +1,16 @@
+TARGET = ssnes_iir_filter.so
+OBJ = ssnes_iir_filter.o
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CC) -o $@ -shared $(OBJ) -lm
+
+%.o: %.c
+	$(CC) -c -o $@ $< -g -std=c99 -fPIC -O3 -march=native $(CFLAGS)
+
+clean:
+	rm -f $(TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean

audio/ext/Makefile.test

@@ -0,0 +1,16 @@
+TARGET = iir_filter
+OBJ = ssnes_iir_filter.o
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CC) -o $@ $(OBJ) -lm
+
+%.o: %.c
+	$(CC) -c -o $@ $< -g -std=c99 -O3 -march=native $(CFLAGS) -DTEST -DLOG
+
+clean:
+	rm -f $(TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean

audio/ext/ssnes_audio.h

@@ -0,0 +1,128 @@
+/////
+// API header for external SSNES audio driver plugins.
+//
+//
+
+#ifndef __SSNES_AUDIO_DRIVER_PLUGIN_H
+#define __SSNES_AUDIO_DRIVER_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#ifdef SSNES_DLL_IMPORT
+#define SSNES_API_EXPORT __declspec(dllimport) 
+#else
+#define SSNES_API_EXPORT __declspec(dllexport) 
+#endif
+#define SSNES_API_CALLTYPE __cdecl
+#else
+#define SSNES_API_EXPORT
+#define SSNES_API_CALLTYPE
+#endif
+
+#ifndef SSNES_TRUE
+#define SSNES_TRUE 1
+#endif
+
+#ifndef SSNES_FALSE
+#define SSNES_FALSE 0
+#endif
+
+#ifndef SSNES_OK
+#define SSNES_OK 1
+#endif
+
+#ifndef SSNES_ERROR
+#define SSNES_ERROR 0
+#endif
+
+#define SSNES_AUDIO_API_VERSION 2
+
+typedef struct ssnes_audio_driver_info
+{
+   // A hint for a subdevice of the audio driver.
+   // This is driver independent, and not relevant for all
+   // audio drivers. I.e. ALSA driver might use "hw:0",
+   // OSS "/dev/audio", etc.
+   const char *device;
+
+   // Audio sample rate.
+   unsigned sample_rate;
+
+   // Maximum audio latency requested for output,
+   // measured in milliseconds.
+   // If driver is not able to provide this latency, it can
+   // be disregarded.
+   unsigned latency;
+} ssnes_audio_driver_info_t;
+
+typedef struct ssnes_audio_driver
+{
+   // Initializes the device.
+   void *(*init)(const ssnes_audio_driver_info_t *info);
+
+   // Write data in buffer to audio driver.
+   // A frame here is defined as one combined sample of left and right
+   // channels. (I.e. 44.1kHz, 16-bit stereo has 88.2k samples/s, and
+   // 44.1k frames/s.)
+   //
+   // Samples are interleaved in format LRLRLRLRLR ...
+   // If the driver returns true in use_float(), a floating point
+   // format will be used, with range [-1.0, 1.0].
+   // If not, signed 16-bit samples in native byte ordering will be used.
+   // 
+   // This function returns the number of frames successfully written.
+   // If an error occurs, -1 should be returned.
+   // Note that non-blocking behavior that cannot write at this time
+   // should return 0 as returning -1 will terminate the driver.
+   //
+   // Unless said otherwise with set_nonblock_state(), all writes
+   // are blocking, and it should block till it has written all frames.
+   int (*write)(void *data, const void *buffer, unsigned frames);
+
+   // Temporarily pauses the audio driver.
+   int (*stop)(void *data);
+
+   // Resumes audio driver from the paused state.
+   int (*start)(void *data);
+
+   // If state is true, nonblocking operation is assumed.
+   // This is typically used for fast-forwarding. If driver cannot
+   // implement nonblocking writes, this can be disregarded, but should
+   // log a message to stderr.
+   void (*set_nonblock_state)(void *data, int state);
+
+   // Stops and frees the audio driver.
+   void (*free)(void *data);
+
+   // If true is returned, the audio driver is capable of using
+   // floating point data. This will likely increase performance as the
+   // resampler unit uses floating point. The sample range is
+   // [-1.0, 1.0].
+   int (*use_float)(void *data);
+
+   // The driver might be forced to use a certain output frequency
+   // (i.e. Jack), and thus to avoid double resampling, the driver
+   // can request SSNES to resample to a different sample rate.
+   // This function can be set to NULL if the driver does not
+   // desire to override the sample rate.
+   unsigned (*sample_rate)(void *data);
+
+   // Human readable identification string for the driver.
+   const char *ident;
+
+   // Must be set to SSNES_AUDIO_API_VERSION.
+   // Used for detecting API mismatch.
+   int api_version;
+} ssnes_audio_driver_t;
+
+SSNES_API_EXPORT const ssnes_audio_driver_t* SSNES_API_CALLTYPE
+   ssnes_audio_driver_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

audio/ext/ssnes_dsp.h

@@ -0,0 +1,129 @@
+/////
+// API header for external SSNES DSP plugins.
+//
+//
+
+#ifndef __SSNES_DSP_PLUGIN_H
+#define __SSNES_DSP_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#ifdef SSNES_DLL_IMPORT
+#define SSNES_API_EXPORT __declspec(dllimport) 
+#else
+#define SSNES_API_EXPORT __declspec(dllexport) 
+#endif
+#define SSNES_API_CALLTYPE __cdecl
+#else
+#define SSNES_API_EXPORT
+#define SSNES_API_CALLTYPE
+#endif
+
+#ifndef SSNES_FALSE
+#define SSNES_FALSE 0
+#endif
+
+#ifndef SSNES_TRUE
+#define SSNES_TRUE 1
+#endif
+
+#define SSNES_DSP_API_VERSION 3
+
+typedef struct ssnes_dsp_info
+{
+   // Input sample rate that the DSP plugin receives. This is generally ~32kHz.
+   // Some small variance is allowed due to syncing behavior.
+   float input_rate;
+
+   // SSNES requests that the DSP plugin resamples the 
+   // input to a certain frequency.
+   //
+   // However, the plugin might ignore this
+   // using the resample field in ssnes_dsp_output_t (see below).
+   float output_rate;
+} ssnes_dsp_info_t;
+
+typedef struct ssnes_dsp_output
+{
+   // The DSP plugin has to provide the buffering for the output samples.
+   // This is for performance reasons to avoid redundant copying of data.
+   // The samples are laid out in interleaving order: LRLRLRLR
+   // The range of the samples are [-1.0, 1.0]. 
+   // This range cannot be exceeded without horrible audio glitches.
+   const float *samples;
+
+   // Frames which the DSP plugin outputted for the current process.
+   // One frame is here defined as a combined sample of 
+   // left and right channels. 
+   // (I.e. 44.1kHz, 16bit stereo will have 
+   // 88.2k samples/sec and 44.1k frames/sec.)
+   unsigned frames;
+
+   // If true, the DSP plugin did not resample the input audio, 
+   // and requests resampling to the proper frequency to be 
+   // performed outside the plugin.
+   // If false, 
+   // it is assumed that the output has the same sample rate as given
+   // in output_rate.
+   int should_resample;
+} ssnes_dsp_output_t;
+
+typedef struct ssnes_dsp_input
+{
+   // Input data for the DSP. The samples are interleaved in order: LRLRLRLR
+   const float *samples;
+
+   // Number of frames for input data.
+   // One frame is here defined as a combined sample of 
+   // left and right channels. 
+   // (I.e. 44.1kHz, 16bit stereo will have 
+   // 88.2k samples/sec and 44.1k frames/sec.)
+   unsigned frames;
+} ssnes_dsp_input_t;
+
+typedef struct ssnes_dsp_plugin
+{
+   // Creates a handle of the plugin. Returns NULL if failed.
+   void *(*init)(const ssnes_dsp_info_t *info);
+
+   // Processes input data. 
+   // The plugin is allowed to return variable sizes for output data.
+   void (*process)(void *data, ssnes_dsp_output_t *output, 
+         const ssnes_dsp_input_t *input);
+
+   // Frees the handle.
+   void (*free)(void *data);
+
+   // API version used to compile the plugin.
+   // Used to detect mismatches in API.
+   // Must be set to SSNES_DSP_API_VERSION on compile.
+   int api_version;
+
+   // Signal plugin that it may open a configuring window or
+   // something similiar. The behavior of this function
+   // is thus plugin dependent. Implementing this is optional,
+   // and can be set to NULL.
+   void (*config)(void *data);
+
+   // Human readable identification string.
+   const char *ident;
+
+   // Called every frame, allows creating a GUI main loop in the main thread.
+   // GUI events can be processed here in a non-blocking fashion.
+   // Can be set to NULL to ignore it.
+   void (*events)(void *data);
+} ssnes_dsp_plugin_t;
+
+// Called by SSNES at startup to get the callback struct.
+// This is NOT dynamically allocated!
+SSNES_API_EXPORT const ssnes_dsp_plugin_t* SSNES_API_CALLTYPE 
+   ssnes_dsp_plugin_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

audio/ext/ssnes_iir_filter.c

@@ -0,0 +1,418 @@
+#include "ssnes_dsp.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+#include <complex.h>
+
+// Simple IIR/EQ filter implementation, optimized for SSE3.
+
+#ifdef __SSE3__ // Build with -march=native or -msse3 to let this be detected! D:
+#define USE_SSE3
+#endif
+
+#ifdef USE_SSE3
+#include <pmmintrin.h>
+#endif
+
+// Make a test build with standalone main()
+//#define TEST
+
+#ifdef TEST
+#include <stdio.h>
+#include <assert.h>
+#endif
+
+// Log filter coeffs for debugging
+//#define LOG
+
+#define min(x, y) ((x) < (y) ? (x) : (y))
+
+#ifndef M_PI
+#define M_PI 3.14159265
+#endif
+
+// Taps needs to be power-of-two.
+#define TAPS (2048)
+
+static const float lp_freq = 5000.0;
+static const float hp_freq = 500.0;
+static const float bp_freq = 300.0;
+static const unsigned bp_q = 500;
+
+#ifdef USE_SSE3
+typedef union
+{
+   __m128 vec[TAPS / 4 + 1]; // Wraparound for unaligned reads.
+   float f[TAPS + 4];
+} vec_filt;
+#else
+typedef float vec_filt[TAPS + 4];
+#endif
+
+typedef struct
+{
+   vec_filt buffer[2];
+   vec_filt iir_buffer[2];
+   vec_filt fir_coeff;
+   vec_filt iir_coeff;
+
+   float out_buffer[4096];
+   unsigned buf_ptr;
+} dsp_state;
+
+// Convolve polynoms.
+static void conv(float * restrict a, const float * restrict b, unsigned a_size, unsigned b_size)
+{
+   float output[a_size + b_size - 1];
+
+   // Lead-in
+   for (int i = 0; i < b_size - 1; i++)
+   {
+      output[i] = 0.0;
+      for (int j = 0; j < b_size; j++)
+      {
+         if ((i - j) >= 0)
+         output[i] += a[i - j] * b[j];
+      }
+   }
+
+   // Mid-section
+   for (unsigned i = b_size - 1; i < a_size; i++)
+   {
+      output[i] = 0.0;
+      for (unsigned j = 0; j < b_size; j++)
+         output[i] += a[i - j] * b[j];
+   }
+
+   // Lead-out
+   for (unsigned i = a_size; i < a_size + b_size - 1; i++)
+   {
+      output[i] = 0.0;
+      for (unsigned j = 0; j < b_size; j++)
+      {
+         if ((i - j) < a_size)
+            output[i] += a[i - j] * b[j];
+      }
+   }
+
+   memcpy(a, output, sizeof(output));
+}
+
+#ifdef LOG
+static void print_coeff(const char *key, const float *coeff, unsigned elem)
+{
+   for (unsigned i = 0; i < elem; i++)
+      fprintf(stderr, "%4s [%3u] = %9.5f\n", key, i, coeff[i]);
+}
+
+static void print_filter_coeffs(const float *fir, const float *iir, unsigned elem)
+{
+   print_coeff("FIR", fir, elem);
+   print_coeff("IIR", iir, elem);
+}
+#endif
+
+// Simulate plain 1-pole RC circuit. 
+// dVc/dt = (Vin - Vc) / RC => 
+// y[n] = y[n - 1] * (1 - Ts/RC) + x[n] * Ts/RC  
+// RCw = 1 => RC = 1/(2*pi*fc)
+static void generate_low_pass(float fir_out[1], float iir_out[2], float freq, float input_rate)
+{
+   float ts = 1.0 / input_rate;
+   float t = 1.0 / (2 * M_PI * freq);
+   fir_out[0] = ts / t;
+   iir_out[0] = 1.0;
+   iir_out[1] = -(1.0 - ts / t);
+
+#ifdef LOG
+   print_coeff("FLOW", fir_out, 1);
+   print_coeff("ILOW", iir_out, 2);
+#endif
+}
+
+// 1-pole RC circuit (Vo taken over R).
+static void generate_high_pass(float fir_out[2], float iir_out[2], float freq, float input_rate)
+{
+   float ts = 1.0 / input_rate;
+   float t = 1.0 / (2 * M_PI * freq);
+   fir_out[0] = 1.0;
+   fir_out[1] = -1.0;
+
+   iir_out[0] = 1.0;
+   iir_out[1] = -(1.0 - ts / t);
+
+#ifdef LOG
+   print_coeff("FHI", fir_out, 2);
+   print_coeff("IHI", iir_out, 2);
+#endif
+}
+
+static void generate_band_pass(float *fir_out, unsigned num_fir, float freq, float input_rate)
+{
+   float w_norm = 2.0 * M_PI * freq / input_rate;
+   for (unsigned i = 0; i < num_fir; i++)
+      fir_out[i] = cosf(i * w_norm);
+
+   complex float amp = 0.0;
+   for (unsigned i = 0; i < num_fir; i++)
+      amp += cosf(i * w_norm) * cexp(-I * w_norm * i); 
+
+   float abs = cabs(amp);
+   for (unsigned i = 0; i < num_fir; i++)
+      fir_out[i] /= abs;
+}
+
+// Generic low-pass. Differential equation.
+static void generate_filter_coeffs(float * restrict fir_out, float * restrict iir_out, float input_rate)
+{
+   fir_out[0] = 1.0;
+   iir_out[0] = 1.0; 
+
+   unsigned fir_length = 1;
+   unsigned iir_length = 1;
+
+   /*
+   // Low pass
+   float lp_fir[1];
+   float lp_iir[2];
+   generate_low_pass(lp_fir, lp_iir, lp_freq, input_rate);
+   conv(fir_out, lp_fir, fir_length, 1);
+   conv(iir_out, lp_iir, iir_length, 2);
+   fir_length += 0;
+   iir_length += 1;
+
+   // High pass
+   float hp_fir[2];
+   float hp_iir[2];
+   generate_high_pass(hp_fir, hp_iir, hp_freq, input_rate);
+   conv(fir_out, hp_fir, fir_length, 2);
+   conv(iir_out, hp_iir, iir_length, 2);
+   fir_length += 1;
+   iir_length += 1;
+*/
+
+   // Band pass
+   float bp_fir[bp_q];
+   generate_band_pass(bp_fir, bp_q, bp_freq, input_rate);
+   conv(fir_out, bp_fir, fir_length, bp_q);
+   fir_length += bp_q - 1;
+   iir_length += 0;
+
+   // Adjust from Z rational polynomial model to discrete domain. 
+   // We don't care about first param as it's implicitly 1.
+   for (unsigned i = 0; i < TAPS; i++)
+      iir_out[i] = -1.0 * iir_out[i + 1];
+}
+
+
+static void *dsp_init(const ssnes_dsp_info_t *info)
+{
+   (void)info;
+   dsp_state *state = calloc(1, sizeof(*state));
+   if (!state)
+      return NULL;
+
+   fprintf(stderr, "Input rate = %.2f\n", (float)info->input_rate);
+
+#ifdef USE_SSE3
+   generate_filter_coeffs(state->fir_coeff.f, state->iir_coeff.f, info->input_rate);
+#ifdef LOG
+   print_filter_coeffs(state->fir_coeff.f, state->iir_coeff.f, 3);
+#endif
+#else
+   generate_filter_coeffs(state->fir_coeff, state->iir_coeff, info->input_rate);
+#ifdef LOG
+   print_filter_coeffs(state->fir_coeff, state->iir_coeff, 3);
+#endif
+#endif
+
+
+#ifdef USE_SSE3
+   memcpy(state->fir_coeff.f + TAPS, state->fir_coeff.f, 4 * sizeof(float));
+   memcpy(state->iir_coeff.f + TAPS, state->iir_coeff.f, 4 * sizeof(float));
+#endif
+
+   return state;
+}
+
+#ifdef USE_SSE3
+static void calculate_iir(float *out, dsp_state *dsp)
+{
+   unsigned buf_ptr = (dsp->buf_ptr - 1) & (TAPS - 1);
+   unsigned iir_ptr = (TAPS - dsp->buf_ptr) & (TAPS - 1);
+
+   const float * restrict samples_left = dsp->buffer[0].f; 
+   const float * restrict samples_right = dsp->buffer[1].f; 
+   const float * restrict iir_left = dsp->iir_buffer[0].f; 
+   const float * restrict iir_right = dsp->iir_buffer[1].f; 
+
+   __m128 sum_left = _mm_setzero_ps();
+   __m128 sum_right = _mm_setzero_ps();
+
+   for (unsigned i = 0; i < TAPS; i += 4)
+   {
+      __m128 left         = _mm_load_ps(samples_left + i);
+      __m128 right        = _mm_load_ps(samples_right + i);
+      const __m128 ileft  = _mm_load_ps(iir_left + i);
+      const __m128 iright = _mm_load_ps(iir_right + i);
+
+      // Need unaligned reads here.
+      const __m128 fir = _mm_loadu_ps(dsp->fir_coeff.f + iir_ptr);
+      const __m128 iir = _mm_loadu_ps(dsp->iir_coeff.f + iir_ptr);
+
+      const __m128 fir_res_left  = _mm_mul_ps(fir, left);
+      const __m128 fir_res_right = _mm_mul_ps(fir, right);
+      const __m128 iir_res_left  = _mm_mul_ps(iir, ileft);
+      const __m128 iir_res_right = _mm_mul_ps(iir, iright);
+
+      left  = _mm_add_ps(fir_res_left,  iir_res_left);
+      right = _mm_add_ps(fir_res_right, iir_res_right);
+
+      sum_left  = _mm_add_ps(sum_left,  left);
+      sum_right = _mm_add_ps(sum_right, right);
+
+      iir_ptr = (iir_ptr + 4) & (TAPS - 1);
+   }
+
+   __m128 res = _mm_hadd_ps(sum_left,  sum_right);
+   res = _mm_hadd_ps(res, res);
+
+   union
+   {
+      __m128 vec;
+      float f[4];
+   } u;
+   u.vec = res;
+
+   out[0] = u.f[0];
+   out[1] = u.f[1];
+   dsp->iir_buffer[0].f[buf_ptr] = u.f[0];
+   dsp->iir_buffer[1].f[buf_ptr] = u.f[1];
+}
+#else
+static void calculate_iir(float *out, dsp_state *dsp)
+{
+   const float * restrict samples_left = dsp->buffer[0]; 
+   const float * restrict samples_right = dsp->buffer[1]; 
+   const float * restrict iir_left = dsp->iir_buffer[0]; 
+   const float * restrict iir_right = dsp->iir_buffer[1]; 
+   const float * restrict fir = dsp->fir_coeff;
+   const float * restrict iir = dsp->iir_coeff;
+   
+   unsigned iir_ptr = 0;
+   unsigned sample_ptr = dsp->buf_ptr;
+
+   float sum[2] = { 0.0f, 0.0f };
+   for (unsigned i = 0; i < TAPS; i++)
+   {
+      sum[0] += fir[iir_ptr] * samples_left[sample_ptr] + iir[iir_ptr] * iir_left[sample_ptr];
+      sum[1] += fir[iir_ptr] * samples_right[sample_ptr] + iir[iir_ptr] * iir_right[sample_ptr];
+      iir_ptr++;
+      sample_ptr = (sample_ptr + 1) & (TAPS - 1);
+   }
+
+   // Stick our output value in the IIR buffer.
+   for (unsigned i = 0; i < 2; i++)
+   {
+      out[i] = sum[i];
+      dsp->iir_buffer[i][(dsp->buf_ptr - 1) & (TAPS - 1)] = sum[i];
+   }
+}
+#endif
+
+static void dsp_process(void *data, ssnes_dsp_output_t *output, const ssnes_dsp_input_t *input)
+{
+   dsp_state *dsp = data;
+   output->should_resample = SSNES_TRUE;
+   output->frames = input->frames;
+   output->samples = dsp->out_buffer;
+
+   for (unsigned i = 0; i < input->frames; i++)
+   {
+#ifdef USE_SSE3
+      dsp->buffer[0].f[dsp->buf_ptr] = input->samples[(i << 1) + 0];
+      dsp->buffer[1].f[dsp->buf_ptr] = input->samples[(i << 1) + 1];
+#else
+      dsp->buffer[0][dsp->buf_ptr] = input->samples[(i << 1) + 0];
+      dsp->buffer[1][dsp->buf_ptr] = input->samples[(i << 1) + 1];
+#endif
+
+      calculate_iir(&dsp->out_buffer[i << 1], dsp);
+      dsp->buf_ptr = (dsp->buf_ptr - 1) & (TAPS - 1);
+   }
+}
+
+static void dsp_config(void *data)
+{
+   (void)data;
+   // Normally we unhide a GUI window or something, 
+   // but we're just going to print to the log instead.
+   fprintf(stderr, "DSP_CONFIG\n");
+}
+
+static void dsp_free(void *data)
+{
+   free(data);
+}
+
+const ssnes_dsp_plugin_t dsp_plug = {
+   .init = dsp_init,
+   .process = dsp_process,
+   .free = dsp_free,
+   .config = dsp_config,
+   .api_version = SSNES_DSP_API_VERSION,
+   .ident = "IIR filter"
+};
+
+SSNES_API_EXPORT const ssnes_dsp_plugin_t*
+   SSNES_API_CALLTYPE ssnes_dsp_plugin_init(void)
+{
+   return &dsp_plug;
+}
+
+#ifdef TEST
+int main(void)
+{
+   const ssnes_dsp_plugin_t *plug = ssnes_dsp_plugin_init();
+   assert(plug);
+
+   ssnes_dsp_info_t info = {
+      .input_rate = 44100,
+      .output_rate = 44100
+   };
+   void *handle = plug->init(&info); // Info isn't used.
+   assert(handle);
+
+   int16_t buf[64];
+   float fbuf[64];
+
+   for (;;)
+   {
+      size_t rd = fread(buf, sizeof(int16_t), 64, stdin); 
+      for (unsigned i = 0; i < rd; i++)
+         fbuf[i] = (float)buf[i];
+
+      ssnes_dsp_input_t input = {
+         .samples = fbuf,
+         .frames = rd >> 1
+      };
+      ssnes_dsp_output_t output;
+      plug->process(handle, &output, &input);
+
+      for (unsigned i = 0; i < output.frames << 1; i++)
+      {
+         int32_t sample = (int32_t)output.samples[i];
+         buf[i] = (sample > 0x7fff) ? 0x7fff : ((sample < -0x8000) ? -0x8000 : (int16_t)sample);
+      }
+
+      fwrite(buf, sizeof(int16_t), output.frames << 1, stdout);
+
+      if (rd < 64)
+         break;
+   }
+
+   plug->free(handle);
+}
+#endif

audio/hermite.c

@@ -20,13 +20,12 @@
 #include "hermite.h"
 #include <stdlib.h>
 
-#define MAX_CHANS 8
+#define CHANNELS 2
 
 struct hermite_resampler
 {
-   float chan_data[MAX_CHANS][4];
+   float chan_data[CHANNELS][4];
    double r_frac;
-   unsigned chans;
 };
 
 static inline float hermite_kernel(float mu1, float a, float b, float c, float d)
@@ -47,35 +46,30 @@ static inline float hermite_kernel(float mu1, float a, float b, float c, float d
    return (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
 }
 
-hermite_resampler_t *hermite_new(unsigned channels)
+hermite_resampler_t *hermite_new(void)
 {
-   if (channels > MAX_CHANS)
-      return NULL;
-
    hermite_resampler_t *re = calloc(1, sizeof(*re));
    if (!re)
       return NULL;
-   re->chans = channels;
    return re;
 }
 
+// We make sure to allocate enough output data beforehand ... ;)
 void hermite_process(hermite_resampler_t *re, struct hermite_data *data)
 {
-   double r_step = 1.0 / data->src_ratio;
+   double r_step = 1.0 / data->ratio;
    size_t processed_out = 0;
-   size_t processed_in = 0;
 
    size_t in_frames = data->input_frames;
-   size_t out_frames = data->output_frames;
    const float *in_data = data->data_in;
    float *out_data = data->data_out;
 
-   while (processed_in < in_frames && processed_out < out_frames)
+   for (size_t i = 0; i < in_frames; i++)
    {
-      while (re->r_frac <= 1.0 && processed_out < out_frames)
+      while (re->r_frac <= 1.0)
       {
          re->r_frac += r_step;
-         for (unsigned i = 0; i < re->chans; i++)
+         for (unsigned i = 0; i < CHANNELS; i++)
          {
             float res = hermite_kernel(re->r_frac, 
                   re->chan_data[i][0], re->chan_data[i][1], re->chan_data[i][2], re->chan_data[i][3]);
@@ -84,23 +78,17 @@ void hermite_process(hermite_resampler_t *re, struct hermite_data *data)
          processed_out++;
       }
 
-      if (re->r_frac >= 1.0)
+      re->r_frac -= 1.0;
+      for (unsigned i = 0; i < CHANNELS; i++)
       {
-         re->r_frac -= 1.0;
-
-         for (unsigned i = 0; i < re->chans; i++)
-         {
-            re->chan_data[i][0] = re->chan_data[i][1];
-            re->chan_data[i][1] = re->chan_data[i][2];
-            re->chan_data[i][2] = re->chan_data[i][3];
-            re->chan_data[i][3] = *in_data++;
-         }
-         processed_in++;
+         re->chan_data[i][0] = re->chan_data[i][1];
+         re->chan_data[i][1] = re->chan_data[i][2];
+         re->chan_data[i][2] = re->chan_data[i][3];
+         re->chan_data[i][3] = *in_data++;
       }
    }
 
-   data->input_frames_used = processed_in;
-   data->output_frames_gen = processed_out;
+   data->output_frames = processed_out;
 }
 
 void hermite_free(hermite_resampler_t *re)

audio/hermite.h

@@ -26,7 +26,7 @@
 
 typedef struct hermite_resampler hermite_resampler_t;
 
-hermite_resampler_t *hermite_new(unsigned channels);
+hermite_resampler_t *hermite_new(void);
 
 struct hermite_data
 {
@@ -36,11 +36,7 @@ struct hermite_data
    size_t input_frames;
    size_t output_frames;
 
-   size_t input_frames_used;
-   size_t output_frames_gen;
-
-   bool end_of_input; // Just used to clone the SRC API.
-   double src_ratio;
+   double ratio;
 };
 
 void hermite_process(hermite_resampler_t *re, struct hermite_data *data);

audio/jack.c

@@ -124,12 +124,15 @@ static size_t find_buffersize(jack_t *jd, int latency)
    return buffer_frames * sizeof(jack_default_audio_sample_t);
 }
 
-static void* __jack_init(const char* device, int rate, int latency)
+static void *ja_init(const char *device, unsigned rate, unsigned latency)
 {
    jack_t *jd = calloc(1, sizeof(jack_t));
-   if ( jd == NULL )
+   if (!jd)
       return NULL;
 
+   pthread_cond_init(&jd->cond, NULL);
+   pthread_mutex_init(&jd->cond_lock, NULL);
+   
    const char **jports = NULL;
 
    jd->client = jack_client_open("SSNES", JackNullOption, NULL);
@@ -148,7 +151,6 @@ static void* __jack_init(const char* device, int rate, int latency)
       SSNES_ERR("Failed to register ports.\n");
       goto error;
    }
-
    
    char *dest_ports[2];
    jports = jack_get_ports(jd->client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
@@ -158,6 +160,18 @@ static void* __jack_init(const char* device, int rate, int latency)
       goto error;
    }
 
+   size_t bufsize = find_buffersize(jd, latency);
+   SSNES_LOG("JACK: Internal buffer size: %d frames.\n", (int)(bufsize / sizeof(jack_default_audio_sample_t)));
+   for (int i = 0; i < 2; i++)
+   {
+      jd->buffer[i] = jack_ringbuffer_create(bufsize);
+      if (jd->buffer[i] == NULL)
+      {
+         SSNES_ERR("Failed to create buffers.\n");
+         goto error;
+      }
+   }
+
    int parsed = parse_ports(dest_ports, jports);
 
    if (jack_activate(jd->client) < 0)
@@ -178,22 +192,7 @@ static void* __jack_init(const char* device, int rate, int latency)
    for (int i = 0; i < parsed; i++)
       free(dest_ports[i]);
 
-   size_t bufsize = find_buffersize(jd, latency);
-
-   SSNES_LOG("JACK: Internal buffer size: %d frames.\n", (int)(bufsize / sizeof(jack_default_audio_sample_t)));
-   for (int i = 0; i < 2; i++)
-   {
-      jd->buffer[i] = jack_ringbuffer_create(bufsize);
-      if (jd->buffer[i] == NULL)
-      {
-         SSNES_ERR("Failed to create buffers.\n");
-         goto error;
-      }
-   }
-
-   pthread_cond_init(&jd->cond, NULL);
-   pthread_mutex_init(&jd->cond_lock, NULL);
-
+  
    jack_free(jports);
    return jd;
 
@@ -247,32 +246,32 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
    return written * sizeof(float) * 2;
 }
 
-static ssize_t __jack_write(void* data, const void* buf, size_t size)
+static ssize_t ja_write(void *data, const void *buf, size_t size)
 {
    jack_t *jd = data;
 
    return write_buffer(jd, buf, size);
 }
 
-static bool __jack_stop(void *data)
+static bool ja_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_set_nonblock_state(void *data, bool state)
+static void ja_set_nonblock_state(void *data, bool state)
 {
    jack_t *jd = data;
    jd->nonblock = state;
 }
 
-static bool __jack_start(void *data)
+static bool ja_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_free(void *data)
+static void ja_free(void *data)
 {
    jack_t *jd = data;
 
@@ -293,20 +292,20 @@ static void __jack_free(void *data)
    free(jd);
 }
 
-static bool __jack_use_float(void *data)
+static bool ja_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
 const audio_driver_t audio_jack = {
-   .init = __jack_init,
-   .write = __jack_write,
-   .stop = __jack_stop,
-   .start = __jack_start,
-   .set_nonblock_state = __jack_set_nonblock_state,
-   .free = __jack_free,
-   .use_float = __jack_use_float,
+   .init = ja_init,
+   .write = ja_write,
+   .stop = ja_stop,
+   .start = ja_start,
+   .set_nonblock_state = ja_set_nonblock_state,
+   .free = ja_free,
+   .use_float = ja_use_float,
    .ident = "jack"
 };
 

audio/openal.c

@@ -56,11 +56,11 @@ typedef struct al
 
 } al_t;
 
-static void* __al_init(const char* device, int rate, int latency)
+static void *al_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
    al_t *al = calloc(1, sizeof(al_t));
-   if ( al == NULL )
+   if (!al)
       return NULL;
 
    al->handle = alcOpenDevice(NULL);
@@ -133,7 +133,7 @@ static bool al_get_buffer(al_t *al, ALuint *buffer)
       };
 #endif
 
-      for(;;)
+      for (;;)
       {
          if (al_unqueue_buffers(al))
             break;
@@ -153,7 +153,7 @@ static bool al_get_buffer(al_t *al, ALuint *buffer)
    return true;
 }
 
-static size_t al_fill_internal_buf(al_t *al, const void* buf, size_t size)
+static size_t al_fill_internal_buf(al_t *al, const void *buf, size_t size)
 {
    size_t read_size = (BUFSIZE - al->tmpbuf_ptr > size) ? size : (BUFSIZE - al->tmpbuf_ptr);
    memcpy(al->tmpbuf + al->tmpbuf_ptr, buf, read_size);
@@ -161,7 +161,7 @@ static size_t al_fill_internal_buf(al_t *al, const void* buf, size_t size)
    return read_size;
 }
 
-static ssize_t __al_write(void* data, const void* buf, size_t size)
+static ssize_t al_write(void *data, const void *buf, size_t size)
 {
    al_t *al = data;
 
@@ -196,32 +196,32 @@ static ssize_t __al_write(void* data, const void* buf, size_t size)
    return size;
 }
 
-static bool __al_stop(void *data)
+static bool al_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_set_nonblock_state(void *data, bool state)
+static void al_set_nonblock_state(void *data, bool state)
 {
    al_t *al = data;
    al->nonblock = state;
 }
 
-static bool __al_start(void *data)
+static bool al_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_free(void *data)
+static void al_free(void *data)
 {
    al_t *al= data;
    if (al)
    {
       alSourceStop(al->source);
       alDeleteSources(1, &al->source);
-      if ( al->buffers )
+      if (al->buffers)
       {
          alDeleteBuffers(al->num_buffers, al->buffers);
          free(al->buffers);
@@ -235,13 +235,12 @@ static void __al_free(void *data)
 }
 
 const audio_driver_t audio_openal = {
-   .init = __al_init,
-   .write = __al_write,
-   .stop = __al_stop,
-   .start = __al_start,
-   .set_nonblock_state = __al_set_nonblock_state,
-   .free = __al_free,
+   .init = al_init,
+   .write = al_write,
+   .stop = al_stop,
+   .start = al_start,
+   .set_nonblock_state = al_set_nonblock_state,
+   .free = al_free,
    .ident = "openal"
 };
 
-   

audio/oss.c

@@ -15,28 +15,44 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include "driver.h"
+#include "general.h"
 #include <stdlib.h>
+
+#ifdef HAVE_OSS_BSD
+#include <soundcard.h>
+#else
 #include <sys/soundcard.h>
+#endif
+
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
 
-static void* __oss_init(const char* device, int rate, int latency)
+#ifdef HAVE_OSS_BSD
+#define DEFAULT_OSS_DEV "/dev/audio"
+#else
+#define DEFAULT_OSS_DEV "/dev/dsp"
+#endif
+
+static void *oss_init(const char *device, unsigned rate, unsigned latency)
 {
    int *fd = calloc(1, sizeof(int));
-   if ( fd == NULL )
+   if (fd == NULL)
       return NULL;
 
-   const char *oss_device = "/dev/dsp";
+   const char *oss_device = DEFAULT_OSS_DEV;
 
-   if ( device != NULL )
+   if (device != NULL)
       oss_device = device;
 
-   if ( (*fd = open(oss_device, O_WRONLY)) < 0 )
+   if ((*fd = open(oss_device, O_WRONLY)) < 0)
    {
       free(fd);
       return NULL;
@@ -45,7 +61,7 @@ static void* __oss_init(const char* device, int rate, int latency)
    int frags = (latency * rate * 4)/(1000 * (1 << 9));
    int frag = (frags << 16) | 9;
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0)
    {
       close(*fd);
       free(fd);
@@ -53,23 +69,24 @@ static void* __oss_init(const char* device, int rate, int latency)
    }
 
    int channels = 2;
-   int format = AFMT_S16_LE;
+   int format = is_little_endian() ?
+      AFMT_S16_LE : AFMT_S16_BE;
 
-   if ( ioctl(*fd, SNDCTL_DSP_CHANNELS, &channels) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_CHANNELS, &channels) < 0)
    {
       close(*fd);
       free(fd);
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0)
    {
       close(*fd);
       free(fd);
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SPEED, &rate) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SPEED, &rate) < 0)
    {
       close(*fd);
       free(fd);
@@ -79,17 +96,17 @@ static void* __oss_init(const char* device, int rate, int latency)
    return fd;
 }
 
-static ssize_t __oss_write(void* data, const void* buf, size_t size)
+static ssize_t oss_write(void *data, const void *buf, size_t size)
 {
    int *fd = data;
 
-   if ( size == 0 )
+   if (size == 0)
       return 0;
 
    ssize_t ret;
-   if ( (ret = write(*fd, buf, size)) <= 0 )
+   if ((ret = write(*fd, buf, size)) <= 0)
    {
-      if ( (fcntl(*fd, F_GETFL) & O_NONBLOCK) && errno == EAGAIN )
+      if ((fcntl(*fd, F_GETFL) & O_NONBLOCK) && errno == EAGAIN)
          return 0;
       return -1;
    }
@@ -97,19 +114,19 @@ static ssize_t __oss_write(void* data, const void* buf, size_t size)
    return ret;
 }
 
-static bool __oss_stop(void *data)
+static bool oss_stop(void *data)
 {
    int *fd = data;
    ioctl(*fd, SNDCTL_DSP_RESET, 0);
    return true;
 }
 
-static bool __oss_start(void *data)
+static bool oss_start(void *data)
 {
    return true;
 }
 
-static void __oss_set_nonblock_state(void *data, bool state)
+static void oss_set_nonblock_state(void *data, bool state)
 {
    int *fd = data;
    int rc;
@@ -121,7 +138,7 @@ static void __oss_set_nonblock_state(void *data, bool state)
       fprintf(stderr, "SSNES [ERROR]: Could not set nonblocking on OSS file descriptor. Will not be able to fast-forward.\n");
 }
 
-static void __oss_free(void *data)
+static void oss_free(void *data)
 {
    int *fd = data;
 
@@ -131,17 +148,12 @@ static void __oss_free(void *data)
 }
 
 const audio_driver_t audio_oss = {
-   .init = __oss_init,
-   .write = __oss_write,
-   .stop = __oss_stop,
-   .start = __oss_start,
-   .set_nonblock_state = __oss_set_nonblock_state,
-   .free = __oss_free,
+   .init = oss_init,
+   .write = oss_write,
+   .stop = oss_stop,
+   .start = oss_start,
+   .set_nonblock_state = oss_set_nonblock_state,
+   .free = oss_free,
    .ident = "oss"
 };
-
-   
-
-
-   
    

audio/pulse.c

@@ -32,7 +32,7 @@ typedef struct
    bool nonblock;
 } pa_t;
 
-static void __pulse_free(void *data)
+static void pulse_free(void *data)
 {
    pa_t *pa = data;
    if (pa)
@@ -59,18 +59,6 @@ static void __pulse_free(void *data)
    }
 }
 
-static inline uint8_t is_little_endian(void)
-{
-   union
-   {
-      uint16_t x;
-      uint8_t y[2];
-   } u;
-
-   u.x = 1;
-   return u.y[0];
-}
-
 static void context_state_cb(pa_context *c, void *data)
 {
    pa_t *pa = data;
@@ -115,7 +103,7 @@ static void stream_latency_update_cb(pa_stream *s, void *data)
    pa_threaded_mainloop_signal(pa->mainloop, 0);
 }
 
-static void* __pulse_init(const char* device, int rate, int latency)
+static void *pulse_init(const char *device, unsigned rate, unsigned latency)
 {
    pa_t *pa = calloc(1, sizeof(*pa));
    if (!pa)
@@ -180,11 +168,11 @@ static void* __pulse_init(const char* device, int rate, int latency)
 unlock_error:
    pa_threaded_mainloop_unlock(pa->mainloop);
 error:
-   __pulse_free(pa); 
+   pulse_free(pa); 
    return NULL;
 }
 
-static ssize_t __pulse_write(void* data, const void* buf, size_t size)
+static ssize_t pulse_write(void *data, const void *buf, size_t size)
 {
    pa_t *pa = data;
 
@@ -210,38 +198,38 @@ static ssize_t __pulse_write(void* data, const void* buf, size_t size)
    return write_size;
 }
 
-static bool __pulse_stop(void *data)
+static bool pulse_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static bool __pulse_start(void *data)
+static bool pulse_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __pulse_set_nonblock_state(void *data, bool state)
+static void pulse_set_nonblock_state(void *data, bool state)
 {
    pa_t *pa = data;
    pa->nonblock = state;
 }
 
-static bool __pulse_use_float(void *data)
+static bool pulse_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
 const audio_driver_t audio_pulse = {
-   .init = __pulse_init,
-   .write = __pulse_write,
-   .stop = __pulse_stop,
-   .start = __pulse_start,
-   .set_nonblock_state = __pulse_set_nonblock_state,
-   .use_float = __pulse_use_float,
-   .free = __pulse_free,
+   .init = pulse_init,
+   .write = pulse_write,
+   .stop = pulse_stop,
+   .start = pulse_start,
+   .set_nonblock_state = pulse_set_nonblock_state,
+   .use_float = pulse_use_float,
+   .free = pulse_free,
    .ident = "pulse"
 };
 

audio/roar.c

@@ -30,8 +30,9 @@ typedef struct
    bool nonblocking;
 } roar_t;
 
-static void* __roar_init(const char* device, int rate, int latency)
+static void *ra_init(const char *device, unsigned rate, unsigned latency)
 {
+   (void)latency;
    int err;
    roar_t *roar = calloc(1, sizeof(roar_t));
    if (roar == NULL)
@@ -51,7 +52,7 @@ static void* __roar_init(const char* device, int rate, int latency)
    return roar;
 }
 
-static ssize_t __roar_write(void* data, const void* buf, size_t size)
+static ssize_t ra_write(void *data, const void *buf, size_t size)
 {
    roar_t *roar = data;
    ssize_t rc;
@@ -77,13 +78,13 @@ static ssize_t __roar_write(void* data, const void* buf, size_t size)
    return size;
 }
 
-static bool __roar_stop(void *data)
+static bool ra_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_set_nonblock_state(void *data, bool state)
+static void ra_set_nonblock_state(void *data, bool state)
 {
    roar_t *roar = data;
    if (roar_vs_blocking(roar->vss, (state) ? ROAR_VS_FALSE : ROAR_VS_TRUE, NULL) < 0)
@@ -91,13 +92,13 @@ static void __roar_set_nonblock_state(void *data, bool state)
    roar->nonblocking = state;
 }
 
-static bool __roar_start(void *data)
+static bool ra_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_free(void *data)
+static void ra_free(void *data)
 {
    roar_t *roar = data;
    roar_vs_close(roar->vss, ROAR_VS_TRUE, NULL);
@@ -105,12 +106,12 @@ static void __roar_free(void *data)
 }
 
 const audio_driver_t audio_roar = {
-   .init = __roar_init,
-   .write = __roar_write,
-   .stop = __roar_stop,
-   .start = __roar_start,
-   .set_nonblock_state = __roar_set_nonblock_state,
-   .free = __roar_free,
+   .init = ra_init,
+   .write = ra_write,
+   .stop = ra_stop,
+   .start = ra_start,
+   .set_nonblock_state = ra_set_nonblock_state,
+   .free = ra_free,
    .ident = "roar"
 };
 

audio/rsound.c

@@ -19,7 +19,7 @@
 #include "driver.h"
 #include <stdlib.h>
 #include <rsound.h>
-#include "buffer.h"
+#include "fifo_buffer.h"
 #include <stdbool.h>
 #include "SDL.h"
 
@@ -29,7 +29,7 @@ typedef struct rsd
    bool nonblock;
    volatile bool has_error;
 
-   rsound_fifo_buffer_t *buffer;
+   fifo_buffer_t *buffer;
 
    SDL_mutex *cond_lock;
    SDL_cond *cond;
@@ -39,9 +39,9 @@ static ssize_t audio_cb(void *data, size_t bytes, void *userdata)
 {
    rsd_t *rsd = userdata;
 
-   size_t avail = rsnd_fifo_read_avail(rsd->buffer);
+   size_t avail = fifo_read_avail(rsd->buffer);
    size_t write_size = bytes > avail ? avail : bytes;
-   rsnd_fifo_read(rsd->buffer, data, write_size);
+   fifo_read(rsd->buffer, data, write_size);
    SDL_CondSignal(rsd->cond);
 
    return write_size;
@@ -54,15 +54,15 @@ static void err_cb(void *userdata)
    SDL_CondSignal(rsd->cond);
 }
 
-static void* __rsd_init(const char* device, int rate, int latency)
+static void *rs_init(const char *device, unsigned rate, unsigned latency)
 {
    rsd_t *rsd = calloc(1, sizeof(rsd_t));
-   if ( rsd == NULL )
+   if (!rsd)
       return NULL;
 
    rsound_t *rd;
 
-   if ( rsd_init(&rd) < 0 )
+   if (rsd_init(&rd) < 0)
    {
       free(rsd);
       return NULL;
@@ -71,7 +71,7 @@ static void* __rsd_init(const char* device, int rate, int latency)
    rsd->cond_lock = SDL_CreateMutex();
    rsd->cond = SDL_CreateCond();
 
-   rsd->buffer = rsnd_fifo_new(1024 * 4);
+   rsd->buffer = fifo_new(1024 * 4);
 
    int channels = 2;
    int format = RSD_S16_NE;
@@ -80,14 +80,14 @@ static void* __rsd_init(const char* device, int rate, int latency)
    rsd_set_param(rd, RSD_SAMPLERATE, &rate);
    rsd_set_param(rd, RSD_LATENCY, &latency);
 
-   if ( device != NULL )
+   if (device)
       rsd_set_param(rd, RSD_HOST, (void*)device);
 
    rsd_set_param(rd, RSD_FORMAT, &format);
 
    rsd_set_callback(rd, audio_cb, err_cb, 256, rsd);
 
-   if ( rsd_start(rd) < 0 )
+   if (rsd_start(rd) < 0)
    {
       free(rsd);
       rsd_free(rd);
@@ -98,7 +98,7 @@ static void* __rsd_init(const char* device, int rate, int latency)
    return rsd;
 }
 
-static ssize_t __rsd_write(void* data, const void* buf, size_t size)
+static ssize_t rs_write(void *data, const void *buf, size_t size)
 {
    rsd_t *rsd = data;
 
@@ -108,9 +108,9 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
    if (rsd->nonblock)
    {
       rsd_callback_lock(rsd->rd);
-      size_t avail = rsnd_fifo_write_avail(rsd->buffer);
+      size_t avail = fifo_write_avail(rsd->buffer);
       size_t write_amt = avail > size ? size : avail;
-      rsnd_fifo_write(rsd->buffer, buf, write_amt);
+      fifo_write(rsd->buffer, buf, write_amt);
       rsd_callback_unlock(rsd->rd);
       return write_amt;
    }
@@ -120,7 +120,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
       while (written < size && !rsd->has_error)
       {
          rsd_callback_lock(rsd->rd);
-         size_t avail = rsnd_fifo_write_avail(rsd->buffer);
+         size_t avail = fifo_write_avail(rsd->buffer);
 
          if (avail == 0)
          {
@@ -135,7 +135,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
          else
          {
             size_t write_amt = size - written > avail ? avail : size - written;
-            rsnd_fifo_write(rsd->buffer, (const char*)buf + written, write_amt);
+            fifo_write(rsd->buffer, (const char*)buf + written, write_amt);
             rsd_callback_unlock(rsd->rd);
             written += write_amt;
          }
@@ -144,7 +144,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
    }
 }
 
-static bool __rsd_stop(void *data)
+static bool rs_stop(void *data)
 {
    rsd_t *rsd = data;
    rsd_stop(rsd->rd);
@@ -152,29 +152,29 @@ static bool __rsd_stop(void *data)
    return true;
 }
 
-static void __rsd_set_nonblock_state(void *data, bool state)
+static void rs_set_nonblock_state(void *data, bool state)
 {
    rsd_t *rsd = data;
    rsd->nonblock = state;
 }
 
-static bool __rsd_start(void *data)
+static bool rs_start(void *data)
 {
    rsd_t *rsd = data;
-   if ( rsd_start(rsd->rd) < 0)
+   if (rsd_start(rsd->rd) < 0)
       return false;
 
    return true;
 }
 
-static void __rsd_free(void *data)
+static void rs_free(void *data)
 {
    rsd_t *rsd = data;
 
    rsd_stop(rsd->rd);
    rsd_free(rsd->rd);
 
-   rsnd_fifo_free(rsd->buffer);
+   fifo_free(rsd->buffer);
    SDL_DestroyMutex(rsd->cond_lock);
    SDL_DestroyCond(rsd->cond);
 
@@ -182,12 +182,12 @@ static void __rsd_free(void *data)
 }
 
 const audio_driver_t audio_rsound = {
-   .init = __rsd_init,
-   .write = __rsd_write,
-   .stop = __rsd_stop,
-   .start = __rsd_start,
-   .set_nonblock_state = __rsd_set_nonblock_state,
-   .free = __rsd_free,
+   .init = rs_init,
+   .write = rs_write,
+   .stop = rs_stop,
+   .start = rs_start,
+   .set_nonblock_state = rs_set_nonblock_state,
+   .free = rs_free,
    .ident = "rsound"
 };
    

audio/sdl.c

@@ -27,7 +27,7 @@
 #include "SDL_audio.h"
 #include "SDL_thread.h"
 #include "general.h"
-#include "buffer.h"
+#include "fifo_buffer.h"
 
 typedef struct sdl_audio
 {
@@ -35,16 +35,16 @@ typedef struct sdl_audio
 
    SDL_mutex *lock;
    SDL_cond *cond;
-   rsound_fifo_buffer_t *buffer;
+   fifo_buffer_t *buffer;
 } sdl_audio_t;
 
 static void sdl_audio_cb(void *data, Uint8 *stream, int len)
 {
    sdl_audio_t *sdl = data;
 
-   size_t avail = rsnd_fifo_read_avail(sdl->buffer);
+   size_t avail = fifo_read_avail(sdl->buffer);
    size_t write_size = len > avail ? avail : len;
-   rsnd_fifo_read(sdl->buffer, stream, write_size);
+   fifo_read(sdl->buffer, stream, write_size);
    SDL_CondSignal(sdl->cond);
 
    // If underrun, fill rest with silence.
@@ -58,7 +58,7 @@ static inline int find_num_frames(int rate, int latency)
    return next_pow2(frames);
 }
 
-static void* sdl_audio_init(const char* device, int rate, int latency)
+static void *sdl_audio_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
    if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
@@ -98,10 +98,10 @@ static void* sdl_audio_init(const char* device, int rate, int latency)
    // Create a buffer twice as big as needed and prefill the buffer.
    size_t bufsize = out.samples * 4 * sizeof(int16_t);
    void *tmp = calloc(1, bufsize);
-   sdl->buffer = rsnd_fifo_new(bufsize);
+   sdl->buffer = fifo_new(bufsize);
    if (tmp)
    {
-      rsnd_fifo_write(sdl->buffer, tmp, bufsize);
+      fifo_write(sdl->buffer, tmp, bufsize);
       free(tmp);
    }
 
@@ -109,7 +109,7 @@ static void* sdl_audio_init(const char* device, int rate, int latency)
    return sdl;
 }
 
-static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
+static ssize_t sdl_audio_write(void *data, const void *buf, size_t size)
 {
    sdl_audio_t *sdl = data;
 
@@ -117,9 +117,9 @@ static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
    if (sdl->nonblock)
    {
       SDL_LockAudio();
-      size_t avail = rsnd_fifo_write_avail(sdl->buffer);
+      size_t avail = fifo_write_avail(sdl->buffer);
       size_t write_amt = avail > size ? size : avail;
-      rsnd_fifo_write(sdl->buffer, buf, write_amt);
+      fifo_write(sdl->buffer, buf, write_amt);
       SDL_UnlockAudio();
       ret = write_amt;
    }
@@ -129,7 +129,7 @@ static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
       while (written < size)
       {
          SDL_LockAudio();
-         size_t avail = rsnd_fifo_write_avail(sdl->buffer);
+         size_t avail = fifo_write_avail(sdl->buffer);
 
          if (avail == 0)
          {
@@ -141,7 +141,7 @@ static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
          else
          {
             size_t write_amt = size - written > avail ? avail : size - written;
-            rsnd_fifo_write(sdl->buffer, (const char*)buf + written, write_amt);
+            fifo_write(sdl->buffer, (const char*)buf + written, write_amt);
             SDL_UnlockAudio();
             written += write_amt;
          }
@@ -180,7 +180,7 @@ static void sdl_audio_free(void *data)
    sdl_audio_t *sdl = data;
    if (sdl)
    {
-      rsnd_fifo_free(sdl->buffer);
+      fifo_free(sdl->buffer);
       SDL_DestroyMutex(sdl->lock);
       SDL_DestroyCond(sdl->cond);
    }
@@ -196,9 +196,4 @@ const audio_driver_t audio_sdl = {
    .free = sdl_audio_free,
    .ident = "sdl"
 };
-
-   
-
-
-   
    

audio/utils.c

@@ -0,0 +1,119 @@
+#include "utils.h"
+
+#if __SSE2__
+#include <emmintrin.h>
+#elif __ALTIVEC__
+#include <altivec.h>
+#endif
+
+void audio_convert_s16_to_float_C(float *out,
+      const int16_t *in, size_t samples)
+{
+   for (size_t i = 0; i < samples; i++)
+      out[i] = (float)in[i] / 0x8000; 
+}
+
+void audio_convert_float_to_s16_C(int16_t *out,
+      const float *in, size_t samples)
+{
+   for (size_t i = 0; i < samples; i++)
+   {
+      int32_t val = in[i] * 0x8000;
+      out[i] = (val > 0x7FFF) ? 0x7FFF : (val < -0x8000 ? -0x8000 : (int16_t)val);
+   }
+}
+
+#if __SSE2__
+void audio_convert_s16_to_float_SSE2(float *out,
+      const int16_t *in, size_t samples)
+{
+   __m128 factor = _mm_set1_ps(1.0f / (0x7fff * 0x10000));
+   size_t i;
+   for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+   {
+      __m128i input = _mm_loadu_si128((const __m128i *)in);
+      __m128i regs[2] = {
+         _mm_unpacklo_epi16(_mm_setzero_si128(), input),
+         _mm_unpackhi_epi16(_mm_setzero_si128(), input),
+      };
+
+      __m128 output[2] = {
+         _mm_mul_ps(_mm_cvtepi32_ps(regs[0]), factor),
+         _mm_mul_ps(_mm_cvtepi32_ps(regs[1]), factor),
+      };
+
+      _mm_storeu_ps(out + 0, output[0]);
+      _mm_storeu_ps(out + 4, output[1]);
+   }
+
+   audio_convert_s16_to_float_C(out, in, samples - i);
+}
+
+void audio_convert_float_to_s16_SSE2(int16_t *out,
+      const float *in, size_t samples)
+{
+   __m128 factor = _mm_set1_ps((float)0x7fff);
+   size_t i;
+   for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+   {
+      __m128 input[2] = { _mm_loadu_ps(in + 0), _mm_loadu_ps(in + 4) };
+      __m128 res[2] = { _mm_mul_ps(input[0], factor), _mm_mul_ps(input[1], factor) };
+
+      __m128i ints[2] = { _mm_cvtps_epi32(res[0]), _mm_cvtps_epi32(res[1]) };
+      __m128i packed = _mm_packs_epi32(ints[0], ints[1]);
+
+      _mm_storeu_si128((__m128i *)out, packed);
+   }
+
+   audio_convert_float_to_s16_C(out, in, samples - i);
+}
+#elif __ALTIVEC__
+void audio_convert_s16_to_float_altivec(float *out,
+      const int16_t *in, size_t samples)
+{
+   // Unaligned loads/store is a bit expensive, so we optimize for the good path (very likely).
+   if (((uintptr_t)out & 15) + ((uintptr_t)in & 15) == 0)
+   {
+      size_t i;
+      for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+      {
+         vector signed short input = vec_ld(0, in);
+         vector signed int hi = vec_unpackh(input);
+         vector signed int lo = vec_unpackl(input);
+         vector float out_hi = vec_ctf(hi, 15);
+         vector float out_lo = vec_ctf(lo, 15);
+
+         vec_st(out_hi,  0, out);
+         vec_st(out_lo, 16, out);
+      }
+
+      audio_convert_s16_to_float_C(out, in, samples - i);
+   }
+   else
+      audio_convert_s16_to_float_C(out, in, samples);
+}
+
+void audio_convert_float_to_s16_altivec(int16_t *out,
+      const float *in, size_t samples)
+{
+   // Unaligned loads/store is a bit expensive, so we optimize for the good path (very likely).
+   if (((uintptr_t)out & 15) + ((uintptr_t)in & 15) == 0)
+   {
+      size_t i;
+      for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+      {
+         vector float input0 = vec_ld( 0, in);
+         vector float input1 = vec_ld(16, in);
+         vector signed int result0 = vec_cts(input0, 15);
+         vector signed int result1 = vec_cts(input1, 15);
+         vec_st(vec_packs(result0, result1), 0, out);
+      }
+
+      audio_convert_float_to_s16_C(out, in, samples - i);
+   }
+   else
+      audio_convert_float_to_s16_C(out, in, samples);
+}
+
+#endif
+

audio/utils.h

@@ -0,0 +1,38 @@
+#ifndef AUDIO_UTILS_H
+#define AUDIO_UTILS_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#if __SSE2__
+#define audio_convert_s16_to_float audio_convert_s16_to_float_SSE2
+#define audio_convert_float_to_s16 audio_convert_float_to_s16_SSE2
+
+void audio_convert_s16_to_float_SSE2(float *out,
+      const int16_t *in, size_t samples);
+
+void audio_convert_float_to_s16_SSE2(int16_t *out,
+      const float *in, size_t samples);
+
+#elif __ALTIVEC__
+#define audio_convert_s16_to_float audio_convert_s16_to_float_altivec
+#define audio_convert_float_to_s16 audio_convert_float_to_s16_altivec
+
+void audio_convert_s16_to_float_altivec(float *out,
+      const int16_t *in, size_t samples);
+
+void audio_convert_float_to_s16_altivec(int16_t *out,
+      const float *in, size_t samples);
+
+#else
+#define audio_convert_s16_to_float audio_convert_s16_to_float_C
+#define audio_convert_float_to_s16 audio_convert_float_to_s16_C
+#endif
+
+void audio_convert_s16_to_float_C(float *out,
+      const int16_t *in, size_t samples);
+void audio_convert_float_to_s16_C(int16_t *out,
+      const float *in, size_t samples);
+
+#endif
+

audio/xaudio-c.cpp

@@ -1,160 +0,0 @@
-/*
-	Simple C interface for XAudio2
-	Author: Hans-Kristian Arntzen
-	License: Public Domain
-*/
-
-// This will currently only compile with MSVC2k10.
-// Should be compilable with some MinGW trickery as well.
-
-#include "xaudio-c.h"
-
-struct xaudio2 : public IXAudio2VoiceCallback
-{
-	xaudio2(unsigned samplerate, unsigned channels, unsigned bits, unsigned size) : 
-		buf(nullptr), pXAudio2(nullptr), pMasterVoice(nullptr), pSourceVoice(nullptr),
-			buffers(0), bufptr(0)
-	{
-		CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-		HRESULT hr;
-		if (FAILED(hr = XAudio2Create(&pXAudio2, 0)))
-			throw -1;
-		if (FAILED(hr = pXAudio2->CreateMasteringVoice(
-			&pMasterVoice, channels, samplerate, 0, 0, nullptr)))
-			throw -1;
-		WAVEFORMATEX wfx;
-		wfx.wFormatTag = WAVE_FORMAT_PCM;
-		wfx.nChannels = channels;
-		wfx.nSamplesPerSec = samplerate;
-		wfx.nBlockAlign = channels * bits / 8;
-		wfx.wBitsPerSample = bits;
-		wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
-		wfx.cbSize = 0;
-		if (FAILED(hr = pXAudio2->CreateSourceVoice(
-			&pSourceVoice, &wfx, XAUDIO2_VOICE_NOSRC, XAUDIO2_DEFAULT_FREQ_RATIO, this, nullptr, nullptr)))
-			throw -1;
-
-		pSourceVoice->Start();
-
-		hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
-		if (!hEvent)
-			throw -1;
-
-		max_buffers = 8;
-		bufsize = size / max_buffers;
-		buf = new uint8_t[bufsize * max_buffers];
-		write_buffer = 0;
-	}
-
-	~xaudio2()
-	{
-		if (pSourceVoice)
-		{
-			pSourceVoice->Stop();
-			pSourceVoice->DestroyVoice();
-		}
-
-		if (pMasterVoice)
-			pMasterVoice->DestroyVoice();
-
-		if (pXAudio2)
-			pXAudio2->Release();
-
-		if (hEvent)
-			CloseHandle(hEvent);
-
-		if (buf)
-			delete[] buf;
-	}
-
-	size_t write_avail() const
-	{
-		return bufsize * (max_buffers - buffers - 1);
-	}
-	
-	size_t write(const void *buffer, size_t bytes)
-	{
-		size_t written = 0;
-		while (written < bytes)
-		{
-			size_t need = min(bytes - written, bufsize - bufptr);
-			memcpy((uint8_t*)buf + write_buffer * bufsize + bufptr, (const uint8_t*)buffer + written, need);
-			written += need;
-			bufptr += need;
-
-			if (bufptr == bufsize)
-			{
-				while (buffers == max_buffers - 1)
-					WaitForSingleObject(hEvent, INFINITE);
-
-				XAUDIO2_BUFFER xa2buffer = {0};
-				xa2buffer.AudioBytes = bufsize;
-				xa2buffer.pAudioData = buf + write_buffer * bufsize;
-				xa2buffer.pContext = nullptr;
-				InterlockedIncrement(&buffers);
-				pSourceVoice->SubmitSourceBuffer(&xa2buffer);
-				bufptr = 0;
-				write_buffer = (write_buffer + 1) % max_buffers;
-			}
-		}
-		return bytes;
-	}
-
-	STDMETHOD_(void, OnBufferStart) (void *) {}
-	STDMETHOD_(void, OnBufferEnd) (void *) 
-	{
-		InterlockedDecrement(&buffers);
-		SetEvent(hEvent);
-	}
-   STDMETHOD_(void, OnLoopEnd) (void *) {}
-   STDMETHOD_(void, OnStreamEnd) () {}
-	STDMETHOD_(void, OnVoiceError) (void *, HRESULT) {}
-	STDMETHOD_(void, OnVoiceProcessingPassEnd) () 
-	{
-		SetEvent(hEvent);
-	}
-	STDMETHOD_(void, OnVoiceProcessingPassStart) (UINT32) {}
-
-	uint8_t *buf;
-	IXAudio2 *pXAudio2;
-	IXAudio2MasteringVoice *pMasterVoice;
-	IXAudio2SourceVoice *pSourceVoice;
-	HANDLE hEvent;
-
-	volatile long buffers;
-	unsigned max_buffers;
-	unsigned bufsize;
-	unsigned bufptr;
-	unsigned write_buffer;
-};
-
-XAUDIOC_API xaudio2_t *xaudio2_new(unsigned samplerate, unsigned channels, unsigned bits, size_t size)
-{
-	xaudio2 *handle = nullptr;
-	try {
-		handle = new xaudio2(samplerate, channels, bits, size);
-	} catch(...) { delete handle; return nullptr; }
-
-	return handle;
-}
-
-XAUDIOC_API size_t xaudio2_write_avail(xaudio2_t *handle)
-{
-	try {
-		return handle->write_avail();
-	} catch(...) { return 0; }
-}
-
-XAUDIOC_API size_t xaudio2_write(xaudio2_t *handle, const void *buf, size_t bytes)
-{
-	try {
-		return handle->write(buf, bytes);
-	} catch(...) { return 0; }
-}
-
-XAUDIOC_API void xaudio2_free(xaudio2_t *handle)
-{
-	delete handle;
-}
-
-

audio/xaudio-c.h

@@ -1,38 +0,0 @@
-/*
-	Simple C interface for XAudio2
-	Author: Hans-Kristian Arntzen
-	License: Public Domain
-*/
-
-#ifndef XAUDIO_C_H
-#define XAUDIO_C_H
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef XAUDIOC_EXPORTS
-#define XAUDIOC_API __declspec(dllexport)
-#else
-#define XAUDIOC_API __declspec(dllimport)
-#endif
-
-typedef struct xaudio2 xaudio2_t;
-
-XAUDIOC_API xaudio2_t* xaudio2_new(unsigned samplerate, unsigned channels, unsigned bits, size_t bufsize);
-XAUDIOC_API size_t xaudio2_write_avail(xaudio2_t *handle);
-XAUDIOC_API size_t xaudio2_write(xaudio2_t *handle, const void *data, size_t bytes);
-XAUDIOC_API void xaudio2_free(xaudio2_t *handle);
-
-typedef xaudio2_t* (*xaudio2_new_t)(unsigned, unsigned, unsigned, size_t);
-typedef size_t (*xaudio2_write_avail_t)(xaudio2_t*);
-typedef size_t (*xaudio2_write_t)(xaudio2_t*, const void*, size_t);
-typedef void (*xaudio2_free_t)(xaudio2_t*);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

audio/xaudio-c/xaudio-c.c

@@ -0,0 +1,162 @@
+/*
+	Simple C interface for XAudio2
+	Author: Hans-Kristian Arntzen
+	License: Public Domain
+*/
+
+#include "xaudio-c.h"
+#include "xaudio.h"
+#include <stdint.h>
+
+#define MAX_BUFFERS 16
+#define MAX_BUFFERS_MASK (MAX_BUFFERS - 1)
+
+struct xaudio2
+{
+   const IXAudio2VoiceCallbackVtbl *lpVtbl;
+
+   uint8_t *buf;
+   IXAudio2 *pXAudio2;
+   IXAudio2MasteringVoice *pMasterVoice;
+   IXAudio2SourceVoice *pSourceVoice;
+   HANDLE hEvent;
+
+   volatile long buffers;
+   unsigned bufsize;
+   unsigned bufptr;
+   unsigned write_buffer;
+};
+
+static void WINAPI voice_on_buffer_end(void *handle_, void *data)
+{
+   (void)data;
+   xaudio2_t *handle = handle_;
+   InterlockedDecrement(&handle->buffers);
+   SetEvent(handle->hEvent);
+}
+
+static void WINAPI dummy_voidp(void *handle, void *data) { (void)handle; (void)data; }
+static void WINAPI dummy_nil(void *handle) { (void)handle; }
+static void WINAPI dummy_uint32(void *handle, UINT32 dummy) { (void)handle; (void)dummy; }
+static void WINAPI dummy_voidp_hresult(void *handle, void *data, HRESULT dummy) { (void)handle; (void)data; (void)dummy; }
+
+const struct IXAudio2VoiceCallbackVtbl voice_vtable = {
+   .OnBufferStart = dummy_voidp,
+   .OnBufferEnd = voice_on_buffer_end,
+   .OnLoopEnd = dummy_voidp,
+   .OnVoiceProcessingPassEnd = dummy_nil,
+   .OnVoiceProcessingPassStart = dummy_uint32,
+   .OnVoiceError = dummy_voidp_hresult,
+   .OnStreamEnd = dummy_nil,
+};
+   
+xaudio2_t *xaudio2_new(unsigned samplerate, unsigned channels, size_t size)
+{
+   xaudio2_t *handle = calloc(1, sizeof(*handle));
+   if (!handle)
+      return NULL;
+
+   handle->lpVtbl = &voice_vtable;
+   CoInitializeEx(0, COINIT_MULTITHREADED);
+   if (FAILED(XAudio2Create(&handle->pXAudio2)))
+      goto error;
+   if (FAILED(IXAudio2_CreateMasteringVoice(handle->pXAudio2,
+               &handle->pMasterVoice, channels, samplerate, 0, 0, 0)))
+      goto error;
+
+   WAVEFORMATEX wfx;
+   wfx.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
+   wfx.nChannels = channels;
+   wfx.nSamplesPerSec = samplerate;
+   wfx.nBlockAlign = channels * sizeof(float);
+   wfx.wBitsPerSample = sizeof(float) * 8;
+   wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
+   wfx.cbSize = 0;
+   if (FAILED(IXAudio2_CreateSourceVoice(handle->pXAudio2,
+               &handle->pSourceVoice, &wfx,
+               XAUDIO2_VOICE_NOSRC, XAUDIO2_DEFAULT_FREQ_RATIO,
+               (IXAudio2VoiceCallback*)handle, 0, 0)))
+      goto error;
+
+   handle->hEvent = CreateEvent(0, FALSE, FALSE, 0);
+   if (!handle->hEvent)
+      goto error;
+
+   IXAudio2SourceVoice_Start(handle->pSourceVoice, 0, XAUDIO2_COMMIT_NOW);
+
+   handle->bufsize = size / MAX_BUFFERS;
+   handle->buf = calloc(1, handle->bufsize * MAX_BUFFERS);
+   if (!handle->buf)
+      goto error;
+
+   return handle;
+
+error:
+   xaudio2_free(handle);
+   return NULL;
+}
+
+size_t xaudio2_write_avail(xaudio2_t *handle)
+{
+   return handle->bufsize * (MAX_BUFFERS - handle->buffers - 1);
+}
+
+size_t xaudio2_write(xaudio2_t *handle, const void *buf, size_t bytes_)
+{
+   unsigned bytes = bytes_;
+   const uint8_t *buffer = buf;
+   while (bytes)
+   {
+      unsigned need = min(bytes, handle->bufsize - handle->bufptr);
+      memcpy(handle->buf + handle->write_buffer * handle->bufsize + handle->bufptr,
+            buffer, need);
+
+      handle->bufptr += need;
+      buffer += need;
+      bytes -= need;
+
+      if (handle->bufptr == handle->bufsize)
+      {
+         while (handle->buffers == MAX_BUFFERS - 1)
+            WaitForSingleObject(handle->hEvent, INFINITE);
+
+         XAUDIO2_BUFFER xa2buffer = {
+            .AudioBytes = handle->bufsize,
+            .pAudioData = handle->buf + handle->write_buffer * handle->bufsize,
+         };
+         if (FAILED(IXAudio2SourceVoice_SubmitSourceBuffer(handle->pSourceVoice, &xa2buffer, NULL)))
+            return 0;
+
+         InterlockedIncrement(&handle->buffers);
+         handle->bufptr = 0;
+         handle->write_buffer = (handle->write_buffer + 1) & MAX_BUFFERS_MASK;
+      }
+   }
+
+   return bytes_;
+}
+
+void xaudio2_free(xaudio2_t *handle)
+{
+   if (handle)
+   {
+      if (handle->pSourceVoice)
+      {
+         IXAudio2SourceVoice_Stop(handle->pSourceVoice, 0, XAUDIO2_COMMIT_NOW);
+         IXAudio2SourceVoice_DestroyVoice(handle->pSourceVoice);
+      }
+
+      if (handle->pMasterVoice)
+         IXAudio2MasteringVoice_DestroyVoice(handle->pMasterVoice);
+
+      if (handle->pXAudio2)
+         IXAudio2_Release(handle->pXAudio2);
+
+      if (handle->hEvent)
+         CloseHandle(handle->hEvent);
+
+      free(handle->buf);
+      free(handle);
+   }
+}
+

audio/xaudio-c/xaudio-c.h

@@ -0,0 +1,27 @@
+/*
+   Simple C interface for XAudio2
+   Author: Hans-Kristian Arntzen
+   License: Public Domain
+*/
+
+#ifndef XAUDIO_C_H
+#define XAUDIO_C_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct xaudio2 xaudio2_t;
+
+xaudio2_t* xaudio2_new(unsigned samplerate, unsigned channels, size_t bufsize);
+size_t xaudio2_write_avail(xaudio2_t *handle);
+size_t xaudio2_write(xaudio2_t *handle, const void *data, size_t bytes);
+void xaudio2_free(xaudio2_t *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

audio/xaudio-c/xaudio.h

@@ -0,0 +1,222 @@
+/*
+   xaudio.h (2010-08-14) / (2011-12-04)
+   authors: OV2, Themaister
+*/
+
+// Kinda stripped down. Only contains the bare essentials used in SSNES.
+
+#ifndef XAUDIO2_MINGW_H
+#define XAUDIO2_MINGW_H
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <basetyps.h>
+#include <objbase.h>
+#include <mmreg.h>
+
+#define DEFINE_GUID_X(n, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+   static const GUID n = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#define DEFINE_CLSID_X(className, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+   DEFINE_GUID_X(CLSID_##className, 0x##l, 0x##w1, 0x##w2, 0x##b1, 0x##b2, 0x##b3, 0x##b4, 0x##b5, 0x##b6, 0x##b7, 0x##b8)
+#define DEFINE_IID_X(interfaceName, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+   DEFINE_GUID_X(IID_##interfaceName, 0x##l, 0x##w1, 0x##w2, 0x##b1, 0x##b2, 0x##b3, 0x##b4, 0x##b5, 0x##b6, 0x##b7, 0x##b8)
+#define X2DEFAULT(x)
+
+DEFINE_CLSID_X(XAudio2, e21a7345, eb21, 468e, be, 50, 80, 4d, b9, 7c, f7, 08);
+DEFINE_IID_X(IXAudio2, 8bcf1f58, 9fe7, 4583, 8a, c6, e2, ad, c4, 65, c8, bb);
+
+#ifndef INTERFACE
+#define INTERFACE void
+#endif
+
+#define XAUDIO2_COMMIT_NOW              0
+#define XAUDIO2_DEFAULT_CHANNELS        0
+#define XAUDIO2_DEFAULT_SAMPLERATE      0
+#define XAUDIO2_DEFAULT_FREQ_RATIO      4.0f
+#define XAUDIO2_DEBUG_ENGINE            0x0001
+#define XAUDIO2_VOICE_NOSRC             0x0004
+
+typedef enum XAUDIO2_DEVICE_ROLE
+{
+   NotDefaultDevice            = 0x0,
+   DefaultConsoleDevice        = 0x1,
+   DefaultMultimediaDevice     = 0x2,
+   DefaultCommunicationsDevice = 0x4,
+   DefaultGameDevice           = 0x8,
+   GlobalDefaultDevice         = 0xf,
+   InvalidDeviceRole           = ~GlobalDefaultDevice
+} XAUDIO2_DEVICE_ROLE;
+
+typedef enum XAUDIO2_WINDOWS_PROCESSOR_SPECIFIER
+{
+   XAUDIO2_ANY_PROCESSOR       = 0xffffffff,
+   XAUDIO2_DEFAULT_PROCESSOR   = XAUDIO2_ANY_PROCESSOR
+} XAUDIO2_WINDOWS_PROCESSOR_SPECIFIER, XAUDIO2_PROCESSOR;
+
+typedef enum XAUDIO2_FILTER_TYPE {
+   LowPassFilter,
+   BandPassFilter,
+   HighPassFilter 
+} XAUDIO2_FILTER_TYPE;
+
+typedef struct XAUDIO2_DEVICE_DETAILS XAUDIO2_DEVICE_DETAILS;
+typedef struct XAUDIO2_VOICE_DETAILS XAUDIO2_VOICE_DETAILS;
+typedef struct XAUDIO2_VOICE_SENDS XAUDIO2_VOICE_SENDS;
+typedef struct XAUDIO2_EFFECT_DESCRIPTOR XAUDIO2_EFFECT_DESCRIPTOR;
+typedef struct XAUDIO2_EFFECT_CHAIN XAUDIO2_EFFECT_CHAIN;
+typedef struct XAUDIO2_FILTER_PARAMETERS XAUDIO2_FILTER_PARAMETERS;
+typedef struct XAUDIO2_BUFFER_WMA XAUDIO2_BUFFER_WMA;
+typedef struct XAUDIO2_VOICE_STATE XAUDIO2_VOICE_STATE;
+typedef struct XAUDIO2_PERFORMANCE_DATA XAUDIO2_PERFORMANCE_DATA;
+typedef struct XAUDIO2_DEBUG_CONFIGURATION XAUDIO2_DEBUG_CONFIGURATION;
+typedef struct IXAudio2EngineCallback IXAudio2EngineCallback;
+typedef struct IXAudio2SubmixVoice IXAudio2SubmixVoice;
+
+typedef struct XAUDIO2_BUFFER
+{
+   UINT32 Flags;
+   UINT32 AudioBytes;
+   const BYTE* pAudioData;
+   UINT32 PlayBegin;
+   UINT32 PlayLength;
+   UINT32 LoopBegin;
+   UINT32 LoopLength;
+   UINT32 LoopCount;
+   void *pContext;
+} XAUDIO2_BUFFER;
+
+DECLARE_INTERFACE(IXAudio2VoiceCallback)
+{
+   STDMETHOD_(void, OnVoiceProcessingPassStart) (THIS_ UINT32 BytesRequired) PURE;
+   STDMETHOD_(void, OnVoiceProcessingPassEnd) (THIS) PURE;
+   STDMETHOD_(void, OnStreamEnd) (THIS) PURE;
+   STDMETHOD_(void, OnBufferStart) (THIS_ void *pBufferContext) PURE;
+   STDMETHOD_(void, OnBufferEnd) (THIS_ void *pBufferContext) PURE;
+   STDMETHOD_(void, OnLoopEnd) (THIS_ void *pBufferContext) PURE;
+   STDMETHOD_(void, OnVoiceError) (THIS_ void *pBufferContext, HRESULT Error) PURE;
+};
+
+DECLARE_INTERFACE(IXAudio2Voice)
+{
+#define Declare_IXAudio2Voice_Methods() \
+   STDMETHOD_(void, GetVoiceDetails) (THIS_ XAUDIO2_VOICE_DETAILS* pVoiceDetails) PURE; \
+   STDMETHOD(SetOutputVoices) (THIS_ const XAUDIO2_VOICE_SENDS* pSendList) PURE; \
+   STDMETHOD(SetEffectChain) (THIS_ const XAUDIO2_EFFECT_CHAIN* pEffectChain) PURE; \
+   STDMETHOD(EnableEffect) (THIS_ UINT32 EffectIndex, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD(DisableEffect) (THIS_ UINT32 EffectIndex, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD_(void, GetEffectState) (THIS_ UINT32 EffectIndex, BOOL* pEnabled) PURE; \
+   STDMETHOD(SetEffectParameters) (THIS_ UINT32 EffectIndex, \
+         const void *pParameters, \
+         UINT32 ParametersByteSize, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD(GetEffectParameters) (THIS_ UINT32 EffectIndex, void *pParameters, \
+         UINT32 ParametersByteSize) PURE; \
+   STDMETHOD(SetFilterParameters) (THIS_ const XAUDIO2_FILTER_PARAMETERS* pParameters, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD_(void, GetFilterParameters) (THIS_ XAUDIO2_FILTER_PARAMETERS* pParameters) PURE; \
+   STDMETHOD(SetVolume) (THIS_ float Volume, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD_(void, GetVolume) (THIS_ float* pVolume) PURE; \
+   STDMETHOD(SetChannelVolumes) (THIS_ UINT32 Channels, const float* pVolumes, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD_(void, GetChannelVolumes) (THIS_ UINT32 Channels, float* pVolumes) PURE; \
+   STDMETHOD(SetOutputMatrix) (THIS_ IXAudio2Voice* pDestinationVoice, \
+         UINT32 SourceChannels, UINT32 DestinationChannels, \
+         const float* pLevelMatrix, \
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
+   STDMETHOD_(void, GetOutputMatrix) (THIS_ IXAudio2Voice* pDestinationVoice, \
+         UINT32 SourceChannels, UINT32 DestinationChannels, \
+         float* pLevelMatrix) PURE; \
+   STDMETHOD_(void, DestroyVoice) (THIS) PURE
+
+   Declare_IXAudio2Voice_Methods();
+};
+
+DECLARE_INTERFACE_(IXAudio2MasteringVoice, IXAudio2Voice)
+{
+   Declare_IXAudio2Voice_Methods();
+};
+
+DECLARE_INTERFACE_(IXAudio2SourceVoice, IXAudio2Voice)
+{
+   Declare_IXAudio2Voice_Methods();
+   STDMETHOD(Start) (THIS_ UINT32 Flags, UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE;
+   STDMETHOD(Stop) (THIS_ UINT32 Flags, UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE;
+   STDMETHOD(SubmitSourceBuffer) (THIS_ const XAUDIO2_BUFFER* pBuffer, const XAUDIO2_BUFFER_WMA* pBufferWMA X2DEFAULT(NULL)) PURE;
+   STDMETHOD(FlushSourceBuffers) (THIS) PURE;
+   STDMETHOD(Discontinuity) (THIS) PURE;
+   STDMETHOD(ExitLoop) (THIS_ UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE;
+   STDMETHOD_(void, GetState) (THIS_ XAUDIO2_VOICE_STATE* pVoiceState) PURE;
+   STDMETHOD(SetFrequencyRatio) (THIS_ float Ratio,
+         UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE;
+   STDMETHOD_(void, GetFrequencyRatio) (THIS_ float* pRatio) PURE;
+};
+
+DECLARE_INTERFACE_(IXAudio2, IUnknown)
+{
+   STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvInterface) PURE;
+   STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+   STDMETHOD_(ULONG, Release) (THIS) PURE;
+   STDMETHOD(GetDeviceCount) (THIS_ UINT32* pCount) PURE;
+   STDMETHOD(GetDeviceDetails) (THIS_ UINT32 Index, XAUDIO2_DEVICE_DETAILS* pDeviceDetails) PURE;
+   STDMETHOD(Initialize) (THIS_ UINT32 Flags X2DEFAULT(0),
+         XAUDIO2_PROCESSOR XAudio2Processor X2DEFAULT(XAUDIO2_DEFAULT_PROCESSOR)) PURE;
+   STDMETHOD(RegisterForCallbacks) (IXAudio2EngineCallback* pCallback) PURE;
+   STDMETHOD_(void, UnregisterForCallbacks) (IXAudio2EngineCallback* pCallback) PURE;
+   STDMETHOD(CreateSourceVoice) (THIS_ IXAudio2SourceVoice** ppSourceVoice,
+         const WAVEFORMATEX* pSourceFormat,
+         UINT32 Flags X2DEFAULT(0),
+         float MaxFrequencyRatio X2DEFAULT(XAUDIO2_DEFAULT_FREQ_RATIO),
+         IXAudio2VoiceCallback* pCallback X2DEFAULT(NULL),
+         const XAUDIO2_VOICE_SENDS* pSendList X2DEFAULT(NULL),
+         const XAUDIO2_EFFECT_CHAIN* pEffectChain X2DEFAULT(NULL)) PURE;
+   STDMETHOD(CreateSubmixVoice) (THIS_ IXAudio2SubmixVoice** ppSubmixVoice,
+         UINT32 InputChannels, UINT32 InputSampleRate,
+         UINT32 Flags X2DEFAULT(0), UINT32 ProcessingStage X2DEFAULT(0),
+         const XAUDIO2_VOICE_SENDS* pSendList X2DEFAULT(NULL),
+         const XAUDIO2_EFFECT_CHAIN* pEffectChain X2DEFAULT(NULL)) PURE;
+   STDMETHOD(CreateMasteringVoice) (THIS_ IXAudio2MasteringVoice** ppMasteringVoice,
+         UINT32 InputChannels X2DEFAULT(XAUDIO2_DEFAULT_CHANNELS),
+         UINT32 InputSampleRate X2DEFAULT(XAUDIO2_DEFAULT_SAMPLERATE),
+         UINT32 Flags X2DEFAULT(0), UINT32 DeviceIndex X2DEFAULT(0),
+         const XAUDIO2_EFFECT_CHAIN* pEffectChain X2DEFAULT(NULL)) PURE;
+   STDMETHOD(StartEngine) (THIS) PURE;
+   STDMETHOD_(void, StopEngine) (THIS) PURE;
+   STDMETHOD(CommitChanges) (THIS_ UINT32 OperationSet) PURE;
+   STDMETHOD_(void, GetPerformanceData) (THIS_ XAUDIO2_PERFORMANCE_DATA* pPerfData) PURE;
+   STDMETHOD_(void, SetDebugConfiguration) (THIS_ const XAUDIO2_DEBUG_CONFIGURATION* pDebugConfiguration,
+         void *pReserved X2DEFAULT(NULL)) PURE;
+};
+
+// C hooks.
+#define IXAudio2_Initialize(THIS, a, b) (THIS)->lpVtbl->Initialize(THIS, a, b)
+#define IXAudio2_Release(THIS) (THIS)->lpVtbl->Release(THIS)
+#define IXAudio2_CreateSourceVoice(THIS, a, b, c, d, e, f, g) (THIS)->lpVtbl->CreateSourceVoice(THIS, a, b, c, d, e, f, g)
+#define IXAudio2_CreateMasteringVoice(THIS, a, b, c, d, e, f) (THIS)->lpVtbl->CreateMasteringVoice(THIS, a, b, c, d, e, f)
+
+#define IXAudio2SourceVoice_Start(THIS, a, b) (THIS)->lpVtbl->Start(THIS, a, b)
+#define IXAudio2SourceVoice_Stop(THIS, a, b) (THIS)->lpVtbl->Stop(THIS, a, b)
+#define IXAudio2SourceVoice_SubmitSourceBuffer(THIS, a, b) (THIS)->lpVtbl->SubmitSourceBuffer(THIS, a, b)
+#define IXAudio2SourceVoice_DestroyVoice(THIS) (THIS)->lpVtbl->DestroyVoice(THIS)
+#define IXAudio2MasteringVoice_DestroyVoice(THIS) (THIS)->lpVtbl->DestroyVoice(THIS)
+
+static inline HRESULT XAudio2Create(IXAudio2 **ppXAudio2)
+{
+   IXAudio2 *pXAudio2;
+   HRESULT hr = CoCreateInstance(&CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, &IID_IXAudio2, (void**)&pXAudio2);
+
+   if (SUCCEEDED(hr))
+   {
+      hr = IXAudio2_Initialize(pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR);
+      if (SUCCEEDED(hr))
+         *ppXAudio2 = pXAudio2;
+      else
+         IXAudio2_Release(pXAudio2);
+   }
+   return hr;
+}
+
+#endif
+

audio/xaudio.c

@@ -15,73 +15,31 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "driver.h"
 #include <stdlib.h>
-#include "xaudio-c.h"
+#include "xaudio-c/xaudio-c.h"
 #include "general.h"
 
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
 typedef struct
 {
    xaudio2_t *xa;
    bool nonblock;
 } xa_t;
 
-static xaudio2_new_t pxanew = NULL;
-static xaudio2_write_t pxawrite = NULL;
-static xaudio2_write_avail_t pxawrite_avail = NULL;
-static xaudio2_free_t pxafree = NULL;
-static HMODULE lib = NULL;
-
-#define LIB_NAME "xaudio-c.dll"
-#define SYM(X) ((void*)GetProcAddress(lib, "xaudio2_" #X))
-
-static void deinit_lib(void)
+static void *xa_init(const char *device, unsigned rate, unsigned latency)
 {
-   FreeModule(lib);
-   lib = NULL;
-}
-
-static bool init_lib(void)
-{
-   if (lib)
-      return true;
-
-   lib = LoadLibrary(LIB_NAME);
-   if (!lib)
-      return false;
-
-   pxanew = SYM(new);
-   pxawrite = SYM(write);
-   pxawrite_avail = SYM(write_avail);
-   pxafree = SYM(free);
-
-   if (!pxanew || !pxawrite || !pxawrite_avail || !pxafree)
-   {
-      deinit_lib();
-      return false;
-   }
-   return true;
-}
-
-static void* __xa_init(const char* device, int rate, int latency)
-{
-   if (!init_lib())
-      return NULL;
+   if (latency < 8)
+      latency = 8; // Do not allow shenanigans.
 
    xa_t *xa = calloc(1, sizeof(xa_t));
    if (xa == NULL)
       return NULL;
 
    size_t bufsize = latency * rate / 1000;
-   bufsize = next_pow2(bufsize);
 
    SSNES_LOG("XAudio2: Requesting %d ms latency, using %d ms latency.\n", latency, (int)bufsize * 1000 / rate);
 
-   xa->xa = pxanew(rate, 2, 16, bufsize << 2);
+   xa->xa = xaudio2_new(rate, 2, bufsize * 2 * sizeof(float));
    if (!xa->xa)
    {
       SSNES_ERR("Failed to init XAudio2.\n");
@@ -91,60 +49,66 @@ static void* __xa_init(const char* device, int rate, int latency)
    return xa;
 }
 
-static ssize_t __xa_write(void* data, const void* buf, size_t size)
+static ssize_t xa_write(void *data, const void *buf, size_t size)
 {
    xa_t *xa = data;
    if (xa->nonblock)
    {
-      size_t avail = pxawrite_avail(xa->xa);
+      size_t avail = xaudio2_write_avail(xa->xa);
+      if (avail == 0)
+         return 0;
       if (avail < size)
          size = avail;
    }
-   return pxawrite(xa->xa, buf, size);
+   size_t ret = xaudio2_write(xa->xa, buf, size);
+   if (ret == 0)
+      return -1;
+   return ret;
 }
 
-static bool __xa_stop(void *data)
+static bool xa_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_set_nonblock_state(void *data, bool state)
+static void xa_set_nonblock_state(void *data, bool state)
 {
    xa_t *xa = data;
    xa->nonblock = state;
 }
 
-static bool __xa_start(void *data)
+static bool xa_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_free(void *data)
+static bool xa_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static void xa_free(void *data)
 {
    xa_t *xa = data;
-   if (xa && xa->xa)
+   if (xa)
    {
-      if (pxafree)
-         pxafree(xa->xa);
+      if (xa->xa)
+         xaudio2_free(xa->xa);
       free(xa);
    }
-   deinit_lib();
 }
 
 const audio_driver_t audio_xa = {
-   .init = __xa_init,
-   .write = __xa_write,
-   .stop = __xa_stop,
-   .start = __xa_start,
-   .set_nonblock_state = __xa_set_nonblock_state,
-   .free = __xa_free,
+   .init = xa_init,
+   .write = xa_write,
+   .stop = xa_stop,
+   .start = xa_start,
+   .set_nonblock_state = xa_set_nonblock_state,
+   .use_float = xa_use_float,
+   .free = xa_free,
    .ident = "xaudio"
 };
-
-   
-
-
-   
    

autosave.c

@@ -16,7 +16,7 @@
  */
 
 #include "autosave.h"
-#include "SDL.h"
+#include "thread.h"
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
@@ -26,11 +26,11 @@
 struct autosave
 {
    volatile bool quit;
-   SDL_mutex *lock;
+   slock_t *lock;
 
-   SDL_mutex *cond_lock;
-   SDL_cond *cond;
-   SDL_Thread *thread;
+   slock_t *cond_lock;
+   scond_t *cond;
+   sthread_t *thread;
 
    void *buffer;
    const void *snes_buffer;
@@ -39,35 +39,49 @@ struct autosave
    unsigned interval;
 };
 
-static int autosave_thread(void *data)
+static void autosave_thread(void *data)
 {
    autosave_t *save = data;
+
+   bool first_log = true;
+
    while (!save->quit)
    {
       autosave_lock(save);
-      memcpy(save->buffer, save->snes_buffer, save->bufsize);
+      bool differ = memcmp(save->buffer, save->snes_buffer, save->bufsize) != 0;
+      if (differ)
+         memcpy(save->buffer, save->snes_buffer, save->bufsize);
       autosave_unlock(save);
 
-      // Should probably deal with this more elegantly.
-      FILE *file = fopen(save->path, "wb");
-      if (file)
+      if (differ)
       {
-         SSNES_LOG("Autosaving SRAM to \"%s\"\n", save->path);
-         bool failed = false;
-         failed |= fwrite(save->buffer, 1, save->bufsize, file) != save->bufsize;
-         failed |= fflush(file) != 0;
-         failed |= fclose(file) != 0;
-         if (failed)
-            SSNES_WARN("Failed to autosave SRAM! Disk might be full.\n");
+         // Should probably deal with this more elegantly.
+         FILE *file = fopen(save->path, "wb");
+         if (file)
+         {
+            // Avoid spamming down stderr ... :)
+            if (first_log)
+            {
+               SSNES_LOG("Autosaving SRAM to \"%s\", will continue to check every %u seconds ...\n", save->path, save->interval);
+               first_log = false;
+            }
+            else
+               SSNES_LOG("SRAM changed ... autosaving ...\n");
+
+            bool failed = false;
+            failed |= fwrite(save->buffer, 1, save->bufsize, file) != save->bufsize;
+            failed |= fflush(file) != 0;
+            failed |= fclose(file) != 0;
+            if (failed)
+               SSNES_WARN("Failed to autosave SRAM! Disk might be full.\n");
+         }
       }
 
-      SDL_mutexP(save->cond_lock);
+      slock_lock(save->cond_lock);
       if (!save->quit)
-         SDL_CondWaitTimeout(save->cond, save->cond_lock, save->interval * 1000);
-      SDL_mutexV(save->cond_lock);
+         scond_wait_timeout(save->cond, save->cond_lock, save->interval * 1000);
+      slock_unlock(save->cond_lock);
    }
-
-   return 0;
 }
 
 autosave_t *autosave_new(const char *path, const void *data, size_t size, unsigned interval)
@@ -87,37 +101,38 @@ autosave_t *autosave_new(const char *path, const void *data, size_t size, unsign
       free(handle);
       return NULL;
    }
+   memcpy(handle->buffer, handle->snes_buffer, handle->bufsize);
 
-   handle->lock = SDL_CreateMutex();
-   handle->cond_lock = SDL_CreateMutex();
-   handle->cond = SDL_CreateCond();
+   handle->lock = slock_new();
+   handle->cond_lock = slock_new();
+   handle->cond = scond_new();
 
-   handle->thread = SDL_CreateThread(autosave_thread, handle);
+   handle->thread = sthread_create(autosave_thread, handle);
 
    return handle;
 }
 
 void autosave_lock(autosave_t *handle)
 {
-   SDL_mutexP(handle->lock);
+   slock_lock(handle->lock);
 }
 
 void autosave_unlock(autosave_t *handle)
 {
-   SDL_mutexV(handle->lock);
+   slock_unlock(handle->lock);
 }
 
 void autosave_free(autosave_t *handle)
 {
-   SDL_mutexP(handle->cond_lock);
+   slock_lock(handle->cond_lock);
    handle->quit = true;
-   SDL_mutexV(handle->cond_lock);
-   SDL_CondSignal(handle->cond);
-   SDL_WaitThread(handle->thread, NULL);
+   slock_unlock(handle->cond_lock);
+   scond_signal(handle->cond);
+   sthread_join(handle->thread);
 
-   SDL_DestroyMutex(handle->lock);
-   SDL_DestroyMutex(handle->cond_lock);
-   SDL_DestroyCond(handle->cond);
+   slock_free(handle->lock);
+   slock_free(handle->cond_lock);
+   scond_free(handle->cond);
 
    free(handle->buffer);
    free(handle);

bps.c

@@ -0,0 +1,175 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "bps.h"
+#include "movie.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+enum bps_mode
+{
+   SOURCE_READ = 0,
+   TARGET_READ,
+   SOURCE_COPY,
+   TARGET_COPY
+};
+
+struct bps_data
+{
+   const uint8_t *modify_data, *source_data; 
+   uint8_t *target_data;
+   size_t modify_length, source_length, target_length;
+   size_t modify_offset, source_offset, target_offset;
+   uint32_t modify_checksum, source_checksum, target_checksum;
+
+   size_t source_relative_offset, target_relative_offset, output_offset;
+};
+
+static uint8_t bps_read(struct bps_data *bps)
+{
+   uint8_t data = bps->modify_data[bps->modify_offset++];
+   bps->modify_checksum = crc32_adjust(bps->modify_checksum, data);
+   return data;
+}
+
+static uint64_t bps_decode(struct bps_data *bps)
+{
+   uint64_t data = 0, shift = 1;
+
+   for (;;)
+   {
+      uint8_t x = bps_read(bps);
+      data += (x & 0x7f) * shift;
+      if (x & 0x80)
+         break;
+      shift <<= 7;
+      data += shift;
+   }
+
+   return data;
+}
+
+static void bps_write(struct bps_data *bps, uint8_t data)
+{
+   bps->target_data[bps->output_offset++] = data;
+   bps->target_checksum = crc32_adjust(bps->target_checksum, data);
+}
+
+bps_error_t bps_apply_patch(
+      const uint8_t *modify_data, size_t modify_length,
+      const uint8_t *source_data, size_t source_length,
+      uint8_t *target_data, size_t *target_length)
+{
+   if (modify_length < 19)
+      return BPS_PATCH_TOO_SMALL;
+
+   struct bps_data bps = {
+      .modify_data = modify_data,
+      .modify_length = modify_length,
+      .target_data = target_data,
+      .target_length = *target_length,
+      .source_data = source_data,
+      .source_length = source_length,
+
+      .modify_checksum = ~0,
+      .target_checksum = ~0,
+   };
+
+   if ((bps_read(&bps) != 'B') || (bps_read(&bps) != 'P') || (bps_read(&bps) != 'S') || (bps_read(&bps) != '1'))
+      return BPS_PATCH_INVALID_HEADER;
+
+   size_t modify_source_size = bps_decode(&bps);
+   size_t modify_target_size = bps_decode(&bps);
+   size_t modify_markup_size = bps_decode(&bps);
+   for (size_t i = 0; i < modify_markup_size; i++)
+      bps_read(&bps);
+
+   if (modify_source_size > bps.source_length)
+      return BPS_SOURCE_TOO_SMALL;
+   if (modify_target_size > bps.target_length)
+      return BPS_TARGET_TOO_SMALL;
+
+   while (bps.modify_offset < bps.modify_length - 12)
+   {
+      size_t length = bps_decode(&bps);
+      unsigned mode = length & 3;
+      length = (length >> 2) + 1;
+
+      switch (mode)
+      {
+         case SOURCE_READ:
+            while (length--)
+               bps_write(&bps, bps.source_data[bps.output_offset]);
+            break;
+
+         case TARGET_READ:
+            while (length--)
+               bps_write(&bps, bps_read(&bps));
+            break;
+
+         case SOURCE_COPY:
+         case TARGET_COPY:
+         {
+            int offset = bps_decode(&bps);
+            bool negative = offset & 1;
+            offset >>= 1;
+            if (negative)
+               offset = -offset;
+
+            if (mode == SOURCE_COPY)
+            {
+               bps.source_offset += offset;
+               while (length--)
+                  bps_write(&bps, bps.source_data[bps.source_offset++]);
+            }
+            else
+            {
+               bps.target_offset += offset;
+               while (length--)
+                  bps_write(&bps, bps.target_data[bps.target_offset++]);
+               break;
+            }
+            break;
+         }
+      }
+   }
+
+   uint32_t modify_source_checksum = 0, modify_target_checksum = 0, modify_modify_checksum = 0;
+   for (unsigned i = 0; i < 32; i += 8)
+      modify_source_checksum |= bps_read(&bps) << i;
+   for (unsigned i = 0; i < 32; i += 8)
+      modify_target_checksum |= bps_read(&bps) << i;
+
+   uint32_t checksum = ~bps.modify_checksum;
+   for (unsigned i = 0; i < 32; i += 8)
+      modify_modify_checksum |= bps_read(&bps) << i;
+
+   bps.source_checksum = crc32_calculate(bps.source_data, bps.source_length);
+   bps.target_checksum = ~bps.target_checksum;
+
+   if (bps.source_checksum != modify_source_checksum)
+      return BPS_SOURCE_CHECKSUM_INVALID;
+   if (bps.target_checksum != modify_target_checksum)
+      return BPS_TARGET_CHECKSUM_INVALID;
+   if (checksum != modify_modify_checksum)
+      return BPS_PATCH_CHECKSUM_INVALID;
+
+   *target_length = modify_target_size;
+
+   return BPS_SUCCESS;
+}
+

bps.h

@@ -0,0 +1,45 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BPS_H
+#define __BPS_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+// BPS implementation from bSNES (nall::).
+
+typedef enum bps_error
+{
+   BPS_UNKNOWN,
+   BPS_SUCCESS,
+   BPS_PATCH_TOO_SMALL,
+   BPS_PATCH_INVALID_HEADER,
+   BPS_SOURCE_TOO_SMALL,
+   BPS_TARGET_TOO_SMALL,
+   BPS_SOURCE_CHECKSUM_INVALID,
+   BPS_TARGET_CHECKSUM_INVALID,
+   BPS_PATCH_CHECKSUM_INVALID
+} bps_error_t;
+
+bps_error_t bps_apply_patch(
+      const uint8_t *patch_data, size_t patch_length,
+      const uint8_t *source_data, size_t source_length,
+      uint8_t *target_data, size_t *target_length);
+
+#endif
+

cheats.c

@@ -0,0 +1,388 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cheats.h"
+#include "sha256.h"
+#include "dynamic.h"
+#include "general.h"
+#include "strl.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_CONFIGFILE
+#include "conf/config_file.h"
+#endif
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+struct cheat
+{
+   char *desc;
+   bool state;
+   char *code;
+};
+
+struct cheat_manager
+{
+   struct cheat *cheats;
+   unsigned ptr;
+   unsigned size;
+   unsigned buf_size;
+};
+
+static char *strcat_alloc(char *dest, const char *input)
+{
+   size_t dest_len = dest ? strlen(dest) : 0;
+   size_t input_len = strlen(input);
+   size_t required_len = dest_len + input_len + 1;
+
+   char *output = realloc(dest, required_len);
+   if (!output)
+      return NULL;
+
+   if (dest)
+      strlcat(output, input, required_len);
+   else
+      strlcpy(output, input, required_len);
+
+   return output;
+}
+
+static bool xml_grab_cheat(struct cheat *cht, xmlNodePtr ptr)
+{
+   if (!ptr)
+      return false;
+
+   memset(cht, 0, sizeof(struct cheat));
+   bool first = true;
+
+   for (; ptr; ptr = ptr->next)
+   {
+      if (strcmp((const char*)ptr->name, "description") == 0)
+      {
+         cht->desc = (char*)xmlNodeGetContent(ptr);
+      }
+      else if (strcmp((const char*)ptr->name, "code") == 0)
+      {
+         if (!first)
+         {
+            cht->code = strcat_alloc(cht->code, "+");
+            if (!cht->code)
+               return false;
+         }
+
+         xmlChar *code = xmlNodeGetContent(ptr);
+         if (!code)
+            return false;
+
+         cht->code = strcat_alloc(cht->code, (const char*)code);
+         xmlFree(code);
+         if (!cht->code)
+            return false;
+
+         first = false;
+      }
+   }
+
+   return true;
+}
+
+static bool xml_grab_cheats(cheat_manager_t *handle, xmlNodePtr ptr)
+{
+   for (; ptr; ptr = ptr->next)
+   {
+      if (strcmp((const char*)ptr->name, "name") == 0)
+      {
+         xmlChar *name = xmlNodeGetContent(ptr);
+         if (name)
+         {
+            SSNES_LOG("Found cheat for game: \"%s\"\n", name);
+            xmlFree(name);
+         }
+      }
+      else if (strcmp((const char*)ptr->name, "cheat") == 0)
+      {
+         if (handle->size == handle->buf_size)
+         {
+            handle->buf_size *= 2;
+            handle->cheats = realloc(handle->cheats, handle->buf_size * sizeof(struct cheat));
+            if (!handle->cheats)
+               return false;
+         }
+
+         if (xml_grab_cheat(&handle->cheats[handle->size], ptr->children))
+            handle->size++;
+      }
+   }
+
+   return true;
+}
+
+static void cheat_manager_apply_cheats(cheat_manager_t *handle)
+{
+   unsigned index = 0;
+   psnes_cheat_reset();
+   for (unsigned i = 0; i < handle->size; i++)
+   {
+      if (handle->cheats[i].state)
+         psnes_cheat_set(index++, true, handle->cheats[i].code);
+   }
+}
+
+static void cheat_manager_load_config(cheat_manager_t *handle, const char *path, const char *sha256)
+{
+#ifdef HAVE_CONFIGFILE
+   if (!(*path))
+      return;
+
+   config_file_t *conf = config_file_new(path);
+   if (!conf)
+      return;
+
+   char *str;
+   if (!config_get_string(conf, sha256, &str))
+   {
+      config_file_free(conf);
+      return;
+   }
+
+   const char *num = strtok(str, ";");
+   while (num)
+   {
+      unsigned index = strtoul(num, NULL, 0);
+      if (index < handle->size)
+         handle->cheats[index].state = true;
+
+      num = strtok(NULL, ";");
+   }
+
+   free(str);
+   config_file_free(conf);
+
+   cheat_manager_apply_cheats(handle);
+
+#else
+   (void)handle;
+   (void)path;
+   (void)sha256;
+#endif
+}
+
+static void cheat_manager_save_config(cheat_manager_t *handle, const char *path, const char *sha256)
+{
+#ifdef HAVE_CONFIGFILE
+   if (!(*path))
+      return;
+
+   config_file_t *conf = config_file_new(path);
+   if (!conf)
+      conf = config_file_new(NULL);
+
+   if (!conf)
+   {
+      SSNES_ERR("Cannot save XML cheat settings!\n");
+      return;
+   }
+
+   char conf_str[512] = {0};
+   char tmp[32] = {0};
+
+   for (unsigned i = 0; i < handle->size; i++)
+   {
+      if (handle->cheats[i].state)
+      {
+         snprintf(tmp, sizeof(tmp), "%u;", i);
+         strlcat(conf_str, tmp, sizeof(conf_str));
+      }
+   }
+
+   if (*conf_str)
+      conf_str[strlen(conf_str) - 1] = '\0'; // Remove the trailing ';'
+
+   config_set_string(conf, sha256, conf_str);
+
+   if (!config_file_write(conf, path))
+      SSNES_ERR("Failed to write XML cheat settings to \"%s\"! Check permissions!\n", path);
+
+   config_file_free(conf);
+
+#else
+   (void)handle;
+   (void)path;
+   (void)sha256;
+#endif
+}
+
+cheat_manager_t* cheat_manager_new(const char *path)
+{
+   LIBXML_TEST_VERSION;
+
+   psnes_cheat_reset();
+
+   xmlParserCtxtPtr ctx = NULL;
+   xmlDocPtr doc = NULL;
+   cheat_manager_t *handle = calloc(1, sizeof(struct cheat_manager));
+   if (!handle)
+      return NULL;
+
+   handle->buf_size = 1;
+   handle->cheats = calloc(handle->buf_size, sizeof(struct cheat));
+   if (!handle->cheats)
+   {
+      handle->buf_size = 0;
+      goto error;
+   }
+
+   ctx = xmlNewParserCtxt();
+   if (!ctx)
+      goto error;
+
+   doc = xmlCtxtReadFile(ctx, path, NULL, 0);
+   if (!doc)
+   {
+      SSNES_ERR("Failed to parse XML file: %s\n", path);
+      goto error;
+   }
+
+   if (ctx->valid == 0)
+   {
+      SSNES_ERR("Cannot validate XML file: %s\n", path);
+      goto error;
+   }
+
+   xmlNodePtr head = xmlDocGetRootElement(doc);
+   xmlNodePtr cur = NULL;
+   for (cur = head; cur; cur = cur->next)
+   {
+      if (cur->type == XML_ELEMENT_NODE && strcmp((const char*)cur->name, "database") == 0)
+         break;
+   }
+
+   if (!cur)
+      goto error;
+
+   for (cur = cur->children; cur; cur = cur->next)
+   {
+      if (cur->type != XML_ELEMENT_NODE)
+         continue;
+
+      if (strcmp((const char*)cur->name, "cartridge") == 0)
+      {
+         xmlChar *sha256 = xmlGetProp(cur, (const xmlChar*)"sha256");
+         if (!sha256)
+            continue;
+
+         if (strcmp((const char*)sha256, g_extern.sha256) == 0)
+         {
+            xmlFree(sha256);
+            break;
+         }
+
+         xmlFree(sha256);
+      }
+   }
+
+   if (!cur)
+      goto error;
+
+   if (!xml_grab_cheats(handle, cur->children))
+   {
+      SSNES_ERR("Failed to grab cheats. This should not happen.\n");
+      goto error;
+   }
+
+   if (handle->size == 0)
+   {
+      SSNES_ERR("Did not find any cheats in XML file: %s\n", path);
+      goto error;
+   }
+
+   cheat_manager_load_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
+
+   xmlFreeDoc(doc);
+   xmlFreeParserCtxt(ctx);
+   return handle;
+
+error:
+   cheat_manager_free(handle);
+   if (doc)
+      xmlFreeDoc(doc);
+   if (ctx)
+      xmlFreeParserCtxt(ctx);
+   return NULL;
+}
+
+void cheat_manager_free(cheat_manager_t *handle)
+{
+   if (!handle)
+      return;
+
+   if (handle->cheats)
+   {
+      cheat_manager_save_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
+      for (unsigned i = 0; i < handle->size; i++)
+      {
+         xmlFree(handle->cheats[i].desc);
+         free(handle->cheats[i].code);
+      }
+
+      free(handle->cheats);
+   }
+
+   free(handle);
+}
+
+static void cheat_manager_update(cheat_manager_t *handle)
+{
+   msg_queue_clear(g_extern.msg_queue);
+   char msg[256];
+   snprintf(msg, sizeof(msg), "Cheat: #%u [%s]: %s", handle->ptr, handle->cheats[handle->ptr].state ? "ON" : "OFF", handle->cheats[handle->ptr].desc);
+   msg_queue_push(g_extern.msg_queue, msg, 1, 180);
+   SSNES_LOG("%s\n", msg);
+}
+
+
+void cheat_manager_toggle(cheat_manager_t *handle)
+{
+   handle->cheats[handle->ptr].state ^= true;
+   cheat_manager_apply_cheats(handle);
+   cheat_manager_update(handle);
+}
+
+void cheat_manager_index_next(cheat_manager_t *handle)
+{
+   handle->ptr = (handle->ptr + 1) % handle->size;
+   cheat_manager_update(handle);
+}
+
+void cheat_manager_index_prev(cheat_manager_t *handle)
+{
+   if (handle->ptr == 0)
+      handle->ptr = handle->size - 1;
+   else
+      handle->ptr--;
+
+   cheat_manager_update(handle);
+}
+

cheats.h

@@ -0,0 +1,30 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_CHEATS_H
+#define __SSNES_CHEATS_H
+
+typedef struct cheat_manager cheat_manager_t;
+
+cheat_manager_t* cheat_manager_new(const char *path);
+void cheat_manager_free(cheat_manager_t *handle);
+
+void cheat_manager_index_next(cheat_manager_t *handle);
+void cheat_manager_index_prev(cheat_manager_t *handle);
+void cheat_manager_toggle(cheat_manager_t *handle);
+
+#endif

conf/config_file.c

@@ -21,19 +21,52 @@
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <errno.h>
+#include "../strl.h"
+
+#if !defined(_WIN32) && !defined(__CELLOS_LV2__)
+#include <sys/param.h> // MAXPATHLEN
+#elif defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#ifndef MAXPATHLEN
+#ifdef PATH_MAX
+#define MAXPATHLEN PATH_MAX
+#else
+#define MAXPATHLEN 512
+#endif
+#endif
+
+#define MAX_INCLUDE_DEPTH 16
 
 struct entry_list
 {
+   bool readonly; // If we got this from an #include, do not allow write.
    char *key;
    char *value;
    struct entry_list *next;
 };
 
+struct include_list
+{
+   char *path;
+   struct include_list *next;
+};
+
 struct config_file
 {
+   char *path;
    struct entry_list *entries;
+   struct entry_list *tail;
+   unsigned include_depth;
+
+   struct include_list *includes;
 };
 
+static config_file_t *config_file_new_internal(const char *path, unsigned depth);
+
 static char *getaline(FILE *file)
 {
    char *newline = malloc(9);
@@ -56,13 +89,191 @@ static char *getaline(FILE *file)
    return newline; 
 }
 
-static bool parse_line(struct entry_list *list, char *line)
+static char *extract_value(char *line, bool is_value)
+{
+   if (is_value)
+   {
+      while (isspace(*line))
+         line++;
+
+      // If we don't have an equal sign here, we've got an invalid string...
+      if (*line != '=')
+         return false;
+
+      line++;
+   }
+
+   while (isspace(*line))
+      line++;
+
+   // We have a full string. Read until next ".
+   if (*line == '"')
+   {
+      line++;
+      char *tok = strtok(line, "\"");
+      if (!tok)
+         return false;
+      return strdup(tok);
+   }
+   else if (*line == '\0') // Nothing :(
+      return NULL;
+   else // We don't have that... Read till next space.
+   {
+      char *tok = strtok(line, " \n\t\f\r\v");
+      if (tok)
+         return strdup(tok);
+      else
+         return NULL;
+   }
+}
+
+static void set_list_readonly(struct entry_list *list)
+{
+   while (list)
+   {
+      list->readonly = true;
+      list = list->next;
+   }
+}
+
+// Move semantics? :)
+static void add_child_list(config_file_t *parent, config_file_t *child)
+{
+   if (parent->entries)
+   {
+      struct entry_list *head = parent->entries;
+      while (head->next)
+         head = head->next;
+
+      set_list_readonly(child->entries);
+      head->next = child->entries;
+   }
+   else
+   {
+      set_list_readonly(child->entries);
+      parent->entries = child->entries;
+   }
+
+   child->entries = NULL;
+
+   // Rebase tail.
+   if (parent->entries)
+   {
+      struct entry_list *head = parent->entries;
+      while (head->next)
+         head = head->next;
+      parent->tail = head;
+   }
+   else
+      parent->tail = NULL;
+}
+
+static void add_include_list(config_file_t *conf, const char *path)
+{
+   struct include_list *head = conf->includes;
+   struct include_list *node = calloc(1, sizeof(*node));
+   node->path = strdup(path);
+
+   if (head)
+   {
+      while (head->next)
+         head = head->next;
+
+      head->next = node;
+   }
+   else
+      conf->includes = node;
+}
+
+static void add_sub_conf(config_file_t *conf, char *line)
+{
+   char *path = extract_value(line, false);
+   if (!path)
+      return;
+
+   add_include_list(conf, path);
+
+   char real_path[MAXPATHLEN];
+
+#ifdef _WIN32
+   // Accomodate POSIX systems on Win32.
+   bool is_full_path = *path == '/';
+
+   if (is_full_path)
+      strlcpy(real_path, path, sizeof(real_path));
+   else
+      GetFullPathNameA(path, sizeof(real_path), real_path, NULL);
+
+   if (strcmp(path, real_path) != 0)
+   {
+      strlcpy(real_path, conf->path, sizeof(real_path));
+      char *split = strrchr(real_path, '/');
+      if (!split)
+         split = strrchr(real_path, '\\');
+
+      split[1] = '\0';
+      strlcat(real_path, path, sizeof(real_path));
+   }
+#else
+   if (*path == '/')
+   {
+      strlcpy(real_path, path, sizeof(real_path));
+   }
+#ifndef __CELLOS_LV2__
+   else if (*path == '~')
+   {
+      const char *home = getenv("HOME");
+      strlcpy(real_path, home ? home : "/", sizeof(real_path));
+      strlcat(real_path, path + 1, sizeof(real_path));
+   }
+#endif
+   else
+   {
+      strlcpy(real_path, conf->path, sizeof(real_path));
+      char *split = strrchr(real_path, '/');
+      if (split)
+      {
+         split[1] = '\0';
+         strlcat(real_path, path, sizeof(real_path));
+      }
+      else
+         strlcpy(real_path, path, sizeof(real_path));
+   }
+#endif
+
+   config_file_t *sub_conf = config_file_new_internal(real_path, conf->include_depth + 1);
+   if (!sub_conf)
+   {
+      free(path);
+      return;
+   }
+
+   // Pilfer internal list! :D
+   add_child_list(conf, sub_conf);
+   config_file_free(sub_conf);
+   free(path);
+}
+
+static bool parse_line(config_file_t *conf, struct entry_list *list, char *line)
 {
    // Remove everything after comment.
    char *comment = strchr(line, '#');
    if (comment)
       *comment = '\0';
 
+   // Starting line with # and include includes config files. :)
+   if ((comment == line) && (conf->include_depth < MAX_INCLUDE_DEPTH))
+   {
+      comment++;
+      if (strstr(comment, "include ") == comment)
+      {
+         add_sub_conf(conf, comment + strlen("include "));
+         return false;
+      }
+   }
+   else if (conf->include_depth >= MAX_INCLUDE_DEPTH)
+      fprintf(stderr, "!!! #include depth exceeded for config! Might be a cycle.\n");
+
    // Skips to first character.
    while (isspace(*line))
       line++;
@@ -84,66 +295,42 @@ static bool parse_line(struct entry_list *list, char *line)
    key[index] = '\0';
    list->key = key;
 
-   while (isspace(*line))
-      line++;
-
-   // If we don't have an equal sign here, we've got an invalid string...
-   if (*line != '=')
+   list->value = extract_value(line, true);
+   if (!list->value)
    {
       list->key = NULL;
       free(key);
       return false;
    }
-   line++;
-
-   while (isspace(*line))
-      line++;
-
-   // We have a full string. Read until next ".
-   if (*line == '"')
-   {
-      char *tok = strtok(line + 1, "\"");
-      if (tok == NULL)
-      {
-         list->key = NULL;
-         free(key);
-         return false;
-      }
-      list->value = strdup(tok);
-   }
-   else // We don't have that... Read till next space.
-   {
-      char *tok = strtok(line, " \t\f");
-      if (tok == NULL)
-      {
-         list->key = NULL;
-         free(key);
-         return false;
-      }
-      list->value = strdup(tok);
-   }
 
    return true;
 }
 
-config_file_t *config_file_new(const char *path)
+static config_file_t *config_file_new_internal(const char *path, unsigned depth)
 {
-
    struct config_file *conf = calloc(1, sizeof(*conf));
-   if (conf == NULL)
+   if (!conf)
       return NULL;
 
-   if (path == NULL)
+   if (!path)
       return conf;
 
-   FILE *file = fopen(path, "r");
-   if (!file)
+   conf->path = strdup(path);
+   if (!conf->path)
    {
       free(conf);
       return NULL;
    }
 
-   struct entry_list *tail = conf->entries;
+   conf->include_depth = depth;
+
+   FILE *file = fopen(path, "r");
+   if (!file)
+   {
+      free(conf->path);
+      free(conf);
+      return NULL;
+   }
 
    while (!feof(file))
    {
@@ -152,50 +339,69 @@ config_file_t *config_file_new(const char *path)
 
       if (line)
       {
-         if (parse_line(list, line))
+         if (parse_line(conf, list, line))
          {
-            if (conf->entries == NULL)
+            if (conf->entries)
             {
-               conf->entries = list;
-               tail = list;
+               conf->tail->next = list;
+               conf->tail = list;
             }
             else
             {
-               tail->next = list;
-               tail = list;
+               conf->entries = list;
+               conf->tail = list;
             }
          }
+
          free(line);
       }
+
+      if (list != conf->tail)
+         free(list);
    }
    fclose(file);
 
    return conf;
 }
 
+config_file_t *config_file_new(const char *path)
+{
+   return config_file_new_internal(path, 0);
+}
+
 void config_file_free(config_file_t *conf)
 {
-   if (conf != NULL)
+   if (!conf)
+      return;
+
+   struct entry_list *tmp = conf->entries;
+   while (tmp)
    {
-      struct entry_list *tmp = conf->entries;
-      struct entry_list *old = tmp;
-      while (tmp != NULL)
-      {
-         free(tmp->key);
-         free(tmp->value);
-         old = tmp;
-         tmp = tmp->next;
-         free(old);
-      }
-      free(conf);
+      free(tmp->key);
+      free(tmp->value);
+      struct entry_list *hold = tmp;
+      tmp = tmp->next;
+      free(hold);
    }
+
+   struct include_list *inc_tmp = conf->includes;
+   while (inc_tmp)
+   {
+      free(inc_tmp->path);
+      struct include_list *hold = inc_tmp;
+      inc_tmp = inc_tmp->next;
+      free(hold);
+   }
+
+   free(conf->path);
+   free(conf);
 }
 
 bool config_get_double(config_file_t *conf, const char *key, double *in)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
@@ -211,12 +417,42 @@ bool config_get_int(config_file_t *conf, const char *key, int *in)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
-         *in = strtol(list->value, NULL, 0);
-         return true;
+         errno = 0;
+         int val = strtol(list->value, NULL, 0);
+         if (errno == 0)
+         {
+            *in = val;
+            return true;
+         }
+         return
+            false;
+      }
+      list = list->next;
+   }
+   return false;
+}
+
+bool config_get_hex(config_file_t *conf, const char *key, unsigned *in)
+{
+   struct entry_list *list = conf->entries;
+
+   while (list)
+   {
+      if (strcmp(key, list->key) == 0)
+      {
+         errno = 0;
+         unsigned val = strtoul(list->value, NULL, 16);
+         if (errno == 0)
+         {
+            *in = val;
+            return true;
+         }
+         else
+            return false;
       }
       list = list->next;
    }
@@ -227,11 +463,11 @@ bool config_get_char(config_file_t *conf, const char *key, char *in)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
-         if (strlen(list->value) > 1)
+         if (list->value[0] && list->value[1])
             return false;
          *in = *list->value;
          return true;
@@ -245,7 +481,7 @@ bool config_get_string(config_file_t *conf, const char *key, char **str)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
@@ -257,11 +493,27 @@ bool config_get_string(config_file_t *conf, const char *key, char **str)
    return false;
 }
 
+bool config_get_array(config_file_t *conf, const char *key, char *buf, size_t size)
+{
+   struct entry_list *list = conf->entries;
+
+   while (list)
+   {
+      if (strcmp(key, list->key) == 0)
+      {
+         strlcpy(buf, list->value, size);
+         return true;
+      }
+      list = list->next;
+   }
+   return false;
+}
+
 bool config_get_bool(config_file_t *conf, const char *key, bool *in)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
@@ -287,14 +539,15 @@ void config_set_string(config_file_t *conf, const char *key, const char *val)
 {
    struct entry_list *list = conf->entries;
    struct entry_list *last = list;
-   while (list != NULL)
+   while (list)
    {
-      if (strcmp(key, list->key) == 0)
+      if (!list->readonly && (strcmp(key, list->key) == 0))
       {
          free(list->value);
          list->value = strdup(val);
          return;
       }
+
       last = list;
       list = list->next;
    }
@@ -358,11 +611,50 @@ bool config_file_write(config_file_t *conf, const char *path)
 
 void config_file_dump(config_file_t *conf, FILE *file)
 {
-   struct entry_list *list = conf->entries;
-
-   while (list != NULL)
+   struct include_list *includes = conf->includes;
+   while (includes)
    {
-      fprintf(file, "%s = \"%s\"\n", list->key, list->value);
+      fprintf(file, "#include \"%s\"\n", includes->path);
+      includes = includes->next;
+   }
+
+   struct entry_list *list = conf->entries;
+   while (list)
+   {
+      if (!list->readonly)
+         fprintf(file, "%s = \"%s\"\n", list->key, list->value);
       list = list->next;
    }
 }
+
+void config_file_dump_all(config_file_t *conf, FILE *file)
+{
+   struct include_list *includes = conf->includes;
+   while (includes)
+   {
+      fprintf(file, "#include \"%s\"\n", includes->path);
+      includes = includes->next;
+   }
+
+   struct entry_list *list = conf->entries;
+   while (list)
+   {
+      fprintf(file, "%s = \"%s\" %s\n", list->key, list->value, list->readonly ? "(included)" : "");
+      list = list->next;
+   }
+}
+
+bool config_entry_exists(config_file_t *conf, const char *entry)
+{
+   struct entry_list *list = conf->entries;
+
+   while (list)
+   {
+      if (strcmp(entry, list->key) == 0)
+         return true;
+      list = list->next;
+   }
+
+   return false;
+}
+

conf/config_file.h

@@ -22,6 +22,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <stddef.h>
 
 typedef struct config_file config_file_t;
 
@@ -30,26 +31,39 @@ typedef struct config_file config_file_t;
 // - # are treated as comments. Rest of the line is ignored.
 // - Format is: key = value. There can be as many spaces as you like in-between.
 // - Value can be wrapped inside "" for multiword strings. (foo = "hai u")
+//
+// - #include includes a config file in-place.
+// Path is relative to where config file was loaded unless an absolute path is chosen.
+// Key/value pairs from an #include are read-only, and cannot be modified.
 
-// Loads a config file. Returns NULL if file doesn't exist. NULL path will create an empty config file.
+// Loads a config file. Returns NULL if file doesn't exist.
+// NULL path will create an empty config file.
 config_file_t *config_file_new(const char *path);
 // Frees config file.
 void config_file_free(config_file_t *conf);
 
-// All extract functions return true when value is valid and exists. Returns false otherwise.
+// All extract functions return true when value is valid and exists.
+// Returns false otherwise.
+
+bool config_entry_exists(config_file_t *conf, const char *entry);
 
 // Extracts a double from config file.
 bool config_get_double(config_file_t *conf, const char *entry, double *in);
 // Extracts an int from config file.
 bool config_get_int(config_file_t *conf, const char *entry, int *in);
+// Extracts an int from config file. (Hexadecimal)
+bool config_get_hex(config_file_t *conf, const char *entry, unsigned *in);
 // Extracts a single char. If value consists of several chars, this is an error.
 bool config_get_char(config_file_t *conf, const char *entry, char *in);
 // Extracts an allocated string in *in. This must be free()-d if this function succeeds.
 bool config_get_string(config_file_t *conf, const char *entry, char **in);
+// Extracts a string to a preallocated buffer. Avoid memory allocation.
+bool config_get_array(config_file_t *conf, const char *entry, char *in, size_t size);
 // Extracts a boolean from config. Valid boolean true are "true" and "1". Valid false are "false" and "0". Other values will be treated as an error.
 bool config_get_bool(config_file_t *conf, const char *entry, bool *in);
 
-// Setters. Similiar to the getters.
+// Setters. Similar to the getters. Will not write to entry if the entry
+// was obtained from an #include.
 void config_set_double(config_file_t *conf, const char *entry, double value);
 void config_set_int(config_file_t *conf, const char *entry, int val);
 void config_set_char(config_file_t *conf, const char *entry, char val);
@@ -61,7 +75,8 @@ bool config_file_write(config_file_t *conf, const char *path);
 
 // Dump the current config to an already opened file. Does not close the file.
 void config_file_dump(config_file_t *conf, FILE *file);
-
-
+// Also dumps inherited values, useful for logging.
+void config_file_dump_all(config_file_t *conf, FILE *file);
 
 #endif
+

config.def.h

@@ -30,20 +30,13 @@
 #include "config.h"
 #endif
 
-#ifdef HAVE_SDL
-#include "SDL.h"
-#else
-#error HAVE_SDL is not defined!
-#endif
-
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#endif
-
+#include "input/keysym.h"
 
 ///////////////// Drivers
 #define VIDEO_GL 0
 #define VIDEO_XVIDEO 11
+#define VIDEO_SDL 13
+#define VIDEO_EXT 14
 ////////////////////////
 #define AUDIO_RSOUND 1
 #define AUDIO_OSS 2
@@ -54,18 +47,31 @@
 #define AUDIO_SDL 8
 #define AUDIO_XAUDIO 9
 #define AUDIO_PULSE 10
+#define AUDIO_EXT 15
+#define AUDIO_DSOUND 16
+#define AUDIO_COREAUDIO 17
+#define AUDIO_PS3 18
 ////////////////////////
 #define INPUT_SDL 7
 #define INPUT_X 12
+#define INPUT_PS3 19
 ////////////////////////
 
-#if defined(HAVE_SDL)
+#if defined(HAVE_OPENGL) || defined(__CELLOS_LV2__)
 #define VIDEO_DEFAULT_DRIVER VIDEO_GL
 #elif defined(HAVE_XVIDEO)
 #define VIDEO_DEFAULT_DRIVER VIDEO_XVIDEO
+#elif defined(HAVE_SDL)
+#define VIDEO_DEFAULT_DRIVER VIDEO_SDL
+#elif defined(HAVE_DYLIB)
+#define VIDEO_DEFAULT_DRIVER VIDEO_EXT
+#else
+#error "Need at least one video driver!"
 #endif
 
-#if defined(HAVE_ALSA)
+#if defined(__CELLOS_LV2__)
+#define AUDIO_DEFAULT_DRIVER AUDIO_PS3
+#elif defined(HAVE_ALSA)
 #define AUDIO_DEFAULT_DRIVER AUDIO_ALSA
 #elif defined(HAVE_PULSE)
 #define AUDIO_DEFAULT_DRIVER AUDIO_PULSE
@@ -73,8 +79,12 @@
 #define AUDIO_DEFAULT_DRIVER AUDIO_OSS
 #elif defined(HAVE_JACK)
 #define AUDIO_DEFAULT_DRIVER AUDIO_JACK
+#elif defined(HAVE_COREAUDIO)
+#define AUDIO_DEFAULT_DRIVER AUDIO_COREAUDIO
 #elif defined(HAVE_AL)
 #define AUDIO_DEFAULT_DRIVER AUDIO_AL
+#elif defined(HAVE_DSOUND)
+#define AUDIO_DEFAULT_DRIVER AUDIO_DSOUND
 #elif defined(HAVE_SDL)
 #define AUDIO_DEFAULT_DRIVER AUDIO_SDL
 #elif defined(HAVE_XAUDIO)
@@ -83,14 +93,20 @@
 #define AUDIO_DEFAULT_DRIVER AUDIO_RSOUND
 #elif defined(HAVE_ROAR)
 #define AUDIO_DEFAULT_DRIVER AUDIO_ROAR
+#elif defined(HAVE_DYLIB)
+#define AUDIO_DEFAULT_DRIVER AUDIO_EXT
 #else
-#error Need at least one audio driver!
+#error "Need at least one audio driver!"
 #endif
 
 #if defined(HAVE_SDL)
 #define INPUT_DEFAULT_DRIVER INPUT_SDL
+#elif defined(__CELLOS_LV2__)
+#define INPUT_DEFAULT_DRIVER INPUT_PS3
 #elif defined(HAVE_XVIDEO)
 #define INPUT_DEFAULT_DRIVER INPUT_X
+#else
+#error "Need at least one input driver!"
 #endif
 
 
@@ -99,14 +115,20 @@
 ////////////////
 
 // Windowed
-static const float xscale = 3.0; // Real x res = 296 * xscale
-static const float yscale = 3.0; // Real y res = 224 * yscale
+static const float xscale = 3.0; // Real x res = aspect * base_size * xscale
+static const float yscale = 3.0; // Real y res = base_size * yscale
 
 // Fullscreen
 static const bool fullscreen = false;  // To start in Fullscreen or not
 static const unsigned fullscreen_x = 0; // Fullscreen resolution. A value of 0 uses the desktop resolution.
 static const unsigned fullscreen_y = 0;
 
+// Force 16-bit colors.
+static const bool force_16bit = false;
+
+// Forcibly disable composition. Only valid on Windows Vista/7 for now.
+static const bool disable_composition = false;
+
 // Video VSYNC (recommended)
 static const bool vsync = true;
 
@@ -116,12 +138,17 @@ static const bool video_smooth = true;
 // On resize and fullscreen, rendering area will stay 4:3
 static const bool force_aspect = true; 
 
+// Crop overscanned frames (7/8 or 15/15 for interlaced frames).
+static const bool crop_overscan = true;
+
 // Font size for on-screen messages.
 static const unsigned font_size = 48;
 
 // Offset for where messages will be placed on-screen. Values are in range [0.0, 1.0].
 static const float message_pos_offset_x = 0.05;
 static const float message_pos_offset_y = 0.05;
+// Color of the message.
+static const uint32_t message_color = 0xffff00; // RGB hex value.
 
 // Render-to-texture before rendering to screen (multi-pass shaders)
 static const bool render_to_texture = false;
@@ -129,7 +156,28 @@ static const float fbo_scale_x = 2.0;
 static const float fbo_scale_y = 2.0;
 static const bool second_pass_smooth = true;
 
-#define SNES_ASPECT_RATIO (4.0/3)
+// Record video assuming game runs hi-res.
+static const bool hires_record = false;
+
+// Record post-filtered (CPU filter) video rather than raw SNES output.
+static const bool post_filter_record = false;
+
+// OSD-messages
+static const bool font_enable = true;
+
+// The accurate refresh rate of your monitor (Hz).
+// This is used to calculate audio input rate with the formula:
+// audio_input_rate = game_input_rate * display_refresh_rate / game_refresh_rate.
+// If the implementation does not report any values,
+// SNES NTSC defaults will be assumed for compatibility.
+// This value should stay close to 60Hz to avoid large pitch changes.
+// If your monitor does not run at 60Hz, or something close to it, disable VSync,
+// and leave this at its default.
+#ifdef __CELLOS_LV2__
+static const float refresh_rate = 59.92; 
+#else
+static const float refresh_rate = 59.95; 
+#endif
 
 ////////////////
 // Audio
@@ -141,15 +189,11 @@ static const bool audio_enable = true;
 // Output samplerate
 static const unsigned out_rate = 48000; 
 
-// Input samplerate from libSNES. 
-// Lower this (slightly) if you are experiencing frequent audio dropouts while vsync is enabled.
-static const float in_rate = 31980.0; 
-
 // When changing input rate on-the-fly
 static const float audio_rate_step = 0.25;
 
 // Audio device (e.g. hw:0,0 or /dev/audio). If NULL, will use defaults.
-static const char* audio_device = NULL;
+static const char *audio_device = NULL;
 
 // Desired audio latency in milliseconds. Might not be honored if driver can't provide given latency.
 static const int out_latency = 64;
@@ -157,11 +201,6 @@ static const int out_latency = 64;
 // Will sync audio. (recommended) 
 static const bool audio_sync = true;
 
-// Defines the quality (and cpu reqirements) of samplerate conversion.
-#ifdef HAVE_SRC
-#define SAMPLERATE_QUALITY SRC_LINEAR
-#endif
-
 // Enables use of rewind. This will incur some memory footprint depending on the save state buffer.
 // This rewind only works when using bSNES core atm.
 static const bool rewind_enable = false;
@@ -173,13 +212,21 @@ static const unsigned rewind_buffer_size = 20 << 20; // 20MiB
 static const unsigned rewind_granularity = 1;
 
 // Pause gameplay when gameplay loses focus.
-static const bool pause_nonactive = true;
+static const bool pause_nonactive = false;
 
 // Saves non-volatile SRAM at a regular interval. It is measured in seconds. A value of 0 disables autosave.
 static const unsigned autosave_interval = 0;
 
 // When being client over netplay, use keybinds for player 1 rather than player 2.
-static const bool netplay_client_swap_input = false;
+static const bool netplay_client_swap_input = true;
+
+// On save state load, block SRAM from being overwritten.
+// This could potentially lead to buggy games.
+static const bool block_sram_overwrite = false;
+
+// When saving savestates, state index is automatically incremented before saving.
+// When the ROM is loaded, state index will be set to the highest existing value.
+static const bool savestate_auto_index = false;
 
 
 ////////////////////
@@ -188,113 +235,66 @@ static const bool netplay_client_swap_input = false;
 
 // Axis threshold (between 0.0 and 1.0)
 // How far an axis must be tilted to result in a button press
-#define AXIS_THRESHOLD 0.5
+static const float axis_threshold = 0.5;
 
 // To figure out which joypad buttons to use, check jstest or similar.
 // SDL sometimes reverses the axes for some odd reason, but hey. :D
 
 // Player 1
 static const struct snes_keybind snes_keybinds_1[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_x,           1,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_z,           0,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_s,           3,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_a,           2,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_q,           4,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_w,           5,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_LEFT,       11,      AXIS_NEG(0) },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_RIGHT,      12,      AXIS_POS(0) },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_UP,         13,      AXIS_NEG(1) },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_DOWN,       14,      AXIS_POS(1) },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_RETURN,      7,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_RSHIFT,      6,      AXIS_NONE },
-   { SSNES_FAST_FORWARD_KEY,           SDLK_SPACE,      10,      AXIS_NONE },
-   { SSNES_SAVE_STATE_KEY,             SDLK_F2,     NO_BTN,      AXIS_NONE },
-   { SSNES_LOAD_STATE_KEY,             SDLK_F4,     NO_BTN,      AXIS_NONE },
-   { SSNES_FULLSCREEN_TOGGLE_KEY,      SDLK_f,      NO_BTN,      AXIS_NONE },
-   { SSNES_QUIT_KEY,                   SDLK_ESCAPE, NO_BTN,      AXIS_NONE },
-   { SSNES_STATE_SLOT_MINUS,           SDLK_F6,     NO_BTN,      AXIS_NONE },
-   { SSNES_STATE_SLOT_PLUS,            SDLK_F7,     NO_BTN,      AXIS_NONE },
-   { SSNES_AUDIO_INPUT_RATE_PLUS,      SDLK_KP_PLUS, NO_BTN,     AXIS_NONE },
-   { SSNES_AUDIO_INPUT_RATE_MINUS,     SDLK_KP_MINUS, NO_BTN,    AXIS_NONE },
-   { SSNES_REWIND,                     SDLK_r,      NO_BTN,      AXIS_NONE },
-   { SSNES_MOVIE_RECORD_TOGGLE,        SDLK_o,      NO_BTN,      AXIS_NONE },
-   { SSNES_PAUSE_TOGGLE,               SDLK_p,      NO_BTN,      AXIS_NONE },
-   { SSNES_RESET,                      SDLK_h,      NO_BTN,      AXIS_NONE },
-   { SSNES_SHADER_NEXT,                SDLK_m,      NO_BTN,      AXIS_NONE },
-   { SSNES_SHADER_PREV,                SDLK_n,      NO_BTN,      AXIS_NONE },
+   // SNES button               | keyboard key | js btn | js axis |
+   { SNES_DEVICE_ID_JOYPAD_A,          SK_x,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_B,          SK_z,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_X,          SK_s,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_Y,          SK_a,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_L,          SK_q,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_R,          SK_w,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_LEFT,       SK_LEFT,   NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SK_RIGHT,  NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_UP,         SK_UP,     NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_DOWN,       SK_DOWN,   NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_START,      SK_RETURN, NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_SELECT,     SK_RSHIFT, NO_BTN,      AXIS_NONE },
+   { SSNES_FAST_FORWARD_KEY,           SK_SPACE,  NO_BTN,      AXIS_NONE },
+   { SSNES_FAST_FORWARD_HOLD_KEY,      SK_l,      NO_BTN,      AXIS_NONE },
+   { SSNES_SAVE_STATE_KEY,             SK_F2,     NO_BTN,      AXIS_NONE },
+   { SSNES_LOAD_STATE_KEY,             SK_F4,     NO_BTN,      AXIS_NONE },
+   { SSNES_FULLSCREEN_TOGGLE_KEY,      SK_f,      NO_BTN,      AXIS_NONE },
+   { SSNES_QUIT_KEY,                   SK_ESCAPE, NO_BTN,      AXIS_NONE },
+   { SSNES_STATE_SLOT_MINUS,           SK_F6,     NO_BTN,      AXIS_NONE },
+   { SSNES_STATE_SLOT_PLUS,            SK_F7,     NO_BTN,      AXIS_NONE },
+   { SSNES_AUDIO_INPUT_RATE_PLUS,      SK_KP_PLUS, NO_BTN,     AXIS_NONE },
+   { SSNES_AUDIO_INPUT_RATE_MINUS,     SK_KP_MINUS, NO_BTN,    AXIS_NONE },
+   { SSNES_REWIND,                     SK_r,      NO_BTN,      AXIS_NONE },
+   { SSNES_MOVIE_RECORD_TOGGLE,        SK_o,      NO_BTN,      AXIS_NONE },
+   { SSNES_PAUSE_TOGGLE,               SK_p,      NO_BTN,      AXIS_NONE },
+   { SSNES_FRAMEADVANCE,               SK_k,      NO_BTN,      AXIS_NONE },
+   { SSNES_RESET,                      SK_h,      NO_BTN,      AXIS_NONE },
+   { SSNES_SHADER_NEXT,                SK_m,      NO_BTN,      AXIS_NONE },
+   { SSNES_SHADER_PREV,                SK_n,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_INDEX_PLUS,           SK_y,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_INDEX_MINUS,          SK_t,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_TOGGLE,               SK_u,      NO_BTN,      AXIS_NONE },
+   { SSNES_SCREENSHOT,                 SK_PRINT,  NO_BTN,      AXIS_NONE },
+   { SSNES_DSP_CONFIG,                 SK_c,      NO_BTN,      AXIS_NONE },
+   { SSNES_MUTE,                       SK_F9,     NO_BTN,      AXIS_NONE },
    { -1 }
 };
 
-// Player 2
-static const struct snes_keybind snes_keybinds_2[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_b,          1,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_v,          0,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_g,          3,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_f,          2,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_r,          4,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_t,          5,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_j,         11,       AXIS_NEG(0) },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_l,         12,       AXIS_POS(0) },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_i,         13,       AXIS_NEG(1) },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_k,         14,       AXIS_POS(1) },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_p,          6,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_o,          7,       AXIS_NONE },
-   { -1 }
-};
-
-// Player 3
-static const struct snes_keybind snes_keybinds_3[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_b,          1,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_v,          0,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_g,          3,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_f,          2,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_r,          4,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_t,          5,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_j,         11,       AXIS_NEG(0) },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_l,         12,       AXIS_POS(0) },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_i,         13,       AXIS_NEG(1) },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_k,         14,       AXIS_POS(1) },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_p,          6,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_o,          7,       AXIS_NONE },
-   { -1 }
-};
-
-// Player 4
-static const struct snes_keybind snes_keybinds_4[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_b,          1,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_v,          0,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_g,          3,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_f,          2,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_r,          4,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_t,          5,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_j,         11,       AXIS_NEG(0) },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_l,         12,       AXIS_POS(0) },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_i,         13,       AXIS_NEG(1) },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_k,         14,       AXIS_POS(1) },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_p,          6,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_o,          7,       AXIS_NONE },
-   { -1 }
-};
-
-// Player 5
-static const struct snes_keybind snes_keybinds_5[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_b,          1,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_v,          0,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_g,          3,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_f,          2,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_r,          4,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_t,          5,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_j,         11,       AXIS_NEG(0) },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_l,         12,       AXIS_POS(0) },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_i,         13,       AXIS_NEG(1) },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_k,         14,       AXIS_POS(1) },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_p,          6,       AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_o,          7,       AXIS_NONE },
+// Player 2-5
+static const struct snes_keybind snes_keybinds_rest[] = {
+   { SNES_DEVICE_ID_JOYPAD_A,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_B,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_X,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_Y,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_L,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_R,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_LEFT,       SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_UP,         SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_DOWN,       SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_START,      SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_SELECT,     SK_UNKNOWN, NO_BTN, AXIS_NONE },
    { -1 }
 };
 

config.features.h

@@ -14,13 +14,31 @@ static const bool _sdl_supp = true;
 static const bool _sdl_supp = false;
 #endif
 
+#ifdef HAVE_THREADS
+static const bool _thread_supp = true;
+#else
+static const bool _thread_supp = false;
+#endif
+
+#ifdef HAVE_OPENGL
+static const bool _opengl_supp = true;
+#else
+static const bool _opengl_supp = false;
+#endif
+
+#ifdef HAVE_XVIDEO
+static const bool _xvideo_supp = true;
+#else
+static const bool _xvideo_supp = false;
+#endif
+
 #ifdef HAVE_ALSA
 static const bool _alsa_supp = true;
 #else
 static const bool _alsa_supp = false;
 #endif
 
-#ifdef HAVE_OSS
+#if defined(HAVE_OSS) || defined(HAVE_OSS_BSD)
 static const bool _oss_supp = true;
 #else
 static const bool _oss_supp = false;
@@ -62,10 +80,10 @@ static const bool _xaudio_supp = true;
 static const bool _xaudio_supp = false;
 #endif
 
-#ifdef HAVE_FILTER
-static const bool _filter_supp = true;
+#ifdef HAVE_DYLIB
+static const bool _dylib_supp = true;
 #else
-static const bool _filter_supp = false;
+static const bool _dylib_supp = false;
 #endif
 
 #ifdef HAVE_CG
@@ -80,6 +98,12 @@ static const bool _xml_supp = true;
 static const bool _xml_supp = false;
 #endif
 
+#ifdef HAVE_SDL_IMAGE
+static const bool _sdl_image_supp = true;
+#else
+static const bool _sdl_image_supp = false;
+#endif
+
 #ifdef HAVE_FBO
 static const bool _fbo_supp = true;
 #else
@@ -98,10 +122,10 @@ static const bool _ffmpeg_supp = true;
 static const bool _ffmpeg_supp = false;
 #endif
 
-#ifdef HAVE_SRC
-static const bool _src_supp = true;
+#ifdef HAVE_X264RGB
+static const bool _x264rgb_supp = true;
 #else
-static const bool _src_supp = false;
+static const bool _x264rgb_supp = false;
 #endif
 
 #ifdef HAVE_CONFIGFILE
@@ -122,4 +146,10 @@ static const bool _netplay_supp = true;
 static const bool _netplay_supp = false;
 #endif
 
+#ifdef HAVE_PYTHON
+static const bool _python_supp = true;
+#else
+static const bool _python_supp = false;
+#endif
+
 #endif

docs/ssnes-joyconfig.1

@@ -1,6 +1,6 @@
 .\" ssnes-joyconfig.1:
 
-.TH  "SSNES-JOYCONFIG" "1" "January 2011" "SSNES-JOYCONFIG" "System Manager's Manual: ssnes-joyconfig"
+.TH  "SSNES-JOYCONFIG" "1" "October 2011" "SSNES-JOYCONFIG" "System Manager's Manual: ssnes-joyconfig"
 
 .SH NAME
 

docs/ssnes.1

@@ -1,6 +1,6 @@
 .\" ssnes.1:
 
-.TH  "SSNES" "1" "January 2011" "SSNES" "System Manager's Manual: ssnes"
+.TH  "SSNES" "1" "November 2011" "SSNES" "System Manager's Manual: ssnes"
 
 .SH NAME
 
@@ -27,24 +27,45 @@ If no rom file path is defined on the command line, \fBssnes\fR will try to load
 \fB--help, -h\fR
 Prints help text.
 
+.TP
+\fB--features\fR
+Prints available features compiled into SSNES, then exits.
+
+.TP
+\fB-L PATH, --libsnes PATH\fR
+Path to a libsnes implementation which is to be used.
+This option will override any setting in a config file.
+This option is only available if SSNES is compiled with dynamic libsnes loading.
+
 .TP
 \fB--save PATH, -s PATH\fR
 Overrides the path used for save ram (*.srm).
 Without this flag, the save ram path will be inferred from the rom path name, and put in the same directory as the rom file with the extention replaced with '.srm'. 
 When rom is loaded from \fBstdin\fR, this flag is mandatory to define as no path can be inferred.
+If PATH is a directory, SSNES will treat this as the save file directory, where the save file name will be inferred from the rom name.
+When loading a rom from stdin, the path must be a full path, however.
 
 .TP
-\fB--savestate PATH, -S path\fR
+\fB--savestate PATH, -S PATH\fR
 Overrides the path used for save states.
 Without this flag, the save state path will be inferred from the rom path name, and put in the same directory as the rom file with the extention replace with '.state'.
 When rom is loaded from \fBstdin\fR, this flag is mandatory to define as no path can be inferred.
+If PATH is a directory, SSNES will treat this as the save state directory, where the state file name will be inferred from the rom name.
+When loading a rom from stdin, the path must be a full path, however.
 Do note that save states are bound to the libsnes implementation being used. Using a different libsnes could invalidate the save state file.
 
+.TP
+\fB--fullscreen, -f\fR
+Always starts SSNES in fullscreen. Disregards settings in configuration file.
+
 .TP
 \fB--config PATH, -c PATH\fR
 Sets the configuration file path. \fBssnes\fR will use this path to load the configuration file.
 Should this not be defined, \fBssnes\fR will look in platform specific paths to attempt finding the config file.
 /etc/ssnes.cfg (when installed), or ssnes.cfg in the source tarball serves as a skeleton configuration file.
+If PATH is a directory, SSNES will treat this as the config file directory, where the state file name will be inferred from the rom name (*.cfg).
+When loading a rom from stdin, the path must be a full path, however.
+If a config cannot be found when using directory path, the default config path will be used instead.
 
 .IP
 Unix-like systems will look in $XDG_CONFIG_HOME/ssnes/ssnes.cfg first. Then it will try $HOME/.ssnes.cfg. Last, it will try /etc/ssnes.cfg. If no configuration is found, default settings will be assumed. A configuration file does not need to define every possible option, only those that should be overridden.
@@ -80,6 +101,10 @@ When using Sufami, save ram paths will be inferred from the Sufami BIOS path, no
 \fB--mouse PORT, -m PORT\fR
 Connects a Super Nintendo Mouse into port number PORT of the emulated SNES. Possible values for PORT are 1 and 2.
 
+.TP
+\fB--nodevice PORT, -N PORT\fR
+Disconnects an input device from port number PORT of the emulated SNES. Possible values for PORT are 1 and 2. This may be needed for some odd games to run properly.
+
 .TP
 \fB--scope, -p\fR
 Connects a Super Scope into port 2 of the SNES. It is controlled with your mouse.
@@ -98,13 +123,30 @@ Connects a four-way multitap into port 2 of the SNES. This allows for up to 5 pl
 
 .TP
 \fB--record PATH, -r PATH\fR
-Activates video recording of gameplay into PATH. Video recording options can be configured in config file.
+Activates video recording of gameplay into PATH. Using .mkv extension is recommended.
+Codecs used are (FFV1 or H264 RGB lossless (x264))/FLAC, suitable for processing the material further.
+
+.TP
+\fB--size WIDTHxHEIGHT\fR
+Allows specifying the exact output width and height of FFmpeg recording. This option will override any configuration settings.
+The video input is scaled with point filtering before being encoded at the correct size.
 
 .TP
 \fB--bsvplay PATH, -P PATH\fR
 Play back a movie recorded in the .bsv format (bSNES). Cart ROM and movie file need to correspond.
 It also requires to play back with the same libsnes backend that was used for recording.
 
+.TP
+\fB--bsvrecord PATH, -R PATH\fR
+Start recording a .bsv video to PATH immediately after startup.
+
+.TP
+\fB--sram-mode MODE, -M MODE\fR
+MODE designates how to handle SRAM.
+The format of the second parameter is {no,}load-{no,}save.
+These two boolean values tell if SRAM loading and SRAM saving should take place.
+Note that noload-save implies that the SRAM will be overwritten with new data.
+
 .TP
 \fB--verbose, -v\fR
 Activates verbose logging.
@@ -131,5 +173,19 @@ Network port used for netplay. This defaults to 55435. This option affects both
 Attempts to apply an UPS patch to the current ROM image. No files are altered. 
 If this flag is not specified, SSNES will look for a .ups file with same basename as ROM specified.
 
+.TP
+\fB--bps PATCH\fR
+Attempts to apply a BPS patch to the current ROM image. No files are altered. 
+If this flag is not specified, SSNES will look for a .bps file with same basename as ROM specified.
+
+.TP
+\fB--xml MAP, -X MAP\fR
+Specifies path to XML memory map for the given ROM.
+If this flag is not specified, SSNES will look for a .xml file with same basename as ROM specified.
+
+.TP
+\fB-D, --detach\fR
+Detach from the current console. This is currently only relevant for Microsoft Windows.
+
 .SH "SEE ALSO"
 \fBssnes-joyconfig\fR(1)

driver.c

@@ -29,15 +29,21 @@
 #endif
 
 static const audio_driver_t *audio_drivers[] = {
+#ifdef __CELLOS_LV2__
+   &audio_ps3,
+#endif
 #ifdef HAVE_ALSA
    &audio_alsa,
 #endif
-#ifdef HAVE_OSS
+#if defined(HAVE_OSS) || defined(HAVE_OSS_BSD)
    &audio_oss,
 #endif
 #ifdef HAVE_RSOUND
    &audio_rsound,
 #endif
+#ifdef HAVE_COREAUDIO
+   &audio_coreaudio,
+#endif
 #ifdef HAVE_AL
    &audio_openal,
 #endif
@@ -53,32 +59,47 @@ static const audio_driver_t *audio_drivers[] = {
 #ifdef HAVE_XAUDIO
    &audio_xa,
 #endif
+#ifdef HAVE_DSOUND
+   &audio_dsound,
+#endif
 #ifdef HAVE_PULSE
    &audio_pulse,
 #endif
+#ifdef HAVE_DYLIB
+   &audio_ext,
+#endif
 };
 
 static const video_driver_t *video_drivers[] = {
-#ifdef HAVE_SDL
+#ifdef HAVE_OPENGL
    &video_gl,
 #endif
+#ifdef HAVE_SDL
+   &video_sdl,
+#endif
 #ifdef HAVE_XVIDEO
    &video_xvideo,
 #endif
+#ifdef HAVE_DYLIB
+   &video_ext,
+#endif
 };
 
 static const input_driver_t *input_drivers[] = {
+#ifdef __CELLOS_LV2__
+   &input_ps3,
+#endif
 #ifdef HAVE_SDL
    &input_sdl,
 #endif
-//#ifdef HAVE_XVIDEO
-//   &input_x,
-//#endif
+#ifdef HAVE_XVIDEO
+   &input_x,
+#endif
 };
 
 static void find_audio_driver(void)
 {
-   for (int i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
    {
       if (strcasecmp(g_settings.audio.driver, audio_drivers[i]->ident) == 0)
       {
@@ -88,7 +109,7 @@ static void find_audio_driver(void)
    }
    SSNES_ERR("Couldn't find any audio driver named \"%s\"\n", g_settings.audio.driver);
    fprintf(stderr, "Available audio drivers are:\n");
-   for (int i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
       fprintf(stderr, "\t%s\n", audio_drivers[i]->ident);
 
    exit(1);
@@ -96,7 +117,7 @@ static void find_audio_driver(void)
 
 static void find_video_driver(void)
 {
-   for (int i = 0; i < sizeof(video_drivers) / sizeof(video_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(video_drivers) / sizeof(video_driver_t*); i++)
    {
       if (strcasecmp(g_settings.video.driver, video_drivers[i]->ident) == 0)
       {
@@ -114,7 +135,7 @@ static void find_video_driver(void)
 
 static void find_input_driver(void)
 {
-   for (int i = 0; i < sizeof(input_drivers) / sizeof(input_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(input_drivers) / sizeof(input_driver_t*); i++)
    {
       if (strcasecmp(g_settings.input.driver, input_drivers[i]->ident) == 0)
       {
@@ -125,7 +146,7 @@ static void find_input_driver(void)
    SSNES_ERR("Couldn't find any input driver named \"%s\"\n", g_settings.input.driver);
    fprintf(stderr, "Available input drivers are:\n");
    for (int i = 0; i < sizeof(input_drivers) / sizeof(input_driver_t*); i++)
-      fprintf(stderr, "\t%s\n", video_drivers[i]->ident);
+      fprintf(stderr, "\t%s\n", input_drivers[i]->ident);
 
    exit(1);
 }
@@ -142,24 +163,139 @@ void uninit_drivers(void)
    uninit_audio();
 }
 
+#ifdef HAVE_DYLIB
+static void init_dsp_plugin(void)
+{
+   if (!(*g_settings.audio.dsp_plugin))
+      return;
+
+   g_extern.audio_data.dsp_lib = dylib_load(g_settings.audio.dsp_plugin);
+   if (!g_extern.audio_data.dsp_lib)
+   {
+      SSNES_ERR("Failed to open DSP plugin: \"%s\" ...\n", g_settings.audio.dsp_plugin);
+      return;
+   }
+
+   const ssnes_dsp_plugin_t* (*SSNES_API_CALLTYPE plugin_init)(void) = 
+      (const ssnes_dsp_plugin_t *(SSNES_API_CALLTYPE*)(void))dylib_proc(g_extern.audio_data.dsp_lib, "ssnes_dsp_plugin_init");
+   if (!plugin_init)
+   {
+      SSNES_ERR("Failed to find symbol \"ssnes_dsp_plugin_init\" in DSP plugin.\n");
+      goto error;
+   }
+
+   g_extern.audio_data.dsp_plugin = plugin_init();
+   if (!g_extern.audio_data.dsp_plugin)
+   {
+      SSNES_ERR("Failed to get a valid DSP plugin.\n");
+      goto error;
+   }
+
+   if (g_extern.audio_data.dsp_plugin->api_version != SSNES_DSP_API_VERSION)
+   {
+      SSNES_ERR("DSP plugin API mismatch! SSNES: %d, Plugin: %d\n", SSNES_DSP_API_VERSION, g_extern.audio_data.dsp_plugin->api_version);
+      goto error;
+   }
+
+   SSNES_LOG("Loaded DSP plugin: \"%s\"\n", g_extern.audio_data.dsp_plugin->ident ? g_extern.audio_data.dsp_plugin->ident : "Unknown");
+
+   const ssnes_dsp_info_t info = {
+      .input_rate = g_settings.audio.in_rate,
+      .output_rate = g_settings.audio.out_rate
+   };
+
+   g_extern.audio_data.dsp_handle = g_extern.audio_data.dsp_plugin->init(&info);
+   if (!g_extern.audio_data.dsp_handle)
+   {
+      SSNES_ERR("Failed to init DSP plugin.\n");
+      goto error;
+   }
+
+   return;
+
+error:
+   if (g_extern.audio_data.dsp_lib)
+      dylib_close(g_extern.audio_data.dsp_lib);
+   g_extern.audio_data.dsp_plugin = NULL;
+   g_extern.audio_data.dsp_lib = NULL;
+}
+
+static void deinit_dsp_plugin(void)
+{
+   if (g_extern.audio_data.dsp_lib && g_extern.audio_data.dsp_plugin)
+   {
+      g_extern.audio_data.dsp_plugin->free(g_extern.audio_data.dsp_handle);
+      dylib_close(g_extern.audio_data.dsp_lib);
+   }
+}
+#endif
+
+static void adjust_audio_input_rate(void)
+{
+   static bool first = true;
+   if (!first)
+      return;
+
+   if (g_extern.system.timing_set)
+   {
+      float timing_skew = fabs(1.0f - g_extern.system.timing.fps / g_settings.video.refresh_rate);
+      if (timing_skew > 0.05f) // We don't want to adjust pitch too much. If we have extreme cases, just don't readjust at all.
+      {
+         SSNES_LOG("Timings deviate too much. Will not adjust. (Display = %.2f Hz, Game = %.2lf Hz)\n",
+               g_settings.video.refresh_rate,
+               g_extern.system.timing.fps);
+
+         g_settings.video.refresh_rate = g_extern.system.timing.fps;
+      }
+   }
+
+   if (g_extern.system.timing_set)
+   {
+      g_settings.audio.in_rate = g_extern.system.timing.sample_rate *
+         (g_settings.video.refresh_rate / g_extern.system.timing.fps);
+   }
+   else
+   {
+      g_settings.audio.in_rate = 32040.5 *
+         (g_settings.video.refresh_rate / (21477272.0 / 357366.0)); // SNES metrics.
+   }
+
+   SSNES_LOG("Set audio input rate to: %.2f Hz.\n", g_settings.audio.in_rate);
+   first = false;
+}
+
 #define AUDIO_CHUNK_SIZE_BLOCKING 64
 #define AUDIO_CHUNK_SIZE_NONBLOCKING 2048 // So we don't get complete line-noise when fast-forwarding audio.
 #define AUDIO_MAX_RATIO 16
 void init_audio(void)
 {
+   // Accomodate rewind since at some point we might have two full buffers.
+   size_t max_bufsamples = AUDIO_CHUNK_SIZE_NONBLOCKING * 2;
+
+   // Used for recording even if audio isn't enabled.
+   assert((g_extern.audio_data.conv_outsamples = malloc(max_bufsamples * sizeof(int16_t) * AUDIO_MAX_RATIO)));
+   g_extern.audio_data.chunk_size = g_extern.audio_data.block_chunk_size;
+
+   // Needs to be able to hold full content of a full max_bufsamples in addition to its own.
+   assert((g_extern.audio_data.rewind_buf = malloc(max_bufsamples * sizeof(int16_t))));
+   g_extern.audio_data.rewind_size = max_bufsamples;
+
    if (!g_settings.audio.enable)
    {
       g_extern.audio_active = false;
       return;
    }
 
+   adjust_audio_input_rate();
    find_audio_driver();
 
    g_extern.audio_data.block_chunk_size = AUDIO_CHUNK_SIZE_BLOCKING;
    g_extern.audio_data.nonblock_chunk_size = AUDIO_CHUNK_SIZE_NONBLOCKING;
 
-   driver.audio_data = driver.audio->init(strlen(g_settings.audio.device) ? g_settings.audio.device : NULL, g_settings.audio.out_rate, g_settings.audio.latency);
-   if ( driver.audio_data == NULL )
+   driver.audio_data = driver.audio->init(*g_settings.audio.device ? g_settings.audio.device : NULL,
+         g_settings.audio.out_rate, g_settings.audio.latency);
+
+   if (!driver.audio_data)
       g_extern.audio_active = false;
 
    if (g_extern.audio_active && driver.audio->use_float && driver.audio->use_float(driver.audio_data))
@@ -170,56 +306,54 @@ void init_audio(void)
       driver.audio->set_nonblock_state(driver.audio_data, true);
       g_extern.audio_data.chunk_size = g_extern.audio_data.nonblock_chunk_size;
    }
-   else
-      g_extern.audio_data.chunk_size = g_extern.audio_data.block_chunk_size;
 
-#ifdef HAVE_SRC
-   int err;
-   g_extern.audio_data.source = src_new(g_settings.audio.src_quality, 2, &err);
+   g_extern.audio_data.source = hermite_new();
    if (!g_extern.audio_data.source)
       g_extern.audio_active = false;
-#else
-   g_extern.audio_data.source = hermite_new(2);
-   if (!g_extern.audio_data.source)
-      g_extern.audio_active = false;
-#endif
 
-   size_t max_bufsamples = g_extern.audio_data.block_chunk_size > g_extern.audio_data.nonblock_chunk_size ?
-      g_extern.audio_data.block_chunk_size : g_extern.audio_data.nonblock_chunk_size;
-
-   assert(g_settings.audio.out_rate < g_settings.audio.in_rate * AUDIO_MAX_RATIO);
    assert((g_extern.audio_data.data = malloc(max_bufsamples * sizeof(float))));
    g_extern.audio_data.data_ptr = 0;
+   assert(g_settings.audio.out_rate < g_settings.audio.in_rate * AUDIO_MAX_RATIO);
    assert((g_extern.audio_data.outsamples = malloc(max_bufsamples * sizeof(float) * AUDIO_MAX_RATIO)));
-   assert((g_extern.audio_data.conv_outsamples = malloc(max_bufsamples * sizeof(int16_t) * AUDIO_MAX_RATIO)));
+
+   g_extern.audio_data.src_ratio =
+      (double)g_settings.audio.out_rate / g_settings.audio.in_rate;
+
+#ifdef HAVE_DYLIB
+   init_dsp_plugin();
+#endif
 }
 
 void uninit_audio(void)
 {
+   free(g_extern.audio_data.conv_outsamples); g_extern.audio_data.conv_outsamples = NULL;
+   g_extern.audio_data.data_ptr = 0;
+   free(g_extern.audio_data.rewind_buf);
+   g_extern.audio_data.rewind_buf = NULL;
+
    if (!g_settings.audio.enable)
    {
       g_extern.audio_active = false;
       return;
    }
 
-   if ( driver.audio_data && driver.audio )
+   if (driver.audio_data && driver.audio)
       driver.audio->free(driver.audio_data);
 
-   if ( g_extern.audio_data.source )
-   {
-#ifdef HAVE_SRC
-      src_delete(g_extern.audio_data.source);
-#else
+   if (g_extern.audio_data.source)
       hermite_free(g_extern.audio_data.source);
-#endif
-   }
 
-   free(g_extern.audio_data.data); g_extern.audio_data.data = NULL;
-   free(g_extern.audio_data.outsamples); g_extern.audio_data.outsamples = NULL;
-   free(g_extern.audio_data.conv_outsamples); g_extern.audio_data.conv_outsamples = NULL;
+   free(g_extern.audio_data.data);
+   g_extern.audio_data.data = NULL;
+   free(g_extern.audio_data.outsamples);
+   g_extern.audio_data.outsamples = NULL;
+
+#ifdef HAVE_DYLIB
+   deinit_dsp_plugin();
+#endif
 }
 
-#ifdef HAVE_FILTER
+#ifdef HAVE_DYLIB
 static void init_filter(void)
 {
    if (g_extern.filter.active)
@@ -235,8 +369,12 @@ static void init_filter(void)
       return;
    }
 
-   g_extern.filter.psize = dylib_proc(g_extern.filter.lib, "filter_size");
-   g_extern.filter.prender = dylib_proc(g_extern.filter.lib, "filter_render");
+   g_extern.filter.psize = 
+      (void (*)(unsigned*, unsigned*))dylib_proc(g_extern.filter.lib, "filter_size");
+   g_extern.filter.prender = 
+      (void (*)(uint32_t*, uint32_t*, 
+                unsigned, const uint16_t*, 
+                unsigned, unsigned, unsigned))dylib_proc(g_extern.filter.lib, "filter_render");
    if (!g_extern.filter.psize || !g_extern.filter.prender)
    {
       SSNES_ERR("Failed to find functions in filter...\n");
@@ -247,23 +385,23 @@ static void init_filter(void)
 
    g_extern.filter.active = true;
 
-   unsigned width = 512;
-   unsigned height = 512;
+   unsigned width = g_extern.system.geom.max_width;
+   unsigned height = g_extern.system.geom.max_height;
    g_extern.filter.psize(&width, &height);
 
    unsigned pow2_x = next_pow2(ceil(width));
    unsigned pow2_y = next_pow2(ceil(height));
    unsigned maxsize = pow2_x > pow2_y ? pow2_x : pow2_y; 
-   g_extern.filter.scale = maxsize / 256;
+   g_extern.filter.scale = maxsize / SSNES_SCALE_BASE;
 
-   g_extern.filter.buffer = malloc(256 * 256 * g_extern.filter.scale * g_extern.filter.scale * sizeof(uint32_t));
-   g_extern.filter.pitch = 256 * g_extern.filter.scale * sizeof(uint32_t);
+   g_extern.filter.buffer = malloc(SSNES_SCALE_BASE * SSNES_SCALE_BASE * g_extern.filter.scale * g_extern.filter.scale * sizeof(uint32_t));
+   g_extern.filter.pitch = SSNES_SCALE_BASE * g_extern.filter.scale * sizeof(uint32_t);
    assert(g_extern.filter.buffer);
 
    g_extern.filter.colormap = malloc(32768 * sizeof(uint32_t));
    assert(g_extern.filter.colormap);
 
-   // Set up conversion map from 16-bit XBGR1555 to 32-bit RGBA.
+   // Set up conversion map from 16-bit XRGB1555 to 32-bit ARGB.
    for (int i = 0; i < 32768; i++)
    {
       unsigned r = (i >> 10) & 31;
@@ -273,10 +411,9 @@ static void init_filter(void)
       r = (r << 3) | (r >> 2);
       g = (g << 3) | (g >> 2);
       b = (b << 3) | (b >> 2);
-      g_extern.filter.colormap[i] = (r << 24) | (g << 16) | (b << 8);
+      g_extern.filter.colormap[i] = (r << 16) | (g << 8) | (b << 0);
    }
 }
-#endif
 
 static void deinit_filter(void)
 {
@@ -289,6 +426,7 @@ static void deinit_filter(void)
       free(g_extern.filter.colormap);
    }
 }
+#endif
 
 #ifdef HAVE_XML
 static void init_shader_dir(void)
@@ -313,12 +451,15 @@ static void deinit_shader_dir(void)
 {
    // It handles NULL, no worries :D
    dir_list_free(g_extern.shader_dir.elems);
+   g_extern.shader_dir.elems = NULL;
+   g_extern.shader_dir.size = 0;
+   g_extern.shader_dir.ptr = 0;
 }
 #endif
 
 void init_video_input(void)
 {
-#ifdef HAVE_FILTER
+#ifdef HAVE_DYLIB
    init_filter();
 #endif
 
@@ -326,8 +467,9 @@ void init_video_input(void)
    init_shader_dir();
 #endif
 
-   // We use at least 512x512 textures to accomodate for hi-res games.
-   unsigned scale = 2;
+   unsigned max_dim = max(g_extern.system.geom.max_width, g_extern.system.geom.max_height);
+   unsigned scale = max_dim / SSNES_SCALE_BASE;
+   scale = max(scale, 1);
 
    find_video_driver();
    find_input_driver();
@@ -335,9 +477,38 @@ void init_video_input(void)
    if (g_extern.filter.active)
       scale = g_extern.filter.scale;
 
+   unsigned width;
+   unsigned height;
+   if (g_settings.video.fullscreen)
+   {
+      width = g_settings.video.fullscreen_x;
+      height = g_settings.video.fullscreen_y;
+   }
+   else
+   {
+      if (g_settings.video.force_aspect && (g_settings.video.aspect_ratio > 0.0f))
+      {
+         width = roundf(g_extern.system.geom.base_height * g_settings.video.xscale * g_settings.video.aspect_ratio);
+         height = roundf(g_extern.system.geom.base_height * g_settings.video.yscale);
+      }
+      else
+      {
+         width = roundf(g_extern.system.geom.base_width * g_settings.video.xscale);
+         height = roundf(g_extern.system.geom.base_height * g_settings.video.yscale);
+      }
+   }
+
+   if (g_settings.video.aspect_ratio < 0.0f)
+   {
+      g_settings.video.aspect_ratio = (float)g_extern.system.geom.base_width / g_extern.system.geom.base_height;
+      SSNES_LOG("Adjusting aspect ratio to %.2f\n", g_settings.video.aspect_ratio);
+   }
+
+   SSNES_LOG("Video @ %ux%u\n", width, height);
+
    video_info_t video = {
-      .width = (g_settings.video.fullscreen) ? g_settings.video.fullscreen_x : (296 * g_settings.video.xscale),
-      .height = (g_settings.video.fullscreen) ? g_settings.video.fullscreen_y : (224 * g_settings.video.yscale),
+      .width = width,
+      .height = height,
       .fullscreen = g_settings.video.fullscreen,
       .vsync = g_settings.video.vsync,
       .force_aspect = g_settings.video.force_aspect,
@@ -349,9 +520,9 @@ void init_video_input(void)
    const input_driver_t *tmp = driver.input;
    driver.video_data = driver.video->init(&video, &driver.input, &driver.input_data);
 
-   if ( driver.video_data == NULL )
+   if (driver.video_data == NULL)
    {
-      SSNES_ERR("Cannot open video driver... Exiting ...\n");
+      SSNES_ERR("Cannot open video driver ... Exiting ...\n");
       exit(1);
    }
 
@@ -362,7 +533,7 @@ void init_video_input(void)
       if (driver.input != NULL)
       {
          driver.input_data = driver.input->init();
-         if ( driver.input_data == NULL )
+         if (driver.input_data == NULL)
          {
             SSNES_ERR("Cannot init input driver. Exiting ...\n");
             exit(1);
@@ -378,13 +549,15 @@ void init_video_input(void)
 
 void uninit_video_input(void)
 {
-   if ( driver.video_data && driver.video )
-      driver.video->free(driver.video_data);
-
-   if ( driver.input_data != driver.video_data && driver.input )
+   if (driver.input_data != driver.video_data && driver.input)
       driver.input->free(driver.input_data);
 
+   if (driver.video_data && driver.video)
+      driver.video->free(driver.video_data);
+
+#ifdef HAVE_DYLIB
    deinit_filter();
+#endif
 
 #ifdef HAVE_XML
    deinit_shader_dir();

driver.h

@@ -24,10 +24,14 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <unistd.h>
+#include "input/keysym.h"
 
+// SNES has 12 buttons from 0-11 (libsnes.hpp)
+#define SSNES_FIRST_META_KEY 12
 enum
 {
-   SSNES_FAST_FORWARD_KEY = 0x666, // Hurr, durr
+   SSNES_FAST_FORWARD_KEY = SSNES_FIRST_META_KEY,
+   SSNES_FAST_FORWARD_HOLD_KEY,
    SSNES_LOAD_STATE_KEY,
    SSNES_SAVE_STATE_KEY,
    SSNES_FULLSCREEN_TOGGLE_KEY,
@@ -39,24 +43,33 @@ enum
    SSNES_REWIND,
    SSNES_MOVIE_RECORD_TOGGLE,
    SSNES_PAUSE_TOGGLE,
+   SSNES_FRAMEADVANCE,
    SSNES_RESET,
    SSNES_SHADER_NEXT,
    SSNES_SHADER_PREV,
+   SSNES_CHEAT_INDEX_PLUS,
+   SSNES_CHEAT_INDEX_MINUS,
+   SSNES_CHEAT_TOGGLE,
+   SSNES_SCREENSHOT,
+   SSNES_DSP_CONFIG,
+   SSNES_MUTE,
+
+   SSNES_BIND_LIST_END
 };
 
 
 struct snes_keybind
 {
    int id;
-   uint16_t key;
+   enum ssnes_key key;
    uint16_t joykey;
    uint32_t joyaxis;
 };
 
 typedef struct video_info
 {
-   int width;
-   int height;
+   unsigned width;
+   unsigned height;
    bool fullscreen;
    bool vsync;
    bool force_aspect;
@@ -67,12 +80,12 @@ typedef struct video_info
 
 typedef struct audio_driver
 {
-   void* (*init)(const char* device, int rate, int latency);
-   ssize_t (*write)(void* data, const void* buf, size_t size);
-   bool (*stop)(void* data);
-   bool (*start)(void* data);
-   void (*set_nonblock_state)(void* data, bool toggle); // Should we care about blocking in audio thread? Fast forwarding.
-   void (*free)(void* data);
+   void *(*init)(const char *device, unsigned rate, unsigned latency);
+   ssize_t (*write)(void *data, const void *buf, size_t size);
+   bool (*stop)(void *data);
+   bool (*start)(void *data);
+   void (*set_nonblock_state)(void *data, bool toggle); // Should we care about blocking in audio thread? Fast forwarding.
+   void (*free)(void *data);
    bool (*use_float)(void *data); // Defines if driver will take standard floating point samples, or int16_t samples.
    const char *ident;
 } audio_driver_t;
@@ -98,25 +111,25 @@ typedef struct audio_driver
 
 typedef struct input_driver
 {
-   void* (*init)(void);
-   void (*poll)(void* data);
-   int16_t (*input_state)(void* data, const struct snes_keybind **snes_keybinds, bool port, unsigned device, unsigned index, unsigned id);
-   bool (*key_pressed)(void* data, int key);
-   void (*free)(void* data);
+   void *(*init)(void);
+   void (*poll)(void *data);
+   int16_t (*input_state)(void *data, const struct snes_keybind **snes_keybinds, bool port, unsigned device, unsigned index, unsigned id);
+   bool (*key_pressed)(void *data, int key);
+   void (*free)(void *data);
    const char *ident;
 } input_driver_t;
 
 typedef struct video_driver
 {
-   void* (*init)(video_info_t *video, const input_driver_t **input, void **input_data); 
+   void *(*init)(const video_info_t *video, const input_driver_t **input, void **input_data); 
    // Should the video driver act as an input driver as well? :) The video init might preinitialize an input driver to override the settings in case the video driver relies on input driver for event handling, e.g.
-   bool (*frame)(void* data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg); // msg is for showing a message on the screen along with the video frame.
-   void (*set_nonblock_state)(void* data, bool toggle); // Should we care about syncing to vblank? Fast forwarding.
+   bool (*frame)(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg); // msg is for showing a message on the screen along with the video frame.
+   void (*set_nonblock_state)(void *data, bool toggle); // Should we care about syncing to vblank? Fast forwarding.
    // Is the window still active?
    bool (*alive)(void *data);
    bool (*focus)(void *data); // Does the window have focus?
    bool (*xml_shader)(void *data, const char *path); // Sets XML-shader. Might not be implemented.
-   void (*free)(void* data);
+   void (*free)(void *data);
    const char *ident;
 } video_driver_t;
 
@@ -151,10 +164,17 @@ extern const audio_driver_t audio_jack;
 extern const audio_driver_t audio_sdl;
 extern const audio_driver_t audio_xa;
 extern const audio_driver_t audio_pulse;
+extern const audio_driver_t audio_ext;
+extern const audio_driver_t audio_dsound;
+extern const audio_driver_t audio_coreaudio;
+extern const audio_driver_t audio_ps3;
 extern const video_driver_t video_gl;
 extern const video_driver_t video_xvideo;
+extern const video_driver_t video_sdl;
+extern const video_driver_t video_ext;
 extern const input_driver_t input_sdl;
 extern const input_driver_t input_x;
+extern const input_driver_t input_ps3;
 ////////////////////////////////////////////////
 
 #endif

dynamic.c

@@ -17,35 +17,42 @@
 
 #include "dynamic.h"
 #include "general.h"
+#include "strl.h"
 #include <string.h>
+#include <assert.h>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <libsnes.hpp>
+#include <stdbool.h>
+#include "libsnes.hpp"
 
+#ifdef NEED_DYNAMIC
 #ifdef _WIN32
 #include <windows.h>
 #else
 #include <dlfcn.h>
 #endif
-
-#ifdef HAVE_DYNAMIC
-#define DLSYM(lib, x) dylib_proc(lib, #x)
-
-#define SYM(x) do { \
-   p##x = DLSYM(lib_handle, x); \
-   if (p##x == NULL) { SSNES_ERR("Failed to load symbol: \"%s\"\n", #x); exit(1); } \
-} while(0)
-
-#define OPT_SYM(x) do { \
-   p##x = DLSYM(lib_handle, x); \
-} while(0)
-
-static dylib_t lib_handle = NULL;
 #endif
 
+#ifdef NEED_DYNAMIC
+#define DLSYM(lib, x) dylib_proc(lib, #x)
+
+#define SYM(type, x) do { \
+   p##x = (type)DLSYM(lib_handle, x); \
+   if (p##x == NULL) { SSNES_ERR("Failed to load symbol: \"%s\"\n", #x); exit(1); } \
+} while (0)
+
+#define OPT_SYM(type, x) do { \
+   p##x = (type)DLSYM(lib_handle, x); \
+} while (0)
+
+#endif
+
+#ifdef HAVE_DYNAMIC
+static dylib_t lib_handle = NULL;
+#endif
 
 void (*psnes_init)(void);
 
@@ -57,6 +64,9 @@ void (*psnes_set_input_state)(snes_input_state_t);
 void (*psnes_reset)(void);
 void (*psnes_run)(void);
 
+void (*psnes_cheat_reset)(void);
+void (*psnes_cheat_set)(unsigned, bool, const char*);
+
 const char *(*psnes_library_id)(void) = NULL;
 unsigned (*psnes_library_revision_minor)(void);
 unsigned (*psnes_library_revision_major)(void);
@@ -92,6 +102,11 @@ unsigned (*psnes_get_memory_size)(unsigned);
 void (*psnes_unload_cartridge)(void);
 void (*psnes_term)(void);
 
+#ifdef NEED_DYNAMIC
+static void set_environment(void);
+#endif
+static void set_environment_defaults(void);
+
 #ifdef HAVE_DYNAMIC
 static void load_dynamic(void)
 {
@@ -103,39 +118,44 @@ static void load_dynamic(void)
       exit(1);
    }
 
-   SYM(snes_init);
-   SYM(snes_set_video_refresh);
-   SYM(snes_set_audio_sample);
-   SYM(snes_set_input_poll);
-   SYM(snes_set_input_state);
-   OPT_SYM(snes_library_id);
-   SYM(snes_library_revision_minor);
-   SYM(snes_library_revision_major);
-   SYM(snes_reset);
-   SYM(snes_run);
-   SYM(snes_get_region);
-   SYM(snes_load_cartridge_normal);
-   SYM(snes_load_cartridge_super_game_boy);
-   SYM(snes_load_cartridge_bsx);
-   SYM(snes_load_cartridge_bsx_slotted);
-   SYM(snes_load_cartridge_sufami_turbo);
-   SYM(snes_set_controller_port_device);
-   SYM(snes_serialize_size);
-   SYM(snes_serialize);
-   SYM(snes_unserialize);
-   SYM(snes_set_cartridge_basename);
-   SYM(snes_get_memory_data);
-   SYM(snes_get_memory_size);
-   SYM(snes_unload_cartridge);
-   SYM(snes_term);
+   SYM(void (*)(void), snes_init);
+   SYM(void (*)(snes_video_refresh_t), snes_set_video_refresh);
+   SYM(void (*)(snes_audio_sample_t), snes_set_audio_sample);
+   SYM(void (*)(snes_input_poll_t), snes_set_input_poll);
+   SYM(void (*)(snes_input_state_t), snes_set_input_state);
+   SYM(const char *(*)(void), snes_library_id);
+   SYM(unsigned (*)(void), snes_library_revision_minor);
+   SYM(unsigned (*)(void), snes_library_revision_major);
+   SYM(void (*)(void), snes_cheat_reset);
+   SYM(void (*)(unsigned, bool, const char*), snes_cheat_set);
+   SYM(void (*)(void), snes_reset);
+   SYM(void (*)(void), snes_run);
+   SYM(bool (*)(void), snes_get_region);
+   SYM(bool (*)(const char*, const uint8_t*, unsigned), snes_load_cartridge_normal);
+   SYM(bool (*)(const char*, const uint8_t*, unsigned, 
+            const char*, const uint8_t*, unsigned), snes_load_cartridge_super_game_boy);
+   SYM(bool (*)(const char*, const uint8_t*, unsigned, 
+            const char*, const uint8_t*, unsigned), snes_load_cartridge_bsx);
+   SYM(bool (*)(const char*, const uint8_t*, unsigned, 
+            const char*, const uint8_t*, unsigned), snes_load_cartridge_bsx_slotted);
+   SYM(bool (*)(const char*, const uint8_t*, unsigned, 
+            const char*, const uint8_t*, unsigned, 
+            const char*, const uint8_t*, unsigned), snes_load_cartridge_sufami_turbo);
+   SYM(void (*)(bool, unsigned), snes_set_controller_port_device);
+   SYM(unsigned (*)(void), snes_serialize_size);
+   SYM(bool (*)(uint8_t*, unsigned), snes_serialize);
+   SYM(bool (*)(const uint8_t*, unsigned), snes_unserialize);
+   SYM(void (*)(const char*), snes_set_cartridge_basename);
+   SYM(uint8_t *(*)(unsigned), snes_get_memory_data);
+   SYM(unsigned (*)(unsigned), snes_get_memory_size);
+   SYM(void (*)(void), snes_unload_cartridge);
+   SYM(void (*)(void), snes_term);
 }
-#endif
-
+#else
 #define SSYM(x) do { \
    p##x = x; \
-} while(0)
+} while (0)
 
-#ifndef HAVE_DYNAMIC
 static void set_statics(void)
 {
    SSYM(snes_init);
@@ -145,6 +165,9 @@ static void set_statics(void)
    SSYM(snes_set_input_state);
    SSYM(snes_library_revision_minor);
    SSYM(snes_library_revision_major);
+   SSYM(snes_library_id);
+   SSYM(snes_cheat_reset);
+   SSYM(snes_cheat_set);
    SSYM(snes_reset);
    SSYM(snes_run);
    SSYM(snes_get_region);
@@ -165,22 +188,47 @@ static void set_statics(void)
 }
 #endif
 
-void init_dlsym(void)
+void init_libsnes_sym(void)
 {
+   // Guarantee that we can do "dirty" casting.
+   // Every OS that this program supports should pass this ...
+   assert(sizeof(void*) == sizeof(void (*)(void)));
+
 #ifdef HAVE_DYNAMIC
-   if (strlen(g_settings.libsnes) > 0)
-      load_dynamic();
-   else
+   // Try to verify that -lsnes was not linked in from other modules
+   // since loading it dynamically and with -l will fail hard.
+   function_t sym = dylib_proc(NULL, "snes_init");
+   if (sym)
    {
-      SSNES_ERR("This binary is built to use runtime dynamic binding of libsnes. Set libsnes_path in config to load a libsnes library dynamically.\n");
+      SSNES_ERR("Serious problem! SSNES wants to load libsnes dyamically, but it is already linked!\n"); 
+      SSNES_ERR("This could happen if other modules SSNES depends on link against libsnes directly.\n");
+      SSNES_ERR("Proceeding could cause a crash! Aborting ...\n");
       exit(1);
    }
+
+   if (!*g_settings.libsnes)
+   {
+#if defined(_WIN32)
+      strlcpy(g_settings.libsnes, "snes.dll", sizeof(g_settings.libsnes));
+#elif defined(__APPLE__)
+      strlcpy(g_settings.libsnes, "libsnes.dylib", sizeof(g_settings.libsnes));
 #else
-      set_statics();
+      strlcpy(g_settings.libsnes, "libsnes.so", sizeof(g_settings.libsnes));
+#endif
+   }
+
+   load_dynamic();
+#else
+   set_statics();
+#endif
+
+   set_environment_defaults();
+#ifdef NEED_DYNAMIC
+   set_environment();
 #endif
 }
 
-void uninit_dlsym(void)
+void uninit_libsnes_sym(void)
 {
 #ifdef HAVE_DYNAMIC
    if (lib_handle)
@@ -188,6 +236,7 @@ void uninit_dlsym(void)
 #endif
 }
 
+#ifdef NEED_DYNAMIC
 // Platform independent dylib loading.
 dylib_t dylib_load(const char *path)
 {
@@ -198,16 +247,29 @@ dylib_t dylib_load(const char *path)
 #endif
 }
 
-void* dylib_proc(dylib_t lib, const char *proc)
+function_t dylib_proc(dylib_t lib, const char *proc)
 {
 #ifdef _WIN32
-   void *sym = (void*)GetProcAddress(lib, proc);
+   function_t sym = (function_t)GetProcAddress(lib ? lib : GetModuleHandle(NULL), proc);
 #else
-   void *sym = dlsym(lib, proc);
+   void *ptr_sym = NULL;
+   if (lib)
+      ptr_sym = dlsym(lib, proc); 
+   else
+   {
+      void *handle = dlopen(NULL, RTLD_LAZY);
+      if (handle)
+      {
+         ptr_sym = dlsym(handle, proc);
+         dlclose(handle);
+      }
+   }
+
+   // Dirty hack to workaround the non-legality of (void*) -> fn-pointer casts.
+   function_t sym;
+   memcpy(&sym, &ptr_sym, sizeof(void*));
 #endif
 
-   if (!sym)
-      SSNES_WARN("Failed to load symbol \"%s\"\n", proc);
    return sym;
 }
 
@@ -220,3 +282,92 @@ void dylib_close(dylib_t lib)
 #endif
 }
 
+static bool environment_cb(unsigned cmd, void *data)
+{
+   switch (cmd)
+   {
+      case SNES_ENVIRONMENT_GET_FULLPATH:
+         *(const char**)data = g_extern.system.fullpath;
+         SSNES_LOG("Environ FULLPATH: \"%s\"\n", g_extern.system.fullpath);
+         break;
+
+      case SNES_ENVIRONMENT_SET_GEOMETRY:
+         g_extern.system.geom = *(const struct snes_geometry*)data;
+         g_extern.system.geom.max_width = next_pow2(g_extern.system.geom.max_width);
+         g_extern.system.geom.max_height = next_pow2(g_extern.system.geom.max_height);
+         SSNES_LOG("Environ SET_GEOMETRY: (%ux%u) / (%ux%u)\n",
+               g_extern.system.geom.base_width,
+               g_extern.system.geom.base_height,
+               g_extern.system.geom.max_width,
+               g_extern.system.geom.max_height);
+         break;
+
+      case SNES_ENVIRONMENT_SET_PITCH:
+         g_extern.system.pitch = *(const unsigned*)data;
+         SSNES_LOG("Environ SET_PITCH: %u\n", g_extern.system.pitch);
+         break;
+
+      case SNES_ENVIRONMENT_GET_OVERSCAN:
+         *(bool*)data = !g_settings.video.crop_overscan;
+         SSNES_LOG("Environ GET_OVERSCAN: %u\n", (unsigned)!g_settings.video.crop_overscan);
+         break;
+
+      case SNES_ENVIRONMENT_SET_TIMING:
+         g_extern.system.timing = *(const struct snes_system_timing*)data;
+         g_extern.system.timing_set = true;
+         SSNES_LOG("Environ SET_TIMING: %.3lf Hz/ %.3lf Hz\n", g_extern.system.timing.fps, g_extern.system.timing.sample_rate);
+         break;
+
+      case SNES_ENVIRONMENT_GET_CAN_DUPE:
+         *(bool*)data = true;
+         SSNES_LOG("Environ GET_CAN_DUPE: true\n");
+         break;
+
+      case SNES_ENVIRONMENT_SET_NEED_FULLPATH:
+         g_extern.system.need_fullpath = *(const bool*)data;
+         SSNES_LOG("Environ SET_NEED_FULLPATH: %s\n", g_extern.system.need_fullpath ? "true" : "false");
+         break;
+
+      case SNES_ENVIRONMENT_GET_CAN_REWIND:
+         *(bool*)data = g_settings.rewind_enable;
+         SSNES_LOG("Environ GET_CAN_REWIND: %s\n", g_settings.rewind_enable ? "true" : "false");
+         break;
+
+      default:
+         SSNES_LOG("Environ UNSUPPORTED (#%u)!\n", cmd);
+         return false;
+   }
+
+   return true;
+}
+
+// SSNES extension hooks. Totally optional 'n shizz :)
+static void set_environment(void)
+{
+#ifdef HAVE_DYNAMIC
+   dylib_t lib = lib_handle;
+#else
+   dylib_t lib = NULL;
+#endif
+
+   void (*psnes_set_environment)(snes_environment_t) = 
+      (void (*)(snes_environment_t))dylib_proc(lib, "snes_set_environment");
+
+   if (psnes_set_environment)
+      psnes_set_environment(environment_cb);
+}
+#endif
+
+// Assume SNES as defaults.
+static void set_environment_defaults(void)
+{
+   SSNES_LOG("Setting environment defaults (SNES)\n");
+   g_extern.system.pitch = 0; // 0 is classic libsnes semantics.
+   g_extern.system.geom = (struct snes_geometry) {
+      .base_width = 256,
+      .base_height = 224,
+      .max_width = 512,
+      .max_height = 512,
+   };
+}
+

dynamic.h

@@ -19,16 +19,29 @@
 #define __DYNAMIC_H
 
 #include <stdbool.h>
-#include <libsnes.hpp>
+#include "libsnes.hpp"
 
-void init_dlsym(void);
-void uninit_dlsym(void);
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined(HAVE_DYNAMIC) || defined(HAVE_DYLIB)
+#define NEED_DYNAMIC
+#else
+#undef NEED_DYNAMIC
+#endif
+
+void init_libsnes_sym(void);
+void uninit_libsnes_sym(void);
 
 typedef void *dylib_t;
+#ifdef NEED_DYNAMIC
+typedef void (*function_t)(void);
 
 dylib_t dylib_load(const char *path);
 void dylib_close(dylib_t lib);
-void* dylib_proc(dylib_t lib, const char *proc);
+function_t dylib_proc(dylib_t lib, const char *proc);
+#endif
 
 extern void (*psnes_init)(void);
 
@@ -37,7 +50,10 @@ extern void (*psnes_set_audio_sample)(snes_audio_sample_t);
 extern void (*psnes_set_input_poll)(snes_input_poll_t);
 extern void (*psnes_set_input_state)(snes_input_state_t);
 
-extern const char* (*psnes_library_id)(void);
+extern void (*psnes_cheat_reset)(void);
+extern void (*psnes_cheat_set)(unsigned, bool, const char*);
+
+extern const char *(*psnes_library_id)(void);
 extern unsigned (*psnes_library_revision_minor)(void);
 extern unsigned (*psnes_library_revision_major)(void);
 

fifo_buffer.c

@@ -13,19 +13,20 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "buffer.h"
+#include "fifo_buffer.h"
+#include <stdint.h>
 
-struct rsound_fifo_buffer
+struct fifo_buffer
 {
-   char *buffer;
+   uint8_t *buffer;
    size_t bufsize;
    size_t first;
    size_t end;
 };
 
-rsound_fifo_buffer_t* rsnd_fifo_new(size_t size)
+fifo_buffer_t *fifo_new(size_t size)
 {
-   rsound_fifo_buffer_t *buf = calloc(1, sizeof(*buf));
+   fifo_buffer_t *buf = calloc(1, sizeof(*buf));
    if (buf == NULL)
       return NULL;
 
@@ -40,20 +41,14 @@ rsound_fifo_buffer_t* rsnd_fifo_new(size_t size)
    return buf;
 }
 
-void rsnd_fifo_free(rsound_fifo_buffer_t* buffer)
+void fifo_free(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    free(buffer->buffer);
    free(buffer);
 }
 
-size_t rsnd_fifo_read_avail(rsound_fifo_buffer_t* buffer)
+size_t fifo_read_avail(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    size_t first = buffer->first;
    size_t end = buffer->end;
    if (end < first)
@@ -61,11 +56,8 @@ size_t rsnd_fifo_read_avail(rsound_fifo_buffer_t* buffer)
    return end - first;
 }
 
-size_t rsnd_fifo_write_avail(rsound_fifo_buffer_t* buffer)
+size_t fifo_write_avail(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    size_t first = buffer->first;
    size_t end = buffer->end;
    if (end < first)
@@ -74,13 +66,8 @@ size_t rsnd_fifo_write_avail(rsound_fifo_buffer_t* buffer)
    return (buffer->bufsize - 1) - (end - first);
 }
 
-void rsnd_fifo_write(rsound_fifo_buffer_t* buffer, const void* in_buf, size_t size)
+void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-   assert(in_buf);
-   assert(rsnd_fifo_write_avail(buffer) >= size);
-
    size_t first_write = size;
    size_t rest_write = 0;
    if (buffer->end + size > buffer->bufsize)
@@ -91,19 +78,14 @@ void rsnd_fifo_write(rsound_fifo_buffer_t* buffer, const void* in_buf, size_t si
 
    memcpy(buffer->buffer + buffer->end, in_buf, first_write);
    if (rest_write > 0)
-      memcpy(buffer->buffer, (const char*)in_buf + first_write, rest_write);
+      memcpy(buffer->buffer, (const uint8_t*)in_buf + first_write, rest_write);
 
    buffer->end = (buffer->end + size) % buffer->bufsize;
 }
 
 
-void rsnd_fifo_read(rsound_fifo_buffer_t* buffer, void* in_buf, size_t size)
+void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-   assert(in_buf);
-   assert(rsnd_fifo_read_avail(buffer) >= size);
-
    size_t first_read = size;
    size_t rest_read = 0;
    if (buffer->first + size > buffer->bufsize)
@@ -112,9 +94,9 @@ void rsnd_fifo_read(rsound_fifo_buffer_t* buffer, void* in_buf, size_t size)
       rest_read = size - first_read;
    }
 
-   memcpy(in_buf, (const char*)buffer->buffer + buffer->first, first_read);
+   memcpy(in_buf, (const uint8_t*)buffer->buffer + buffer->first, first_read);
    if (rest_read > 0)
-      memcpy((char*)in_buf + first_read, buffer->buffer, rest_read);
+      memcpy((uint8_t*)in_buf + first_read, buffer->buffer, rest_read);
 
    buffer->first = (buffer->first + size) % buffer->bufsize;
 }

fifo_buffer.h

@@ -21,16 +21,16 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifndef RSD_FIFO_BUF_TYPEDEF
-#define RSD_FIFO_BUF_TYPEDEF
-typedef struct rsound_fifo_buffer rsound_fifo_buffer_t;
+#ifndef FIFO_BUF_TYPEDEF
+#define FIFO_BUF_TYPEDEF
+typedef struct fifo_buffer fifo_buffer_t;
 #endif
 
-rsound_fifo_buffer_t* rsnd_fifo_new(size_t size);
-void rsnd_fifo_write(rsound_fifo_buffer_t* buffer, const void* in_buf, size_t size);
-void rsnd_fifo_read(rsound_fifo_buffer_t* buffer, void* in_buf, size_t size);
-void rsnd_fifo_free(rsound_fifo_buffer_t* buffer);
-size_t rsnd_fifo_read_avail(rsound_fifo_buffer_t* buffer);
-size_t rsnd_fifo_write_avail(rsound_fifo_buffer_t* buffer);
+fifo_buffer_t *fifo_new(size_t size);
+void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size);
+void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size);
+void fifo_free(fifo_buffer_t *buffer);
+size_t fifo_read_avail(fifo_buffer_t *buffer);
+size_t fifo_write_avail(fifo_buffer_t *buffer);
 
 #endif

file.c

@@ -19,23 +19,33 @@
 #include "general.h"
 #include <stdlib.h>
 #include <stdbool.h>
-#include <libsnes.hpp>
+#include "libsnes.hpp"
 #include <string.h>
+#include <assert.h>
+#include <time.h>
 #include "dynamic.h"
 #include "movie.h"
 #include "ups.h"
+#include "bps.h"
+#include "strl.h"
+
+#ifdef HAVE_XML
+#include "sha256.h"
+#endif
 
 #ifdef _WIN32
 #include <io.h>
 #include <fcntl.h>
 #include <windows.h>
+#include <shlwapi.h>
 #else
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <dirent.h>
 #endif
 
 // Generic file loader.
-static ssize_t read_file(const char *path, void **buf)
+ssize_t read_file(const char *path, void **buf)
 {
    void *rom_buf = NULL;
    FILE *file = fopen(path, "rb");
@@ -46,7 +56,7 @@ static ssize_t read_file(const char *path, void **buf)
    long len = ftell(file);
    ssize_t rc = 0;
    rewind(file);
-   rom_buf = malloc(len);
+   rom_buf = malloc(len + 1);
    if (!rom_buf)
    {
       SSNES_ERR("Couldn't allocate memory!\n");
@@ -57,6 +67,9 @@ static ssize_t read_file(const char *path, void **buf)
       SSNES_WARN("Didn't read whole file.\n");
 
    *buf = rom_buf;
+   // Allow for easy reading of strings to be safe.
+   // Will only work with sane character formatting (Unix).
+   ((char*)rom_buf)[len] = '\0'; 
    fclose(file);
    return rc;
 
@@ -68,6 +81,154 @@ error:
    return -1;
 }
 
+// Reads file content as one string.
+bool read_file_string(const char *path, char **buf)
+{
+   *buf = NULL;
+   FILE *file = fopen(path, "r");
+   if (!file)
+      goto error;
+
+   fseek(file, 0, SEEK_END);
+   long len = ftell(file) + 2; // Takes account of being able to read in EOF and '\0' at end.
+   rewind(file);
+
+   *buf = calloc(len, sizeof(char));
+   if (!*buf)
+      goto error;
+
+   char *ptr = *buf;
+
+   while (ptr && !feof(file))
+   {
+      size_t bufsize = (size_t)(((ptrdiff_t)*buf + (ptrdiff_t)len) - (ptrdiff_t)ptr);
+      fgets(ptr, bufsize, file);
+
+      ptr = strchr(ptr, '\0');
+   }
+
+   ptr = strchr(ptr, EOF);
+   if (ptr) *ptr = '\0';
+
+   fclose(file);
+   return true;
+
+error:
+   if (file)
+      fclose(file);
+   if (*buf)
+      free(*buf);
+   return false;
+}
+
+enum patch_type
+{
+   PATCH_NONE,
+   PATCH_UPS,
+   PATCH_BPS
+};
+
+static void patch_rom(uint8_t **buf, ssize_t *size)
+{
+   uint8_t *ret_buf = *buf;
+   ssize_t ret_size = *size;
+
+   ssize_t patch_size = 0;
+   void *patch_data = NULL;
+   enum patch_type type = PATCH_NONE;
+
+   if (g_extern.ups_pref && g_extern.bps_pref)
+   {
+      SSNES_WARN("Both UPS and BPS patch explicitly defined, ignoring both ...\n");
+      return;
+   }
+
+   if (!g_extern.bps_pref && *g_extern.ups_name && (patch_size = read_file(g_extern.ups_name, &patch_data)) >= 0)
+      type = PATCH_UPS;
+   else if (!g_extern.ups_pref && *g_extern.bps_name && (patch_size = read_file(g_extern.bps_name, &patch_data)) >= 0)
+      type = PATCH_BPS;
+
+   if (type == PATCH_NONE)
+   {
+      SSNES_LOG("Did not find a valid ROM patch.\n");
+      return;
+   }
+
+   switch (type)
+   {
+      case PATCH_UPS:
+         SSNES_LOG("Found UPS file in \"%s\", attempting to patch ...\n", g_extern.ups_name);
+         break;
+      case PATCH_BPS:
+         SSNES_LOG("Found BPS file in \"%s\", attempting to patch ...\n", g_extern.bps_name);
+         break;
+
+      default:
+         return; // Should not happen, but.
+   }
+
+   size_t target_size = ret_size * 4; // Just to be sure ...
+   uint8_t *patched_rom = malloc(target_size);
+   if (!patched_rom)
+   {
+      SSNES_ERR("Failed to allocate memory for patched ROM ...\n");
+      goto error;
+   }
+
+   bool success = false;
+   switch (type)
+   {
+      case PATCH_UPS:
+      {
+         ups_error_t err = ups_apply_patch(patch_data, patch_size, ret_buf, ret_size, patched_rom, &target_size);
+         if (err == UPS_SUCCESS)
+         {
+            SSNES_LOG("ROM patched successfully (UPS)!\n");
+            success = true;
+         }
+         else
+            SSNES_ERR("Failed to patch UPS: Error #%u\n", (unsigned)err);
+
+         break;
+      }
+
+      case PATCH_BPS:
+      {
+         bps_error_t err = bps_apply_patch(patch_data, patch_size, ret_buf, ret_size, patched_rom, &target_size);
+         if (err == BPS_SUCCESS)
+         {
+            SSNES_LOG("ROM patched successfully (BPS)!\n");
+            success = true;
+         }
+         else
+            SSNES_ERR("Failed to patch BPS: Error #%u\n", (unsigned)err);
+
+         break;
+      }
+
+      default:
+         return;
+   }
+
+   if (success)
+   {
+      free(ret_buf);
+      *buf = patched_rom;
+      *size = target_size;
+   }
+
+   if (patch_data)
+      free(patch_data);
+
+   return;
+
+error:
+   *buf = ret_buf;
+   *size = ret_size;
+   if (patch_data)
+      free(patch_data);
+}
+
 // Load SNES rom only. Applies a hack for headered ROMs.
 static ssize_t read_rom_file(FILE* file, void** buf)
 {
@@ -90,7 +251,7 @@ static ssize_t read_rom_file(FILE* file, void** buf)
          return -1;
       }
 
-      for(;;)
+      for (;;)
       {
          size_t ret = fread(rom_buf + buf_ptr, 1, buf_size - buf_ptr, stdin);
          buf_ptr += ret;
@@ -135,45 +296,21 @@ static ssize_t read_rom_file(FILE* file, void** buf)
       ret_buf = rom_buf;
    }
 
-   // Patch with UPS.
-   ssize_t ups_patch_size;
-   void *ups_patch = NULL;
-   if (*g_extern.ups_name && (ups_patch_size = read_file(g_extern.ups_name, &ups_patch)) >= 0)
-   {
-      SSNES_LOG("Found UPS file in \"%s\", attempting to patch ...\n", g_extern.ups_name);
-
-      size_t target_size = ret * 4; // Just to be sure ...
-      uint8_t *patched_rom = malloc(target_size);
-      if (patched_rom)
-      {
-         ups_error_t err = ups_apply_patch(ups_patch, ups_patch_size, ret_buf, ret, patched_rom, &target_size);
-         if (err == UPS_SUCCESS)
-         {
-            free(ret_buf);
-            ret_buf = patched_rom;
-            ret = target_size;
-            SSNES_LOG("ROM patched successfully (UPS)!\n");
-         }
-         else
-         {
-            free(patched_rom);
-            SSNES_LOG("ROM failed to patch (UPS).\n");
-         }
-
-         free(ups_patch);
-      }
-   }
-   else if (*g_extern.ups_name)
-      SSNES_LOG("Could not find UPS patch.\n");
-
-   // Remove SMC header if present.
+   // Remove copier header if present (512 first bytes).
    if ((ret & 0x7fff) == 512)
    {
       memmove(ret_buf, ret_buf + 512, ret - 512);
       ret -= 512;
    }
 
+   // Attempt to apply a patch :)
+   patch_rom(&ret_buf, &ret);
+   
    g_extern.cart_crc = crc32_calculate(ret_buf, ret);
+#ifdef HAVE_XML
+   sha256_hash(g_extern.sha256, ret_buf, ret);
+   SSNES_LOG("SHA256 sum: %s\n", g_extern.sha256);
+#endif
    *buf = ret_buf;
    return ret;
 }
@@ -187,13 +324,74 @@ static bool dump_to_file(const char *path, const void *data, size_t size)
       return false;
    else
    {
-      fwrite(data, 1, size, file);
+      bool ret = fwrite(data, 1, size, file) == size;
       fclose(file);
-      return true;
+      return ret;
    }
 }
 
-bool save_state(const char* path)
+static const char *ramtype2str(int type)
+{
+   switch (type)
+   {
+      case SNES_MEMORY_CARTRIDGE_RAM:
+      case SNES_MEMORY_GAME_BOY_RAM:
+      case SNES_MEMORY_BSX_RAM:
+         return ".srm";
+
+      case SNES_MEMORY_CARTRIDGE_RTC:
+      case SNES_MEMORY_GAME_BOY_RTC:
+         return ".rtc";
+
+      case SNES_MEMORY_BSX_PRAM:
+         return ".pram";
+
+      case SNES_MEMORY_SUFAMI_TURBO_A_RAM:
+         return ".aram";
+      case SNES_MEMORY_SUFAMI_TURBO_B_RAM:
+         return ".bram";
+
+      default:
+         return "";
+   }
+}
+
+// Attempt to save valuable RAM data somewhere ...
+static void dump_to_file_desperate(const void *data, size_t size, int type)
+{
+#ifdef _WIN32
+   const char *base = getenv("APPDATA");
+#elif defined(__CELLOS_LV2__)
+   const char *base = NULL;
+#else
+   const char *base = getenv("HOME");
+#endif
+
+   if (!base)
+      goto error;
+
+   char path[MAXPATHLEN];
+   snprintf(path, sizeof(path), "%s/SSNES-recovery-", base);
+   char timebuf[MAXPATHLEN];
+
+   time_t time_;
+   time(&time_);
+   strftime(timebuf, sizeof(timebuf), "%Y-%m-%d-%H-%M-%S", localtime(&time_));
+   strlcat(path, timebuf, sizeof(path));
+   strlcat(path, ramtype2str(type), sizeof(path));
+
+   if (dump_to_file(path, data, size))
+      SSNES_WARN("Succeeded in saving RAM data to \"%s\". Phew! :D\n", path);
+   else
+      goto error;
+
+   return;
+
+error:
+   SSNES_WARN("Failed ... Tough luck ... :(\n");
+}
+
+bool save_state(const char *path)
 {
    SSNES_LOG("Saving state: \"%s\".\n", path);
    size_t size = psnes_serialize_size();
@@ -216,7 +414,7 @@ bool save_state(const char* path)
    return ret;
 }
 
-bool load_state(const char* path)
+bool load_state(const char *path)
 {
    SSNES_LOG("Loading state: \"%s\".\n", path);
    void *buf = NULL;
@@ -229,14 +427,81 @@ bool load_state(const char* path)
    else
    {
       SSNES_LOG("State size: %d bytes.\n", (int)size);
+
+      uint8_t *block_buf[2] = {NULL, NULL};
+      int block_type[2] = {-1, -1};
+      unsigned block_size[2] = {0};
+
+      if (g_settings.block_sram_overwrite)
+      {
+         SSNES_LOG("Blocking SRAM overwrite!\n");
+         switch (g_extern.game_type)
+         {
+            case SSNES_CART_NORMAL:
+               block_type[0] = SNES_MEMORY_CARTRIDGE_RAM;
+               block_type[1] = SNES_MEMORY_CARTRIDGE_RTC;
+               break;
+
+            case SSNES_CART_BSX:
+            case SSNES_CART_BSX_SLOTTED:
+               block_type[0] = SNES_MEMORY_BSX_RAM;
+               block_type[1] = SNES_MEMORY_BSX_PRAM;
+               break;
+
+            case SSNES_CART_SUFAMI:
+               block_type[0] = SNES_MEMORY_SUFAMI_TURBO_A_RAM;
+               block_type[1] = SNES_MEMORY_SUFAMI_TURBO_B_RAM;
+               break;
+
+            case SSNES_CART_SGB:
+               block_type[0] = SNES_MEMORY_GAME_BOY_RAM;
+               block_type[1] = SNES_MEMORY_GAME_BOY_RTC;
+               break;
+         }
+      }
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_type[i] != -1)
+            block_size[i] = psnes_get_memory_size(block_type[i]);
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_size[i])
+            block_buf[i] = malloc(block_size[i]);
+
+      // Backup current SRAM which is overwritten by unserialize.
+      for (unsigned i = 0; i < 2; i++)
+      {
+         if (block_buf[i])
+         {
+            const uint8_t *ptr = psnes_get_memory_data(block_type[i]);
+            if (ptr)
+               memcpy(block_buf[i], ptr, block_size[i]);
+         }
+      }
+
       psnes_unserialize(buf, size);
+
+      // Flush back :D
+      for (unsigned i = 0; i < 2; i++)
+      {
+         if (block_buf[i])
+         {
+            uint8_t *ptr = psnes_get_memory_data(block_type[i]);
+            if (ptr)
+               memcpy(ptr, block_buf[i], block_size[i]);
+         }
+      }
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_buf[i])
+            free(block_buf[i]);
    }
 
    free(buf);
    return true;
 }
 
-void load_ram_file(const char* path, int type)
+void load_ram_file(const char *path, int type)
 {
    size_t size = psnes_get_memory_size(type);
    uint8_t *data = psnes_get_memory_data(type);
@@ -247,18 +512,39 @@ void load_ram_file(const char* path, int type)
    void *buf = NULL;
    ssize_t rc = read_file(path, &buf);
    if (rc <= size)
-      memcpy(data, buf, size);
+      memcpy(data, buf, rc);
 
    free(buf);
 }
 
-void save_ram_file(const char* path, int type)
+void save_ram_file(const char *path, int type)
 {
    size_t size = psnes_get_memory_size(type);
    uint8_t *data = psnes_get_memory_data(type);
 
-   if ( data && size > 0 )
-      dump_to_file(path, data, size);
+   if (data && size > 0)
+   {
+      if (!dump_to_file(path, data, size))
+      {
+         SSNES_ERR("Failed to save SNES RAM!\n");
+         SSNES_WARN("Attempting to recover ...\n");
+         dump_to_file_desperate(data, size, type);
+      }
+   }
+}
+
+static char *load_xml_map(const char *path)
+{
+   char *xml_buf = NULL;
+   if (*path)
+   {
+      if (!read_file_string(path, &xml_buf))
+         SSNES_LOG("Did not find XML memory map in \"%s\"\n", path);
+      else
+         SSNES_LOG("Found XML memory map in \"%s\"\n", path);
+   }
+
+   return xml_buf;
 }
 
 static bool load_sgb_rom(void)
@@ -276,27 +562,25 @@ static bool load_sgb_rom(void)
       goto error;
    }
 
-   extra_rom = fopen(g_extern.gb_rom_path, "rb");
-   if (!extra_rom)
-   {
-      SSNES_ERR("Couldn't open GameBoy ROM!\n");
-      goto error;
-   }
-
-   if ((extra_rom_len = read_rom_file(extra_rom, &extra_rom_buf)) == -1)
+   if ((extra_rom_len = read_file(g_extern.gb_rom_path, &extra_rom_buf)) == -1)
    {
       SSNES_ERR("Cannot read GameBoy rom.\n");
       goto error;
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (!psnes_load_cartridge_super_game_boy(
-            NULL, rom_buf, rom_len,
+            xml_buf, rom_buf, rom_len,
             NULL, extra_rom_buf, extra_rom_len))
    {
       SSNES_ERR("Cannot load SGB/GameBoy rom.\n");
       goto error;
    }
 
+   if (xml_buf)
+      free(xml_buf);
+
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
    if (extra_rom)
@@ -330,23 +614,18 @@ static bool load_bsx_rom(bool slotted)
       goto error;
    }
 
-   extra_rom = fopen(g_extern.bsx_rom_path, "rb");
-   if (!extra_rom)
-   {
-      SSNES_ERR("Couldn't open BSX game rom!\n");
-      goto error;
-   }
-
-   if ((extra_rom_len = read_rom_file(extra_rom, &extra_rom_buf)) == -1)
+   if ((extra_rom_len = read_file(g_extern.bsx_rom_path, &extra_rom_buf)) == -1)
    {
       SSNES_ERR("Cannot read BSX game rom.\n");
       goto error;
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (slotted)
    {   
       if (!psnes_load_cartridge_bsx_slotted(
-               NULL, rom_buf, rom_len,
+               xml_buf, rom_buf, rom_len,
                NULL, extra_rom_buf, extra_rom_len))
       {
          SSNES_ERR("Cannot load BSX slotted rom.\n");
@@ -365,6 +644,9 @@ static bool load_bsx_rom(bool slotted)
       }
    }
 
+   if (xml_buf)
+      free(xml_buf);
+
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
    if (extra_rom)
@@ -404,23 +686,18 @@ static bool load_sufami_rom(void)
    {
       if (strlen(roms[i]) > 0)
       {
-         extra_rom[i] = fopen(roms[i], "rb");
-         if (!extra_rom[i])
+         if ((extra_rom_len[i] = read_file(roms[i], &extra_rom_buf[i])) == -1)
          {
-            SSNES_ERR("Couldn't open BSX game rom!\n");
-            goto error;
-         }
-
-         if ((extra_rom_len[i] = read_rom_file(extra_rom[i], &extra_rom_buf[i])) == -1)
-         {
-            SSNES_ERR("Cannot read BSX game rom.\n");
+            SSNES_ERR("Cannot read Sufami game rom.\n");
             goto error;
          }
       }
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (!psnes_load_cartridge_sufami_turbo(
-            NULL, rom_buf, rom_len,
+            xml_buf, rom_buf, rom_len,
             NULL, extra_rom_buf[0], extra_rom_len[0],
             NULL, extra_rom_buf[1], extra_rom_len[1]))
    {
@@ -428,6 +705,8 @@ static bool load_sufami_rom(void)
       goto error;
    }
 
+   if (xml_buf)
+      free(xml_buf);
 
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
@@ -458,24 +737,43 @@ static bool load_normal_rom(void)
    void *rom_buf = NULL;
    ssize_t rom_len = 0;
 
-   if ((rom_len = read_rom_file(g_extern.rom_file, &rom_buf)) == -1)
+   if (!g_extern.system.need_fullpath)
    {
-      SSNES_ERR("Could not read ROM file.\n");
-      return false;
+      if ((rom_len = read_rom_file(g_extern.rom_file, &rom_buf)) == -1)
+      {
+         SSNES_ERR("Could not read ROM file.\n");
+         return false;
+      }
+
+      if (g_extern.rom_file)
+         fclose(g_extern.rom_file);
+
+      SSNES_LOG("ROM size: %d bytes\n", (int)rom_len);
+
    }
+   else
+   {
+      if (!g_extern.rom_file)
+      {
+         SSNES_ERR("Implementation requires a full path to be set, cannot load ROM from stdin. Aborting ...\n");
+         return false;
+      }
 
-   if (g_extern.rom_file != NULL)
       fclose(g_extern.rom_file);
+      SSNES_LOG("ROM loading skipped. Implementation will load it on its own.\n");
+   }
+   
+   char *xml_buf = load_xml_map(g_extern.xml_name);
 
-   SSNES_LOG("ROM size: %d bytes\n", (int)rom_len);
-
-   if (!psnes_load_cartridge_normal(NULL, rom_buf, rom_len))
+   if (!psnes_load_cartridge_normal(xml_buf, rom_buf, rom_len))
    {
       SSNES_ERR("ROM file is not valid!\n");
       free(rom_buf);
+      free(xml_buf);
       return false;
    }
 
+   free(xml_buf);
    free(rom_buf);
    return true;
 }
@@ -519,10 +817,8 @@ bool init_rom_file(enum ssnes_game_type type)
 }
 
 // Yep, this is C alright ;)
-char** dir_list_new(const char *dir, const char *ext)
+char **dir_list_new(const char *dir, const char *ext)
 {
-   size_t path_len = strlen(dir);
-
    size_t cur_ptr = 0;
    size_t cur_size = 32;
    char **dir_list = NULL;
@@ -531,18 +827,22 @@ char** dir_list_new(const char *dir, const char *ext)
    WIN32_FIND_DATAW ffd;
    HANDLE hFind = INVALID_HANDLE_VALUE;
 
+   wchar_t wchar_buf[MAXPATHLEN];
+   char utf8_buf[MAXPATHLEN];
 
-   size_t final_off = MAX_PATH + path_len + 2;
+   if (strlcpy(utf8_buf, dir, sizeof(utf8_buf)) >= sizeof(utf8_buf))
+      goto error;
+   if (strlcat(utf8_buf, "/*", sizeof(utf8_buf)) >= sizeof(utf8_buf))
+      goto error;
 
-   wchar_t wchar_buf[MAX_PATH + 1];
-   char utf8_buf[MAX_PATH + 3];
+   if (ext)
+   {
+      if (strlcat(utf8_buf, ext, sizeof(utf8_buf)) >= sizeof(utf8_buf))
+         goto error;
+   }
 
-   strncpy(utf8_buf, dir, MAX_PATH);
-   strcat(utf8_buf, "/*");
-   utf8_buf[MAX_PATH + 2] = '\0';
-
-   int ret = MultiByteToWideChar(CP_UTF8, 0, utf8_buf, strlen(utf8_buf), wchar_buf, MAX_PATH);
-   wchar_buf[ret] = 0;
+   if (MultiByteToWideChar(CP_UTF8, 0, utf8_buf, -1, wchar_buf, MAXPATHLEN) == 0)
+      goto error;
 
    hFind = FindFirstFileW(wchar_buf, &ffd);
    if (hFind == INVALID_HANDLE_VALUE)
@@ -550,7 +850,6 @@ char** dir_list_new(const char *dir, const char *ext)
 #else
    DIR *directory = NULL;
    const struct dirent *entry = NULL;
-   size_t final_off = sizeof(entry->d_name) + path_len + 2;
 
    directory = opendir(dir);
    if (!directory)
@@ -571,8 +870,8 @@ char** dir_list_new(const char *dir, const char *ext)
 #ifdef _WIN32
       if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
          continue;
-      int ret = WideCharToMultiByte(CP_UTF8, 0, ffd.cFileName, wcslen(ffd.cFileName), utf8_buf, MAX_PATH, NULL, NULL);
-      utf8_buf[ret] = '\0';
+      if (WideCharToMultiByte(CP_UTF8, 0, ffd.cFileName, -1, utf8_buf, MAXPATHLEN, NULL, NULL) == 0)
+         continue;
       if (ext && !strstr(utf8_buf, ext))
          continue;
 #else
@@ -580,19 +879,17 @@ char** dir_list_new(const char *dir, const char *ext)
          continue;
 #endif
 
-      dir_list[cur_ptr] = malloc(final_off);
+      dir_list[cur_ptr] = malloc(MAXPATHLEN);
       if (!dir_list[cur_ptr])
          goto error;
 
-      strcpy(dir_list[cur_ptr], dir);
+      strlcpy(dir_list[cur_ptr], dir, MAXPATHLEN);
+      strlcat(dir_list[cur_ptr], "/", MAXPATHLEN);
 #ifdef _WIN32
-      dir_list[cur_ptr][path_len] = '\\';
-      strcpy(&dir_list[cur_ptr][path_len + 1], utf8_buf);
+      strlcat(dir_list[cur_ptr], utf8_buf, MAXPATHLEN);
 #else
-      dir_list[cur_ptr][path_len] = '/';
-      strcpy(&dir_list[cur_ptr][path_len + 1], entry->d_name);
+      strlcat(dir_list[cur_ptr], entry->d_name, MAXPATHLEN);
 #endif
-      dir_list[cur_ptr][final_off - 1] = '\0';
 
       cur_ptr++;
       if (cur_ptr + 1 == cur_size) // Need to reserve for NULL.
@@ -608,7 +905,6 @@ char** dir_list_new(const char *dir, const char *ext)
    }
 #ifdef _WIN32
    while (FindNextFileW(hFind, &ffd) != 0);
-
 #endif
 
 #ifdef _WIN32
@@ -641,3 +937,70 @@ void dir_list_free(char **dir_list)
       free(*dir_list++);
    free(orig);
 }
+
+bool path_is_directory(const char *path)
+{
+#ifdef _WIN32
+   wchar_t buf[MAXPATHLEN];
+   if (MultiByteToWideChar(CP_UTF8, 0, path, -1, buf, MAXPATHLEN) == 0)
+      return false;
+   return PathIsDirectoryW(buf) == FILE_ATTRIBUTE_DIRECTORY;
+#elif defined(__CELLOS_LV2__)
+   return false; // STUB
+#elif defined(XENON)
+   // Dummy
+   (void)path;
+   return false;
+#else
+   struct stat buf;
+   if (stat(path, &buf) < 0)
+      return false;
+
+   return S_ISDIR(buf.st_mode);
+#endif
+}
+
+bool path_file_exists(const char *path)
+{
+   FILE *dummy = fopen(path, "rb");
+   if (dummy)
+   {
+      fclose(dummy);
+      return true;
+   }
+   return false;
+}
+
+void fill_pathname(char *out_path, const char *in_path, const char *replace, size_t size)
+{
+   char tmp_path[MAXPATHLEN];
+   assert(strlcpy(tmp_path, in_path, sizeof(tmp_path)) < sizeof(tmp_path));
+   char *tok = strrchr(tmp_path, '.');
+   if (tok != NULL)
+      *tok = '\0';
+   assert(strlcpy(out_path, tmp_path, size) < size);
+   assert(strlcat(out_path, replace, size) < size);
+}
+
+void fill_pathname_noext(char *out_path, const char *in_path, const char *replace, size_t size)
+{
+   assert(strlcpy(out_path, in_path, size) < size);
+   assert(strlcat(out_path, replace, size) < size);
+}
+
+void fill_pathname_dir(char *in_dir, const char *in_basename, const char *replace, size_t size)
+{
+   assert(strlcat(in_dir, "/", size) < size); 
+   
+   const char *base = strrchr(in_basename, '/');
+   if (!base)
+      base = strrchr(in_basename, '\\');
+
+   if (base)
+      base++;
+   else
+      base = in_basename;
+
+   assert(strlcat(in_dir, base, size) < size);
+   assert(strlcat(in_dir, replace, size) < size);
+}

file.h

@@ -26,16 +26,34 @@
 #include <sys/types.h>
 #include "general.h"
 
-bool load_state(const char* path);
-bool save_state(const char* path);
+// Generic file, path and directory handling.
 
-void load_ram_file(const char* path, int type);
-void save_ram_file(const char* path, int type);
+ssize_t read_file(const char *path, void **buf);
+
+bool load_state(const char *path);
+bool save_state(const char *path);
+
+void load_ram_file(const char *path, int type);
+void save_ram_file(const char *path, int type);
 
 bool init_rom_file(enum ssnes_game_type type);
 
 // Returns a NULL-terminated list of files in a directory with full paths.
-char** dir_list_new(const char *dir, const char *ext);
+// If ext is NULL, any file will be picked.
+// If non-NULL, only files with extension ext are added.
+char **dir_list_new(const char *dir, const char *ext);
 void dir_list_free(char **dir_list);
 
+bool path_is_directory(const char *path);
+bool path_file_exists(const char *path);
+
+// Path-name operations.
+// Replaces filename extension with replace.
+void fill_pathname(char *out_path, const char *in_path, const char *replace, size_t size);
+// Sets filename extension. Assumes in_path has no extension.
+void fill_pathname_noext(char *out_path, const char *in_path, const char *replace, size_t size);
+// Concatenates in_basename and replace to in_dir.
+void fill_pathname_dir(char *in_dir, const char *in_basename, const char *replace, size_t size);
+
+
 #endif

general.h

@@ -20,29 +20,49 @@
 #define __SSNES_GENERAL_H
 
 #include <stdbool.h>
-#include "driver.h"
 #include <stdio.h>
+#include <time.h>
+#include "driver.h"
 #include "record/ffemu.h"
 #include "message.h"
 #include "rewind.h"
 #include "movie.h"
 #include "autosave.h"
-#include "netplay.h"
 #include "dynamic.h"
+#include "cheats.h"
+#include "audio/ext/ssnes_dsp.h"
+
+#ifdef __CELLOS_LV2__
+#include <sys/timer.h>
+#endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#else
-#include "audio/hermite.h"
+#ifdef HAVE_NETPLAY
+#include "netplay.h"
 #endif
 
+#include "audio/hermite.h"
+
+#if !defined(_WIN32) && !defined(__CELLOS_LV2__)
+#include <sys/param.h> // MAXPATHLEN
+#elif defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#ifndef MAXPATHLEN
+#ifdef PATH_MAX
+#define MAXPATHLEN PATH_MAX
+#else
+#define MAXPATHLEN 512
+#endif
+#endif
 
 #define MAX_PLAYERS 5
-#define MAX_BINDS 28 // Needs to be increased every time there are new binds added.
+#define MAX_BINDS (SSNES_BIND_LIST_END + 1)
 #define SSNES_NO_JOYPAD 0xFFFF
 
 enum ssnes_shader_type
@@ -67,24 +87,37 @@ struct settings
       bool vsync;
       bool smooth;
       bool force_aspect;
+      bool crop_overscan;
       float aspect_ratio;
-      char cg_shader_path[256];
-      char bsnes_shader_path[256];
-      char filter_path[256];
+      char cg_shader_path[MAXPATHLEN];
+      char bsnes_shader_path[MAXPATHLEN];
+      char filter_path[MAXPATHLEN];
       enum ssnes_shader_type shader_type;
+      float refresh_rate;
 
       bool render_to_texture;
       double fbo_scale_x;
       double fbo_scale_y;
-      char second_pass_shader[256];
+      char second_pass_shader[MAXPATHLEN];
       bool second_pass_smooth;
-      char shader_dir[256];
+      char shader_dir[MAXPATHLEN];
 
-      char font_path[256];
+      char font_path[MAXPATHLEN];
       unsigned font_size;
+      bool font_enable;
       float msg_pos_x;
       float msg_pos_y;
+      float msg_color_r;
+      float msg_color_g;
+      float msg_color_b;
 
+      bool force_16bit;
+      bool disable_composition;
+
+      bool hires_record;
+      bool post_filter_record;
+
+      char external_driver[MAXPATHLEN];
    } video;
 
    struct
@@ -94,10 +127,12 @@ struct settings
       unsigned out_rate;
       float in_rate;
       float rate_step;
-      char device[256];
+      char device[MAXPATHLEN];
       unsigned latency;
       bool sync;
-      int src_quality;
+
+      char dsp_plugin[MAXPATHLEN];
+      char external_driver[MAXPATHLEN];
    } audio;
 
    struct
@@ -109,14 +144,21 @@ struct settings
       bool netplay_client_swap_input;
    } input;
 
-   char libsnes[256];
+   char libsnes[MAXPATHLEN];
+   char cheat_database[MAXPATHLEN];
+   char cheat_settings_path[MAXPATHLEN];
+
+   char screenshot_directory[MAXPATHLEN];
 
    bool rewind_enable;
-   unsigned rewind_buffer_size;
+   size_t rewind_buffer_size;
    unsigned rewind_granularity;
 
    bool pause_nonactive;
    unsigned autosave_interval;
+
+   bool block_sram_overwrite;
+   bool savestate_auto_index;
 };
 
 enum ssnes_game_type
@@ -135,45 +177,58 @@ struct global
    bool verbose;
    bool audio_active;
    bool video_active;
+   bool force_fullscreen;
 
    bool has_mouse[2];
    bool has_scope[2];
    bool has_justifier;
    bool has_justifiers;
    bool has_multitap;
+   bool disconnect_device[2];
 
    FILE *rom_file;
    enum ssnes_game_type game_type;
    uint32_t cart_crc;
 
-   char gb_rom_path[256];
-   char bsx_rom_path[256];
-   char sufami_rom_path[2][256];
+   char gb_rom_path[MAXPATHLEN];
+   char bsx_rom_path[MAXPATHLEN];
+   char sufami_rom_path[2][MAXPATHLEN];
    bool has_set_save_path;
    bool has_set_state_path;
 
 #ifdef HAVE_CONFIGFILE
-   char config_path[256];
+   char config_path[MAXPATHLEN];
 #endif
    
-   char basename[256];
-   char savefile_name_srm[256];
-   char savefile_name_rtc[512]; // Make sure that fill_pathname has space.
-   char savefile_name_psrm[512];
-   char savefile_name_asrm[512];
-   char savefile_name_bsrm[512];
-   char savestate_name[256];
-   char ups_name[512];
+   char basename[MAXPATHLEN];
+   char savefile_name_srm[MAXPATHLEN];
+   char savefile_name_rtc[MAXPATHLEN]; // Make sure that fill_pathname has space.
+   char savefile_name_psrm[MAXPATHLEN];
+   char savefile_name_asrm[MAXPATHLEN];
+   char savefile_name_bsrm[MAXPATHLEN];
+   char savestate_name[MAXPATHLEN];
+   char xml_name[MAXPATHLEN];
+
+   bool ups_pref;
+   bool bps_pref;
+   char ups_name[MAXPATHLEN];
+   char bps_name[MAXPATHLEN];
 
    unsigned state_slot;
 
    struct
    {
-#ifdef HAVE_SRC
-      SRC_STATE *source;
-#else
+      struct snes_geometry geom;
+      unsigned pitch; // If 0, has classic libsnes semantics.
+      char fullpath[MAXPATHLEN];
+      struct snes_system_timing timing;
+      bool timing_set;
+      bool need_fullpath;
+   } system;
+
+   struct
+   {
       hermite_resampler_t *source;
-#endif
 
       float *data;
       size_t data_ptr;
@@ -181,10 +236,21 @@ struct global
       size_t nonblock_chunk_size;
       size_t block_chunk_size;
 
+      double src_ratio;
+
       bool use_float;
+      bool mute;
 
       float *outsamples;
       int16_t *conv_outsamples;
+
+      int16_t *rewind_buf;
+      size_t rewind_ptr;
+      size_t rewind_size;
+
+      dylib_t dsp_lib;
+      const ssnes_dsp_plugin_t *dsp_plugin;
+      void *dsp_handle;
    } audio_data;
 
    struct
@@ -208,41 +274,70 @@ struct global
    void *state_buf;
    bool frame_is_reverse;
 
-   // Movie record support
-   bsv_movie_t *bsv_movie;
-   char bsv_movie_path[256];
-   bool bsv_movie_end;
-   bool bsv_movie_playback;
+   // Movie playback/recording support.
+   struct
+   {
+      bsv_movie_t *movie;
+      char movie_path[MAXPATHLEN];
+      bool movie_playback;
+
+      // Immediate playback/recording.
+      char movie_start_path[MAXPATHLEN];
+      bool movie_start_recording;
+      bool movie_start_playback;
+      bool movie_end;
+   } bsv;
+
+   bool sram_load_disable;
+   bool sram_save_disable;
 
    // Pausing support
    bool is_paused;
+   bool is_oneshot;
 
    // Autosave support.
    autosave_t *autosave[2];
 
    // Netplay.
+#ifdef HAVE_NETPLAY
    netplay_t *netplay;
-   char netplay_server[256];
+   char netplay_server[MAXPATHLEN];
    bool netplay_enable;
    bool netplay_is_client;
    unsigned netplay_sync_frames;
    uint16_t netplay_port;
+#endif
 
    // FFmpeg record.
 #ifdef HAVE_FFMPEG
    ffemu_t *rec;
-   char record_path[256];
+   char record_path[MAXPATHLEN];
    bool recording;
+   unsigned record_width;
+   unsigned record_height;
 #endif
 
+   struct
+   {
+      const uint16_t *data;
+      unsigned width;
+      unsigned height;
+   } frame_cache;
+
    char title_buf[64];
 
    struct
    {
-      char** elems;
+      char **elems;
       size_t size;
       size_t ptr;
    } shader_dir;
+
+   char sha256[64 + 1];
+
+#ifdef HAVE_XML
+   cheat_manager_t *cheat;
+#endif
 };
 
 void parse_config(void);
@@ -250,21 +345,31 @@ void parse_config(void);
 extern struct settings g_settings;
 extern struct global g_extern;
 
-#define SSNES_LOG(msg, args...) do { \
+#define SSNES_LOG(...) do { \
    if (g_extern.verbose) \
-      fprintf(stderr, "SSNES: " msg, ##args); \
+      fprintf(stderr, "SSNES: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
 
-#define SSNES_ERR(msg, args...) do { \
-      fprintf(stderr, "SSNES [ERROR] :: " msg, ##args); \
+#define SSNES_ERR(...) do { \
+      fprintf(stderr, "SSNES [ERROR] :: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
 
-#define SSNES_WARN(msg, args...) do { \
-      fprintf(stderr, "SSNES [WARN] :: " msg, ##args); \
+#define SSNES_WARN(...) do { \
+      fprintf(stderr, "SSNES [WARN] :: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
+
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#define SSNES_SCALE_BASE 256
 
 static inline uint32_t next_pow2(uint32_t v)
 {
@@ -278,6 +383,36 @@ static inline uint32_t next_pow2(uint32_t v)
    return v;
 }
 
+static inline uint8_t is_little_endian(void)
+{
+   union
+   {
+      uint16_t x;
+      uint8_t y[2];
+   } u;
+
+   u.x = 1;
+   return u.y[0];
+}
+
+static inline void ssnes_sleep(unsigned msec)
+{
+#ifdef __CELLOS_LV2__
+   sys_timer_usleep(1000 * msec);
+#elif defined(_WIN32)
+   Sleep(msec);
+#elif defined(XENON)
+   // Dummy
+   (void)msec;
+#else
+   struct timespec tv = {
+      .tv_sec = msec / 1000,
+      .tv_nsec = (msec % 1000) * 1000000,
+   };
+   nanosleep(&tv, NULL);
+#endif
+}
+
 #endif
 
 

getopt.c

@@ -0,0 +1,181 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "getopt_ssnes.h"
+
+#ifndef HAVE_GETOPT_LONG
+
+#include <string.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <assert.h>
+
+char *optarg;
+int optind, opterr, optopt;
+
+static bool is_short_option(const char *str)
+{
+   return str[0] == '-' && str[1] != '-';
+}
+
+static bool is_long_option(const char *str)
+{
+   return str[0] == '-' && str[1] == '-';
+}
+
+static int find_short_index(char * const *argv)
+{
+   for (int index = 0; argv[index]; index++)
+   {
+      if (is_short_option(argv[index]))
+         return index;
+   }
+
+   return -1;
+}
+
+static int find_long_index(char * const *argv)
+{
+   for (int index = 0; argv[index]; index++)
+   {
+      if (is_long_option(argv[index]))
+         return index;
+   }
+
+   return -1;
+}
+
+static int parse_short(const char *optstring, char * const *argv)
+{
+   char arg = argv[0][1];
+   if (arg == ':')
+      return '?';
+
+   const char *opt = strchr(optstring, arg);
+   if (!opt)
+      return '?';
+
+   bool multiple_opt = argv[0][2];
+   bool takes_arg = opt[1] == ':';
+   if (multiple_opt && takes_arg) // Makes little sense to allow.
+      return '?';
+
+   if (takes_arg)
+   {
+      optarg = argv[1];
+      optind += 2;
+      return optarg ? opt[0] : '?';
+   }
+   else if (multiple_opt)
+   {
+      memmove(&argv[0][1], &argv[0][2], strlen(&argv[0][2]) + 1);
+      return opt[0];
+   }
+   else
+   {
+      optind++;
+      return opt[0];
+   }
+}
+
+static int parse_long(const struct option *longopts, char * const *argv)
+{
+   const struct option *opt = NULL;
+   for (size_t indice = 0; longopts[indice].name; indice++)
+   {
+      if (strcmp(longopts[indice].name, &argv[0][2]) == 0)
+      {
+         opt = &longopts[indice];
+         break;
+      }
+   }
+
+   if (!opt)
+      return '?';
+   
+   // getopt_long has an "optional" arg, but we don't bother with that.
+   if (opt->has_arg && !argv[1])
+      return '?';
+
+   if (opt->has_arg)
+   {
+      optarg = argv[1];
+      optind += 2;
+   }
+   else
+      optind++;
+
+   if (opt->flag)
+   {
+      *opt->flag = opt->val;
+      return 0;
+   }
+   else
+      return opt->val;
+}
+
+static void shuffle_block(char **begin, char **last, char **end)
+{
+   ptrdiff_t len = last - begin;
+   const char *tmp[len];
+   memcpy(tmp, begin, sizeof(tmp));
+   memmove(begin, last, (end - last) * sizeof(char*));
+   memcpy(end - len, tmp, sizeof(tmp));
+}
+
+int getopt_long(int argc, char *argv[],
+      const char *optstring, const struct option *longopts, int *longindex)
+{
+   (void)longindex;
+   if (argc == 1)
+      return -1;
+
+   if (optind == 0)
+      optind = 1;
+
+   int short_index = find_short_index(&argv[optind]);
+   int long_index  = find_long_index(&argv[optind]);
+
+   // We're done here.
+   if (short_index == -1 && long_index == -1)
+      return -1;
+
+   // Reorder argv so that non-options come last.
+   // Non-POSIXy, but that's what getopt does by default.
+   if ((short_index > 0) && ((short_index < long_index) || (long_index == -1)))
+   {
+      shuffle_block(&argv[optind], &argv[optind + short_index], &argv[argc]);
+      short_index = 0;
+   }
+   else if ((long_index > 0) && ((long_index < short_index) || (short_index == -1)))
+   {
+      shuffle_block(&argv[optind], &argv[optind + long_index], &argv[argc]);
+      long_index = 0;
+   }
+
+   assert(short_index == 0 || long_index == 0);
+
+   if (short_index == 0)
+      return parse_short(optstring, &argv[optind]);
+   else if (long_index == 0)
+      return parse_long(longopts, &argv[optind]);
+   else
+      return '?';
+}
+
+#endif
+

getopt_ssnes.h

@@ -0,0 +1,52 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_GETOPT_H
+#define __SSNES_GETOPT_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+// Custom implementation of the GNU getopt_long for portability.
+// Not designed to be fully compatible,
+// but compatible with the features SSNES uses.
+
+#ifdef HAVE_GETOPT_LONG
+#include <getopt.h>
+#else
+// Avoid possible naming collitions during link since we prefer to use the actual name.
+#define getopt_long(argc, argv, optstring, longopts, longindex) __getopt_long_ssnes(argc, argv, optstring, longopts, longindex)
+
+struct option
+{
+   const char *name;
+   int has_arg;
+   int *flag;
+   int val;
+};
+
+// argv[] is declared with char * const argv[] in GNU,
+// but this makes no sense, as non-POSIX getopt_long mutates argv (non-opts are moved to the end).
+int getopt_long(int argc, char *argv[],
+      const char *optstring, const struct option *longopts, int *longindex);
+extern char *optarg;
+extern int optind, opterr, optopt;
+#endif
+
+#endif
+

gfx/ext.c

@@ -0,0 +1,366 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Loader for external API plugins.
+
+#define SSNES_DLL_IMPORT
+#include "ext/ssnes_video.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "dynamic.h"
+#include "general.h"
+#include "sdlwrap.h"
+#include "gfx_common.h"
+
+#ifdef HAVE_FREETYPE
+#include "fonts.h"
+#endif
+
+#ifdef HAVE_PYTHON
+#define PY_STATE_OMIT_DECLARATION
+#include "py_state/py_state.h"
+#endif
+
+static bool g_input_dead = true;
+static bool g_video_dead = true;
+static dylib_t g_lib = NULL;
+
+/////////// Input hook
+
+typedef struct
+{
+   const ssnes_input_driver_t *driver;
+   void *handle;
+} input_ext_t;
+
+static void *input_ext_init(void)
+{
+   g_input_dead = false;
+   return calloc(1, sizeof(input_ext_t));
+}
+
+static void input_ext_poll(void *data)
+{
+   input_ext_t *ext = data;
+   ext->driver->poll(ext->handle);
+}
+
+static int16_t input_ext_input_state(void *data, const struct snes_keybind **snes_keybinds, bool port, unsigned device, unsigned index, unsigned id)
+{
+   input_ext_t *ext = data;
+
+   unsigned player = 0;
+   if (device == SNES_DEVICE_MULTITAP)
+      player = (port == SNES_PORT_1) ? 1 : index + 2;
+   else
+      player = (port == SNES_PORT_1) ? 1 : 2;
+
+   const struct snes_keybind *ssnes_bind = NULL;
+
+   for (unsigned i = 0; g_settings.input.binds[player - 1][i].id != -1; i++)
+   {
+      if (g_settings.input.binds[player - 1][i].id == id)
+      {
+         ssnes_bind = &g_settings.input.binds[player - 1][i];
+         break;
+      }
+   }
+
+   if (ssnes_bind)
+   {
+      struct ssnes_keybind bind = {
+         .key = ssnes_bind->key,
+         .joykey = ssnes_bind->joykey,
+         .joyaxis = ssnes_bind->joyaxis
+      };
+
+      return ext->driver->input_state(ext->handle, &bind, player);
+   }
+   else
+      return 0;
+}
+
+static bool input_ext_key_pressed(void *data, int key)
+{
+   input_ext_t *ext = data;
+
+   const struct snes_keybind *ssnes_bind = NULL;
+   for (unsigned i = 0; g_settings.input.binds[0][i].id != -1; i++)
+   {
+      if (g_settings.input.binds[0][i].id == key)
+      {
+         ssnes_bind = &g_settings.input.binds[0][i];
+         break;
+      }
+   }
+
+   if (ssnes_bind)
+   {
+      struct ssnes_keybind bind = {
+         .key = ssnes_bind->key,
+         .joykey = ssnes_bind->joykey,
+         .joyaxis = ssnes_bind->joyaxis
+      };
+
+      return ext->driver->input_state(ext->handle, &bind, 1);
+   }
+   else
+      return false;
+}
+
+static void input_ext_free(void *data)
+{
+   input_ext_t *ext = data;
+   if (ext)
+   {
+      if (ext->driver && ext->handle)
+         ext->driver->free(ext->handle);
+
+      if (g_video_dead)
+      {
+         dylib_close(g_lib);
+         g_lib = NULL;
+      }
+
+      g_input_dead = true;
+
+      free(ext);
+   }
+}
+
+static const input_driver_t input_ext = {
+   .init = input_ext_init,
+   .poll = input_ext_poll,
+   .input_state = input_ext_input_state,
+   .key_pressed = input_ext_key_pressed,
+   .free = input_ext_free,
+   .ident = "ext"
+};
+
+
+//////////// Video hook
+typedef struct
+{
+   const ssnes_video_driver_t *driver;
+   void *handle;
+} ext_t;
+
+static void video_ext_free(void *data)
+{
+   ext_t *ext = data;
+   if (ext)
+   {
+      if (ext->driver && ext->handle)
+         ext->driver->free(ext->handle);
+
+      if (g_input_dead)
+      {
+         dylib_close(g_lib);
+         g_lib = NULL;
+      }
+
+      g_video_dead = true;
+
+      free(ext);
+   }
+}
+
+static bool video_ext_focus(void *data)
+{
+   ext_t *ext = data;
+   return ext->driver->focus(ext->handle);
+}
+
+static bool video_ext_alive(void *data)
+{
+   ext_t *ext = data;
+   return ext->driver->alive(ext->handle);
+}
+
+static void video_ext_set_nonblock_state(void *data, bool state)
+{
+   ext_t *ext = data;
+   ext->driver->set_nonblock_state(ext->handle, state);
+}
+
+static bool video_ext_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+{
+   ext_t *ext = data;
+   return ext->driver->frame(ext->handle, frame, width, height, pitch, msg);
+}
+
+static void *setup_input(ext_t *ext, const ssnes_input_driver_t *driver)
+{
+   int joypad_index[5];
+   for (unsigned i = 0; i < 5; i++)
+      joypad_index[i] = g_settings.input.joypad_map[i] == SSNES_NO_JOYPAD ? -1 : g_settings.input.joypad_map[i];
+
+   void *handle = driver->init(joypad_index, g_settings.input.axis_threshold);
+   if (!handle)
+      return NULL;
+
+   input_ext_t *wrap_handle = input_ext.init();
+   if (!wrap_handle)
+      return NULL;
+
+   wrap_handle->handle = handle;
+   wrap_handle->driver = driver;
+
+   return wrap_handle;
+}
+
+static bool setup_video(ext_t *ext, const video_info_t *video, const input_driver_t **input, void **input_data)
+{
+   SSNES_LOG("Loaded driver: \"%s\"\n", ext->driver->ident ? ext->driver->ident : "Unknown");
+
+   if (SSNES_GRAPHICS_API_VERSION != ext->driver->api_version)
+   {
+      SSNES_ERR("API version mismatch detected!\n");
+      SSNES_ERR("Required API version: %d, Library version: %d\n", SSNES_GRAPHICS_API_VERSION, ext->driver->api_version);
+      return false;
+   }
+
+   const char *cg_shader = NULL;
+   const char *xml_shader = NULL;
+   enum ssnes_shader_type type = g_settings.video.shader_type;
+   if ((type == SSNES_SHADER_CG || type == SSNES_SHADER_AUTO) && *g_settings.video.cg_shader_path)
+      cg_shader = g_settings.video.cg_shader_path;
+   else if ((type == SSNES_SHADER_BSNES || type == SSNES_SHADER_AUTO) && *g_settings.video.bsnes_shader_path)
+      xml_shader = g_settings.video.bsnes_shader_path;
+
+   int font_color_r = g_settings.video.msg_color_r * 255;
+   int font_color_g = g_settings.video.msg_color_g * 255;
+   int font_color_b = g_settings.video.msg_color_b * 255;
+   font_color_r = font_color_r > 255 ? 255 : (font_color_r < 0 ? 0 : font_color_r);
+   font_color_g = font_color_g > 255 ? 255 : (font_color_g < 0 ? 0 : font_color_g);
+   font_color_b = font_color_b > 255 ? 255 : (font_color_b < 0 ? 0 : font_color_b);
+
+   const char *font = NULL;
+   if (g_settings.video.font_enable)
+   {
+#ifdef HAVE_FREETYPE
+      if (*g_settings.video.font_path)
+         font = g_settings.video.font_path;
+      else
+         font = font_renderer_get_default_font();
+#else
+      font = *g_settings.video.font_path ?
+         g_settings.video.font_path : NULL;
+#endif
+   }
+
+   char title_buf[128];
+   gfx_window_title_reset();
+   gfx_window_title(title_buf, sizeof(title_buf));
+
+   ssnes_video_info_t info = {
+      .width = video->width,
+      .height = video->height,
+      .fullscreen = video->fullscreen,
+      .vsync = video->vsync,
+      .force_aspect = video->force_aspect,
+      .aspect_ratio = g_settings.video.aspect_ratio,
+      .smooth = video->smooth,
+      .input_scale = video->input_scale,
+      .color_format = video->rgb32 ? SSNES_COLOR_FORMAT_ARGB8888 : SSNES_COLOR_FORMAT_XRGB1555,
+      .xml_shader = xml_shader,
+      .cg_shader = cg_shader,
+      .ttf_font = font,
+      .ttf_font_size = g_settings.video.font_size,
+      .ttf_font_color = (font_color_r << 16) | (font_color_g << 8) | (font_color_b << 0),
+      .title_hint = title_buf,
+
+#ifdef HAVE_PYTHON
+      .python_state_new = py_state_new,
+      .python_state_get = py_state_get,
+      .python_state_free = py_state_free,
+#endif
+   };
+
+   const ssnes_input_driver_t *input_driver = NULL;
+   ext->handle = ext->driver->init(&info, &input_driver);
+   if (!ext->handle)
+      return false;
+
+   *input = input_driver ? &input_ext : NULL;
+   if (input_driver)
+      *input_data = setup_input(ext, input_driver);
+   else
+      *input_data = NULL;
+
+   return true;
+}
+
+static void *video_ext_init(const video_info_t *video, const input_driver_t **input, void **input_data)
+{
+   ext_t *ext = calloc(1, sizeof(*ext));
+   if (!ext)
+      return NULL;
+
+   if (!(*g_settings.video.external_driver))
+   {
+      SSNES_ERR("External driver needs video_external_driver path to be set!\n");
+      goto error;
+   }
+
+   g_lib = dylib_load(g_settings.video.external_driver);
+   if (!g_lib)
+   {
+      SSNES_ERR("Failed to open library: \"%s\"\n", g_settings.video.external_driver);
+      goto error;
+   }
+
+   const ssnes_video_driver_t* (*video_init)(void) = 
+      (const ssnes_video_driver_t *(*)(void))dylib_proc(g_lib, "ssnes_video_init");
+   if (!video_init)
+   {
+      SSNES_ERR("Couldn't find function ssnes_video_init in library ...\n");
+      goto error;
+   }
+
+   ext->driver = video_init();
+   if (!ext->driver)
+   {
+      SSNES_ERR("External driver returned invalid driver handle.\n");
+      goto error;
+   }
+
+   if (!setup_video(ext, video, input, input_data))
+   {
+      SSNES_ERR("Failed to start driver.\n");
+      goto error;
+   }
+
+   g_video_dead = false;
+   return ext;
+
+error:
+   video_ext_free(ext);
+   return NULL;
+}
+
+const video_driver_t video_ext = {
+   .init = video_ext_init,
+   .frame = video_ext_frame,
+   .alive = video_ext_alive,
+   .set_nonblock_state = video_ext_set_nonblock_state,
+   .focus = video_ext_focus,
+   .free = video_ext_free,
+   .ident = "ext"
+};
+

gfx/ext/ssnes_video.h

@@ -0,0 +1,278 @@
+/////
+// API header for external SSNES video and input plugins.
+//
+//
+
+#ifndef __SSNES_VIDEO_DRIVER_H
+#define __SSNES_VIDEO_DRIVER_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#ifdef SSNES_DLL_IMPORT
+#define SSNES_API_EXPORT __declspec(dllimport) 
+#else
+#define SSNES_API_EXPORT __declspec(dllexport) 
+#endif
+#define SSNES_API_CALLTYPE __cdecl
+#else
+#define SSNES_API_EXPORT
+#define SSNES_API_CALLTYPE
+#endif
+
+#define SSNES_GRAPHICS_API_VERSION 2
+
+// Since we don't want to rely on C++ or C99 for a proper boolean type,
+// make sure return semantics are perfectly clear ... ;)
+
+#ifndef SSNES_OK
+#define SSNES_OK 1
+#endif
+
+#ifndef SSNES_ERROR
+#define SSNES_ERROR 0
+#endif
+
+#ifndef SSNES_TRUE
+#define SSNES_TRUE 1
+#endif
+
+#ifndef SSNES_FALSE
+#define SSNES_FALSE 0
+#endif
+
+#define SSNES_COLOR_FORMAT_XRGB1555 0
+#define SSNES_COLOR_FORMAT_ARGB8888 1
+
+#define SSNES_INPUT_SCALE_BASE 256
+
+typedef struct py_state py_state_t;
+
+// Create a new runtime for Python.
+// py_script: The python script to be loaded. If is_file is true, this will be the full path to a file.
+// If false, it will be an UTF-8 encoded string of the script.
+// is_file: Tells if py_script is the path to a script, or a script itself.
+// py_class: name of the class being instantiated. 
+typedef py_state_t *(*python_state_new_cb)(const char *py_script, unsigned is_file, const char *py_class);
+// Grabs a value from the Python runtime.
+// id: The uniform (class method) to be called.
+// frame_count: Passes frame_count as an argument to the script.
+typedef float (*python_state_get_cb)(py_state_t *handle, const char *id, unsigned frame_count);
+// Frees the runtime.
+typedef void (*python_state_free_cb)(py_state_t *handle);
+
+typedef struct ssnes_video_info
+{ 
+   // Width of window. 
+   // If fullscreen mode is requested, 
+   // a width of 0 means the resolution of the desktop should be used.
+   unsigned width;
+
+   // Height of window. 
+   // If fullscreen mode is requested, 
+   // a height of 0 means the resolutiof the desktop should be used.
+   unsigned height;
+
+   // If true, start the window in fullscreen mode.
+   int fullscreen;
+
+   // If true, VSync should be enabled.
+   int vsync;
+
+   // If true, the output image should have the aspect ratio 
+   // as set in aspect_ratio.
+   int force_aspect;
+
+   // Aspect ratio. Only takes effect if force_aspect is enabled.
+   float aspect_ratio;
+
+   // Requests that the image is smoothed,
+   // using bilinear filtering or otherwise.
+   // If this cannot be implemented efficiently, this can be disregarded.
+   // If smooth is false, nearest-neighbor scaling is requested.
+   int smooth;
+
+   // input_scale defines the maximum size of the picture that will
+   // ever be used with the frame callback.
+   // The maximum resolution is a multiple of 256x256 size (SSNES_INPUT_SCALE_BASE),
+   // so an input scale of 2
+   // means you should allocate a texture or of 512x512.
+   unsigned input_scale;
+
+   // Defines the coloring format used of the input frame.
+   // XRGB1555 format is 16-bit and has byte ordering: 0RRRRRGGGGGBBBBB,
+   // in native endian.
+   // ARGB8888 is AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB, native endian.
+   // Alpha channel should be disregarded.
+   int color_format;
+
+   // If non-NULL, requests the use of an XML shader.
+   // Can be disregarded.
+   const char *xml_shader;
+   // If non-NULL, requests the use of a Cg shader.
+   // Can be disregarded.
+   // If both are non-NULL,
+   // Cg or XML could be used at the discretion of the plugin.
+   const char *cg_shader;
+
+   // Requestes that a certain
+   // TTF font is used for rendering messages to the screen.
+   // Can be disregarded.
+   const char *ttf_font;
+   unsigned ttf_font_size;
+   unsigned ttf_font_color; // Font color, in format ARGB8888. Alpha should be disregarded.
+
+   // A title that should be displayed in the title bar of the window.
+   const char *title_hint;
+
+   // Functions to peek into the python runtime for shaders.
+   // Check typedefs above for explanation.
+   // These may be NULL if SSNES is not built with Python support.
+   python_state_new_cb python_state_new;
+   python_state_get_cb python_state_get;
+   python_state_free_cb python_state_free;
+} ssnes_video_info_t;
+
+// Some convenience macros.
+// Extract which axes to test for in negative or positive direction.
+// May be equal to SSNES_NO_AXIS, which means testing should not occur.
+#define SSNES_AXIS_NEG_GET(x) (((unsigned)(x) >> 16) & 0xFFFFU)
+#define SSNES_AXIS_POS_GET(x) ((unsigned)(x) & 0xFFFFU)
+
+// I hope no joypad will ever have this many buttons or axes ... ;)
+// If joykey is this value, do not check that button.
+#define SSNES_NO_AXIS (0xFFFFFFFFU)
+#define SSNES_NO_BTN ((unsigned short)0xFFFFU)
+
+// Masks to test on joykey which hat direction is to be tested for.
+#define SSNES_HAT_UP_MASK (1 << 15)
+#define SSNES_HAT_DOWN_MASK (1 << 14)
+#define SSNES_HAT_LEFT_MASK (1 << 13)
+#define SSNES_HAT_RIGHT_MASK (1 << 12)
+#define SSNES_HAT_MAP(x, hat) ((x & ((1 << 12) - 1)) | hat)
+
+#define SSNES_HAT_MASK (SSNES_HAT_UP_MASK | SSNES_HAT_DOWN_MASK | \
+      SSNES_HAT_LEFT_MASK | SSNES_HAT_RIGHT_MASK)
+
+// Test this on the joykey. If true, we want to test for a joypad hat
+// rather than a button.
+#define SSNES_GET_HAT_DIR(x) (x & SSNES_HAT_MASK)
+
+// Gets the joypad hat to be tested for. 
+// Only valid when SSNES_GET_HAT_DIR() returns true.
+#define SSNES_GET_HAT(x) (x & (~SSNES_HAT_MASK))
+
+// key, joykey and joyaxis are all checked at the same time.
+// If any one of these are pressed, return 1 in state callback.
+struct ssnes_keybind
+{
+   // If analog_x is true, we request an analog device to be polled
+   // rather than normal keys.
+   // The returned value should be the delta of 
+   // last frame and current frame in the X-axis.
+   int analog_x;
+   // If analog_y is true, we request an analog device to be polled
+   // rather than normal keys.
+   // The returned value should be the delta of 
+   // last frame and current frame in the Y-axis.
+   int analog_y;
+
+   // Keyboard key. The key values use the SDL 1.2 keysyms, 
+   // which probably need to be transformed to the native format.
+   // The actual keysyms SSNES uses are found in input/keysym.h.
+   unsigned short key;
+
+   // Joypad key. Joypad POV (hats) are embedded into this key as well.
+   unsigned short joykey;
+
+   // Joypad axis. Negative and positive axes are embedded into this variable.
+   unsigned joyaxis;
+};
+
+typedef struct ssnes_input_driver
+{
+   // Inits input driver. 
+   // Joypad index denotes which joypads are desired for the various players.
+   // Should an entry be negative,
+   // do not open joypad for that player.
+   // Threshold states the minimum offset that a joypad axis 
+   // has to be held for it to be registered.
+   // The range of this is [0, 1],
+   // where 0 means any displacement will register,
+   // and 1 means the axis has to be pressed all the way to register.
+   void *(*init)(const int joypad_index[5], float axis_threshold);
+
+   // Polls input. Called once every frame.
+   void (*poll)(void *data);
+
+   // Queries input state for a certain key on a certain player.
+   // Players are 1 - 5.
+   // For digital inputs, pressed key is 1, not pressed key is 0.
+   // Analog values have same range as a signed 16-bit integer.
+   int (*input_state)(void *data, const struct ssnes_keybind *bind,
+         unsigned player);
+
+   // Frees the input struct.
+   void (*free)(void *data);
+
+   // Human readable indentification string.
+   const char *ident;
+} ssnes_input_driver_t;
+
+typedef struct ssnes_video_driver
+{
+   // Inits the video driver. Returns an opaque handle pointer to the driver.
+   // Returns NULL on error.
+   //
+   // Should the video driver request that a certain input driver is used,
+   // it is possible to set the driver to *input.
+   // If no certain driver is desired, set *input to NULL.
+   void *(*init)(const ssnes_video_info_t *video, 
+         const ssnes_input_driver_t **input); 
+
+   // Updates frame on the screen. 
+   // Frame can be either XRGB1555 or ARGB32 format
+   // depending on rgb32 setting in ssnes_video_info_t. 
+   // Pitch is the distance in bytes between two scanlines in memory. 
+   // 
+   // When msg is non-NULL, 
+   // it's a message that should be displayed to the user.
+   int (*frame)(void *data, const void *frame, 
+         unsigned width, unsigned height, unsigned pitch, const char *msg);
+
+   // Requests nonblocking operation. 
+   // True = VSync is turned off. 
+   // False = VSync is turned on.
+   void (*set_nonblock_state)(void *data, int toggle);
+
+   // This must return false when the user exits the emulator.
+   int (*alive)(void *data);
+
+   // Does the window have focus?
+   int (*focus)(void *data);
+
+   // Frees the video driver.
+   void (*free)(void *data);
+
+   // A human-readable identification of the video driver.
+   const char *ident;
+
+   // Needs to be defined to SSNES_GRAPHICS_API_VERSION. 
+   // This is used to detect API/ABI mismatches.
+   int api_version;
+} ssnes_video_driver_t;
+
+// Called by SSNES on startup to get a driver handle.
+// This is NOT dynamically allocated.
+SSNES_API_EXPORT const ssnes_video_driver_t* SSNES_API_CALLTYPE
+   ssnes_video_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

gfx/fonts.c

@@ -16,10 +16,10 @@
  */
 
 #include "fonts.h"
+#include "file.h"
 #include <string.h>
 #include <stddef.h>
 #include <stdlib.h>
-#include <assert.h>
 
 #include <ft2build.h>
 #include FT_FREETYPE_H
@@ -79,12 +79,16 @@ void font_renderer_msg(font_renderer_t *handle, const char *msg, struct font_out
       if (!err)
       {
          struct font_output *tmp = calloc(1, sizeof(*tmp));
-         assert(tmp);
-
-         //fprintf(stderr, "Char: %c, off_x: %d, off_y: %d, bmp_left: %d, bmp_top: %d\n", msg[i], off_x, off_y, slot->bitmap_left, slot->bitmap_top);
+         if (!tmp)
+            break;
 
          tmp->output = malloc(slot->bitmap.pitch * slot->bitmap.rows);
-         assert(tmp->output);
+         if (!tmp->output)
+         {
+            free(tmp);
+            break;
+         }
+
          memcpy(tmp->output, slot->bitmap.buffer, slot->bitmap.pitch * slot->bitmap.rows);
 
          tmp->width = slot->bitmap.width;
@@ -128,3 +132,35 @@ void font_renderer_free(font_renderer_t *handle)
    if (handle->lib)
       FT_Done_FreeType(handle->lib);
 }
+
+// Not the cleanest way to do things for sure, but should hopefully work ... :)
+
+#if defined(_WIN32)
+static const char *font_paths[] = {
+   "C:\\Windows\\Fonts\\consola.ttf",
+   "C:\\Windows\\Fonts\\verdana.ttf",
+#elif defined(__APPLE__)
+static const char *font_paths[] = {
+   "/Library/Fonts/Microsoft/Candara.ttf",
+   "/Library/Fonts/Verdana.ttf",
+   "/Library/Fonts/Tahoma.ttf",
+#else
+static const char *font_paths[] = {
+   "/usr/share/fonts/TTF/DejaVuSansMono.ttf",
+   "/usr/share/fonts/TTF/DejaVuSans.ttf",
+#endif
+   "osd-font.ttf", // Magic font to search for, useful for distribution.
+};
+
+// Highly OS/platform dependent.
+const char *font_renderer_get_default_font(void)
+{
+   for (unsigned i = 0; i < sizeof(font_paths) / sizeof(font_paths[0]); i++)
+   {
+      if (path_file_exists(font_paths[i]))
+         return font_paths[i];
+   }
+
+   return NULL;
+}
+

gfx/fonts.h

@@ -25,10 +25,10 @@ typedef struct font_renderer font_renderer_t;
 
 struct font_output
 {
-   uint8_t *output;
+   uint8_t *output; // 8-bit intensity.
    unsigned width, height, pitch;
    int off_x, off_y;
-   struct font_output *next;
+   struct font_output *next; // linked list.
 };
 
 struct font_output_list
@@ -37,8 +37,12 @@ struct font_output_list
 };
 
 font_renderer_t *font_renderer_new(const char *font_path, unsigned font_size);
-void font_renderer_msg(font_renderer_t *handle, const char *msg, struct font_output_list *output);
+void font_renderer_msg(font_renderer_t *handle, const char *msg,
+      struct font_output_list *output);
+
 void font_renderer_free_output(struct font_output_list *list);
 void font_renderer_free(font_renderer_t *handle);
 
+const char *font_renderer_get_default_font(void);
+
 #endif

gfx/gfx_common.c

@@ -16,7 +16,7 @@
  */
 
 #include "gfx_common.h"
-#include "general.h"
+#include "../general.h"
 #include <sys/time.h>
 
 static float tv_to_fps(const struct timeval *tv, const struct timeval *new_tv, int frames)
@@ -25,21 +25,37 @@ static float tv_to_fps(const struct timeval *tv, const struct timeval *new_tv, i
    return frames/time;
 }
 
+static unsigned gl_frames = 0;
+
+void gfx_window_title_reset(void)
+{
+   gl_frames = 0;
+}
+
+#ifdef __CELLOS_LV2__
+#include <sys/sys_time.h>
+static void gettimeofday(struct timeval *val, void *dummy)
+{
+   (void)dummy;
+   uint64_t usec = sys_time_get_system_time();
+   val->tv_sec = usec / 1000000;
+   val->tv_usec = usec % 1000000;
+}
+#endif
+
 bool gfx_window_title(char *buf, size_t size)
 {
-   static int frames = 0;
    static struct timeval tv;
    struct timeval new_tv;
    bool ret = false;
 
-   if (frames == 0)
+   if (gl_frames == 0)
    {
       gettimeofday(&tv, NULL);
-      snprintf(buf, size, g_extern.title_buf);
+      snprintf(buf, size, "%s", g_extern.title_buf);
       ret = true;
    }
-
-   if ((frames % 180) == 0 && frames > 0)
+   else if ((gl_frames % 180) == 0)
    {
       gettimeofday(&new_tv, NULL);
       struct timeval tmp_tv = tv;
@@ -47,12 +63,63 @@ bool gfx_window_title(char *buf, size_t size)
 
       float fps = tv_to_fps(&tmp_tv, &new_tv, 180);
 
-      snprintf(buf, size, "%s || FPS: %6.1f || Frames: %d", g_extern.title_buf, fps, frames);
+      snprintf(buf, size, "%s || FPS: %6.1f || Frames: %d", g_extern.title_buf, fps, gl_frames);
       ret = true;
    }
 
-   frames++;
+   gl_frames++;
    return ret;
 }
 
+#ifdef _WIN32
+#include <windows.h>
+#include "dynamic.h"
+// We only load this library once, so we let it be unloaded at application shutdown,
+// since unloading it early seems to cause issues on some systems.
+
+static dylib_t dwmlib = NULL;
+
+static void gfx_dwm_shutdown(void)
+{
+   if (dwmlib)
+      dylib_close(dwmlib);
+}
+
+void gfx_set_dwm(void)
+{
+   static bool inited = false;
+   if (inited)
+      return;
+   inited = true;
+
+   dwmlib = dylib_load("dwmapi.dll");
+   if (!dwmlib)
+   {
+      SSNES_LOG("Did not find dwmapi.dll.\n");
+      return;
+   }
+   atexit(gfx_dwm_shutdown);
+
+   HRESULT (WINAPI *mmcss)(BOOL) = (HRESULT (WINAPI*)(BOOL))dylib_proc(dwmlib, "DwmEnableMMCSS");
+   if (mmcss)
+   {
+      SSNES_LOG("Setting multimedia scheduling for DWM.\n");
+      mmcss(TRUE);
+   }
+
+   if (!g_settings.video.disable_composition)
+      return;
+
+   HRESULT (WINAPI *composition_enable)(UINT) = (HRESULT (WINAPI*)(UINT))dylib_proc(dwmlib, "DwmEnableComposition");
+   if (!composition_enable)
+   {
+      SSNES_ERR("Did not find DwmEnableComposition ...\n");
+      return;
+   }
+
+   HRESULT ret = composition_enable(0);
+   if (FAILED(ret))
+      SSNES_ERR("Failed to set composition state ...\n");
+}
+#endif
 

gfx/gfx_common.h

@@ -22,5 +22,10 @@
 #include <stdbool.h>
 
 bool gfx_window_title(char *buf, size_t size);
+void gfx_window_title_reset(void);
+
+#ifdef _WIN32
+void gfx_set_dwm(void);
+#endif
 
 #endif

gfx/gl_common.h

@@ -18,11 +18,20 @@
 #ifndef __GL_COMMON_H
 #define __GL_COMMON_H
 
-#include "general.h"
+#include "../general.h"
+#include <assert.h>
 
-#ifdef __APPLE__
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#if defined(__APPLE__)
 #include <OpenGL/gl.h>
 #include <OpenGL/glext.h>
+#elif defined(__CELLOS_LV2__)
+#include <PSGL/psgl.h>
+#include <PSGL/psglu.h>
+#include <GLES/glext.h>
 #else
 #define GL_GLEXT_PROTOTYPES
 #include <GL/gl.h>
@@ -52,9 +61,6 @@ static inline bool gl_check_error(void)
       case GL_OUT_OF_MEMORY:
          SSNES_ERR("GL: Out of memory. Harhar.\n");
          break;
-      case GL_TABLE_TOO_LARGE:
-         SSNES_ERR("GL: Table too large. Big tables scare you! :(\n");
-         break;
       case GL_NO_ERROR:
          return true;
          break;
@@ -93,4 +99,21 @@ struct gl_fbo_scale
    bool valid;
 };
 
+struct gl_tex_info
+{
+   GLuint tex;
+   GLfloat input_size[2];
+   GLfloat tex_size[2];
+   GLfloat coord[8];
+};
+
+// Windows ... <_<
+#if (defined(HAVE_XML) || defined(HAVE_CG)) && defined(_WIN32)
+extern PFNGLCLIENTACTIVETEXTUREPROC pglClientActiveTexture;
+extern PFNGLACTIVETEXTUREPROC pglActiveTexture;
+#else
+#define pglClientActiveTexture glClientActiveTexture
+#define pglActiveTexture glActiveTexture
+#endif
+
 #endif

gfx/image.c

@@ -0,0 +1,183 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include "image.h"
+#include "../file.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include "../general.h"
+
+#ifdef HAVE_SDL_IMAGE
+
+#include "SDL_image.h"
+bool texture_image_load(const char *path, struct texture_image *out_img)
+{
+   SDL_Surface *img = IMG_Load(path);
+   if (!img)
+      return false;
+
+   out_img->width = img->w;
+   out_img->height = img->h;
+
+   size_t size = out_img->width * out_img->height * sizeof(uint32_t);
+   out_img->pixels = malloc(size);
+   if (!out_img->pixels)
+   {
+      SDL_FreeSurface(img);
+      return false;
+   }
+
+   const SDL_PixelFormat *fmt = img->format;
+   
+   SSNES_LOG("SDL_image: %dx%d @ %d bpp\n", img->w, img->h, img->format->BitsPerPixel);
+   if (img->format->BitsPerPixel == 32)
+   {
+      for (unsigned y = 0; y < img->h; y++)
+      {
+         uint32_t *dst = out_img->pixels + y * img->w;
+         const uint32_t *src = (const uint32_t*)img->pixels + y * img->pitch / sizeof(uint32_t);
+
+         for (unsigned x = 0; x < img->w; x++)
+         {
+            uint32_t r = (src[x] & fmt->Rmask) >> fmt->Rshift;
+            uint32_t g = (src[x] & fmt->Gmask) >> fmt->Gshift;
+            uint32_t b = (src[x] & fmt->Bmask) >> fmt->Bshift;
+            uint32_t a = (src[x] & fmt->Amask) >> fmt->Ashift;
+            dst[x] = (b << 24) | (g << 16) | (r << 8) | a;
+         }
+      }
+   }
+   else if (img->format->BitsPerPixel == 24)
+   {
+      for (unsigned y = 0; y < img->h; y++)
+      {
+         uint32_t *dst = out_img->pixels + y * img->w;
+         const uint8_t *src = (const uint8_t*)img->pixels + y * img->pitch;
+
+         for (unsigned x = 0; x < img->w; x++)
+         {
+            // Correct?
+            uint32_t color = 0;
+            color |= src[3 * x + 0] << 0;
+            color |= src[3 * x + 1] << 8;
+            color |= src[3 * x + 2] << 16;
+            uint32_t r = (color & fmt->Rmask) >> fmt->Rshift;
+            uint32_t g = (color & fmt->Gmask) >> fmt->Gshift;
+            uint32_t b = (color & fmt->Bmask) >> fmt->Bshift;
+            dst[x] = (b << 24) | (g << 16) | (r << 8) | 0xff;
+         }
+      }
+   }
+   else
+   {
+      SSNES_ERR("8-bit and 16-bit image support are not implemented.\n");
+      SDL_FreeSurface(img);
+      return false;
+   }
+
+   SDL_FreeSurface(img);
+
+   return true;
+}
+
+#else
+
+bool texture_image_load(const char *path, struct texture_image *out_img)
+{
+   // TODO: Check more gracefully.
+   if (!strstr(path, ".tga"))
+      return false;
+
+   void *raw_buf = NULL;
+   ssize_t len = read_file(path, &raw_buf);
+   if (len < 0)
+      return false;
+
+   uint8_t *buf = raw_buf;
+
+   if (buf[2] != 2) // Uncompressed RGB
+   {
+      free(buf);
+      return false;
+   }
+
+   unsigned width = 0;
+   unsigned height = 0;
+
+   uint8_t info[6];
+   memcpy(info, buf + 12, 6);
+
+   width = info[0] + ((unsigned)info[1] * 256);
+   height = info[2] + ((unsigned)info[3] * 256);
+   unsigned bits = info[4];
+
+   SSNES_LOG("Loaded TGA: (%ux%u @ %u bpp)\n", width, height, bits);
+
+   unsigned size = width * height * sizeof(uint32_t);
+   out_img->pixels = malloc(size);
+   out_img->width = width;
+   out_img->height = height;
+   if (!out_img->pixels)
+   {
+      free(buf);
+      return false;
+   }
+
+   const uint8_t *tmp = buf + 18;
+   if (bits == 32)
+   {
+      for (unsigned i = 0; i < width * height; i++)
+      {
+         uint32_t b = tmp[i * 4 + 0];
+         uint32_t g = tmp[i * 4 + 1];
+         uint32_t r = tmp[i * 4 + 2];
+         uint32_t a = tmp[i * 4 + 3];
+
+         out_img->pixels[i] = (b << 24) | (g << 16) | (r << 8) | a;
+      }
+   }
+   else if (bits == 24)
+   {
+      for (unsigned i = 0; i < width * height; i++)
+      {
+         uint32_t b = tmp[i * 3 + 0];
+         uint32_t g = tmp[i * 3 + 1];
+         uint32_t r = tmp[i * 3 + 2];
+         uint32_t a = 0xff;
+
+         out_img->pixels[i] = (b << 24) | (g << 16) | (r << 8) | a;
+      }
+   }
+   else
+   {
+      free(buf);
+      free(out_img->pixels);
+      out_img->pixels = NULL;
+      return false;
+   }
+
+   free(buf);
+   return true;
+}
+
+#endif

gfx/image.h

@@ -0,0 +1,34 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_IMAGE_H
+#define __SSNES_IMAGE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+struct texture_image
+{
+   unsigned width;
+   unsigned height;
+   uint32_t *pixels;
+};
+
+bool texture_image_load(const char *path, struct texture_image* img);
+
+#endif
+

gfx/py_state/py_state.c

@@ -0,0 +1,351 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <Python.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "dynamic.h"
+#include "libsnes.hpp"
+#include "py_state.h"
+#include "general.h"
+#include "strl.h"
+#include "file.h"
+
+#define PY_READ_FUNC_DECL(RAMTYPE) py_read_##RAMTYPE
+#define PY_READ_FUNC(RAMTYPE) \
+   static PyObject* PY_READ_FUNC_DECL(RAMTYPE) (PyObject *self, PyObject *args) \
+   { \
+      (void)self; \
+\
+      const uint8_t *data = psnes_get_memory_data(SNES_MEMORY_##RAMTYPE); \
+      if (!data) \
+      { \
+         Py_INCREF(Py_None); \
+         return Py_None; \
+      } \
+      unsigned max = psnes_get_memory_size(SNES_MEMORY_##RAMTYPE); \
+\
+      unsigned addr; \
+      if (!PyArg_ParseTuple(args, "I", &addr)) \
+         return NULL; \
+\
+      if (addr >= max || addr < 0) \
+      { \
+         Py_INCREF(Py_None); \
+         return Py_None; \
+      } \
+\
+      return PyLong_FromLong((long)data[addr]); \
+   }
+
+PY_READ_FUNC(WRAM)
+PY_READ_FUNC(VRAM)
+PY_READ_FUNC(APURAM)
+PY_READ_FUNC(CGRAM)
+PY_READ_FUNC(OAM)
+
+static PyObject *py_read_input(PyObject *self, PyObject *args)
+{
+   (void)self;
+
+   if (!driver.input_data)
+      return PyBool_FromLong(0);
+
+   unsigned player;
+   unsigned key;
+   if (!PyArg_ParseTuple(args, "II", &player, &key))
+      return NULL;
+
+   if (player > MAX_PLAYERS || player < 1 || key >= SSNES_FIRST_META_KEY)
+      return NULL;
+
+   static const struct snes_keybind *binds[MAX_PLAYERS] = {
+      g_settings.input.binds[0],
+      g_settings.input.binds[1],
+      g_settings.input.binds[2],
+      g_settings.input.binds[3],
+      g_settings.input.binds[4],
+   };
+
+   int16_t res = driver.input->input_state(driver.input_data, 
+         binds, player > 1, 
+         player > 2 ? SNES_DEVICE_MULTITAP : SNES_DEVICE_JOYPAD,
+         player > 2 ? player - 2 : 0,
+         key);
+
+   return PyBool_FromLong(res);
+}
+
+static PyObject *py_read_input_meta(PyObject *self, PyObject *args)
+{
+   (void)self;
+
+   if (!driver.input_data)
+      return PyBool_FromLong(0);
+
+   unsigned key;
+   if (!PyArg_ParseTuple(args, "I", &key))
+      return NULL;
+
+   if (key < SSNES_FIRST_META_KEY)
+      return NULL;
+
+   bool ret = driver.input->key_pressed(driver.input_data, key);
+   return PyBool_FromLong(ret);
+}
+
+static PyMethodDef SNESMethods[] = {
+   { "read_wram",    PY_READ_FUNC_DECL(WRAM),   METH_VARARGS, "Read WRAM from SNES." },
+   { "read_vram",    PY_READ_FUNC_DECL(VRAM),   METH_VARARGS, "Read VRAM from SNES." },
+   { "read_apuram",  PY_READ_FUNC_DECL(APURAM), METH_VARARGS, "Read APURAM from SNES." },
+   { "read_cgram",   PY_READ_FUNC_DECL(CGRAM),  METH_VARARGS, "Read CGRAM from SNES." },
+   { "read_oam",     PY_READ_FUNC_DECL(OAM),    METH_VARARGS, "Read OAM from SNES." },
+   { "input",        py_read_input,             METH_VARARGS, "Read input state from SNES." },
+   { "input_meta",   py_read_input_meta,        METH_VARARGS, "Read SSNES specific input." },
+   { NULL, NULL, 0, NULL }
+};
+
+#define DECL_ATTR_SNES(attr) PyObject_SetAttrString(mod, #attr, PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_##attr))
+#define DECL_ATTR_SSNES(attr) PyObject_SetAttrString(mod, #attr, PyLong_FromLong(SSNES_##attr))
+static void py_set_attrs(PyObject *mod)
+{
+   DECL_ATTR_SNES(B);
+   DECL_ATTR_SNES(Y);
+   DECL_ATTR_SNES(SELECT);
+   DECL_ATTR_SNES(START);
+   DECL_ATTR_SNES(UP);
+   DECL_ATTR_SNES(DOWN);
+   DECL_ATTR_SNES(LEFT);
+   DECL_ATTR_SNES(RIGHT);
+   DECL_ATTR_SNES(A);
+   DECL_ATTR_SNES(X);
+   DECL_ATTR_SNES(L);
+   DECL_ATTR_SNES(R);
+
+   DECL_ATTR_SSNES(FAST_FORWARD_KEY);
+   DECL_ATTR_SSNES(FAST_FORWARD_HOLD_KEY);
+   DECL_ATTR_SSNES(LOAD_STATE_KEY);
+   DECL_ATTR_SSNES(SAVE_STATE_KEY);
+   DECL_ATTR_SSNES(FULLSCREEN_TOGGLE_KEY);
+   DECL_ATTR_SSNES(QUIT_KEY);
+   DECL_ATTR_SSNES(STATE_SLOT_PLUS);
+   DECL_ATTR_SSNES(STATE_SLOT_MINUS);
+   DECL_ATTR_SSNES(AUDIO_INPUT_RATE_PLUS);
+   DECL_ATTR_SSNES(AUDIO_INPUT_RATE_MINUS);
+   DECL_ATTR_SSNES(REWIND);
+   DECL_ATTR_SSNES(MOVIE_RECORD_TOGGLE);
+   DECL_ATTR_SSNES(PAUSE_TOGGLE);
+   DECL_ATTR_SSNES(FRAMEADVANCE);
+   DECL_ATTR_SSNES(RESET);
+   DECL_ATTR_SSNES(SHADER_NEXT);
+   DECL_ATTR_SSNES(SHADER_PREV);
+   DECL_ATTR_SSNES(CHEAT_INDEX_PLUS);
+   DECL_ATTR_SSNES(CHEAT_INDEX_MINUS);
+   DECL_ATTR_SSNES(CHEAT_TOGGLE);
+   DECL_ATTR_SSNES(SCREENSHOT);
+   DECL_ATTR_SSNES(DSP_CONFIG);
+   DECL_ATTR_SSNES(MUTE);
+}
+
+static PyModuleDef SNESModule = {
+   PyModuleDef_HEAD_INIT, "snes", NULL, -1, SNESMethods,
+   NULL, NULL, NULL, NULL
+};
+
+static PyObject* PyInit_SNES(void)
+{
+   PyObject *mod = PyModule_Create(&SNESModule);
+   if (!mod)
+      return NULL;
+
+   py_set_attrs(mod);
+   return mod;
+}
+
+struct py_state
+{
+   PyObject *main;
+   PyObject *dict;
+   PyObject *inst;
+
+   bool warned_ret;
+   bool warned_type;
+};
+
+static char *dupe_newline(const char *str)
+{
+   if (!str)
+      return NULL;
+
+   unsigned size = strlen(str) + 2;
+   char *ret = malloc(size);
+   if (!ret)
+      return NULL;
+
+   strlcpy(ret, str, size);
+   ret[size - 2] = '\n';
+   ret[size - 1] = '\0';
+   return ret;
+}
+
+// Need to make sure that first-line indentation is 0. :(
+static char *align_program(const char *program)
+{
+   char *prog = strdup(program);
+   if (!prog)
+      return NULL;
+
+   size_t prog_size = strlen(program) + 1;
+   char *new_prog = calloc(1, prog_size);
+   if (!new_prog)
+      return NULL;
+
+   char *line = dupe_newline(strtok(prog, "\n"));
+   if (!line)
+   {
+      free(prog);
+      return NULL;
+   }
+
+   unsigned skip_chars = 0;
+   while (isblank(line[skip_chars]) && line[skip_chars])
+      skip_chars++;
+
+   while (line)
+   {
+      unsigned length = strlen(line);
+      unsigned skip_len = skip_chars > length ? length : skip_chars;
+
+      strlcat(new_prog, line + skip_len, prog_size);
+
+      free(line);
+      line = dupe_newline(strtok(NULL, "\n"));
+   }
+
+   free(prog);
+   return new_prog;
+}
+
+py_state_t *py_state_new(const char *script, unsigned is_file, const char *pyclass)
+{
+   SSNES_LOG("Initializing Python runtime ...\n");
+   PyImport_AppendInittab("snes", &PyInit_SNES);
+   Py_Initialize();
+   SSNES_LOG("Initialized Python runtime!\n");
+
+   py_state_t *handle = calloc(1, sizeof(*handle));
+
+   handle->main = PyImport_AddModule("__main__");
+   if (!handle->main)
+      goto error;
+   Py_INCREF(handle->main);
+
+   if (is_file)
+   {
+      // Have to hack around the fact that the
+      // FILE struct isn't standardized across environments.
+      // PyRun_SimpleFile() breaks on Windows.
+
+      char *script_ = NULL;
+      if (read_file(script, (void**)&script_) < 0)
+      {
+         SSNES_ERR("Python: Failed to read script\n");
+         goto error;
+      }
+
+      PyRun_SimpleString(script_);
+      free(script_);
+   }
+   else
+   {
+      char *script_ = align_program(script);
+      if (script_)
+      {
+         PyRun_SimpleString(script_);
+         free(script_);
+      }
+   }
+
+   SSNES_LOG("Python: Script loaded.\n");
+   handle->dict = PyModule_GetDict(handle->main);
+   if (!handle->dict)
+   {
+      SSNES_ERR("Python: PyModule_GetDict() failed.\n");
+      goto error;
+   }
+   Py_INCREF(handle->dict);
+
+   PyObject *hook = PyDict_GetItemString(handle->dict, pyclass);
+   if (!hook)
+   {
+      SSNES_ERR("Python: PyDict_GetItemString() failed.\n");
+      goto error;
+   }
+
+   handle->inst = PyObject_CallFunction(hook, NULL);
+   if (!handle->inst)
+   {
+      SSNES_ERR("Python: PyObject_CallFunction() failed.\n");
+      goto error;
+   }
+   Py_INCREF(handle->inst);
+
+   return handle;
+
+error:
+   PyErr_Print();
+   PyErr_Clear();
+   py_state_free(handle);
+   return NULL;
+}
+
+void py_state_free(py_state_t *handle)
+{
+   if (handle)
+   {
+      PyErr_Print();
+      PyErr_Clear();
+
+      Py_CLEAR(handle->inst);
+      Py_CLEAR(handle->dict);
+      Py_CLEAR(handle->main);
+
+      free(handle);
+      Py_Finalize();
+   }
+}
+
+float py_state_get(py_state_t *handle, const char *id,
+      unsigned frame_count)
+{
+   PyObject *ret = PyObject_CallMethod(handle->inst, (char*)id, (char*)"I", frame_count);
+   if (!ret)
+   {
+      if (!handle->warned_ret)
+         SSNES_WARN("Didn't get return value from script! Bug?\n");
+      handle->warned_ret = true;
+      return 0.0f;
+   }
+
+   float retval = (float)PyFloat_AsDouble(ret);
+   Py_DECREF(ret);
+   return retval;
+}
+

gfx/py_state/py_state.h

@@ -0,0 +1,34 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_PY_STATE_H
+#define __SSNES_PY_STATE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifndef PY_STATE_OMIT_DECLARATION
+typedef struct py_state py_state_t;
+#endif
+
+py_state_t *py_state_new(const char *program, unsigned is_file, const char *pyclass);
+void py_state_free(py_state_t *handle);
+
+float py_state_get(py_state_t *handle, 
+      const char *id, unsigned frame_count);
+
+#endif

gfx/sdl.c

@@ -0,0 +1,564 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SDL.h"
+#include "driver.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include "general.h"
+#include "input/ssnes_sdl_input.h"
+#include "gfx_common.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_FREETYPE
+#include "fonts.h"
+#endif
+
+static void convert_15bit_15bit_direct(uint16_t *out, unsigned outpitch, const uint16_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt);
+static void convert_32bit_32bit_direct(uint32_t *out, unsigned outpitch, const uint32_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt);
+static void convert_15bit_15bit_shift(uint16_t *out, unsigned outpitch, const uint16_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt);
+static void convert_32bit_32bit_shift(uint32_t *out, unsigned outpitch, const uint32_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt);
+
+typedef struct sdl_video sdl_video_t;
+struct sdl_video
+{
+   SDL_Surface *screen, *buffer;
+   bool quitting;
+   bool rgb32;
+   bool upsample;
+
+   bool render32;
+
+   void (*convert_15_func)(uint16_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned, const SDL_PixelFormat*);
+   void (*convert_32_func)(uint32_t*, unsigned, const uint32_t*, unsigned, unsigned, unsigned, const SDL_PixelFormat*);
+
+#ifdef HAVE_FREETYPE
+   font_renderer_t *font;
+   uint8_t font_r;
+   uint8_t font_g;
+   uint8_t font_b;
+#endif
+};
+
+static void sdl_gfx_free(void *data)
+{
+   sdl_video_t *vid = data;
+   if (!vid)
+      return;
+
+   if (vid->buffer)
+      SDL_FreeSurface(vid->buffer);
+
+   SDL_QuitSubSystem(SDL_INIT_VIDEO);
+
+#ifdef HAVE_FREETYPE
+   if (vid->font)
+      font_renderer_free(vid->font);
+#endif
+
+   free(vid);
+}
+
+static void sdl_init_font(sdl_video_t *vid, const char *font_path, unsigned font_size)
+{
+#ifdef HAVE_FREETYPE
+   if (!g_settings.video.font_enable)
+      return;
+
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
+   {
+      vid->font = font_renderer_new(path, font_size);
+      if (vid->font)
+      {
+         int r = g_settings.video.msg_color_r * 255;
+         int g = g_settings.video.msg_color_g * 255;
+         int b = g_settings.video.msg_color_b * 255;
+
+         r = r < 0 ? 0 : (r > 255 ? 255 : r);
+         g = g < 0 ? 0 : (g > 255 ? 255 : g);
+         b = b < 0 ? 0 : (b > 255 ? 255 : b);
+
+         // RGB888 -> RGB555
+         if (!vid->render32)
+         {
+            r >>= 3;
+            g >>= 3;
+            b >>= 3;
+         }
+
+         vid->font_r = r;
+         vid->font_g = g;
+         vid->font_b = b;
+      }
+      else
+         SSNES_WARN("Failed to init font.\n");
+   }
+   else
+      SSNES_LOG("Did not find default font.\n");
+#else
+   (void)vid;
+   (void)font_path;
+   (void)font_size;
+#endif
+}
+
+// Not very optimized, but hey :D
+static void sdl_render_msg_15(sdl_video_t *vid, SDL_Surface *buffer, const char *msg, unsigned width, unsigned height, const SDL_PixelFormat *fmt)
+{
+#ifdef HAVE_FREETYPE
+   if (!vid->font)
+      return;
+
+   struct font_output_list out;
+   font_renderer_msg(vid->font, msg, &out);
+   struct font_output *head = out.head;
+
+   int base_x = g_settings.video.msg_pos_x * width;
+   int base_y = (1.0 - g_settings.video.msg_pos_y) * height;
+
+   unsigned rshift = fmt->Rshift;
+   unsigned gshift = fmt->Gshift;
+   unsigned bshift = fmt->Bshift;
+
+   while (head)
+   {
+      int rbase_x = base_x + head->off_x;
+      int rbase_y = base_y - head->off_y;
+      if (rbase_y >= 0)
+      {
+         for (int y = 0; y < head->height && (y + rbase_y) < height; y++)
+         {
+            if (rbase_x < 0)
+               continue;
+
+            const uint8_t *a = head->output + head->pitch * y;
+            uint16_t *out = (uint16_t*)buffer->pixels + (rbase_y - head->height + y) * (buffer->pitch >> 1) + rbase_x;
+
+            for (int x = 0; x < head->width && (x + rbase_x) < width; x++)
+            {
+               unsigned blend = a[x];
+               unsigned out_pix = out[x];
+               unsigned r = (out_pix >> rshift) & 0x1f;
+               unsigned g = (out_pix >> gshift) & 0x1f;
+               unsigned b = (out_pix >> bshift) & 0x1f;
+
+               unsigned out_r = (r * (256 - blend) + vid->font_r * blend) >> 8;
+               unsigned out_g = (g * (256 - blend) + vid->font_g * blend) >> 8;
+               unsigned out_b = (b * (256 - blend) + vid->font_b * blend) >> 8;
+               out[x] = (out_r << rshift) | (out_g << gshift) | (out_b << bshift);
+            }
+         }
+      }
+
+      head = head->next;
+   }
+
+   font_renderer_free_output(&out);
+
+#else
+   (void)vid;
+   (void)buffer;
+   (void)msg;
+   (void)width;
+   (void)height;
+#endif
+}
+
+static void sdl_render_msg_32(sdl_video_t *vid, SDL_Surface *buffer, const char *msg, unsigned width, unsigned height, const SDL_PixelFormat *fmt)
+{
+#ifdef HAVE_FREETYPE
+   if (!vid->font)
+      return;
+
+   struct font_output_list out;
+   font_renderer_msg(vid->font, msg, &out);
+   struct font_output *head = out.head;
+
+   int base_x = g_settings.video.msg_pos_x * width;
+   int base_y = (1.0 - g_settings.video.msg_pos_y) * height;
+
+   unsigned rshift = fmt->Rshift;
+   unsigned gshift = fmt->Gshift;
+   unsigned bshift = fmt->Bshift;
+
+   while (head)
+   {
+      int rbase_x = base_x + head->off_x;
+      int rbase_y = base_y - head->off_y;
+      if (rbase_y >= 0)
+      {
+         for (int y = 0; y < head->height && (y + rbase_y) < height; y++)
+         {
+            if (rbase_x < 0)
+               continue;
+
+            const uint8_t *a = head->output + head->pitch * y;
+            uint32_t *out = (uint32_t*)buffer->pixels + (rbase_y - head->height + y) * (buffer->pitch >> 2) + rbase_x;
+
+            for (int x = 0; x < head->width && (x + rbase_x) < width; x++)
+            {
+               unsigned blend = a[x];
+               unsigned out_pix = out[x];
+               unsigned r = (out_pix >> rshift) & 0xff;
+               unsigned g = (out_pix >> gshift) & 0xff;
+               unsigned b = (out_pix >> bshift) & 0xff;
+
+               unsigned out_r = (r * (256 - blend) + vid->font_r * blend) >> 8;
+               unsigned out_g = (g * (256 - blend) + vid->font_g * blend) >> 8;
+               unsigned out_b = (b * (256 - blend) + vid->font_b * blend) >> 8;
+               out[x] = (out_r << rshift) | (out_g << gshift) | (out_b << bshift);
+            }
+         }
+      }
+
+      head = head->next;
+   }
+
+   font_renderer_free_output(&out);
+
+#else
+   (void)vid;
+   (void)buffer;
+   (void)msg;
+   (void)width;
+   (void)height;
+#endif
+}
+
+static void *sdl_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
+{
+#ifdef _WIN32
+   gfx_set_dwm();
+#endif
+
+   SDL_InitSubSystem(SDL_INIT_VIDEO);
+
+   sdl_video_t *vid = calloc(1, sizeof(*vid));
+   if (!vid)
+      return NULL;
+
+   const SDL_VideoInfo *video_info = SDL_GetVideoInfo();
+   assert(video_info);
+   unsigned full_x = video_info->current_w;
+   unsigned full_y = video_info->current_h;
+   SSNES_LOG("Detecting desktop resolution %ux%u.\n", full_x, full_y);
+
+   if (!video->fullscreen)
+      SSNES_LOG("Creating window @ %ux%u\n", video->width, video->height);
+
+   vid->render32 = video->rgb32 && !g_settings.video.force_16bit;
+   vid->screen = SDL_SetVideoMode(video->width, video->height, vid->render32 ? 32 : 15, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
+
+   if (!vid->screen && !g_settings.video.force_16bit && !video->rgb32)
+   {
+      vid->upsample = true;
+      vid->screen = SDL_SetVideoMode(video->width, video->height, 32, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
+      SSNES_WARN("SDL: 15-bit colors failed, attempting 32-bit colors.\n");
+      vid->render32 = true;
+   }
+
+   if (!vid->screen)
+   {
+      SSNES_ERR("Failed to init SDL surface: %s\n", SDL_GetError());
+      goto error;
+   }
+
+   SDL_ShowCursor(SDL_DISABLE);
+
+   const SDL_PixelFormat *fmt = vid->screen->format;
+   if (vid->render32)
+   {
+      SSNES_LOG("SDL: Creating 32-bit buffer.\n");
+      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, SSNES_SCALE_BASE * video->input_scale,
+            SSNES_SCALE_BASE * video->input_scale, 32,
+            fmt->Rmask, fmt->Bmask, fmt->Gmask, fmt->Amask);
+   }
+   else
+   {
+      SSNES_LOG("SDL: Creating 15-bit buffer.\n");
+      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, SSNES_SCALE_BASE * video->input_scale,
+            SSNES_SCALE_BASE * video->input_scale, 15,
+            fmt->Rmask, fmt->Gmask, fmt->Bmask, fmt->Amask);
+   }
+   SSNES_LOG("[Debug]: SDL Pixel format: Rshift = %u, Gshift = %u, Bshift = %u\n", 
+         (unsigned)fmt->Rshift, (unsigned)fmt->Gshift, (unsigned)fmt->Bshift);
+
+   if (!vid->buffer)
+   {
+      SSNES_ERR("SDL_CreateRGBSurface failed: %s\n", SDL_GetError());
+      goto error;
+   }
+
+   sdl_input_t *sdl_input = input_sdl.init();
+   if (sdl_input)
+   {
+      *input = &input_sdl;
+      *input_data = sdl_input;
+   }
+   else
+      *input = NULL;
+
+   vid->rgb32 = video->rgb32;
+
+   sdl_init_font(vid, g_settings.video.font_path, g_settings.video.font_size);
+
+
+   if (fmt->Rshift == 10 && fmt->Gshift ==  5 && fmt->Bshift == 0) // XRGB1555
+   {
+      SSNES_LOG("SDL: 15-bit format matches. Fast blit.\n");
+      vid->convert_15_func = convert_15bit_15bit_direct;
+   }
+   else
+   {
+      SSNES_LOG("SDL: 15-bit format does not match. Needs conversion.\n");
+      vid->convert_15_func = convert_15bit_15bit_shift;
+   }
+
+   if (fmt->Rshift == 16 && fmt->Gshift == 8 && fmt->Bshift == 0) // ARGB8888
+   {
+      SSNES_LOG("SDL: 32-bit format matches. Fast blit.\n");
+      vid->convert_32_func = convert_32bit_32bit_direct;
+   }
+   else
+   {
+      SSNES_LOG("SDL: 32-bit format does not match. Needs conversion.\n");
+      vid->convert_32_func = convert_32bit_32bit_shift;
+   }
+
+   return vid;
+
+error:
+   sdl_gfx_free(vid);
+   return NULL;
+}
+
+static inline uint16_t conv_pixel_32_15(uint32_t pix, const SDL_PixelFormat *fmt)
+{
+   uint16_t r = ((pix & 0x00f80000) >> 19) << fmt->Rshift;
+   uint16_t g = ((pix & 0x0000f800) >> 11) << fmt->Gshift;
+   uint16_t b = ((pix & 0x000000f8) >>  3) << fmt->Bshift;
+   return r | g | b;
+}
+
+static inline uint32_t conv_pixel_15_32(uint16_t pix, const SDL_PixelFormat *fmt)
+{
+   uint32_t r = ((pix >> 10) & 0x1f) << (fmt->Rshift + 3);
+   uint32_t g = ((pix >>  5) & 0x1f) << (fmt->Gshift + 3);
+   uint32_t b = ((pix >>  0) & 0x1f) << (fmt->Bshift + 3);
+   return r | g | b;
+}
+
+static void convert_32bit_15bit(uint16_t *out, unsigned outpitch, const uint32_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      for (unsigned x = 0; x < width; x++)
+         out[x] = conv_pixel_32_15(input[x], fmt);
+
+      out += outpitch >> 1;
+      input += pitch >> 2;
+   }
+}
+
+static void convert_15bit_32bit(uint32_t *out, unsigned outpitch, const uint16_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      for (unsigned x = 0; x < width; x++)
+         out[x] = conv_pixel_15_32(input[x], fmt);
+
+      out += outpitch >> 2;
+      input += pitch >> 1;
+   }
+}
+
+static void convert_15bit_15bit_direct(uint16_t *out, unsigned outpitch, const uint16_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      uint16_t *dest = out + ((y * outpitch) >> 1);
+      const uint16_t *src = input + ((y * pitch) >> 1);
+      memcpy(dest, src, width * sizeof(uint16_t));
+   }
+   (void)fmt;
+}
+
+static void convert_32bit_32bit_direct(uint32_t *out, unsigned outpitch, const uint32_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      uint32_t *dest = out + ((y * outpitch) >> 2);
+      const uint32_t *src = input + ((y * pitch) >> 2);
+      memcpy(dest, src, width * sizeof(uint32_t));
+   }
+   (void)fmt;
+}
+
+static void convert_15bit_15bit_shift(uint16_t *out, unsigned outpitch, const uint16_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      uint16_t *dest = out + ((y * outpitch) >> 1);
+      const uint16_t *src = input + ((y * pitch) >> 1);
+      for (unsigned x = 0; x < width; x++)
+      {
+         uint16_t color = src[x];
+         uint16_t r = ((color >> 10) & 0x1f) << fmt->Rshift;
+         uint16_t g = ((color >>  5) & 0x1f) << fmt->Gshift;
+         uint16_t b = ((color >>  0) & 0x1f) << fmt->Bshift;
+         dest[x] = r | g | b;
+      }
+   }
+}
+
+static void convert_32bit_32bit_shift(uint32_t *out, unsigned outpitch, const uint32_t *input, unsigned width, unsigned height, unsigned pitch, const SDL_PixelFormat *fmt)
+{
+   for (unsigned y = 0; y < height; y++)
+   {
+      uint32_t *dest = out + ((y * outpitch) >> 2);
+      const uint32_t *src = input + ((y * pitch) >> 2);
+      for (unsigned x = 0; x < width; x++)
+      {
+         uint32_t color = src[x];
+         uint32_t r = ((color >> 16) & 0xff) << fmt->Rshift;
+         uint32_t g = ((color >>  8) & 0xff) << fmt->Gshift;
+         uint32_t b = ((color >>  0) & 0xff) << fmt->Bshift;
+         dest[x] = r | g | b;
+      }
+   }
+}
+
+static void check_window(sdl_video_t *vid)
+{
+   SDL_Event event;
+   while (SDL_PollEvent(&event))
+   {
+      switch (event.type)
+      {
+         case SDL_QUIT:
+            vid->quitting = true;
+            break;
+
+         default:
+            break;
+      }
+   }
+}
+
+static bool sdl_gfx_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+{
+   sdl_video_t *vid = data;
+
+   if (SDL_MUSTLOCK(vid->buffer))
+      SDL_LockSurface(vid->buffer);
+
+   // :(
+   // 15-bit -> 32-bit (Sometimes 15-bit won't work on "modern" OSes :\)
+   if (vid->upsample)
+   {
+      convert_15bit_32bit(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
+   }
+   // 15-bit -> 15-bit
+   else if (!vid->rgb32)
+   {
+      vid->convert_15_func(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
+   }
+   // 32-bit -> 15-bit
+   else if (vid->rgb32 && g_settings.video.force_16bit)
+   {
+      convert_32bit_15bit(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
+   }
+   // 32-bit -> 32-bit
+   else
+   {
+      vid->convert_32_func(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
+   }
+   
+   if (SDL_MUSTLOCK(vid->buffer))
+      SDL_UnlockSurface(vid->buffer);
+
+   SDL_Rect src = {
+      .x = 0,
+      .y = 0,
+      .w = width,
+      .h = height
+   };
+
+   SDL_Rect dest = {
+      .x = 0,
+      .y = 0,
+      .w = vid->screen->w,
+      .h = vid->screen->h
+   };
+
+   SDL_SoftStretch(vid->buffer, &src, vid->screen, &dest);
+
+   if (msg)
+   {
+      if ((!vid->rgb32 || g_settings.video.force_16bit) && !vid->upsample)
+         sdl_render_msg_15(vid, vid->screen, msg, vid->screen->w, vid->screen->h, vid->screen->format);
+      else
+         sdl_render_msg_32(vid, vid->screen, msg, vid->screen->w, vid->screen->h, vid->screen->format);
+   }
+
+   char buf[128];
+   if (gfx_window_title(buf, sizeof(buf)))
+      SDL_WM_SetCaption(buf, NULL);
+
+   SDL_Flip(vid->screen);
+
+   return true;
+}
+
+static void sdl_gfx_set_nonblock_state(void *data, bool state)
+{
+   (void)data; // Can SDL even do this?
+   (void)state;
+}
+
+static bool sdl_gfx_alive(void *data)
+{
+   sdl_video_t *vid = data;
+   check_window(vid);
+   return !vid->quitting;
+}
+
+static bool sdl_gfx_focus(void *data)
+{
+   (void)data;
+   return (SDL_GetAppState() & (SDL_APPINPUTFOCUS | SDL_APPACTIVE)) == (SDL_APPINPUTFOCUS | SDL_APPACTIVE);
+}
+
+
+const video_driver_t video_sdl = {
+   .init = sdl_gfx_init,
+   .frame = sdl_gfx_frame,
+   .alive = sdl_gfx_alive,
+   .set_nonblock_state = sdl_gfx_set_nonblock_state,
+   .focus = sdl_gfx_focus,
+   .free = sdl_gfx_free,
+   .ident = "sdl"
+};
+

gfx/sdlwrap.c

@@ -0,0 +1,354 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sdlwrap.h"
+#include "SDL_syswm.h"
+#include "general.h"
+#include <assert.h>
+
+#ifdef __APPLE__
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#endif
+
+// SDL 1.2 is portable, sure, but you still need some platform specific workarounds ;)
+// Hopefully SDL 1.3 will solve this more cleanly :D
+// Welcome to #ifdef HELL! :D
+//
+
+#if SDL_MODERN
+static SDL_Window* g_window;
+static SDL_GLContext g_ctx;
+#endif
+
+static bool g_fullscreen;
+static unsigned g_interval;
+
+void sdlwrap_set_swap_interval(unsigned interval, bool inited)
+{
+   g_interval = interval;
+
+#if SDL_MODERN
+   if (g_window)
+      SDL_GL_SetSwapInterval(g_interval);
+#else
+   if (inited)
+   {
+#if defined(_WIN32)
+      static BOOL (APIENTRY *wgl_swap_interval)(int) = NULL;
+      if (!wgl_swap_interval)
+      {
+         SDL_SYM_WRAP(wgl_swap_interval, "wglSwapIntervalEXT");
+      }
+      if (wgl_swap_interval) wgl_swap_interval(g_interval);
+
+#elif defined(__APPLE__) && defined(HAVE_OPENGL)
+      GLint val = g_interval;
+      CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &val);
+#else
+      static int (*glx_swap_interval)(int) = NULL;
+      if (!glx_swap_interval) 
+      {
+         SDL_SYM_WRAP(glx_swap_interval, "glXSwapIntervalSGI");
+      }
+      if (!glx_swap_interval)
+      {
+         SDL_SYM_WRAP(glx_swap_interval, "glXSwapIntervalMESA");
+      }
+      if (glx_swap_interval) 
+         glx_swap_interval(g_interval);
+      else 
+         SSNES_WARN("Could not find GLX VSync call. :(\n");
+#endif
+   }
+#endif
+}
+
+bool sdlwrap_init(void)
+{
+#if SDL_MODERN
+   return SDL_VideoInit(NULL) == 0;
+#else
+   if (SDL_WasInit(SDL_INIT_VIDEO))
+      return true;
+
+   return SDL_Init(SDL_INIT_VIDEO) == 0;
+#endif
+}
+
+#if SDL_MODERN
+void sdlwrap_destroy(void)
+{
+   if (g_ctx)
+      SDL_GL_DeleteContext(g_ctx);
+   if (g_window)
+      SDL_DestroyWindow(g_window);
+
+   g_ctx = NULL;
+   g_window = NULL;
+   SDL_VideoQuit();
+}
+#else
+void sdlwrap_destroy(void) 
+{
+   SDL_QuitSubSystem(SDL_INIT_VIDEO);
+}
+#endif
+
+bool sdlwrap_set_video_mode(
+      unsigned width, unsigned height,
+      unsigned bits, bool fullscreen)
+{
+#if SDL_MODERN
+   if (g_window)
+      return true;
+#endif
+
+#if SDL_MODERN
+   static const int resizable = SDL_WINDOW_RESIZABLE;
+#else
+#ifndef __APPLE__ // Resizing on OSX is broken in 1.2 it seems :)
+   static const int resizable = SDL_RESIZABLE;
+#else
+   static const int resizable = 0;
+#endif
+#endif
+
+   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+#if !SDL_MODERN
+   SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, g_interval);
+#endif
+
+#if SDL_MODERN
+      if (bits == 15)
+      {
+         SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+         SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
+         SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+      }
+      g_window = SDL_CreateWindow("SSNES", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+            width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | (fullscreen ? SDL_WINDOW_FULLSCREEN : resizable));
+      if (!g_window)
+         return false;
+      g_ctx = SDL_GL_CreateContext(g_window);
+#else
+   if (!SDL_SetVideoMode(width, height, bits,
+         SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : resizable)))
+      return false;
+#endif
+
+   int attr = 0;
+#if SDL_MODERN
+   SDL_GL_SetSwapInterval(g_interval);
+#else
+   SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &attr);
+   if (attr <= 0 && g_interval)
+   {
+      SSNES_WARN("SDL failed to setup VSync, attempting to recover using native calls!\n");
+      sdlwrap_set_swap_interval(g_interval, true);
+   }
+#endif
+
+   g_fullscreen = fullscreen;
+
+   attr = 0;
+   SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &attr);
+   if (attr <= 0)
+      SSNES_WARN("GL double buffer has not been enabled!\n");
+
+   return true;
+}
+
+// SDL 1.2 has an awkward model where you need to "confirm" window resizing.
+// SDL 1.3 luckily removes this quirk.
+void sdlwrap_set_resize(unsigned width, unsigned height)
+{
+#if SDL_MODERN
+   (void)width;
+   (void)height;
+#else
+#ifndef __APPLE__ // Resizing on OSX is broken in 1.2 it seems :)
+   static const int resizable = SDL_RESIZABLE;
+#else
+   static const int resizable = 0;
+#endif
+   SDL_SetVideoMode(width, height, 0, SDL_OPENGL | (g_fullscreen ? SDL_FULLSCREEN : resizable));
+#endif
+}
+
+void sdlwrap_wm_set_caption(const char *str)
+{
+#if SDL_MODERN
+   SDL_SetWindowTitle(g_window, str);
+#else
+   SDL_WM_SetCaption(str, NULL);
+#endif
+}
+
+void sdlwrap_swap_buffers(void)
+{
+#if SDL_MODERN
+   SDL_GL_SwapWindow(g_window);
+#else
+   SDL_GL_SwapBuffers();
+#endif
+}
+
+bool sdlwrap_key_pressed(int key)
+{
+   int num_keys;
+#if SDL_MODERN
+   Uint8 *keymap = SDL_GetKeyboardState(&num_keys);
+   key = SDL_GetScancodeFromKey(key);
+   if (key >= num_keys)
+      return false;
+
+   return keymap[key];
+#else
+   Uint8 *keymap = SDL_GetKeyState(&num_keys);
+   if (key >= num_keys)
+      return false;
+
+   return keymap[key];
+#endif
+}
+
+// 1.2 specific workaround for tiling WMs. In 1.3 we call GetSize directly, so we don't need to rely on
+// proper event handling (I hope).
+#if !defined(__APPLE__) && !defined(_WIN32) && !SDL_MODERN && !defined(XENON)
+static void sdlwrap_get_window_size(unsigned *width, unsigned *height)
+{
+   SDL_SysWMinfo info;
+   SDL_VERSION(&info.version);
+   SDL_GetWMInfo(&info);
+   XWindowAttributes target;
+
+   info.info.x11.lock_func();
+   XGetWindowAttributes(info.info.x11.display, info.info.x11.window,
+         &target);
+   info.info.x11.unlock_func();
+
+   *width = target.width;
+   *height = target.height;
+}
+#endif
+
+void sdlwrap_check_window(bool *quit,
+      bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
+{
+   *quit = false;
+   *resize = false;
+   SDL_Event event;
+#if SDL_MODERN
+   while (SDL_PollEvent(&event))
+   {
+      switch (event.type)
+      {
+         case SDL_QUIT:
+            *quit = true;
+            return;
+
+         case SDL_WINDOWEVENT:
+            switch (event.window.event)
+            {
+               case SDL_WINDOWEVENT_CLOSE:
+                  *quit = true;
+                  return;
+
+               case SDL_WINDOWEVENT_RESIZED:
+                  *resize = true;
+                  *width = event.window.data1;
+                  *height = event.window.data2;
+                  break;
+            }
+            break;
+      }
+   }
+
+   if (!*resize)
+   {
+      int w, h;
+      SDL_GetWindowSize(g_window, &w, &h);
+      if (*width != (unsigned)w || *height != (unsigned)h)
+      {
+         *resize = true;
+         *width = w;
+         *height = h;
+      }
+   }
+#else
+   while (SDL_PollEvent(&event))
+   {
+      switch (event.type)
+      {
+         case SDL_QUIT:
+            *quit = true;
+            break;
+
+         case SDL_VIDEORESIZE:
+            *resize = true;
+            *width = event.resize.w;
+            *height = event.resize.h;
+            break;
+      }
+   }
+
+#if !defined(__APPLE__) && !defined(_WIN32) && !defined(XENON)
+   // Hack to workaround limitations in tiling WMs ...
+   if (!*resize && !g_fullscreen)
+   {
+      unsigned new_width, new_height;
+      sdlwrap_get_window_size(&new_width, &new_height);
+      if ((new_width != *width || new_height != *height) || (frame_count == 10)) // Ugly hack :D
+      {
+         *resize = true;
+         *width = new_width;
+         *height = new_height;
+         SSNES_LOG("GL: Verified window size: %u x %u\n", *width, *height);
+      }
+   }
+#endif
+#endif
+}
+
+bool sdlwrap_get_wm_info(SDL_SysWMinfo *info)
+{
+#ifdef XENON
+   (void)info;
+   return false;
+#elif SDL_MODERN
+   if (g_window)
+      return SDL_GetWindowWMInfo(g_window, info);
+   else
+      return SDL_GetWMInfo(info) == 1;
+#else
+   return SDL_GetWMInfo(info) == 1;
+#endif
+}
+
+bool sdlwrap_window_has_focus(void)
+{
+#if SDL_MODERN
+   Uint32 flags = SDL_GetWindowFlags(g_window);
+   flags &= SDL_WINDOW_INPUT_FOCUS;
+   return flags == SDL_WINDOW_INPUT_FOCUS;
+#else
+   return (SDL_GetAppState() & (SDL_APPINPUTFOCUS | SDL_APPACTIVE)) == (SDL_APPINPUTFOCUS | SDL_APPACTIVE);
+#endif
+}
+

gfx/sdlwrap.h

@@ -0,0 +1,68 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Compatibility wrapper between SDL 1.2/1.3 for OpenGL.
+// Wraps functions which differ in 1.2 and 1.3.
+
+#ifndef __SDLWRAP_H
+#define __SDLWRAP_H
+
+#include <stdbool.h>
+
+#include "SDL.h"
+#include "SDL_version.h"
+#include "SDL_syswm.h"
+
+#if SDL_VERSION_ATLEAST(1, 3, 0)
+#define SDL_MODERN 1
+#else
+#define SDL_MODERN 0
+#endif
+
+// Not legal to cast (void*) to fn-pointer. Need workaround to be compliant.
+#define SDL_SYM_WRAP(sym, symbol) { \
+   assert(sizeof(void*) == sizeof(void (*)(void))); \
+   void *sym__ = SDL_GL_GetProcAddress(symbol); \
+   memcpy(&(sym), &sym__, sizeof(void*)); \
+}
+
+void sdlwrap_set_swap_interval(unsigned interval, bool inited);
+
+bool sdlwrap_set_video_mode(
+      unsigned width, unsigned height,
+      unsigned bits, bool fullscreen);
+
+bool sdlwrap_init(void);
+void sdlwrap_destroy(void);
+
+void sdlwrap_wm_set_caption(const char *str);
+
+void sdlwrap_swap_buffers(void);
+
+bool sdlwrap_key_pressed(int key);
+
+void sdlwrap_check_window(bool *quit,
+      bool *resize, unsigned *width, unsigned *height, unsigned frame_count);
+
+void sdlwrap_set_resize(unsigned width, unsigned height);
+
+bool sdlwrap_get_wm_info(SDL_SysWMinfo *info);
+
+bool sdlwrap_window_has_focus(void);
+
+#endif
+

gfx/shader_cg.h

@@ -30,7 +30,11 @@ void gl_cg_set_proj_matrix(void);
 
 void gl_cg_set_params(unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
-      unsigned out_width, unsigned out_height);
+      unsigned out_width, unsigned out_height,
+      unsigned frame_count,
+      const struct gl_tex_info *info,
+      const struct gl_tex_info *prev_info,
+      const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt);
 
 void gl_cg_use(unsigned index);
 

gfx/shader_glsl.c

@@ -17,8 +17,11 @@
 
 #include <stdbool.h>
 #include <string.h>
-#include "general.h"
+#include "../general.h"
 #include "shader_glsl.h"
+#include "../strl.h"
+#include "snes_state.h"
+#include "../dynamic.h"
 
 #ifdef __APPLE__
 #include <OpenGL/gl.h>
@@ -30,13 +33,15 @@
 
 
 #define NO_SDL_GLEXT
-#include "SDL.h"
+#include "sdlwrap.h"
 #include "SDL_opengl.h"
 #include <stdlib.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
 #include "gl_common.h"
+#include "image.h"
+
 
 #ifdef __APPLE__
 #define pglCreateProgram glCreateProgram
@@ -50,6 +55,7 @@
 #define pglLinkProgram glLinkProgram
 #define pglGetUniformLocation glGetUniformLocation
 #define pglUniform1i glUniform1i
+#define pglUniform1f glUniform1f
 #define pglUniform2fv glUniform2fv
 #define pglUniform4fv glUniform4fv
 #define pglGetShaderiv glGetShaderiv
@@ -58,6 +64,10 @@
 #define pglGetProgramInfoLog glGetProgramInfoLog
 #define pglDeleteProgram glDeleteProgram
 #define pglGetAttachedShaders glGetAttachedShaders
+#define pglGetAttribLocation glGetAttribLocation
+#define pglEnableVertexAttribArray glEnableVertexAttribArray
+#define pglDisableVertexAttribArray glDisableVertexAttribArray
+#define pglVertexAttribPointer glVertexAttribPointer
 #else
 static PFNGLCREATEPROGRAMPROC pglCreateProgram = NULL;
 static PFNGLUSEPROGRAMPROC pglUseProgram = NULL;
@@ -70,6 +80,7 @@ static PFNGLDETACHSHADERPROC pglDetachShader = NULL;
 static PFNGLLINKPROGRAMPROC pglLinkProgram = NULL;
 static PFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation = NULL;
 static PFNGLUNIFORM1IPROC pglUniform1i = NULL;
+static PFNGLUNIFORM1FPROC pglUniform1f = NULL;
 static PFNGLUNIFORM2FVPROC pglUniform2fv = NULL;
 static PFNGLUNIFORM4FVPROC pglUniform4fv = NULL;
 static PFNGLGETSHADERIVPROC pglGetShaderiv = NULL;
@@ -78,9 +89,16 @@ static PFNGLGETPROGRAMIVPROC pglGetProgramiv = NULL;
 static PFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog = NULL;
 static PFNGLDELETEPROGRAMPROC pglDeleteProgram = NULL;
 static PFNGLGETATTACHEDSHADERSPROC pglGetAttachedShaders = NULL;
+static PFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation = NULL;
+static PFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray = NULL;
+static PFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray = NULL;
+static PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer = NULL;
 #endif
 
 #define MAX_PROGRAMS 16
+#define MAX_TEXTURES 8
+#define MAX_VARIABLES 256
+#define PREV_TEXTURES 7
 
 enum filter_type
 {
@@ -96,6 +114,21 @@ static struct gl_fbo_scale gl_scale[MAX_PROGRAMS];
 static unsigned gl_num_programs = 0;
 static unsigned active_index = 0;
 
+static GLuint gl_teximage[MAX_TEXTURES];
+static unsigned gl_teximage_cnt = 0;
+static char gl_teximage_uniforms[MAX_TEXTURES][64];
+
+static snes_tracker_t *gl_snes_tracker = NULL;
+static struct snes_tracker_uniform_info gl_tracker_info[MAX_VARIABLES];
+static unsigned gl_tracker_info_cnt = 0;
+static char gl_tracker_script[MAXPATHLEN];
+static char gl_tracker_script_class[64];
+static xmlChar *gl_script_program = NULL;
+
+static GLint gl_attribs[PREV_TEXTURES + 1 + MAX_PROGRAMS];
+static unsigned gl_attrib_index = 0;
+
+
 struct shader_program
 {
    char *vertex;
@@ -112,6 +145,21 @@ struct shader_program
    bool valid_scale;
 };
 
+static const char *stock_vertex =
+   "varying vec4 color;\n"
+   "void main() {\n"
+   "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
+   "   gl_TexCoord[0] = gl_MultiTexCoord0;\n"
+   "   color = gl_Color;\n"
+   "}";
+
+static const char *stock_fragment =
+   "uniform sampler2D rubyTexture;\n"
+   "varying vec4 color;\n"
+   "void main() {\n"
+   "   gl_FragColor = color * texture2D(rubyTexture, gl_TexCoord[0].xy);\n"
+   "}";
+
 static bool get_xml_attrs(struct shader_program *prog, xmlNodePtr ptr)
 {
    prog->scale_x = 1.0;
@@ -273,6 +321,290 @@ static bool get_xml_attrs(struct shader_program *prog, xmlNodePtr ptr)
    return true;
 }
 
+static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
+{
+   if (gl_teximage_cnt >= MAX_TEXTURES)
+   {
+      SSNES_WARN("Too many texture images! Ignoring ...\n");
+      return true;
+   }
+
+   bool linear = true;
+   xmlChar *filename = xmlGetProp(ptr, (const xmlChar*)"file");
+   xmlChar *filter = xmlGetProp(ptr, (const xmlChar*)"filter");
+   xmlChar *id = xmlGetProp(ptr, (const xmlChar*)"id");
+
+   if (!id)
+   {
+      SSNES_ERR("Could not find ID in texture.\n");
+      goto error;
+   }
+
+   if (!filename)
+   {
+      SSNES_ERR("Could not find filename in texture.\n");
+      goto error;
+   }
+
+   if (filter && strcmp((const char*)filter, "nearest") == 0)
+      linear = false;
+
+   char tex_path[MAXPATHLEN];
+   strlcpy(tex_path, shader_path, sizeof(tex_path));
+
+   char *last = strrchr(tex_path, '/');
+   if (!last) last = strrchr(tex_path, '\\');
+   if (last) last[1] = '\0';
+
+   strlcat(tex_path, (const char*)filename, sizeof(tex_path));
+
+   struct texture_image img;
+   SSNES_LOG("Loading texture image from: \"%s\" ...\n", tex_path);
+   if (!texture_image_load(tex_path, &img))
+   {
+      SSNES_ERR("Failed to load texture image from: \"%s\"\n", tex_path);
+      goto error;
+   }
+
+   strlcpy(gl_teximage_uniforms[gl_teximage_cnt], (const char*)id, sizeof(gl_teximage_uniforms[0]));
+
+   glGenTextures(1, &gl_teximage[gl_teximage_cnt]);
+
+   pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
+   glBindTexture(GL_TEXTURE_2D, gl_teximage[gl_teximage_cnt]);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear ? GL_LINEAR : GL_NEAREST);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear ? GL_LINEAR : GL_NEAREST);
+
+   glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+   glPixelStorei(GL_UNPACK_ROW_LENGTH, img.width);
+   glTexImage2D(GL_TEXTURE_2D,
+         0, GL_RGBA, img.width, img.height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, img.pixels);
+
+   pglActiveTexture(GL_TEXTURE0);
+   glBindTexture(GL_TEXTURE_2D, 0);
+   free(img.pixels);
+
+   xmlFree(filename);
+   xmlFree(id);
+   if (filter)
+      xmlFree(filter);
+
+   gl_teximage_cnt++;
+
+   return true;
+
+error:
+   if (filename)
+      xmlFree(filename);
+   if (filter)
+      xmlFree(filter);
+   if (filter)
+      xmlFree(id);
+   return false;
+}
+
+#ifdef HAVE_PYTHON
+static bool get_script(const char *path, xmlNodePtr ptr)
+{
+   if (*gl_tracker_script || gl_script_program)
+   {
+      SSNES_ERR("Script already imported.\n");
+      return false;
+   }
+
+   xmlChar *script_class = xmlGetProp(ptr, (const xmlChar*)"class");
+   if (script_class)
+   {
+      strlcpy(gl_tracker_script_class, (const char*)script_class, sizeof(gl_tracker_script_class));
+      xmlFree(script_class);
+   }
+
+   xmlChar *language = xmlGetProp(ptr, (const xmlChar*)"language");
+   if (!language || strcmp((const char*)language, "python") != 0)
+   {
+      SSNES_ERR("Script language is not Python!\n");
+      if (language)
+         xmlFree(language);
+      return false;
+   }
+
+   if (language)
+      xmlFree(language);
+
+   xmlChar *src = xmlGetProp(ptr, (const xmlChar*)"src");
+   if (src)
+   {
+      strlcpy(gl_tracker_script, path, sizeof(gl_tracker_script));
+      char *dir_ptr = strrchr(gl_tracker_script, '/');
+      if (!dir_ptr) dir_ptr = strrchr(gl_tracker_script, '\\');
+      if (dir_ptr) dir_ptr[1] = '\0';
+      strlcat(gl_tracker_script, (const char*)src, sizeof(gl_tracker_script));
+
+      xmlFree(src);
+   }
+   else
+   {
+      xmlChar *script = xmlNodeGetContent(ptr);
+      if (!script)
+      {
+         SSNES_ERR("No content in script!\n");
+         return false;
+      }
+      gl_script_program = script;
+   }
+
+   return true;
+}
+#endif
+
+static bool get_import_value(xmlNodePtr ptr)
+{
+   if (gl_tracker_info_cnt >= MAX_VARIABLES)
+   {
+      SSNES_ERR("Too many import variables ...\n");
+      return false;
+   }
+
+   xmlChar *id = xmlGetProp(ptr, (const xmlChar*)"id");
+   xmlChar *semantic = xmlGetProp(ptr, (const xmlChar*)"semantic");
+   xmlChar *wram = xmlGetProp(ptr, (const xmlChar*)"wram");
+   xmlChar *input = xmlGetProp(ptr, (const xmlChar*)"input_slot");
+   xmlChar *apuram = xmlGetProp(ptr, (const xmlChar*)"apuram");
+   xmlChar *vram = xmlGetProp(ptr, (const xmlChar*)"vram");
+   xmlChar *oam = xmlGetProp(ptr, (const xmlChar*)"oam");
+   xmlChar *cgram = xmlGetProp(ptr, (const xmlChar*)"cgram");
+   xmlChar *bitmask = xmlGetProp(ptr, (const xmlChar*)"mask");
+
+   if (!semantic || !id)
+   {
+      SSNES_ERR("No semantic or ID for import value!\n");
+      goto error;
+   }
+
+   enum snes_tracker_type tracker_type;
+
+   if (strcmp((const char*)semantic, "capture") == 0)
+      tracker_type = SSNES_STATE_CAPTURE;
+   else if (strcmp((const char*)semantic, "capture_previous") == 0)
+      tracker_type = SSNES_STATE_CAPTURE_PREV;
+   else if (strcmp((const char*)semantic, "transition") == 0)
+      tracker_type = SSNES_STATE_TRANSITION;
+   else if (strcmp((const char*)semantic, "transition_count") == 0)
+      tracker_type = SSNES_STATE_TRANSITION_COUNT;
+   else if (strcmp((const char*)semantic, "transition_previous") == 0)
+      tracker_type = SSNES_STATE_TRANSITION_PREV;
+#ifdef HAVE_PYTHON
+   else if (strcmp((const char*)semantic, "python") == 0)
+      tracker_type = SSNES_STATE_PYTHON;
+#endif
+   else
+   {
+      SSNES_ERR("Invalid semantic for import value.\n");
+      goto error;
+   }
+
+   enum snes_ram_type ram_type = SSNES_STATE_NONE;
+   uint32_t addr = 0;
+
+#ifdef HAVE_PYTHON
+   if (tracker_type != SSNES_STATE_PYTHON)
+#endif
+   {
+      if (input) 
+      {
+         unsigned slot = strtoul((const char*)input, NULL, 0);
+         switch (slot)
+         {
+            case 1:
+               ram_type = SSNES_STATE_INPUT_SLOT1;
+               break;
+            case 2:
+               ram_type = SSNES_STATE_INPUT_SLOT2;
+               break;
+
+            default:
+               SSNES_ERR("Invalid input slot for import!\n");
+               goto error;
+         }
+      }
+      else if (wram) { addr = strtoul((const char*)wram, NULL, 16); ram_type = SSNES_STATE_WRAM; }
+      else if (apuram) { addr = strtoul((const char*)apuram, NULL, 16); ram_type = SSNES_STATE_APURAM; }
+      else if (vram) { addr = strtoul((const char*)vram, NULL, 16); ram_type = SSNES_STATE_VRAM; }
+      else if (oam) { addr = strtoul((const char*)oam, NULL, 16); ram_type = SSNES_STATE_OAM; }
+      else if (cgram) { addr = strtoul((const char*)cgram, NULL, 16); ram_type = SSNES_STATE_CGRAM; }
+      else
+      {
+         SSNES_ERR("No RAM address specificed for import value.\n");
+         goto error;
+      }
+   }
+
+   unsigned memtype;
+   switch (ram_type)
+   {
+      case SSNES_STATE_WRAM:
+         memtype = SNES_MEMORY_WRAM;
+         break;
+      case SSNES_STATE_APURAM:
+         memtype = SNES_MEMORY_APURAM;
+         break;
+      case SSNES_STATE_VRAM:
+         memtype = SNES_MEMORY_VRAM;
+         break;
+      case SSNES_STATE_OAM:
+         memtype = SNES_MEMORY_OAM;
+         break;
+      case SSNES_STATE_CGRAM:
+         memtype = SNES_MEMORY_CGRAM;
+         break;
+
+      default:
+         memtype = -1u;
+   }
+
+   if ((memtype != -1u) && (addr >= psnes_get_memory_size(memtype)))
+   {
+      SSNES_ERR("Address out of bounds.\n");
+      goto error;
+   }
+
+   unsigned mask_value = 0;
+   if (bitmask)
+      mask_value = strtoul((const char*)bitmask, NULL, 16);
+
+   strlcpy(gl_tracker_info[gl_tracker_info_cnt].id, (const char*)id, sizeof(gl_tracker_info[0].id));
+   gl_tracker_info[gl_tracker_info_cnt].addr = addr;
+   gl_tracker_info[gl_tracker_info_cnt].type = tracker_type;
+   gl_tracker_info[gl_tracker_info_cnt].ram_type = ram_type;
+   gl_tracker_info[gl_tracker_info_cnt].mask = mask_value;
+   gl_tracker_info_cnt++;
+
+   if (id) xmlFree(id);
+   if (semantic) xmlFree(semantic);
+   if (wram) xmlFree(wram);
+   if (input) xmlFree(input);
+   if (apuram) xmlFree(apuram);
+   if (vram) xmlFree(vram);
+   if (oam) xmlFree(oam);
+   if (cgram) xmlFree(cgram);
+   if (bitmask) xmlFree(bitmask);
+   return true;
+
+error:
+   if (id) xmlFree(id);
+   if (semantic) xmlFree(semantic);
+   if (wram) xmlFree(wram);
+   if (input) xmlFree(input);
+   if (apuram) xmlFree(apuram);
+   if (vram) xmlFree(vram);
+   if (oam) xmlFree(oam);
+   if (cgram) xmlFree(cgram);
+   if (bitmask) xmlFree(bitmask);
+   return false;
+}
+
 static unsigned get_xml_shaders(const char *path, struct shader_program *prog, size_t size)
 {
    LIBXML_TEST_VERSION;
@@ -354,6 +686,32 @@ static unsigned get_xml_shaders(const char *path, struct shader_program *prog, s
          }
          num++;
       }
+      else if (strcmp((const char*)cur->name, "texture") == 0)
+      {
+         if (!get_texture_image(path, cur))
+         {
+            SSNES_ERR("Texture image failed to load.\n");
+            goto error;
+         }
+      }
+      else if (strcmp((const char*)cur->name, "import") == 0)
+      {
+         if (!get_import_value(cur))
+         {
+            SSNES_ERR("Import value is invalid.\n");
+            goto error;
+         }
+      }
+#ifdef HAVE_PYTHON
+      else if (strcmp((const char*)cur->name, "script") == 0)
+      {
+         if (!get_script(path, cur))
+         {
+            SSNES_ERR("Script is invalid.\n");
+            goto error;
+         }
+      }
+#endif
    }
 
    if (num == 0)
@@ -376,8 +734,8 @@ error:
 
 static void print_shader_log(GLuint obj)
 {
-   int info_len = 0;
-   int max_len;
+   GLint info_len = 0;
+   GLint max_len;
 
    pglGetShaderiv(obj, GL_INFO_LOG_LENGTH, &max_len);
 
@@ -390,8 +748,8 @@ static void print_shader_log(GLuint obj)
 
 static void print_linker_log(GLuint obj)
 {
-   int info_len = 0;
-   int max_len;
+   GLint info_len = 0;
+   GLint max_len;
 
    pglGetProgramiv(obj, GL_INFO_LOG_LENGTH, &max_len);
 
@@ -402,13 +760,42 @@ static void print_linker_log(GLuint obj)
       SSNES_LOG("Linker log: %s\n", info_log);
 }
 
+static bool compile_shader(GLuint shader, const char *program)
+{
+   pglShaderSource(shader, 1, &program, 0);
+   pglCompileShader(shader);
+
+   GLint status;
+   pglGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+   print_shader_log(shader);
+
+   return status == GL_TRUE;
+}
+
+static bool link_program(GLuint prog)
+{
+   pglLinkProgram(prog);
+
+   GLint status;
+   pglGetProgramiv(prog, GL_LINK_STATUS, &status);
+   print_linker_log(prog);
+
+   if (status == GL_TRUE)
+   {
+      pglUseProgram(prog);
+      return true;
+   }
+   else
+      return false;
+}
+
 static bool compile_programs(GLuint *gl_prog, struct shader_program *progs, size_t num)
 {
    for (unsigned i = 0; i < num; i++)
    {
       gl_prog[i] = pglCreateProgram();
 
-      if (!gl_check_error() || gl_prog[i] == 0)
+      if (gl_prog[i] == 0)
       {
          SSNES_ERR("Failed to create GL program #%u.\n", i);
          return false;
@@ -418,61 +805,56 @@ static bool compile_programs(GLuint *gl_prog, struct shader_program *progs, size
       {
          SSNES_LOG("Found GLSL vertex shader.\n");
          GLuint shader = pglCreateShader(GL_VERTEX_SHADER);
-         pglShaderSource(shader, 1, (const char**)&progs[i].vertex, 0);
-         pglCompileShader(shader);
-         print_shader_log(shader);
+         if (!compile_shader(shader, progs[i].vertex))
+         {
+            SSNES_ERR("Failed to compile vertex shader #%u\n", i);
+            return false;
+         }
 
          pglAttachShader(gl_prog[i], shader);
          free(progs[i].vertex);
       }
 
-      if (!gl_check_error())
-      {
-         SSNES_ERR("Failed to compile vertex shader #%u\n", i);
-         return false;
-      }
-
       if (progs[i].fragment)
       {
          SSNES_LOG("Found GLSL fragment shader.\n");
          GLuint shader = pglCreateShader(GL_FRAGMENT_SHADER);
-         pglShaderSource(shader, 1, (const char**)&progs[i].fragment, 0);
-         pglCompileShader(shader);
-         print_shader_log(shader);
+         if (!compile_shader(shader, progs[i].fragment))
+         {
+            SSNES_ERR("Failed to compile fragment shader #%u\n", i);
+            return false;
+         }
 
          pglAttachShader(gl_prog[i], shader);
          free(progs[i].fragment);
       }
 
-      if (!gl_check_error())
-      {
-         SSNES_ERR("Failed to compile fragment shader #%u\n", i);
-         return false;
-      }
-
       if (progs[i].vertex || progs[i].fragment)
       {
          SSNES_LOG("Linking GLSL program.\n");
-         pglLinkProgram(gl_prog[i]);
-         pglUseProgram(gl_prog[i]);
-         print_linker_log(gl_prog[i]);
+         if (!link_program(gl_prog[i]))
+         {
+            SSNES_ERR("Failed to link program #%u\n", i);
+            return false;
+         }
 
          GLint location = pglGetUniformLocation(gl_prog[i], "rubyTexture");
          pglUniform1i(location, 0);
          pglUseProgram(0);
       }
-
-      if (!gl_check_error())
-      {
-         SSNES_ERR("Failed to link program #%u\n", i);
-         return false;
-      }
    }
 
    return true;
 }
 
-#define LOAD_GL_SYM(SYM) if (!(pgl##SYM)) pgl##SYM = SDL_GL_GetProcAddress("gl" #SYM)
+static void gl_glsl_reset_attrib(void)
+{
+   for (unsigned i = 0; i < gl_attrib_index; i++)
+      pglDisableVertexAttribArray(gl_attribs[i]);
+   gl_attrib_index = 0;
+}
+
+#define LOAD_GL_SYM(SYM) if (!pgl##SYM) { SDL_SYM_WRAP(pgl##SYM, "gl" #SYM) }
 
 bool gl_glsl_init(const char *path)
 {
@@ -489,6 +871,7 @@ bool gl_glsl_init(const char *path)
    LOAD_GL_SYM(LinkProgram);
    LOAD_GL_SYM(GetUniformLocation);
    LOAD_GL_SYM(Uniform1i);
+   LOAD_GL_SYM(Uniform1f);
    LOAD_GL_SYM(Uniform2fv);
    LOAD_GL_SYM(Uniform4fv);
    LOAD_GL_SYM(GetShaderiv);
@@ -497,6 +880,10 @@ bool gl_glsl_init(const char *path)
    LOAD_GL_SYM(GetProgramInfoLog);
    LOAD_GL_SYM(DeleteProgram);
    LOAD_GL_SYM(GetAttachedShaders);
+   LOAD_GL_SYM(GetAttribLocation);
+   LOAD_GL_SYM(EnableVertexAttribArray);
+   LOAD_GL_SYM(DisableVertexAttribArray);
+   LOAD_GL_SYM(VertexAttribPointer);
 #endif
 
    SSNES_LOG("Checking GLSL shader support ...\n");
@@ -506,17 +893,26 @@ bool gl_glsl_init(const char *path)
    bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
       && pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
       && pglDetachShader && pglLinkProgram && pglGetUniformLocation
-      && pglUniform1i && pglUniform2fv && pglUniform4fv
+      && pglUniform1i && pglUniform1f && pglUniform2fv && pglUniform4fv
       && pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog 
-      && pglDeleteProgram && pglGetAttachedShaders;
+      && pglDeleteProgram && pglGetAttachedShaders
+      && pglGetAttribLocation && pglEnableVertexAttribArray && pglDisableVertexAttribArray
+      && pglVertexAttribPointer;
 #endif
 
    if (!shader_support)
    {
-      SSNES_ERR("GLSL shaders aren't supported by your GL driver.\n");
+      SSNES_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
       return false;
    }
 
+   struct shader_program stock_prog = {
+      .vertex = strdup(stock_vertex),
+      .fragment = strdup(stock_fragment),
+   };
+   if (!compile_programs(&gl_program[0], &stock_prog, 1))
+      return false;
+
    struct shader_program progs[MAX_PROGRAMS];
    unsigned num_progs = get_xml_shaders(path, progs, MAX_PROGRAMS - 1);
 
@@ -542,7 +938,7 @@ bool gl_glsl_init(const char *path)
       return false;
 
    // SSNES custom two-pass with two different files.
-   if (num_progs == 1 && *g_settings.video.second_pass_shader)
+   if (num_progs == 1 && *g_settings.video.second_pass_shader && g_settings.video.render_to_texture)
    {
       unsigned secondary_progs = get_xml_shaders(g_settings.video.second_pass_shader, progs, 1);
       if (secondary_progs == 1)
@@ -557,11 +953,44 @@ bool gl_glsl_init(const char *path)
       }
    }
 
-   if (!gl_check_error())
-      return false;
+   //if (!gl_check_error())
+   //   SSNES_WARN("Detected GL error!\n");
+
+   if (gl_tracker_info_cnt > 0)
+   {
+      struct snes_tracker_info info = {
+         .wram = psnes_get_memory_data(SNES_MEMORY_WRAM),
+         .vram = psnes_get_memory_data(SNES_MEMORY_VRAM),
+         .cgram = psnes_get_memory_data(SNES_MEMORY_CGRAM),
+         .apuram = psnes_get_memory_data(SNES_MEMORY_APURAM),
+         .oam = psnes_get_memory_data(SNES_MEMORY_OAM),
+         .info = gl_tracker_info,
+         .info_elem = gl_tracker_info_cnt,
+      };
+
+#ifdef HAVE_PYTHON
+      if (*gl_tracker_script)
+         info.script = gl_tracker_script;
+      else if (gl_script_program)
+         info.script = (const char*)gl_script_program;
+      else
+         info.script = NULL;
+
+      info.script_class = *gl_tracker_script_class ? gl_tracker_script_class : NULL;
+      info.script_is_file = *gl_tracker_script;
+#endif
+
+      gl_snes_tracker = snes_tracker_init(&info);
+      if (!gl_snes_tracker)
+         SSNES_WARN("Failed to init SNES tracker!\n");
+   }
    
    glsl_enable = true;
    gl_num_programs = num_progs;
+   gl_program[gl_num_programs + 1] = gl_program[0];
+
+   gl_glsl_reset_attrib();
+
    return true;
 }
 
@@ -570,10 +999,10 @@ void gl_glsl_deinit(void)
    if (glsl_enable)
    {
       pglUseProgram(0);
-      for (int i = 1; i < MAX_PROGRAMS; i++)
+      for (int i = 0; i <= gl_num_programs; i++)
       {
          if (gl_program[i] == 0)
-            break;
+            continue;
 
          GLsizei count;
          GLuint shaders[2];
@@ -587,32 +1016,216 @@ void gl_glsl_deinit(void)
 
          pglDeleteProgram(gl_program[i]);
       }
+
+      glDeleteTextures(gl_teximage_cnt, gl_teximage);
+      gl_teximage_cnt = 0;
+      memset(gl_teximage_uniforms, 0, sizeof(gl_teximage_uniforms));
    }
 
    memset(gl_program, 0, sizeof(gl_program));
    glsl_enable = false;
    active_index = 0;
+
+   gl_tracker_info_cnt = 0;
+   memset(gl_tracker_info, 0, sizeof(gl_tracker_info));
+   memset(gl_tracker_script, 0, sizeof(gl_tracker_script));
+   memset(gl_tracker_script_class, 0, sizeof(gl_tracker_script_class));
+   if (gl_script_program)
+   {
+      xmlFree(gl_script_program);
+      gl_script_program = NULL;
+   }
+   if (gl_snes_tracker)
+   {
+      snes_tracker_free(gl_snes_tracker);
+      gl_snes_tracker = NULL;
+   }
+
+   gl_glsl_reset_attrib();
 }
 
 void gl_glsl_set_params(unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
-      unsigned out_width, unsigned out_height)
+      unsigned out_width, unsigned out_height,
+      unsigned frame_count,
+      const struct gl_tex_info *info, 
+      const struct gl_tex_info *prev_info, 
+      const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt)
 {
-   if (glsl_enable && gl_program[active_index] > 0)
+   // We enforce a certain layout for our various texture types in the texunits.
+   // - Regular SNES frame (rubyTexture) (always bound).
+   // - LUT textures (always bound).
+   // - Original texture (always bound if meaningful).
+   // - FBO textures (always bound if available).
+   // - Previous textures.
+
+   if (!glsl_enable || (gl_program[active_index] == 0))
+      return;
+
+   GLint location;
+
+   float inputSize[2] = {width, height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyInputSize");
+   pglUniform2fv(location, 1, inputSize);
+
+   float outputSize[2] = {out_width, out_height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyOutputSize");
+   pglUniform2fv(location, 1, outputSize);
+
+   float textureSize[2] = {tex_width, tex_height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyTextureSize");
+   pglUniform2fv(location, 1, textureSize);
+
+   location = pglGetUniformLocation(gl_program[active_index], "rubyFrameCount");
+   pglUniform1i(location, frame_count);
+
+   location = pglGetUniformLocation(gl_program[active_index], "rubyFrameDirection");
+   pglUniform1i(location, g_extern.frame_is_reverse ? -1 : 1);
+
+   for (unsigned i = 0; i < gl_teximage_cnt; i++)
    {
-      GLint location;
+      location = pglGetUniformLocation(gl_program[active_index], gl_teximage_uniforms[i]);
+      pglUniform1i(location, i + 1);
+   }
 
-      float inputSize[2] = {width, height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyInputSize");
-      pglUniform2fv(location, 1, inputSize);
+   unsigned texunit = gl_teximage_cnt + 1;
 
-      float outputSize[2] = {out_width, out_height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyOutputSize");
-      pglUniform2fv(location, 1, outputSize);
+   // Set original texture unless we're in first pass (pointless).
+   if (active_index > 1)
+   {
+      // Bind original texture.
+      pglActiveTexture(GL_TEXTURE0 + texunit);
 
-      float textureSize[2] = {tex_width, tex_height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyTextureSize");
-      pglUniform2fv(location, 1, textureSize);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTexture");
+      pglUniform1i(location, texunit++);
+      glBindTexture(GL_TEXTURE_2D, info->tex);
+
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTextureSize");
+      pglUniform2fv(location, 1, info->tex_size);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigInputSize");
+      pglUniform2fv(location, 1, info->input_size);
+
+      // Pass texture coordinates.
+      location = pglGetAttribLocation(gl_program[active_index], "rubyOrigTexCoord");
+      if (location >= 0)
+      {
+         pglEnableVertexAttribArray(location);
+         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, info->coord);
+         gl_attribs[gl_attrib_index++] = location;
+      }
+
+      // Bind new texture in the chain.
+      if (fbo_info_cnt > 0)
+      {
+         pglActiveTexture(GL_TEXTURE0 + texunit + fbo_info_cnt - 1);
+         glBindTexture(GL_TEXTURE_2D, fbo_info[fbo_info_cnt - 1].tex);
+      }
+
+      // Bind FBO textures.
+      for (unsigned i = 0; i < fbo_info_cnt; i++)
+      {
+         char attrib_buf[64];
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexture", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform1i(location, texunit++);
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTextureSize", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform2fv(location, 1, fbo_info[i].tex_size);
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uInputSize", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform2fv(location, 1, fbo_info[i].input_size);
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexCoord", i + 1);
+         location = pglGetAttribLocation(gl_program[active_index], attrib_buf);
+         if (location >= 0)
+         {
+            pglEnableVertexAttribArray(location);
+            pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, fbo_info[i].coord);
+            gl_attribs[gl_attrib_index++] = location;
+         }
+      }
+   }
+   else
+   {
+      // First pass, so unbind everything to avoid collitions.
+      // Unbind ORIG.
+      pglActiveTexture(GL_TEXTURE0 + texunit);
+      glBindTexture(GL_TEXTURE_2D, 0);
+
+      GLuint base_tex = texunit + 1;
+      // Unbind any lurking FBO passes.
+      // Rendering to a texture that is bound to a texture unit
+      // sounds very shaky ... ;)
+      for (unsigned i = 0; i < gl_num_programs; i++)
+      {
+         pglActiveTexture(GL_TEXTURE0 + base_tex + i);
+         glBindTexture(GL_TEXTURE_2D, 0);
+      }
+   }
+
+   // Set previous textures. Only bind if they're actually used.
+   for (unsigned i = 0; i < PREV_TEXTURES; i++)
+   {
+      char attr_buf_tex[64];
+      char attr_buf_tex_size[64];
+      char attr_buf_input_size[64];
+      char attr_buf_coord[64];
+      static const char *prev_names[PREV_TEXTURES] = {
+         "Prev",
+         "Prev1",
+         "Prev2",
+         "Prev3",
+         "Prev4",
+         "Prev5",
+         "Prev6",
+      };
+
+      snprintf(attr_buf_tex,        sizeof(attr_buf_tex),        "ruby%sTexture",     prev_names[i]);
+      snprintf(attr_buf_tex_size,   sizeof(attr_buf_tex_size),   "ruby%sTextureSize", prev_names[i]);
+      snprintf(attr_buf_input_size, sizeof(attr_buf_input_size), "ruby%sInputSize",   prev_names[i]);
+      snprintf(attr_buf_coord,      sizeof(attr_buf_coord),      "ruby%sTexCoord",    prev_names[i]);
+
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_tex);
+      if (location >= 0)
+      {
+         pglActiveTexture(GL_TEXTURE0 + texunit);
+         glBindTexture(GL_TEXTURE_2D, prev_info[i].tex);
+         pglUniform1i(location, texunit++);
+      }
+
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_tex_size);
+      pglUniform2fv(location, 1, prev_info[i].tex_size);
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_input_size);
+      pglUniform2fv(location, 1, prev_info[i].input_size);
+
+      // Pass texture coordinates.
+      location = pglGetAttribLocation(gl_program[active_index], attr_buf_coord);
+      if (location >= 0)
+      {
+         pglEnableVertexAttribArray(location);
+         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, prev_info[i].coord);
+         gl_attribs[gl_attrib_index++] = location;
+      }
+   }
+
+   pglActiveTexture(GL_TEXTURE0);
+
+   if (gl_snes_tracker)
+   {
+      static struct snes_tracker_uniform info[MAX_VARIABLES];
+      static unsigned cnt = 0;
+
+      if (active_index == 1)
+         cnt = snes_get_uniform(gl_snes_tracker, info, MAX_VARIABLES, frame_count);
+
+      for (unsigned i = 0; i < cnt; i++)
+      {
+         location = pglGetUniformLocation(gl_program[active_index], info[i].id);
+         pglUniform1f(location, info[i].value);
+      }
    }
 }
 
@@ -623,6 +1236,8 @@ void gl_glsl_use(unsigned index)
 {
    if (glsl_enable)
    {
+      gl_glsl_reset_attrib();
+
       active_index = index;
       pglUseProgram(gl_program[index]);
    }

gfx/shader_glsl.h

@@ -30,7 +30,11 @@ void gl_glsl_set_proj_matrix(void);
 
 void gl_glsl_set_params(unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
-      unsigned out_width, unsigned out_height);
+      unsigned out_width, unsigned out_height,
+      unsigned frame_counter,
+      const struct gl_tex_info *info, 
+      const struct gl_tex_info *prev_info,
+      const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt);
 
 void gl_glsl_use(unsigned index);
 

gfx/snes_state.c

@@ -0,0 +1,260 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "snes_state.h"
+#include <stdlib.h>
+#include <assert.h>
+#include "../strl.h"
+#include "../general.h"
+#include "../libsnes.hpp"
+
+#ifdef HAVE_PYTHON
+#include "py_state/py_state.h"
+#endif
+
+struct snes_tracker_internal
+{
+   char id[64];
+
+   bool is_input;
+   const uint16_t *input_ptr;
+   const uint8_t *ptr;
+#ifdef HAVE_PYTHON
+   py_state_t *py;
+#endif
+
+   uint32_t addr;
+   unsigned mask;
+
+   enum snes_tracker_type type;
+
+   uint32_t prev[2];
+   int frame_count;
+   int frame_count_prev;
+   uint32_t old_value; 
+   int transition_count;
+};
+
+struct snes_tracker
+{
+   struct snes_tracker_internal *info;
+   unsigned info_elem;
+
+   uint16_t input_state[2];
+
+#ifdef HAVE_PYTHON
+   py_state_t *py;
+#endif
+};
+
+snes_tracker_t* snes_tracker_init(const struct snes_tracker_info *info)
+{
+   snes_tracker_t *tracker = calloc(1, sizeof(*tracker));
+   if (!tracker)
+      return NULL;
+
+#ifdef HAVE_PYTHON
+   if (info->script)
+   {
+      tracker->py = py_state_new(info->script, info->script_is_file, info->script_class ? info->script_class : "GameAware");
+      if (!tracker->py)
+      {
+         free(tracker);
+         SSNES_ERR("Failed to init Python script.\n");
+         return NULL;
+      }
+   }
+#endif
+
+   tracker->info = calloc(info->info_elem, sizeof(struct snes_tracker_internal));
+   tracker->info_elem = info->info_elem;
+
+   for (unsigned i = 0; i < info->info_elem; i++)
+   {
+      strlcpy(tracker->info[i].id, info->info[i].id, sizeof(tracker->info[i].id));
+      tracker->info[i].addr = info->info[i].addr;
+      tracker->info[i].type = info->info[i].type;
+      tracker->info[i].mask = (info->info[i].mask == 0) ? -1u : info->info[i].mask;
+
+#ifdef HAVE_PYTHON
+      if (info->info[i].type == SSNES_STATE_PYTHON)
+         tracker->info[i].py = tracker->py;
+#endif
+
+      // If we don't have a valid pointer.
+      static const uint8_t empty = 0;
+
+      switch (info->info[i].ram_type)
+      {
+         case SSNES_STATE_WRAM:
+            tracker->info[i].ptr = info->wram ? info->wram : &empty;
+            break;
+         case SSNES_STATE_APURAM:
+            tracker->info[i].ptr = info->apuram ? info->apuram : &empty;
+            break;
+         case SSNES_STATE_OAM:
+            tracker->info[i].ptr = info->oam ? info->oam : &empty;
+            break;
+         case SSNES_STATE_CGRAM:
+            tracker->info[i].ptr = info->cgram ? info->cgram : &empty;
+            break;
+         case SSNES_STATE_VRAM:
+            tracker->info[i].ptr = info->vram ? info->vram : &empty;
+            break;
+         case SSNES_STATE_INPUT_SLOT1:
+            tracker->info[i].input_ptr = &tracker->input_state[0];
+            tracker->info[i].is_input = true;
+            break;
+         case SSNES_STATE_INPUT_SLOT2:
+            tracker->info[i].input_ptr = &tracker->input_state[1];
+            tracker->info[i].is_input = true;
+            break;
+
+         default:
+            tracker->info[i].ptr = &empty;
+      }
+   }
+
+   return tracker;
+}
+
+void snes_tracker_free(snes_tracker_t *tracker)
+{
+   free(tracker->info);
+#ifdef HAVE_PYTHON
+   py_state_free(tracker->py);
+#endif
+   free(tracker);
+}
+
+#define fetch() ((info->is_input ? *info->input_ptr : info->ptr[info->addr]) & info->mask)
+
+static void update_element(
+      struct snes_tracker_uniform *uniform,
+      struct snes_tracker_internal *info,
+      unsigned frame_count)
+{
+   uniform->id = info->id;
+
+   switch (info->type)
+   {
+      case SSNES_STATE_CAPTURE:
+         uniform->value = fetch();
+         break;
+
+      case SSNES_STATE_CAPTURE_PREV:
+         if (info->prev[0] != fetch())
+         {
+            info->prev[1] = info->prev[0];
+            info->prev[0] = fetch();
+         }
+         uniform->value = info->prev[1];
+         break;
+
+      case SSNES_STATE_TRANSITION:
+         if (info->old_value != fetch())
+         {
+            info->old_value = fetch();
+            info->frame_count = frame_count;
+         }
+         uniform->value = info->frame_count;
+         break;
+
+      case SSNES_STATE_TRANSITION_COUNT:
+         if (info->old_value != fetch())
+         {
+            info->old_value = fetch();
+            info->transition_count++;
+         }
+         uniform->value = info->transition_count;
+         break;
+
+      case SSNES_STATE_TRANSITION_PREV:
+         if (info->old_value != fetch())
+         {
+            info->old_value = fetch();
+            info->frame_count_prev = info->frame_count;
+            info->frame_count = frame_count;
+         }
+         uniform->value = info->frame_count_prev;
+         break;
+      
+#ifdef HAVE_PYTHON
+      case SSNES_STATE_PYTHON:
+         uniform->value = py_state_get(info->py, info->id, frame_count);
+         break;
+#endif
+      
+      default:
+         break;
+   }
+}
+
+#undef fetch
+
+// Updates 16-bit input in same format as SNES itself.
+static void update_input(snes_tracker_t *tracker)
+{
+   if (!driver.input_data)
+      return;
+
+   static const unsigned buttons[] = {
+      SNES_DEVICE_ID_JOYPAD_R,
+      SNES_DEVICE_ID_JOYPAD_L,
+      SNES_DEVICE_ID_JOYPAD_X,
+      SNES_DEVICE_ID_JOYPAD_A,
+      SNES_DEVICE_ID_JOYPAD_RIGHT,
+      SNES_DEVICE_ID_JOYPAD_LEFT,
+      SNES_DEVICE_ID_JOYPAD_DOWN,
+      SNES_DEVICE_ID_JOYPAD_UP,
+      SNES_DEVICE_ID_JOYPAD_START,
+      SNES_DEVICE_ID_JOYPAD_SELECT,
+      SNES_DEVICE_ID_JOYPAD_Y,
+      SNES_DEVICE_ID_JOYPAD_B
+   };
+
+   static const struct snes_keybind *binds[MAX_PLAYERS] = {
+      g_settings.input.binds[0],
+      g_settings.input.binds[1],
+      g_settings.input.binds[2],
+      g_settings.input.binds[3],
+      g_settings.input.binds[4]
+   };
+
+   uint16_t state[2] = {0};
+   for (unsigned i = 4; i < 16; i++)
+   {
+      state[0] |= (driver.input->input_state(driver.input_data, binds, SNES_PORT_1, SNES_DEVICE_JOYPAD, 0, buttons[i - 4]) ? 1 : 0) << i;
+      state[1] |= (driver.input->input_state(driver.input_data, binds, SNES_PORT_2, SNES_DEVICE_JOYPAD, 0, buttons[i - 4]) ? 1 : 0) << i;
+   }
+
+   for (unsigned i = 0; i < 2; i++)
+      tracker->input_state[i] = state[i];
+}
+
+unsigned snes_get_uniform(snes_tracker_t *tracker, struct snes_tracker_uniform *uniforms, unsigned elem, unsigned frame_count)
+{
+   unsigned elems = tracker->info_elem < elem ? tracker->info_elem : elem;
+
+   update_input(tracker);
+
+   for (unsigned i = 0; i < elems; i++)
+      update_element(&uniforms[i], &tracker->info[i], frame_count);
+
+   return elems;
+}
+

gfx/snes_state.h

@@ -0,0 +1,92 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_SNES_STATE_H
+#define __SSNES_SNES_STATE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+enum snes_tracker_type
+{
+   SSNES_STATE_CAPTURE,
+   SSNES_STATE_CAPTURE_PREV,
+   SSNES_STATE_TRANSITION,
+   SSNES_STATE_TRANSITION_COUNT,
+   SSNES_STATE_TRANSITION_PREV,
+#ifdef HAVE_PYTHON
+   SSNES_STATE_PYTHON
+#endif
+};
+
+enum snes_ram_type
+{
+   SSNES_STATE_NONE,
+   SSNES_STATE_WRAM,
+   SSNES_STATE_APURAM,
+   SSNES_STATE_OAM,
+   SSNES_STATE_CGRAM,
+   SSNES_STATE_VRAM,
+   SSNES_STATE_INPUT_SLOT1,
+   SSNES_STATE_INPUT_SLOT2
+};
+
+struct snes_tracker_uniform_info
+{
+   char id[64];
+   uint32_t addr;
+   enum snes_tracker_type type;
+   enum snes_ram_type ram_type;
+   unsigned mask;
+};
+
+struct snes_tracker_info
+{
+   const uint8_t *wram;
+   const uint8_t *vram;
+   const uint8_t *cgram;
+   const uint8_t *oam;
+   const uint8_t *apuram;
+
+   const struct snes_tracker_uniform_info *info;
+   unsigned info_elem;
+
+#ifdef HAVE_PYTHON
+   const char *script;
+   const char *script_class;
+   bool script_is_file;
+#endif
+};
+
+struct snes_tracker_uniform
+{
+   const char *id;
+   float value;
+};
+
+typedef struct snes_tracker snes_tracker_t;
+
+snes_tracker_t* snes_tracker_init(const struct snes_tracker_info *info);
+void snes_tracker_free(snes_tracker_t *tracker);
+
+unsigned snes_get_uniform(snes_tracker_t *tracker, struct snes_tracker_uniform *uniforms, unsigned elem, unsigned frame_count);
+
+#endif

gfx/xvideo.c

@@ -63,11 +63,17 @@ struct xv
    uint8_t *ytable;
    uint8_t *utable;
    uint8_t *vtable;
-   unsigned luma_i;
-   unsigned chroma_i;
 
 #ifdef HAVE_FREETYPE
    font_renderer_t *font;
+
+   unsigned luma_index[2];
+   unsigned chroma_u_index;
+   unsigned chroma_v_index;
+
+   uint8_t font_y;
+   uint8_t font_u;
+   uint8_t font_v;
 #endif
 
    void (*render_func)(xv_t*, const void *frame, unsigned width, unsigned height, unsigned pitch);
@@ -77,7 +83,7 @@ static void xv_set_nonblock_state(void *data, bool state)
 {
    xv_t *xv = data;
    Atom atom = XInternAtom(xv->display, "XV_SYNC_TO_VBLANK", true);
-   if (atom != None && xv->port >= 0)
+   if (atom != None && xv->port)
       XvSetPortAttribute(xv->display, xv->port, atom, !state);
    else
       SSNES_WARN("Failed to set SYNC_TO_VBLANK attribute.\n");
@@ -89,6 +95,17 @@ static void sighandler(int sig)
    g_quit = 1;
 }
 
+static inline void calculate_yuv(uint8_t *y, uint8_t *u, uint8_t *v, unsigned r, unsigned g, unsigned b)
+{
+   int y_ = (int)(+((double)r * 0.257) + ((double)g * 0.504) + ((double)b * 0.098) +  16.0);
+   int u_ = (int)(-((double)r * 0.148) - ((double)g * 0.291) + ((double)b * 0.439) + 128.0);
+   int v_ = (int)(+((double)r * 0.439) - ((double)g * 0.368) - ((double)b * 0.071) + 128.0);
+
+   *y = y_ < 0 ? 0 : (y_ > 255 ? 255 : y_);
+   *u = y_ < 0 ? 0 : (u_ > 255 ? 255 : u_);
+   *v = v_ < 0 ? 0 : (v_ > 255 ? 255 : v_);
+}
+
 static void init_yuv_tables(xv_t *xv)
 {
    xv->ytable = malloc(0x8000);
@@ -98,18 +115,12 @@ static void init_yuv_tables(xv_t *xv)
    for (unsigned i = 0; i < 0x8000; i++) 
    {
       // Extract RGB555 color data from i
-      uint8_t r = (i >> 10) & 0x1F, g = (i >> 5) & 0x1F, b = (i) & 0x1F;
-      r = (r << 3) | (r >> 2);  //R5->R8
-      g = (g << 3) | (g >> 2);  //G5->G8
-      b = (b << 3) | (b >> 2);  //B5->B8
+      unsigned r = (i >> 10) & 0x1F, g = (i >> 5) & 0x1F, b = (i) & 0x1F;
+      r = (r << 3) | (r >> 2);  // R5->R8
+      g = (g << 3) | (g >> 2);  // G5->G8
+      b = (b << 3) | (b >> 2);  // B5->B8
 
-      int y = (int)(+((double)r * 0.257) + ((double)g * 0.504) + ((double)b * 0.098) +  16.0);
-      int u = (int)(-((double)r * 0.148) - ((double)g * 0.291) + ((double)b * 0.439) + 128.0);
-      int v = (int)(+((double)r * 0.439) - ((double)g * 0.368) - ((double)b * 0.071) + 128.0);
-
-      xv->ytable[i] = y < 0 ? 0 : y > 255 ? 255 : y;
-      xv->utable[i] = u < 0 ? 0 : u > 255 ? 255 : u;
-      xv->vtable[i] = v < 0 ? 0 : v > 255 ? 255 : v;
+      calculate_yuv(&xv->ytable[i], &xv->utable[i], &xv->vtable[i], r, g, b);
    }
 }
 
@@ -173,12 +184,33 @@ static void set_fullscreen(xv_t *xv)
 static void xv_init_font(xv_t *xv, const char *font_path, unsigned font_size)
 {
 #ifdef HAVE_FREETYPE
-   if (*font_path)
+   if (!g_settings.video.font_enable)
+      return;
+
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      xv->font = font_renderer_new(font_path, font_size);
-      if (!xv->font)
-         SSNES_WARN("Failed to init font\n");
+      xv->font = font_renderer_new(path, font_size);
+      if (xv->font)
+      {
+         int r = g_settings.video.msg_color_r * 255;
+         r = (r < 0 ? 0 : (r > 255 ? 255 : r));
+         int g = g_settings.video.msg_color_g * 255;
+         g = (g < 0 ? 0 : (g > 255 ? 255 : g));
+         int b = g_settings.video.msg_color_b * 255;
+         b = (b < 0 ? 0 : (b > 255 ? 255 : b));
+
+         calculate_yuv(&xv->font_y, &xv->font_u, &xv->font_v,
+               r, g, b);
+      }
+      else
+         SSNES_WARN("Failed to init font.\n");
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
 #endif
 }
 
@@ -249,7 +281,7 @@ static void render32_yuy2(xv_t *xv, const void *input_, unsigned width, unsigned
       for (unsigned x = 0; x < width; x++)
       {
          uint32_t p = *input++;
-         p = ((p >> 17) & 0x7c00) | ((p >> 14) & 0x03e0) | ((p >> 11) & 0x1f); // RGBA -> RGB15
+         p = ((p >> 9) & 0x7c00) | ((p >> 6) & 0x03e0) | ((p >> 3) & 0x1f); // ARGB -> RGB15
 
          uint8_t y0 = xv->ytable[p];
          uint8_t u = xv->utable[p];
@@ -278,7 +310,7 @@ static void render32_uyvy(xv_t *xv, const void *input_, unsigned width, unsigned
       for (unsigned x = 0; x < width; x++)
       {
          uint32_t p = *input++;
-         p = ((p >> 17) & 0x7c00) | ((p >> 14) & 0x03e0) | ((p >> 11) & 0x1f); // RGBA -> RGB15
+         p = ((p >> 9) & 0x7c00) | ((p >> 6) & 0x03e0) | ((p >> 3) & 0x1f); // ARGB -> RGB15
 
          uint8_t y0 = xv->ytable[p];
          uint8_t u = xv->utable[p];
@@ -297,8 +329,76 @@ static void render32_uyvy(xv_t *xv, const void *input_, unsigned width, unsigned
    }
 }
 
+struct format_desc
+{
+   void (*render_16)(xv_t *xv, const void *input,
+         unsigned width, unsigned height, unsigned pitch);
+   void (*render_32)(xv_t *xv, const void *input,
+         unsigned width, unsigned height, unsigned pitch);
+   char components[4];
+   unsigned luma_index[2];
+   unsigned u_index;
+   unsigned v_index;
+};
 
-static void* xv_init(video_info_t *video, const input_driver_t **input, void **input_data)
+static const struct format_desc formats[] = {
+   {
+      .render_16 = render16_yuy2,
+      .render_32 = render32_yuy2,
+      .components = { 'Y', 'U', 'Y', 'V' },
+      .luma_index = { 0, 2 },
+      .u_index = 1,
+      .v_index = 3,
+   },
+   {
+      .render_16 = render16_uyvy,
+      .render_32 = render32_uyvy,
+      .components = { 'U', 'Y', 'V', 'Y' },
+      .luma_index = { 1, 3 },
+      .u_index = 0,
+      .v_index = 2,
+   },
+};
+
+static bool adaptor_set_format(xv_t *xv, Display *dpy, XvPortID port, const video_info_t *video)
+{
+   int format_count;
+   XvImageFormatValues *format = XvListImageFormats(xv->display, port, &format_count);
+   if (!format)
+      return false;
+
+   for (int i = 0; i < format_count; i++) 
+   {
+      for (unsigned j = 0; j < sizeof(formats) / sizeof(formats[0]); j++)
+      {
+         if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
+         {
+            if (format[i].component_order[0] == formats[j].components[0] &&
+                  format[i].component_order[1] == formats[j].components[1] &&
+                  format[i].component_order[2] == formats[j].components[2] &&
+                  format[i].component_order[3] == formats[j].components[3]) 
+            {
+               xv->fourcc = format[i].id;
+               xv->render_func = video->rgb32 ? formats[j].render_32 : formats[j].render_16;
+
+#ifdef HAVE_FREETYPE
+               xv->luma_index[0] = formats[j].luma_index[0];
+               xv->luma_index[1] = formats[j].luma_index[1];
+               xv->chroma_u_index = formats[j].u_index;
+               xv->chroma_v_index = formats[j].v_index;
+#endif
+               XFree(format);
+               return true;
+            }
+         }
+      }
+   }
+
+   XFree(format);
+   return false;
+}
+
+static void *xv_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
    xv_t *xv = calloc(1, sizeof(*xv));
    if (!xv)
@@ -315,7 +415,7 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
    xv->keep_aspect = video->force_aspect;
 
    // Find an appropriate Xv port.
-   xv->port = -1;
+   xv->port = 0;
    XvAdaptorInfo *adaptor_info;
    unsigned adaptor_count = 0;
    XvQueryAdaptors(xv->display, DefaultRootWindow(xv->display), &adaptor_count, &adaptor_info);
@@ -325,17 +425,20 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
       if (adaptor_info[i].num_formats < 1) continue;
       if (!(adaptor_info[i].type & XvInputMask)) continue;
       if (!(adaptor_info[i].type & XvImageMask)) continue;
+      if (!adaptor_set_format(xv, xv->display, adaptor_info[i].base_id, video)) continue;
 
       xv->port     = adaptor_info[i].base_id;
       xv->depth    = adaptor_info[i].formats->depth;
       xv->visualid = adaptor_info[i].formats->visual_id;
+
+      SSNES_LOG("XVideo: Found suitable XvPort #%u\n", (unsigned)xv->port);
       break;
    }
    XvFreeAdaptorInfo(adaptor_info);
 
-   if (xv->port < 0) 
+   if (xv->port == 0) 
    {
-      SSNES_ERR("XVideo: Failed to find valid XvPort.\n");
+      SSNES_ERR("XVideo: Failed to find valid XvPort or format.\n");
       goto error;
    }
 
@@ -359,8 +462,8 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
    attributes.border_pixel = 0;
    attributes.event_mask = StructureNotifyMask | DestroyNotify | ClientMessage;
 
-   unsigned width = video->fullscreen ? ((video->width == 0) ? 256 : video->width) : video->width;
-   unsigned height = video->fullscreen ? ((video->height == 0) ? 224 : video->height) : video->height;
+   unsigned width = video->fullscreen ? ((video->width == 0) ? g_extern.system.geom.base_width : video->width) : video->width;
+   unsigned height = video->fullscreen ? ((video->height == 0) ? g_extern.system.geom.base_height : video->height) : video->height;
    xv->window = XCreateWindow(xv->display, DefaultRootWindow(xv->display),
          0, 0, width, height,
          0, xv->depth, InputOutput, visualinfo->visual,
@@ -383,54 +486,10 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
 
    // Set colorkey to auto paint, so that Xv video output is always visible
    Atom atom = XInternAtom(xv->display, "XV_AUTOPAINT_COLORKEY", true);
-   if(atom != None) XvSetPortAttribute(xv->display, xv->port, atom, 1);
+   if (atom != None) XvSetPortAttribute(xv->display, xv->port, atom, 1);
 
-   int format_count;
-   XvImageFormatValues *format = XvListImageFormats(xv->display, xv->port, &format_count);
-
-   bool has_format = false;
-   for (int i = 0; i < format_count; i++) 
-   {
-      if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
-      {
-         if (format[i].component_order[0] == 'Y' && format[i].component_order[1] == 'U'
-               && format[i].component_order[2] == 'Y' && format[i].component_order[3] == 'V') 
-         {
-            has_format = true;
-            xv->fourcc = format[i].id;
-            xv->render_func = video->rgb32 ? render32_yuy2 : render16_yuy2;
-            xv->luma_i = 0; xv->chroma_i = 1;
-            break;
-         }
-      }
-   }
-
-   if (!has_format) for (int i = 0; i < format_count; i++) 
-   {
-      if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
-      {
-         if (format[i].component_order[0] == 'U' && format[i].component_order[1] == 'Y'
-               && format[i].component_order[2] == 'V' && format[i].component_order[3] == 'Y') 
-         {
-            has_format = true;
-            xv->fourcc = format[i].id;
-            xv->render_func = video->rgb32 ? render32_uyvy : render16_uyvy;
-            xv->chroma_i = 0; xv->luma_i = 1;
-            break;
-         }
-      }
-   }
-
-
-   free(format);
-   if (!has_format) 
-   {
-      SSNES_ERR("XVideo: unable to find a supported image format.\n");
-      goto error;
-   }
-
-   xv->width = 512;
-   xv->height = 512;
+   xv->width = g_extern.system.geom.max_width;
+   xv->height = g_extern.system.geom.max_height;
 
    xv->image = XvShmCreateImage(xv->display, xv->port, xv->fourcc, NULL, xv->width, xv->height, &xv->shminfo);
    if (!xv->image) 
@@ -466,8 +525,6 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
    xv_set_nonblock_state(xv, !video->vsync);
    xv->focus = true;
 
-   xv_init_font(xv, g_settings.video.font_path, g_settings.video.font_size);
-
    void *xinput = input_x.init();
    if (xinput)
    {
@@ -478,6 +535,8 @@ static void* xv_init(video_info_t *video, const input_driver_t **input, void **i
       *input = NULL;
 
    init_yuv_tables(xv);
+   xv_init_font(xv, g_settings.video.font_path, g_settings.video.font_size);
+
    return xv;
 
 error:
@@ -561,6 +620,7 @@ static void calc_out_rect(bool keep_aspect, unsigned *x, unsigned *y, unsigned *
 }
 
 // TODO: Is there some way to render directly like GL? :(
+// Hacky C code is hacky :D Yay.
 static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned height)
 {
 #ifdef HAVE_FREETYPE
@@ -574,12 +634,17 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
    int _base_x = g_settings.video.msg_pos_x * width;
    int _base_y = height - g_settings.video.msg_pos_y * height;
 
-   unsigned luma_i = xv->luma_i;
-   unsigned chroma_i = xv->chroma_i;
+   unsigned luma_index[2] = { xv->luma_index[0], xv->luma_index[1] };
+   unsigned chroma_u_index = xv->chroma_u_index;
+   unsigned chroma_v_index = xv->chroma_v_index;
+
+   unsigned pitch = width << 1; // YUV formats used are 16 bpp.
 
    while (head)
    {
-      int base_x = _base_x + head->off_x;
+      int base_x = (_base_x + head->off_x) << 1;
+      base_x &= ~3; // Make sure we always start on the correct boundary so the indices are correct.
+
       int base_y = _base_y - head->off_y;
       if (base_y >= 0)
       {
@@ -588,21 +653,33 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
             if (base_x < 0)
                continue;
 
-            const uint8_t *a = head->output + head->pitch * y;
-            uint8_t *out = (uint8_t*)xv->image->data + (base_y - head->height + y) * (width << 1) + (base_x << 1);
+            const uint8_t * restrict a = head->output + head->pitch * y;
+            uint8_t * restrict out = (uint8_t*)xv->image->data + (base_y - head->height + y) * pitch + base_x;
 
-            for (int x = 0; x < (head->width << 1) && (base_x + x) < width; x += 2)
+            for (int x = 0; x < (head->width << 1) && (base_x + x) < pitch; x += 4)
             {
-               // Blend luma
-               uint8_t blend = a[x >> 1];
-               unsigned blended = blend + (((256 - blend) * (unsigned)out[x + luma_i]) >> 8);
-               blended = blended > 255 ? 255 : blended;
-               out[x + luma_i] = blended;
+               unsigned alpha[2];
+               alpha[0] = a[(x >> 1) + 0];
 
-               // Blend chroma
-               blended = (128 * blend + ((256 - blend) * (unsigned)out[x + chroma_i])) >> 8;
-               blended = blended > 255 ? 255 : blended;
-               out[x + chroma_i] = blended;
+               if (((x >> 1) + 1) == head->width) // We reached the end, uhoh! Branching like a BOSS! :D
+                  alpha[1] = 0;
+               else
+                  alpha[1] = a[(x >> 1) + 1];
+
+               unsigned alpha_sub = (alpha[0] + alpha[1]) >> 1; // Blended alpha for the sub-samples U/V channels.
+
+               for (unsigned i = 0; i < 2; i++)
+               {
+                  unsigned blended = (xv->font_y * alpha[i] + ((256 - alpha[i]) * out[x + luma_index[i]])) >> 8;
+                  out[x + luma_index[i]] = blended;
+               }
+
+               // Blend chroma channels
+               unsigned blended = (xv->font_u * alpha_sub + ((256 - alpha_sub) * out[x + chroma_u_index])) >> 8;
+               out[x + chroma_u_index] = blended;
+
+               blended = (xv->font_v * alpha_sub + ((256 - alpha_sub) * out[x + chroma_v_index])) >> 8;
+               out[x + chroma_v_index] = blended;
             }
          }
       }
@@ -619,7 +696,7 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
 #endif
 }
 
-static bool xv_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+static bool xv_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
 {
    xv_t *xv = data;
 
@@ -630,11 +707,12 @@ static bool xv_frame(void *data, const void* frame, unsigned width, unsigned hei
    XGetWindowAttributes(xv->display, xv->window, &target);
    xv->render_func(xv, frame, width, height, pitch);
 
-   if (msg)
-      xv_render_msg(xv, msg, xv->width, xv->height);
-
    unsigned x, y, owidth, oheight;
    calc_out_rect(xv->keep_aspect, &x, &y, &owidth, &oheight, target.width, target.height);
+
+   if (msg)
+      xv_render_msg(xv, msg, width << 1, height << 1);
+
    XvShmPutImage(xv->display, xv->port, xv->window, xv->gc, xv->image,
          0, 0, width << 1, height << 1,
          x, y, owidth, oheight,
@@ -693,9 +771,9 @@ static void xv_free(void *data)
    shmctl(xv->shminfo.shmid, IPC_RMID, NULL);
    XFree(xv->image);
 
-   if(xv->window) 
+   if (xv->window) 
       XUnmapWindow(xv->display, xv->window);
-   if(xv->colormap) 
+   if (xv->colormap) 
       XFreeColormap(xv->display, xv->colormap);
 
    XCloseDisplay(xv->display);

input/dinput.c

@@ -0,0 +1,257 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ssnes_dinput.h"
+#include "SDL.h"
+#include "SDL_syswm.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include "../gfx/sdlwrap.h"
+
+void sdl_dinput_free(sdl_dinput_t *di)
+{
+   if (di)
+   {
+      for (unsigned i = 0; i < MAX_PLAYERS; i++)
+      {
+         if (di->joypad[i])
+         {
+            IDirectInputDevice8_Unacquire(di->joypad[i]);
+            IDirectInputDevice8_Release(di->joypad[i]);
+         }
+      }
+
+      if (di->ctx)
+         IDirectInput8_Release(di->ctx);
+
+      free(di);
+   }
+}
+
+static BOOL CALLBACK enum_axes_cb(const DIDEVICEOBJECTINSTANCE *inst, void *p)
+{
+   LPDIRECTINPUTDEVICE8 joypad = p;
+
+   DIPROPRANGE range;
+   memset(&range, 0, sizeof(range));
+   range.diph.dwSize = sizeof(DIPROPRANGE);
+   range.diph.dwHeaderSize = sizeof(DIPROPHEADER);
+   range.diph.dwHow = DIPH_BYID;
+   range.diph.dwObj = inst->dwType;
+   range.lMin = -32768;
+   range.lMax = 32767;
+   IDirectInputDevice8_SetProperty(joypad, DIPROP_RANGE, &range.diph);
+
+   return DIENUM_CONTINUE;
+}
+
+static BOOL CALLBACK enum_joypad_cb(const DIDEVICEINSTANCE *inst, void *p)
+{
+   sdl_dinput_t *di = p;
+
+   unsigned active = 0;
+   unsigned n;
+   for (n = 0; n < MAX_PLAYERS; n++)
+   {
+      if (!di->joypad[n] && g_settings.input.joypad_map[n] == di->joypad_cnt)
+         break;
+
+      if (di->joypad[n])
+         active++;
+   }
+
+   if (active == MAX_PLAYERS) return DIENUM_STOP;
+
+   di->joypad_cnt++;
+   if (n == MAX_PLAYERS)
+      return DIENUM_CONTINUE;
+
+   if (FAILED(IDirectInput8_CreateDevice(di->ctx, &inst->guidInstance, &di->joypad[n], NULL)))
+      return DIENUM_CONTINUE;
+
+   IDirectInputDevice8_SetDataFormat(di->joypad[n], &c_dfDIJoystick2);
+   IDirectInputDevice8_SetCooperativeLevel(di->joypad[n], di->hWnd,
+         DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
+
+   IDirectInputDevice8_EnumObjects(di->joypad[n], enum_axes_cb, 
+         di->joypad[n], DIDFT_ABSAXIS);
+
+   return DIENUM_CONTINUE; 
+}
+
+sdl_dinput_t* sdl_dinput_init(void)
+{
+   sdl_dinput_t *di = calloc(1, sizeof(*di));
+   if (!di)
+      return NULL;
+
+   CoInitialize(NULL);
+
+   SDL_SysWMinfo info;
+   SDL_VERSION(&info.version);
+
+   if (!sdlwrap_get_wm_info(&info))
+   {
+      SSNES_ERR("Failed to get SysWM info.\n");
+      goto error;
+   }
+
+#if SDL_MODERN
+   di->hWnd = info.info.win.window;
+#else
+   di->hWnd = info.window;
+#endif
+
+   if (FAILED(DirectInput8Create(
+      GetModuleHandle(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8,
+      (void**)&di->ctx, NULL)))
+   {
+      SSNES_ERR("Failed to init DirectInput.\n");
+      goto error;
+   }
+
+   SSNES_LOG("Enumerating DInput devices ...\n");
+   IDirectInput8_EnumDevices(di->ctx, DI8DEVCLASS_GAMECTRL, enum_joypad_cb, di, DIEDFL_ATTACHEDONLY);
+   SSNES_LOG("Done enumerating DInput devices ...\n");
+
+   return di;
+
+error:
+   sdl_dinput_free(di);
+   return NULL;
+}
+
+static bool dinput_joykey_pressed(sdl_dinput_t *di, unsigned port_num, uint16_t joykey)
+{
+   if (joykey == NO_BTN)
+      return false;
+
+   // Check hat.
+   if (GET_HAT_DIR(joykey))
+   {
+      unsigned hat = GET_HAT(joykey);
+      
+      unsigned elems = sizeof(di->joy_state[0].rgdwPOV) / sizeof(di->joy_state[0].rgdwPOV[0]);
+      if (hat >= elems)
+         return false;
+
+      unsigned pov = di->joy_state[port_num].rgdwPOV[hat];
+
+      // Magic numbers I'm not sure where originate from.
+      if (pov < 36000)
+      {
+         switch (GET_HAT_DIR(joykey))
+         {
+            case HAT_UP_MASK:
+               return (pov >= 31500) || (pov <= 4500);
+            case HAT_RIGHT_MASK:
+               return (pov >= 4500) && (pov <= 13500);
+            case HAT_DOWN_MASK:
+               return (pov >= 13500) && (pov <= 22500);
+            case HAT_LEFT_MASK:
+               return (pov >= 22500) && (pov <= 31500);
+         }
+      }
+
+      return false;
+   }
+   else
+   {
+      unsigned elems = sizeof(di->joy_state[0].rgbButtons) / sizeof(di->joy_state[0].rgbButtons[0]);
+
+      if (joykey < elems)
+         return di->joy_state[port_num].rgbButtons[joykey];
+   }
+
+   return false;
+}
+
+static bool dinput_joyaxis_pressed(sdl_dinput_t *di, unsigned port_num, uint32_t joyaxis)
+{
+   if (joyaxis == AXIS_NONE)
+      return false;
+
+   int min = -32678 * g_settings.input.axis_threshold;
+   int max = 32677 * g_settings.input.axis_threshold;
+
+   switch (AXIS_NEG_GET(joyaxis))
+   {
+      case 0:
+         return di->joy_state[port_num].lX <= min;
+      case 1:
+         return di->joy_state[port_num].lY <= min;
+      case 2:
+         return di->joy_state[port_num].lZ <= min;
+      case 3:
+         return di->joy_state[port_num].lRx <= min;
+      case 4:
+         return di->joy_state[port_num].lRy <= min;
+      case 5:
+         return di->joy_state[port_num].lRz <= min;
+   }
+
+   switch (AXIS_POS_GET(joyaxis))
+   {
+      case 0:
+         return di->joy_state[port_num].lX >= max;
+      case 1:
+         return di->joy_state[port_num].lY >= max;
+      case 2:
+         return di->joy_state[port_num].lZ >= max;
+      case 3:
+         return di->joy_state[port_num].lRx >= max;
+      case 4:
+         return di->joy_state[port_num].lRy >= max;
+      case 5:
+         return di->joy_state[port_num].lRz >= max;
+   }
+
+   return false;
+}
+
+bool sdl_dinput_pressed(sdl_dinput_t *di, unsigned port_num, const struct snes_keybind *key)
+{
+   if (di->joypad[port_num] == NULL)
+      return false;
+   if (dinput_joykey_pressed(di, port_num, key->joykey))
+      return true;
+   if (dinput_joyaxis_pressed(di, port_num, key->joyaxis))
+      return true;
+
+   return false;
+}
+
+void sdl_dinput_poll(sdl_dinput_t *di)
+{
+   memset(di->joy_state, 0, sizeof(di->joy_state));
+   for (unsigned i = 0; i < MAX_PLAYERS; i++)
+   {
+      if (di->joypad[i])
+      {
+         if (FAILED(IDirectInputDevice8_Poll(di->joypad[i])))
+         {
+            IDirectInputDevice8_Acquire(di->joypad[i]);
+            continue;
+         }
+
+         IDirectInputDevice8_GetDeviceState(di->joypad[i], sizeof(DIJOYSTATE2), &di->joy_state[i]);
+      }
+   }
+}
+

input/keysym.h

@@ -0,0 +1,173 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_KEYSYM_H
+#define __SSNES_KEYSYM_H
+
+// Global keysym table for SSNES.
+// As you may have noticed, it's the same as SDL 1.2 since I'm lazy.
+
+enum ssnes_key
+{
+   SK_UNKNOWN        = 0,
+   SK_FIRST          = 0,
+   SK_BACKSPACE      = 8,
+   SK_TAB            = 9,
+   SK_CLEAR          = 12,
+   SK_RETURN         = 13,
+   SK_PAUSE          = 19,
+   SK_ESCAPE         = 27,
+   SK_SPACE          = 32,
+   SK_EXCLAIM        = 33,
+   SK_QUOTEDBL       = 34,
+   SK_HASH           = 35,
+   SK_DOLLAR         = 36,
+   SK_AMPERSAND      = 38,
+   SK_QUOTE          = 39,
+   SK_LEFTPAREN      = 40,
+   SK_RIGHTPAREN     = 41,
+   SK_ASTERISK       = 42,
+   SK_PLUS           = 43,
+   SK_COMMA          = 44,
+   SK_MINUS          = 45,
+   SK_PERIOD         = 46,
+   SK_SLASH          = 47,
+   SK_0              = 48,
+   SK_1              = 49,
+   SK_2              = 50,
+   SK_3              = 51,
+   SK_4              = 52,
+   SK_5              = 53,
+   SK_6              = 54,
+   SK_7              = 55,
+   SK_8              = 56,
+   SK_9              = 57,
+   SK_COLON          = 58,
+   SK_SEMICOLON      = 59,
+   SK_LESS           = 60,
+   SK_EQUALS         = 61,
+   SK_GREATER        = 62,
+   SK_QUESTION       = 63,
+   SK_AT             = 64,
+   SK_LEFTBRACKET    = 91,
+   SK_BACKSLASH      = 92,
+   SK_RIGHTBRACKET   = 93,
+   SK_CARET          = 94,
+   SK_UNDERSCORE     = 95,
+   SK_BACKQUOTE      = 96,
+   SK_a              = 97,
+   SK_b              = 98,
+   SK_c              = 99,
+   SK_d              = 100,
+   SK_e              = 101,
+   SK_f              = 102,
+   SK_g              = 103,
+   SK_h              = 104,
+   SK_i              = 105,
+   SK_j              = 106,
+   SK_k              = 107,
+   SK_l              = 108,
+   SK_m              = 109,
+   SK_n              = 110,
+   SK_o              = 111,
+   SK_p              = 112,
+   SK_q              = 113,
+   SK_r              = 114,
+   SK_s              = 115,
+   SK_t              = 116,
+   SK_u              = 117,
+   SK_v              = 118,
+   SK_w              = 119,
+   SK_x              = 120,
+   SK_y              = 121,
+   SK_z              = 122,
+   SK_DELETE         = 127,
+
+   SK_KP0            = 256,
+   SK_KP1            = 257,
+   SK_KP2            = 258,
+   SK_KP3            = 259,
+   SK_KP4            = 260,
+   SK_KP5            = 261,
+   SK_KP6            = 262,
+   SK_KP7            = 263,
+   SK_KP8            = 264,
+   SK_KP9            = 265,
+   SK_KP_PERIOD      = 266,
+   SK_KP_DIVIDE      = 267,
+   SK_KP_MULTIPLY    = 268,
+   SK_KP_MINUS       = 269,
+   SK_KP_PLUS        = 270,
+   SK_KP_ENTER       = 271,
+   SK_KP_EQUALS      = 272,
+
+   SK_UP             = 273,
+   SK_DOWN           = 274,
+   SK_RIGHT          = 275,
+   SK_LEFT           = 276,
+   SK_INSERT         = 277,
+   SK_HOME           = 278,
+   SK_END            = 279,
+   SK_PAGEUP         = 280,
+   SK_PAGEDOWN       = 281,
+
+   SK_F1             = 282,
+   SK_F2             = 283,
+   SK_F3             = 284,
+   SK_F4             = 285,
+   SK_F5             = 286,
+   SK_F6             = 287,
+   SK_F7             = 288,
+   SK_F8             = 289,
+   SK_F9             = 290,
+   SK_F10            = 291,
+   SK_F11            = 292,
+   SK_F12            = 293,
+   SK_F13            = 294,
+   SK_F14            = 295,
+   SK_F15            = 296,
+
+   SK_NUMLOCK        = 300,
+   SK_CAPSLOCK       = 301,
+   SK_SCROLLOCK      = 302,
+   SK_RSHIFT         = 303,
+   SK_LSHIFT         = 304,
+   SK_RCTRL          = 305,
+   SK_LCTRL          = 306,
+   SK_RALT           = 307,
+   SK_LALT           = 308,
+   SK_RMETA          = 309,
+   SK_LMETA          = 310,
+   SK_LSUPER         = 311,
+   SK_RSUPER         = 312,
+   SK_MODE           = 313,
+   SK_COMPOSE        = 314,
+
+   SK_HELP           = 315,
+   SK_PRINT          = 316,
+   SK_SYSREQ         = 317,
+   SK_BREAK          = 318,
+   SK_MENU           = 319,
+   SK_POWER          = 320,
+   SK_EURO           = 321,
+   SK_UNDO           = 322,
+
+   SK_LAST
+};
+
+#endif
+

input/sdl.c

@@ -17,20 +17,128 @@
 
 #include "driver.h"
 
-#include "SDL.h"
+#include "../gfx/sdlwrap.h"
 #include <stdbool.h>
 #include "general.h"
 #include <stdint.h>
 #include <stdlib.h>
-#include <libsnes.hpp>
+#include "../libsnes.hpp"
 #include "ssnes_sdl_input.h"
+#include "keysym.h"
 
-static void* sdl_input_init(void)
+struct key_bind
 {
+   unsigned sdl;
+   enum ssnes_key sk;
+};
+
+static unsigned keysym_lut[SK_LAST];
+static const struct key_bind lut_binds[] = {
+   { SDLK_LEFT, SK_LEFT },
+   { SDLK_RIGHT, SK_RIGHT },
+   { SDLK_UP, SK_UP },
+   { SDLK_DOWN, SK_DOWN },
+   { SDLK_RETURN, SK_RETURN },
+   { SDLK_TAB, SK_TAB },
+   { SDLK_INSERT, SK_INSERT },
+   { SDLK_DELETE, SK_DELETE },
+   { SDLK_RSHIFT, SK_RSHIFT },
+   { SDLK_LSHIFT, SK_LSHIFT },
+   { SDLK_LCTRL, SK_LCTRL },
+   { SDLK_LALT, SK_LALT },
+   { SDLK_SPACE, SK_SPACE },
+   { SDLK_ESCAPE, SK_ESCAPE },
+   { SDLK_BACKSPACE, SK_BACKSPACE },
+   { SDLK_KP_ENTER, SK_KP_ENTER },
+   { SDLK_KP_PLUS, SK_KP_PLUS },
+   { SDLK_KP_MINUS, SK_KP_MINUS },
+   { SDLK_KP_MULTIPLY, SK_KP_MULTIPLY },
+   { SDLK_KP_DIVIDE, SK_KP_DIVIDE },
+   { SDLK_BACKQUOTE, SK_BACKQUOTE },
+   { SDLK_PAUSE, SK_PAUSE },
+   { SDLK_KP0, SK_KP0 },
+   { SDLK_KP1, SK_KP1 },
+   { SDLK_KP2, SK_KP2 },
+   { SDLK_KP3, SK_KP3 },
+   { SDLK_KP4, SK_KP4 },
+   { SDLK_KP5, SK_KP5 },
+   { SDLK_KP6, SK_KP6 },
+   { SDLK_KP7, SK_KP7 },
+   { SDLK_KP8, SK_KP8 },
+   { SDLK_KP9, SK_KP9 },
+   { SDLK_0, SK_0 },
+   { SDLK_1, SK_1 },
+   { SDLK_2, SK_2 },
+   { SDLK_3, SK_3 },
+   { SDLK_4, SK_4 },
+   { SDLK_5, SK_5 },
+   { SDLK_6, SK_6 },
+   { SDLK_7, SK_7 },
+   { SDLK_8, SK_8 },
+   { SDLK_9, SK_9 },
+   { SDLK_F1, SK_F1 },
+   { SDLK_F2, SK_F2 },
+   { SDLK_F3, SK_F3 },
+   { SDLK_F4, SK_F4 },
+   { SDLK_F5, SK_F5 },
+   { SDLK_F6, SK_F6 },
+   { SDLK_F7, SK_F7 },
+   { SDLK_F8, SK_F8 },
+   { SDLK_F9, SK_F9 },
+   { SDLK_F10, SK_F10 },
+   { SDLK_F11, SK_F11 },
+   { SDLK_F12, SK_F12 },
+   { SDLK_a, SK_a },
+   { SDLK_b, SK_b },
+   { SDLK_c, SK_c },
+   { SDLK_d, SK_d },
+   { SDLK_e, SK_e },
+   { SDLK_f, SK_f },
+   { SDLK_g, SK_g },
+   { SDLK_h, SK_h },
+   { SDLK_i, SK_i },
+   { SDLK_j, SK_j },
+   { SDLK_k, SK_k },
+   { SDLK_l, SK_l },
+   { SDLK_m, SK_m },
+   { SDLK_n, SK_n },
+   { SDLK_o, SK_o },
+   { SDLK_p, SK_p },
+   { SDLK_q, SK_q },
+   { SDLK_r, SK_r },
+   { SDLK_s, SK_s },
+   { SDLK_t, SK_t },
+   { SDLK_u, SK_u },
+   { SDLK_v, SK_v },
+   { SDLK_w, SK_w },
+   { SDLK_x, SK_x },
+   { SDLK_y, SK_y },
+   { SDLK_z, SK_z },
+};
+
+static void init_lut(void)
+{
+   memset(keysym_lut, 0, sizeof(keysym_lut));
+   for (unsigned i = 0; i < sizeof(lut_binds) / sizeof(lut_binds[0]); i++)
+      keysym_lut[lut_binds[i].sk] = lut_binds[i].sdl;
+}
+
+static void *sdl_input_init(void)
+{
+   init_lut();
    sdl_input_t *sdl = calloc(1, sizeof(*sdl));
    if (!sdl)
       return NULL;
 
+#ifdef HAVE_DINPUT
+   sdl->di = sdl_dinput_init();
+   if (!sdl->di)
+   {
+      free(sdl);
+      SSNES_ERR("Failed to init SDL/DInput.\n");
+      return NULL;
+   }
+#else
    if (SDL_Init(SDL_INIT_JOYSTICK) < 0)
       return NULL;
 
@@ -60,26 +168,23 @@ static void* sdl_input_init(void)
          sdl->num_hats[i] = SDL_JoystickNumHats(sdl->joysticks[i]);
       }
    }
+#endif
 
    sdl->use_keyboard = true;
-
    return sdl;
 }
 
-
 static bool sdl_key_pressed(int key)
 {
-   int num_keys;
-   Uint8 *keymap = SDL_GetKeyState(&num_keys);
-
-   if (key >= num_keys)
-      return false;
-
-   return keymap[key];
+   return sdlwrap_key_pressed(keysym_lut[key]);
 }
 
+#ifndef HAVE_DINPUT
 static bool sdl_joykey_pressed(sdl_input_t *sdl, int port_num, uint16_t joykey)
 {
+   if (joykey == NO_BTN)
+      return false;
+
    // Check hat.
    if (GET_HAT_DIR(joykey))
    {
@@ -120,37 +225,43 @@ static bool sdl_joykey_pressed(sdl_input_t *sdl, int port_num, uint16_t joykey)
 
 static bool sdl_axis_pressed(sdl_input_t *sdl, int port_num, uint32_t joyaxis)
 {
-   if (joyaxis != AXIS_NONE)
+   if (joyaxis == AXIS_NONE)
+      return false;
+
+   if (AXIS_NEG_GET(joyaxis) < sdl->num_axes[port_num])
    {
-      if (AXIS_NEG_GET(joyaxis) < sdl->num_axes[port_num])
-      {
-         Sint16 val = SDL_JoystickGetAxis(sdl->joysticks[port_num], AXIS_NEG_GET(joyaxis));
-         float scaled = (float)val / 0x8000;
-         if (scaled < -g_settings.input.axis_threshold)
-            return true;
-      }
-      if (AXIS_POS_GET(joyaxis) < sdl->num_axes[port_num])
-      {
-         Sint16 val = SDL_JoystickGetAxis(sdl->joysticks[port_num], AXIS_POS_GET(joyaxis));
-         float scaled = (float)val / 0x8000;
-         if (scaled > g_settings.input.axis_threshold)
-            return true;
-      }
+      Sint16 val = SDL_JoystickGetAxis(sdl->joysticks[port_num], AXIS_NEG_GET(joyaxis));
+      float scaled = (float)val / 0x8000;
+      if (scaled < -g_settings.input.axis_threshold)
+         return true;
+   }
+   if (AXIS_POS_GET(joyaxis) < sdl->num_axes[port_num])
+   {
+      Sint16 val = SDL_JoystickGetAxis(sdl->joysticks[port_num], AXIS_POS_GET(joyaxis));
+      float scaled = (float)val / 0x8000;
+      if (scaled > g_settings.input.axis_threshold)
+         return true;
    }
 
    return false;
 }
+#endif
 
-static bool sdl_is_pressed(sdl_input_t *sdl, int port_num, const struct snes_keybind *key)
+static bool sdl_is_pressed(sdl_input_t *sdl, unsigned port_num, const struct snes_keybind *key)
 {
    if (sdl->use_keyboard && sdl_key_pressed(key->key))
       return true;
+
+#ifdef HAVE_DINPUT
+   return sdl_dinput_pressed(sdl->di, port_num, key);
+#else
    if (sdl->joysticks[port_num] == NULL)
       return false;
    if (sdl_joykey_pressed(sdl, port_num, key->joykey))
       return true;
    if (sdl_axis_pressed(sdl, port_num, key->joyaxis))
       return true;
+#endif
 
    return false;
 }
@@ -159,7 +270,7 @@ static bool sdl_bind_button_pressed(void *data, int key)
 {
    // Only let player 1 use special binds called from main loop.
    const struct snes_keybind *binds = g_settings.input.binds[0];
-   for (int i = 0; binds[i].id != -1; i++)
+   for (unsigned i = 0; binds[i].id != -1; i++)
    {
       if (binds[i].id == key)
          return sdl_is_pressed(data, 0, &binds[i]);
@@ -168,23 +279,21 @@ static bool sdl_bind_button_pressed(void *data, int key)
 }
 
 static int16_t sdl_joypad_device_state(sdl_input_t *sdl, const struct snes_keybind **binds, 
-      int port_num, unsigned device, unsigned index, unsigned id)
+      unsigned port_num, int id)
 {
    const struct snes_keybind *snes_keybinds = binds[port_num];
 
-   for (int i = 0; snes_keybinds[i].id != -1; i++)
+   for (unsigned i = 0; snes_keybinds[i].id != -1; i++)
    {
-      if (snes_keybinds[i].id == (int)id)
-         return sdl_is_pressed(sdl, port_num, &snes_keybinds[i]);
+      if (snes_keybinds[i].id == id)
+         return sdl_is_pressed(sdl, port_num, &snes_keybinds[i]) ? 1 : 0;
    }
 
-   return false;
+   return 0;
 }
 
-static int16_t sdl_mouse_device_state(sdl_input_t *sdl, bool port, unsigned id)
+static int16_t sdl_mouse_device_state(sdl_input_t *sdl, unsigned id)
 {
-   // Might implement support for joypad mapping later.
-   (void)port;
    switch (id)
    {
       case SNES_DEVICE_ID_MOUSE_LEFT:
@@ -248,11 +357,11 @@ static int16_t sdl_input_state(void *data, const struct snes_keybind **binds, bo
    switch (device)
    {
       case SNES_DEVICE_JOYPAD:
-         return sdl_joypad_device_state(data, binds, (port == SNES_PORT_1) ? 0 : 1, device, index, id);
+         return sdl_joypad_device_state(data, binds, (port == SNES_PORT_1) ? 0 : 1, id);
       case SNES_DEVICE_MULTITAP:
-         return sdl_joypad_device_state(data, binds, (port == SNES_PORT_2) ? 1 + index : 0, device, index, id);
+         return sdl_joypad_device_state(data, binds, (port == SNES_PORT_2) ? 1 + index : 0, id);
       case SNES_DEVICE_MOUSE:
-         return sdl_mouse_device_state(data, port, id);
+         return sdl_mouse_device_state(data, id);
       case SNES_DEVICE_SUPER_SCOPE:
          return sdl_scope_device_state(data, id);
       case SNES_DEVICE_JUSTIFIER:
@@ -273,14 +382,19 @@ static void sdl_input_free(void *data)
       while (SDL_PollEvent(&event));
 
       sdl_input_t *sdl = data;
+
+#ifdef HAVE_DINPUT
+      sdl_dinput_free(sdl->di);
+#else
       for (int i = 0; i < MAX_PLAYERS; i++)
       {
          if (sdl->joysticks[i])
             SDL_JoystickClose(sdl->joysticks[i]);
       }
+      SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
+#endif
 
       free(data);
-      SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
    }
 }
 
@@ -298,37 +412,15 @@ static void sdl_poll_mouse(sdl_input_t *sdl)
 static void sdl_input_poll(void *data)
 {
    SDL_PumpEvents();
-   SDL_Event event;
-   SDL_JoystickUpdate();
-   sdl_poll_mouse(data);
-
    sdl_input_t *sdl = data;
-   // Search for events...
-   while (SDL_PollEvent(&event))
-   {
-      switch (event.type)
-      {
-         case SDL_QUIT:
-            if (sdl->quitting)
-            {
-               *sdl->quitting = true;
-               return;
-            }
-            break;
 
-         case SDL_VIDEORESIZE:
-            if (sdl->should_resize)
-            {
-               *sdl->new_width = event.resize.w;
-               *sdl->new_height = event.resize.h;
-               *sdl->should_resize = true;
-            }
-            break;
+#ifdef HAVE_DINPUT
+   sdl_dinput_poll(sdl->di);
+#else
+   SDL_JoystickUpdate();
+#endif
 
-         default:
-            break;
-      }
-   }
+   sdl_poll_mouse(sdl);
 }
 
 const input_driver_t input_sdl = {

input/ssnes_dinput.h

@@ -0,0 +1,48 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SSNES_DINPUT_H
+#define __SSNES_DINPUT_H
+
+#undef DIRECTINPUT_VERSION
+#define DIRECTINPUT_VERSION 0x0800
+
+#include <dinput.h>
+#include <stdbool.h>
+#include "general.h"
+
+// Piggyback joypad driver for SDL.
+
+typedef struct sdl_dinput
+{
+   HWND hWnd;
+   LPDIRECTINPUT8 ctx;
+   LPDIRECTINPUTDEVICE8 joypad[MAX_PLAYERS];
+   unsigned joypad_cnt;
+   DIJOYSTATE2 joy_state[MAX_PLAYERS];
+} sdl_dinput_t;
+
+sdl_dinput_t *sdl_dinput_init(void);
+void sdl_dinput_free(sdl_dinput_t *di);
+
+bool sdl_dinput_pressed(sdl_dinput_t *di, unsigned port_num, 
+      const struct snes_keybind *key);
+
+void sdl_dinput_poll(sdl_dinput_t *di);
+
+
+#endif

input/ssnes_sdl_input.h

@@ -20,20 +20,25 @@
 
 #include "SDL.h"
 #include "general.h"
+
+#ifdef HAVE_DINPUT
+#include "ssnes_dinput.h"
+#endif
+
 typedef struct sdl_input
 {
+#ifdef HAVE_DINPUT
+   sdl_dinput_t *di;
+#else
    SDL_Joystick *joysticks[MAX_PLAYERS];
    unsigned num_axes[MAX_PLAYERS];
    unsigned num_buttons[MAX_PLAYERS];
    unsigned num_hats[MAX_PLAYERS];
    unsigned num_joysticks;
+#endif
+
    bool use_keyboard;
 
-   // A video driver could pre-init with the SDL driver and have it handle resizing events...
-   bool *quitting;
-   bool *should_resize;
-   unsigned *new_width;
-   unsigned *new_height;
    int16_t mouse_x, mouse_y;
    int16_t mouse_l, mouse_r, mouse_m;
 } sdl_input_t;

input/x11_input.c

@@ -23,6 +23,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include "ssnes_sdl_input.h"
+#include "keysym.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ -37,76 +38,102 @@ typedef struct x11_input
 
 struct key_bind
 {
-   int x;
-   int sdl;
+   unsigned x;
+   enum ssnes_key sk;
 };
 
-static int keysym_lut[SDLK_LAST];
+static unsigned keysym_lut[SK_LAST];
 static const struct key_bind lut_binds[] = {
-   { XK_Left, SDLK_LEFT },
-   { XK_Right, SDLK_RIGHT },
-   { XK_Up, SDLK_UP },
-   { XK_Down, SDLK_DOWN },
-   { XK_Return, SDLK_RETURN },
-   { XK_Tab, SDLK_TAB },
-   { XK_Insert, SDLK_INSERT },
-   { XK_Delete, SDLK_DELETE },
-   { XK_Shift_R, SDLK_RSHIFT },
-   { XK_Shift_L, SDLK_LSHIFT },
-   { XK_Control_L, SDLK_LCTRL },
-   { XK_Alt_L, SDLK_LALT },
-   { XK_space, SDLK_SPACE },
-   { XK_Escape, SDLK_ESCAPE },
-   { XK_KP_Add, SDLK_KP_PLUS },
-   { XK_KP_Subtract, SDLK_KP_MINUS },
-   { XK_F1, SDLK_F1 },
-   { XK_F2, SDLK_F2 },
-   { XK_F3, SDLK_F3 },
-   { XK_F4, SDLK_F4 },
-   { XK_F5, SDLK_F5 },
-   { XK_F6, SDLK_F6 },
-   { XK_F7, SDLK_F7 },
-   { XK_F8, SDLK_F8 },
-   { XK_F9, SDLK_F9 },
-   { XK_F10, SDLK_F10 },
-   { XK_F11, SDLK_F11 },
-   { XK_F12, SDLK_F12 },
-   { XK_a, SDLK_a },
-   { XK_b, SDLK_b },
-   { XK_c, SDLK_c },
-   { XK_d, SDLK_d },
-   { XK_e, SDLK_e },
-   { XK_f, SDLK_f },
-   { XK_g, SDLK_g },
-   { XK_h, SDLK_h },
-   { XK_i, SDLK_i },
-   { XK_j, SDLK_j },
-   { XK_k, SDLK_k },
-   { XK_l, SDLK_l },
-   { XK_m, SDLK_m },
-   { XK_n, SDLK_n },
-   { XK_o, SDLK_o },
-   { XK_p, SDLK_p },
-   { XK_q, SDLK_q },
-   { XK_r, SDLK_r },
-   { XK_s, SDLK_s },
-   { XK_t, SDLK_t },
-   { XK_u, SDLK_u },
-   { XK_v, SDLK_v },
-   { XK_w, SDLK_w },
-   { XK_x, SDLK_x },
-   { XK_y, SDLK_y },
-   { XK_z, SDLK_z },
+   { XK_Left, SK_LEFT },
+   { XK_Right, SK_RIGHT },
+   { XK_Up, SK_UP },
+   { XK_Down, SK_DOWN },
+   { XK_Return, SK_RETURN },
+   { XK_Tab, SK_TAB },
+   { XK_Insert, SK_INSERT },
+   { XK_Delete, SK_DELETE },
+   { XK_Shift_R, SK_RSHIFT },
+   { XK_Shift_L, SK_LSHIFT },
+   { XK_Control_L, SK_LCTRL },
+   { XK_Alt_L, SK_LALT },
+   { XK_space, SK_SPACE },
+   { XK_Escape, SK_ESCAPE },
+   { XK_BackSpace, SK_BACKSPACE },
+   { XK_KP_Enter, SK_KP_ENTER },
+   { XK_KP_Add, SK_KP_PLUS },
+   { XK_KP_Subtract, SK_KP_MINUS },
+   { XK_KP_Multiply, SK_KP_MULTIPLY },
+   { XK_KP_Divide, SK_KP_DIVIDE },
+   { XK_grave, SK_BACKQUOTE },
+   { XK_Pause, SK_PAUSE },
+   { XK_KP_0, SK_KP0 },
+   { XK_KP_1, SK_KP1 },
+   { XK_KP_2, SK_KP2 },
+   { XK_KP_3, SK_KP3 },
+   { XK_KP_4, SK_KP4 },
+   { XK_KP_5, SK_KP5 },
+   { XK_KP_6, SK_KP6 },
+   { XK_KP_7, SK_KP7 },
+   { XK_KP_8, SK_KP8 },
+   { XK_KP_9, SK_KP9 },
+   { XK_0, SK_0 },
+   { XK_1, SK_1 },
+   { XK_2, SK_2 },
+   { XK_3, SK_3 },
+   { XK_4, SK_4 },
+   { XK_5, SK_5 },
+   { XK_6, SK_6 },
+   { XK_7, SK_7 },
+   { XK_8, SK_8 },
+   { XK_9, SK_9 },
+   { XK_F1, SK_F1 },
+   { XK_F2, SK_F2 },
+   { XK_F3, SK_F3 },
+   { XK_F4, SK_F4 },
+   { XK_F5, SK_F5 },
+   { XK_F6, SK_F6 },
+   { XK_F7, SK_F7 },
+   { XK_F8, SK_F8 },
+   { XK_F9, SK_F9 },
+   { XK_F10, SK_F10 },
+   { XK_F11, SK_F11 },
+   { XK_F12, SK_F12 },
+   { XK_a, SK_a },
+   { XK_b, SK_b },
+   { XK_c, SK_c },
+   { XK_d, SK_d },
+   { XK_e, SK_e },
+   { XK_f, SK_f },
+   { XK_g, SK_g },
+   { XK_h, SK_h },
+   { XK_i, SK_i },
+   { XK_j, SK_j },
+   { XK_k, SK_k },
+   { XK_l, SK_l },
+   { XK_m, SK_m },
+   { XK_n, SK_n },
+   { XK_o, SK_o },
+   { XK_p, SK_p },
+   { XK_q, SK_q },
+   { XK_r, SK_r },
+   { XK_s, SK_s },
+   { XK_t, SK_t },
+   { XK_u, SK_u },
+   { XK_v, SK_v },
+   { XK_w, SK_w },
+   { XK_x, SK_x },
+   { XK_y, SK_y },
+   { XK_z, SK_z },
 };
 
 static void init_lut(void)
 {
    memset(keysym_lut, 0, sizeof(keysym_lut));
    for (unsigned i = 0; i < sizeof(lut_binds) / sizeof(lut_binds[0]); i++)
-      keysym_lut[lut_binds[i].sdl] = lut_binds[i].x;
+      keysym_lut[lut_binds[i].sk] = lut_binds[i].x;
 }
 
-static void* x_input_init(void)
+static void *x_input_init(void)
 {
    x11_input_t *x11 = calloc(1, sizeof(*x11));
    if (!x11)

libsnes.hpp

@@ -66,6 +66,60 @@ extern "C" {
 #define SNES_MEMORY_OAM     103
 #define SNES_MEMORY_CGRAM   104
 
+// SSNES extension. Not required to be implemented for a working implementation.
+#define SNES_ENVIRONMENT_GET_FULLPATH 0         // const char ** --
+                                                // Full path of game loaded.
+                                                //
+#define SNES_ENVIRONMENT_SET_GEOMETRY 1         // const struct snes_geometry * --
+                                                // Window geometry information for the system/game.
+                                                //
+#define SNES_ENVIRONMENT_SET_PITCH 2            // const unsigned * --
+                                                // Pitch of game image.
+                                                //
+#define SNES_ENVIRONMENT_GET_OVERSCAN 3         // bool * --
+                                                // Boolean value whether or not the implementation should use overscan.
+                                                //
+#define SNES_ENVIRONMENT_SET_TIMING 4           // const struct snes_system_timing * --
+                                                // Set exact timings of the system. Used primarily for video recording.
+                                                //
+#define SNES_ENVIRONMENT_GET_CAN_DUPE 5         // bool * --
+                                                // Boolean value whether or not SSNES supports frame duping,
+                                                // passing NULL to video frame callback.
+                                                //
+                                                //
+#define SNES_ENVIRONMENT_SET_NEED_FULLPATH 6    // const bool * --
+                                                // Boolean value telling if implementation needs a valid fullpath to be able to run.
+                                                // If this is the case, SSNES will not open the rom directly,
+                                                // and pass NULL to rom data.
+                                                // Implementation must then use SNES_ENVIRONMENT_GET_FULLPATH.
+                                                // This is useful for implementations with very large roms,
+                                                // which are impractical to load fully into RAM.
+                                                //
+#define SNES_ENVIRONMENT_GET_CAN_REWIND 7       // bool * --
+                                                // Boolean value telling if SSNES is able to rewind.
+                                                // Some implementations might need to take extra precautions
+                                                // to allow this as smoothly as possible.
+
+struct snes_geometry
+{
+   unsigned base_width;    // Nominal video width of system.
+   unsigned base_height;   // Nominal video height of system.
+   unsigned max_width;     // Maximum possible width of system.
+   unsigned max_height;    // Maximum possible height of system.
+};
+
+struct snes_system_timing
+{
+   double fps;
+   double sample_rate;
+};
+
+typedef bool (*snes_environment_t)(unsigned cmd, void *data);
+
+// Must be called before calling snes_init().
+void snes_set_environment(snes_environment_t);
+////
+
 typedef void (*snes_video_refresh_t)(const uint16_t *data, unsigned width, unsigned height);
 typedef void (*snes_audio_sample_t)(uint16_t left, uint16_t right);
 typedef void (*snes_input_poll_t)(void);
@@ -74,6 +128,8 @@ typedef int16_t (*snes_input_state_t)(bool port, unsigned device, unsigned index
 unsigned snes_library_revision_major(void);
 unsigned snes_library_revision_minor(void);
 
+const char *snes_library_id(void);
+
 void snes_set_video_refresh(snes_video_refresh_t);
 void snes_set_audio_sample(snes_audio_sample_t);
 void snes_set_input_poll(snes_input_poll_t);

movie.c

@@ -78,7 +78,7 @@ uint32_t crc32_adjust(uint32_t crc32, uint8_t input)
 uint32_t crc32_calculate(const uint8_t *data, unsigned length)
 {
    uint32_t crc32 = ~0;
-   for(unsigned i = 0; i < length; i++)
+   for (unsigned i = 0; i < length; i++)
       crc32 = crc32_adjust(crc32, data[i]);
    return ~crc32;
 }
@@ -88,13 +88,12 @@ struct bsv_movie
    FILE *file;
    uint8_t *state;
 
-   long *frame_pos; // A ring buffer keeping track of many key presses were requested per frame.
+   size_t *frame_pos; // A ring buffer keeping track of positions in the file for each frame.
    size_t frame_mask;
-   uint16_t current_frame_count;
    size_t frame_ptr;
 
    bool playback;
-   unsigned min_file_pos;
+   size_t min_file_pos;
 
    bool first_rewind;
    bool did_rewind;
@@ -103,22 +102,10 @@ struct bsv_movie
 #define BSV_MAGIC 0x42535631
 
 #define MAGIC_INDEX 0
-#define SERIALIZER_INDEX 1
+#define SERIALIZER_INDEX 1 // Not current used.
 #define CRC_INDEX 2
 #define STATE_SIZE_INDEX 3
 
-static inline uint8_t is_little_endian(void)
-{
-   union
-   {
-      uint16_t u16;
-      uint8_t u8[2];
-   } u;
-
-   u.u16 = 1;
-   return u.u8[0];
-}
-
 // Convert to big-endian if needed
 static inline uint32_t swap_if_big32(uint32_t val)
 {
@@ -128,6 +115,14 @@ static inline uint32_t swap_if_big32(uint32_t val)
       return (val >> 24) | ((val >> 8) & 0xFF00) | ((val << 8) & 0xFF0000) | (val << 24);
 }
 
+static inline uint32_t swap_if_little32(uint32_t val)
+{
+   if (!is_little_endian()) // Big-endian
+      return val;
+   else
+      return (val >> 24) | ((val >> 8) & 0xFF00) | ((val << 8) & 0xFF0000) | (val << 24);
+}
+
 static inline uint16_t swap_if_big16(uint16_t val)
 {
    if (is_little_endian())
@@ -153,7 +148,8 @@ static bool init_playback(bsv_movie_t *handle, const char *path)
       return false;
    }
 
-   if (swap_if_big32(header[MAGIC_INDEX]) != BSV_MAGIC)
+   // Compatibility with old implementation that used incorrect documentation.
+   if (swap_if_little32(header[MAGIC_INDEX]) != BSV_MAGIC && swap_if_big32(header[MAGIC_INDEX]) != BSV_MAGIC)
    {
       SSNES_ERR("Movie file is not a valid BSV1 file!\n");
       return false;
@@ -166,25 +162,32 @@ static bool init_playback(bsv_movie_t *handle, const char *path)
    }
 
    uint32_t state_size = swap_if_big32(header[STATE_SIZE_INDEX]);
-   handle->state = malloc(state_size);
-   if (!handle->state)
-      return false;
+
+   // If we're playing back from the start, state_size is 0.
+   if (state_size)
+   {
+      handle->state = malloc(state_size);
+      if (!handle->state)
+         return false;
+
+      if (fread(handle->state, 1, state_size, handle->file) != state_size)
+      {
+         SSNES_ERR("Couldn't read state from movie.\n");
+         return false;
+      }
+
+      if (psnes_serialize_size() != state_size)
+      {
+         SSNES_ERR("Movie format seems to have a different serializer version. Cannot continue.\n");
+         exit(1);
+      }
+
+      // Unserialize to start playback.
+      psnes_unserialize(handle->state, state_size);
+   }
 
    handle->min_file_pos = sizeof(header) + state_size;
 
-   if (fread(handle->state, 1, state_size, handle->file) != state_size)
-   {
-      SSNES_ERR("Couldn't read state from movie.\n");
-      return false;
-   }
-
-   if (psnes_serialize_size() != state_size)
-   {
-      SSNES_ERR("Movie format seems to have a different serializer version. Cannot continue.\n");
-      exit(1);
-   }
-   // Unserialize to start playback.
-   psnes_unserialize(handle->state, state_size);
    return true;
 }
 
@@ -198,11 +201,14 @@ static bool init_record(bsv_movie_t *handle, const char *path)
    }
 
    uint32_t header[4] = {0};
-   header[MAGIC_INDEX] = swap_if_big32(BSV_MAGIC);
-   //header[SERIALIZER_INDEX] = 0; // TODO: Fix this.
+
+   // This value is supposed to show up as BSV1 in a HEX editor.
+   header[MAGIC_INDEX] = swap_if_little32(BSV_MAGIC);
+
    header[CRC_INDEX] = swap_if_big32(g_extern.cart_crc);
 
    uint32_t state_size = psnes_serialize_size();
+
    header[STATE_SIZE_INDEX] = swap_if_big32(state_size);
    fwrite(header, 4, sizeof(uint32_t), handle->file);
 
@@ -212,8 +218,12 @@ static bool init_record(bsv_movie_t *handle, const char *path)
 
    handle->min_file_pos = sizeof(header) + state_size;
 
-   psnes_serialize(handle->state, state_size);
-   fwrite(handle->state, 1, state_size, handle->file);
+   if (state_size > 0)
+   {
+      psnes_serialize(handle->state, state_size);
+      fwrite(handle->state, 1, state_size, handle->file);
+   }
+
    return true;
 }
 
@@ -257,8 +267,11 @@ bsv_movie_t *bsv_movie_init(const char *path, enum ssnes_movie_type type)
    else if (!init_record(handle, path))
       goto error;
 
-   if (!(handle->frame_pos = calloc((1 << 20), sizeof(long)))) // Just pick something really large :D
+   // Just pick something really large :D ~1 million frames rewind should do the trick.
+   if (!(handle->frame_pos = calloc((1 << 20), sizeof(size_t))))
       goto error; 
+
+   handle->frame_pos[0] = handle->min_file_pos;
    handle->frame_mask = (1 << 20) - 1;
 
    return handle;
@@ -270,14 +283,11 @@ error:
 
 void bsv_movie_set_frame_start(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Starting frame: %u, Pos: %ld\n", (unsigned)handle->frame_ptr, ftell(handle->file));
    handle->frame_pos[handle->frame_ptr] = ftell(handle->file);
-
 }
 
 void bsv_movie_set_frame_end(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Frame++\n");
    handle->frame_ptr = (handle->frame_ptr + 1) & handle->frame_mask;
 
    handle->first_rewind = !handle->did_rewind;
@@ -286,22 +296,27 @@ void bsv_movie_set_frame_end(bsv_movie_t *handle)
 
 void bsv_movie_frame_rewind(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Frame--\n");
-
    handle->did_rewind = true;
-   if (handle->frame_ptr <= 1)
+
+   // If we're at the beginning ... :)
+   if ((handle->frame_ptr <= 1) && (handle->frame_pos[0] == handle->min_file_pos))
    {
       handle->frame_ptr = 0;
       fseek(handle->file, handle->min_file_pos, SEEK_SET);
    }
    else
    {
+      // First time rewind is performed, the old frame is simply replayed.
+      // However, playing back that frame caused us to read data, and push data to the ring buffer.
+      // Sucessively rewinding frames, we need to rewind past the read data, plus another.
       handle->frame_ptr = (handle->frame_ptr - (handle->first_rewind ? 1 : 2)) & handle->frame_mask;
       fseek(handle->file, handle->frame_pos[handle->frame_ptr], SEEK_SET);
    }
 
+   // We rewound past the beginning. :O
    if (ftell(handle->file) <= (long)handle->min_file_pos)
    {
+      // If recording, we simply reset the starting point. Nice and easy.
       if (!handle->playback)
       {
          fseek(handle->file, 4 * sizeof(uint32_t), SEEK_SET);

netplay.c

@@ -15,25 +15,14 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "netplay.h"
-#include "general.h"
-#include "autosave.h"
-#include "dynamic.h"
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <assert.h>
-
 #ifdef _WIN32
+#ifndef _WIN32_WINNT
 #define _WIN32_WINNT 0x0501
+#endif
 #define WIN32_LEAN_AND_MEAN
-#include <windows.h>
 #include <winsock2.h>
+#include <windows.h>
 #include <ws2tcpip.h>
-// Woohoo, Winsock has headers from the STONE AGE! :D
-#define close(x) closesocket(x)
-#define CONST_CAST (const char*)
-#define NONCONST_CAST (char*)
 #else
 #include <sys/select.h>
 #include <sys/types.h>
@@ -43,11 +32,29 @@
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <signal.h>
+#endif
+
+#include "netplay.h"
+#include "general.h"
+#include "autosave.h"
+#include "dynamic.h"
+#include "message.h"
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <assert.h>
+
+
+#ifdef _WIN32
+// Woohoo, Winsock has headers from the STONE AGE! :D
+#define close(x) closesocket(x)
+#define CONST_CAST (const char*)
+#define NONCONST_CAST (char*)
+#else
 #define CONST_CAST
 #define NONCONST_CAST
 #endif
 
-
 #define PREV_PTR(x) ((x) == 0 ? handle->buffer_size - 1 : (x) - 1)
 #define NEXT_PTR(x) ((x + 1) % handle->buffer_size)
 
@@ -62,7 +69,7 @@ struct delta_frame
    bool used_real;
 };
 
-#define UDP_FRAME_PACKETS 8
+#define UDP_FRAME_PACKETS 16
 
 struct netplay
 {
@@ -88,18 +95,25 @@ struct netplay
    uint32_t packet_buffer[UDP_FRAME_PACKETS * 2]; // To compat UDP packet loss we also send old data along with the packets.
    uint32_t frame_count;
    uint32_t read_frame_count;
+   uint32_t other_frame_count;
    struct addrinfo *addr;
    struct sockaddr_storage their_addr;
    bool has_client_addr;
+
+   unsigned timeout_cnt;
 };
 
+static void warn_hangup(void)
+{
+   SSNES_WARN("Netplay has disconnected. Will continue without connection ...\n");
+   if (g_extern.msg_queue)
+      msg_queue_push(g_extern.msg_queue, "Netplay has disconnected. Will continue without connection.", 0, 480);
+}
+
 void input_poll_net(void)
 {
    if (!netplay_should_skip(g_extern.netplay) && netplay_can_poll(g_extern.netplay))
-   {
-      netplay_callbacks(g_extern.netplay)->poll_cb();
       netplay_poll(g_extern.netplay);
-   }
 }
 
 void video_frame_net(const uint16_t *data, unsigned width, unsigned height)
@@ -243,7 +257,7 @@ static bool init_socket(netplay_t *handle, const char *server, uint16_t port)
 {
 #ifdef _WIN32
    WSADATA wsaData;
-   if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
+   if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
       WSACleanup();
       return false;
@@ -264,9 +278,27 @@ bool netplay_can_poll(netplay_t *handle)
    return handle->can_poll;
 }
 
+// Not really a hash, but should be enough to differentiate implementations from each other.
+// Subtle differences in the implementation will not be possible to spot.
+// The alternative would have been checking serialization sizes, but it was troublesome for cross platform compat.
+static uint32_t implementation_magic_value(void)
+{
+   uint32_t res = 0;
+   res |= (psnes_library_revision_major() & 0xf) << 0;
+   res |= (psnes_library_revision_minor() & 0xf) << 4;
+
+   // Shouldn't really use this, but oh well :) It'll do the job.
+   const char *lib = psnes_library_id();
+   size_t len = strlen(lib);
+   for (size_t i = 0; i < len; i++)
+      res ^= lib[i] << (i & 0xf);
+
+   return res;
+}
+
 static bool send_info(netplay_t *handle)
 {
-   uint32_t header[3] = { htonl(g_extern.cart_crc), htonl(psnes_serialize_size()), htonl(psnes_get_memory_size(SNES_MEMORY_CARTRIDGE_RAM)) };
+   uint32_t header[3] = { htonl(g_extern.cart_crc), htonl(implementation_magic_value()), htonl(psnes_get_memory_size(SNES_MEMORY_CARTRIDGE_RAM)) };
    if (send(handle->fd, CONST_CAST header, sizeof(header), 0) != sizeof(header))
       return false;
 
@@ -301,9 +333,9 @@ static bool get_info(netplay_t *handle)
       SSNES_ERR("Cart CRC32s differ! Cannot use different games!\n");
       return false;
    }
-   if (psnes_serialize_size() != ntohl(header[1]))
+   if (implementation_magic_value() != ntohl(header[1]))
    {
-      SSNES_ERR("Serialization sizes differ, make sure you're using exact same libsnes implementations!\n");
+      SSNES_ERR("Implementations differ, make sure you're using exact same libsnes implementations!\n");
       return false;
    }
    if (psnes_get_memory_size(SNES_MEMORY_CARTRIDGE_RAM) != ntohl(header[2]))
@@ -343,6 +375,9 @@ static void init_buffers(netplay_t *handle)
 
 netplay_t *netplay_new(const char *server, uint16_t port, unsigned frames, const struct snes_callbacks *cb)
 {
+   if (frames > UDP_FRAME_PACKETS)
+      frames = UDP_FRAME_PACKETS;
+
    netplay_t *handle = calloc(1, sizeof(*handle));
    if (!handle)
       return NULL;
@@ -401,7 +436,7 @@ static bool send_chunk(netplay_t *handle)
    {
       if (sendto(handle->udp_fd, CONST_CAST handle->packet_buffer, sizeof(handle->packet_buffer), 0, addr, sizeof(struct sockaddr)) != sizeof(handle->packet_buffer))
       {
-         SSNES_WARN("Netplay connection hung up. Will continue without netplay.\n");
+         warn_hangup();
          handle->has_connection = false;
          return false;
       }
@@ -409,26 +444,32 @@ static bool send_chunk(netplay_t *handle)
    return true;
 }
 
-#define MAX_RETRIES 64
+#define MAX_RETRIES 16
 #define RETRY_MS 500
 
 static int poll_input(netplay_t *handle, bool block)
 {
-   fd_set fds;
-   FD_ZERO(&fds);
-   FD_SET(handle->udp_fd, &fds);
-   FD_SET(handle->fd, &fds);
    int max_fd = (handle->fd > handle->udp_fd ? handle->fd : handle->udp_fd) + 1;
 
-   struct timeval tv = {
+   const struct timeval tv = {
       .tv_sec = 0,
       .tv_usec = block ? (RETRY_MS * 1000) : 0
    };
 
-   int i = 0;
    do
-   {
-      if (select(max_fd, &fds, NULL, NULL, &tv) < 0)
+   { 
+      handle->timeout_cnt++;
+
+      // select() does not take pointer to const struct timeval.
+      // Technically possible for select() to modify tmp_tv, so we go paranoia mode.
+      struct timeval tmp_tv = tv;
+
+      fd_set fds;
+      FD_ZERO(&fds);
+      FD_SET(handle->udp_fd, &fds);
+      FD_SET(handle->fd, &fds);
+
+      if (select(max_fd, &fds, NULL, NULL, &tmp_tv) < 0)
          return -1;
 
       // Somewhat hacky, but we aren't using the TCP connection for anything useful atm.
@@ -441,20 +482,17 @@ static int poll_input(netplay_t *handle, bool block)
 
       if (block && !send_chunk(handle))
       {
-         SSNES_WARN("Netplay connection hung up. Will continue without netplay.\n");
+         warn_hangup();
          handle->has_connection = false;
          return -1;
       }
 
       if (block)
-         SSNES_LOG("Network lag of %d ms, resending packet... Attempt %d of %d ...\n", RETRY_MS, i, MAX_RETRIES);
-
-      // Seems to be necessary on Win32.
-      FD_ZERO(&fds);
-      FD_SET(handle->udp_fd, &fds);
-      FD_SET(handle->fd, &fds);
-
-   } while ((i++ < MAX_RETRIES) && block);
+      {
+         SSNES_LOG("Network is stalling, resending packet... Count %u of %d ...\n",
+               handle->timeout_cnt, MAX_RETRIES);
+      }
+   } while ((handle->timeout_cnt < MAX_RETRIES) && block);
 
    if (block)
       return -1;
@@ -470,7 +508,7 @@ static bool get_self_input_state(netplay_t *handle)
    if (handle->frame_count > 0) // First frame we always give zero input since relying on input from first frame screws up when we use -F 0.
    {
       snes_input_state_t cb = handle->cbs.state_cb;
-      for (int i = 0; i <= 11; i++)
+      for (unsigned i = 0; i <= 11; i++)
       {
          int16_t tmp = cb(g_settings.input.netplay_client_swap_input ? 0 : !handle->port, SNES_DEVICE_JOYPAD, 0, i);
          state |= tmp ? 1 << i : 0;
@@ -483,7 +521,7 @@ static bool get_self_input_state(netplay_t *handle)
 
    if (!send_chunk(handle))
    {
-      SSNES_WARN("Netplay connection hung up. Will continue without netplay.\n");
+      warn_hangup();
       handle->has_connection = false;
       return false;
    }
@@ -511,7 +549,7 @@ static void parse_packet(netplay_t *handle, uint32_t *buffer, unsigned size)
 
    for (unsigned i = 0; i < size && handle->read_frame_count <= handle->frame_count; i++)
    {
-      uint32_t frame = buffer[2 * i];
+      uint32_t frame = buffer[2 * i + 0];
       uint32_t state = buffer[2 * i + 1];
 
       if (frame == handle->read_frame_count)
@@ -520,6 +558,7 @@ static void parse_packet(netplay_t *handle, uint32_t *buffer, unsigned size)
          handle->buffer[handle->read_ptr].real_input_state = state;
          handle->read_ptr = NEXT_PTR(handle->read_ptr);
          handle->read_frame_count++;
+         handle->timeout_cnt = 0;
       }
    }
 }
@@ -544,7 +583,7 @@ bool netplay_poll(netplay_t *handle)
    if (!get_self_input_state(handle))
       return false;
 
-   // We skip reading the first frame so the host has a change to grab our host info so we don't block forever :')
+   // We skip reading the first frame so the host has a chance to grab our host info so we don't block forever :')
    if (handle->frame_count == 0)
    {
       handle->buffer[0].used_real = true;
@@ -555,20 +594,22 @@ bool netplay_poll(netplay_t *handle)
       return true;
    }
 
-   //fprintf(stderr, "Other ptr: %lu, Read ptr: %lu, Self ptr: %lu\n", handle->other_ptr, handle->read_ptr, handle->self_ptr);
+   //fprintf(stderr, "Before poll: Other ptr: %lu, Read ptr: %lu, Self ptr: %lu\n", handle->other_ptr, handle->read_ptr, handle->self_ptr);
+   /*
    if (handle->buffer_size > 1)
    {
       assert(handle->other_ptr != handle->self_ptr);
       assert(handle->read_ptr != handle->self_ptr);
    }
    assert(handle->other_ptr == handle->read_ptr);
+   */
 
    // We might have reached the end of the buffer, where we simply have to block.
-   int res = poll_input(handle, handle->other_ptr == NEXT_PTR(handle->self_ptr));
+   int res = poll_input(handle, handle->other_ptr == handle->self_ptr);
    if (res == -1)
    {
       handle->has_connection = false;
-      SSNES_WARN("Netplay connection timed out. Will continue without netplay.\n");
+      warn_hangup();
       return false;
    }
 
@@ -580,26 +621,28 @@ bool netplay_poll(netplay_t *handle)
          uint32_t buffer[UDP_FRAME_PACKETS * 2];
          if (!receive_data(handle, buffer, sizeof(buffer)))
          {
-            SSNES_WARN("Netplay connection hung up. Will continue without netplay.\n");
+            warn_hangup();
             handle->has_connection = false;
             return false;
          }
          parse_packet(handle, buffer, UDP_FRAME_PACKETS);
 
       } while ((handle->read_frame_count <= handle->frame_count) && 
-            poll_input(handle, (handle->other_ptr == NEXT_PTR(handle->self_ptr)) && 
+            poll_input(handle, (handle->other_ptr == handle->self_ptr) && 
                (first_read == handle->read_frame_count)) == 1);
    }
    else
    {
       // Cannot allow this. Should not happen though.
-      if (NEXT_PTR(handle->self_ptr) == handle->other_ptr)
+      if (handle->self_ptr == handle->other_ptr)
       {
-         SSNES_WARN("Netplay connection hung up. Will continue without netplay.\n");
+         warn_hangup();
          return false;
       }
    }
 
+   //fprintf(stderr, "After poll: Other ptr: %lu, Read ptr: %lu, Self ptr: %lu\n", handle->other_ptr, handle->read_ptr, handle->self_ptr);
+
    if (handle->read_ptr != handle->self_ptr)
       simulate_input(handle);
    else
@@ -659,6 +702,8 @@ void netplay_pre_frame(netplay_t *handle)
 {
    psnes_serialize(handle->buffer[handle->self_ptr].state, handle->state_size);
    handle->can_poll = true;
+
+   input_poll_net();
 }
 
 // Here we check if we have new input and replay from recorded input.
@@ -667,36 +712,42 @@ void netplay_post_frame(netplay_t *handle)
    handle->frame_count++;
 
    // Nothing to do...
-   if (handle->other_ptr == handle->read_ptr)
+   if (handle->other_frame_count == handle->read_frame_count)
       return;
 
    // Skip ahead if we predicted correctly. Skip until our simulation failed.
-   while (handle->other_ptr != handle->read_ptr)
+   while (handle->other_frame_count < handle->read_frame_count)
    {
       struct delta_frame *ptr = &handle->buffer[handle->other_ptr];
       if ((ptr->simulated_input_state != ptr->real_input_state) && !ptr->used_real)
          break;
       handle->other_ptr = NEXT_PTR(handle->other_ptr);
+      handle->other_frame_count++;
    }
 
-   if (handle->other_ptr != handle->read_ptr)
+   if (handle->other_frame_count < handle->read_frame_count)
    {
       // Replay frames
       handle->is_replay = true;
       handle->tmp_ptr = handle->other_ptr;
       psnes_unserialize(handle->buffer[handle->other_ptr].state, handle->state_size);
-      while (handle->tmp_ptr != handle->self_ptr)
+      bool first = true;
+      while (first || (handle->tmp_ptr != handle->self_ptr))
       {
          psnes_serialize(handle->buffer[handle->tmp_ptr].state, handle->state_size);
+#ifdef HAVE_THREADS
          lock_autosave();
+#endif
          psnes_run();
+#ifdef HAVE_THREADS
          unlock_autosave();
+#endif
          handle->tmp_ptr = NEXT_PTR(handle->tmp_ptr);
+         first = false;
       }
       handle->other_ptr = handle->read_ptr;
+      handle->other_frame_count = handle->read_frame_count;
       handle->is_replay = false;
    }
-
 }
 
-

netplay.h

@@ -21,7 +21,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
-#include <libsnes.hpp>
+#include "libsnes.hpp"
 
 void input_poll_net(void);
 int16_t input_state_net(bool port, unsigned device, unsigned index, unsigned id);
@@ -34,7 +34,6 @@ struct snes_callbacks
 {
    snes_video_refresh_t frame_cb;
    snes_audio_sample_t sample_cb;
-   snes_input_poll_t poll_cb;
    snes_input_state_t state_cb;
 };
 

ps3/main.c

@@ -0,0 +1,41 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Daniel De Matteis
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/process.h>
+#include <sysutil/sysutil_common.h>
+#include <sys/spu_initialize.h>
+#include <stddef.h>
+
+int ssnes_main(int argc, char *argv[]);
+
+SYS_PROCESS_PARAM(1001, 0x100000)
+
+#undef main
+// Temporary, a more sane implementation should go here.
+int main(int argc, char *argv[])
+{
+   sys_spu_initialize(4, 3);
+   char arg1[] = "ssnes";
+   char arg2[] = "/dev_hdd0/game/SNES90000/USRDIR/main.sfc";
+   char arg3[] = "-v";
+   char arg4[] = "-c";
+   char arg5[] = "/dev_hdd0/game/SSNE10000/USRDIR/ssnes.cfg";
+   char *argv_[] = { arg1, arg2, arg3, arg4, arg5, NULL };
+   return ssnes_main(sizeof(argv_) / sizeof(argv_[0]) - 1, argv_);
+}
+

ps3/pad_input.c

@@ -0,0 +1,111 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Daniel De Matteis
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cell/pad.h>
+#include <sdk_version.h>
+#include "pad_input.h"
+
+#define LOWER_BUTTONS 2
+#define HIGHER_BUTTONS 3
+#define RSTICK_X 4
+#define RSTICK_Y 5
+#define LSTICK_X 6
+#define LSTICK_Y 7
+
+#define DEADZONE_LOW 55
+#define DEADZONE_HIGH 210
+
+#define PRESSED_LEFT_LSTICK(state)   (CTRL_AXIS_LSTICK_X(state) <= DEADZONE_LOW)
+#define PRESSED_RIGHT_LSTICK(state)  (CTRL_AXIS_LSTICK_X(state) >= DEADZONE_HIGH)
+#define PRESSED_UP_LSTICK(state)     (CTRL_AXIS_LSTICK_Y(state) <= DEADZONE_LOW)
+#define PRESSED_DOWN_LSTICK(state)   (CTRL_AXIS_LSTICK_Y(state) >= DEADZONE_HIGH)
+#define PRESSED_LEFT_RSTICK(state)   (CTRL_AXIS_RSTICK_X(state) <= DEADZONE_LOW)
+#define PRESSED_RIGHT_RSTICK(state)  (CTRL_AXIS_RSTICK_X(state) >= DEADZONE_HIGH)
+#define PRESSED_UP_RSTICK(state)     (CTRL_AXIS_RSTICK_Y(state) <= DEADZONE_LOW)
+#define PRESSED_DOWN_RSTICK(state)   (CTRL_AXIS_RSTICK_Y(state) >= DEADZONE_HIGH)
+
+#define LSTICK_LEFT_SHIFT 48
+#define LSTICK_RIGHT_SHIFT 49
+#define LSTICK_UP_SHIFT 50
+#define LSTICK_DOWN_SHIFT 51
+
+#define RSTICK_LEFT_SHIFT 52
+#define RSTICK_RIGHT_SHIFT 53
+#define RSTICK_UP_SHIFT 54
+#define RSTICK_DOWN_SHIFT 55
+
+int cell_pad_input_init(void)
+{
+   return cellPadInit(MAX_PADS);
+}
+
+void cell_pad_input_deinit(void)
+{
+   cellPadEnd();
+}
+
+uint32_t cell_pad_input_pads_connected(void)
+{
+#if(CELL_SDK_VERSION > 0x340000)
+   CellPadInfo2 pad_info;
+   cellPadGetInfo2(&pad_info);
+#else
+   CellPadInfo pad_info;
+   cellPadGetInfo(&pad_info);
+#endif
+   return pad_info.now_connect;
+}
+
+#define M(x) (x & 0xFF)
+
+uint64_t cell_pad_input_poll_device(uint32_t id)
+{
+   CellPadData pad_data;
+   static uint64_t ret[MAX_PADS];
+
+   // Get new pad data
+   cellPadGetData(id, &pad_data);
+
+   if (pad_data.len == 0)
+      return ret[id];
+   else
+   {
+      ret[id] = 0;
+
+      // Build the return value.
+      ret[id] |= (uint64_t)M(pad_data.button[LOWER_BUTTONS]);
+      ret[id] |= (uint64_t)M(pad_data.button[HIGHER_BUTTONS]) << 8;
+      ret[id] |= (uint64_t)M(pad_data.button[RSTICK_X]) << 32;
+      ret[id] |= (uint64_t)M(pad_data.button[RSTICK_Y]) << 40;
+      ret[id] |= (uint64_t)M(pad_data.button[LSTICK_X]) << 16;
+      ret[id] |= (uint64_t)M(pad_data.button[LSTICK_Y]) << 24;
+
+      ret[id] |= (uint64_t)(PRESSED_LEFT_LSTICK(ret[id]) ? 1 : 0) << LSTICK_LEFT_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_RIGHT_LSTICK(ret[id]) ? 1 : 0) << LSTICK_RIGHT_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_UP_LSTICK(ret[id]) ? 1 : 0) << LSTICK_UP_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_DOWN_LSTICK(ret[id]) ? 1 : 0) << LSTICK_DOWN_SHIFT;
+
+      ret[id] |= (uint64_t)(PRESSED_LEFT_RSTICK(ret[id]) ? 1 : 0) << RSTICK_LEFT_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_RIGHT_RSTICK(ret[id]) ? 1 : 0) << RSTICK_RIGHT_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_UP_RSTICK(ret[id]) ? 1 : 0) << RSTICK_UP_SHIFT;
+      ret[id] |= (uint64_t)(PRESSED_DOWN_RSTICK(ret[id]) ? 1 : 0) << RSTICK_DOWN_SHIFT;
+      return ret[id];
+   }
+}
+#undef M
+

ps3/pad_input.h

@@ -0,0 +1,108 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Daniel De Matteis
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CELL_PAD_INPUT_H
+#define __CELL_PAD_INPUT_H
+
+#define MAX_PADS 7
+
+#define CTRL_SELECT_MASK 0x01
+#define CTRL_L3_MASK 0x2
+#define CTRL_R3_MASK 0x4
+#define CTRL_START_MASK 0x8
+#define CTRL_UP_MASK 0x10
+#define CTRL_RIGHT_MASK 0x20
+#define CTRL_DOWN_MASK 0x40
+#define CTRL_LEFT_MASK 0x80
+
+#define CTRL_L2_MASK 0x100
+#define CTRL_R2_MASK 0x200
+#define CTRL_L1_MASK 0x400
+#define CTRL_R1_MASK 0x800
+#define CTRL_TRIANGLE_MASK 0x1000
+#define CTRL_CIRCLE_MASK 0x2000
+#define CTRL_CROSS_MASK 0x4000
+#define CTRL_SQUARE_MASK 0x8000
+
+// Big numbers, harhar.
+#define CTRL_LSTICK_LEFT_MASK    0x1000000000000LLU
+#define CTRL_LSTICK_RIGHT_MASK   0x2000000000000LLU
+#define CTRL_LSTICK_UP_MASK      0x4000000000000LLU
+#define CTRL_LSTICK_DOWN_MASK    0x8000000000000LLU
+#define CTRL_RSTICK_LEFT_MASK    0x10000000000000LLU
+#define CTRL_RSTICK_RIGHT_MASK   0x20000000000000LLU
+#define CTRL_RSTICK_UP_MASK      0x40000000000000LLU
+#define CTRL_RSTICK_DOWN_MASK    0x80000000000000LLU
+
+
+#define CTRL_SELECT(state) (CTRL_SELECT_MASK & state)
+#define CTRL_L3(state) (CTRL_L3_MASK & state)
+#define CTRL_R3(state) (CTRL_R3_MASK & state)
+#define CTRL_START(state) (CTRL_START_MASK & state)
+#define CTRL_UP(state) (CTRL_UP_MASK & state)
+#define CTRL_RIGHT(state) (CTRL_RIGHT_MASK & state)
+#define CTRL_DOWN(state) (CTRL_DOWN_MASK & state)
+#define CTRL_LEFT(state) (CTRL_LEFT_MASK & state)
+
+#define CTRL_L2(state) (CTRL_L2_MASK & state)
+#define CTRL_R2(state) (CTRL_R2_MASK & state)
+#define CTRL_L1(state) (CTRL_L1_MASK & state)
+#define CTRL_R1(state) (CTRL_R1_MASK & state)
+#define CTRL_TRIANGLE(state) (CTRL_TRIANGLE_MASK & state)
+#define CTRL_CIRCLE(state) (CTRL_CIRCLE_MASK & state)
+#define CTRL_CROSS(state) (CTRL_CROSS_MASK & state)
+#define CTRL_SQUARE(state) (CTRL_SQUARE_MASK & state)
+
+#define CTRL_LSTICK_LEFT(state)     (CTRL_LSTICK_LEFT_MASK & state)
+#define CTRL_LSTICK_RIGHT(state)    (CTRL_LSTICK_RIGHT_MASK & state)
+#define CTRL_LSTICK_UP(state)       (CTRL_LSTICK_UP_MASK & state)
+#define CTRL_LSTICK_DOWN(state)     (CTRL_LSTICK_DOWN_MASK & state)
+#define CTRL_RSTICK_LEFT(state)     (CTRL_RSTICK_LEFT_MASK & state)
+#define CTRL_RSTICK_RIGHT(state)    (CTRL_RSTICK_RIGHT_MASK & state)
+#define CTRL_RSTICK_UP(state)       (CTRL_RSTICK_UP_MASK & state)
+#define CTRL_RSTICK_DOWN(state)     (CTRL_RSTICK_DOWN_MASK & state)
+
+#define CTRL_MASK(state, mask) (state & mask)
+
+#define CTRL_AXIS_LSTICK_X(state) ((uint8_t)(((0xFF0000LLU & state) >> 16) & 0xFF))
+#define CTRL_AXIS_LSTICK_Y(state) ((uint8_t)(((0xFF000000LLU & state) >> 24) & 0xFF))
+#define CTRL_AXIS_RSTICK_X(state) ((uint8_t)(((0xFF00000000LLU & state) >> 32) & 0xFF))
+#define CTRL_AXIS_RSTICK_Y(state) ((uint8_t)(((0xFF0000000000LLU & state) >> 40) & 0xFF))
+
+typedef uint64_t cell_input_state_t;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+   // Init and destruction of device.
+   int cell_pad_input_init(void);
+   void cell_pad_input_deinit(void);
+
+   // Get number of pads connected
+   uint32_t cell_pad_input_pads_connected(void);
+
+   cell_input_state_t cell_pad_input_poll_device(uint32_t id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

ps3/pkg/USRDIR/ssnes.cfg

@@ -0,0 +1,335 @@
+##### Config file for SSNES
+
+# Save all save files (*.srm) to this directory. This includes related files like .bsv, .rtc, .psrm, etc ...
+# This will be overridden by explicit command line options.
+# savefile_directory =
+
+# Save all save states (*.state) to this directory.
+# This will be overridden by explicit command line options.
+# savestate_directory =
+
+## If enabled, load libsnes from a dynamic location.
+# libsnes_path = "/path/to/libsnes.so"
+
+#### Video
+
+# Video driver to use. "gl", "xvideo", "sdl" or "ext" (external API driver)
+# video_driver = "gl"
+
+# Path to external video driver using the SSNES driver API.
+# video_external_driver =
+
+# Windowed xscale and yscale
+# (Real x res: base_size * xscale * aspect_ratio, real y res: base_size * yscale)
+# video_xscale = 3.0
+# video_yscale = 3.0
+
+# Fullscreen resolution. Resolution of 0 uses the resolution of the desktop.
+# video_fullscreen_x = 0
+# video_fullscreen_y = 0
+
+# Start in fullscreen. Can be changed at runtime.
+# video_fullscreen = false
+
+# Force 16-bit colors. Apparently some video cards in use today have troubles with 32-bit ...
+# video_force_16bit = false
+
+# Forcibly disable composition. Only works in Windows Vista/7 for now.
+# video_disable_composition = false
+
+# Video vsync.
+# video_vsync = true
+
+# Smoothens picture with bilinear filtering. Should be disabled if using pixel shaders.
+# video_smooth = true
+
+# Forces rendering area to stay equal to SNES aspect ratio 4:3 or as defined in video_aspect_ratio.
+# video_force_aspect = true
+
+# A floating point value for video aspect ratio (width / height)
+# video_aspect_ratio = 1.333
+
+# Forces cropping of overscanned frames. Crops away top 7 scanlines and 8 bottom scanlines. (15/15 for interlaced frames).
+# video_crop_overscan = false
+
+# Path to Cg shader.
+# video_cg_shader = "/path/to/cg/shader.cg"
+
+# Path to bSNES XML shader (GLSL only). If both Cg shader path and XML shader path are defined, 
+# Cg shader will take priority unless overridden in video_shader_type.
+# video_bsnes_shader = "/path/to/bsnes/xml/shader.shader"
+
+# Which shader type to use. Valid values are "cg", "bsnes", "none" and "auto"
+# video_shader_type = auto
+
+# Defines a directory where XML shaders are kept.
+# video_shader_dir =
+
+# Render to texture first. Useful when doing multi-pass shaders or control the output of shaders better.
+# video_render_to_texture = false
+
+# Defines the video scale of render-to-texture. 
+# The output FBO size is scaled by these amounts against the input size (typically 256 * 224 for SNES).
+# video_fbo_scale_x = 2.0
+# video_fbo_scale_y = 2.0
+
+# Define shader to use for second pass (needs render-to-texture).
+# video_second_pass_shader = "/path/to/second/shader.{cg,shader}"
+
+# Defines if bilinear filtering is used during second pass (needs render-to-texture).
+# video_second_pass_smooth = true
+
+# CPU-based filter. Path to a bSNES CPU filter (*.filter)
+# video_filter =
+
+# Path to a TTF font used for rendering messages. This path must be defined to enable fonts.
+# Do note that the _full_ path of the font is necessary!
+# video_font_path = 
+
+# Size of the TTF font rendered.
+# video_font_size = 48
+
+# Enable usage of OSD messages.
+# video_font_enable = true
+
+# Offset for where messages will be placed on screen. Values are in range 0.0 to 1.0 for both x and y values. 
+# [0.0, 0.0] maps to the lower left corner of the screen.
+# video_message_pos_x = 0.05
+# video_message_pos_y = 0.05
+
+# Color for message. The value is treated as a hexadecimal value.
+# It is a regular RGB hex number, i.e. red is "ff0000".
+# video_message_color = ffffff
+
+# Video refresh rate of your monitor.
+# Used to calculate a suitable audio input rate.
+# video_refresh_rate = 59.95
+
+#### Audio
+
+# Enable audio.
+# audio_enable = true
+
+# Audio output samplerate.
+# audio_out_rate = 48000
+
+# When altering audio_in_rate on-the-fly, define by how much each time.
+# audio_rate_step = 0.25
+
+# Audio driver backend. Depending on configuration possible candidates are: alsa, pulse, oss, jack, rsound, roar, openal, sdl, xaudio and ext (external driver).
+# audio_driver =
+
+# Path to external audio driver using the SSNES audio driver API.
+# audio_external_driver =
+
+# Override the default audio device the audio_driver uses. This is driver dependant. E.g. ALSA wants a PCM device, OSS wants a path (e.g. /dev/dsp), Jack wants portnames (e.g. system:playback1,system:playback_2), and so on ...
+# audio_device =
+
+# External DSP plugin that processes audio before it's sent to the driver.
+# audio_dsp_plugin =
+
+# Will sync (block) on audio. Recommended.
+# audio_sync = true
+
+# Desired audio latency in milliseconds. Might not be honored if driver can't provide given latency.
+# audio_latency = 64
+
+
+### Input
+
+# Input driver. Depending on video driver, it might force a different input driver.
+# input_driver = sdl
+
+# Defines axis threshold. Possible values are [0.0, 1.0]
+# input_axis_threshold = 0.5
+
+# Keyboard input. Will recognize normal keypresses and special keys like "left", "right", and so on.
+# Keyboard input, Joypad and Joyaxis will all obey the "nul" bind, which disables the bind completely, 
+# rather than relying on a default.
+# input_player1_a = x
+# input_player1_b = z
+# input_player1_y = a
+# input_player1_x = s
+# input_player1_start = enter
+# input_player1_select = rshift
+# input_player1_l = q
+# input_player1_r = w
+# input_player1_left = left
+# input_player1_right = right
+# input_player1_up = up
+# input_player1_down = down
+
+# If desired, it is possible to override which joypads are being used for player 1 through 5. First joypad available is 0.
+# input_player1_joypad_index = 0
+# input_player2_joypad_index = 1
+# input_player3_joypad_index = 2
+# input_player4_joypad_index = 3
+# input_player5_joypad_index = 4
+
+# Joypad buttons. Figure these out by looking at jstest /dev/input/js0 output, or use ssnes-joyconfig.
+# You can use joypad hats with hnxx, where n is the hat, and xx is a string representing direction. 
+# E.g. "h0up"
+# input_player1_a_btn = 1
+# input_player1_b_btn = 0
+# input_player1_y_btn = 2
+# input_player1_x_btn = 3
+# input_player1_start_btn = 7
+# input_player1_select_btn = 6
+# input_player1_l_btn = 4
+# input_player1_r_btn = 5
+# input_player1_left_btn = 11
+# input_player1_right_btn = 12
+# input_player1_up_btn = 13
+# input_player1_down_btn = 14
+
+# Axis for SNES DPAD. 
+# Needs to be either '+' or '-' in the first character signaling either positive or negative direction of the axis, then the axis number. 
+# Do note that every other input option has the corresponding _btn and _axis binds as well; they are omitted here for clarity.
+# input_player1_left_axis = -0
+# input_player1_right_axis = +0
+# input_player1_up_axis = +1
+# input_player1_down_axis = -1
+
+# Same stuff, just for player two.
+# input_player2_a = 
+# input_player2_b =
+# input_player2_y =
+# input_player2_x =
+# input_player2_start =
+# input_player2_select =
+# input_player2_l =
+# input_player2_r =
+# input_player2_left =
+# input_player2_right =
+# input_player2_up =
+# input_player2_down =
+
+# input_player2_a_btn = 1
+# input_player2_b_btn = 0
+# input_player2_y_btn = 2
+# input_player2_x_btn = 3
+# input_player2_start_btn = 7
+# input_player2_select_btn = 6
+# input_player2_l_btn = 4
+# input_player2_r_btn = 5
+# input_player2_left_btn = 11
+# input_player2_right_btn = 12
+# input_player2_up_btn = 13
+# input_player2_down_btn = 14
+
+
+# input_player2_left_axis = -0
+# input_player2_right_axis = +0
+# input_player2_up_axis = -1
+# input_player2_down_axis = +1
+
+# This goes all the way to player 5, but again omitted for clarity.
+
+# Toggles fullscreen.
+# input_toggle_fullscreen = f
+# Saves state.
+# input_save_state = f2
+# Loads state.
+# input_load_state = f4
+
+# State slots. With slot set to 0, save state name is *.state (or whatever defined on commandline).
+# When slot is != 0, path will be $path%d, where %d is slot number.
+# input_state_slot_increase = f7
+# input_state_slot_decrease = f6
+
+# Toggles between fast-forwarding and normal speed.
+# input_toggle_fast_forward = space
+
+# Hold for fast-forward. Releasing button disables fast-forward.
+# input_hold_fast_forward = l
+
+# Key to exit emulator cleanly. 
+# Killing it in any hard way (SIGTERM, SIGKILL, etc, will terminate emulator without saving RAM, etc.)
+# input_exit_emulator = escape
+
+# Decrease/increase input sample rate on the fly. Amount to decrease/increase is defined by audio_rate_step.
+# input_rate_step_up = kp_plus
+# input_rate_step_down = kp_minus
+
+# Applies next and previous XML shader in directory.
+# input_shader_next = m
+# input_shader_prev = n
+
+# Enable rewinding. This will take a performance hit when playing, so it is disabled by default.
+# Do note that rewinding will only work properly when using bSNES libsnes core atm.
+# rewind_enable = true
+
+# Rewinding buffer size in megabytes. Bigger rewinding buffer means you can rewind longer.
+# The buffer should be approx. 20MB per minute of buffer time.
+# rewind_buffer_size = 20
+
+# Rewind granularity. When rewinding defined number of frames, you can rewind several frames at a time, increasing the rewinding speed.
+# rewind_granularity = 1
+
+# Hold button down to rewind. Rewinding must be enabled.
+# input_rewind = r
+
+# Toggle between recording and not.
+# input_movie_record_toggle = o
+
+# Toggle between paused and non-paused state
+# input_pause_toggle = p
+
+# Frame advance when game is paused
+# input_frame_advance = k
+
+# Reset the emulated SNES.
+# input_reset = h
+
+# Configures DSP plugin
+# input_dsp_config = c
+
+# Pause gameplay when window focus is lost.
+# pause_nonactive = true
+
+# Autosaves the non-volatile SRAM at a regular interval. This is disabled by default unless set otherwise.
+# The interval is measured in seconds. A value of 0 disables autosave.
+# autosave_interval =
+
+# When being client over netplay, use keybinds for player 1.
+# netplay_client_swap_input = false
+
+
+# Path to XML cheat database (as used by bSNES).
+# cheat_database_path =
+
+# Path to XML cheat config, a file which keeps track of which
+# cheat settings are used for individual games.
+# If the file does not exist, it will be created.
+# cheat_settings_path =
+
+# Cheats.
+# input_cheat_index_plus = y
+# input_cheat_index_minus = t
+# input_cheat_toggle = u
+
+# Mute/unmute audio
+# input_audio_mute = f9
+
+# Take screenshot
+# input_screenshot = print_screen
+
+# Directory to dump screenshots to.
+# screenshot_directory =
+
+# Records video assuming video is hi-res.
+# video_hires_record = false
+
+# Records video after CPU video filter.
+# video_post_filter_record = false
+
+# Block SRAM from being overwritten when loading save states.
+# Might potentially lead to buggy games.
+# block_sram_overwrite = false
+
+# When saving a savestate, save state index is automatically increased before
+# it is saved.
+# Also, when loading a ROM, the index will be set to the highest existing index.
+# There is no upper bound on the index.
+# savestate_auto_index = false
+

ps3/pkg/package.conf

@@ -0,0 +1,5 @@
+Content-ID = UP0001-SSNE10000_00-0000000000000001
+k_licensee = 0x00000000000000000000000000000000
+DRM_Type = Local
+Content_Type = Game_Exec
+PackageVersion = 00.01

ps3/ps3_audio.c

@@ -0,0 +1,197 @@
+/*  SSNES - A Super Ninteno Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Daniel De Matteis
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../driver.h"
+#include "../general.h"
+#include <stdlib.h>
+#include <cell/audio.h>
+#include <sys/timer.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/synchronization.h>
+#include "../fifo_buffer.h"
+#include <sys/event.h>
+
+#define AUDIO_BLOCKS 8 // 8 or 16. Guess what we choose? :)
+#define AUDIO_CHANNELS 2 // All hail glorious stereo!
+
+typedef struct
+{
+   uint32_t audio_port;
+   bool nonblocking;
+   volatile bool quit_thread;
+   fifo_buffer_t *buffer;
+
+   pthread_t thread;
+   sys_lwmutex_t lock;
+   sys_lwmutex_t cond_lock;
+   sys_lwcond_t cond;
+} ps3_audio_t;
+
+static void *event_loop(void *data)
+{
+   ps3_audio_t *aud = data;
+   sys_event_queue_t id;
+   sys_ipc_key_t key;
+   sys_event_t event;
+
+   cellAudioCreateNotifyEventQueue(&id, &key);
+   cellAudioSetNotifyEventQueue(key);
+
+   float out_tmp[CELL_AUDIO_BLOCK_SAMPLES * AUDIO_CHANNELS] __attribute__((aligned(16)));
+
+   while (!aud->quit_thread)
+   {
+      sys_event_queue_receive(id, &event, SYS_NO_TIMEOUT);
+
+      sys_lwmutex_lock(&aud->lock, SYS_NO_TIMEOUT);
+      if (fifo_read_avail(aud->buffer) >= sizeof(out_tmp))
+         fifo_read(aud->buffer, out_tmp, sizeof(out_tmp));
+      else
+         memset(out_tmp, 0, sizeof(out_tmp));
+      sys_lwmutex_unlock(&aud->lock);
+      sys_lwcond_signal(&aud->cond);
+
+      cellAudioAddData(aud->audio_port, out_tmp, CELL_AUDIO_BLOCK_SAMPLES, 1.0);
+   }
+
+   cellAudioRemoveNotifyEventQueue(key);
+   pthread_exit(NULL);
+   return NULL;
+}
+
+static void *ps3_audio_init(const char *device, unsigned rate, unsigned latency)
+{
+   (void)latency;
+   (void)device;
+   (void)rate; // Always use 48kHz.
+   g_settings.audio.out_rate = 48000.0;
+
+   ps3_audio_t *data = calloc(1, sizeof(*data));
+   if (!data)
+      return NULL;
+
+   CellAudioPortParam params;
+   cellAudioInit();
+   params.nChannel = AUDIO_CHANNELS;
+   params.nBlock = AUDIO_BLOCKS;
+   params.attr = 0;
+
+   if (cellAudioPortOpen(&params, &data->audio_port) != CELL_OK)
+   {
+      cellAudioQuit();
+      free(data);
+      return NULL;
+   }
+
+   data->buffer = fifo_new(CELL_AUDIO_BLOCK_SAMPLES * AUDIO_CHANNELS * AUDIO_BLOCKS * sizeof(float));
+
+   sys_lwmutex_attribute_t lock_attr, cond_lock_attr;
+   sys_lwcond_attribute_t cond_attr;
+
+   sys_lwmutex_attribute_initialize(lock_attr);
+   sys_lwmutex_attribute_initialize(cond_lock_attr);
+   sys_lwcond_attribute_initialize(cond_attr);
+
+   sys_lwmutex_create(&data->lock, &lock_attr);
+   sys_lwmutex_create(&data->cond_lock, &cond_lock_attr);
+   sys_lwcond_create(&data->cond, &data->cond_lock, &cond_attr);
+
+   cellAudioPortStart(data->audio_port);
+   pthread_create(&data->thread, NULL, event_loop, data);
+   return data;
+}
+
+static ssize_t ps3_audio_write(void *data, const void *buf, size_t size)
+{
+   ps3_audio_t *aud = data;
+
+   if (aud->nonblocking)
+   {
+      if (fifo_write_avail(aud->buffer) < size)
+         return 0;
+   }
+   else
+   {
+      while (fifo_write_avail(aud->buffer) < size)
+         sys_lwcond_wait(&aud->cond, 0);
+   }
+
+   sys_lwmutex_lock(&aud->lock, SYS_NO_TIMEOUT);
+   fifo_write(aud->buffer, buf, size);
+   sys_lwmutex_unlock(&aud->lock);
+   return size;
+}
+
+static bool ps3_audio_stop(void *data)
+{
+   ps3_audio_t *aud = data;
+   cellAudioPortStop(aud->audio_port);
+   return true;
+}
+
+static bool ps3_audio_start(void *data)
+{
+   ps3_audio_t *aud = data;
+   cellAudioPortStart(aud->audio_port);
+   return true;
+}
+
+static void ps3_audio_set_nonblock_state(void *data, bool state)
+{
+   ps3_audio_t *aud = data;
+   aud->nonblocking = state;
+}
+
+static void ps3_audio_free(void *data)
+{
+   ps3_audio_t *aud = data;
+
+   aud->quit_thread = true;
+   cellAudioPortStart(aud->audio_port);
+   pthread_join(aud->thread, NULL);
+
+   cellAudioPortStop(aud->audio_port);
+   cellAudioPortClose(aud->audio_port);
+   cellAudioQuit();
+   fifo_free(aud->buffer);
+
+   sys_lwmutex_destroy(&aud->lock);
+   sys_lwmutex_destroy(&aud->cond_lock);
+   sys_lwcond_destroy(&aud->cond);
+
+   free(data);
+}
+
+static bool ps3_audio_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+const audio_driver_t audio_ps3 = {
+   .init = ps3_audio_init,
+   .write = ps3_audio_write,
+   .stop = ps3_audio_stop,
+   .start = ps3_audio_start,
+   .set_nonblock_state = ps3_audio_set_nonblock_state,
+   .use_float = ps3_audio_use_float,
+   .free = ps3_audio_free,
+   .ident = "ps3"
+};
+

ps3/ps3_input.c

@@ -0,0 +1,142 @@
+/*  SSNES - A Super Ninteno Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011 - Daniel De Matteis
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "../driver.h"
+#include "pad_input.h"
+#include <stdint.h>
+#include "../libsnes.hpp"
+
+#include <stdlib.h>
+
+static uint64_t state[5];
+static void ps3_input_poll(void *data)
+{
+   (void)data;
+   for (unsigned i = 0; i < 5; i++)
+      state[i] = cell_pad_input_poll_device(i);
+}
+
+static int16_t ps3_input_state(void *data, const struct snes_keybind **binds,
+      bool port, unsigned device,
+      unsigned index, unsigned id)
+{
+   (void)data;
+   (void)binds;
+   (void)index;
+
+   if (device != SNES_DEVICE_JOYPAD)
+      return 0;
+
+   unsigned player = 0;
+   if (port == SNES_PORT_2 && device == SNES_DEVICE_MULTITAP)
+      player = index + 1;
+   else if (port == SNES_PORT_2)
+      player = 1;
+
+   // Hardcoded binds.
+   uint64_t button;
+   switch (id)
+   {
+      case SNES_DEVICE_ID_JOYPAD_A:
+         button = CTRL_CIRCLE_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_B:
+         button = CTRL_CROSS_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_X:
+         button = CTRL_TRIANGLE_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_Y:
+         button = CTRL_SQUARE_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_LEFT:
+         button = CTRL_LEFT_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_RIGHT:
+         button = CTRL_RIGHT_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_UP:
+         button = CTRL_UP_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_DOWN:
+         button = CTRL_DOWN_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_START:
+         button = CTRL_START_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_SELECT:
+         button = CTRL_SELECT_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_L:
+         button = CTRL_L1_MASK;
+         break;
+      case SNES_DEVICE_ID_JOYPAD_R:
+         button = CTRL_R1_MASK;
+         break;
+      default:
+         button = 0;
+   }
+
+   return CTRL_MASK(state[player], button) ? 1 : 0;
+}
+
+static void ps3_free_input(void *data)
+{
+   (void)data;
+   cell_pad_input_deinit();
+}
+
+static void* ps3_input_init(void)
+{
+   cell_pad_input_init();
+   return (void*)-1;
+}
+
+static bool ps3_key_pressed(void *data, int key)
+{
+   (void)data;
+   switch(key)
+   {
+      case SSNES_FAST_FORWARD_HOLD_KEY:
+         return CTRL_RSTICK_UP(state[0]) && CTRL_R2(~state[0]);
+      case SSNES_LOAD_STATE_KEY:
+         return (CTRL_RSTICK_UP(state[0]) && CTRL_R2(state[0]));
+      case SSNES_SAVE_STATE_KEY:
+         return (CTRL_RSTICK_DOWN(state[0]) && CTRL_R2(state[0]));
+      case SSNES_STATE_SLOT_PLUS:
+         return (CTRL_RSTICK_RIGHT(state[0]) && CTRL_R2(state[0]));
+      case SSNES_STATE_SLOT_MINUS:
+         return (CTRL_RSTICK_LEFT(state[0]) && CTRL_R2(state[0]));
+      case SSNES_REWIND:
+         return CTRL_RSTICK_DOWN(state[0]) && CTRL_R2(~state[0]);
+      default:
+         break;
+   }
+
+   return false;
+}
+
+const input_driver_t input_ps3 = {
+   .init = ps3_input_init,
+   .poll = ps3_input_poll,
+   .input_state = ps3_input_state,
+   .key_pressed = ps3_key_pressed,
+   .free = ps3_free_input,
+   .ident = "ps3",
+};