Updates for 0.8.1.

Does not need to bump ABI version.

Makefile

@@ -2,8 +2,8 @@ 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 strl.o screenshot.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 autosave.o gfx/gfx_common.o ups.o bps.o strl.o screenshot.o
+JOYCONFIG_OBJ = tools/ssnes-joyconfig.o conf/config_file.o strl.o
 HEADERS = $(wildcard */*.h) $(wildcard *.h)
 
 LIBS = -lm
@@ -172,11 +172,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)

Makefile.win

@@ -1,47 +1,40 @@
 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 strl.o screenshot.o
-JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o
+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 bps.o ups.o strl.o screenshot.o audio/hermite.o
+JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o strl.o
 
 CC = gcc
 CXX = g++
 
 HAVE_DINPUT = 1
-HAVE_SRC = 0
-HAVE_SDL = 1
-HAVE_SDL_IMAGE = 1
-HAVE_XML = 1
-HAVE_FREETYPE = 1
 HAVE_XAUDIO = 1
 HAVE_DSOUND = 1
-HAVE_RSOUND = 1
+HAVE_SDL = 1
 HAVE_DYLIB = 1
 HAVE_NETPLAY = 1
-HAVE_FBO = 1
-HAVE_CG = 1
-HAVE_PYTHON = 1
-HAVE_FFMPEG = 0
+
+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
+LIBS = -lm -lshlwapi
 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
+LDCXXFLAGS = -static-libstdc++
 
 ifeq ($(HAVE_SDL), 1)
    OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
-   LIBS += $(SDL_LIBS) -lopengl32
-   DEFINES += $(SDL_CFLAGS) -DHAVE_SDL
+   LIBS += -lSDL -lopengl32
+   DEFINES += -ISDL -DHAVE_SDL
 endif
 
 ifeq ($(HAVE_SDL_IMAGE), 1)
@@ -56,8 +49,9 @@ ifeq ($(HAVE_CG), 1)
 endif
 
 ifeq ($(HAVE_XAUDIO), 1)
-   OBJ += audio/xaudio.o
+   OBJ += audio/xaudio.o audio/xaudio-c/xaudio-c.o
    DEFINES += -DHAVE_XAUDIO
+   LIBS += -lole32
 endif
 
 ifeq ($(HAVE_DSOUND), 1)
@@ -74,8 +68,8 @@ endif
 
 ifeq ($(HAVE_XML), 1)
    OBJ += gfx/shader_glsl.o gfx/image.o gfx/snes_state.o sha256.o cheats.o
-   DEFINES += $(XML_CFLAGS) -DHAVE_XML
-   LIBS += -lxml2
+   DEFINES += -Ilibxml2 -DHAVE_XML
+   LIBS += -lxml2 -liconv
 endif
 
 ifeq ($(HAVE_DYLIB), 1)
@@ -91,7 +85,7 @@ endif
 ifeq ($(HAVE_FREETYPE), 1)
    OBJ += gfx/fonts.o
    DEFINES += -DHAVE_FREETYPE -Ifreetype2
-   LIBS += -lz -lfreetype6
+   LIBS += -lfreetype -lz
 endif
 
 ifeq ($(DYNAMIC), 1)
@@ -116,13 +110,13 @@ endif
 
 ifeq ($(HAVE_DINPUT), 1)
    LIBS += -ldinput8 -ldxguid -lole32
-   DEFINES += -DHAVE_DINPUT -Iffmpeg
+   DEFINES += -DHAVE_DINPUT
    OBJ += input/dinput.o
 endif
 
 ifeq ($(HAVE_FFMPEG), 1)
-   LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lzlib1
-   DEFINES += -DHAVE_FFMPEG
+   LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lz
+   DEFINES += -DHAVE_FFMPEG -Iffmpeg
    OBJ += record/ffemu.o
 endif
 
@@ -130,42 +124,53 @@ ifneq ($(V),1)
    Q := @
 endif
 
-
-CFLAGS = -Wall -O3 -std=gnu99 -I.
+CFLAGS += -Wall -O3 -std=gnu99 -I.
+CXXFLAGS += -Wall -O3 -pedantic -I.
 
 all: $(TARGET) $(JTARGET)
 
 $(TARGET): $(OBJ)
-	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS)
+	$(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) $(SDL_LIBS) $(LDFLAGS)
+	$(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 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.7.zip $(TARGET) ssnes.cfg snes.dll libxml2.dll iconv.dll zlib1.dll SDL.dll freetype6.dll xaudio-c.dll rsound.dll pthreadGC2.dll cg.dll cgGL.dll libjpeg-8.dll libpng15-15.dll python32.dll SDL_image.dll $(JTARGET)
+dist_x86: all
+	zip -r ssnes-win32-0.8.1.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
 
-libs:
+dist_x86_64: all
+	zip -r ssnes-win64-0.8.1.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
 
-.PHONY: all install uninstall clean dist libs
+libs_x86_64:
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win64-libs.zip --no-check-certificate
+	unzip SSNES-win64-libs.zip
+
+.PHONY: all install uninstall clean dist_x86 dist_x86_64 libs_x86 libs_x86_64

Makefile.win64

@@ -1,158 +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 strl.o screenshot.o
-JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o
-
-CC = gcc
-CXX = g++
-
-HAVE_DINPUT = 1
-HAVE_SRC = 0
-HAVE_SDL = 1
-HAVE_XML = 1
-HAVE_FREETYPE = 1
-HAVE_XAUDIO = 1
-HAVE_DSOUND = 1
-HAVE_RSOUND = 0
-HAVE_DYLIB = 1
-HAVE_NETPLAY = 1
-HAVE_FBO = 1
-HAVE_CG = 0
-HAVE_PYTHON = 0
-libsnes ?= -lsnes
-
-LIBS = -lm
-DEFINES = -I. -DHAVE_CONFIGFILE
-LDFLAGS = -L. -static-libgcc -s
-
-SRC_LIBS = -lsamplerate-0
-SDL_LIBS = -lmingw32 -lSDL -lSDLmain -lwinmm -mwindows -lm -luser32 -lgdi32 -lwinmm -ldxguid
-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/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
-   LIBS += $(SDL_LIBS) -lopengl32 
-   DEFINES += $(SDL_CFLAGS) -DHAVE_SDL
-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
-   DEFINES += -DHAVE_XAUDIO
-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 += $(XML_CFLAGS) -DHAVE_XML -DLIBXML_STATIC
-   LIBS += -lxml2 -lz -lws2_32
-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 += -lz -lfreetype6
-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
-
-
-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-win64-0.7.zip $(TARGET) ssnes.cfg snes.dll xaudio-c.dll README.win32.txt $(JTARGET)
-
-libs:
-	wget https://github.com/downloads/Themaister/SSNES/ssnes-win64-libs.zip --no-check-certificate
-	unzip ssnes-win64-libs.zip
-
-.PHONY: all install uninstall clean dist libs

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.cpp

@@ -0,0 +1,164 @@
+/*
+	Simple C interface for XAudio2
+	Author: Hans-Kristian Arntzen
+	License: Public Domain
+*/
+
+#include "xaudio-c.h"
+#include "xaudio2.hpp"
+#include <stdint.h>
+#include <algorithm>
+
+struct xaudio2 : public IXAudio2VoiceCallback
+{
+   xaudio2(unsigned samplerate, unsigned channels, unsigned size) : 
+      buf(0), pXAudio2(0), pMasterVoice(0), pSourceVoice(0),
+      buffers(0), bufptr(0)
+   {
+      CoInitializeEx(0, COINIT_MULTITHREADED);
+      if (FAILED(XAudio2Create(&pXAudio2, 0)))
+         throw -1;
+      if (FAILED(pXAudio2->CreateMasteringVoice(
+                  &pMasterVoice, channels, samplerate, 0, 0, 0)))
+         throw -1;
+
+      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(pXAudio2->CreateSourceVoice(
+                  &pSourceVoice, &wfx, XAUDIO2_VOICE_NOSRC, XAUDIO2_DEFAULT_FREQ_RATIO, this, 0, 0)))
+         throw -1;
+
+      hEvent = CreateEvent(0, FALSE, FALSE, 0);
+      if (!hEvent)
+         throw -1;
+
+      pSourceVoice->Start(0);
+
+      bufsize = size / max_buffers;
+      buf = new uint8_t[bufsize * max_buffers];
+      write_buffer = 0;
+   }
+
+   virtual ~xaudio2()
+   {
+      if (pSourceVoice)
+      {
+         pSourceVoice->Stop(0);
+         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_)
+   {
+      unsigned bytes = bytes_;
+      const uint8_t *buffer = reinterpret_cast<const uint8_t*>(buffer_);
+      while (bytes > 0)
+      {
+         unsigned need = std::min(bytes, bufsize - bufptr);
+         memcpy(buf + write_buffer * bufsize + bufptr,
+               buffer, need);
+
+         bufptr += need;
+         buffer += need;
+         bytes -= need;
+
+         if (bufptr == bufsize)
+         {
+            WaitForSingleObject(hEvent, 0); // Clear out ready state.
+            while (buffers == max_buffers - 1)
+               WaitForSingleObject(hEvent, INFINITE);
+
+            XAUDIO2_BUFFER xa2buffer = {0};
+            xa2buffer.AudioBytes = bufsize;
+            xa2buffer.pAudioData = buf + write_buffer * bufsize;
+            xa2buffer.pContext = 0;
+            if (FAILED(pSourceVoice->SubmitSourceBuffer(&xa2buffer)))
+               return 0;
+
+            InterlockedIncrement(&buffers);
+            bufptr = 0;
+            write_buffer = (write_buffer + 1) & (max_buffers_mask);
+         }
+      }
+
+      return bytes_;
+   }
+
+   enum { max_buffers = 16, max_buffers_mask = max_buffers - 1 };
+
+   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) () {}
+   STDMETHOD_(void, OnVoiceProcessingPassStart) (UINT32) {}
+
+   uint8_t *buf;
+   IXAudio2 *pXAudio2;
+   IXAudio2MasteringVoice *pMasterVoice;
+   IXAudio2SourceVoice *pSourceVoice;
+   HANDLE hEvent;
+
+   volatile long buffers;
+   unsigned bufsize;
+   unsigned bufptr;
+   unsigned write_buffer;
+};
+
+xaudio2_t *xaudio2_new(unsigned samplerate, unsigned channels, size_t size)
+{
+   xaudio2 *handle = 0;
+   try {
+      handle = new xaudio2(samplerate, channels, size);
+   } catch(...) { delete handle; return 0; }
+
+   return handle;
+}
+
+size_t xaudio2_write_avail(xaudio2_t *handle)
+{
+   try {
+      return handle->write_avail();
+   } catch(...) { return 0; }
+}
+
+size_t xaudio2_write(xaudio2_t *handle, const void *buf, size_t bytes)
+{
+   try {
+      return handle->write(buf, bytes);
+   } catch(...) { return 0; }
+}
+
+void xaudio2_free(xaudio2_t *handle)
+{
+   delete 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/xaudio2.hpp

@@ -0,0 +1,329 @@
+/*
+   xaudio2.hpp (2010-08-14)
+   author: OV2
+*/
+
+#ifndef XAUDIO2_MINGW_H
+#define XAUDIO2_MINGW_H
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef min
+#undef max
+#include <basetyps.h>
+#include <objbase.h>
+#include <mmreg.h>
+
+// 64-bit GCC fix
+#define GUID_EXT EXTERN_C
+#define GUID_SECT
+
+#define DEFINE_GUID_X(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) GUID_EXT const GUID n GUID_SECT = {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) =x
+
+DEFINE_CLSID_X(XAudio2, e21a7345, eb21, 468e, be, 50, 80, 4d, b9, 7c, f7, 08);
+DEFINE_CLSID_X(XAudio2_Debug, f7a76c21, 53d4, 46bb, ac, 53, 8b, 45, 9c, ae, 46, bd);
+DEFINE_IID_X(IXAudio2, 8bcf1f58, 9fe7, 4583, 8a, c6, e2, ad, c4, 65, c8, bb);
+
+DECLARE_INTERFACE(IXAudio2Voice);
+
+#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 struct XAUDIO2_DEVICE_DETAILS
+{
+   WCHAR DeviceID[256];
+   WCHAR DisplayName[256];
+   XAUDIO2_DEVICE_ROLE Role;
+   WAVEFORMATEXTENSIBLE OutputFormat;
+} XAUDIO2_DEVICE_DETAILS;
+
+typedef struct XAUDIO2_VOICE_DETAILS
+{
+   UINT32 CreationFlags;
+   UINT32 InputChannels;
+   UINT32 InputSampleRate;
+} XAUDIO2_VOICE_DETAILS;
+
+typedef enum XAUDIO2_WINDOWS_PROCESSOR_SPECIFIER
+{
+   Processor1  = 0x00000001,
+   Processor2  = 0x00000002,
+   Processor3  = 0x00000004,
+   Processor4  = 0x00000008,
+   Processor5  = 0x00000010,
+   Processor6  = 0x00000020,
+   Processor7  = 0x00000040,
+   Processor8  = 0x00000080,
+   Processor9  = 0x00000100,
+   Processor10 = 0x00000200,
+   Processor11 = 0x00000400,
+   Processor12 = 0x00000800,
+   Processor13 = 0x00001000,
+   Processor14 = 0x00002000,
+   Processor15 = 0x00004000,
+   Processor16 = 0x00008000,
+   Processor17 = 0x00010000,
+   Processor18 = 0x00020000,
+   Processor19 = 0x00040000,
+   Processor20 = 0x00080000,
+   Processor21 = 0x00100000,
+   Processor22 = 0x00200000,
+   Processor23 = 0x00400000,
+   Processor24 = 0x00800000,
+   Processor25 = 0x01000000,
+   Processor26 = 0x02000000,
+   Processor27 = 0x04000000,
+   Processor28 = 0x08000000,
+   Processor29 = 0x10000000,
+   Processor30 = 0x20000000,
+   Processor31 = 0x40000000,
+   Processor32 = 0x80000000,
+   XAUDIO2_ANY_PROCESSOR = 0xffffffff,
+   XAUDIO2_DEFAULT_PROCESSOR = XAUDIO2_ANY_PROCESSOR
+} XAUDIO2_WINDOWS_PROCESSOR_SPECIFIER, XAUDIO2_PROCESSOR;
+
+typedef struct XAUDIO2_VOICE_SENDS
+{
+   UINT32 OutputCount;
+   IXAudio2Voice** pOutputVoices;
+} XAUDIO2_VOICE_SENDS;
+
+typedef struct XAUDIO2_EFFECT_DESCRIPTOR
+{
+   IUnknown* pEffect;
+   BOOL InitialState;
+   UINT32 OutputChannels;
+} XAUDIO2_EFFECT_DESCRIPTOR;
+
+typedef struct XAUDIO2_EFFECT_CHAIN
+{
+   UINT32 EffectCount;
+   const XAUDIO2_EFFECT_DESCRIPTOR* pEffectDescriptors;
+} XAUDIO2_EFFECT_CHAIN;
+
+typedef enum XAUDIO2_FILTER_TYPE
+{
+   LowPassFilter,
+   BandPassFilter,
+   HighPassFilter
+} XAUDIO2_FILTER_TYPE;
+
+typedef struct XAUDIO2_FILTER_PARAMETERS
+{
+   XAUDIO2_FILTER_TYPE Type;
+   float Frequency;
+   float OneOverQ;
+
+} XAUDIO2_FILTER_PARAMETERS;
+
+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;
+
+typedef struct XAUDIO2_BUFFER_WMA
+{
+   const UINT32* pDecodedPacketCumulativeBytes;
+   UINT32 PacketCount;
+} XAUDIO2_BUFFER_WMA;
+
+typedef struct XAUDIO2_VOICE_STATE
+{
+   void* pCurrentBufferContext;
+   UINT32 BuffersQueued;
+   UINT64 SamplesPlayed;
+} XAUDIO2_VOICE_STATE;
+
+typedef struct XAUDIO2_PERFORMANCE_DATA
+{
+   UINT64 AudioCyclesSinceLastQuery;
+   UINT64 TotalCyclesSinceLastQuery;
+   UINT32 MinimumCyclesPerQuantum;
+   UINT32 MaximumCyclesPerQuantum;
+   UINT32 MemoryUsageInBytes;
+   UINT32 CurrentLatencyInSamples;
+   UINT32 GlitchesSinceEngineStarted;
+   UINT32 ActiveSourceVoiceCount;
+   UINT32 TotalSourceVoiceCount;
+   UINT32 ActiveSubmixVoiceCount;
+   UINT32 TotalSubmixVoiceCount;
+   UINT32 ActiveXmaSourceVoices;
+   UINT32 ActiveXmaStreams;
+} XAUDIO2_PERFORMANCE_DATA;
+
+typedef struct XAUDIO2_DEBUG_CONFIGURATION
+{
+   UINT32 TraceMask;
+   UINT32 BreakMask;
+   BOOL LogThreadID;
+   BOOL LogFileline;
+   BOOL LogFunctionName;
+   BOOL LogTiming;
+} XAUDIO2_DEBUG_CONFIGURATION;
+
+DECLARE_INTERFACE(IXAudio2EngineCallback)
+{
+   STDMETHOD_(void, OnProcessingPassStart) (THIS) PURE;
+   STDMETHOD_(void, OnProcessingPassEnd) (THIS) PURE;
+   STDMETHOD_(void, OnCriticalError) (THIS_ HRESULT Error) PURE;
+};
+
+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_(IXAudio2SubmixVoice, 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;
+};
+
+static inline HRESULT XAudio2Create(IXAudio2** ppXAudio2, UINT32 Flags X2DEFAULT(0),
+      XAUDIO2_PROCESSOR XAudio2Processor X2DEFAULT(XAUDIO2_DEFAULT_PROCESSOR))
+{
+   IXAudio2* pXAudio2;
+   HRESULT hr = CoCreateInstance((Flags & XAUDIO2_DEBUG_ENGINE) ? CLSID_XAudio2_Debug : CLSID_XAudio2,
+         NULL, CLSCTX_INPROC_SERVER, IID_IXAudio2, reinterpret_cast<void**>(&pXAudio2));
+
+   if (SUCCEEDED(hr))
+   {
+      hr = pXAudio2->Initialize(Flags, XAudio2Processor);
+      if (SUCCEEDED(hr))
+         *ppXAudio2 = pXAudio2;
+      else
+         pXAudio2->Release();
+   }
+   return hr;
+}
+
+#endif
+

audio/xaudio.c

@@ -15,63 +15,19 @@
  *  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)
-{
-   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, unsigned rate, unsigned latency)
 {
-   if (!init_lib())
-      return NULL;
-
    if (latency < 8)
       latency = 8; // Do not allow shenanigans.
 
@@ -80,11 +36,10 @@ static void* __xa_init(const char* device, unsigned rate, unsigned latency)
       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");
@@ -99,11 +54,16 @@ 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)
@@ -124,16 +84,21 @@ static bool __xa_start(void *data)
    return true;
 }
 
+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 = {
@@ -142,12 +107,8 @@ const audio_driver_t audio_xa = {
    .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

@@ -42,6 +42,9 @@ struct autosave
 static int autosave_thread(void *data)
 {
    autosave_t *save = data;
+
+   bool first_log = true;
+
    while (!save->quit)
    {
       autosave_lock(save);
@@ -52,7 +55,13 @@ static int autosave_thread(void *data)
       FILE *file = fopen(save->path, "wb");
       if (file)
       {
-         SSNES_LOG("Autosaving SRAM to \"%s\"\n", save->path);
+         // Avoid spamming down stderr ... :)
+         if (first_log)
+         {
+            SSNES_LOG("Autosaving SRAM to \"%s\", will continue to autosave every %u seconds ...\n", save->path, save->interval);
+            first_log = false;
+         }
+
          bool failed = false;
          failed |= fwrite(save->buffer, 1, save->bufsize, file) != save->bufsize;
          failed |= fflush(file) != 0;

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

@@ -21,10 +21,17 @@
 #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 <assert.h>
 
 #include <libxml/parser.h>
 #include <libxml/tree.h>
@@ -51,7 +58,8 @@ static char* strcat_alloc(char *dest, const char *input)
    size_t required_len = dest_len + input_len + 1;
 
    char *output = realloc(dest, required_len);
-   assert(output);
+   if (!output)
+      return NULL;
 
    if (dest)
       strlcat(output, input, required_len);
@@ -61,62 +69,175 @@ static char* strcat_alloc(char *dest, const char *input)
    return output;
 }
 
-static void xml_grab_cheat(struct cheat *cht, xmlNodePtr ptr)
+static bool xml_grab_cheat(struct cheat *cht, xmlNodePtr ptr)
 {
+   if (!ptr)
+      return false;
+
    memset(cht, 0, sizeof(struct cheat));
    bool first = true;
-   for (xmlNodePtr node = ptr; node; node = node->next)
+
+   for (; ptr; ptr = ptr->next)
    {
-      if (strcmp((const char*)node->name, "description") == 0)
+      if (strcmp((const char*)ptr->name, "description") == 0)
       {
-         cht->desc = (char*)xmlNodeGetContent(node);
+         cht->desc = (char*)xmlNodeGetContent(ptr);
       }
-      else if (strcmp((const char*)node->name, "code") == 0)
+      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(node);
-         assert(code);
+         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 void xml_grab_cheats(cheat_manager_t *handle, xmlNodePtr ptr)
+static bool xml_grab_cheats(cheat_manager_t *handle, xmlNodePtr ptr)
 {
-   xmlNodePtr node = NULL;
-   for (node = ptr; node; node = node->next)
+   for (; ptr; ptr = ptr->next)
    {
-      if (strcmp((const char*)node->name, "name") == 0)
+      if (strcmp((const char*)ptr->name, "name") == 0)
       {
-         xmlChar *name = xmlNodeGetContent(node);
+         xmlChar *name = xmlNodeGetContent(ptr);
          if (name)
          {
             SSNES_LOG("Found cheat for game: \"%s\"\n", name);
             xmlFree(name);
          }
       }
-      else if (strcmp((const char*)node->name, "cheat") == 0)
+      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));
-            assert(handle->cheats);
+            if (!handle->cheats)
+               return false;
          }
 
-         xml_grab_cheat(&handle->cheats[handle->size++], node->children);
+         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;
@@ -125,8 +246,8 @@ cheat_manager_t* cheat_manager_new(const char *path)
    if (!handle)
       return NULL;
 
-   handle->buf_size = 32;
-   handle->cheats = malloc(handle->buf_size * sizeof(struct cheat));
+   handle->buf_size = 1;
+   handle->cheats = calloc(handle->buf_size, sizeof(struct cheat));
    if (!handle->cheats)
    {
       handle->buf_size = 0;
@@ -172,7 +293,7 @@ cheat_manager_t* cheat_manager_new(const char *path)
          if (!sha256)
             continue;
 
-         if (memcmp(sha256, g_extern.sha256, 64) == 0)
+         if (strcmp((const char*)sha256, g_extern.sha256) == 0)
          {
             xmlFree(sha256);
             break;
@@ -185,7 +306,19 @@ cheat_manager_t* cheat_manager_new(const char *path)
    if (!cur)
       goto error;
 
-   xml_grab_cheats(handle, cur->children);
+   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);
@@ -207,6 +340,7 @@ void cheat_manager_free(cheat_manager_t *handle)
 
    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);
@@ -228,18 +362,11 @@ static void cheat_manager_update(cheat_manager_t *handle)
    SSNES_LOG("%s\n", msg);
 }
 
+
 void cheat_manager_toggle(cheat_manager_t *handle)
 {
    handle->cheats[handle->ptr].state ^= true;
-
-   unsigned index = 0;
-   psnes_cheat_reset();
-   for (unsigned i = 0; i < handle->size; i++)
-   {
-      if (handle->cheats[handle->ptr].state)
-         psnes_cheat_set(index++, true, handle->cheats[handle->ptr].code);
-   }
-
+   cheat_manager_apply_cheats(handle);
    cheat_manager_update(handle);
 }
 

conf/config_file.c

@@ -21,6 +21,8 @@
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <errno.h>
+#include "strl.h"
 
 struct entry_list
 {
@@ -215,8 +217,15 @@ bool config_get_int(config_file_t *conf, const char *key, int *in)
    {
       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;
    }
@@ -231,8 +240,15 @@ bool config_get_hex(config_file_t *conf, const char *key, unsigned *in)
    {
       if (strcmp(key, list->key) == 0)
       {
-         *in = strtol(list->value, NULL, 16);
-         return true;
+         errno = 0;
+         unsigned val = strtoul(list->value, NULL, 16);
+         if (errno == 0)
+         {
+            *in = val;
+            return true;
+         }
+         else
+            return false;
       }
       list = list->next;
    }
@@ -247,7 +263,7 @@ bool config_get_char(config_file_t *conf, const char *key, char *in)
    {
       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;
@@ -273,6 +289,22 @@ 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 != NULL)
+   {
+      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;

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;
 
@@ -48,6 +49,8 @@ bool config_get_hex(config_file_t *conf, const char *entry, unsigned *in);
 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);
 

config.def.h

@@ -150,6 +150,8 @@ 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 = 0xffffff; // RGB hex value.
 
 // Render-to-texture before rendering to screen (multi-pass shaders)
 static const bool render_to_texture = false;
@@ -222,7 +224,7 @@ static const bool netplay_client_swap_input = true;
 
 // 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

docs/ssnes.1

@@ -32,12 +32,16 @@ Prints help text.
 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
@@ -49,6 +53,9 @@ Always starts SSNES in fullscreen. Disregards settings in configuration file.
 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.
@@ -105,7 +112,8 @@ 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/FLAC, suitable for processing the material further.
 
 .TP
 \fB--bsvplay PATH, -P PATH\fR
@@ -138,6 +146,11 @@ 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.

driver.h

@@ -27,7 +27,7 @@
 
 enum
 {
-   SSNES_FAST_FORWARD_KEY = 0x666, // Hurr, durr
+   SSNES_FAST_FORWARD_KEY = 12, // SNES has 12 buttons from 0-11 (libsnes.hpp)
    SSNES_FAST_FORWARD_HOLD_KEY,
    SSNES_LOAD_STATE_KEY,
    SSNES_SAVE_STATE_KEY,
@@ -47,7 +47,9 @@ enum
    SSNES_CHEAT_INDEX_MINUS,
    SSNES_CHEAT_TOGGLE,
    SSNES_SCREENSHOT,
-   SSNES_DSP_CONFIG
+   SSNES_DSP_CONFIG,
+
+   SSNES_BIND_LIST_END
 };
 
 

dynamic.c

@@ -184,6 +184,26 @@ void init_dlsym(void)
    assert(sizeof(void*) == sizeof(void (*)(void)));
 
 #ifdef HAVE_DYNAMIC
+
+#ifndef _WIN32 // Try to verify that -lsnes was not linked in from other modules
+               // since loading it dynamically and with -l will fail hard.
+   void *lib = dlopen(NULL, RTLD_LAZY);
+   if (lib)
+   {
+      void *sym = dlsym(lib, "snes_init");
+      if (sym)
+      {
+         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");
+         dlclose(lib);
+         exit(1);
+      }
+
+      dlclose(lib);
+   }
+#endif
+
    if (strlen(g_settings.libsnes) > 0)
       load_dynamic();
    else

file.c

@@ -21,9 +21,12 @@
 #include <stdbool.h>
 #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
@@ -34,8 +37,10 @@
 #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
 
@@ -116,6 +121,114 @@ error:
    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)
 {
@@ -183,37 +296,6 @@ 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 in: \"%s\".\n", g_extern.ups_name);
-
    // Remove copier header if present (512 first bytes).
    if ((ret & 0x7fff) == 512)
    {
@@ -221,6 +303,9 @@ static ssize_t read_rom_file(FILE* file, void** buf)
       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);
@@ -239,13 +324,72 @@ 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");
+#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();
@@ -268,7 +412,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;
@@ -288,7 +432,7 @@ bool load_state(const char* path)
    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);
@@ -304,13 +448,20 @@ void load_ram_file(const char* path, int type)
    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 (!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)
@@ -585,8 +736,6 @@ bool init_rom_file(enum ssnes_game_type type)
 // Yep, this is C alright ;)
 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;
@@ -595,18 +744,18 @@ 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;
+   if (strlcat(utf8_buf, ext, sizeof(utf8_buf)) >= sizeof(utf8_buf))
+      goto error;
 
-   wchar_t wchar_buf[MAX_PATH + 1];
-   char utf8_buf[MAX_PATH + 3];
-
-   strlcpy(utf8_buf, dir, sizeof(utf8_buf));
-   strlcat(utf8_buf, "/*", sizeof(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)
@@ -614,7 +763,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)
@@ -635,8 +783,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, MAX_PATH, NULL, NULL) == 0)
+         continue;
       if (ext && !strstr(utf8_buf, ext))
          continue;
 #else
@@ -644,16 +792,16 @@ 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;
 
-      strlcpy(dir_list[cur_ptr], dir, final_off);
-      strlcat(dir_list[cur_ptr], "/", final_off);
+      strlcpy(dir_list[cur_ptr], dir, MAXPATHLEN);
+      strlcat(dir_list[cur_ptr], "/", MAXPATHLEN);
 #ifdef _WIN32
-      strlcat(dir_list[cur_ptr], utf8_buf, final_off);
+      strlcat(dir_list[cur_ptr], utf8_buf, MAXPATHLEN);
 #else
-      strlcat(dir_list[cur_ptr], entry->d_name, final_off);
+      strlcat(dir_list[cur_ptr], entry->d_name, MAXPATHLEN);
 #endif
 
       cur_ptr++;
@@ -670,7 +818,6 @@ char** dir_list_new(const char *dir, const char *ext)
    }
 #ifdef _WIN32
    while (FindNextFileW(hFind, &ffd) != 0);
-
 #endif
 
 #ifdef _WIN32
@@ -703,3 +850,64 @@ 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;
+#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[strlen(in_path) + 1];
+   strlcpy(tmp_path, in_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

@@ -28,11 +28,11 @@
 
 ssize_t read_file(const char *path, void **buf);
 
-bool load_state(const char* path);
-bool save_state(const char* path);
+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);
+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);
 
@@ -40,4 +40,16 @@ bool init_rom_file(enum ssnes_game_type type);
 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

@@ -42,9 +42,20 @@
 #include "audio/hermite.h"
 #endif
 
+#ifndef _WIN32
+#include <sys/param.h> // MAXPATHLEN
+#endif
+
+#ifndef MAXPATHLEN
+#ifdef PATH_MAX
+#define MAXPATHLEN PATH_MAX
+#else
+#define MAXPATHLEN 512
+#endif
+#endif
 
 #define MAX_PLAYERS 5
-#define MAX_BINDS 34 // 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
@@ -71,22 +82,25 @@ struct settings
       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;
 
       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;
       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;
@@ -94,7 +108,7 @@ struct settings
       bool hires_record;
       bool post_filter_record;
 
-      char external_driver[256];
+      char external_driver[MAXPATHLEN];
    } video;
 
    struct
@@ -104,13 +118,13 @@ 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[256];
-      char external_driver[256];
+      char dsp_plugin[MAXPATHLEN];
+      char external_driver[MAXPATHLEN];
    } audio;
 
    struct
@@ -122,10 +136,11 @@ struct settings
       bool netplay_client_swap_input;
    } input;
 
-   char libsnes[256];
-   char cheat_database[256];
+   char libsnes[MAXPATHLEN];
+   char cheat_database[MAXPATHLEN];
+   char cheat_settings_path[MAXPATHLEN];
 
-   char screenshot_directory[256];
+   char screenshot_directory[MAXPATHLEN];
 
    bool rewind_enable;
    unsigned rewind_buffer_size;
@@ -164,25 +179,29 @@ struct global
    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 xml_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;
 
@@ -233,7 +252,7 @@ struct global
 
    // Movie record support
    bsv_movie_t *bsv_movie;
-   char bsv_movie_path[256];
+   char bsv_movie_path[MAXPATHLEN];
    bool bsv_movie_end;
    bool bsv_movie_playback;
 
@@ -245,7 +264,7 @@ struct global
 
    // Netplay.
    netplay_t *netplay;
-   char netplay_server[256];
+   char netplay_server[MAXPATHLEN];
    bool netplay_enable;
    bool netplay_is_client;
    unsigned netplay_sync_frames;
@@ -254,7 +273,7 @@ struct global
    // FFmpeg record.
 #ifdef HAVE_FFMPEG
    ffemu_t *rec;
-   char record_path[256];
+   char record_path[MAXPATHLEN];
    bool recording;
 #endif
 

gfx/ext.c

@@ -232,6 +232,12 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
    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);
 
    ssnes_video_info_t info = {
       .width = video->width,
@@ -246,7 +252,8 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
       .xml_shader = xml_shader,
       .cg_shader = cg_shader,
       .ttf_font = *g_settings.video.font_path ? g_settings.video.font_path : NULL,
-      .ttf_font_size = g_settings.video.font_size
+      .ttf_font_size = g_settings.video.font_size,
+      .ttf_font_color = (font_color_r << 16) | (font_color_g << 8) | (font_color_b << 0),
    };
 
    const ssnes_input_driver_t *input_driver = NULL;

gfx/ext/ssnes_video.h

@@ -108,7 +108,7 @@ typedef struct ssnes_video_info
    // Can be disregarded.
    const char *ttf_font;
    unsigned ttf_font_size;
-
+   unsigned ttf_font_color; // Font color, in format RGB888.
 } ssnes_video_info_t;
 
 // Some convenience macros.

gfx/gfx_common.c

@@ -116,17 +116,9 @@ void gfx_set_dwm(void)
 #include "SDL_syswm.h"
 #include "SDL.h"
 
+#if !defined(__APPLE__) && !defined(_WIN32)
 void gfx_get_window_size(unsigned *width, unsigned *height)
 {
-#if defined(__APPLE__) || defined(_WIN32)
-   SDL_Event evnt;
-   while (SDL_PollEvent(&evnt));
-   const SDL_VideoInfo *info = SDL_GetVideoInfo();
-   *width = info->current_w;
-   *height = info->current_h;
-#else
-   // It seems that we need to go hardcore to get the actual
-   // window sizes properly right after startup ... :D
    SDL_SysWMinfo info;
    SDL_VERSION(&info.version);
    SDL_GetWMInfo(&info);
@@ -138,6 +130,5 @@ void gfx_get_window_size(unsigned *width, unsigned *height)
 
    *width = target.width;
    *height = target.height;
-#endif
 }
-
+#endif

gfx/gfx_common.h

@@ -28,6 +28,8 @@ void gfx_window_title_reset(void);
 void gfx_set_dwm(void);
 #endif
 
+#if !defined(__APPLE__) && !defined(_WIN32)
 void gfx_get_window_size(unsigned *width, unsigned *height);
+#endif
 
 #endif

gfx/gl.c

@@ -147,6 +147,7 @@ typedef struct gl
 
    bool should_resize;
    bool quitting;
+   bool fullscreen;
    bool keep_aspect;
 
    unsigned full_x, full_y;
@@ -498,7 +499,7 @@ static void gl_init_fbo(gl_t *gl, unsigned width, unsigned height)
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_type);
 
       glTexImage2D(GL_TEXTURE_2D,
-            0, GL_RGBA, gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0, GL_RGBA,
+            0, GL_RGBA, gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0, GL_BGRA,
             GL_UNSIGNED_INT_8_8_8_8, NULL);
    }
 
@@ -621,6 +622,7 @@ static void gl_render_msg(gl_t *gl, const char *msg)
    // Need blending. 
    // Using fixed function pipeline here since we cannot guarantee presence of shaders (would be kinda overkill anyways).
    glEnable(GL_BLEND);
+   glColor4f(g_settings.video.msg_color_r, g_settings.video.msg_color_g, g_settings.video.msg_color_b, 1);
 
    struct font_output_list out;
    font_renderer_msg(gl->font, msg, &out);
@@ -653,10 +655,13 @@ static void gl_render_msg(gl_t *gl, const char *msg)
    }
    font_renderer_free_output(&out);
 
+   glColor4f(1, 1, 1, 1);
+
    // Go back to old rendering path.
    glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->tex_coords);
    glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
    glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
+
    glDisable(GL_BLEND);
 #endif
 }
@@ -706,7 +711,9 @@ static void check_window(gl_t *gl)
       }
    }
 
-   if (!gl->should_resize)
+#if !defined(__APPLE__) && !defined(_WIN32)
+   // Hack to workaround limitations in tiling WMs ...
+   if (!gl->should_resize && !gl->fullscreen)
    {
       unsigned new_width, new_height;
       gfx_get_window_size(&new_width, &new_height);
@@ -718,6 +725,7 @@ static void check_window(gl_t *gl)
          SSNES_LOG("GL: Verified window size: %u x %u\n", gl->win_width, gl->win_height);
       }
    }
+#endif
 }
 
 static bool gl_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
@@ -797,7 +805,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    if (gl->should_resize)
    {
       gl->should_resize = false;
-      SDL_SetVideoMode(gl->win_width, gl->win_height, 0, SDL_OPENGL | SDL_RESIZABLE | (g_settings.video.fullscreen ? SDL_FULLSCREEN : 0));
+      SDL_SetVideoMode(gl->win_width, gl->win_height, 0, SDL_OPENGL | (g_settings.video.fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE));
 
 #ifdef HAVE_FBO
       if (!gl->render_to_tex)
@@ -820,7 +828,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
                pglBindFramebuffer(GL_FRAMEBUFFER, gl->fbo[i]);
                glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i]);
                glTexImage2D(GL_TEXTURE_2D,
-                     0, GL_RGBA, gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0, GL_RGBA,
+                     0, GL_RGBA, gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0, GL_BGRA,
                      GL_UNSIGNED_INT_8_8_8_8, NULL);
 
                pglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl->fbo_texture[i], 0);
@@ -1042,7 +1050,10 @@ static void gl_set_nonblock_state(void *data, bool state)
       {
          SDL_SYM_WRAP(glx_swap_interval, "glXSwapIntervalMESA");
       }
-      if (glx_swap_interval) glx_swap_interval(state ? 0 : 1);
+      if (glx_swap_interval) 
+         glx_swap_interval(state ? 0 : 1);
+      else 
+         SSNES_WARN("Could not find GLX VSync call. :(\n");
 #endif
    }
 }
@@ -1095,6 +1106,7 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    }
 
    gl->vsync = video->vsync;
+   gl->fullscreen = video->fullscreen;
    int attr = 0;
    SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &attr);
    if (attr <= 0 && video->vsync)
@@ -1189,11 +1201,12 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    gl->tex_h = 256 * video->input_scale;
 
    // Empty buffer that we use to clear out the texture with on res change.
-   gl->empty_buf = calloc(gl->base_size, gl->tex_w * gl->tex_h);
+   gl->empty_buf = calloc(gl->tex_w * gl->tex_h, gl->base_size);
 
    for (unsigned i = 0; i < 2; i++)
    {
       glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, gl->tex_w);
       glTexImage2D(GL_TEXTURE_2D,
             0, GL_RGBA, gl->tex_w, gl->tex_h, 0, gl->texture_type,
             gl->texture_fmt, gl->empty_buf ? gl->empty_buf : NULL);

gfx/image.c

@@ -63,7 +63,7 @@ bool texture_image_load(const char *path, struct texture_image *out_img)
             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] = (r << 24) | (g << 16) | (b << 8) | a;
+            dst[x] = (b << 24) | (g << 16) | (r << 8) | a;
          }
       }
    }
@@ -84,7 +84,7 @@ bool texture_image_load(const char *path, struct texture_image *out_img)
             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] = (r << 24) | (g << 16) | (b << 8) | 0xff;
+            dst[x] = (b << 24) | (g << 16) | (r << 8) | 0xff;
          }
       }
    }
@@ -148,24 +148,24 @@ bool texture_image_load(const char *path, struct texture_image *out_img)
    {
       for (unsigned i = 0; i < width * height; i++)
       {
-         uint32_t r = tmp[i * 4 + 2];
-         uint32_t g = tmp[i * 4 + 1];
          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] = (r << 24) | (g << 16) | (b << 8) | a;
+         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 r = tmp[i * 3 + 2];
-         uint32_t g = tmp[i * 3 + 1];
          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] = (r << 24) | (g << 16) | (b << 8) | a;
+         out_img->pixels[i] = (b << 24) | (g << 16) | (r << 8) | a;
       }
    }
    else

gfx/sdl.c

@@ -45,11 +45,16 @@ struct sdl_video
    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
 };
 
@@ -78,7 +83,29 @@ static void sdl_init_font(sdl_video_t *vid, const char *font_path, unsigned font
    if (*font_path)
    {
       vid->font = font_renderer_new(font_path, font_size);
-      if (!vid->font)
+      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
@@ -128,9 +155,9 @@ static void sdl_render_msg_15(sdl_video_t *vid, SDL_Surface *buffer, const char
                unsigned g = (out_pix >> gshift) & 0x1f;
                unsigned b = (out_pix >> bshift) & 0x1f;
 
-               unsigned out_r = (r * (256 - blend) + 0x1f * blend) >> 8;
-               unsigned out_g = (g * (256 - blend) + 0x1f * blend) >> 8;
-               unsigned out_b = (b * (256 - blend) + 0x1f * blend) >> 8;
+               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);
             }
          }
@@ -189,9 +216,9 @@ static void sdl_render_msg_32(sdl_video_t *vid, SDL_Surface *buffer, const char
                unsigned g = (out_pix >> gshift) & 0xff;
                unsigned b = (out_pix >> bshift) & 0xff;
 
-               unsigned out_r = (r * (256 - blend) + 0xff * blend) >> 8;
-               unsigned out_g = (g * (256 - blend) + 0xff * blend) >> 8;
-               unsigned out_b = (b * (256 - blend) + 0xff * blend) >> 8;
+               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);
             }
          }
@@ -232,13 +259,15 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    if (!video->fullscreen)
       SSNES_LOG("Creating window @ %ux%u\n", video->width, video->height);
 
-   vid->screen = SDL_SetVideoMode(video->width, video->height, (g_settings.video.force_16bit || !video->rgb32) ? 15 : 32, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
+   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)
@@ -250,7 +279,7 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    SDL_ShowCursor(SDL_DISABLE);
 
    const SDL_PixelFormat *fmt = vid->screen->format;
-   if (!g_settings.video.force_16bit && (video->rgb32 || vid->upsample))
+   if (vid->render32)
    {
       SSNES_LOG("SDL: Creating 32-bit buffer.\n");
       vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, 256 * video->input_scale, 256 * video->input_scale, 32,
@@ -285,7 +314,7 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    sdl_init_font(vid, g_settings.video.font_path, g_settings.video.font_size);
 
 
-   if (fmt->Rshift == 10 && fmt->Gshift ==  5 && fmt->Bshift == 0) 
+   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;
@@ -296,7 +325,7 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
       vid->convert_15_func = convert_15bit_15bit_shift;
    }
 
-   if (fmt->Rshift == 16 && fmt->Gshift == 8 && fmt->Bshift == 0) 
+   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;
@@ -456,15 +485,7 @@ static bool sdl_gfx_frame(void *data, const void* frame, unsigned width, unsigne
    {
       vid->convert_32_func(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
    }
-
-   if (msg)
-   {
-      if ((!vid->rgb32 || g_settings.video.force_16bit) && !vid->upsample)
-         sdl_render_msg_15(vid, vid->buffer, msg, width, height, vid->screen->format);
-      else
-         sdl_render_msg_32(vid, vid->buffer, msg, width, height, vid->screen->format);
-   }
-
+   
    if (SDL_MUSTLOCK(vid->buffer))
       SDL_UnlockSurface(vid->buffer);
 
@@ -484,6 +505,14 @@ static bool sdl_gfx_frame(void *data, const void* frame, unsigned width, unsigne
 
    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);

gfx/shader_cg.c

@@ -37,20 +37,23 @@ static const char* stock_cg_program =
       "("
       "	float4 position	: POSITION,"
       "	float2 texCoord : TEXCOORD0,"
+      "  float4 color : COLOR,"
       ""
       "  uniform float4x4 modelViewProj,"
       ""
       "	out float4 oPosition : POSITION,"
-      "	out float2 otexCoord : TEXCOORD0"
+      "	out float2 otexCoord : TEXCOORD0,"
+      "  out float4 oColor : COLOR"
       ")"
       "{"
       "	oPosition = mul(modelViewProj, position);"
       "	otexCoord = texCoord;"
+      "  oColor = color;"
       "}"
       ""
-      "float4 main_fragment(float2 tex : TEXCOORD0, uniform sampler2D s0 : TEXUNIT0) : COLOR"
+      "float4 main_fragment(in float4 color : COLOR, float2 tex : TEXCOORD0, uniform sampler2D s0 : TEXUNIT0) : COLOR"
       "{"
-      "   return tex2D(s0, tex);"
+      "   return color * tex2D(s0, tex);"
       "}";
 
 #ifdef SSNES_CG_DEBUG
@@ -398,7 +401,7 @@ static bool load_textures(const char *dir_path, config_file_t *conf)
       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_RGBA, GL_UNSIGNED_INT_8_8_8_8, img.pixels);
+            0, GL_RGBA, img.width, img.height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, img.pixels);
 
       lut_textures_num++;
 

gfx/shader_glsl.c

@@ -356,7 +356,7 @@ static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
    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_RGBA, GL_UNSIGNED_INT_8_8_8_8, img.pixels);
+         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);

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);
@@ -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);
    }
 }
 
@@ -176,7 +187,19 @@ static void xv_init_font(xv_t *xv, const char *font_path, unsigned font_size)
    if (*font_path)
    {
       xv->font = font_renderer_new(font_path, font_size);
-      if (!xv->font)
+      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");
    }
 #endif
@@ -297,7 +320,6 @@ static void render32_uyvy(xv_t *xv, const void *input_, unsigned width, unsigned
    }
 }
 
-
 static void* xv_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
    xv_t *xv = calloc(1, sizeof(*xv));
@@ -383,7 +405,7 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
 
    // 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);
@@ -399,29 +421,43 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
             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;
+
+#ifdef HAVE_FREETYPE
+            xv->luma_index[0] = 0;
+            xv->luma_index[1] = 2;
+            xv->chroma_u_index = 1;
+            xv->chroma_v_index = 3;
+#endif
             break;
          }
       }
    }
 
-   if (!has_format) for (int i = 0; i < format_count; i++) 
+   if (!has_format) 
    {
-      if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
+      for (int i = 0; i < format_count; i++) 
       {
-         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') 
+         if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
          {
-            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;
+            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;
+
+#ifdef HAVE_FREETYPE
+               xv->luma_index[0] = 1;
+               xv->luma_index[1] = 3;
+               xv->chroma_u_index = 0;
+               xv->chroma_v_index = 2;
+#endif
+               break;
+            }
          }
       }
    }
 
-
    free(format);
    if (!has_format) 
    {
@@ -466,8 +502,6 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
    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 +512,8 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
       *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 +597,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 +611,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 +630,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;
             }
          }
       }
@@ -630,11 +684,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 +748,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

@@ -15,10 +15,10 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "ssnes_dinput.h"
 #include "SDL.h"
 #include "SDL_syswm.h"
 #include <stdbool.h>
-#include "ssnes_dinput.h"
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
@@ -45,7 +45,7 @@ void sdl_dinput_free(sdl_dinput_t *di)
 
 static BOOL CALLBACK enum_axes_cb(const DIDEVICEOBJECTINSTANCE *inst, void *p)
 {
-   IDirectInputDevice8 *joypad = p;
+   LPDIRECTINPUTDEVICE8 joypad = p;
 
    DIPROPRANGE range;
    memset(&range, 0, sizeof(range));

input/ssnes_dinput.h

@@ -30,8 +30,8 @@
 typedef struct sdl_dinput
 {
    HWND hWnd;
-   IDirectInput8 *ctx;
-   IDirectInputDevice8 *joypad[MAX_PLAYERS];
+   LPDIRECTINPUT8 ctx;
+   LPDIRECTINPUTDEVICE8 joypad[MAX_PLAYERS];
    unsigned joypad_cnt;
    DIJOYSTATE2 joy_state[MAX_PLAYERS];
 } sdl_dinput_t;

netplay.c

@@ -25,10 +25,12 @@
 #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)

qb/config.libs.sh

@@ -3,6 +3,15 @@
 check_switch_c C99 -std=gnu99
 check_critical C99 "Cannot find C99 compatible compiler."
 
+# There are still broken 64-bit Linux distros out there. :)
+if [ -d /usr/lib64 ]; then
+   add_library_dirs /usr/lib64
+fi
+
+if [ -d /opt/local/lib ]; then
+   add_library_dirs /opt/local/lib
+fi
+
 if [ "$OS" = BSD ]; then
    DYLIB=-lc
 else
@@ -56,7 +65,9 @@ if [ $HAVE_SDL_NEW = yes ]; then
    exit 1
 fi
 
-check_lib CG -lCg cgCreateContext
+# On some distros, -lCg doesn't link against -lstdc++ it seems ...
+check_lib_cxx CG -lCg cgCreateContext
+
 check_pkgconf XML libxml-2.0
 check_pkgconf SDL_IMAGE SDL_image
 

qb/config.params.sh

@@ -1,7 +1,7 @@
 . qb/qb.params.sh
 
 PACKAGE_NAME=ssnes
-PACKAGE_VERSION=0.7
+PACKAGE_VERSION=0.8.1
 
 # Adds a command line opt to ./configure --help
 # $1: Variable (HAVE_ALSA, HAVE_OSS, etc)   

record/ffemu.c

@@ -79,14 +79,13 @@ static bool init_audio(struct audio_info *audio, struct ffemu_params *param)
    if (!codec)
       return false;
 
-   audio->codec = avcodec_alloc_context();
-   avcodec_get_context_defaults(audio->codec);
+   audio->codec = avcodec_alloc_context3(codec);
 
    audio->codec->sample_rate = param->samplerate;
    audio->codec->time_base = (AVRational) { 1, param->samplerate };
    audio->codec->channels = param->channels;
    audio->codec->sample_fmt = AV_SAMPLE_FMT_S16;
-   if (avcodec_open(audio->codec, codec) != 0)
+   if (avcodec_open2(audio->codec, codec, NULL) != 0)
       return false;
 
    audio->buffer = av_malloc(audio->codec->frame_size * param->channels * sizeof(int16_t));
@@ -119,14 +118,15 @@ static bool init_video(struct video_info *video, struct ffemu_params *param)
       video->pix_size = sizeof(uint32_t);
    }
 
-   video->codec = avcodec_alloc_context();
+   video->codec = avcodec_alloc_context3(codec);
    video->codec->width = param->out_width;
    video->codec->height = param->out_height;
    video->codec->time_base = (AVRational) {param->fps.den, param->fps.num};
    video->codec->pix_fmt = PIX_FMT_RGB32;
    video->codec->sample_aspect_ratio = av_d2q(param->aspect_ratio * param->out_height / param->out_width, 255);
+   video->codec->thread_count = 2;
 
-   if (avcodec_open(video->codec, codec) != 0)
+   if (avcodec_open2(video->codec, codec, NULL) != 0)
       return false;
 
    // Allocate a big buffer :p ffmpeg API doesn't seem to give us some clues how big this buffer should be.
@@ -147,11 +147,7 @@ static bool init_muxer(ffemu_t *handle)
    AVFormatContext *ctx = avformat_alloc_context();
    av_strlcpy(ctx->filename, handle->params.filename, sizeof(ctx->filename));
    ctx->oformat = av_guess_format(NULL, ctx->filename, NULL);
-#ifdef AVIO_FLAG_WRITE
    if (avio_open(&ctx->pb, ctx->filename, AVIO_FLAG_WRITE) < 0)
-#else
-   if (url_fopen(&ctx->pb, ctx->filename, URL_WRONLY) < 0)
-#endif
    {
       av_free(ctx);
       return false;
@@ -173,7 +169,7 @@ static bool init_muxer(ffemu_t *handle)
       handle->audio.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
    handle->muxer.astream = stream;
 
-   if (av_write_header(ctx) < 0)
+   if (avformat_write_header(ctx, NULL) < 0)
       return false;
 
    handle->muxer.ctx = ctx;
@@ -244,7 +240,6 @@ static void deinit_thread_buf(ffemu_t *handle)
 
 ffemu_t *ffemu_new(const struct ffemu_params *params)
 {
-   avcodec_init();
    av_register_all();
 
    ffemu_t *handle = calloc(1, sizeof(*handle));

settings.c

@@ -20,6 +20,7 @@
 #include <assert.h>
 #include "strl.h"
 #include "config.def.h"
+#include "file.h"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -28,6 +29,7 @@
 #include <ctype.h>
 
 struct settings g_settings;
+struct global g_extern;
 
 #ifdef HAVE_CONFIGFILE
 static void read_keybinds(config_file_t *conf);
@@ -133,6 +135,10 @@ static void set_defaults(void)
    g_settings.video.font_size = font_size;
    g_settings.video.msg_pos_x = message_pos_offset_x;
    g_settings.video.msg_pos_y = message_pos_offset_y;
+   
+   g_settings.video.msg_color_r = ((message_color >> 16) & 0xff) / 255.0f;
+   g_settings.video.msg_color_g = ((message_color >>  8) & 0xff) / 255.0f;
+   g_settings.video.msg_color_b = ((message_color >>  0) & 0xff) / 255.0f;
 #endif
 
 #if defined(HAVE_CG) || defined(HAVE_XML)
@@ -170,7 +176,7 @@ static void set_defaults(void)
    for (unsigned i = 1; i < 5; i++)
       memcpy(g_settings.input.binds[i], snes_keybinds_rest, sizeof(snes_keybinds_rest));
 
-   g_settings.input.axis_threshold = AXIS_THRESHOLD;
+   g_settings.input.axis_threshold = axis_threshold;
    g_settings.input.netplay_client_swap_input = netplay_client_swap_input;
    for (int i = 0; i < MAX_PLAYERS; i++)
       g_settings.input.joypad_map[i] = i;
@@ -183,7 +189,6 @@ static void parse_config_file(void);
 
 void parse_config(void)
 {
-   memset(&g_settings, 0, sizeof(struct settings));
    set_defaults();
 
 #ifdef HAVE_CONFIGFILE
@@ -203,7 +208,7 @@ static config_file_t *open_default_config_file(void)
       const char *appdata = getenv("APPDATA");
       if (appdata)
       {
-         char conf_path[strlen(appdata) + strlen("/ssnes.cfg ")];
+         char conf_path[MAXPATHLEN];
          strlcpy(conf_path, appdata, sizeof(conf_path));
          strlcat(conf_path, "/ssnes.cfg", sizeof(conf_path));
          conf = config_file_new(conf_path);
@@ -213,7 +218,7 @@ static config_file_t *open_default_config_file(void)
    const char *home = getenv("HOME");
    if (home)
    {
-      char conf_path[strlen(home) + strlen("/.ssnes.cfg ")];
+      char conf_path[MAXPATHLEN];
       strlcpy(conf_path, home, sizeof(conf_path));
       strlcat(conf_path, "/.ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
@@ -228,14 +233,14 @@ static config_file_t *open_default_config_file(void)
    const char *home = getenv("HOME");
    if (xdg)
    {
-      char conf_path[strlen(xdg) + strlen("/ssnes/ssnes.cfg ")];
+      char conf_path[MAXPATHLEN];
       strlcpy(conf_path, xdg, sizeof(conf_path));
       strlcat(conf_path, "/ssnes/ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
    }
    else if (home)
    {
-      char conf_path[strlen(home) + strlen("/.ssnes.cfg ")];
+      char conf_path[MAXPATHLEN];
       strlcpy(conf_path, home, sizeof(conf_path));
       strlcat(conf_path, "/.ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
@@ -259,13 +264,8 @@ static config_file_t *open_default_config_file(void)
 #define CONFIG_GET_DOUBLE(var, key) if (config_get_double(conf, key, &tmp_double)) \
    g_settings.var = tmp_double
 
-#define CONFIG_GET_STRING(var, key) do { \
-   if (config_get_string(conf, key, &tmp_str)) \
-   { \
-      strlcpy(g_settings.var, tmp_str, sizeof(g_settings.var)); \
-      free(tmp_str); \
-   } \
-} while(0)
+#define CONFIG_GET_STRING(var, key) \
+   config_get_array(conf, key, g_settings.var, sizeof(g_settings.var))
 
 #ifdef HAVE_CONFIGFILE
 static void parse_config_file(void)
@@ -293,7 +293,7 @@ static void parse_config_file(void)
    int tmp_int;
    double tmp_double;
    bool tmp_bool;
-   char *tmp_str;
+   char tmp_str[MAXPATHLEN];
 
    CONFIG_GET_DOUBLE(video.xscale, "video_xscale");
    CONFIG_GET_DOUBLE(video.yscale, "video_yscale");
@@ -326,6 +326,14 @@ static void parse_config_file(void)
    CONFIG_GET_INT(video.font_size, "video_font_size");
    CONFIG_GET_DOUBLE(video.msg_pos_x, "video_message_pos_x");
    CONFIG_GET_DOUBLE(video.msg_pos_y, "video_message_pos_y");
+
+   unsigned msg_color;
+   if (config_get_hex(conf, "video_message_color", &msg_color))
+   {
+      g_settings.video.msg_color_r = ((msg_color >> 16) & 0xff) / 255.0f;
+      g_settings.video.msg_color_g = ((msg_color >>  8) & 0xff) / 255.0f;
+      g_settings.video.msg_color_b = ((msg_color >>  0) & 0xff) / 255.0f;
+   }
 #endif
 
    CONFIG_GET_BOOL(video.hires_record, "video_hires_record");
@@ -338,7 +346,7 @@ static void parse_config_file(void)
 #endif
 
 #if defined(HAVE_CG) || defined(HAVE_XML)
-   if (config_get_string(conf, "video_shader_type", &tmp_str))
+   if (config_get_array(conf, "video_shader_type", tmp_str, sizeof(tmp_str)))
    {
       if (strcmp("cg", tmp_str) == 0)
          g_settings.video.shader_type = SSNES_SHADER_CG;
@@ -348,8 +356,6 @@ static void parse_config_file(void)
          g_settings.video.shader_type = SSNES_SHADER_AUTO;
       else if (strcmp("none", tmp_str) == 0)
          g_settings.video.shader_type = SSNES_SHADER_NONE;
-
-      free(tmp_str);
    }
 #endif
 
@@ -390,7 +396,13 @@ static void parse_config_file(void)
    CONFIG_GET_STRING(audio.dsp_plugin, "audio_dsp_plugin");
    CONFIG_GET_STRING(input.driver, "input_driver");
    CONFIG_GET_STRING(libsnes, "libsnes_path");
+
    CONFIG_GET_STRING(screenshot_directory, "screenshot_directory");
+   if (*g_settings.screenshot_directory && !path_is_directory(g_settings.screenshot_directory))
+   {
+      SSNES_WARN("screenshot_directory is not an existing directory, ignoring ...\n");
+      *g_settings.screenshot_directory = '\0';
+   }
 
    CONFIG_GET_BOOL(rewind_enable, "rewind_enable");
 
@@ -403,6 +415,28 @@ static void parse_config_file(void)
    CONFIG_GET_INT(autosave_interval, "autosave_interval");
 
    CONFIG_GET_STRING(cheat_database, "cheat_database_path");
+   CONFIG_GET_STRING(cheat_settings_path, "cheat_settings_path");
+
+   if (!g_extern.has_set_save_path && config_get_array(conf, "savefile_directory", tmp_str, sizeof(tmp_str)))
+   {
+      if (path_is_directory(tmp_str))
+      {
+         strlcpy(g_extern.savefile_name_srm, tmp_str, sizeof(g_extern.savefile_name_srm));
+         fill_pathname_dir(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm));
+      }
+      else
+         SSNES_WARN("savefile_directory is not a directory, ignoring ...!\n");
+   }
+   if (!g_extern.has_set_state_path && config_get_array(conf, "savestate_directory", tmp_str, sizeof(tmp_str)))
+   {
+      if (path_is_directory(tmp_str))
+      {
+         strlcpy(g_extern.savestate_name, tmp_str, sizeof(g_extern.savestate_name));
+         fill_pathname_dir(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name));
+      }
+      else
+         SSNES_WARN("savestate_directory is not a directory, ignoring ...\n");
+   }
 
    read_keybinds(conf);
 
@@ -669,6 +703,7 @@ static const struct key_map sdlk_map[] = {
    { "print_screen", SDLK_PRINT },
    { "scroll_lock", SDLK_SCROLLOCK },
    { "tilde", SDLK_BACKQUOTE },
+   { "backquote", SDLK_BACKQUOTE },
    { "nul", SDLK_UNKNOWN },
 };
 

ssnes-mingw-build.sh

@@ -0,0 +1,146 @@
+#!/bin/sh
+############### 
+# Build script which builds and packages SSNES for MinGW 32/64-bit.
+# Preferably build on Linux with a cross chain ... :D
+##########
+
+#### 
+## Tweak these to suit your environment.
+## Not defining the variable will avoid building that target.
+## Set MINGW32_BASE and/or MINGW64_BASE to set toolchain prefix:
+## E.g.: i486-mingw32-gcc would get prefix "i486-mingw32".
+
+BUILD_32BIT=yes
+BUILD_64BIT=yes
+BUILD_PHOENIX_GUI=yes
+
+if [ ! -z "$NOBUILD_32BIT" ]; then
+   BUILD_32BIT=no
+fi
+if [ ! -z "$NOBUILD_64BIT" ]; then
+   BUILD_64BIT=no
+fi
+if [ ! -z "$NOBUILD_PHOENIX_GUI" ]; then
+   BUILD_PHOENIX_GUI=no
+fi
+
+########
+
+die()
+{
+   echo "$@"
+   exit 1
+}
+
+message()
+{
+   echo ""
+   echo "================================"
+   echo "$@"
+   echo "================================"
+   echo ""
+}
+
+if [ ! -f "`which zip`" ]; then
+   echo "Cannot find 'zip'. Cannot package, quitting ..."
+   exit 1
+fi
+
+if [ ! -f "`which unzip`" ]; then
+   echo "Cannot find 'unzip'. Cannot unpack, quitting ..."
+   exit 1
+fi
+
+if [ ! -f "`which wget`" ]; then
+   echo "Cannot find 'wget'. Cannot unpack, quitting ..."
+   exit 1
+fi
+
+do_phoenix_build()
+{
+   message "Build Phoenix GUI"
+   ### Build Phoenix GUI
+   if [ ! -d "Phoenix" ]; then
+      git clone git://github.com/Themaister/SSNES-Phoenix.git Phoenix
+      cd Phoenix
+   else
+      cd Phoenix
+      git pull origin master
+   fi
+
+   make -f Makefile.win32 clean || die "Failed to clean ..."
+   make -f Makefile.win32 CC="$C_COMPILER" CXX="$CXX_COMPILER" WINDRES="$WINDRES" -j4 all || die "Failed to build ..."
+   touch ssnes-phoenix.cfg
+   cp ssnes-phoenix.cfg ssnes-phoenix.exe ../ || die "Failed to copy ..."
+
+   cd ..
+}
+
+do_build()
+{
+   SSNES_DIR="$1"
+   LIBZIPNAME="$2"
+   BUILDTYPE="$3"
+
+   if [ ! -d "$SSNES_DIR" ]; then
+      git clone git://github.com/Themaister/SSNES.git "$SSNES_DIR"
+      cd "$SSNES_DIR"
+   else
+      cd "$SSNES_DIR"
+      git pull origin master
+   fi
+
+   if [ ! -f "$LIBZIPNAME" ]; then
+      make -f Makefile.win libs_${BUILDTYPE} || die "Failed to extract"
+   fi
+
+   make -f Makefile.win clean || die "Failed to clean ..."
+   make -f Makefile.win CC="$C_COMPILER" CXX="$CXX_COMPILER" -j4 all SLIM=1 || die "Failed to build ..."
+   make -f Makefile.win CC="$C_COMPILER" CXX="$CXX_COMPILER" dist_${BUILDTYPE} SLIM=1 || die "Failed to dist ..."
+   if [ -z "`find . | grep "ssnes-win"`" ]; then
+      die "Did not find build ..."
+   fi
+
+   if [ "$BUILD_PHOENIX_GUI" = "yes" ]; then
+      do_phoenix_build
+   fi
+
+   ZIP_BASE="`find . | grep "ssnes-win" | head -n1`"
+   ZIP_SLIM="`echo $ZIP_BASE | sed -e 's|\.zip|-slim.zip|'`"
+   ZIP_FULL="`echo $ZIP_BASE | sed -e 's|\.zip|-full.zip|'`"
+
+   if [ "$BUILD_PHOENIX_GUI" = "yes" ]; then
+      zip "$ZIP_BASE" ssnes-phoenix.exe ssnes-phoenix.cfg
+   fi
+   mv -v "$ZIP_BASE" "../$ZIP_SLIM" || die "Failed to move final build ..."
+
+   make -f Makefile.win clean || die "Failed to clean ..."
+   make -f Makefile.win CC="$C_COMPILER" CXX="$CXX_COMPILER" -j4 all || die "Failed to build ..."
+   make -f Makefile.win CC="$C_COMPILER" CXX="$CXX_COMPILER" dist_${BUILDTYPE} || die "Failed to dist ..."
+
+   if [ "$BUILD_PHOENIX_GUI" = "yes" ]; then
+      zip "$ZIP_BASE" ssnes-phoenix.exe ssnes-phoenix.cfg
+   fi
+   mv -v "$ZIP_BASE" "../$ZIP_FULL" || die "Failed to move final build ..."
+   
+   cd ..
+}
+
+if [ "$BUILD_32BIT" = yes ]; then
+   message "Building for 32-bit!"
+   C_COMPILER=${MINGW32_BASE}-gcc
+   CXX_COMPILER=${MINGW32_BASE}-g++
+   WINDRES=${MINGW32_BASE}-windres
+   do_build "SSNES-w32" "SSNES-win32-libs.zip" "x86"
+fi
+
+if [ "$BUILD_64BIT" = yes ]; then
+   message "Building for 64-bit!"
+   C_COMPILER=${MINGW64_BASE}-gcc
+   CXX_COMPILER=${MINGW64_BASE}-g++
+   WINDRES=${MINGW64_BASE}-windres
+   do_build "SSNES-w64" "SSNES-win64-libs.zip" "x86_64"
+fi
+
+message "Built successfully! :)"
+

ssnes.c

@@ -49,15 +49,9 @@
 #include "SDL.h" 
 // OSX seems to really need -lSDLmain, 
 // so we include SDL.h here so it can hack our main.
-// I had issues including this in Win32 for some reason. :)
+// We want to use -mconsole in Win32, so we need main().
 #endif
 
-struct global g_extern = {
-   .video_active = true,
-   .audio_active = true,
-   .game_type = SSNES_CART_NORMAL,
-};
-
 // To avoid continous switching if we hold the button down, we require that the button must go from pressed, unpressed back to pressed to be able to toggle between then.
 static void set_fast_forward_button(bool new_button_state, bool new_hold_button_state)
 {
@@ -96,7 +90,7 @@ static void set_fast_forward_button(bool new_button_state, bool new_hold_button_
 
 static void take_screenshot(const uint16_t *frame, unsigned width, unsigned height)
 {
-   if (!*(g_settings.screenshot_directory))
+   if (!(*g_settings.screenshot_directory))
       return;
 
    bool ret = screenshot_dump(g_settings.screenshot_directory, frame, 
@@ -329,26 +323,8 @@ static int16_t input_state(bool port, unsigned device, unsigned index, unsigned
    return res;
 }
 
-static void fill_pathname(char *out_path, const char *in_path, const char *replace, size_t size)
-{
-   char tmp_path[strlen(in_path) + 1];
-   strlcpy(tmp_path, in_path, sizeof(tmp_path));
-   char *tok = NULL;
-   tok = strrchr(tmp_path, '.');
-   if (tok != NULL)
-      *tok = '\0';
-   assert(strlcpy(out_path, tmp_path, size) < size);
-   assert(strlcat(out_path, replace, size) < size);
-}
-
-static 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);
-}
-
 #ifdef _WIN32
-#define SSNES_DEFAULT_CONF_PATH_STR "\n\tDefaults to ssnes.cfg in same directory as ssnes.exe."
+#define SSNES_DEFAULT_CONF_PATH_STR "\n\t\tDefaults to ssnes.cfg in same directory as ssnes.exe."
 #elif defined(__APPLE__)
 #define SSNES_DEFAULT_CONF_PATH_STR " Defaults to $HOME/.ssnes.cfg."
 #else
@@ -356,7 +332,7 @@ static void fill_pathname_noext(char *out_path, const char *in_path, const char
 #endif
 
 #ifdef _WIN32
-#define PACKAGE_VERSION "0.7"
+#define PACKAGE_VERSION "0.8.1"
 #endif
 
 #include "config.features.h"
@@ -425,10 +401,11 @@ static void print_help(void)
 #endif
 
 #ifdef HAVE_FFMPEG
-   puts("\t-r/--record: Path to record video file.\n\t\tSettings for video/audio codecs are found in config file.");
+   puts("\t-r/--record: Path to record video file.\n\t\tUsing .mkv extension is recommended, and codecs used are FFV1/FLAC.");
 #endif
    puts("\t-v/--verbose: Verbose logging.");
    puts("\t-U/--ups: Specifies path for UPS patch that will be applied to ROM.");
+   puts("\t--bps: Specifies path for BPS patch that will be applied to ROM.");
    puts("\t-X/--xml: Specifies path to XML memory map.");
    puts("\t-D/--detach: Detach SSNES from the running console. Not relevant for all platforms.\n");
 
@@ -437,12 +414,84 @@ static void print_help(void)
 
 static void set_basename(const char *path)
 {
-   char tmp[strlen(path) + 1];
-   strlcpy(tmp, path, sizeof(tmp));
-   char *dst = strrchr(tmp, '.');
+   strlcpy(g_extern.basename, path, sizeof(g_extern.basename));
+   char *dst = strrchr(g_extern.basename, '.');
    if (dst)
       *dst = '\0';
-   strlcpy(g_extern.basename, tmp, sizeof(g_extern.basename));
+}
+
+static void set_paths(const char *path)
+{
+   set_basename(path);
+
+   SSNES_LOG("Opening file: \"%s\"\n", path);
+   g_extern.rom_file = fopen(path, "rb");
+   if (g_extern.rom_file == NULL)
+   {
+      SSNES_ERR("Could not open file: \"%s\"\n", path);
+      exit(1);
+   }
+
+   if (!g_extern.has_set_save_path)
+      fill_pathname_noext(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm));
+   if (!g_extern.has_set_state_path)
+      fill_pathname_noext(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name));
+
+   if (path_is_directory(g_extern.savefile_name_srm))
+   {
+      fill_pathname_dir(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm));
+      SSNES_LOG("Redirecting save file to \"%s\".\n", g_extern.savefile_name_srm);
+   }
+   if (path_is_directory(g_extern.savestate_name))
+   {
+      fill_pathname_dir(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name));
+      SSNES_LOG("Redirecting save state to \"%s\".\n", g_extern.savestate_name);
+   }
+   if (*g_extern.config_path && path_is_directory(g_extern.config_path))
+   {
+      fill_pathname_dir(g_extern.config_path, g_extern.basename, ".cfg", sizeof(g_extern.config_path));
+      SSNES_LOG("Redirecting config file to \"%s\".\n", g_extern.config_path);
+      if (!path_file_exists(g_extern.config_path))
+      {
+         *g_extern.config_path = '\0';
+         SSNES_LOG("Did not find config file. Using system default.\n");
+      }
+   }
+}
+
+static void verify_stdin_paths(void)
+{
+   if (strlen(g_extern.savefile_name_srm) == 0)
+   {
+      SSNES_ERR("Need savefile path argument (--save) when reading rom from stdin.\n");
+      print_help();
+      exit(1);
+   }
+   else if (strlen(g_extern.savestate_name) == 0)
+   {
+      SSNES_ERR("Need savestate path argument (--savestate) when reading rom from stdin.\n");
+      print_help();
+      exit(1);
+   }
+
+   if (path_is_directory(g_extern.savefile_name_srm))
+   {
+      SSNES_ERR("Cannot specify directory for path argument (--save) when reading from stdin.\n");
+      print_help();
+      exit(1);
+   }
+   else if (path_is_directory(g_extern.savestate_name))
+   {
+      SSNES_ERR("Cannot specify directory for path argument (--savestate) when reading from stdin.\n");
+      print_help();
+      exit(1);
+   }
+   else if (path_is_directory(g_extern.config_path))
+   {
+      SSNES_ERR("Cannot specify directory for config file (--config) when reading from stdin.\n");
+      print_help();
+      exit(1);
+   }
 }
 
 static void parse_input(int argc, char *argv[])
@@ -484,6 +533,7 @@ static void parse_input(int argc, char *argv[])
       { "frames", 1, NULL, 'F' },
       { "port", 1, &val, 'p' },
       { "ups", 1, NULL, 'U' },
+      { "bps", 1, &val, 'B' },
       { "xml", 1, NULL, 'X' },
       { "detach", 0, NULL, 'D' },
       { NULL, 0, NULL, 0 }
@@ -635,6 +685,7 @@ static void parse_input(int argc, char *argv[])
 
          case 'U':
             strlcpy(g_extern.ups_name, optarg, sizeof(g_extern.ups_name));
+            g_extern.ups_pref = true;
             break;
 
          case 'X':
@@ -651,7 +702,11 @@ static void parse_input(int argc, char *argv[])
             switch (val)
             {
                case 'p':
-                  g_extern.netplay_port = strtol(optarg, NULL, 0);
+                  g_extern.netplay_port = strtoul(optarg, NULL, 0);
+                  break;
+               case 'B':
+                  strlcpy(g_extern.bps_name, optarg, sizeof(g_extern.bps_name));
+                  g_extern.bps_pref = true;
                   break;
                default:
                   break;
@@ -669,34 +724,9 @@ static void parse_input(int argc, char *argv[])
    }
 
    if (optind < argc)
-   {
-      set_basename(argv[optind]);
-     
-      SSNES_LOG("Opening file: \"%s\"\n", argv[optind]);
-      g_extern.rom_file = fopen(argv[optind], "rb");
-      if (g_extern.rom_file == NULL)
-      {
-         SSNES_ERR("Could not open file: \"%s\"\n", argv[optind]);
-         exit(1);
-      }
-      // strl* would be nice :D
-      if (!g_extern.has_set_save_path)
-         fill_pathname_noext(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm));
-      if (!g_extern.has_set_state_path)
-         fill_pathname_noext(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name));
-   }
-   else if (strlen(g_extern.savefile_name_srm) == 0)
-   {
-      SSNES_ERR("Need savefile path argument (--save) when reading rom from stdin.\n");
-      print_help();
-      exit(1);
-   }
-   else if (strlen(g_extern.savestate_name) == 0)
-   {
-      SSNES_ERR("Need savestate path argument (--savefile) when reading rom from stdin.\n");
-      print_help();
-      exit(1);
-   }
+      set_paths(argv[optind]);
+   else
+      verify_stdin_paths();
 }
 
 // TODO: Add rest of the controllers.
@@ -1077,11 +1107,17 @@ static void fill_pathnames(void)
    if (!g_extern.bsv_movie_playback)
       fill_pathname(g_extern.bsv_movie_path, g_extern.savefile_name_srm, "", sizeof(g_extern.bsv_movie_path));
 
-   if (!(*g_extern.ups_name) && *g_extern.basename)
-      fill_pathname_noext(g_extern.ups_name, g_extern.basename, ".ups", sizeof(g_extern.ups_name));
+   if (*g_extern.basename)
+   {
+      if (!(*g_extern.ups_name))
+         fill_pathname_noext(g_extern.ups_name, g_extern.basename, ".ups", sizeof(g_extern.ups_name));
 
-   if (!(*g_extern.xml_name) && *g_extern.basename)
-      fill_pathname_noext(g_extern.xml_name, g_extern.basename, ".xml", sizeof(g_extern.xml_name));
+      if (!(*g_extern.bps_name))
+         fill_pathname_noext(g_extern.bps_name, g_extern.basename, ".bps", sizeof(g_extern.bps_name));
+
+      if (!(*g_extern.xml_name))
+         fill_pathname_noext(g_extern.xml_name, g_extern.basename, ".xml", sizeof(g_extern.xml_name));
+   }
 }
 
 // Save or load state here.
@@ -1091,7 +1127,7 @@ static void check_savestates(void)
    bool should_savestate = driver.input->key_pressed(driver.input_data, SSNES_SAVE_STATE_KEY);
    if (should_savestate && !old_should_savestate)
    {
-      char save_path[strlen(g_extern.savestate_name) * 2];
+      char save_path[MAXPATHLEN];
 
       if (g_extern.state_slot > 0)
          snprintf(save_path, sizeof(save_path), "%s%u", g_extern.savestate_name, g_extern.state_slot);
@@ -1117,7 +1153,7 @@ static void check_savestates(void)
    bool should_loadstate = driver.input->key_pressed(driver.input_data, SSNES_LOAD_STATE_KEY);
    if (!should_savestate && should_loadstate && !old_should_loadstate)
    {
-      char load_path[strlen(g_extern.savestate_name) * 2];
+      char load_path[MAXPATHLEN];
 
       if (g_extern.state_slot > 0)
          snprintf(load_path, sizeof(load_path), "%s%u", g_extern.savestate_name, g_extern.state_slot);
@@ -1513,16 +1549,27 @@ static void fill_title_buf(void)
       snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "SSNES");
 }
 
+static void init_state(void)
+{
+   // Make absolutely sure our big global structs are in-fact zeroed out.
+   memset(&g_extern, 0, sizeof(g_extern));
+   memset(&g_settings, 0, sizeof(g_settings));
+   g_extern.video_active = true;
+   g_extern.audio_active = true;
+   g_extern.game_type = SSNES_CART_NORMAL;
+}
 
 int main(int argc, char *argv[])
 {
+   init_state();
+
    parse_input(argc, argv);
    parse_config();
    init_dlsym();
    fill_title_buf();
 
    psnes_init();
-   if (strlen(g_extern.basename) > 0)
+   if (*g_extern.basename)
       psnes_set_cartridge_basename(g_extern.basename);
 
    SSNES_LOG("Version of libsnes API: %u.%u\n", psnes_library_revision_major(), psnes_library_revision_minor());
@@ -1532,10 +1579,6 @@ int main(int argc, char *argv[])
    if (!init_rom_file(g_extern.game_type))
       goto error;
 
-#ifdef HAVE_XML
-   init_cheats();
-#endif
-
    init_msg_queue();
    init_movie();
 
@@ -1549,7 +1592,7 @@ int main(int argc, char *argv[])
 
    if (!g_extern.netplay)
       init_rewind();
-
+      
 #ifdef HAVE_NETPLAY
    psnes_set_video_refresh(g_extern.netplay ? video_frame_net : video_frame);
    psnes_set_audio_sample(g_extern.netplay ? audio_sample_net : audio_sample);
@@ -1569,6 +1612,11 @@ int main(int argc, char *argv[])
 
    if (!g_extern.bsv_movie_playback && !g_extern.netplay_is_client)
       init_autosave();
+      
+#ifdef HAVE_XML
+   if (!g_extern.netplay && !g_extern.bsv_movie)
+      init_cheats();
+#endif
 
    // Main loop
    for(;;)
@@ -1663,3 +1711,4 @@ error:
    return 1;
 }
 
+

ssnes.cfg

@@ -1,5 +1,13 @@
 ##### 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"
 
@@ -83,7 +91,11 @@
 # 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_pox_y = 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
 
 #### Audio
 
@@ -283,6 +295,11 @@
 # 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