Updates for 0.9.2.

FFmpeg and Python does not require explicit --enable.

Makefile

@@ -2,11 +2,11 @@ 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 bps.o strl.o screenshot.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 thread.o audio/hermite.o
 JOYCONFIG_OBJ = tools/ssnes-joyconfig.o conf/config_file.o strl.o
 HEADERS = $(wildcard */*.h) $(wildcard *.h)
 
-LIBS = -lm
+LIBS = -lm -lpthread
 DEFINES = -DHAVE_CONFIG_H
 
 ifneq ($(findstring Darwin,$(OS)),)
@@ -23,11 +23,8 @@ ifneq ($(findstring BSD,$(OS)),)
    DYLIB_LIB = -lc
 endif
 
-ifeq ($(HAVE_SRC), 1)
-   LIBS += $(SRC_LIBS)
-   DEFINES += $(SRC_CFLAGS)
-else
-   OBJ += audio/hermite.o
+ifneq ($(findstring Linux,$(OS)),)
+   LIBS += -lrt
 endif
 
 ifeq ($(HAVE_CONFIGFILE), 1)
@@ -89,20 +86,24 @@ ifeq ($(HAVE_COREAUDIO), 1)
 endif
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
+   OBJ += gfx/sdl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
    DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
    LIBS += $(SDL_LIBS)
+
+ifeq ($(HAVE_OPENGL), 1)
+	OBJ += gfx/gl.o 
 ifeq ($(OSX),1)
-   LIBS += -framework OpenGL
+	LIBS += -framework OpenGL
 else
-   LIBS += -lGL
+	LIBS += -lGL
+endif
 endif
 endif
 
 ifeq ($(HAVE_XVIDEO), 1)
    OBJ += gfx/xvideo.o input/x11_input.o
-   LIBS += $(XVIDEO_LIBS)
-   DEFINES += $(XVIDEO_CFLAGS)
+   LIBS += $(XVIDEO_LIBS) $(X11_LIBS) $(XEXT_LIBS)
+   DEFINES += $(XVIDEO_CFLAGS) $(X11_CFLAGS) $(XEXT_CFLAGS)
 endif
 
 ifeq ($(HAVE_CG), 1)
@@ -111,9 +112,19 @@ ifeq ($(HAVE_CG), 1)
 endif
 
 ifeq ($(HAVE_XML), 1)
-   OBJ += gfx/shader_glsl.o gfx/image.o gfx/snes_state.o sha256.o cheats.o 
+   OBJ += sha256.o cheats.o 
    LIBS += $(XML_LIBS)
    DEFINES += $(XML_CFLAGS)
+
+ifeq ($(HAVE_OPENGL), 1)
+   OBJ += gfx/shader_glsl.o 
+endif
+endif
+
+ifeq ($(HAVE_XML), 1)
+   OBJ += gfx/snes_state.o gfx/image.o 
+else ifeq ($(HAVE_CG), 1)
+   OBJ += gfx/snes_state.o gfx/image.o 
 endif
 
 ifeq ($(HAVE_DYLIB), 1)
@@ -158,9 +169,14 @@ ifneq ($(V),1)
    Q := @
 endif
 
-CFLAGS += -Wall -O3 -g -I. -pedantic
+OPTIMIZE_FLAG = -O3
+ifeq ($(DEBUG), 1)
+   OPTIMIZE_FLAG = -O0
+endif
+
+CFLAGS += -Wall $(OPTIMIZE_FLAG) -g -I. -pedantic
 ifneq ($(findstring icc,$(CC)),)
-   CFLAGS += -std=c99
+   CFLAGS += -std=c99 -D_GNU_SOURCE
 else
    CFLAGS += -std=gnu99
 endif

Makefile.win

@@ -1,6 +1,6 @@
 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 bps.o ups.o strl.o screenshot.o audio/hermite.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 thread.o
 JOBJ = conf/config_file.o tools/main-stub.o tools/ssnes-joyconfig.o strl.o
 
 CC = gcc
@@ -10,8 +10,10 @@ HAVE_DINPUT = 1
 HAVE_XAUDIO = 1
 HAVE_DSOUND = 1
 HAVE_SDL = 1
+HAVE_OPENGL = 1
 HAVE_DYLIB = 1
 HAVE_NETPLAY = 1
+DYNAMIC = 1
 
 ifeq ($(SLIM),)
    HAVE_SDL_IMAGE = 1
@@ -28,15 +30,20 @@ libsnes ?= -lsnes
 
 LIBS = -lm -lshlwapi
 DEFINES = -I. -DHAVE_CONFIGFILE
-LDFLAGS = -L. -static-libgcc -s
-LDCXXFLAGS = -static-libstdc++
+LDFLAGS = -L. -static-libgcc
+LDCXXFLAGS = -static-libstdc++ -s
 
 ifeq ($(HAVE_SDL), 1)
    OBJ += gfx/sdl.o gfx/gl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
-   LIBS += -lSDL -lopengl32
+   LIBS += -lSDL
    DEFINES += -ISDL -DHAVE_SDL
 endif
 
+ifeq ($(HAVE_OPENGL), 1)
+   DEFINES += -DHAVE_OPENGL
+   LIBS += -lopengl32
+endif
+
 ifeq ($(HAVE_SDL_IMAGE), 1)
    LIBS += -lSDL_image
    DEFINES += -DHAVE_SDL_IMAGE
@@ -117,6 +124,12 @@ endif
 ifeq ($(HAVE_FFMPEG), 1)
    LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lz
    DEFINES += -DHAVE_FFMPEG -Iffmpeg
+   DEFINES += -DHAVE_FFMPEG_ALLOC_CONTEXT3
+   DEFINES += -DHAVE_FFMPEG_AVCODEC_OPEN2
+   DEFINES += -DHAVE_FFMPEG_AVIO_OPEN
+   DEFINES += -DHAVE_FFMPEG_AVFORMAT_WRITE_HEADER
+   DEFINES += -DHAVE_FFMPEG_AVFORMAT_NEW_STREAM
+   DEFINES += -DHAVE_X264RGB
    OBJ += record/ffemu.o
 endif
 
@@ -160,17 +173,21 @@ clean:
 	rm -f tools/*.o
 
 dist_x86: all
-	zip -r ssnes-win32-0.8.2.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+	zip -r ssnes-win32-0.9.2.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
 
 dist_x86_64: all
-	zip -r ssnes-win64-0.8.2.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+	zip -r ssnes-win64-0.9.2.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
 
 libs_x86:
 	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-libs.zip --no-check-certificate
 	unzip SSNES-win32-libs.zip
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-headers.zip --no-check-certificate
+	unzip SSNES-win32-headers.zip
 
 libs_x86_64:
 	wget https://github.com/downloads/Themaister/SSNES/SSNES-win64-libs.zip --no-check-certificate
 	unzip SSNES-win64-libs.zip
+	wget https://github.com/downloads/Themaister/SSNES/SSNES-win64-headers.zip --no-check-certificate
+	unzip SSNES-win64-headers.zip
 
 .PHONY: all install uninstall clean dist_x86 dist_x86_64 libs_x86 libs_x86_64

README.md

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

README.win32.txt

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

audio/alsa.c

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

audio/coreaudio.c

@@ -95,7 +95,7 @@ static OSStatus audio_cb(void *userdata, AudioUnitRenderActionFlags *action_flag
    return noErr;
 }
 
-static void* coreaudio_init(const char* device, unsigned rate, unsigned latency)
+static void *coreaudio_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
 
@@ -210,7 +210,7 @@ error:
    return NULL;
 }
 
-static ssize_t coreaudio_write(void* data, const void* buf_, size_t size)
+static ssize_t coreaudio_write(void *data, const void *buf_, size_t size)
 {
    coreaudio_t *dev = data;
 

audio/dsound.c

@@ -249,7 +249,7 @@ static void dsound_free(void *data)
    }
 }
 
-static void* dsound_init(const char *device, unsigned rate, unsigned latency)
+static void *dsound_init(const char *device, unsigned rate, unsigned latency)
 {
    dsound_t *ds = calloc(1, sizeof(*ds));
    if (!ds)

audio/ext.c

@@ -45,7 +45,7 @@ static void audio_ext_free(void *data)
    }
 }
 
-static void* audio_ext_init(const char *device, unsigned rate, unsigned latency)
+static void *audio_ext_init(const char *device, unsigned rate, unsigned latency)
 {
    if (!(*g_settings.audio.external_driver))
    {

audio/ext/ssnes_audio.h

@@ -61,7 +61,7 @@ typedef struct ssnes_audio_driver_info
 typedef struct ssnes_audio_driver
 {
    // Initializes the device.
-   void* (*init)(const ssnes_audio_driver_info_t *info);
+   void *(*init)(const ssnes_audio_driver_info_t *info);
 
    // Write data in buffer to audio driver.
    // A frame here is defined as one combined sample of left and right

audio/ext/ssnes_dsp.h

@@ -87,7 +87,7 @@ typedef struct ssnes_dsp_input
 typedef struct ssnes_dsp_plugin
 {
    // Creates a handle of the plugin. Returns NULL if failed.
-   void* (*init)(const ssnes_dsp_info_t *info);
+   void *(*init)(const ssnes_dsp_info_t *info);
 
    // Processes input data. 
    // The plugin is allowed to return variable sizes for output data.

audio/ext/ssnes_iir_filter.c

@@ -207,7 +207,7 @@ static void generate_filter_coeffs(float * restrict fir_out, float * restrict ii
 }
 
 
-static void* dsp_init(const ssnes_dsp_info_t *info)
+static void *dsp_init(const ssnes_dsp_info_t *info)
 {
    (void)info;
    dsp_state *state = calloc(1, sizeof(*state));

audio/hermite.c

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

audio/hermite.h

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

audio/jack.c

@@ -124,7 +124,7 @@ static size_t find_buffersize(jack_t *jd, int latency)
    return buffer_frames * sizeof(jack_default_audio_sample_t);
 }
 
-static void* __jack_init(const char* device, unsigned rate, unsigned latency)
+static void *ja_init(const char *device, unsigned rate, unsigned latency)
 {
    jack_t *jd = calloc(1, sizeof(jack_t));
    if (!jd)
@@ -246,32 +246,32 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
    return written * sizeof(float) * 2;
 }
 
-static ssize_t __jack_write(void* data, const void* buf, size_t size)
+static ssize_t ja_write(void *data, const void *buf, size_t size)
 {
    jack_t *jd = data;
 
    return write_buffer(jd, buf, size);
 }
 
-static bool __jack_stop(void *data)
+static bool ja_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_set_nonblock_state(void *data, bool state)
+static void ja_set_nonblock_state(void *data, bool state)
 {
    jack_t *jd = data;
    jd->nonblock = state;
 }
 
-static bool __jack_start(void *data)
+static bool ja_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_free(void *data)
+static void ja_free(void *data)
 {
    jack_t *jd = data;
 
@@ -292,20 +292,20 @@ static void __jack_free(void *data)
    free(jd);
 }
 
-static bool __jack_use_float(void *data)
+static bool ja_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
 const audio_driver_t audio_jack = {
-   .init = __jack_init,
-   .write = __jack_write,
-   .stop = __jack_stop,
-   .start = __jack_start,
-   .set_nonblock_state = __jack_set_nonblock_state,
-   .free = __jack_free,
-   .use_float = __jack_use_float,
+   .init = ja_init,
+   .write = ja_write,
+   .stop = ja_stop,
+   .start = ja_start,
+   .set_nonblock_state = ja_set_nonblock_state,
+   .free = ja_free,
+   .use_float = ja_use_float,
    .ident = "jack"
 };
 

audio/openal.c

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

audio/oss.c

@@ -41,7 +41,7 @@
 #define DEFAULT_OSS_DEV "/dev/dsp"
 #endif
 
-static void* __oss_init(const char* device, unsigned rate, unsigned latency)
+static void *oss_init(const char *device, unsigned rate, unsigned latency)
 {
    int *fd = calloc(1, sizeof(int));
    if (fd == NULL)
@@ -96,7 +96,7 @@ static void* __oss_init(const char* device, unsigned rate, unsigned latency)
    return fd;
 }
 
-static ssize_t __oss_write(void* data, const void* buf, size_t size)
+static ssize_t oss_write(void *data, const void *buf, size_t size)
 {
    int *fd = data;
 
@@ -114,19 +114,19 @@ static ssize_t __oss_write(void* data, const void* buf, size_t size)
    return ret;
 }
 
-static bool __oss_stop(void *data)
+static bool oss_stop(void *data)
 {
    int *fd = data;
    ioctl(*fd, SNDCTL_DSP_RESET, 0);
    return true;
 }
 
-static bool __oss_start(void *data)
+static bool oss_start(void *data)
 {
    return true;
 }
 
-static void __oss_set_nonblock_state(void *data, bool state)
+static void oss_set_nonblock_state(void *data, bool state)
 {
    int *fd = data;
    int rc;
@@ -138,7 +138,7 @@ static void __oss_set_nonblock_state(void *data, bool state)
       fprintf(stderr, "SSNES [ERROR]: Could not set nonblocking on OSS file descriptor. Will not be able to fast-forward.\n");
 }
 
-static void __oss_free(void *data)
+static void oss_free(void *data)
 {
    int *fd = data;
 
@@ -148,12 +148,12 @@ static void __oss_free(void *data)
 }
 
 const audio_driver_t audio_oss = {
-   .init = __oss_init,
-   .write = __oss_write,
-   .stop = __oss_stop,
-   .start = __oss_start,
-   .set_nonblock_state = __oss_set_nonblock_state,
-   .free = __oss_free,
+   .init = oss_init,
+   .write = oss_write,
+   .stop = oss_stop,
+   .start = oss_start,
+   .set_nonblock_state = oss_set_nonblock_state,
+   .free = oss_free,
    .ident = "oss"
 };
    

audio/pulse.c

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

audio/roar.c

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

audio/rsound.c

@@ -54,15 +54,15 @@ static void err_cb(void *userdata)
    SDL_CondSignal(rsd->cond);
 }
 
-static void* __rsd_init(const char* device, unsigned rate, unsigned latency)
+static void *rs_init(const char *device, unsigned rate, unsigned latency)
 {
    rsd_t *rsd = calloc(1, sizeof(rsd_t));
-   if ( rsd == NULL )
+   if (!rsd)
       return NULL;
 
    rsound_t *rd;
 
-   if ( rsd_init(&rd) < 0 )
+   if (rsd_init(&rd) < 0)
    {
       free(rsd);
       return NULL;
@@ -80,14 +80,14 @@ static void* __rsd_init(const char* device, unsigned rate, unsigned latency)
    rsd_set_param(rd, RSD_SAMPLERATE, &rate);
    rsd_set_param(rd, RSD_LATENCY, &latency);
 
-   if ( device != NULL )
+   if (device)
       rsd_set_param(rd, RSD_HOST, (void*)device);
 
    rsd_set_param(rd, RSD_FORMAT, &format);
 
    rsd_set_callback(rd, audio_cb, err_cb, 256, rsd);
 
-   if ( rsd_start(rd) < 0 )
+   if (rsd_start(rd) < 0)
    {
       free(rsd);
       rsd_free(rd);
@@ -98,7 +98,7 @@ static void* __rsd_init(const char* device, unsigned rate, unsigned latency)
    return rsd;
 }
 
-static ssize_t __rsd_write(void* data, const void* buf, size_t size)
+static ssize_t rs_write(void *data, const void *buf, size_t size)
 {
    rsd_t *rsd = data;
 
@@ -144,7 +144,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
    }
 }
 
-static bool __rsd_stop(void *data)
+static bool rs_stop(void *data)
 {
    rsd_t *rsd = data;
    rsd_stop(rsd->rd);
@@ -152,22 +152,22 @@ static bool __rsd_stop(void *data)
    return true;
 }
 
-static void __rsd_set_nonblock_state(void *data, bool state)
+static void rs_set_nonblock_state(void *data, bool state)
 {
    rsd_t *rsd = data;
    rsd->nonblock = state;
 }
 
-static bool __rsd_start(void *data)
+static bool rs_start(void *data)
 {
    rsd_t *rsd = data;
-   if ( rsd_start(rsd->rd) < 0)
+   if (rsd_start(rsd->rd) < 0)
       return false;
 
    return true;
 }
 
-static void __rsd_free(void *data)
+static void rs_free(void *data)
 {
    rsd_t *rsd = data;
 
@@ -182,12 +182,12 @@ static void __rsd_free(void *data)
 }
 
 const audio_driver_t audio_rsound = {
-   .init = __rsd_init,
-   .write = __rsd_write,
-   .stop = __rsd_stop,
-   .start = __rsd_start,
-   .set_nonblock_state = __rsd_set_nonblock_state,
-   .free = __rsd_free,
+   .init = rs_init,
+   .write = rs_write,
+   .stop = rs_stop,
+   .start = rs_start,
+   .set_nonblock_state = rs_set_nonblock_state,
+   .free = rs_free,
    .ident = "rsound"
 };
    

audio/sdl.c

@@ -58,7 +58,7 @@ static inline int find_num_frames(int rate, int latency)
    return next_pow2(frames);
 }
 
-static void* sdl_audio_init(const char* device, unsigned rate, unsigned latency)
+static void *sdl_audio_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
    if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
@@ -109,7 +109,7 @@ static void* sdl_audio_init(const char* device, unsigned rate, unsigned latency)
    return sdl;
 }
 
-static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
+static ssize_t sdl_audio_write(void *data, const void *buf, size_t size)
 {
    sdl_audio_t *sdl = data;
 

audio/utils.h

@@ -0,0 +1,82 @@
+#ifndef AUDIO_UTILS_H
+#define AUDIO_UTILS_H
+
+#include <stdint.h>
+
+#if __SSE2__
+#include <mmintrin.h>
+#include <emmintrin.h>
+#define audio_convert_s16_to_float audio_convert_s16_to_float_SSE2
+#define audio_convert_float_to_s16 audio_convert_float_to_s16_SSE2
+#else
+#define audio_convert_s16_to_float audio_convert_s16_to_float_C
+#define audio_convert_float_to_s16 audio_convert_float_to_s16_C
+#endif
+
+static inline void audio_convert_s16_to_float_C(float *out,
+      const int16_t *in, unsigned samples)
+{
+   for (unsigned i = 0; i < samples; i++)
+      out[i] = (float)in[i] / 0x8000; 
+}
+
+static inline void audio_convert_float_to_s16_C(int16_t *out,
+      const float *in, unsigned samples)
+{
+   for (unsigned i = 0; i < samples; i++)
+   {
+      int32_t val = in[i] * 0x8000;
+      out[i] = (val > 0x7FFF) ? 0x7FFF : (val < -0x8000 ? -0x8000 : (int16_t)val);
+   }
+}
+
+#if __SSE2__
+static inline void audio_convert_s16_to_float_SSE2(float *out,
+      const int16_t *in, unsigned samples)
+{
+   __m128 factor = _mm_set1_ps(1.0f / (0x7fff * 0x10000));
+   unsigned i;
+   for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+   {
+      __m128i input = _mm_loadu_si128((const __m128i *)in);
+      __m128i regs[2] = {
+         _mm_unpacklo_epi16(_mm_setzero_si128(), input),
+         _mm_unpackhi_epi16(_mm_setzero_si128(), input),
+      };
+
+      __m128 output[2] = {
+         _mm_mul_ps(_mm_cvtepi32_ps(regs[0]), factor),
+         _mm_mul_ps(_mm_cvtepi32_ps(regs[1]), factor),
+      };
+
+      _mm_storeu_ps(out + 0, output[0]);
+      _mm_storeu_ps(out + 4, output[1]);
+   }
+
+   audio_convert_s16_to_float_C(out, in, samples - i);
+}
+
+static inline void audio_convert_float_to_s16_SSE2(int16_t *out,
+      const float *in, unsigned samples)
+{
+   __m128 factor = _mm_set1_ps((float)0x7fff);
+   unsigned i;
+   for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
+   {
+      __m128 input[2] = { _mm_loadu_ps(in + 0), _mm_loadu_ps(in + 4) };
+      __m128 res[2] = { _mm_mul_ps(input[0], factor), _mm_mul_ps(input[1], factor) };
+
+      __m128i ints[2] = { _mm_cvtps_epi32(res[0]), _mm_cvtps_epi32(res[1]) };
+      __m128i packed = _mm_packs_epi32(ints[0], ints[1]);
+
+      _mm_storeu_si128((__m128i *)out, packed);
+   }
+
+   audio_convert_float_to_s16_C(out, in, samples - i);
+}
+
+
+#endif
+
+#endif
+

audio/xaudio-c/xaudio2.hpp

@@ -146,7 +146,7 @@ typedef struct XAUDIO2_BUFFER
    UINT32 LoopBegin;
    UINT32 LoopLength;
    UINT32 LoopCount;
-   void* pContext;
+   void *pContext;
 } XAUDIO2_BUFFER;
 
 typedef struct XAUDIO2_BUFFER_WMA
@@ -157,7 +157,7 @@ typedef struct XAUDIO2_BUFFER_WMA
 
 typedef struct XAUDIO2_VOICE_STATE
 {
-   void* pCurrentBufferContext;
+   void *pCurrentBufferContext;
    UINT32 BuffersQueued;
    UINT64 SamplesPlayed;
 } XAUDIO2_VOICE_STATE;
@@ -201,10 +201,10 @@ 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;
+   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)
@@ -219,10 +219,10 @@ DECLARE_INTERFACE(IXAudio2Voice)
          UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
    STDMETHOD_(void, GetEffectState) (THIS_ UINT32 EffectIndex, BOOL* pEnabled) PURE; \
    STDMETHOD(SetEffectParameters) (THIS_ UINT32 EffectIndex, \
-         const void* pParameters, \
+         const void *pParameters, \
          UINT32 ParametersByteSize, \
          UINT32 OperationSet X2DEFAULT(XAUDIO2_COMMIT_NOW)) PURE; \
-   STDMETHOD(GetEffectParameters) (THIS_ UINT32 EffectIndex, void* pParameters, \
+   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; \
@@ -304,7 +304,7 @@ DECLARE_INTERFACE_(IXAudio2, IUnknown)
    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;
+         void *pReserved X2DEFAULT(NULL)) PURE;
 };
 
 static inline HRESULT XAudio2Create(IXAudio2** ppXAudio2, UINT32 Flags X2DEFAULT(0),

audio/xaudio.c

@@ -26,7 +26,7 @@ typedef struct
    bool nonblock;
 } xa_t;
 
-static void* __xa_init(const char* device, unsigned rate, unsigned latency)
+static void *xa_init(const char *device, unsigned rate, unsigned latency)
 {
    if (latency < 8)
       latency = 8; // Do not allow shenanigans.
@@ -49,7 +49,7 @@ static void* __xa_init(const char* device, unsigned rate, unsigned latency)
    return xa;
 }
 
-static ssize_t __xa_write(void* data, const void* buf, size_t size)
+static ssize_t xa_write(void *data, const void *buf, size_t size)
 {
    xa_t *xa = data;
    if (xa->nonblock)
@@ -66,31 +66,31 @@ static ssize_t __xa_write(void* data, const void* buf, size_t size)
    return ret;
 }
 
-static bool __xa_stop(void *data)
+static bool xa_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_set_nonblock_state(void *data, bool state)
+static void xa_set_nonblock_state(void *data, bool state)
 {
    xa_t *xa = data;
    xa->nonblock = state;
 }
 
-static bool __xa_start(void *data)
+static bool xa_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static bool __xa_use_float(void *data)
+static bool xa_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __xa_free(void *data)
+static void xa_free(void *data)
 {
    xa_t *xa = data;
    if (xa)
@@ -102,13 +102,13 @@ static void __xa_free(void *data)
 }
 
 const audio_driver_t audio_xa = {
-   .init = __xa_init,
-   .write = __xa_write,
-   .stop = __xa_stop,
-   .start = __xa_start,
-   .set_nonblock_state = __xa_set_nonblock_state,
-   .use_float = __xa_use_float,
-   .free = __xa_free,
+   .init = xa_init,
+   .write = xa_write,
+   .stop = xa_stop,
+   .start = xa_start,
+   .set_nonblock_state = xa_set_nonblock_state,
+   .use_float = xa_use_float,
+   .free = xa_free,
    .ident = "xaudio"
 };
    

autosave.c

@@ -16,7 +16,7 @@
  */
 
 #include "autosave.h"
-#include "SDL.h"
+#include "thread.h"
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
@@ -26,11 +26,11 @@
 struct autosave
 {
    volatile bool quit;
-   SDL_mutex *lock;
+   slock_t *lock;
 
-   SDL_mutex *cond_lock;
-   SDL_cond *cond;
-   SDL_Thread *thread;
+   slock_t *cond_lock;
+   scond_t *cond;
+   sthread_t *thread;
 
    void *buffer;
    const void *snes_buffer;
@@ -39,7 +39,7 @@ struct autosave
    unsigned interval;
 };
 
-static int autosave_thread(void *data)
+static void autosave_thread(void *data)
 {
    autosave_t *save = data;
 
@@ -77,13 +77,11 @@ static int autosave_thread(void *data)
          }
       }
 
-      SDL_mutexP(save->cond_lock);
+      slock_lock(save->cond_lock);
       if (!save->quit)
-         SDL_CondWaitTimeout(save->cond, save->cond_lock, save->interval * 1000);
-      SDL_mutexV(save->cond_lock);
+         scond_wait_timeout(save->cond, save->cond_lock, save->interval * 1000);
+      slock_unlock(save->cond_lock);
    }
-
-   return 0;
 }
 
 autosave_t *autosave_new(const char *path, const void *data, size_t size, unsigned interval)
@@ -105,36 +103,36 @@ autosave_t *autosave_new(const char *path, const void *data, size_t size, unsign
    }
    memcpy(handle->buffer, handle->snes_buffer, handle->bufsize);
 
-   handle->lock = SDL_CreateMutex();
-   handle->cond_lock = SDL_CreateMutex();
-   handle->cond = SDL_CreateCond();
+   handle->lock = slock_new();
+   handle->cond_lock = slock_new();
+   handle->cond = scond_new();
 
-   handle->thread = SDL_CreateThread(autosave_thread, handle);
+   handle->thread = sthread_create(autosave_thread, handle);
 
    return handle;
 }
 
 void autosave_lock(autosave_t *handle)
 {
-   SDL_mutexP(handle->lock);
+   slock_lock(handle->lock);
 }
 
 void autosave_unlock(autosave_t *handle)
 {
-   SDL_mutexV(handle->lock);
+   slock_unlock(handle->lock);
 }
 
 void autosave_free(autosave_t *handle)
 {
-   SDL_mutexP(handle->cond_lock);
+   slock_lock(handle->cond_lock);
    handle->quit = true;
-   SDL_mutexV(handle->cond_lock);
-   SDL_CondSignal(handle->cond);
-   SDL_WaitThread(handle->thread, NULL);
+   slock_unlock(handle->cond_lock);
+   scond_signal(handle->cond);
+   sthread_join(handle->thread);
 
-   SDL_DestroyMutex(handle->lock);
-   SDL_DestroyMutex(handle->cond_lock);
-   SDL_DestroyCond(handle->cond);
+   slock_free(handle->lock);
+   slock_free(handle->cond_lock);
+   scond_free(handle->cond);
 
    free(handle->buffer);
    free(handle);

cheats.c

@@ -51,7 +51,7 @@ struct cheat_manager
    unsigned buf_size;
 };
 
-static char* strcat_alloc(char *dest, const char *input)
+static char *strcat_alloc(char *dest, const char *input)
 {
    size_t dest_len = dest ? strlen(dest) : 0;
    size_t input_len = strlen(input);

conf/config_file.c

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

conf/config_file.h

@@ -31,13 +31,21 @@ typedef struct config_file config_file_t;
 // - # are treated as comments. Rest of the line is ignored.
 // - Format is: key = value. There can be as many spaces as you like in-between.
 // - Value can be wrapped inside "" for multiword strings. (foo = "hai u")
+//
+// - #include includes a config file in-place.
+// Path is relative to where config file was loaded unless an absolute path is chosen.
+// Key/value pairs from an #include are read-only, and cannot be modified.
 
-// Loads a config file. Returns NULL if file doesn't exist. NULL path will create an empty config file.
+// Loads a config file. Returns NULL if file doesn't exist.
+// NULL path will create an empty config file.
 config_file_t *config_file_new(const char *path);
 // Frees config file.
 void config_file_free(config_file_t *conf);
 
-// All extract functions return true when value is valid and exists. Returns false otherwise.
+// All extract functions return true when value is valid and exists.
+// Returns false otherwise.
+
+bool config_entry_exists(config_file_t *conf, const char *entry);
 
 // Extracts a double from config file.
 bool config_get_double(config_file_t *conf, const char *entry, double *in);
@@ -54,7 +62,8 @@ bool config_get_array(config_file_t *conf, const char *entry, char *in, size_t s
 // Extracts a boolean from config. Valid boolean true are "true" and "1". Valid false are "false" and "0". Other values will be treated as an error.
 bool config_get_bool(config_file_t *conf, const char *entry, bool *in);
 
-// Setters. Similiar to the getters.
+// Setters. Similar to the getters. Will not write to entry if the entry
+// was obtained from an #include.
 void config_set_double(config_file_t *conf, const char *entry, double value);
 void config_set_int(config_file_t *conf, const char *entry, int val);
 void config_set_char(config_file_t *conf, const char *entry, char val);
@@ -66,7 +75,8 @@ bool config_file_write(config_file_t *conf, const char *path);
 
 // Dump the current config to an already opened file. Does not close the file.
 void config_file_dump(config_file_t *conf, FILE *file);
-
-
+// Also dumps inherited values, useful for logging.
+void config_file_dump_all(config_file_t *conf, FILE *file);
 
 #endif
+

config.def.h

@@ -32,10 +32,6 @@
 
 #include "input/keysym.h"
 
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#endif
-
 ///////////////// Drivers
 #define VIDEO_GL 0
 #define VIDEO_XVIDEO 11
@@ -59,7 +55,7 @@
 #define INPUT_X 12
 ////////////////////////
 
-#if defined(HAVE_SDL)
+#if defined(HAVE_OPENGL)
 #define VIDEO_DEFAULT_DRIVER VIDEO_GL
 #elif defined(HAVE_XVIDEO)
 #define VIDEO_DEFAULT_DRIVER VIDEO_XVIDEO
@@ -113,8 +109,8 @@
 ////////////////
 
 // Windowed
-static const float xscale = 3.0; // Real x res = 296 * xscale
-static const float yscale = 3.0; // Real y res = 224 * yscale
+static const float xscale = 3.0; // Real x res = aspect * base_size * xscale
+static const float yscale = 3.0; // Real y res = base_size * yscale
 
 // Fullscreen
 static const bool fullscreen = false;  // To start in Fullscreen or not
@@ -137,7 +133,7 @@ static const bool video_smooth = true;
 static const bool force_aspect = true; 
 
 // Crop overscanned frames (7/8 or 15/15 for interlaced frames).
-static const bool crop_overscan = false;
+static const bool crop_overscan = true;
 
 // Font size for on-screen messages.
 static const unsigned font_size = 48;
@@ -146,7 +142,7 @@ static const unsigned font_size = 48;
 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.
+static const uint32_t message_color = 0xffff00; // RGB hex value.
 
 // Render-to-texture before rendering to screen (multi-pass shaders)
 static const bool render_to_texture = false;
@@ -160,7 +156,18 @@ static const bool hires_record = false;
 // Record post-filtered (CPU filter) video rather than raw SNES output.
 static const bool post_filter_record = false;
 
-#define SNES_ASPECT_RATIO (4.0/3)
+// OSD-messages
+static const bool font_enable = true;
+
+// The accurate refresh rate of your monitor (Hz).
+// This is used to calculate audio input rate with the formula:
+// audio_input_rate = game_input_rate * display_refresh_rate / game_refresh_rate.
+// If the implementation does not report any values,
+// SNES NTSC defaults will be assumed for compatibility.
+// This value should stay close to 60Hz to avoid large pitch changes.
+// If your monitor does not run at 60Hz, or something close to it, disable VSync,
+// and leave this at its default.
+static const float refresh_rate = 59.95; 
 
 ////////////////
 // Audio
@@ -172,15 +179,11 @@ static const bool audio_enable = true;
 // Output samplerate
 static const unsigned out_rate = 48000; 
 
-// Input samplerate from libSNES. 
-// Lower this (slightly) if you are experiencing frequent audio dropouts while vsync is enabled.
-static const float in_rate = 31980.0; 
-
 // When changing input rate on-the-fly
 static const float audio_rate_step = 0.25;
 
 // Audio device (e.g. hw:0,0 or /dev/audio). If NULL, will use defaults.
-static const char* audio_device = NULL;
+static const char *audio_device = NULL;
 
 // Desired audio latency in milliseconds. Might not be honored if driver can't provide given latency.
 static const int out_latency = 64;
@@ -188,11 +191,6 @@ static const int out_latency = 64;
 // Will sync audio. (recommended) 
 static const bool audio_sync = true;
 
-// Defines the quality (and cpu reqirements) of samplerate conversion.
-#ifdef HAVE_SRC
-#define SAMPLERATE_QUALITY SRC_LINEAR
-#endif
-
 // Enables use of rewind. This will incur some memory footprint depending on the save state buffer.
 // This rewind only works when using bSNES core atm.
 static const bool rewind_enable = false;
@@ -204,7 +202,7 @@ static const unsigned rewind_buffer_size = 20 << 20; // 20MiB
 static const unsigned rewind_granularity = 1;
 
 // Pause gameplay when gameplay loses focus.
-static const bool pause_nonactive = true;
+static const bool pause_nonactive = false;
 
 // Saves non-volatile SRAM at a regular interval. It is measured in seconds. A value of 0 disables autosave.
 static const unsigned autosave_interval = 0;
@@ -216,6 +214,10 @@ static const bool netplay_client_swap_input = true;
 // This could potentially lead to buggy games.
 static const bool block_sram_overwrite = false;
 
+// When saving savestates, state index is automatically incremented before saving.
+// When the ROM is loaded, state index will be set to the highest existing value.
+static const bool savestate_auto_index = false;
+
 
 ////////////////////
 // Keybinds, Joypad
@@ -256,6 +258,7 @@ static const struct snes_keybind snes_keybinds_1[] = {
    { SSNES_REWIND,                     SK_r,      NO_BTN,      AXIS_NONE },
    { SSNES_MOVIE_RECORD_TOGGLE,        SK_o,      NO_BTN,      AXIS_NONE },
    { SSNES_PAUSE_TOGGLE,               SK_p,      NO_BTN,      AXIS_NONE },
+   { SSNES_FRAMEADVANCE,               SK_k,      NO_BTN,      AXIS_NONE },
    { SSNES_RESET,                      SK_h,      NO_BTN,      AXIS_NONE },
    { SSNES_SHADER_NEXT,                SK_m,      NO_BTN,      AXIS_NONE },
    { SSNES_SHADER_PREV,                SK_n,      NO_BTN,      AXIS_NONE },

config.features.h

@@ -14,6 +14,12 @@ static const bool _sdl_supp = true;
 static const bool _sdl_supp = false;
 #endif
 
+#ifdef HAVE_OPENGL
+static const bool _opengl_supp = true;
+#else
+static const bool _opengl_supp = false;
+#endif
+
 #ifdef HAVE_XVIDEO
 static const bool _xvideo_supp = true;
 #else
@@ -110,10 +116,10 @@ static const bool _ffmpeg_supp = true;
 static const bool _ffmpeg_supp = false;
 #endif
 
-#ifdef HAVE_SRC
-static const bool _src_supp = true;
+#ifdef HAVE_X264RGB
+static const bool _x264rgb_supp = true;
 #else
-static const bool _src_supp = false;
+static const bool _x264rgb_supp = false;
 #endif
 
 #ifdef HAVE_CONFIGFILE

docs/ssnes-joyconfig.1

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

docs/ssnes.1

@@ -1,6 +1,6 @@
 .\" ssnes.1:
 
-.TH  "SSNES" "1" "January 2011" "SSNES" "System Manager's Manual: ssnes"
+.TH  "SSNES" "1" "November 2011" "SSNES" "System Manager's Manual: ssnes"
 
 .SH NAME
 
@@ -27,6 +27,16 @@ If no rom file path is defined on the command line, \fBssnes\fR will try to load
 \fB--help, -h\fR
 Prints help text.
 
+.TP
+\fB--features\fR
+Prints available features compiled into SSNES, then exits.
+
+.TP
+\fB-L PATH, --libsnes PATH\fR
+Path to a libsnes implementation which is to be used.
+This option will override any setting in a config file.
+This option is only available if SSNES is compiled with dynamic libsnes loading.
+
 .TP
 \fB--save PATH, -s PATH\fR
 Overrides the path used for save ram (*.srm).
@@ -91,6 +101,7 @@ When using Sufami, save ram paths will be inferred from the Sufami BIOS path, no
 \fB--mouse PORT, -m PORT\fR
 Connects a Super Nintendo Mouse into port number PORT of the emulated SNES. Possible values for PORT are 1 and 2.
 
+.TP
 \fB--nodevice PORT, -N PORT\fR
 Disconnects an input device from port number PORT of the emulated SNES. Possible values for PORT are 1 and 2. This may be needed for some odd games to run properly.
 
@@ -115,11 +126,27 @@ Connects a four-way multitap into port 2 of the SNES. This allows for up to 5 pl
 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--size WIDTHxHEIGHT\fR
+Allows specifying the exact output width and height of FFmpeg recording. This option will override any configuration settings.
+The video input is scaled with point filtering before being encoded at the correct size.
+
 .TP
 \fB--bsvplay PATH, -P PATH\fR
 Play back a movie recorded in the .bsv format (bSNES). Cart ROM and movie file need to correspond.
 It also requires to play back with the same libsnes backend that was used for recording.
 
+.TP
+\fB--bsvrecord PATH, -R PATH\fR
+Start recording a .bsv video to PATH immediately after startup.
+
+.TP
+\fB--sram-mode MODE, -M MODE\fR
+MODE designates how to handle SRAM.
+The format of the second parameter is {no,}load-{no,}save.
+These two boolean values tell if SRAM loading and SRAM saving should take place.
+Note that noload-save implies that the SRAM will be overwritten with new data.
+
 .TP
 \fB--verbose, -v\fR
 Activates verbose logging.

driver.c

@@ -68,8 +68,10 @@ static const audio_driver_t *audio_drivers[] = {
 };
 
 static const video_driver_t *video_drivers[] = {
-#ifdef HAVE_SDL
+#ifdef HAVE_OPENGL
    &video_gl,
+#endif
+#ifdef HAVE_SDL
    &video_sdl,
 #endif
 #ifdef HAVE_XVIDEO
@@ -91,7 +93,7 @@ static const input_driver_t *input_drivers[] = {
 
 static void find_audio_driver(void)
 {
-   for (int i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
    {
       if (strcasecmp(g_settings.audio.driver, audio_drivers[i]->ident) == 0)
       {
@@ -101,7 +103,7 @@ static void find_audio_driver(void)
    }
    SSNES_ERR("Couldn't find any audio driver named \"%s\"\n", g_settings.audio.driver);
    fprintf(stderr, "Available audio drivers are:\n");
-   for (int i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(audio_drivers) / sizeof(audio_driver_t*); i++)
       fprintf(stderr, "\t%s\n", audio_drivers[i]->ident);
 
    exit(1);
@@ -109,7 +111,7 @@ static void find_audio_driver(void)
 
 static void find_video_driver(void)
 {
-   for (int i = 0; i < sizeof(video_drivers) / sizeof(video_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(video_drivers) / sizeof(video_driver_t*); i++)
    {
       if (strcasecmp(g_settings.video.driver, video_drivers[i]->ident) == 0)
       {
@@ -127,7 +129,7 @@ static void find_video_driver(void)
 
 static void find_input_driver(void)
 {
-   for (int i = 0; i < sizeof(input_drivers) / sizeof(input_driver_t*); i++)
+   for (unsigned i = 0; i < sizeof(input_drivers) / sizeof(input_driver_t*); i++)
    {
       if (strcasecmp(g_settings.input.driver, input_drivers[i]->ident) == 0)
       {
@@ -220,24 +222,72 @@ static void deinit_dsp_plugin(void)
    }
 }
 
+static void adjust_audio_input_rate(void)
+{
+   static bool first = true;
+   if (!first)
+      return;
+
+   if (g_extern.system.timing_set)
+   {
+      float timing_skew = fabs(1.0f - g_extern.system.timing.fps / g_settings.video.refresh_rate);
+      if (timing_skew > 0.05f) // We don't want to adjust pitch too much. If we have extreme cases, just don't readjust at all.
+      {
+         SSNES_LOG("Timings deviate too much. Will not adjust. (Display = %.2f Hz, Game = %.2lf Hz)\n",
+               g_settings.video.refresh_rate,
+               g_extern.system.timing.fps);
+
+         g_settings.video.refresh_rate = g_extern.system.timing.fps;
+      }
+   }
+
+   if (g_extern.system.timing_set)
+   {
+      g_settings.audio.in_rate = g_extern.system.timing.sample_rate *
+         (g_settings.video.refresh_rate / g_extern.system.timing.fps);
+   }
+   else
+   {
+      g_settings.audio.in_rate = 32040.5 *
+         (g_settings.video.refresh_rate / (21477272.0 / 357366.0)); // SNES metrics.
+   }
+
+   SSNES_LOG("Set audio input rate to: %.2f Hz.\n", g_settings.audio.in_rate);
+   first = false;
+}
+
 #define AUDIO_CHUNK_SIZE_BLOCKING 64
 #define AUDIO_CHUNK_SIZE_NONBLOCKING 2048 // So we don't get complete line-noise when fast-forwarding audio.
 #define AUDIO_MAX_RATIO 16
 void init_audio(void)
 {
+   // Accomodate rewind since at some point we might have two full buffers.
+   size_t max_bufsamples = AUDIO_CHUNK_SIZE_NONBLOCKING * 2;
+
+   // Used for recording even if audio isn't enabled.
+   assert((g_extern.audio_data.conv_outsamples = malloc(max_bufsamples * sizeof(int16_t) * AUDIO_MAX_RATIO)));
+   g_extern.audio_data.chunk_size = g_extern.audio_data.block_chunk_size;
+
+   // Needs to be able to hold full content of a full max_bufsamples in addition to its own.
+   assert((g_extern.audio_data.rewind_buf = malloc(max_bufsamples * sizeof(int16_t))));
+   g_extern.audio_data.rewind_size = max_bufsamples;
+
    if (!g_settings.audio.enable)
    {
       g_extern.audio_active = false;
       return;
    }
 
+   adjust_audio_input_rate();
    find_audio_driver();
 
    g_extern.audio_data.block_chunk_size = AUDIO_CHUNK_SIZE_BLOCKING;
    g_extern.audio_data.nonblock_chunk_size = AUDIO_CHUNK_SIZE_NONBLOCKING;
 
-   driver.audio_data = driver.audio->init(strlen(g_settings.audio.device) ? g_settings.audio.device : NULL, g_settings.audio.out_rate, g_settings.audio.latency);
-   if ( driver.audio_data == NULL )
+   driver.audio_data = driver.audio->init(*g_settings.audio.device ? g_settings.audio.device : NULL,
+         g_settings.audio.out_rate, g_settings.audio.latency);
+
+   if (!driver.audio_data)
       g_extern.audio_active = false;
 
    if (g_extern.audio_active && driver.audio->use_float && driver.audio->use_float(driver.audio_data))
@@ -248,55 +298,45 @@ void init_audio(void)
       driver.audio->set_nonblock_state(driver.audio_data, true);
       g_extern.audio_data.chunk_size = g_extern.audio_data.nonblock_chunk_size;
    }
-   else
-      g_extern.audio_data.chunk_size = g_extern.audio_data.block_chunk_size;
 
-#ifdef HAVE_SRC
-   int err;
-   g_extern.audio_data.source = src_new(g_settings.audio.src_quality, 2, &err);
+   g_extern.audio_data.source = hermite_new();
    if (!g_extern.audio_data.source)
       g_extern.audio_active = false;
-#else
-   g_extern.audio_data.source = hermite_new(2);
-   if (!g_extern.audio_data.source)
-      g_extern.audio_active = false;
-#endif
 
-   size_t max_bufsamples = g_extern.audio_data.block_chunk_size > g_extern.audio_data.nonblock_chunk_size ?
-      g_extern.audio_data.block_chunk_size : g_extern.audio_data.nonblock_chunk_size;
-
-   assert(g_settings.audio.out_rate < g_settings.audio.in_rate * AUDIO_MAX_RATIO);
    assert((g_extern.audio_data.data = malloc(max_bufsamples * sizeof(float))));
    g_extern.audio_data.data_ptr = 0;
+   assert(g_settings.audio.out_rate < g_settings.audio.in_rate * AUDIO_MAX_RATIO);
    assert((g_extern.audio_data.outsamples = malloc(max_bufsamples * sizeof(float) * AUDIO_MAX_RATIO)));
-   assert((g_extern.audio_data.conv_outsamples = malloc(max_bufsamples * sizeof(int16_t) * AUDIO_MAX_RATIO)));
+
+   g_extern.audio_data.src_ratio =
+      (double)g_settings.audio.out_rate / g_settings.audio.in_rate;
 
    init_dsp_plugin();
 }
 
 void uninit_audio(void)
 {
+   free(g_extern.audio_data.conv_outsamples); g_extern.audio_data.conv_outsamples = NULL;
+   g_extern.audio_data.data_ptr = 0;
+   free(g_extern.audio_data.rewind_buf);
+   g_extern.audio_data.rewind_buf = NULL;
+
    if (!g_settings.audio.enable)
    {
       g_extern.audio_active = false;
       return;
    }
 
-   if ( driver.audio_data && driver.audio )
+   if (driver.audio_data && driver.audio)
       driver.audio->free(driver.audio_data);
 
-   if ( g_extern.audio_data.source )
-   {
-#ifdef HAVE_SRC
-      src_delete(g_extern.audio_data.source);
-#else
+   if (g_extern.audio_data.source)
       hermite_free(g_extern.audio_data.source);
-#endif
-   }
 
-   free(g_extern.audio_data.data); g_extern.audio_data.data = NULL;
-   free(g_extern.audio_data.outsamples); g_extern.audio_data.outsamples = NULL;
-   free(g_extern.audio_data.conv_outsamples); g_extern.audio_data.conv_outsamples = NULL;
+   free(g_extern.audio_data.data);
+   g_extern.audio_data.data = NULL;
+   free(g_extern.audio_data.outsamples);
+   g_extern.audio_data.outsamples = NULL;
 
    deinit_dsp_plugin();
 }
@@ -333,17 +373,17 @@ static void init_filter(void)
 
    g_extern.filter.active = true;
 
-   unsigned width = 512;
-   unsigned height = 512;
+   unsigned width = g_extern.system.geom.max_width;
+   unsigned height = g_extern.system.geom.max_height;
    g_extern.filter.psize(&width, &height);
 
    unsigned pow2_x = next_pow2(ceil(width));
    unsigned pow2_y = next_pow2(ceil(height));
    unsigned maxsize = pow2_x > pow2_y ? pow2_x : pow2_y; 
-   g_extern.filter.scale = maxsize / 256;
+   g_extern.filter.scale = maxsize / SSNES_SCALE_BASE;
 
-   g_extern.filter.buffer = malloc(256 * 256 * g_extern.filter.scale * g_extern.filter.scale * sizeof(uint32_t));
-   g_extern.filter.pitch = 256 * g_extern.filter.scale * sizeof(uint32_t);
+   g_extern.filter.buffer = malloc(SSNES_SCALE_BASE * SSNES_SCALE_BASE * g_extern.filter.scale * g_extern.filter.scale * sizeof(uint32_t));
+   g_extern.filter.pitch = SSNES_SCALE_BASE * g_extern.filter.scale * sizeof(uint32_t);
    assert(g_extern.filter.buffer);
 
    g_extern.filter.colormap = malloc(32768 * sizeof(uint32_t));
@@ -415,8 +455,9 @@ void init_video_input(void)
    init_shader_dir();
 #endif
 
-   // We use at least 512x512 textures to accomodate for hi-res games.
-   unsigned scale = 2;
+   unsigned max_dim = max(g_extern.system.geom.max_width, g_extern.system.geom.max_height);
+   unsigned scale = max_dim / SSNES_SCALE_BASE;
+   scale = max(scale, 1);
 
    find_video_driver();
    find_input_driver();
@@ -433,18 +474,26 @@ void init_video_input(void)
    }
    else
    {
-      if (g_settings.video.force_aspect)
+      if (g_settings.video.force_aspect && (g_settings.video.aspect_ratio > 0.0f))
       {
-         width = 224 * g_settings.video.xscale * g_settings.video.aspect_ratio;
-         height = 224 * g_settings.video.yscale;
+         width = roundf(g_extern.system.geom.base_height * g_settings.video.xscale * g_settings.video.aspect_ratio);
+         height = roundf(g_extern.system.geom.base_height * g_settings.video.yscale);
       }
       else
       {
-         width = 256 * g_settings.video.xscale;
-         height = 224 * g_settings.video.yscale;
+         width = roundf(g_extern.system.geom.base_width * g_settings.video.xscale);
+         height = roundf(g_extern.system.geom.base_height * g_settings.video.yscale);
       }
    }
 
+   if (g_settings.video.aspect_ratio < 0.0f)
+   {
+      g_settings.video.aspect_ratio = (float)g_extern.system.geom.base_width / g_extern.system.geom.base_height;
+      SSNES_LOG("Adjusting aspect ratio to %.2f\n", g_settings.video.aspect_ratio);
+   }
+
+   SSNES_LOG("Video @ %ux%u\n", width, height);
+
    video_info_t video = {
       .width = width,
       .height = height,

driver.h

@@ -26,9 +26,11 @@
 #include <unistd.h>
 #include "input/keysym.h"
 
+// SNES has 12 buttons from 0-11 (libsnes.hpp)
+#define SSNES_FIRST_META_KEY 12
 enum
 {
-   SSNES_FAST_FORWARD_KEY = 12, // SNES has 12 buttons from 0-11 (libsnes.hpp)
+   SSNES_FAST_FORWARD_KEY = SSNES_FIRST_META_KEY,
    SSNES_FAST_FORWARD_HOLD_KEY,
    SSNES_LOAD_STATE_KEY,
    SSNES_SAVE_STATE_KEY,
@@ -41,6 +43,7 @@ enum
    SSNES_REWIND,
    SSNES_MOVIE_RECORD_TOGGLE,
    SSNES_PAUSE_TOGGLE,
+   SSNES_FRAMEADVANCE,
    SSNES_RESET,
    SSNES_SHADER_NEXT,
    SSNES_SHADER_PREV,
@@ -76,12 +79,12 @@ typedef struct video_info
 
 typedef struct audio_driver
 {
-   void* (*init)(const char* device, unsigned rate, unsigned latency);
-   ssize_t (*write)(void* data, const void* buf, size_t size);
-   bool (*stop)(void* data);
-   bool (*start)(void* data);
-   void (*set_nonblock_state)(void* data, bool toggle); // Should we care about blocking in audio thread? Fast forwarding.
-   void (*free)(void* data);
+   void *(*init)(const char *device, unsigned rate, unsigned latency);
+   ssize_t (*write)(void *data, const void *buf, size_t size);
+   bool (*stop)(void *data);
+   bool (*start)(void *data);
+   void (*set_nonblock_state)(void *data, bool toggle); // Should we care about blocking in audio thread? Fast forwarding.
+   void (*free)(void *data);
    bool (*use_float)(void *data); // Defines if driver will take standard floating point samples, or int16_t samples.
    const char *ident;
 } audio_driver_t;
@@ -107,25 +110,25 @@ typedef struct audio_driver
 
 typedef struct input_driver
 {
-   void* (*init)(void);
-   void (*poll)(void* data);
-   int16_t (*input_state)(void* data, const struct snes_keybind **snes_keybinds, bool port, unsigned device, unsigned index, unsigned id);
-   bool (*key_pressed)(void* data, int key);
-   void (*free)(void* data);
+   void *(*init)(void);
+   void (*poll)(void *data);
+   int16_t (*input_state)(void *data, const struct snes_keybind **snes_keybinds, bool port, unsigned device, unsigned index, unsigned id);
+   bool (*key_pressed)(void *data, int key);
+   void (*free)(void *data);
    const char *ident;
 } input_driver_t;
 
 typedef struct video_driver
 {
-   void* (*init)(const video_info_t *video, const input_driver_t **input, void **input_data); 
+   void *(*init)(const video_info_t *video, const input_driver_t **input, void **input_data); 
    // Should the video driver act as an input driver as well? :) The video init might preinitialize an input driver to override the settings in case the video driver relies on input driver for event handling, e.g.
-   bool (*frame)(void* data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg); // msg is for showing a message on the screen along with the video frame.
-   void (*set_nonblock_state)(void* data, bool toggle); // Should we care about syncing to vblank? Fast forwarding.
+   bool (*frame)(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg); // msg is for showing a message on the screen along with the video frame.
+   void (*set_nonblock_state)(void *data, bool toggle); // Should we care about syncing to vblank? Fast forwarding.
    // Is the window still active?
    bool (*alive)(void *data);
    bool (*focus)(void *data); // Does the window have focus?
    bool (*xml_shader)(void *data, const char *path); // Sets XML-shader. Might not be implemented.
-   void (*free)(void* data);
+   void (*free)(void *data);
    const char *ident;
 } video_driver_t;
 

dynamic.c

@@ -17,6 +17,7 @@
 
 #include "dynamic.h"
 #include "general.h"
+#include "strl.h"
 #include <string.h>
 #include <assert.h>
 
@@ -38,16 +39,15 @@
 #define SYM(type, x) do { \
    p##x = (type)DLSYM(lib_handle, x); \
    if (p##x == NULL) { SSNES_ERR("Failed to load symbol: \"%s\"\n", #x); exit(1); } \
-} while(0)
+} while (0)
 
 #define OPT_SYM(type, x) do { \
    p##x = (type)DLSYM(lib_handle, x); \
-} while(0)
+} while (0)
 
 static dylib_t lib_handle = NULL;
 #endif
 
-
 void (*psnes_init)(void);
 
 void (*psnes_set_video_refresh)(snes_video_refresh_t);
@@ -96,6 +96,10 @@ unsigned (*psnes_get_memory_size)(unsigned);
 void (*psnes_unload_cartridge)(void);
 void (*psnes_term)(void);
 
+#ifdef HAVE_DYLIB
+static void set_environment(void);
+#endif
+
 #ifdef HAVE_DYNAMIC
 static void load_dynamic(void)
 {
@@ -112,7 +116,7 @@ static void load_dynamic(void)
    SYM(void (*)(snes_audio_sample_t), snes_set_audio_sample);
    SYM(void (*)(snes_input_poll_t), snes_set_input_poll);
    SYM(void (*)(snes_input_state_t), snes_set_input_state);
-   OPT_SYM(const char *(*)(void), snes_library_id);
+   SYM(const char *(*)(void), snes_library_id);
    SYM(unsigned (*)(void), snes_library_revision_minor);
    SYM(unsigned (*)(void), snes_library_revision_major);
    SYM(void (*)(void), snes_cheat_reset);
@@ -144,7 +148,7 @@ static void load_dynamic(void)
 
 #define SSYM(x) do { \
    p##x = x; \
-} while(0)
+} while (0)
 
 #ifndef HAVE_DYNAMIC
 static void set_statics(void)
@@ -156,6 +160,7 @@ static void set_statics(void)
    SSYM(snes_set_input_state);
    SSYM(snes_library_revision_minor);
    SSYM(snes_library_revision_major);
+   SSYM(snes_library_id);
    SSYM(snes_cheat_reset);
    SSYM(snes_cheat_set);
    SSYM(snes_reset);
@@ -180,39 +185,41 @@ static void set_statics(void)
 
 void init_dlsym(void)
 {
-   // Guarantee that we can do "dirty" casting. Every OS that this program supports should pass this ...
+   // Guarantee that we can do "dirty" casting.
+   // Every OS that this program supports should pass this ...
    assert(sizeof(void*) == sizeof(void (*)(void)));
 
 #ifdef HAVE_DYNAMIC
 
-#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)
+   // Try to verify that -lsnes was not linked in from other modules
+   // since loading it dynamically and with -l will fail hard.
+   function_t sym = dylib_proc(NULL, "snes_init");
+   if (sym)
    {
-      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
-   {
-      SSNES_ERR("This binary is built to use runtime dynamic binding of libsnes. Set libsnes_path in config to load a libsnes library dynamically.\n");
+      SSNES_ERR("Serious problem! SSNES wants to load libsnes dyamically, but it is already linked!\n"); 
+      SSNES_ERR("This could happen if other modules SSNES depends on link against libsnes directly.\n");
+      SSNES_ERR("Proceeding could cause a crash! Aborting ...\n");
       exit(1);
    }
+
+   if (!*g_settings.libsnes)
+   {
+#if defined(_WIN32)
+      strlcpy(g_settings.libsnes, "snes.dll", sizeof(g_settings.libsnes));
+#elif defined(__APPLE__)
+      strlcpy(g_settings.libsnes, "libsnes.dylib", sizeof(g_settings.libsnes));
 #else
-      set_statics();
+      strlcpy(g_settings.libsnes, "libsnes.so", sizeof(g_settings.libsnes));
+#endif
+   }
+
+   load_dynamic();
+#else
+   set_statics();
+#endif
+
+#ifdef HAVE_DYLIB
+   set_environment();
 #endif
 }
 
@@ -237,16 +244,26 @@ dylib_t dylib_load(const char *path)
 function_t dylib_proc(dylib_t lib, const char *proc)
 {
 #ifdef _WIN32
-   function_t sym = (function_t)GetProcAddress(lib, proc);
+   function_t sym = (function_t)GetProcAddress(lib ? lib : GetModuleHandle(NULL), proc);
 #else
-   // Dirty hack to workaround the non-legality of void* -> fn-pointer casts.
-   void *ptr_sym = dlsym(lib, proc); 
+   void *ptr_sym = NULL;
+   if (lib)
+      ptr_sym = dlsym(lib, proc); 
+   else
+   {
+      void *handle = dlopen(NULL, RTLD_LAZY);
+      if (handle)
+      {
+         ptr_sym = dlsym(handle, proc);
+         dlclose(handle);
+      }
+   }
+
+   // Dirty hack to workaround the non-legality of (void*) -> fn-pointer casts.
    function_t sym;
    memcpy(&sym, &ptr_sym, sizeof(void*));
 #endif
 
-   if (!sym)
-      SSNES_WARN("Failed to load symbol \"%s\"\n", proc);
    return sym;
 }
 
@@ -259,3 +276,82 @@ void dylib_close(dylib_t lib)
 #endif
 }
 
+static bool environment_cb(unsigned cmd, void *data)
+{
+   switch (cmd)
+   {
+      case SNES_ENVIRONMENT_GET_FULLPATH:
+         *(const char**)data = g_extern.system.fullpath;
+         SSNES_LOG("FULLPATH: \"%s\"\n", g_extern.system.fullpath);
+         break;
+
+      case SNES_ENVIRONMENT_SET_GEOMETRY:
+         g_extern.system.geom = *(const struct snes_geometry*)data;
+         g_extern.system.geom.max_width = next_pow2(g_extern.system.geom.max_width);
+         g_extern.system.geom.max_height = next_pow2(g_extern.system.geom.max_height);
+         SSNES_LOG("SET_GEOMETRY: (%ux%u) / (%ux%u)\n",
+               g_extern.system.geom.base_width,
+               g_extern.system.geom.base_height,
+               g_extern.system.geom.max_width,
+               g_extern.system.geom.max_height);
+         break;
+
+      case SNES_ENVIRONMENT_SET_PITCH:
+         g_extern.system.pitch = *(const unsigned*)data;
+         SSNES_LOG("SET_PITCH: %u\n", g_extern.system.pitch);
+         break;
+
+      case SNES_ENVIRONMENT_GET_OVERSCAN:
+         *(bool*)data = !g_settings.video.crop_overscan;
+         SSNES_LOG("GET_OVERSCAN: %u\n", (unsigned)!g_settings.video.crop_overscan);
+         break;
+
+      case SNES_ENVIRONMENT_SET_TIMING:
+         g_extern.system.timing = *(const struct snes_system_timing*)data;
+         g_extern.system.timing_set = true;
+         break;
+
+      case SNES_ENVIRONMENT_GET_CAN_DUPE:
+         *(bool*)data = true;
+         break;
+
+      default:
+         return false;
+   }
+
+   return true;
+}
+
+#ifdef HAVE_DYLIB
+// Assume SNES as defaults.
+static void set_environment_defaults(void)
+{
+   g_extern.system.pitch = 0; // 0 is classic libsnes semantics.
+   g_extern.system.geom = (struct snes_geometry) {
+      .base_width = 256,
+      .base_height = 224,
+      .max_width = 512,
+      .max_height = 512,
+   };
+}
+
+// SSNES extension hooks. Totally optional 'n shizz :)
+static void set_environment(void)
+{
+#ifdef HAVE_DYNAMIC
+   dylib_t lib = lib_handle;
+#else
+   dylib_t lib = NULL;
+#endif
+
+   void (*psnes_set_environment)(snes_environment_t) = 
+      (void (*)(snes_environment_t))dylib_proc(lib, "snes_set_environment");
+
+   if (psnes_set_environment)
+      psnes_set_environment(environment_cb);
+
+   set_environment_defaults();
+}
+#endif
+
+

dynamic.h

@@ -41,7 +41,7 @@ extern void (*psnes_set_input_state)(snes_input_state_t);
 extern void (*psnes_cheat_reset)(void);
 extern void (*psnes_cheat_set)(unsigned, bool, const char*);
 
-extern const char* (*psnes_library_id)(void);
+extern const char *(*psnes_library_id)(void);
 extern unsigned (*psnes_library_revision_minor)(void);
 extern unsigned (*psnes_library_revision_major)(void);
 

fifo_buffer.c

@@ -14,16 +14,17 @@
  */
 
 #include "fifo_buffer.h"
+#include <stdint.h>
 
 struct fifo_buffer
 {
-   char *buffer;
+   uint8_t *buffer;
    size_t bufsize;
    size_t first;
    size_t end;
 };
 
-fifo_buffer_t* fifo_new(size_t size)
+fifo_buffer_t *fifo_new(size_t size)
 {
    fifo_buffer_t *buf = calloc(1, sizeof(*buf));
    if (buf == NULL)
@@ -40,20 +41,14 @@ fifo_buffer_t* fifo_new(size_t size)
    return buf;
 }
 
-void fifo_free(fifo_buffer_t* buffer)
+void fifo_free(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    free(buffer->buffer);
    free(buffer);
 }
 
-size_t fifo_read_avail(fifo_buffer_t* buffer)
+size_t fifo_read_avail(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    size_t first = buffer->first;
    size_t end = buffer->end;
    if (end < first)
@@ -61,11 +56,8 @@ size_t fifo_read_avail(fifo_buffer_t* buffer)
    return end - first;
 }
 
-size_t fifo_write_avail(fifo_buffer_t* buffer)
+size_t fifo_write_avail(fifo_buffer_t *buffer)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    size_t first = buffer->first;
    size_t end = buffer->end;
    if (end < first)
@@ -74,13 +66,8 @@ size_t fifo_write_avail(fifo_buffer_t* buffer)
    return (buffer->bufsize - 1) - (end - first);
 }
 
-void fifo_write(fifo_buffer_t* buffer, const void* in_buf, size_t size)
+void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-   assert(in_buf);
-   assert(fifo_write_avail(buffer) >= size);
-
    size_t first_write = size;
    size_t rest_write = 0;
    if (buffer->end + size > buffer->bufsize)
@@ -91,19 +78,14 @@ void fifo_write(fifo_buffer_t* buffer, const void* in_buf, size_t size)
 
    memcpy(buffer->buffer + buffer->end, in_buf, first_write);
    if (rest_write > 0)
-      memcpy(buffer->buffer, (const char*)in_buf + first_write, rest_write);
+      memcpy(buffer->buffer, (const uint8_t*)in_buf + first_write, rest_write);
 
    buffer->end = (buffer->end + size) % buffer->bufsize;
 }
 
 
-void fifo_read(fifo_buffer_t* buffer, void* in_buf, size_t size)
+void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-   assert(in_buf);
-   assert(fifo_read_avail(buffer) >= size);
-
    size_t first_read = size;
    size_t rest_read = 0;
    if (buffer->first + size > buffer->bufsize)
@@ -112,9 +94,9 @@ void fifo_read(fifo_buffer_t* buffer, void* in_buf, size_t size)
       rest_read = size - first_read;
    }
 
-   memcpy(in_buf, (const char*)buffer->buffer + buffer->first, first_read);
+   memcpy(in_buf, (const uint8_t*)buffer->buffer + buffer->first, first_read);
    if (rest_read > 0)
-      memcpy((char*)in_buf + first_read, buffer->buffer, rest_read);
+      memcpy((uint8_t*)in_buf + first_read, buffer->buffer, rest_read);
 
    buffer->first = (buffer->first + size) % buffer->bufsize;
 }

fifo_buffer.h

@@ -26,11 +26,11 @@
 typedef struct fifo_buffer fifo_buffer_t;
 #endif
 
-fifo_buffer_t* fifo_new(size_t size);
-void fifo_write(fifo_buffer_t* buffer, const void* in_buf, size_t size);
-void fifo_read(fifo_buffer_t* buffer, void* in_buf, size_t size);
-void fifo_free(fifo_buffer_t* buffer);
-size_t fifo_read_avail(fifo_buffer_t* buffer);
-size_t fifo_write_avail(fifo_buffer_t* buffer);
+fifo_buffer_t *fifo_new(size_t size);
+void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size);
+void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size);
+void fifo_free(fifo_buffer_t *buffer);
+size_t fifo_read_avail(fifo_buffer_t *buffer);
+size_t fifo_write_avail(fifo_buffer_t *buffer);
 
 #endif

file.c

@@ -251,7 +251,7 @@ static ssize_t read_rom_file(FILE* file, void** buf)
          return -1;
       }
 
-      for(;;)
+      for (;;)
       {
          size_t ret = fread(rom_buf + buf_ptr, 1, buf_size - buf_ptr, stdin);
          buf_ptr += ret;
@@ -510,7 +510,7 @@ void load_ram_file(const char *path, int type)
    void *buf = NULL;
    ssize_t rc = read_file(path, &buf);
    if (rc <= size)
-      memcpy(data, buf, size);
+      memcpy(data, buf, rc);
 
    free(buf);
 }
@@ -531,7 +531,7 @@ void save_ram_file(const char *path, int type)
    }
 }
 
-static char* load_xml_map(const char *path)
+static char *load_xml_map(const char *path)
 {
    char *xml_buf = NULL;
    if (*path)
@@ -801,7 +801,7 @@ bool init_rom_file(enum ssnes_game_type type)
 }
 
 // Yep, this is C alright ;)
-char** dir_list_new(const char *dir, const char *ext)
+char **dir_list_new(const char *dir, const char *ext)
 {
    size_t cur_ptr = 0;
    size_t cur_size = 32;
@@ -818,8 +818,12 @@ char** dir_list_new(const char *dir, const char *ext)
       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;
+
+   if (ext)
+   {
+      if (strlcat(utf8_buf, ext, sizeof(utf8_buf)) >= sizeof(utf8_buf))
+         goto error;
+   }
 
    if (MultiByteToWideChar(CP_UTF8, 0, utf8_buf, -1, wchar_buf, MAXPATHLEN) == 0)
       goto error;

file.h

@@ -26,6 +26,8 @@
 #include <sys/types.h>
 #include "general.h"
 
+// Generic file, path and directory handling.
+
 ssize_t read_file(const char *path, void **buf);
 
 bool load_state(const char *path);
@@ -37,7 +39,9 @@ void save_ram_file(const char *path, int type);
 bool init_rom_file(enum ssnes_game_type type);
 
 // Returns a NULL-terminated list of files in a directory with full paths.
-char** dir_list_new(const char *dir, const char *ext);
+// If ext is NULL, any file will be picked.
+// If non-NULL, only files with extension ext are added.
+char **dir_list_new(const char *dir, const char *ext);
 void dir_list_free(char **dir_list);
 
 bool path_is_directory(const char *path);

general.h

@@ -20,8 +20,9 @@
 #define __SSNES_GENERAL_H
 
 #include <stdbool.h>
-#include "driver.h"
 #include <stdio.h>
+#include <time.h>
+#include "driver.h"
 #include "record/ffemu.h"
 #include "message.h"
 #include "rewind.h"
@@ -36,14 +37,13 @@
 #include "config.h"
 #endif
 
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#else
 #include "audio/hermite.h"
-#endif
 
 #ifndef _WIN32
 #include <sys/param.h> // MAXPATHLEN
+#else
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 #endif
 
 #ifndef MAXPATHLEN
@@ -86,6 +86,7 @@ struct settings
       char bsnes_shader_path[MAXPATHLEN];
       char filter_path[MAXPATHLEN];
       enum ssnes_shader_type shader_type;
+      float refresh_rate;
 
       bool render_to_texture;
       double fbo_scale_x;
@@ -96,6 +97,7 @@ struct settings
 
       char font_path[MAXPATHLEN];
       unsigned font_size;
+      bool font_enable;
       float msg_pos_x;
       float msg_pos_y;
       float msg_color_r;
@@ -121,7 +123,6 @@ struct settings
       char device[MAXPATHLEN];
       unsigned latency;
       bool sync;
-      int src_quality;
 
       char dsp_plugin[MAXPATHLEN];
       char external_driver[MAXPATHLEN];
@@ -143,13 +144,14 @@ struct settings
    char screenshot_directory[MAXPATHLEN];
 
    bool rewind_enable;
-   unsigned rewind_buffer_size;
+   size_t rewind_buffer_size;
    unsigned rewind_granularity;
 
    bool pause_nonactive;
    unsigned autosave_interval;
 
    bool block_sram_overwrite;
+   bool savestate_auto_index;
 };
 
 enum ssnes_game_type
@@ -209,11 +211,16 @@ struct global
 
    struct
    {
-#ifdef HAVE_SRC
-      SRC_STATE *source;
-#else
+      struct snes_geometry geom;
+      unsigned pitch; // If 0, has classic libsnes semantics.
+      char fullpath[MAXPATHLEN];
+      struct snes_system_timing timing;
+      bool timing_set;
+   } system;
+
+   struct
+   {
       hermite_resampler_t *source;
-#endif
 
       float *data;
       size_t data_ptr;
@@ -221,11 +228,17 @@ struct global
       size_t nonblock_chunk_size;
       size_t block_chunk_size;
 
+      double src_ratio;
+
       bool use_float;
 
       float *outsamples;
       int16_t *conv_outsamples;
 
+      int16_t *rewind_buf;
+      size_t rewind_ptr;
+      size_t rewind_size;
+
       dylib_t dsp_lib;
       const ssnes_dsp_plugin_t *dsp_plugin;
       void *dsp_handle;
@@ -252,14 +265,26 @@ struct global
    void *state_buf;
    bool frame_is_reverse;
 
-   // Movie record support
-   bsv_movie_t *bsv_movie;
-   char bsv_movie_path[MAXPATHLEN];
-   bool bsv_movie_end;
-   bool bsv_movie_playback;
+   // Movie playback/recording support.
+   struct
+   {
+      bsv_movie_t *movie;
+      char movie_path[MAXPATHLEN];
+      bool movie_playback;
+
+      // Immediate playback/recording.
+      char movie_start_path[MAXPATHLEN];
+      bool movie_start_recording;
+      bool movie_start_playback;
+      bool movie_end;
+   } bsv;
+
+   bool sram_load_disable;
+   bool sram_save_disable;
 
    // Pausing support
    bool is_paused;
+   bool is_oneshot;
 
    // Autosave support.
    autosave_t *autosave[2];
@@ -277,21 +302,28 @@ struct global
    ffemu_t *rec;
    char record_path[MAXPATHLEN];
    bool recording;
+   unsigned record_width;
+   unsigned record_height;
 #endif
 
+   struct
+   {
+      const uint16_t *data;
+      unsigned width;
+      unsigned height;
+   } frame_cache;
+
    char title_buf[64];
 
    struct
    {
-      char** elems;
+      char **elems;
       size_t size;
       size_t ptr;
    } shader_dir;
 
    char sha256[64 + 1];
 
-   bool do_screenshot;
-
 #ifdef HAVE_XML
    cheat_manager_t *cheat;
 #endif
@@ -306,17 +338,27 @@ extern struct global g_extern;
    if (g_extern.verbose) \
       fprintf(stderr, "SSNES: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
 
 #define SSNES_ERR(...) do { \
       fprintf(stderr, "SSNES [ERROR] :: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
 
 #define SSNES_WARN(...) do { \
       fprintf(stderr, "SSNES [WARN] :: " __VA_ARGS__); \
       fflush(stderr); \
-   } while(0)
+   } while (0)
+
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#define SSNES_SCALE_BASE 256
 
 static inline uint32_t next_pow2(uint32_t v)
 {
@@ -342,6 +384,19 @@ static inline uint8_t is_little_endian(void)
    return u.y[0];
 }
 
+static inline void ssnes_sleep(unsigned usec)
+{
+#ifdef _WIN32
+   Sleep(10);
+#else
+   struct timespec tv = {
+      .tv_sec = 0,
+      .tv_nsec = 10000000
+   };
+   nanosleep(&tv, NULL);
+#endif
+}
+
 #endif
 
 

gfx/ext.c

@@ -25,6 +25,16 @@
 #include "dynamic.h"
 #include "general.h"
 #include "sdlwrap.h"
+#include "gfx_common.h"
+
+#ifdef HAVE_FREETYPE
+#include "fonts.h"
+#endif
+
+#ifdef HAVE_PYTHON
+#define PY_STATE_OMIT_DECLARATION
+#include "py_state/py_state.h"
+#endif
 
 static bool g_input_dead = true;
 static bool g_video_dead = true;
@@ -38,7 +48,7 @@ typedef struct
    void *handle;
 } input_ext_t;
 
-static void* input_ext_init(void)
+static void *input_ext_init(void)
 {
    g_input_dead = false;
    return calloc(1, sizeof(input_ext_t));
@@ -194,7 +204,7 @@ static bool video_ext_frame(void *data, const void *frame, unsigned width, unsig
    return ext->driver->frame(ext->handle, frame, width, height, pitch, msg);
 }
 
-static void* setup_input(ext_t *ext, const ssnes_input_driver_t *driver)
+static void *setup_input(ext_t *ext, const ssnes_input_driver_t *driver)
 {
    int joypad_index[5];
    for (unsigned i = 0; i < 5; i++)
@@ -240,6 +250,24 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
    font_color_g = font_color_g > 255 ? 255 : (font_color_g < 0 ? 0 : font_color_g);
    font_color_b = font_color_b > 255 ? 255 : (font_color_b < 0 ? 0 : font_color_b);
 
+   const char *font = NULL;
+   if (g_settings.video.font_enable)
+   {
+#ifdef HAVE_FREETYPE
+      if (*g_settings.video.font_path)
+         font = g_settings.video.font_path;
+      else
+         font = font_renderer_get_default_font();
+#else
+      font = *g_settings.video.font_path ?
+         g_settings.video.font_path : NULL;
+#endif
+   }
+
+   char title_buf[128];
+   gfx_window_title_reset();
+   gfx_window_title(title_buf, sizeof(title_buf));
+
    ssnes_video_info_t info = {
       .width = video->width,
       .height = video->height,
@@ -252,9 +280,16 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
       .color_format = video->rgb32 ? SSNES_COLOR_FORMAT_ARGB8888 : SSNES_COLOR_FORMAT_XRGB1555,
       .xml_shader = xml_shader,
       .cg_shader = cg_shader,
-      .ttf_font = *g_settings.video.font_path ? g_settings.video.font_path : NULL,
+      .ttf_font = font,
       .ttf_font_size = g_settings.video.font_size,
       .ttf_font_color = (font_color_r << 16) | (font_color_g << 8) | (font_color_b << 0),
+      .title_hint = title_buf,
+
+#ifdef HAVE_PYTHON
+      .python_state_new = py_state_new,
+      .python_state_get = py_state_get,
+      .python_state_free = py_state_free,
+#endif
    };
 
    const ssnes_input_driver_t *input_driver = NULL;
@@ -271,7 +306,7 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
    return true;
 }
 
-static void* video_ext_init(const video_info_t *video, const input_driver_t **input, void **input_data)
+static void *video_ext_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
    ext_t *ext = calloc(1, sizeof(*ext));
    if (!ext)

gfx/ext/ssnes_video.h

@@ -6,6 +6,8 @@
 #ifndef __SSNES_VIDEO_DRIVER_H
 #define __SSNES_VIDEO_DRIVER_H
 
+#include <stddef.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -22,10 +24,10 @@ extern "C" {
 #define SSNES_API_CALLTYPE
 #endif
 
-#define SSNES_GRAPHICS_API_VERSION 1
+#define SSNES_GRAPHICS_API_VERSION 2
 
 // Since we don't want to rely on C++ or C99 for a proper boolean type,
-// and make sure return semantics are perfectly clear ... ;)
+// make sure return semantics are perfectly clear ... ;)
 
 #ifndef SSNES_OK
 #define SSNES_OK 1
@@ -46,6 +48,23 @@ extern "C" {
 #define SSNES_COLOR_FORMAT_XRGB1555 0
 #define SSNES_COLOR_FORMAT_ARGB8888 1
 
+#define SSNES_INPUT_SCALE_BASE 256
+
+typedef struct py_state py_state_t;
+
+// Create a new runtime for Python.
+// py_script: The python script to be loaded. If is_file is true, this will be the full path to a file.
+// If false, it will be an UTF-8 encoded string of the script.
+// is_file: Tells if py_script is the path to a script, or a script itself.
+// py_class: name of the class being instantiated. 
+typedef py_state_t *(*python_state_new_cb)(const char *py_script, unsigned is_file, const char *py_class);
+// Grabs a value from the Python runtime.
+// id: The uniform (class method) to be called.
+// frame_count: Passes frame_count as an argument to the script.
+typedef float (*python_state_get_cb)(py_state_t *handle, const char *id, unsigned frame_count);
+// Frees the runtime.
+typedef void (*python_state_free_cb)(py_state_t *handle);
+
 typedef struct ssnes_video_info
 { 
    // Width of window. 
@@ -79,12 +98,9 @@ typedef struct ssnes_video_info
 
    // input_scale defines the maximum size of the picture that will
    // ever be used with the frame callback.
-   // The maximum resolution is a multiple of 256x256 size,
+   // The maximum resolution is a multiple of 256x256 size (SSNES_INPUT_SCALE_BASE),
    // so an input scale of 2
    // means you should allocate a texture or of 512x512.
-   // It is normally set to 2 due to the possibility of
-   // pseudo-hires on the SNES.
-   // CPU filters or otherwise might increase this value.
    unsigned input_scale;
 
    // Defines the coloring format used of the input frame.
@@ -108,7 +124,17 @@ 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.
+   unsigned ttf_font_color; // Font color, in format ARGB8888. Alpha should be disregarded.
+
+   // A title that should be displayed in the title bar of the window.
+   const char *title_hint;
+
+   // Functions to peek into the python runtime for shaders.
+   // Check typedefs above for explanation.
+   // These may be NULL if SSNES is not built with Python support.
+   python_state_new_cb python_state_new;
+   python_state_get_cb python_state_get;
+   python_state_free_cb python_state_free;
 } ssnes_video_info_t;
 
 // Some convenience macros.
@@ -119,7 +145,7 @@ typedef struct ssnes_video_info
 
 // I hope no joypad will ever have this many buttons or axes ... ;)
 // If joykey is this value, do not check that button.
-#define SSNES_NO_AXIS ((unsigned short)0xFFFFU)
+#define SSNES_NO_AXIS (0xFFFFFFFFU)
 #define SSNES_NO_BTN ((unsigned short)0xFFFFU)
 
 // Masks to test on joykey which hat direction is to be tested for.
@@ -178,20 +204,20 @@ typedef struct ssnes_input_driver
    // The range of this is [0, 1],
    // where 0 means any displacement will register,
    // and 1 means the axis has to be pressed all the way to register.
-   void* (*init)(const int joypad_index[5], float axis_threshold);
+   void *(*init)(const int joypad_index[5], float axis_threshold);
 
    // Polls input. Called once every frame.
-   void (*poll)(void* data);
+   void (*poll)(void *data);
 
    // Queries input state for a certain key on a certain player.
    // Players are 1 - 5.
    // For digital inputs, pressed key is 1, not pressed key is 0.
    // Analog values have same range as a signed 16-bit integer.
-   int (*input_state)(void* data, const struct ssnes_keybind *bind,
+   int (*input_state)(void *data, const struct ssnes_keybind *bind,
          unsigned player);
 
    // Frees the input struct.
-   void (*free)(void* data);
+   void (*free)(void *data);
 
    // Human readable indentification string.
    const char *ident;
@@ -205,7 +231,7 @@ typedef struct ssnes_video_driver
    // Should the video driver request that a certain input driver is used,
    // it is possible to set the driver to *input.
    // If no certain driver is desired, set *input to NULL.
-   void* (*init)(const ssnes_video_info_t *video, 
+   void *(*init)(const ssnes_video_info_t *video, 
          const ssnes_input_driver_t **input); 
 
    // Updates frame on the screen. 
@@ -215,13 +241,13 @@ typedef struct ssnes_video_driver
    // 
    // When msg is non-NULL, 
    // it's a message that should be displayed to the user.
-   int (*frame)(void* data, const void* frame, 
+   int (*frame)(void *data, const void *frame, 
          unsigned width, unsigned height, unsigned pitch, const char *msg);
 
    // Requests nonblocking operation. 
    // True = VSync is turned off. 
    // False = VSync is turned on.
-   void (*set_nonblock_state)(void* data, int toggle);
+   void (*set_nonblock_state)(void *data, int toggle);
 
    // This must return false when the user exits the emulator.
    int (*alive)(void *data);
@@ -230,13 +256,13 @@ typedef struct ssnes_video_driver
    int (*focus)(void *data);
 
    // Frees the video driver.
-   void (*free)(void* data);
+   void (*free)(void *data);
 
    // A human-readable identification of the video driver.
    const char *ident;
 
    // Needs to be defined to SSNES_GRAPHICS_API_VERSION. 
-   // This is used to detect API mismatches.
+   // This is used to detect API/ABI mismatches.
    int api_version;
 } ssnes_video_driver_t;
 

gfx/fonts.c

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

gfx/fonts.h

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

gfx/gfx_common.c

@@ -84,7 +84,7 @@ void gfx_set_dwm(void)
    dwmlib = dylib_load("dwmapi.dll");
    if (!dwmlib)
    {
-      SSNES_LOG("Did not find dwmapi.dll");
+      SSNES_LOG("Did not find dwmapi.dll.\n");
       return;
    }
    atexit(gfx_dwm_shutdown);

gfx/gl.c

@@ -34,6 +34,7 @@
 #include "gl_common.h"
 #include "gfx_common.h"
 #include "sdlwrap.h"
+#include "strl.h"
 
 #define NO_SDL_GLEXT
 #include "SDL.h"
@@ -77,6 +78,13 @@ static const GLfloat tex_coords[] = {
    1, 1
 };
 
+static const GLfloat white_color[] = {
+   1, 1, 1, 1,
+   1, 1, 1, 1,
+   1, 1, 1, 1,
+   1, 1, 1, 1,
+};
+
 
 #ifdef HAVE_FBO
 #ifdef _WIN32
@@ -123,12 +131,19 @@ static inline bool load_gl_proc(void) { return true; }
 
 #define MAX_SHADERS 16
 
+#if defined(HAVE_XML) || defined(HAVE_CG)
+#define TEXTURES 8
+#else
+#define TEXTURES 1
+#endif
+#define TEXTURES_MASK (TEXTURES - 1)
+
 typedef struct gl
 {
    bool vsync;
-   GLuint texture[2];
+   GLuint texture[TEXTURES];
    unsigned tex_index; // For use with PREV.
-   struct gl_tex_info prev_info;
+   struct gl_tex_info prev_info[TEXTURES];
    GLuint tex_filter;
 
    void *empty_buf;
@@ -157,8 +172,8 @@ typedef struct gl
    unsigned win_height;
    unsigned vp_width, vp_out_width;
    unsigned vp_height, vp_out_height;
-   unsigned last_width[2];
-   unsigned last_height[2];
+   unsigned last_width[TEXTURES];
+   unsigned last_height[TEXTURES];
    unsigned tex_w, tex_h;
    GLfloat tex_coords[8];
 #ifdef HAVE_FBO
@@ -172,6 +187,11 @@ typedef struct gl
 #ifdef HAVE_FREETYPE
    font_renderer_t *font;
    GLuint font_tex;
+   int font_tex_w, font_tex_h;
+   void *font_tex_empty_buf;
+   char font_last_msg[256];
+   int font_last_width, font_last_height;
+   GLfloat font_color[16];
 #endif
 
 } gl_t;
@@ -332,9 +352,16 @@ static void gl_shader_scale(unsigned index, struct gl_fbo_scale *scale)
 static inline void gl_init_font(gl_t *gl, const char *font_path, unsigned font_size)
 {
 #ifdef HAVE_FREETYPE
-   if (strlen(font_path) > 0)
+   if (!g_settings.video.font_enable)
+      return;
+
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      gl->font = font_renderer_new(font_path, font_size);
+      gl->font = font_renderer_new(path, font_size);
       if (gl->font)
       {
          glGenTextures(1, &gl->font_tex);
@@ -348,6 +375,21 @@ static inline void gl_init_font(gl_t *gl, const char *font_path, unsigned font_s
       else
          SSNES_WARN("Couldn't init font renderer with font \"%s\"...\n", font_path);
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
+
+   for (unsigned i = 0; i < 4; i++)
+   {
+      gl->font_color[4 * i + 0] = g_settings.video.msg_color_r;
+      gl->font_color[4 * i + 1] = g_settings.video.msg_color_g;
+      gl->font_color[4 * i + 2] = g_settings.video.msg_color_b;
+      gl->font_color[4 * i + 3] = 1.0;
+   }
+
+#else
+   (void)gl;
+   (void)font_path;
+   (void)font_size;
 #endif
 }
 
@@ -523,7 +565,7 @@ static void gl_init_fbo(gl_t *gl, unsigned width, unsigned height)
 error:
    glDeleteTextures(gl->fbo_pass, gl->fbo_texture);
    pglDeleteFramebuffers(gl->fbo_pass, gl->fbo);
-   SSNES_WARN("Failed to set up FBO. Two-pass shading will not work.\n");
+   SSNES_ERR("Failed to set up frame buffer objects. Multi-pass shading will not work.\n");
 #else
    (void)gl;
    (void)width;
@@ -538,7 +580,12 @@ static inline void gl_deinit_font(gl_t *gl)
    {
       font_renderer_free(gl->font);
       glDeleteTextures(1, &gl->font_tex);
+
+      if (gl->font_tex_empty_buf)
+         free(gl->font_tex_empty_buf);
    }
+#else
+   (void)gl;
 #endif
 }
 ////////////
@@ -605,67 +652,191 @@ static void set_viewport(gl_t *gl, unsigned width, unsigned height, bool force_f
    //SSNES_LOG("Setting viewport @ %ux%u\n", width, height);
 }
 
+#ifdef HAVE_FREETYPE
+
+// Somewhat overwhelming code just to render some damn fonts.
+// We aim to use NPOT textures for compatibility with old and shitty cards.
+// Also, we want to avoid reallocating a texture for each glyph (performance dips), so we
+// contruct the whole texture using one call, and copy straight to it with
+// glTexSubImage.
+
+struct font_rect
+{
+   int x, y;
+   int width, height;
+   int pot_width, pot_height;
+};
+
+static void calculate_msg_geometry(const struct font_output *head, struct font_rect *rect)
+{
+   int x_min = head->off_x;
+   int x_max = head->off_x + head->width;
+   int y_min = head->off_y;
+   int y_max = head->off_y + head->height;
+
+   while ((head = head->next))
+   {
+      int left = head->off_x;
+      int right = head->off_x + head->width;
+      int bottom = head->off_y;
+      int top = head->off_y + head->height;
+
+      if (left < x_min)
+         x_min = left;
+      if (right > x_max)
+         x_max = right;
+
+      if (bottom < y_min)
+         y_min = bottom;
+      if (top > y_max)
+         y_max = top;
+   }
+
+   rect->x = x_min;
+   rect->y = y_min;
+   rect->width = x_max - x_min;
+   rect->height = y_max - y_min;
+}
+
+static void adjust_power_of_two(gl_t *gl, struct font_rect *geom)
+{
+   // Some systems really hate NPOT textures.
+   geom->pot_width = next_pow2(geom->width);
+   geom->pot_height = next_pow2(geom->height);
+
+   if ((geom->pot_width > gl->font_tex_w) || (geom->pot_height > gl->font_tex_h))
+   {
+      gl->font_tex_empty_buf = realloc(gl->font_tex_empty_buf, geom->pot_width * geom->pot_height);
+      memset(gl->font_tex_empty_buf, 0, geom->pot_width * geom->pot_height);
+
+      glPixelStorei(GL_UNPACK_ALIGNMENT, 8);
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, geom->pot_width);
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY8, geom->pot_width, geom->pot_height,
+            0, GL_LUMINANCE, GL_UNSIGNED_BYTE, gl->font_tex_empty_buf);
+
+      gl->font_tex_w = geom->pot_width;
+      gl->font_tex_h = geom->pot_height;
+   }
+}
+
+// Old style "blitting", so we can render all the fonts in one go.
+// TODO: Is it possible that fonts could overlap if we blit without alpha blending?
+static void blit_fonts(gl_t *gl, const struct font_output *head, const struct font_rect *geom)
+{
+   // Clear out earlier fonts.
+   glPixelStorei(GL_UNPACK_ALIGNMENT, 8);
+   glPixelStorei(GL_UNPACK_ROW_LENGTH, gl->font_tex_w);
+   glTexSubImage2D(GL_TEXTURE_2D,
+         0, 0, 0, gl->font_tex_w, gl->font_tex_h,
+         GL_LUMINANCE, GL_UNSIGNED_BYTE, gl->font_tex_empty_buf);
+
+   while (head)
+   {
+      // head has top-left oriented coords.
+      int x = head->off_x - geom->x;
+      int y = head->off_y - geom->y;
+      y = gl->font_tex_h - head->height - y - 1;
+
+      glPixelStorei(GL_UNPACK_ALIGNMENT, get_alignment(head->pitch));
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, head->pitch);
+      glTexSubImage2D(GL_TEXTURE_2D,
+            0, x, y, head->width, head->height,
+            GL_LUMINANCE, GL_UNSIGNED_BYTE, head->output);
+
+      head = head->next;
+   }
+}
+
+static void calculate_font_coords(gl_t *gl,
+      GLfloat font_vertex[8], GLfloat font_tex_coords[8])
+{
+   GLfloat lx = g_settings.video.msg_pos_x;
+   GLfloat hx = (GLfloat)gl->font_last_width / gl->vp_width + lx;
+   GLfloat ly = g_settings.video.msg_pos_y;
+   GLfloat hy = (GLfloat)gl->font_last_height / gl->vp_height + ly;
+
+   font_vertex[0] = lx;
+   font_vertex[1] = ly;
+   font_vertex[2] = lx;
+   font_vertex[3] = hy;
+   font_vertex[4] = hx;
+   font_vertex[5] = hy;
+   font_vertex[6] = hx;
+   font_vertex[7] = ly;
+
+   lx = 0.0f;
+   hx = (GLfloat)gl->font_last_width / gl->font_tex_w;
+   ly = 1.0f - (GLfloat)gl->font_last_height / gl->font_tex_h; 
+   hy = 1.0f;
+
+   font_tex_coords[0] = lx;
+   font_tex_coords[1] = hy;
+   font_tex_coords[2] = lx;
+   font_tex_coords[3] = ly;
+   font_tex_coords[4] = hx;
+   font_tex_coords[5] = ly;
+   font_tex_coords[6] = hx;
+   font_tex_coords[7] = hy;
+}
+
 static void gl_render_msg(gl_t *gl, const char *msg)
 {
-#ifdef HAVE_FREETYPE
    if (!gl->font)
       return;
 
    GLfloat font_vertex[8]; 
+   GLfloat font_tex_coords[8];
 
    // Deactivate custom shaders. Enable the font texture.
    gl_shader_use(0);
    set_viewport(gl, gl->win_width, gl->win_height, false);
    glBindTexture(GL_TEXTURE_2D, gl->font_tex);
-   glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), font_vertex);
-   glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), tex_coords); // Use the static one (uses whole texture).
+   glVertexPointer(2, GL_FLOAT, 0, font_vertex);
+   glTexCoordPointer(2, GL_FLOAT, 0, font_tex_coords);
+   glColorPointer(4, GL_FLOAT, 0, gl->font_color);
 
    // 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);
-   struct font_output *head = out.head;
 
-   while (head != NULL)
+   // If we get the same message, there's obviously no need to render fonts again ...
+   if (strcmp(gl->font_last_msg, msg) != 0)
    {
-      GLfloat lx = (GLfloat)head->off_x / gl->vp_width + g_settings.video.msg_pos_x;
-      GLfloat hx = (GLfloat)(head->off_x + head->width) / gl->vp_width + g_settings.video.msg_pos_x;
-      GLfloat ly = (GLfloat)head->off_y / gl->vp_height + g_settings.video.msg_pos_y;
-      GLfloat hy = (GLfloat)(head->off_y + head->height) / gl->vp_height + g_settings.video.msg_pos_y;
+      font_renderer_msg(gl->font, msg, &out);
+      struct font_output *head = out.head;
 
-      font_vertex[0] = lx;
-      font_vertex[1] = ly;
-      font_vertex[2] = lx;
-      font_vertex[3] = hy;
-      font_vertex[4] = hx;
-      font_vertex[5] = hy;
-      font_vertex[6] = hx;
-      font_vertex[7] = ly;
+      struct font_rect geom;
+      calculate_msg_geometry(head, &geom);
+      adjust_power_of_two(gl, &geom);
+      blit_fonts(gl, head, &geom);
 
-      glPixelStorei(GL_UNPACK_ALIGNMENT, get_alignment(head->pitch));
-      glPixelStorei(GL_UNPACK_ROW_LENGTH, head->pitch);
-      glTexImage2D(GL_TEXTURE_2D,
-            0, GL_INTENSITY8, head->width, head->height, 0, GL_LUMINANCE,
-            GL_UNSIGNED_BYTE, head->output);
+      font_renderer_free_output(&out);
+      strlcpy(gl->font_last_msg, msg, sizeof(gl->font_last_msg));
 
-      head = head->next;
-      glDrawArrays(GL_QUADS, 0, 4);
+      gl->font_last_width = geom.width;
+      gl->font_last_height = geom.height;
    }
-   font_renderer_free_output(&out);
-
-   glColor4f(1, 1, 1, 1);
+   calculate_font_coords(gl, font_vertex, font_tex_coords);
+   
+   glDrawArrays(GL_QUADS, 0, 4);
 
    // 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);
+   glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
+   glVertexPointer(2, GL_FLOAT, 0, vertexes_flipped);
+   glColorPointer(4, GL_FLOAT, 0, white_color);
    glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
 
    glDisable(GL_BLEND);
-#endif
 }
+#else
+static void gl_render_msg(gl_t *gl, const char *msg)
+{
+   (void)gl;
+   (void)msg;
+}
+#endif
 
 static inline void set_lut_texture_coords(const GLfloat *coords)
 {
@@ -673,7 +844,7 @@ static inline void set_lut_texture_coords(const GLfloat *coords)
    // For texture images.
    pglClientActiveTexture(GL_TEXTURE1);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-   glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), coords);
+   glTexCoordPointer(2, GL_FLOAT, 0, coords);
    pglClientActiveTexture(GL_TEXTURE0);
 #else
    (void)coords;
@@ -697,19 +868,14 @@ static void check_window(gl_t *gl)
          gl->frame_count);
 
    if (quit)
-   {
       gl->quitting = true;
-   }
    else if (resize)
-   {
       gl->should_resize = true;
-   }
 }
 
-static bool gl_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+static bool gl_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
 {
    gl_t *gl = data;
-   check_window(gl);
 
    gl_shader_use(1);
    gl->frame_count++;
@@ -784,7 +950,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    {
       gl->should_resize = false;
 
-      sdlwrap_set_video_mode(gl->win_width, gl->win_height, 0, g_settings.video.fullscreen);
+      sdlwrap_set_resize(gl->win_width, gl->win_height);
 
 #ifdef HAVE_FBO
       if (!gl->render_to_tex)
@@ -847,7 +1013,8 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
       set_texture_coords(gl->tex_coords, xamt, yamt);
    }
 #if defined(HAVE_XML) || defined(HAVE_CG)
-   else if (width != gl->last_width[1 - gl->tex_index] || height != gl->last_height[1 - gl->tex_index])
+   // We might have used different texture coordinates last frame. Edge case if resolution changes very rapidly.
+   else if (width != gl->last_width[(gl->tex_index - 1) & TEXTURES_MASK] || height != gl->last_height[(gl->tex_index - 1) & TEXTURES_MASK])
    {
       GLfloat xamt = (GLfloat)width / gl->tex_w;
       GLfloat yamt = (GLfloat)height / gl->tex_h;
@@ -859,7 +1026,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    // Need to preserve the "flipped" state when in FBO as well to have 
    // consistent texture coordinates.
    if (gl->render_to_tex)
-      glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes);
+      glVertexPointer(2, GL_FLOAT, 0, vertexes);
 #endif
 
    glPixelStorei(GL_UNPACK_ROW_LENGTH, pitch / gl->base_size);
@@ -878,7 +1045,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 
    glClear(GL_COLOR_BUFFER_BIT);
    gl_shader_set_params(width, height, gl->tex_w, gl->tex_h, gl->vp_width, gl->vp_height, gl->frame_count, 
-         &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
+         &tex_info, gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
    glDrawArrays(GL_QUADS, 0, 4);
 
@@ -886,7 +1053,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    if (gl->fbo_inited)
    {
       // Render the rest of our passes.
-      glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->fbo_tex_coords);
+      glTexCoordPointer(2, GL_FLOAT, 0, gl->fbo_tex_coords);
 
       // It's kinda handy ... :)
       const struct gl_fbo_rect *prev_rect;
@@ -923,7 +1090,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
          gl_shader_set_params(prev_rect->img_width, prev_rect->img_height, 
                prev_rect->width, prev_rect->height, 
                gl->vp_width, gl->vp_height, gl->frame_count, 
-               &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
+               &tex_info, gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
          glDrawArrays(GL_QUADS, 0, 4);
 
@@ -949,18 +1116,19 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
       gl_shader_set_params(prev_rect->img_width, prev_rect->img_height, 
             prev_rect->width, prev_rect->height, 
             gl->vp_width, gl->vp_height, gl->frame_count, 
-            &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
+            &tex_info, gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
-      glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
+      glVertexPointer(2, GL_FLOAT, 0, vertexes_flipped);
       glDrawArrays(GL_QUADS, 0, 4);
 
-      glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->tex_coords);
+      glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
    }
 #endif
 
 #if defined(HAVE_XML) || defined(HAVE_CG)
-   memcpy(&gl->prev_info, &tex_info, sizeof(tex_info));
-   gl->tex_index = 1 - gl->tex_index;
+   memmove(gl->prev_info + 1, gl->prev_info, sizeof(tex_info) * (TEXTURES - 1));
+   memcpy(&gl->prev_info[0], &tex_info, sizeof(tex_info));
+   gl->tex_index = (gl->tex_index + 1) & TEXTURES_MASK;
 #endif
 
    if (msg)
@@ -983,7 +1151,8 @@ static void gl_free(void *data)
    gl_shader_deinit();
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-   glDeleteTextures(2, gl->texture);
+   glDisableClientState(GL_COLOR_ARRAY);
+   glDeleteTextures(TEXTURES, gl->texture);
 
 #ifdef HAVE_FBO
    if (gl->fbo_inited)
@@ -1010,7 +1179,7 @@ static void gl_set_nonblock_state(void *data, bool state)
    }
 }
 
-static void* gl_init(const video_info_t *video, const input_driver_t **input, void **input_data)
+static void *gl_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
 #ifdef _WIN32
    gfx_set_dwm();
@@ -1086,7 +1255,8 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    SSNES_LOG("GL: Loaded %u program(s).\n", gl_shader_num());
 
    // Set up render to texture.
-   gl_init_fbo(gl, 256 * video->input_scale, 256 * video->input_scale);
+   gl_init_fbo(gl, SSNES_SCALE_BASE * video->input_scale,
+         SSNES_SCALE_BASE * video->input_scale);
    
    gl->keep_aspect = video->force_aspect;
 
@@ -1109,15 +1279,14 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_DITHER);
-   glColor4f(1, 1, 1, 1);
    glClearColor(0, 0, 0, 1);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
-   glGenTextures(2, gl->texture);
+   glGenTextures(TEXTURES, gl->texture);
 
-   for (unsigned i = 0; i < 2; i++)
+   for (unsigned i = 0; i < TEXTURES; i++)
    {
       glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
 
@@ -1130,20 +1299,23 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-   glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
+   glEnableClientState(GL_COLOR_ARRAY);
+   glVertexPointer(2, GL_FLOAT, 0, vertexes_flipped);
 
    memcpy(gl->tex_coords, tex_coords, sizeof(tex_coords));
-   glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->tex_coords);
+   glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
+
+   glColorPointer(4, GL_FLOAT, 0, white_color);
 
    set_lut_texture_coords(tex_coords);
 
-   gl->tex_w = 256 * video->input_scale;
-   gl->tex_h = 256 * video->input_scale;
+   gl->tex_w = SSNES_SCALE_BASE * video->input_scale;
+   gl->tex_h = SSNES_SCALE_BASE * video->input_scale;
 
    // Empty buffer that we use to clear out the texture with on res change.
    gl->empty_buf = calloc(gl->tex_w * gl->tex_h, gl->base_size);
 
-   for (unsigned i = 0; i < 2; i++)
+   for (unsigned i = 0; i < TEXTURES; i++)
    {
       glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
       glPixelStorei(GL_UNPACK_ROW_LENGTH, gl->tex_w);
@@ -1153,18 +1325,21 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    }
    glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
 
-   for (unsigned i = 0; i < 2; i++)
+   for (unsigned i = 0; i < TEXTURES; i++)
    {
       gl->last_width[i] = gl->tex_w;
       gl->last_height[i] = gl->tex_h;
    }
 
-   gl->prev_info.tex = gl->texture[1 - gl->tex_index];
-   gl->prev_info.input_size[0] = gl->tex_w;
-   gl->prev_info.tex_size[0] = gl->tex_w;
-   gl->prev_info.input_size[1] = gl->tex_h;
-   gl->prev_info.tex_size[1] = gl->tex_h;
-   memcpy(gl->prev_info.coord, tex_coords, sizeof(tex_coords)); 
+   for (unsigned i = 0; i < TEXTURES; i++)
+   {
+      gl->prev_info[i].tex = gl->texture[(gl->tex_index - (i + 1)) & TEXTURES_MASK];
+      gl->prev_info[i].input_size[0] = gl->tex_w;
+      gl->prev_info[i].tex_size[0] = gl->tex_w;
+      gl->prev_info[i].input_size[1] = gl->tex_h;
+      gl->prev_info[i].tex_size[1] = gl->tex_h;
+      memcpy(gl->prev_info[i].coord, tex_coords, sizeof(tex_coords)); 
+   }
 
    // Hook up SDL input driver to get SDL_QUIT events and RESIZE.
    sdl_input_t *sdl_input = input_sdl.init();
@@ -1191,6 +1366,7 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
 static bool gl_alive(void *data)
 {
    gl_t *gl = data;
+   check_window(gl);
    return !gl->quitting;
 }
 

gfx/py_state/py_state.c

@@ -26,6 +26,7 @@
 #include "py_state.h"
 #include "general.h"
 #include "strl.h"
+#include "file.h"
 
 #define PY_READ_FUNC_DECL(RAMTYPE) py_read_##RAMTYPE
 #define PY_READ_FUNC(RAMTYPE) \
@@ -60,7 +61,7 @@ PY_READ_FUNC(APURAM)
 PY_READ_FUNC(CGRAM)
 PY_READ_FUNC(OAM)
 
-static PyObject* py_read_input(PyObject *self, PyObject *args)
+static PyObject *py_read_input(PyObject *self, PyObject *args)
 {
    (void)self;
 
@@ -72,12 +73,16 @@ static PyObject* py_read_input(PyObject *self, PyObject *args)
    if (!PyArg_ParseTuple(args, "II", &player, &key))
       return NULL;
 
-   if (player > MAX_PLAYERS || player < 1)
+   if (player > MAX_PLAYERS || player < 1 || key >= SSNES_FIRST_META_KEY)
       return NULL;
 
-   const struct snes_keybind *binds[MAX_PLAYERS];
-   for (int i = 0; i < MAX_PLAYERS; i++)
-      binds[i] = g_settings.input.binds[i];
+   static const struct snes_keybind *binds[MAX_PLAYERS] = {
+      g_settings.input.binds[0],
+      g_settings.input.binds[1],
+      g_settings.input.binds[2],
+      g_settings.input.binds[3],
+      g_settings.input.binds[4],
+   };
 
    int16_t res = driver.input->input_state(driver.input_data, 
          binds, player > 1, 
@@ -85,7 +90,25 @@ static PyObject* py_read_input(PyObject *self, PyObject *args)
          player > 2 ? player - 2 : 0,
          key);
 
-   return PyBool_FromLong((long)res);
+   return PyBool_FromLong(res);
+}
+
+static PyObject *py_read_input_meta(PyObject *self, PyObject *args)
+{
+   (void)self;
+
+   if (!driver.input_data)
+      return PyBool_FromLong(0);
+
+   unsigned key;
+   if (!PyArg_ParseTuple(args, "I", &key))
+      return NULL;
+
+   if (key < SSNES_FIRST_META_KEY)
+      return NULL;
+
+   bool ret = driver.input->key_pressed(driver.input_data, key);
+   return PyBool_FromLong(ret);
 }
 
 static PyMethodDef SNESMethods[] = {
@@ -95,23 +118,49 @@ static PyMethodDef SNESMethods[] = {
    { "read_cgram",   PY_READ_FUNC_DECL(CGRAM),  METH_VARARGS, "Read CGRAM from SNES." },
    { "read_oam",     PY_READ_FUNC_DECL(OAM),    METH_VARARGS, "Read OAM from SNES." },
    { "input",        py_read_input,             METH_VARARGS, "Read input state from SNES." },
+   { "input_meta",   py_read_input_meta,        METH_VARARGS, "Read SSNES specific input." },
    { NULL, NULL, 0, NULL }
 };
 
+#define DECL_ATTR_SNES(attr) PyObject_SetAttrString(mod, #attr, PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_##attr))
+#define DECL_ATTR_SSNES(attr) PyObject_SetAttrString(mod, #attr, PyLong_FromLong(SSNES_##attr))
 static void py_set_attrs(PyObject *mod)
 {
-   PyObject_SetAttrString(mod, "B", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_B));
-   PyObject_SetAttrString(mod, "Y", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_Y));
-   PyObject_SetAttrString(mod, "SELECT", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_SELECT));
-   PyObject_SetAttrString(mod, "START", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_START));
-   PyObject_SetAttrString(mod, "UP", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_UP));
-   PyObject_SetAttrString(mod, "DOWN", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_DOWN));
-   PyObject_SetAttrString(mod, "LEFT", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_LEFT));
-   PyObject_SetAttrString(mod, "RIGHT", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_RIGHT));
-   PyObject_SetAttrString(mod, "A", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_A));
-   PyObject_SetAttrString(mod, "X", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_X));
-   PyObject_SetAttrString(mod, "L", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_L));
-   PyObject_SetAttrString(mod, "R", PyLong_FromLong(SNES_DEVICE_ID_JOYPAD_R));
+   DECL_ATTR_SNES(B);
+   DECL_ATTR_SNES(Y);
+   DECL_ATTR_SNES(SELECT);
+   DECL_ATTR_SNES(START);
+   DECL_ATTR_SNES(UP);
+   DECL_ATTR_SNES(DOWN);
+   DECL_ATTR_SNES(LEFT);
+   DECL_ATTR_SNES(RIGHT);
+   DECL_ATTR_SNES(A);
+   DECL_ATTR_SNES(X);
+   DECL_ATTR_SNES(L);
+   DECL_ATTR_SNES(R);
+
+   DECL_ATTR_SSNES(FAST_FORWARD_KEY);
+   DECL_ATTR_SSNES(FAST_FORWARD_HOLD_KEY);
+   DECL_ATTR_SSNES(LOAD_STATE_KEY);
+   DECL_ATTR_SSNES(SAVE_STATE_KEY);
+   DECL_ATTR_SSNES(FULLSCREEN_TOGGLE_KEY);
+   DECL_ATTR_SSNES(QUIT_KEY);
+   DECL_ATTR_SSNES(STATE_SLOT_PLUS);
+   DECL_ATTR_SSNES(STATE_SLOT_MINUS);
+   DECL_ATTR_SSNES(AUDIO_INPUT_RATE_PLUS);
+   DECL_ATTR_SSNES(AUDIO_INPUT_RATE_MINUS);
+   DECL_ATTR_SSNES(REWIND);
+   DECL_ATTR_SSNES(MOVIE_RECORD_TOGGLE);
+   DECL_ATTR_SSNES(PAUSE_TOGGLE);
+   DECL_ATTR_SSNES(FRAMEADVANCE);
+   DECL_ATTR_SSNES(RESET);
+   DECL_ATTR_SSNES(SHADER_NEXT);
+   DECL_ATTR_SSNES(SHADER_PREV);
+   DECL_ATTR_SSNES(CHEAT_INDEX_PLUS);
+   DECL_ATTR_SSNES(CHEAT_INDEX_MINUS);
+   DECL_ATTR_SSNES(CHEAT_TOGGLE);
+   DECL_ATTR_SSNES(SCREENSHOT);
+   DECL_ATTR_SSNES(DSP_CONFIG);
 }
 
 static PyModuleDef SNESModule = {
@@ -156,7 +205,7 @@ static char *dupe_newline(const char *str)
 }
 
 // Need to make sure that first-line indentation is 0. :(
-static char* align_program(const char *program)
+static char *align_program(const char *program)
 {
    char *prog = strdup(program);
    if (!prog)
@@ -190,28 +239,38 @@ static char* align_program(const char *program)
    }
 
    free(prog);
-
    return new_prog;
 }
 
-py_state_t *py_state_new(const char *script, bool is_file, const char *pyclass)
+py_state_t *py_state_new(const char *script, unsigned is_file, const char *pyclass)
 {
+   SSNES_LOG("Initializing Python runtime ...\n");
    PyImport_AppendInittab("snes", &PyInit_SNES);
    Py_Initialize();
+   SSNES_LOG("Initialized Python runtime!\n");
 
    py_state_t *handle = calloc(1, sizeof(*handle));
 
    handle->main = PyImport_AddModule("__main__");
    if (!handle->main)
       goto error;
+   Py_INCREF(handle->main);
 
    if (is_file)
    {
-      FILE *file = fopen(script, "r");
-      if (!file)
+      // Have to hack around the fact that the
+      // FILE struct isn't standardized across environments.
+      // PyRun_SimpleFile() breaks on Windows.
+
+      char *script_ = NULL;
+      if (read_file(script, (void**)&script_) < 0)
+      {
+         SSNES_ERR("Python: Failed to read script\n");
          goto error;
-      PyRun_SimpleFile(file, script);
-      fclose(file);
+      }
+
+      PyRun_SimpleString(script_);
+      free(script_);
    }
    else
    {
@@ -223,22 +282,35 @@ py_state_t *py_state_new(const char *script, bool is_file, const char *pyclass)
       }
    }
 
+   SSNES_LOG("Python: Script loaded.\n");
    handle->dict = PyModule_GetDict(handle->main);
    if (!handle->dict)
+   {
+      SSNES_ERR("Python: PyModule_GetDict() failed.\n");
       goto error;
+   }
+   Py_INCREF(handle->dict);
 
    PyObject *hook = PyDict_GetItemString(handle->dict, pyclass);
    if (!hook)
+   {
+      SSNES_ERR("Python: PyDict_GetItemString() failed.\n");
       goto error;
+   }
 
    handle->inst = PyObject_CallFunction(hook, NULL);
    if (!handle->inst)
+   {
+      SSNES_ERR("Python: PyObject_CallFunction() failed.\n");
       goto error;
+   }
+   Py_INCREF(handle->inst);
 
    return handle;
 
 error:
    PyErr_Print();
+   PyErr_Clear();
    py_state_free(handle);
    return NULL;
 }
@@ -247,20 +319,19 @@ void py_state_free(py_state_t *handle)
 {
    if (handle)
    {
-      if (handle->main)
-         Py_DECREF(handle->main);
-      if (handle->dict)
-         Py_DECREF(handle->dict);
-      if (handle->inst)
-         Py_DECREF(handle->inst);
+      PyErr_Print();
+      PyErr_Clear();
+
+      Py_CLEAR(handle->inst);
+      Py_CLEAR(handle->dict);
+      Py_CLEAR(handle->main);
 
       free(handle);
+      Py_Finalize();
    }
-
-   Py_Finalize();
 }
 
-int py_state_get(py_state_t *handle, const char *id,
+float py_state_get(py_state_t *handle, const char *id,
       unsigned frame_count)
 {
    PyObject *ret = PyObject_CallMethod(handle->inst, (char*)id, (char*)"I", frame_count);
@@ -269,19 +340,10 @@ int py_state_get(py_state_t *handle, const char *id,
       if (!handle->warned_ret)
          SSNES_WARN("Didn't get return value from script! Bug?\n");
       handle->warned_ret = true;
-      return 0;
-   }
-
-   int retval = 0;
-   if (PyLong_Check(ret))
-      retval = (int)PyLong_AsLong(ret);
-   else
-   {
-      if (!handle->warned_type)
-         SSNES_WARN("Didn't get long compatible value from script! Bug?\n");
-      handle->warned_type = true;
+      return 0.0f;
    }
 
+   float retval = (float)PyFloat_AsDouble(ret);
    Py_DECREF(ret);
    return retval;
 }

gfx/py_state/py_state.h

@@ -21,12 +21,14 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#ifndef PY_STATE_OMIT_DECLARATION
 typedef struct py_state py_state_t;
+#endif
 
-py_state_t *py_state_new(const char *program, bool is_file, const char *pyclass);
+py_state_t *py_state_new(const char *program, unsigned is_file, const char *pyclass);
 void py_state_free(py_state_t *handle);
 
-int py_state_get(py_state_t *handle, 
+float py_state_get(py_state_t *handle, 
       const char *id, unsigned frame_count);
 
 #endif

gfx/sdl.c

@@ -80,9 +80,16 @@ static void sdl_gfx_free(void *data)
 static void sdl_init_font(sdl_video_t *vid, const char *font_path, unsigned font_size)
 {
 #ifdef HAVE_FREETYPE
-   if (*font_path)
+   if (!g_settings.video.font_enable)
+      return;
+
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      vid->font = font_renderer_new(font_path, font_size);
+      vid->font = font_renderer_new(path, font_size);
       if (vid->font)
       {
          int r = g_settings.video.msg_color_r * 255;
@@ -108,6 +115,8 @@ static void sdl_init_font(sdl_video_t *vid, const char *font_path, unsigned font
       else
          SSNES_WARN("Failed to init font.\n");
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
 #else
    (void)vid;
    (void)font_path;
@@ -238,7 +247,7 @@ static void sdl_render_msg_32(sdl_video_t *vid, SDL_Surface *buffer, const char
 #endif
 }
 
-static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
+static void *sdl_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
 #ifdef _WIN32
    gfx_set_dwm();
@@ -282,13 +291,15 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    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,
+      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, SSNES_SCALE_BASE * video->input_scale,
+            SSNES_SCALE_BASE * video->input_scale, 32,
             fmt->Rmask, fmt->Bmask, fmt->Gmask, fmt->Amask);
    }
    else
    {
       SSNES_LOG("SDL: Creating 15-bit buffer.\n");
-      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, 256 * video->input_scale, 256 * video->input_scale, 15,
+      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, SSNES_SCALE_BASE * video->input_scale,
+            SSNES_SCALE_BASE * video->input_scale, 15,
             fmt->Rmask, fmt->Gmask, fmt->Bmask, fmt->Amask);
    }
    SSNES_LOG("[Debug]: SDL Pixel format: Rshift = %u, Gshift = %u, Bshift = %u\n", 
@@ -456,10 +467,9 @@ static void check_window(sdl_video_t *vid)
    }
 }
 
-static bool sdl_gfx_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+static bool sdl_gfx_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
 {
    sdl_video_t *vid = data;
-   check_window(vid);
 
    if (SDL_MUSTLOCK(vid->buffer))
       SDL_LockSurface(vid->buffer);
@@ -531,6 +541,7 @@ static void sdl_gfx_set_nonblock_state(void *data, bool state)
 static bool sdl_gfx_alive(void *data)
 {
    sdl_video_t *vid = data;
+   check_window(vid);
    return !vid->quitting;
 }
 

gfx/sdlwrap.c

@@ -22,6 +22,7 @@
 
 #ifdef __APPLE__
 #include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
 #endif
 
 // SDL 1.2 is portable, sure, but you still need some platform specific workarounds ;)
@@ -55,7 +56,7 @@ void sdlwrap_set_swap_interval(unsigned interval, bool inited)
       }
       if (wgl_swap_interval) wgl_swap_interval(g_interval);
 
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) && defined(HAVE_OPENGL)
       GLint val = g_interval;
       CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &val);
 #else
@@ -82,6 +83,9 @@ bool sdlwrap_init(void)
 #if SDL_MODERN
    return SDL_VideoInit(NULL) == 0;
 #else
+   if (SDL_WasInit(SDL_INIT_VIDEO))
+      return true;
+
    return SDL_Init(SDL_INIT_VIDEO) == 0;
 #endif
 }
@@ -170,6 +174,23 @@ bool sdlwrap_set_video_mode(
    return true;
 }
 
+// SDL 1.2 has an awkward model where you need to "confirm" window resizing.
+// SDL 1.3 luckily removes this quirk.
+void sdlwrap_set_resize(unsigned width, unsigned height)
+{
+#if SDL_MODERN
+   (void)width;
+   (void)height;
+#else
+#ifndef __APPLE__ // Resizing on OSX is broken in 1.2 it seems :)
+   static const int resizable = SDL_RESIZABLE;
+#else
+   static const int resizable = 0;
+#endif
+   SDL_SetVideoMode(width, height, 0, SDL_OPENGL | (g_fullscreen ? SDL_FULLSCREEN : resizable));
+#endif
+}
+
 void sdlwrap_wm_set_caption(const char *str)
 {
 #if SDL_MODERN

gfx/sdlwrap.h

@@ -33,7 +33,7 @@
 #define SDL_MODERN 0
 #endif
 
-// Not legal to cast void* to fn-pointer. Need workaround to be compliant.
+// Not legal to cast (void*) to fn-pointer. Need workaround to be compliant.
 #define SDL_SYM_WRAP(sym, symbol) { \
    assert(sizeof(void*) == sizeof(void (*)(void))); \
    void *sym__ = SDL_GL_GetProcAddress(symbol); \
@@ -58,6 +58,8 @@ bool sdlwrap_key_pressed(int key);
 void sdlwrap_check_window(bool *quit,
       bool *resize, unsigned *width, unsigned *height, unsigned frame_count);
 
+void sdlwrap_set_resize(unsigned width, unsigned height);
+
 bool sdlwrap_get_wm_info(SDL_SysWMinfo *info);
 
 bool sdlwrap_window_has_focus(void);

gfx/shader_cg.c

@@ -32,7 +32,7 @@
 //#define SSNES_CG_DEBUG
 
 // Used when we call deactivate() since just unbinding the program didn't seem to work... :(
-static const char* stock_cg_program =
+static const char *stock_cg_program =
       "void main_vertex"
       "("
       "	float4 position	: POSITION,"
@@ -95,6 +95,7 @@ struct cg_fbo_params
 #define MAX_SHADERS 16
 #define MAX_TEXTURES 8
 #define MAX_VARIABLES 64
+#define PREV_TEXTURES 7
 
 struct cg_program
 {
@@ -104,15 +105,17 @@ struct cg_program
    CGparameter tex_size_f;
    CGparameter out_size_f;
    CGparameter frame_cnt_f;
+   CGparameter frame_dir_f;
    CGparameter vid_size_v;
    CGparameter tex_size_v;
    CGparameter out_size_v;
    CGparameter frame_cnt_v;
+   CGparameter frame_dir_v;
    CGparameter mvp;
 
    struct cg_fbo_params fbo[MAX_SHADERS];
    struct cg_fbo_params orig;
-   struct cg_fbo_params prev;
+   struct cg_fbo_params prev[PREV_TEXTURES];
 };
 
 #define FILTER_UNSPEC 0
@@ -131,7 +134,19 @@ static unsigned lut_textures[MAX_TEXTURES];
 static unsigned lut_textures_num = 0;
 static char lut_textures_uniform[MAX_TEXTURES][64];
 
+static CGparameter cg_attribs[PREV_TEXTURES + 1 + MAX_SHADERS];
+static unsigned cg_attrib_index;
+
+#ifdef HAVE_CONFIGFILE
 static snes_tracker_t *snes_tracker = NULL;
+#endif
+
+static void gl_cg_reset_attrib(void)
+{
+   for (unsigned i = 0; i < cg_attrib_index; i++)
+      cgGLDisableClientState(cg_attribs[i]);
+   cg_attrib_index = 0;
+}
 
 void gl_cg_set_proj_matrix(void)
 {
@@ -153,113 +168,124 @@ void gl_cg_set_params(unsigned width, unsigned height,
       const struct gl_tex_info *fbo_info,
       unsigned fbo_info_cnt)
 {
-   if (cg_active && active_index > 0)
+   if (!cg_active || (active_index == 0))
+      return;
+
+   // Set frame.
+   set_param_2f(prg[active_index].vid_size_f, width, height);
+   set_param_2f(prg[active_index].tex_size_f, tex_width, tex_height);
+   set_param_2f(prg[active_index].out_size_f, out_width, out_height);
+   set_param_1f(prg[active_index].frame_cnt_f, (float)frame_count);
+   set_param_1f(prg[active_index].frame_dir_f, g_extern.frame_is_reverse ? -1.0 : 1.0);
+
+   set_param_2f(prg[active_index].vid_size_v, width, height);
+   set_param_2f(prg[active_index].tex_size_v, tex_width, tex_height);
+   set_param_2f(prg[active_index].out_size_v, out_width, out_height);
+   set_param_1f(prg[active_index].frame_cnt_v, (float)frame_count);
+   set_param_1f(prg[active_index].frame_dir_v, g_extern.frame_is_reverse ? -1.0 : 1.0);
+
+   // Set orig texture.
+   CGparameter param = prg[active_index].orig.tex;
+   if (param)
    {
-      // Set frame.
-      set_param_2f(prg[active_index].vid_size_f, width, height);
-      set_param_2f(prg[active_index].tex_size_f, tex_width, tex_height);
-      set_param_2f(prg[active_index].out_size_f, out_width, out_height);
-      set_param_1f(prg[active_index].frame_cnt_f, (float)frame_count);
+      cgGLSetTextureParameter(param, info->tex);
+      cgGLEnableTextureParameter(param);
+   }
 
-      set_param_2f(prg[active_index].vid_size_v, width, height);
-      set_param_2f(prg[active_index].tex_size_v, tex_width, tex_height);
-      set_param_2f(prg[active_index].out_size_v, out_width, out_height);
-      set_param_1f(prg[active_index].frame_cnt_v, (float)frame_count);
+   set_param_2f(prg[active_index].orig.vid_size_v, info->input_size[0], info->input_size[1]);
+   set_param_2f(prg[active_index].orig.vid_size_f, info->input_size[0], info->input_size[1]);
+   set_param_2f(prg[active_index].orig.tex_size_v, info->tex_size[0], info->tex_size[1]);
+   set_param_2f(prg[active_index].orig.tex_size_f, info->tex_size[0], info->tex_size[1]);
+   if (prg[active_index].orig.coord)
+   {
+      cgGLSetParameterPointer(prg[active_index].orig.coord, 2, GL_FLOAT, 0, info->coord);
+      cgGLEnableClientState(prg[active_index].orig.coord);
+      cg_attribs[cg_attrib_index++] = prg[active_index].orig.coord;
+   }
 
-      // Set orig texture.
-      CGparameter param = prg[active_index].orig.tex;
+   // Set prev textures.
+   for (unsigned i = 0; i < PREV_TEXTURES; i++)
+   {
+      param = prg[active_index].prev[i].tex;
       if (param)
       {
-         cgGLSetTextureParameter(param, info->tex);
+         cgGLSetTextureParameter(param, prev_info[i].tex);
          cgGLEnableTextureParameter(param);
       }
 
-      set_param_2f(prg[active_index].orig.vid_size_v, info->input_size[0], info->input_size[1]);
-      set_param_2f(prg[active_index].orig.vid_size_f, info->input_size[0], info->input_size[1]);
-      set_param_2f(prg[active_index].orig.tex_size_v, info->tex_size[0], info->tex_size[1]);
-      set_param_2f(prg[active_index].orig.tex_size_f, info->tex_size[0], info->tex_size[1]);
-      if (prg[active_index].orig.coord)
-      {
-         cgGLSetParameterPointer(prg[active_index].orig.coord, 2, GL_FLOAT, 0, info->coord);
-         cgGLEnableClientState(prg[active_index].orig.coord);
-      }
+      set_param_2f(prg[active_index].prev[i].vid_size_v, prev_info[i].input_size[0], prev_info[i].input_size[1]);
+      set_param_2f(prg[active_index].prev[i].vid_size_f, prev_info[i].input_size[0], prev_info[i].input_size[1]);
+      set_param_2f(prg[active_index].prev[i].tex_size_v, prev_info[i].tex_size[0],   prev_info[i].tex_size[1]);
+      set_param_2f(prg[active_index].prev[i].tex_size_f, prev_info[i].tex_size[0],   prev_info[i].tex_size[1]);
 
-      // Set prev texture
-      param = prg[active_index].prev.tex;
+      if (prg[active_index].prev[i].coord)
+      {
+         cgGLSetParameterPointer(prg[active_index].prev[i].coord, 2, GL_FLOAT, 0, prev_info[i].coord);
+         cgGLEnableClientState(prg[active_index].prev[i].coord);
+         cg_attribs[cg_attrib_index++] = prg[active_index].prev[i].coord;
+      }
+   }
+
+   // Set lookup textures.
+   for (unsigned i = 0; i < lut_textures_num; i++)
+   {
+      CGparameter param = cgGetNamedParameter(prg[active_index].fprg, lut_textures_uniform[i]);
       if (param)
       {
-         cgGLSetTextureParameter(param, prev_info->tex);
+         cgGLSetTextureParameter(param, lut_textures[i]);
          cgGLEnableTextureParameter(param);
       }
+   }
 
-      set_param_2f(prg[active_index].prev.vid_size_v, prev_info->input_size[0], prev_info->input_size[1]);
-      set_param_2f(prg[active_index].prev.vid_size_f, prev_info->input_size[0], prev_info->input_size[1]);
-      set_param_2f(prg[active_index].prev.tex_size_v, prev_info->tex_size[0], prev_info->tex_size[1]);
-      set_param_2f(prg[active_index].prev.tex_size_f, prev_info->tex_size[0], prev_info->tex_size[1]);
-      if (prg[active_index].prev.coord)
+   // Set FBO textures.
+   if (active_index > 2)
+   {
+      for (unsigned i = 0; i < fbo_info_cnt; i++)
       {
-         cgGLSetParameterPointer(prg[active_index].prev.coord, 2, GL_FLOAT, 0, prev_info->coord);
-         cgGLEnableClientState(prg[active_index].prev.coord);
-      }
-
-      // Set lookup textures.
-      for (unsigned i = 0; i < lut_textures_num; i++)
-      {
-         CGparameter param = cgGetNamedParameter(prg[active_index].fprg, lut_textures_uniform[i]);
-         if (param)
+         if (prg[active_index].fbo[i].tex)
          {
-            cgGLSetTextureParameter(param, lut_textures[i]);
-            cgGLEnableTextureParameter(param);
+            cgGLSetTextureParameter(prg[active_index].fbo[i].tex, fbo_info[i].tex);
+            cgGLEnableTextureParameter(prg[active_index].fbo[i].tex);
          }
-      }
-      
-      // Set FBO textures.
-      if (active_index > 2)
-      {
-         for (unsigned i = 0; i < fbo_info_cnt; i++)
+
+         set_param_2f(prg[active_index].fbo[i].vid_size_v, 
+               fbo_info[i].input_size[0], fbo_info[i].input_size[1]);
+         set_param_2f(prg[active_index].fbo[i].vid_size_f, 
+               fbo_info[i].input_size[0], fbo_info[i].input_size[1]);
+
+         set_param_2f(prg[active_index].fbo[i].tex_size_v, 
+               fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]);
+         set_param_2f(prg[active_index].fbo[i].tex_size_f, 
+               fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]);
+
+         if (prg[active_index].fbo[i].coord)
          {
-            if (prg[active_index].fbo[i].tex)
-            {
-               cgGLSetTextureParameter(prg[active_index].fbo[i].tex, fbo_info[i].tex);
-               cgGLEnableTextureParameter(prg[active_index].fbo[i].tex);
-            }
-
-            set_param_2f(prg[active_index].fbo[i].vid_size_v, 
-                  fbo_info[i].input_size[0], fbo_info[i].input_size[1]);
-            set_param_2f(prg[active_index].fbo[i].vid_size_f, 
-                  fbo_info[i].input_size[0], fbo_info[i].input_size[1]);
-
-            set_param_2f(prg[active_index].fbo[i].tex_size_v, 
-                  fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]);
-            set_param_2f(prg[active_index].fbo[i].tex_size_f, 
-                  fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]);
-
-            if (prg[active_index].fbo[i].coord)
-            {
-               cgGLSetParameterPointer(prg[active_index].fbo[i].coord, 2, GL_FLOAT, 0, fbo_info[i].coord);
-               cgGLEnableClientState(prg[active_index].fbo[i].coord);
-            }
-         }
-      }
-
-      // Set state parameters
-      if (snes_tracker)
-      {
-         static struct snes_tracker_uniform info[MAX_VARIABLES];
-         static unsigned cnt = 0;
-
-         if (active_index == 1)
-            cnt = snes_get_uniform(snes_tracker, info, MAX_VARIABLES, frame_count);
-
-         for (unsigned i = 0; i < cnt; i++)
-         {
-            CGparameter param_v = cgGetNamedParameter(prg[active_index].vprg, info[i].id);
-            CGparameter param_f = cgGetNamedParameter(prg[active_index].fprg, info[i].id);
-            set_param_1f(param_v, info[i].value);
-            set_param_1f(param_f, info[i].value);
+            cgGLSetParameterPointer(prg[active_index].fbo[i].coord, 2, GL_FLOAT, 0, fbo_info[i].coord);
+            cgGLEnableClientState(prg[active_index].fbo[i].coord);
+            cg_attribs[cg_attrib_index++] = prg[active_index].fbo[i].coord;
          }
       }
    }
+
+#ifdef HAVE_CONFIGFILE
+   // Set state parameters
+   if (snes_tracker)
+   {
+      static struct snes_tracker_uniform info[MAX_VARIABLES];
+      static unsigned cnt = 0;
+
+      if (active_index == 1)
+         cnt = snes_get_uniform(snes_tracker, info, MAX_VARIABLES, frame_count);
+
+      for (unsigned i = 0; i < cnt; i++)
+      {
+         CGparameter param_v = cgGetNamedParameter(prg[active_index].vprg, info[i].id);
+         CGparameter param_f = cgGetNamedParameter(prg[active_index].fprg, info[i].id);
+         set_param_1f(param_v, info[i].value);
+         set_param_1f(param_f, info[i].value);
+      }
+   }
+#endif
 }
 
 void gl_cg_deinit(void)
@@ -267,6 +293,8 @@ void gl_cg_deinit(void)
    if (!cg_active)
       return;
 
+   gl_cg_reset_attrib();
+
    cg_active = false;
    cg_shader_num = 0;
    memset(prg, 0, sizeof(prg));
@@ -276,46 +304,56 @@ void gl_cg_deinit(void)
    glDeleteTextures(lut_textures_num, lut_textures);
    lut_textures_num = 0;
 
+#ifdef HAVE_CONFIGFILE
    if (snes_tracker)
    {
       snes_tracker_free(snes_tracker);
       snes_tracker = NULL;
    }
+#endif
 
    cgDestroyContext(cgCtx);
 }
 
+#define SET_LISTING_INDEX(type, index) \
+{ \
+   const char *list = cgGetLastListing(cgCtx); \
+   if (list) \
+      listing_##type[index] = strdup(list); \
+}
+
+#define SET_LISTING(type) \
+{ \
+   const char *list = cgGetLastListing(cgCtx); \
+   if (list) \
+      listing_##type = strdup(list); \
+}
+
 static bool load_plain(const char *path)
 {
    SSNES_LOG("Loading Cg file: %s\n", path);
-   if (strlen(g_settings.video.second_pass_shader) > 0)
-      SSNES_LOG("Loading 2nd pass: %s\n", g_settings.video.second_pass_shader);
 
-   char *listing[3] = {NULL};
-   const char *list = NULL;
+   char *listing_v[3] = {NULL};
+   char *listing_f[3] = {NULL};
 
    prg[0].fprg = cgCreateProgram(cgCtx, CG_SOURCE, stock_cg_program, cgFProf, "main_fragment", 0);
+   SET_LISTING_INDEX(f, 0);
    prg[0].vprg = cgCreateProgram(cgCtx, CG_SOURCE, stock_cg_program, cgVProf, "main_vertex", 0);
-
-   list = cgGetLastListing(cgCtx);
-   if (list)
-      listing[0] = strdup(list);
+   SET_LISTING_INDEX(v, 0);
 
    prg[1].fprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path, cgFProf, "main_fragment", 0);
+   SET_LISTING_INDEX(f, 1);
    prg[1].vprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path, cgVProf, "main_vertex", 0);
+   SET_LISTING_INDEX(v, 1);
 
-   list = cgGetLastListing(cgCtx);
-   if (list)
-      listing[1] = strdup(list);
-
-   if (strlen(g_settings.video.second_pass_shader) > 0)
+   if (*g_settings.video.second_pass_shader && g_settings.video.render_to_texture)
    {
+      SSNES_LOG("Loading 2nd pass: %s\n", g_settings.video.second_pass_shader);
       prg[2].fprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, g_settings.video.second_pass_shader, cgFProf, "main_fragment", 0);
+      SET_LISTING_INDEX(f, 2);
       prg[2].vprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, g_settings.video.second_pass_shader, cgVProf, "main_vertex", 0);
+      SET_LISTING_INDEX(v, 2);
 
-      list = cgGetLastListing(cgCtx);
-      if (list)
-         listing[2] = strdup(list);
       cg_shader_num = 2;
    }
    else
@@ -330,8 +368,10 @@ static bool load_plain(const char *path)
       {
          CGerror err = cgGetError();
          SSNES_ERR("CG error: %s\n", cgGetErrorString(err));
-         if (listing[i])
-            SSNES_ERR("%s\n", listing[i]);
+         if (listing_v[i])
+            SSNES_ERR("Vertex:\n%s\n", listing_v[i]);
+         else if (listing_f[i])
+            SSNES_ERR("Fragment:\n%s\n", listing_f[i]);
          goto error;
       }
 
@@ -339,13 +379,19 @@ static bool load_plain(const char *path)
       cgGLLoadProgram(prg[i].vprg);
    }
 
+   for (unsigned i = 0; i < 3; i++)
+   {
+      free(listing_v[i]);
+      free(listing_f[i]);
+   }
+
    return true;
 
 error:
    for (unsigned i = 0; i < 3; i++)
    {
-      if (listing[i])
-         free(listing[i]);
+      free(listing_v[i]);
+      free(listing_f[i]);
    }
    return false;
 }
@@ -491,8 +537,8 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
       unsigned addr = 0;
 #ifdef HAVE_PYTHON
       if (tracker_type != SSNES_STATE_PYTHON)
-      {
 #endif
+      {
          unsigned input_slot = 0;
          if (config_get_hex(conf, input_slot_buf, &input_slot))
          {
@@ -526,11 +572,9 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
             SSNES_ERR("No address assigned to semantic.\n");
             goto error;
          }
-#ifdef HAVE_PYTHON
       }
-#endif
 
-      int memtype = 0;
+      unsigned memtype;
       switch (ram_type)
       {
          case SSNES_STATE_WRAM:
@@ -550,10 +594,10 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
             break;
 
          default:
-            memtype = SNES_MEMORY_WRAM;
+            memtype = -1u;
       }
 
-      if (addr >= psnes_get_memory_size(memtype))
+      if ((memtype != -1u) && (addr >= psnes_get_memory_size(memtype)))
       {
          SSNES_ERR("Address out of bounds.\n");
          goto error;
@@ -582,7 +626,7 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
       .oam = psnes_get_memory_data(SNES_MEMORY_OAM),
       .apuram = psnes_get_memory_data(SNES_MEMORY_APURAM),
       .info = info,
-      .info_elem = info_cnt
+      .info_elem = info_cnt,
    };
 
 #ifdef HAVE_PYTHON
@@ -614,7 +658,6 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
 #endif
 
    free(imports);
-
    return true;
 
 error:
@@ -724,8 +767,8 @@ static bool load_preset(const char *path)
       scale->type_y = SSNES_SCALE_INPUT;
       scale->scale_x = 1.0;
       scale->scale_y = 1.0;
-      scale->abs_x = 256;
-      scale->abs_y = 224;
+      scale->abs_x = g_extern.system.geom.base_width;
+      scale->abs_y = g_extern.system.geom.base_height;
 
       if (strcmp(scale_type_x, "source") == 0)
          scale->type_x = SSNES_SCALE_INPUT;
@@ -808,7 +851,7 @@ static bool load_preset(const char *path)
    }
 
    // Basedir.
-   char dir_path[256];
+   char dir_path[MAXPATHLEN];
    strlcpy(dir_path, path, sizeof(dir_path));
    char *ptr = strrchr(dir_path, '/');
    if (!ptr) ptr = strrchr(dir_path, '\\');
@@ -822,7 +865,7 @@ static bool load_preset(const char *path)
    {
       char *shader_path;
       char attr_buf[64];
-      char path_buf[512];
+      char path_buf[MAXPATHLEN];
 
       print_buf(attr_buf, "shader%u", i);
       if (config_get_string(conf, attr_buf, &shader_path))
@@ -840,19 +883,31 @@ static bool load_preset(const char *path)
       SSNES_LOG("Loading Cg shader: \"%s\".\n", path_buf);
 
       struct cg_program *prog = &prg[i + 1];
+
+      char *listing_f = NULL;
       prog->fprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path_buf, cgFProf, "main_fragment", 0);
+      SET_LISTING(f);
+      
+      char *listing_v = NULL;
       prog->vprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path_buf, cgVProf, "main_vertex", 0);
+      SET_LISTING(v);
 
       if (!prog->fprg || !prog->vprg)
       {
-         const char *listing = cgGetLastListing(cgCtx);
          CGerror err = cgGetError();
          SSNES_ERR("CG error: %s\n", cgGetErrorString(err));
-         if (listing)
-            SSNES_ERR("%s\n", listing);
+         if (listing_v)
+            SSNES_ERR("Vertex:\n%s\n", listing_v);
+         else if (listing_f)
+            SSNES_ERR("Fragment:\n%s\n", listing_f);
+
+         free(listing_f);
+         free(listing_v);
          goto error;
       }
 
+      free(listing_f);
+      free(listing_v);
       cgGLLoadProgram(prog->fprg);
       cgGLLoadProgram(prog->vprg);
    }
@@ -933,10 +988,12 @@ bool gl_cg_init(const char *path)
       prg[i].tex_size_f = cgGetNamedParameter(prg[i].fprg, "IN.texture_size");
       prg[i].out_size_f = cgGetNamedParameter(prg[i].fprg, "IN.output_size");
       prg[i].frame_cnt_f = cgGetNamedParameter(prg[i].fprg, "IN.frame_count");
+      prg[i].frame_dir_f = cgGetNamedParameter(prg[i].fprg, "IN.frame_direction");
       prg[i].vid_size_v = cgGetNamedParameter(prg[i].vprg, "IN.video_size");
       prg[i].tex_size_v = cgGetNamedParameter(prg[i].vprg, "IN.texture_size");
       prg[i].out_size_v = cgGetNamedParameter(prg[i].vprg, "IN.output_size");
       prg[i].frame_cnt_v = cgGetNamedParameter(prg[i].vprg, "IN.frame_count");
+      prg[i].frame_dir_v = cgGetNamedParameter(prg[i].vprg, "IN.frame_direction");
       prg[i].mvp = cgGetNamedParameter(prg[i].vprg, "modelViewProj");
       if (prg[i].mvp)
          cgGLSetStateMatrixParameter(prg[i].mvp, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
@@ -948,12 +1005,37 @@ bool gl_cg_init(const char *path)
       prg[i].orig.tex_size_f = cgGetNamedParameter(prg[i].fprg, "ORIG.texture_size");
       prg[i].orig.coord = cgGetNamedParameter(prg[i].vprg, "ORIG.tex_coord");
 
-      prg[i].prev.tex = cgGetNamedParameter(prg[i].fprg, "PREV.texture");
-      prg[i].prev.vid_size_v = cgGetNamedParameter(prg[i].vprg, "PREV.video_size");
-      prg[i].prev.vid_size_f = cgGetNamedParameter(prg[i].fprg, "PREV.video_size");
-      prg[i].prev.tex_size_v = cgGetNamedParameter(prg[i].vprg, "PREV.texture_size");
-      prg[i].prev.tex_size_f = cgGetNamedParameter(prg[i].fprg, "PREV.texture_size");
-      prg[i].prev.coord = cgGetNamedParameter(prg[i].vprg, "PREV.tex_coord");
+      for (unsigned j = 0; j < PREV_TEXTURES; j++)
+      {
+         char attr_buf_tex[64];
+         char attr_buf_vid_size[64];
+         char attr_buf_tex_size[64];
+         char attr_buf_coord[64];
+         static const char *prev_names[PREV_TEXTURES] = {
+            "PREV",
+            "PREV1",
+            "PREV2",
+            "PREV3",
+            "PREV4",
+            "PREV5",
+            "PREV6",
+         };
+
+         snprintf(attr_buf_tex,      sizeof(attr_buf_tex),      "%s.texture", prev_names[j]);
+         snprintf(attr_buf_vid_size, sizeof(attr_buf_vid_size), "%s.video_size", prev_names[j]);
+         snprintf(attr_buf_tex_size, sizeof(attr_buf_tex_size), "%s.texture_size", prev_names[j]);
+         snprintf(attr_buf_coord,    sizeof(attr_buf_coord),    "%s.tex_coord", prev_names[j]);
+
+         prg[i].prev[j].tex = cgGetNamedParameter(prg[i].fprg, attr_buf_tex);
+
+         prg[i].prev[j].vid_size_v = cgGetNamedParameter(prg[i].vprg, attr_buf_vid_size);
+         prg[i].prev[j].vid_size_f = cgGetNamedParameter(prg[i].fprg, attr_buf_vid_size);
+
+         prg[i].prev[j].tex_size_v = cgGetNamedParameter(prg[i].vprg, attr_buf_tex_size);
+         prg[i].prev[j].tex_size_f = cgGetNamedParameter(prg[i].fprg, attr_buf_tex_size);
+
+         prg[i].prev[j].coord = cgGetNamedParameter(prg[i].vprg, attr_buf_coord);
+      }
 
       for (unsigned j = 0; j < i - 1; j++)
       {
@@ -986,6 +1068,8 @@ void gl_cg_use(unsigned index)
 {
    if (cg_active && prg[index].vprg && prg[index].fprg)
    {
+      gl_cg_reset_attrib();
+
       active_index = index;
       cgGLBindProgram(prg[index].vprg);
       cgGLBindProgram(prg[index].fprg);

gfx/shader_glsl.c

@@ -55,6 +55,7 @@
 #define pglLinkProgram glLinkProgram
 #define pglGetUniformLocation glGetUniformLocation
 #define pglUniform1i glUniform1i
+#define pglUniform1f glUniform1f
 #define pglUniform2fv glUniform2fv
 #define pglUniform4fv glUniform4fv
 #define pglGetShaderiv glGetShaderiv
@@ -65,6 +66,7 @@
 #define pglGetAttachedShaders glGetAttachedShaders
 #define pglGetAttribLocation glGetAttribLocation
 #define pglEnableVertexAttribArray glEnableVertexAttribArray
+#define pglDisableVertexAttribArray glDisableVertexAttribArray
 #define pglVertexAttribPointer glVertexAttribPointer
 #else
 static PFNGLCREATEPROGRAMPROC pglCreateProgram = NULL;
@@ -78,6 +80,7 @@ static PFNGLDETACHSHADERPROC pglDetachShader = NULL;
 static PFNGLLINKPROGRAMPROC pglLinkProgram = NULL;
 static PFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation = NULL;
 static PFNGLUNIFORM1IPROC pglUniform1i = NULL;
+static PFNGLUNIFORM1FPROC pglUniform1f = NULL;
 static PFNGLUNIFORM2FVPROC pglUniform2fv = NULL;
 static PFNGLUNIFORM4FVPROC pglUniform4fv = NULL;
 static PFNGLGETSHADERIVPROC pglGetShaderiv = NULL;
@@ -88,12 +91,14 @@ static PFNGLDELETEPROGRAMPROC pglDeleteProgram = NULL;
 static PFNGLGETATTACHEDSHADERSPROC pglGetAttachedShaders = NULL;
 static PFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation = NULL;
 static PFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray = NULL;
+static PFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray = NULL;
 static PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer = NULL;
 #endif
 
 #define MAX_PROGRAMS 16
 #define MAX_TEXTURES 8
 #define MAX_VARIABLES 256
+#define PREV_TEXTURES 7
 
 enum filter_type
 {
@@ -116,10 +121,14 @@ static char gl_teximage_uniforms[MAX_TEXTURES][64];
 static snes_tracker_t *gl_snes_tracker = NULL;
 static struct snes_tracker_uniform_info gl_tracker_info[MAX_VARIABLES];
 static unsigned gl_tracker_info_cnt = 0;
-static char gl_tracker_script[256];
+static char gl_tracker_script[MAXPATHLEN];
 static char gl_tracker_script_class[64];
 static xmlChar *gl_script_program = NULL;
 
+static GLint gl_attribs[PREV_TEXTURES + 1 + MAX_PROGRAMS];
+static unsigned gl_attrib_index = 0;
+
+
 struct shader_program
 {
    char *vertex;
@@ -136,6 +145,21 @@ struct shader_program
    bool valid_scale;
 };
 
+static const char *stock_vertex =
+   "varying vec4 color;\n"
+   "void main() {\n"
+   "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
+   "   gl_TexCoord[0] = gl_MultiTexCoord0;\n"
+   "   color = gl_Color;\n"
+   "}";
+
+static const char *stock_fragment =
+   "uniform sampler2D rubyTexture;\n"
+   "varying vec4 color;\n"
+   "void main() {\n"
+   "   gl_FragColor = color * texture2D(rubyTexture, gl_TexCoord[0].xy);\n"
+   "}";
+
 static bool get_xml_attrs(struct shader_program *prog, xmlNodePtr ptr)
 {
    prog->scale_x = 1.0;
@@ -325,7 +349,7 @@ static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
    if (filter && strcmp((const char*)filter, "nearest") == 0)
       linear = false;
 
-   char tex_path[256];
+   char tex_path[MAXPATHLEN];
    strlcpy(tex_path, shader_path, sizeof(tex_path));
 
    char *last = strrchr(tex_path, '/');
@@ -481,13 +505,13 @@ static bool get_import_value(xmlNodePtr ptr)
       goto error;
    }
 
-   enum snes_ram_type ram_type = SSNES_STATE_WRAM;
+   enum snes_ram_type ram_type = SSNES_STATE_NONE;
    uint32_t addr = 0;
 
 #ifdef HAVE_PYTHON
    if (tracker_type != SSNES_STATE_PYTHON)
-   {
 #endif
+   {
       if (input) 
       {
          unsigned slot = strtoul((const char*)input, NULL, 0);
@@ -515,11 +539,9 @@ static bool get_import_value(xmlNodePtr ptr)
          SSNES_ERR("No RAM address specificed for import value.\n");
          goto error;
       }
-#ifdef HAVE_PYTHON
    }
-#endif
 
-   int memtype = 0;
+   unsigned memtype;
    switch (ram_type)
    {
       case SSNES_STATE_WRAM:
@@ -539,10 +561,10 @@ static bool get_import_value(xmlNodePtr ptr)
          break;
 
       default:
-         memtype = SNES_MEMORY_WRAM;
+         memtype = -1u;
    }
 
-   if (addr >= psnes_get_memory_size(memtype))
+   if ((memtype != -1u) && (addr >= psnes_get_memory_size(memtype)))
    {
       SSNES_ERR("Address out of bounds.\n");
       goto error;
@@ -825,6 +847,13 @@ static bool compile_programs(GLuint *gl_prog, struct shader_program *progs, size
    return true;
 }
 
+static void gl_glsl_reset_attrib(void)
+{
+   for (unsigned i = 0; i < gl_attrib_index; i++)
+      pglDisableVertexAttribArray(gl_attribs[i]);
+   gl_attrib_index = 0;
+}
+
 #define LOAD_GL_SYM(SYM) if (!pgl##SYM) { SDL_SYM_WRAP(pgl##SYM, "gl" #SYM) }
 
 bool gl_glsl_init(const char *path)
@@ -842,6 +871,7 @@ bool gl_glsl_init(const char *path)
    LOAD_GL_SYM(LinkProgram);
    LOAD_GL_SYM(GetUniformLocation);
    LOAD_GL_SYM(Uniform1i);
+   LOAD_GL_SYM(Uniform1f);
    LOAD_GL_SYM(Uniform2fv);
    LOAD_GL_SYM(Uniform4fv);
    LOAD_GL_SYM(GetShaderiv);
@@ -852,6 +882,7 @@ bool gl_glsl_init(const char *path)
    LOAD_GL_SYM(GetAttachedShaders);
    LOAD_GL_SYM(GetAttribLocation);
    LOAD_GL_SYM(EnableVertexAttribArray);
+   LOAD_GL_SYM(DisableVertexAttribArray);
    LOAD_GL_SYM(VertexAttribPointer);
 #endif
 
@@ -862,19 +893,26 @@ bool gl_glsl_init(const char *path)
    bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
       && pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
       && pglDetachShader && pglLinkProgram && pglGetUniformLocation
-      && pglUniform1i && pglUniform2fv && pglUniform4fv
+      && pglUniform1i && pglUniform1f && pglUniform2fv && pglUniform4fv
       && pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog 
       && pglDeleteProgram && pglGetAttachedShaders
-      && pglGetAttribLocation && pglEnableVertexAttribArray
+      && pglGetAttribLocation && pglEnableVertexAttribArray && pglDisableVertexAttribArray
       && pglVertexAttribPointer;
 #endif
 
    if (!shader_support)
    {
-      SSNES_ERR("GLSL shaders aren't supported by your GL driver.\n");
+      SSNES_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
       return false;
    }
 
+   struct shader_program stock_prog = {
+      .vertex = strdup(stock_vertex),
+      .fragment = strdup(stock_fragment),
+   };
+   if (!compile_programs(&gl_program[0], &stock_prog, 1))
+      return false;
+
    struct shader_program progs[MAX_PROGRAMS];
    unsigned num_progs = get_xml_shaders(path, progs, MAX_PROGRAMS - 1);
 
@@ -900,7 +938,7 @@ bool gl_glsl_init(const char *path)
       return false;
 
    // SSNES custom two-pass with two different files.
-   if (num_progs == 1 && *g_settings.video.second_pass_shader)
+   if (num_progs == 1 && *g_settings.video.second_pass_shader && g_settings.video.render_to_texture)
    {
       unsigned secondary_progs = get_xml_shaders(g_settings.video.second_pass_shader, progs, 1);
       if (secondary_progs == 1)
@@ -949,6 +987,10 @@ bool gl_glsl_init(const char *path)
    
    glsl_enable = true;
    gl_num_programs = num_progs;
+   gl_program[gl_num_programs + 1] = gl_program[0];
+
+   gl_glsl_reset_attrib();
+
    return true;
 }
 
@@ -957,10 +999,10 @@ void gl_glsl_deinit(void)
    if (glsl_enable)
    {
       pglUseProgram(0);
-      for (int i = 1; i < MAX_PROGRAMS; i++)
+      for (int i = 0; i <= gl_num_programs; i++)
       {
          if (gl_program[i] == 0)
-            break;
+            continue;
 
          GLsizei count;
          GLuint shaders[2];
@@ -998,6 +1040,8 @@ void gl_glsl_deinit(void)
       snes_tracker_free(gl_snes_tracker);
       gl_snes_tracker = NULL;
    }
+
+   gl_glsl_reset_attrib();
 }
 
 void gl_glsl_set_params(unsigned width, unsigned height, 
@@ -1009,147 +1053,178 @@ void gl_glsl_set_params(unsigned width, unsigned height,
       const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt)
 {
    // We enforce a certain layout for our various texture types in the texunits.
-   // Unit 0: Regular SNES frame (rubyTexture).
-   // Unit 1-A: LUT textures.
-   // Unit A+1: Previous texture.
-   // Unit A+2: Original texture.
-   // Unit A+3-B: FBO textures.
+   // - Regular SNES frame (rubyTexture) (always bound).
+   // - LUT textures (always bound).
+   // - Original texture (always bound if meaningful).
+   // - FBO textures (always bound if available).
+   // - Previous textures.
 
-   if (glsl_enable && gl_program[active_index] > 0)
+   if (!glsl_enable || (gl_program[active_index] == 0))
+      return;
+
+   GLint location;
+
+   float inputSize[2] = {width, height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyInputSize");
+   pglUniform2fv(location, 1, inputSize);
+
+   float outputSize[2] = {out_width, out_height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyOutputSize");
+   pglUniform2fv(location, 1, outputSize);
+
+   float textureSize[2] = {tex_width, tex_height};
+   location = pglGetUniformLocation(gl_program[active_index], "rubyTextureSize");
+   pglUniform2fv(location, 1, textureSize);
+
+   location = pglGetUniformLocation(gl_program[active_index], "rubyFrameCount");
+   pglUniform1i(location, frame_count);
+
+   location = pglGetUniformLocation(gl_program[active_index], "rubyFrameDirection");
+   pglUniform1i(location, g_extern.frame_is_reverse ? -1 : 1);
+
+   for (unsigned i = 0; i < gl_teximage_cnt; i++)
    {
-      GLint location;
+      location = pglGetUniformLocation(gl_program[active_index], gl_teximage_uniforms[i]);
+      pglUniform1i(location, i + 1);
+   }
 
-      float inputSize[2] = {width, height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyInputSize");
-      pglUniform2fv(location, 1, inputSize);
+   unsigned texunit = gl_teximage_cnt + 1;
 
-      float outputSize[2] = {out_width, out_height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyOutputSize");
-      pglUniform2fv(location, 1, outputSize);
+   // Set original texture unless we're in first pass (pointless).
+   if (active_index > 1)
+   {
+      // Bind original texture.
+      pglActiveTexture(GL_TEXTURE0 + texunit);
 
-      float textureSize[2] = {tex_width, tex_height};
-      location = pglGetUniformLocation(gl_program[active_index], "rubyTextureSize");
-      pglUniform2fv(location, 1, textureSize);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTexture");
+      pglUniform1i(location, texunit++);
+      glBindTexture(GL_TEXTURE_2D, info->tex);
 
-      location = pglGetUniformLocation(gl_program[active_index], "rubyFrameCount");
-      pglUniform1i(location, frame_count);
-
-      for (unsigned i = 0; i < gl_teximage_cnt; i++)
-      {
-         location = pglGetUniformLocation(gl_program[active_index], gl_teximage_uniforms[i]);
-         pglUniform1i(location, i + 1);
-      }
-
-      // Set previous texture.
-      pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
-      glBindTexture(GL_TEXTURE_2D, prev_info->tex);
-      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevTexture");
-      pglUniform1i(location, gl_teximage_cnt + 1);
-
-      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevTextureSize");
-      pglUniform2fv(location, 1, prev_info->tex_size);
-      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevInputSize");
-      pglUniform2fv(location, 1, prev_info->input_size);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTextureSize");
+      pglUniform2fv(location, 1, info->tex_size);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyOrigInputSize");
+      pglUniform2fv(location, 1, info->input_size);
 
       // Pass texture coordinates.
-      location = pglGetAttribLocation(gl_program[active_index], "rubyPrevTexCoord");
+      location = pglGetAttribLocation(gl_program[active_index], "rubyOrigTexCoord");
       if (location >= 0)
       {
          pglEnableVertexAttribArray(location);
-         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, prev_info->coord);
+         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, info->coord);
+         gl_attribs[gl_attrib_index++] = location;
       }
 
-      // Set original texture unless we're in first pass (pointless).
-      if (active_index > 1)
+      // Bind new texture in the chain.
+      if (fbo_info_cnt > 0)
       {
-         // Bind original texture.
-         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 2);
-         glBindTexture(GL_TEXTURE_2D, info->tex);
+         pglActiveTexture(GL_TEXTURE0 + texunit + fbo_info_cnt - 1);
+         glBindTexture(GL_TEXTURE_2D, fbo_info[fbo_info_cnt - 1].tex);
+      }
 
-         location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTexture");
-         pglUniform1i(location, gl_teximage_cnt + 2);
+      // Bind FBO textures.
+      for (unsigned i = 0; i < fbo_info_cnt; i++)
+      {
+         char attrib_buf[64];
 
-         location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTextureSize");
-         pglUniform2fv(location, 1, info->tex_size);
-         location = pglGetUniformLocation(gl_program[active_index], "rubyOrigInputSize");
-         pglUniform2fv(location, 1, info->input_size);
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexture", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform1i(location, texunit++);
 
-         // Pass texture coordinates.
-         location = pglGetAttribLocation(gl_program[active_index], "rubyOrigTexCoord");
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTextureSize", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform2fv(location, 1, fbo_info[i].tex_size);
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uInputSize", i + 1);
+         location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
+         pglUniform2fv(location, 1, fbo_info[i].input_size);
+
+         snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexCoord", i + 1);
+         location = pglGetAttribLocation(gl_program[active_index], attrib_buf);
          if (location >= 0)
          {
             pglEnableVertexAttribArray(location);
-            pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, info->coord);
-         }
-
-         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 3;
-
-         // Bind new texture in the chain.
-         if (fbo_info_cnt > 0)
-         {
-            pglActiveTexture(base_tex + fbo_info_cnt - 1);
-            glBindTexture(GL_TEXTURE_2D, fbo_info[fbo_info_cnt - 1].tex);
-         }
-
-         // Bind FBO textures.
-         for (unsigned i = 0; i < fbo_info_cnt; i++)
-         {
-            char attrib_buf[64];
-
-            snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexture", i + 1);
-            location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
-            pglUniform1i(location, base_tex + i - GL_TEXTURE0);
-
-            snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTextureSize", i + 1);
-            location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
-            pglUniform2fv(location, 1, fbo_info[i].tex_size);
-
-            snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uInputSize", i + 1);
-            location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
-            pglUniform2fv(location, 1, fbo_info[i].input_size);
-
-            snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexCoord", i + 1);
-            location = pglGetAttribLocation(gl_program[active_index], attrib_buf);
-            if (location >= 0)
-            {
-               pglEnableVertexAttribArray(location);
-               pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, fbo_info[i].coord);
-            }
+            pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, fbo_info[i].coord);
+            gl_attribs[gl_attrib_index++] = location;
          }
       }
-      else
+   }
+   else
+   {
+      // First pass, so unbind everything to avoid collitions.
+      // Unbind ORIG.
+      pglActiveTexture(GL_TEXTURE0 + texunit);
+      glBindTexture(GL_TEXTURE_2D, 0);
+
+      GLuint base_tex = texunit + 1;
+      // Unbind any lurking FBO passes.
+      // Rendering to a texture that is bound to a texture unit
+      // sounds very shaky ... ;)
+      for (unsigned i = 0; i < gl_num_programs; i++)
       {
-         // First pass, so unbind everything to avoid collitions.
-         // Unbind ORIG.
-         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 2);
+         pglActiveTexture(GL_TEXTURE0 + base_tex + i);
          glBindTexture(GL_TEXTURE_2D, 0);
+      }
+   }
 
-         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 3;
-         // Unbind any lurking FBO passes.
-         // Rendering to a texture that is bound to a texture unit
-         // sounds very shaky ... ;)
-         for (unsigned i = 0; i < gl_num_programs; i++)
-         {
-            pglActiveTexture(GL_TEXTURE0 + base_tex + i);
-            glBindTexture(GL_TEXTURE_2D, 0);
-         }
+   // Set previous textures. Only bind if they're actually used.
+   for (unsigned i = 0; i < PREV_TEXTURES; i++)
+   {
+      char attr_buf_tex[64];
+      char attr_buf_tex_size[64];
+      char attr_buf_input_size[64];
+      char attr_buf_coord[64];
+      static const char *prev_names[PREV_TEXTURES] = {
+         "Prev",
+         "Prev1",
+         "Prev2",
+         "Prev3",
+         "Prev4",
+         "Prev5",
+         "Prev6",
+      };
+
+      snprintf(attr_buf_tex,        sizeof(attr_buf_tex),        "ruby%sTexture",     prev_names[i]);
+      snprintf(attr_buf_tex_size,   sizeof(attr_buf_tex_size),   "ruby%sTextureSize", prev_names[i]);
+      snprintf(attr_buf_input_size, sizeof(attr_buf_input_size), "ruby%sInputSize",   prev_names[i]);
+      snprintf(attr_buf_coord,      sizeof(attr_buf_coord),      "ruby%sTexCoord",    prev_names[i]);
+
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_tex);
+      if (location >= 0)
+      {
+         pglActiveTexture(GL_TEXTURE0 + texunit);
+         glBindTexture(GL_TEXTURE_2D, prev_info[i].tex);
+         pglUniform1i(location, texunit++);
       }
 
-      pglActiveTexture(GL_TEXTURE0);
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_tex_size);
+      pglUniform2fv(location, 1, prev_info[i].tex_size);
+      location = pglGetUniformLocation(gl_program[active_index], attr_buf_input_size);
+      pglUniform2fv(location, 1, prev_info[i].input_size);
 
-      if (gl_snes_tracker)
+      // Pass texture coordinates.
+      location = pglGetAttribLocation(gl_program[active_index], attr_buf_coord);
+      if (location >= 0)
       {
-         static struct snes_tracker_uniform info[MAX_VARIABLES];
-         static unsigned cnt = 0;
-         
-         if (active_index == 1)
-            cnt = snes_get_uniform(gl_snes_tracker, info, MAX_VARIABLES, frame_count);
+         pglEnableVertexAttribArray(location);
+         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, prev_info[i].coord);
+         gl_attribs[gl_attrib_index++] = location;
+      }
+   }
 
-         for (unsigned i = 0; i < cnt; i++)
-         {
-            location = pglGetUniformLocation(gl_program[active_index], info[i].id);
-            pglUniform1i(location, info[i].value);
-         }
+   pglActiveTexture(GL_TEXTURE0);
+
+   if (gl_snes_tracker)
+   {
+      static struct snes_tracker_uniform info[MAX_VARIABLES];
+      static unsigned cnt = 0;
+
+      if (active_index == 1)
+         cnt = snes_get_uniform(gl_snes_tracker, info, MAX_VARIABLES, frame_count);
+
+      for (unsigned i = 0; i < cnt; i++)
+      {
+         location = pglGetUniformLocation(gl_program[active_index], info[i].id);
+         pglUniform1f(location, info[i].value);
       }
    }
 }
@@ -1161,6 +1236,8 @@ void gl_glsl_use(unsigned index)
 {
    if (glsl_enable)
    {
+      gl_glsl_reset_attrib();
+
       active_index = index;
       pglUseProgram(gl_program[index]);
    }

gfx/snes_state.c

@@ -88,32 +88,32 @@ snes_tracker_t* snes_tracker_init(const struct snes_tracker_info *info)
       strlcpy(tracker->info[i].id, info->info[i].id, sizeof(tracker->info[i].id));
       tracker->info[i].addr = info->info[i].addr;
       tracker->info[i].type = info->info[i].type;
-      tracker->info[i].mask = (info->info[i].mask == 0) ? 0xffffffffu : info->info[i].mask;
+      tracker->info[i].mask = (info->info[i].mask == 0) ? -1u : info->info[i].mask;
 
 #ifdef HAVE_PYTHON
       if (info->info[i].type == SSNES_STATE_PYTHON)
          tracker->info[i].py = tracker->py;
 #endif
 
-      assert(info->wram && info->vram && info->cgram &&
-            info->oam && info->apuram);
+      // If we don't have a valid pointer.
+      static const uint8_t empty = 0;
 
       switch (info->info[i].ram_type)
       {
          case SSNES_STATE_WRAM:
-            tracker->info[i].ptr = info->wram;
+            tracker->info[i].ptr = info->wram ? info->wram : ∅
             break;
          case SSNES_STATE_APURAM:
-            tracker->info[i].ptr = info->apuram;
+            tracker->info[i].ptr = info->apuram ? info->apuram : ∅
             break;
          case SSNES_STATE_OAM:
-            tracker->info[i].ptr = info->oam;
+            tracker->info[i].ptr = info->oam ? info->oam : ∅
             break;
          case SSNES_STATE_CGRAM:
-            tracker->info[i].ptr = info->cgram;
+            tracker->info[i].ptr = info->cgram ? info->cgram : ∅
             break;
          case SSNES_STATE_VRAM:
-            tracker->info[i].ptr = info->vram;
+            tracker->info[i].ptr = info->vram ? info->vram : ∅
             break;
          case SSNES_STATE_INPUT_SLOT1:
             tracker->info[i].input_ptr = &tracker->input_state[0];
@@ -125,7 +125,7 @@ snes_tracker_t* snes_tracker_init(const struct snes_tracker_info *info)
             break;
 
          default:
-            tracker->info[i].ptr = NULL;
+            tracker->info[i].ptr = ∅
       }
    }
 

gfx/snes_state.h

@@ -39,6 +39,7 @@ enum snes_tracker_type
 
 enum snes_ram_type
 {
+   SSNES_STATE_NONE,
    SSNES_STATE_WRAM,
    SSNES_STATE_APURAM,
    SSNES_STATE_OAM,
@@ -78,7 +79,7 @@ struct snes_tracker_info
 struct snes_tracker_uniform
 {
    const char *id;
-   int value;
+   float value;
 };
 
 typedef struct snes_tracker snes_tracker_t;

gfx/xvideo.c

@@ -184,9 +184,16 @@ static void set_fullscreen(xv_t *xv)
 static void xv_init_font(xv_t *xv, const char *font_path, unsigned font_size)
 {
 #ifdef HAVE_FREETYPE
-   if (*font_path)
+   if (!g_settings.video.font_enable)
+      return;
+
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      xv->font = font_renderer_new(font_path, font_size);
+      xv->font = font_renderer_new(path, font_size);
       if (xv->font)
       {
          int r = g_settings.video.msg_color_r * 255;
@@ -202,6 +209,8 @@ static void xv_init_font(xv_t *xv, const char *font_path, unsigned font_size)
       else
          SSNES_WARN("Failed to init font.\n");
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
 #endif
 }
 
@@ -320,7 +329,76 @@ 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)
+struct format_desc
+{
+   void (*render_16)(xv_t *xv, const void *input,
+         unsigned width, unsigned height, unsigned pitch);
+   void (*render_32)(xv_t *xv, const void *input,
+         unsigned width, unsigned height, unsigned pitch);
+   char components[4];
+   unsigned luma_index[2];
+   unsigned u_index;
+   unsigned v_index;
+};
+
+static const struct format_desc formats[] = {
+   {
+      .render_16 = render16_yuy2,
+      .render_32 = render32_yuy2,
+      .components = { 'Y', 'U', 'Y', 'V' },
+      .luma_index = { 0, 2 },
+      .u_index = 1,
+      .v_index = 3,
+   },
+   {
+      .render_16 = render16_uyvy,
+      .render_32 = render32_uyvy,
+      .components = { 'U', 'Y', 'V', 'Y' },
+      .luma_index = { 1, 3 },
+      .u_index = 0,
+      .v_index = 2,
+   },
+};
+
+static bool adaptor_set_format(xv_t *xv, Display *dpy, XvPortID port, const video_info_t *video)
+{
+   int format_count;
+   XvImageFormatValues *format = XvListImageFormats(xv->display, port, &format_count);
+   if (!format)
+      return false;
+
+   for (int i = 0; i < format_count; i++) 
+   {
+      for (unsigned j = 0; j < sizeof(formats) / sizeof(formats[0]); j++)
+      {
+         if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
+         {
+            if (format[i].component_order[0] == formats[j].components[0] &&
+                  format[i].component_order[1] == formats[j].components[1] &&
+                  format[i].component_order[2] == formats[j].components[2] &&
+                  format[i].component_order[3] == formats[j].components[3]) 
+            {
+               xv->fourcc = format[i].id;
+               xv->render_func = video->rgb32 ? formats[j].render_32 : formats[j].render_16;
+
+#ifdef HAVE_FREETYPE
+               xv->luma_index[0] = formats[j].luma_index[0];
+               xv->luma_index[1] = formats[j].luma_index[1];
+               xv->chroma_u_index = formats[j].u_index;
+               xv->chroma_v_index = formats[j].v_index;
+#endif
+               XFree(format);
+               return true;
+            }
+         }
+      }
+   }
+
+   XFree(format);
+   return false;
+}
+
+static void *xv_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
    xv_t *xv = calloc(1, sizeof(*xv));
    if (!xv)
@@ -347,17 +425,20 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
       if (adaptor_info[i].num_formats < 1) continue;
       if (!(adaptor_info[i].type & XvInputMask)) continue;
       if (!(adaptor_info[i].type & XvImageMask)) continue;
+      if (!adaptor_set_format(xv, xv->display, adaptor_info[i].base_id, video)) continue;
 
       xv->port     = adaptor_info[i].base_id;
       xv->depth    = adaptor_info[i].formats->depth;
       xv->visualid = adaptor_info[i].formats->visual_id;
+
+      SSNES_LOG("XVideo: Found suitable XvPort #%u\n", (unsigned)xv->port);
       break;
    }
    XvFreeAdaptorInfo(adaptor_info);
 
    if (xv->port == 0) 
    {
-      SSNES_ERR("XVideo: Failed to find valid XvPort.\n");
+      SSNES_ERR("XVideo: Failed to find valid XvPort or format.\n");
       goto error;
    }
 
@@ -381,8 +462,8 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
    attributes.border_pixel = 0;
    attributes.event_mask = StructureNotifyMask | DestroyNotify | ClientMessage;
 
-   unsigned width = video->fullscreen ? ((video->width == 0) ? 256 : video->width) : video->width;
-   unsigned height = video->fullscreen ? ((video->height == 0) ? 224 : video->height) : video->height;
+   unsigned width = video->fullscreen ? ((video->width == 0) ? g_extern.system.geom.base_width : video->width) : video->width;
+   unsigned height = video->fullscreen ? ((video->height == 0) ? g_extern.system.geom.base_height : video->height) : video->height;
    xv->window = XCreateWindow(xv->display, DefaultRootWindow(xv->display),
          0, 0, width, height,
          0, xv->depth, InputOutput, visualinfo->visual,
@@ -407,66 +488,8 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
    Atom atom = XInternAtom(xv->display, "XV_AUTOPAINT_COLORKEY", true);
    if (atom != None) XvSetPortAttribute(xv->display, xv->port, atom, 1);
 
-   int format_count;
-   XvImageFormatValues *format = XvListImageFormats(xv->display, xv->port, &format_count);
-
-   bool has_format = false;
-   for (int i = 0; i < format_count; i++) 
-   {
-      if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
-      {
-         if (format[i].component_order[0] == 'Y' && format[i].component_order[1] == 'U'
-               && format[i].component_order[2] == 'Y' && format[i].component_order[3] == 'V') 
-         {
-            has_format = true;
-            xv->fourcc = format[i].id;
-            xv->render_func = video->rgb32 ? render32_yuy2 : render16_yuy2;
-
-#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 (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
-         {
-            if (format[i].component_order[0] == 'U' && format[i].component_order[1] == 'Y'
-                  && format[i].component_order[2] == 'V' && format[i].component_order[3] == 'Y') 
-            {
-               has_format = true;
-               xv->fourcc = format[i].id;
-               xv->render_func = video->rgb32 ? render32_uyvy : render16_uyvy;
-
-#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) 
-   {
-      SSNES_ERR("XVideo: unable to find a supported image format.\n");
-      goto error;
-   }
-
-   xv->width = 512;
-   xv->height = 512;
+   xv->width = g_extern.system.geom.max_width;
+   xv->height = g_extern.system.geom.max_height;
 
    xv->image = XvShmCreateImage(xv->display, xv->port, xv->fourcc, NULL, xv->width, xv->height, &xv->shminfo);
    if (!xv->image) 
@@ -673,7 +696,7 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
 #endif
 }
 
-static bool xv_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
+static bool xv_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
 {
    xv_t *xv = data;
 

input/sdl.c

@@ -55,6 +55,7 @@ static const struct key_bind lut_binds[] = {
    { SDLK_KP_MULTIPLY, SK_KP_MULTIPLY },
    { SDLK_KP_DIVIDE, SK_KP_DIVIDE },
    { SDLK_BACKQUOTE, SK_BACKQUOTE },
+   { SDLK_PAUSE, SK_PAUSE },
    { SDLK_KP0, SK_KP0 },
    { SDLK_KP1, SK_KP1 },
    { SDLK_KP2, SK_KP2 },
@@ -122,7 +123,7 @@ static void init_lut(void)
       keysym_lut[lut_binds[i].sk] = lut_binds[i].sdl;
 }
 
-static void* sdl_input_init(void)
+static void *sdl_input_init(void)
 {
    init_lut();
    sdl_input_t *sdl = calloc(1, sizeof(*sdl));

input/x11_input.c

@@ -65,6 +65,7 @@ static const struct key_bind lut_binds[] = {
    { XK_KP_Multiply, SK_KP_MULTIPLY },
    { XK_KP_Divide, SK_KP_DIVIDE },
    { XK_grave, SK_BACKQUOTE },
+   { XK_Pause, SK_PAUSE },
    { XK_KP_0, SK_KP0 },
    { XK_KP_1, SK_KP1 },
    { XK_KP_2, SK_KP2 },
@@ -132,7 +133,7 @@ static void init_lut(void)
       keysym_lut[lut_binds[i].sk] = lut_binds[i].x;
 }
 
-static void* x_input_init(void)
+static void *x_input_init(void)
 {
    x11_input_t *x11 = calloc(1, sizeof(*x11));
    if (!x11)

libsnes.hpp

@@ -66,6 +66,36 @@ extern "C" {
 #define SNES_MEMORY_OAM     103
 #define SNES_MEMORY_CGRAM   104
 
+// SSNES extension. Not required to be implemented for a working implementation.
+#define SNES_ENVIRONMENT_GET_FULLPATH 0   // const char ** -- Full path of game loaded.
+#define SNES_ENVIRONMENT_SET_GEOMETRY 1   // const struct snes_geometry * -- Window geometry information for the system/game.
+#define SNES_ENVIRONMENT_SET_PITCH 2      // const unsigned * -- Pitch of game image.
+#define SNES_ENVIRONMENT_GET_OVERSCAN 3   // bool * -- Boolean value whether or not the implementation should use overscan.
+#define SNES_ENVIRONMENT_SET_TIMING 4     // const struct snes_system_timing * -- Set exact timings of the system.
+                                          // Used primarily for video recording.
+#define SNES_ENVIRONMENT_GET_CAN_DUPE 5   // bool * -- Boolean value whether or not SSNES supports frame duping,
+                                          // passing NULL to video frame callback.
+
+struct snes_geometry
+{
+   unsigned base_width;    // Nominal video width of system.
+   unsigned base_height;   // Nominal video height of system.
+   unsigned max_width;     // Maximum possible width of system.
+   unsigned max_height;    // Maximum possible height of system.
+};
+
+struct snes_system_timing
+{
+   double fps;
+   double sample_rate;
+};
+
+typedef bool (*snes_environment_t)(unsigned cmd, void *data);
+
+// Must be called before calling snes_init().
+void snes_set_environment(snes_environment_t);
+////
+
 typedef void (*snes_video_refresh_t)(const uint16_t *data, unsigned width, unsigned height);
 typedef void (*snes_audio_sample_t)(uint16_t left, uint16_t right);
 typedef void (*snes_input_poll_t)(void);
@@ -74,6 +104,8 @@ typedef int16_t (*snes_input_state_t)(bool port, unsigned device, unsigned index
 unsigned snes_library_revision_major(void);
 unsigned snes_library_revision_minor(void);
 
+const char *snes_library_id(void);
+
 void snes_set_video_refresh(snes_video_refresh_t);
 void snes_set_audio_sample(snes_audio_sample_t);
 void snes_set_input_poll(snes_input_poll_t);

movie.c

@@ -78,7 +78,7 @@ uint32_t crc32_adjust(uint32_t crc32, uint8_t input)
 uint32_t crc32_calculate(const uint8_t *data, unsigned length)
 {
    uint32_t crc32 = ~0;
-   for(unsigned i = 0; i < length; i++)
+   for (unsigned i = 0; i < length; i++)
       crc32 = crc32_adjust(crc32, data[i]);
    return ~crc32;
 }
@@ -88,13 +88,12 @@ struct bsv_movie
    FILE *file;
    uint8_t *state;
 
-   long *frame_pos; // A ring buffer keeping track of many key presses were requested per frame.
+   size_t *frame_pos; // A ring buffer keeping track of positions in the file for each frame.
    size_t frame_mask;
-   uint16_t current_frame_count;
    size_t frame_ptr;
 
    bool playback;
-   unsigned min_file_pos;
+   size_t min_file_pos;
 
    bool first_rewind;
    bool did_rewind;
@@ -103,7 +102,7 @@ struct bsv_movie
 #define BSV_MAGIC 0x42535631
 
 #define MAGIC_INDEX 0
-#define SERIALIZER_INDEX 1
+#define SERIALIZER_INDEX 1 // Not current used.
 #define CRC_INDEX 2
 #define STATE_SIZE_INDEX 3
 
@@ -154,25 +153,32 @@ static bool init_playback(bsv_movie_t *handle, const char *path)
    }
 
    uint32_t state_size = swap_if_big32(header[STATE_SIZE_INDEX]);
-   handle->state = malloc(state_size);
-   if (!handle->state)
-      return false;
+
+   // If we're playing back from the start, state_size is 0.
+   if (state_size)
+   {
+      handle->state = malloc(state_size);
+      if (!handle->state)
+         return false;
+
+      if (fread(handle->state, 1, state_size, handle->file) != state_size)
+      {
+         SSNES_ERR("Couldn't read state from movie.\n");
+         return false;
+      }
+
+      if (psnes_serialize_size() != state_size)
+      {
+         SSNES_ERR("Movie format seems to have a different serializer version. Cannot continue.\n");
+         exit(1);
+      }
+
+      // Unserialize to start playback.
+      psnes_unserialize(handle->state, state_size);
+   }
 
    handle->min_file_pos = sizeof(header) + state_size;
 
-   if (fread(handle->state, 1, state_size, handle->file) != state_size)
-   {
-      SSNES_ERR("Couldn't read state from movie.\n");
-      return false;
-   }
-
-   if (psnes_serialize_size() != state_size)
-   {
-      SSNES_ERR("Movie format seems to have a different serializer version. Cannot continue.\n");
-      exit(1);
-   }
-   // Unserialize to start playback.
-   psnes_unserialize(handle->state, state_size);
    return true;
 }
 
@@ -187,10 +193,10 @@ static bool init_record(bsv_movie_t *handle, const char *path)
 
    uint32_t header[4] = {0};
    header[MAGIC_INDEX] = swap_if_big32(BSV_MAGIC);
-   //header[SERIALIZER_INDEX] = 0; // TODO: Fix this.
    header[CRC_INDEX] = swap_if_big32(g_extern.cart_crc);
 
    uint32_t state_size = psnes_serialize_size();
+
    header[STATE_SIZE_INDEX] = swap_if_big32(state_size);
    fwrite(header, 4, sizeof(uint32_t), handle->file);
 
@@ -200,8 +206,12 @@ static bool init_record(bsv_movie_t *handle, const char *path)
 
    handle->min_file_pos = sizeof(header) + state_size;
 
-   psnes_serialize(handle->state, state_size);
-   fwrite(handle->state, 1, state_size, handle->file);
+   if (state_size > 0)
+   {
+      psnes_serialize(handle->state, state_size);
+      fwrite(handle->state, 1, state_size, handle->file);
+   }
+
    return true;
 }
 
@@ -245,8 +255,11 @@ bsv_movie_t *bsv_movie_init(const char *path, enum ssnes_movie_type type)
    else if (!init_record(handle, path))
       goto error;
 
-   if (!(handle->frame_pos = calloc((1 << 20), sizeof(long)))) // Just pick something really large :D
+   // Just pick something really large :D ~1 million frames rewind should do the trick.
+   if (!(handle->frame_pos = calloc((1 << 20), sizeof(size_t))))
       goto error; 
+
+   handle->frame_pos[0] = handle->min_file_pos;
    handle->frame_mask = (1 << 20) - 1;
 
    return handle;
@@ -258,14 +271,11 @@ error:
 
 void bsv_movie_set_frame_start(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Starting frame: %u, Pos: %ld\n", (unsigned)handle->frame_ptr, ftell(handle->file));
    handle->frame_pos[handle->frame_ptr] = ftell(handle->file);
-
 }
 
 void bsv_movie_set_frame_end(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Frame++\n");
    handle->frame_ptr = (handle->frame_ptr + 1) & handle->frame_mask;
 
    handle->first_rewind = !handle->did_rewind;
@@ -274,22 +284,27 @@ void bsv_movie_set_frame_end(bsv_movie_t *handle)
 
 void bsv_movie_frame_rewind(bsv_movie_t *handle)
 {
-   //fprintf(stderr, "Frame--\n");
-
    handle->did_rewind = true;
-   if (handle->frame_ptr <= 1)
+
+   // If we're at the beginning ... :)
+   if ((handle->frame_ptr <= 1) && (handle->frame_pos[0] == handle->min_file_pos))
    {
       handle->frame_ptr = 0;
       fseek(handle->file, handle->min_file_pos, SEEK_SET);
    }
    else
    {
+      // First time rewind is performed, the old frame is simply replayed.
+      // However, playing back that frame caused us to read data, and push data to the ring buffer.
+      // Sucessively rewinding frames, we need to rewind past the read data, plus another.
       handle->frame_ptr = (handle->frame_ptr - (handle->first_rewind ? 1 : 2)) & handle->frame_mask;
       fseek(handle->file, handle->frame_pos[handle->frame_ptr], SEEK_SET);
    }
 
+   // We rewound past the beginning. :O
    if (ftell(handle->file) <= (long)handle->min_file_pos)
    {
+      // If recording, we simply reset the starting point. Nice and easy.
       if (!handle->playback)
       {
          fseek(handle->file, 4 * sizeof(uint32_t), SEEK_SET);

netplay.c

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

qb/config.libs.sh

@@ -12,16 +12,17 @@ if [ -d /opt/local/lib ]; then
    add_library_dirs /opt/local/lib
 fi
 
-if [ "$OS" = BSD ]; then
+if [ $OS = BSD ]; then
    DYLIB=-lc
 else
    DYLIB=-ldl
 fi
 
-if [ "$HAVE_DYNAMIC" = "yes" ] && [ "$HAVE_CONFIGFILE" = "no" ]; then
-   echo "Cannot have dynamic loading of libsnes and no configfile support."
-   echo "Dynamic loading requires config file support."
-   exit 1
+if [ -z "$LIBSNES" ]; then
+   LIBSNES="-lsnes"
+else
+   echo "Explicit libsnes used, disabling dynamic libsnes loading ..."
+   HAVE_DYNAMIC=no
 fi
 
 if [ $HAVE_DYNAMIC != yes ]; then
@@ -33,18 +34,23 @@ fi
 check_lib DYLIB $DYLIB dlopen
 check_lib NETPLAY -lc socket
 
+if [ $HAVE_DYLIB = no ] && [ $HAVE_DYNAMIC = yes ]; then
+   echo "Dynamic loading of libsnes is enabled, but your platform does not appear to have dlopen(), use --disable-dynamic or --with-libsnes=\"-lsnes\"".
+   exit 1
+fi
+
 check_pkgconf ALSA alsa
 check_header OSS sys/soundcard.h
 check_header OSS_BSD soundcard.h
 check_lib OSS_LIB -lossaudio
 
-if [ "$OS" = "Darwin" ]; then
+if [ $OS = Darwin ]; then
    check_lib AL "-framework OpenAL" alcOpenDevice
 else
    check_lib AL -lopenal alcOpenDevice
 fi
 
-if [ "$OS" = "Darwin" ]; then
+if [ $OS = Darwin ]; then
    check_lib FBO "-framework OpenGL" glFramebufferTexture2D
 else
    check_lib FBO -lGL glFramebufferTexture2D
@@ -61,7 +67,12 @@ check_pkgconf SDL sdl 1.2.10
 check_critical SDL "Cannot find SDL library."
 
 # On some distros, -lCg doesn't link against -lstdc++ it seems ...
-check_lib_cxx CG -lCg cgCreateContext
+if [ $HAVE_OPENGL != no ]; then
+   check_lib_cxx CG -lCg cgCreateContext
+else
+   echo "Ignoring Cg. OpenGL is not enabled."
+   HAVE_CG=no
+fi
 
 check_pkgconf XML libxml-2.0
 check_pkgconf SDL_IMAGE SDL_image
@@ -75,12 +86,29 @@ if [ $HAVE_FFMPEG != no ]; then
    ( [ $HAVE_FFMPEG = auto ] && ( [ $HAVE_AVCODEC = no ] || [ $HAVE_AVFORMAT = no ] || [ $HAVE_AVUTIL = no ] || [ $HAVE_SWSCALE = no ] ) && HAVE_FFMPEG=no ) || HAVE_FFMPEG=yes
 fi
 
-check_pkgconf SRC samplerate
+if [ $HAVE_FFMPEG = yes ]; then
+   check_lib FFMPEG_ALLOC_CONTEXT3 "$AVCODEC_LIBS" avcodec_alloc_context3
+   check_lib FFMPEG_AVCODEC_OPEN2 "$AVCODEC_LIBS" avcodec_open2
+   check_lib FFMPEG_AVIO_OPEN "$AVFORMAT_LIBS" avio_open
+   check_lib FFMPEG_AVFORMAT_WRITE_HEADER "$AVFORMAT_LIBS" avformat_write_header
+   check_lib FFMPEG_AVFORMAT_NEW_STREAM "$AVFORMAT_LIBS" avformat_new_stream
+fi
+
+if [ $HAVE_FFMPEG = no ] && [ $HAVE_X264RGB = yes ]; then
+   echo "x264 RGB recording is enabled, but FFmpeg is not. --enable-x264rgb will not have any effect."
+fi
 
 check_lib DYNAMIC $DYLIB dlopen
 
 check_pkgconf FREETYPE freetype2
-check_pkgconf XVIDEO xv
+check_pkgconf X11 x11
+check_pkgconf XEXT xext
+if [ $HAVE_X11 = yes ] && [ $HAVE_XEXT = yes ]; then
+   check_pkgconf XVIDEO xv
+else
+   echo "X11 or Xext not present. Skipping XVideo."
+   HAVE_XVIDEO=no
+fi
 
 check_lib STRL -lc strlcpy
 
@@ -89,7 +117,7 @@ check_pkgconf PYTHON python3
 add_define_make OS $OS
 
 # Creates config.mk and config.h.
-VARS="ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL DYLIB CG XML SDL_IMAGE DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE SRC CONFIGFILE FREETYPE XVIDEO NETPLAY FBO STRL PYTHON"
+VARS="ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL OPENGL DYLIB CG XML SDL_IMAGE DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE CONFIGFILE FREETYPE XVIDEO X11 XEXT NETPLAY FBO STRL PYTHON FFMPEG_ALLOC_CONTEXT3 FFMPEG_AVCODEC_OPEN2 FFMPEG_AVIO_OPEN FFMPEG_AVFORMAT_WRITE_HEADER FFMPEG_AVFORMAT_NEW_STREAM X264RGB"
 create_config_make config.mk $VARS
 create_config_header config.h $VARS
 

qb/config.params.sh

@@ -1,19 +1,20 @@
 . qb/qb.params.sh
 
 PACKAGE_NAME=ssnes
-PACKAGE_VERSION=0.8.2
+PACKAGE_VERSION=0.9.2
 
 # Adds a command line opt to ./configure --help
 # $1: Variable (HAVE_ALSA, HAVE_OSS, etc)   
 # $2: Comment                 
 # $3: Default arg. auto implies that HAVE_ALSA will be set according to library checks later on.
-add_command_line_enable DYNAMIC "Enable dynamic loading of libsnes library." no
-add_command_line_string LIBSNES "libsnes library used" "-lsnes"
-add_command_line_enable FFMPEG "Enable FFmpeg recording support" no
+add_command_line_enable DYNAMIC "Disable dynamic loading of libsnes library" yes
+add_command_line_string LIBSNES "libsnes library used" ""
+add_command_line_enable FFMPEG "Enable FFmpeg recording support" auto
+add_command_line_enable X264RGB "Enable lossless X264 RGB recording" no
 add_command_line_enable DYLIB "Enable dynamic loading support" auto
 add_command_line_enable NETPLAY "Enable netplay support" auto
-add_command_line_enable SRC "Enable libsamplerate support" no
 add_command_line_enable CONFIGFILE "Disable support for config file" yes
+add_command_line_enable OPENGL "Disable OpenGL support" yes
 add_command_line_enable CG "Enable Cg shader support" auto
 add_command_line_enable XML "Enable bSNES-style XML shader support" auto
 add_command_line_enable FBO "Enable render-to-texture (FBO) support" auto
@@ -28,4 +29,4 @@ add_command_line_enable PULSE "Enable PulseAudio support" auto
 add_command_line_enable FREETYPE "Enable FreeType support" auto
 add_command_line_enable XVIDEO "Enable XVideo support" auto
 add_command_line_enable SDL_IMAGE "Enable SDL_image support" auto
-add_command_line_enable PYTHON "Enable Python 3 support for shaders" no
+add_command_line_enable PYTHON "Enable Python 3 support for shaders" auto

qb/qb.params.sh

@@ -81,7 +81,7 @@ print_sub_str_opt()
 
    lowertext="`echo $arg1 | tr '[A-Z]' '[a-z]'`"
 
-   echo "--with-$lowertext: $arg2 (Defaults: $arg3)"
+   echo "--with-$lowertext: $arg2"
 }
 
 parse_input()

record/ffemu.c

@@ -13,11 +13,16 @@
 #include <stdbool.h>
 #include "ffemu.h"
 #include "fifo_buffer.h"
-#include "SDL_thread.h"
+#include "thread.h"
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
 
 struct video_info
 {
    AVCodecContext *codec;
+   AVCodec *encoder;
 
    AVFrame *conv_frame;
    uint8_t *conv_frame_buf;
@@ -27,7 +32,8 @@ struct video_info
    size_t outbuf_size;
 
    int fmt;
-   int pix_size;
+   int pix_fmt;
+   size_t pix_size;
 
    AVFormatContext *format;
 
@@ -37,6 +43,7 @@ struct video_info
 struct audio_info
 {
    AVCodecContext *codec;
+   AVCodec *encoder;
 
    int16_t *buffer;
    size_t frames_in_buffer;
@@ -62,13 +69,14 @@ struct ffemu
    
    struct ffemu_params params;
 
-   SDL_cond *cond;
-   SDL_mutex *cond_lock;
-   SDL_mutex *lock;
+   scond_t *cond;
+   slock_t *cond_lock;
+   slock_t *lock;
    fifo_buffer_t *audio_fifo;
    fifo_buffer_t *video_fifo;
    fifo_buffer_t *attr_fifo;
-   SDL_Thread *thread;
+   sthread_t *thread;
+
    volatile bool alive;
    volatile bool can_sleep;
 };
@@ -79,14 +87,29 @@ static bool init_audio(struct audio_info *audio, struct ffemu_params *param)
    if (!codec)
       return false;
 
+   audio->encoder = codec;
+
+   // FFmpeg just loves to deprecate stuff :)
+#ifdef HAVE_FFMPEG_ALLOC_CONTEXT3
    audio->codec = avcodec_alloc_context3(codec);
+#else
+   audio->codec = avcodec_alloc_context();
+   avcodec_get_context_defaults(audio->codec);
+#endif
 
    audio->codec->sample_rate = param->samplerate;
-   audio->codec->time_base = (AVRational) { 1, param->samplerate };
+   audio->codec->time_base = av_d2q(1.0 / param->samplerate, 1000000);
    audio->codec->channels = param->channels;
    audio->codec->sample_fmt = AV_SAMPLE_FMT_S16;
+
+#ifdef HAVE_FFMPEG_AVCODEC_OPEN2
    if (avcodec_open2(audio->codec, codec, NULL) != 0)
+#else
+   if (avcodec_open(audio->codec, codec) != 0)
+#endif
+   {
       return false;
+   }
 
    audio->buffer = av_malloc(audio->codec->frame_size * param->channels * sizeof(int16_t));
    if (!audio->buffer)
@@ -100,12 +123,18 @@ static bool init_audio(struct audio_info *audio, struct ffemu_params *param)
    return true;
 }
 
-static bool init_video(struct video_info *video, struct ffemu_params *param)
+static bool init_video(struct video_info *video, const struct ffemu_params *param)
 {
+#ifdef HAVE_X264RGB
+   AVCodec *codec = avcodec_find_encoder(CODEC_ID_H264);
+#else
    AVCodec *codec = avcodec_find_encoder(CODEC_ID_FFV1);
+#endif
    if (!codec)
       return false;
 
+   video->encoder = codec;
+
 #if AV_HAVE_BIGENDIAN
    video->fmt = PIX_FMT_RGB555BE;
 #else
@@ -118,26 +147,58 @@ static bool init_video(struct video_info *video, struct ffemu_params *param)
       video->pix_size = sizeof(uint32_t);
    }
 
+#ifdef HAVE_X264RGB
+   video->pix_fmt = PIX_FMT_BGR24;
+#else
+   video->pix_fmt = PIX_FMT_RGB32;
+#endif
+
+#ifdef HAVE_FFMPEG_ALLOC_CONTEXT3
    video->codec = avcodec_alloc_context3(codec);
+#else
+   video->codec = avcodec_alloc_context();
+   avcodec_get_context_defaults(video->codec);
+#endif
+
    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->time_base = av_d2q(1.0 / param->fps, 1000000); // Arbitrary big number.
    video->codec->sample_aspect_ratio = av_d2q(param->aspect_ratio * param->out_height / param->out_width, 255);
-   video->codec->thread_count = 2;
+   video->codec->pix_fmt = video->pix_fmt;
 
-   if (avcodec_open2(video->codec, codec, NULL) != 0)
+#ifdef HAVE_FFMPEG_AVCODEC_OPEN2
+   AVDictionary *opts = NULL;
+#endif
+
+#ifdef HAVE_X264RGB
+   video->codec->thread_count = 3;
+   av_dict_set(&opts, "qp", "0", 0);
+#else
+   video->codec->thread_count = 2;
+#endif
+
+#ifdef HAVE_FFMPEG_AVCODEC_OPEN2
+   if (avcodec_open2(video->codec, codec, &opts) != 0)
+#else
+   if (avcodec_open(video->codec, codec) != 0)
+#endif
+   {
       return false;
+   }
+
+#ifdef HAVE_FFMPEG_AVCODEC_OPEN2
+   if (opts)
+      av_dict_free(&opts);
+#endif
 
    // Allocate a big buffer :p ffmpeg API doesn't seem to give us some clues how big this buffer should be.
    video->outbuf_size = 1 << 23;
    video->outbuf = av_malloc(video->outbuf_size);
 
-   // Just to make sure we can handle the biggest frames. Seemed to crash with just 256 * 224.
-   int size = avpicture_get_size(PIX_FMT_RGB32, param->fb_width, param->fb_height);
+   size_t size = avpicture_get_size(video->pix_fmt, param->out_width, param->out_height);
    video->conv_frame_buf = av_malloc(size);
    video->conv_frame = avcodec_alloc_frame();
-   avpicture_fill((AVPicture*)video->conv_frame, video->conv_frame_buf, PIX_FMT_RGB32, param->fb_width, param->fb_height);
+   avpicture_fill((AVPicture*)video->conv_frame, video->conv_frame_buf, video->pix_fmt, param->out_width, param->out_height);
 
    return true;
 }
@@ -147,14 +208,34 @@ 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);
-   if (avio_open(&ctx->pb, ctx->filename, AVIO_FLAG_WRITE) < 0)
+
+   // FFmpeg sure likes to make things difficult.
+#if defined(AVIO_FLAG_WRITE)
+#define FFMPEG_FLAG_RW AVIO_FLAG_WRITE
+#elif defined(AVIO_WRONLY)
+#define FFMPEG_FLAG_RW AVIO_WRONLY
+#elif defined(URL_WRONLY)
+#define FFMPEG_FLAG_RW URL_WRONLY
+#else
+#define FFMPEG_FLAG_RW 2 // Seems to be consistent, but you never know.
+#endif
+
+#ifdef HAVE_FFMPEG_AVIO_OPEN
+   if (avio_open(&ctx->pb, ctx->filename, FFMPEG_FLAG_RW) < 0)
+#else
+   if (url_fopen(&ctx->pb, ctx->filename, FFMPEG_FLAG_RW) < 0)
+#endif
    {
       av_free(ctx);
       return false;
    }
 
-   int stream_cnt = 0;
+#ifdef HAVE_FFMPEG_AVFORMAT_NEW_STREAM
+   AVStream *stream = avformat_new_stream(ctx, handle->video.encoder);
+#else
+   unsigned stream_cnt = 0;
    AVStream *stream = av_new_stream(ctx, stream_cnt++);
+#endif
    stream->codec = handle->video.codec;
 
    if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
@@ -162,29 +243,45 @@ static bool init_muxer(ffemu_t *handle)
    handle->muxer.vstream = stream;
    handle->muxer.vstream->sample_aspect_ratio = handle->video.codec->sample_aspect_ratio;
 
+#ifdef HAVE_FFMPEG_AVFORMAT_NEW_STREAM
+   stream = avformat_new_stream(ctx, handle->audio.encoder);
+#else
    stream = av_new_stream(ctx, stream_cnt++);
+#endif
    stream->codec = handle->audio.codec;
 
    if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
       handle->audio.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
    handle->muxer.astream = stream;
 
+#ifdef HAVE_X264RGB // Avoids a warning at end about non-monotonically increasing DTS values. It seems to be harmless to disable this.
+   ctx->oformat->flags |= AVFMT_TS_NONSTRICT;
+#endif
+
+   av_dict_set(&ctx->metadata, "title", "SSNES video dump", 0); 
+
+#ifdef HAVE_FFMPEG_AVFORMAT_WRITE_HEADER
    if (avformat_write_header(ctx, NULL) < 0)
+#else
+   if (av_write_header(ctx) != 0)
+#endif
+   {
       return false;
+   }
 
    handle->muxer.ctx = ctx;
    return true;
 }
 
-#define MAX_FRAMES 64
+#define MAX_FRAMES 32
 
-static int SDLCALL ffemu_thread(void *data);
+static void ffemu_thread(void *data);
 
 static bool init_thread(ffemu_t *handle)
 {
-   assert(handle->lock = SDL_CreateMutex());
-   assert(handle->cond_lock = SDL_CreateMutex());
-   assert(handle->cond = SDL_CreateCond());
+   assert(handle->lock = slock_new());
+   assert(handle->cond_lock = slock_new());
+   assert(handle->cond = scond_new());
    assert(handle->audio_fifo = fifo_new(32000 * sizeof(int16_t) * handle->params.channels * MAX_FRAMES / 60));
    assert(handle->attr_fifo = fifo_new(sizeof(struct ffemu_video_data) * MAX_FRAMES));
    assert(handle->video_fifo = fifo_new(handle->params.fb_width * handle->params.fb_height *
@@ -192,7 +289,7 @@ static bool init_thread(ffemu_t *handle)
 
    handle->alive = true;
    handle->can_sleep = true;
-   assert(handle->thread = SDL_CreateThread(ffemu_thread, handle));
+   assert(handle->thread = sthread_create(ffemu_thread, handle));
 
    return true;
 }
@@ -201,17 +298,17 @@ static void deinit_thread(ffemu_t *handle)
 {
    if (handle->thread)
    {
-      SDL_mutexP(handle->cond_lock);
+      slock_lock(handle->cond_lock);
       handle->alive = false;
       handle->can_sleep = false;
-      SDL_mutexV(handle->cond_lock);
+      slock_unlock(handle->cond_lock);
 
-      SDL_CondSignal(handle->cond);
-      SDL_WaitThread(handle->thread, NULL);
+      scond_signal(handle->cond);
+      sthread_join(handle->thread);
 
-      SDL_DestroyMutex(handle->lock);
-      SDL_DestroyMutex(handle->cond_lock);
-      SDL_DestroyCond(handle->cond);
+      slock_free(handle->lock);
+      slock_free(handle->cond_lock);
+      scond_free(handle->cond);
 
       handle->thread = NULL;
    }
@@ -302,96 +399,111 @@ void ffemu_free(ffemu_t *handle)
    }
 }
 
-int ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data)
+bool ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data)
 {
    for (;;)
    {
-      SDL_mutexP(handle->lock);
+      slock_lock(handle->lock);
       unsigned avail = fifo_write_avail(handle->attr_fifo);
-      SDL_mutexV(handle->lock);
+      slock_unlock(handle->lock);
 
       if (!handle->alive)
-         return -1;
+         return false;
 
       if (avail >= sizeof(*data))
          break;
 
-      SDL_mutexP(handle->cond_lock);
+      slock_lock(handle->cond_lock);
       if (handle->can_sleep)
       {
          handle->can_sleep = false;
-         SDL_CondWait(handle->cond, handle->cond_lock);
+         scond_wait(handle->cond, handle->cond_lock);
          handle->can_sleep = true;
       }
       else
-         SDL_CondSignal(handle->cond);
+         scond_signal(handle->cond);
 
-      SDL_mutexV(handle->cond_lock);
+      slock_unlock(handle->cond_lock);
    }
 
-   SDL_mutexP(handle->lock);
-   fifo_write(handle->attr_fifo, data, sizeof(*data));
-   fifo_write(handle->video_fifo, data->data, data->pitch * data->height);
-   SDL_mutexV(handle->lock);
-   SDL_CondSignal(handle->cond);
+   slock_lock(handle->lock);
 
-   return 0;
+   // Tightly pack our frame to conserve memory. libsnes tends to use a very large pitch.
+   struct ffemu_video_data attr_data = *data;
+
+   if (attr_data.is_dupe)
+      attr_data.width = attr_data.height = attr_data.pitch = 0;
+   else
+      attr_data.pitch = attr_data.width * handle->video.pix_size;
+
+   fifo_write(handle->attr_fifo, &attr_data, sizeof(attr_data));
+
+   unsigned offset = 0;
+   for (unsigned y = 0; y < attr_data.height; y++, offset += data->pitch)
+      fifo_write(handle->video_fifo, (const uint8_t*)data->data + offset, attr_data.pitch);
+
+   slock_unlock(handle->lock);
+   scond_signal(handle->cond);
+
+   return true;
 }
 
-int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
+bool ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
 {
    for (;;)
    {
-      SDL_mutexP(handle->lock);
+      slock_lock(handle->lock);
       unsigned avail = fifo_write_avail(handle->audio_fifo);
-      SDL_mutexV(handle->lock);
+      slock_unlock(handle->lock);
 
       if (!handle->alive)
-         return -1;
+         return false;
 
       if (avail >= data->frames * handle->params.channels * sizeof(int16_t))
          break;
 
-      SDL_mutexP(handle->cond_lock);
+      slock_lock(handle->cond_lock);
       if (handle->can_sleep)
       {
          handle->can_sleep = false;
-         SDL_CondWait(handle->cond, handle->cond_lock);
+         scond_wait(handle->cond, handle->cond_lock);
          handle->can_sleep = true;
       }
       else
-         SDL_CondSignal(handle->cond);
+         scond_signal(handle->cond);
 
-      SDL_mutexV(handle->cond_lock);
+      slock_unlock(handle->cond_lock);
    }
 
-   SDL_mutexP(handle->lock);
+   slock_lock(handle->lock);
    fifo_write(handle->audio_fifo, data->data, data->frames * handle->params.channels * sizeof(int16_t));
-   SDL_mutexV(handle->lock);
-   SDL_CondSignal(handle->cond);
+   slock_unlock(handle->lock);
+   scond_signal(handle->cond);
 
-   return 0;
+   return true;
 }
 
-static int ffemu_push_video_thread(ffemu_t *handle, const struct ffemu_video_data *data)
+static bool ffemu_push_video_thread(ffemu_t *handle, const struct ffemu_video_data *data)
 {
-   handle->video.sws_ctx = sws_getCachedContext(handle->video.sws_ctx, data->width, data->height, handle->video.fmt,
-         handle->params.out_width, handle->params.out_height, PIX_FMT_RGB32, SWS_POINT,
-         NULL, NULL, NULL);
+   if (!data->is_dupe)
+   {
+      handle->video.sws_ctx = sws_getCachedContext(handle->video.sws_ctx, data->width, data->height, handle->video.fmt,
+            handle->params.out_width, handle->params.out_height, handle->video.pix_fmt, SWS_POINT,
+            NULL, NULL, NULL);
 
-   int linesize = data->pitch;
+      int linesize = data->pitch;
 
-   sws_scale(handle->video.sws_ctx, (const uint8_t* const*)&data->data, &linesize, 0,
-         handle->video.codec->height, handle->video.conv_frame->data, handle->video.conv_frame->linesize);
+      sws_scale(handle->video.sws_ctx, (const uint8_t* const*)&data->data, &linesize, 0,
+            data->height, handle->video.conv_frame->data, handle->video.conv_frame->linesize);
+   }
 
    handle->video.conv_frame->pts = handle->video.frame_cnt;
-   handle->video.conv_frame->display_picture_number = handle->video.frame_cnt;
 
    int outsize = avcodec_encode_video(handle->video.codec, handle->video.outbuf,
          handle->video.outbuf_size, handle->video.conv_frame);
 
    if (outsize < 0)
-      return -1;
+      return false;
 
    AVPacket pkt;
    av_init_packet(&pkt);
@@ -408,21 +520,21 @@ static int ffemu_push_video_thread(ffemu_t *handle, const struct ffemu_video_dat
    if (pkt.size > 0)
    {
       if (av_interleaved_write_frame(handle->muxer.ctx, &pkt) < 0)
-         return -1;
+         return false;
    }
 
    handle->video.frame_cnt++;
 
-   return 0;
+   return true;
 }
 
-static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_data *data)
+static bool ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_data *data)
 {
    size_t written_frames = 0;
    while (written_frames < data->frames)
    {
       size_t can_write = handle->audio.codec->frame_size - handle->audio.frames_in_buffer;
-      size_t write_frames = data->frames > can_write ? can_write : data->frames;
+      size_t write_frames = data->frames - written_frames > can_write ? can_write : data->frames - written_frames;
 
       memcpy(handle->audio.buffer + handle->audio.frames_in_buffer * handle->params.channels,
             data->data + written_frames * handle->params.channels, 
@@ -438,15 +550,15 @@ static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_dat
          pkt.data = handle->audio.outbuf;
          pkt.stream_index = handle->muxer.astream->index;
 
-         int out_size = avcodec_encode_audio(handle->audio.codec, handle->audio.outbuf, handle->audio.outbuf_size, handle->audio.buffer);
+         int out_size = avcodec_encode_audio(handle->audio.codec,
+               handle->audio.outbuf, handle->audio.outbuf_size, handle->audio.buffer);
          if (out_size < 0)
-            return -1;
+            return false;
 
          pkt.size = out_size;
-         if (handle->audio.codec->coded_frame && handle->audio.codec->coded_frame->pts != AV_NOPTS_VALUE)
-            pkt.pts = av_rescale_q(handle->audio.codec->coded_frame->pts, handle->audio.codec->time_base, handle->muxer.astream->time_base);
-         else
-            pkt.pts = av_rescale_q(handle->audio.frame_cnt, handle->audio.codec->time_base, handle->muxer.astream->time_base);
+
+         pkt.pts = av_rescale_q(handle->audio.codec->coded_frame->pts,
+               handle->audio.codec->time_base, handle->muxer.astream->time_base);
 
          pkt.flags |= AV_PKT_FLAG_KEY;
          handle->audio.frames_in_buffer = 0;
@@ -455,85 +567,96 @@ static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_dat
          if (pkt.size > 0)
          {
             if (av_interleaved_write_frame(handle->muxer.ctx, &pkt) < 0)
-               return -1;
+               return false;
          }
       }
    }
-   return 0;
+   return true;
 }
 
-int ffemu_finalize(ffemu_t *handle)
+bool ffemu_finalize(ffemu_t *handle)
 {
    deinit_thread(handle);
 
-   // Push out frames still stuck in queue.
+   size_t audio_buf_size = 512 * handle->params.channels * sizeof(int16_t);
+   int16_t *audio_buf = av_malloc(audio_buf_size);
    void *video_buf = av_malloc(2 * handle->params.fb_width * handle->params.fb_height * handle->video.pix_size);
-   if (video_buf)
+
+   // Try pushing data in an interleaving pattern to ease the work of the muxer a bit.
+   bool did_work;
+   do
    {
+      did_work = false;
+
+      if (fifo_read_avail(handle->audio_fifo) >= audio_buf_size)
+      {
+         fifo_read(handle->audio_fifo, audio_buf, audio_buf_size);
+
+         struct ffemu_audio_data aud = {
+            .frames = 512,
+            .data = audio_buf
+         };
+
+         ffemu_push_audio_thread(handle, &aud);
+         did_work = true;
+      }
+
       struct ffemu_video_data attr_buf;
-      while (fifo_read_avail(handle->attr_fifo) >= sizeof(attr_buf))
+      if (fifo_read_avail(handle->attr_fifo) >= sizeof(attr_buf))
       {
          fifo_read(handle->attr_fifo, &attr_buf, sizeof(attr_buf));
          fifo_read(handle->video_fifo, video_buf, attr_buf.height * attr_buf.pitch);
          attr_buf.data = video_buf;
          ffemu_push_video_thread(handle, &attr_buf);
+
+         did_work = true;
       }
-      av_free(video_buf);
-   }
+   } while (did_work);
 
-   size_t audio_buf_size = 128 * handle->params.channels * sizeof(int16_t);
-   int16_t *audio_buf = av_malloc(audio_buf_size);
-   if (audio_buf)
-   {
-      while (fifo_read_avail(handle->audio_fifo) >= audio_buf_size)
-      {
-         fifo_read(handle->audio_fifo, audio_buf, sizeof(audio_buf_size));
-
-         struct ffemu_audio_data aud = {
-            .frames = 128,
-            .data = audio_buf
-         };
-
-         ffemu_push_audio_thread(handle, &aud);
-      }
-      av_free(audio_buf);
-   }
+   // Flush out last audio.
+   size_t avail = fifo_read_avail(handle->audio_fifo);
+   fifo_read(handle->audio_fifo, audio_buf, avail);
+   struct ffemu_audio_data aud = {
+      .frames = avail / (sizeof(int16_t) * handle->params.channels),
+      .data = audio_buf
+   };
+   ffemu_push_audio_thread(handle, &aud);
 
    deinit_thread_buf(handle);
+   av_free(audio_buf);
+   av_free(video_buf);
 
-   // Push out delayed frames. (MPEG codecs)
+   // Flush out last video.
    AVPacket pkt;
    av_init_packet(&pkt);
    pkt.stream_index = handle->muxer.vstream->index;
    pkt.data = handle->video.outbuf;
 
    int out_size = 0;
-   do
+   for (;;)
    {
       out_size = avcodec_encode_video(handle->video.codec, handle->video.outbuf, handle->video.outbuf_size, NULL);
+      if (out_size <= 0)
+         break;
+
       pkt.pts = av_rescale_q(handle->video.codec->coded_frame->pts, handle->video.codec->time_base, handle->muxer.vstream->time_base);
 
       if (handle->video.codec->coded_frame->key_frame)
          pkt.flags |= AV_PKT_FLAG_KEY;
 
       pkt.size = out_size;
-
-      if (pkt.size > 0)
-      {
-         int err = av_interleaved_write_frame(handle->muxer.ctx, &pkt);
-         if (err < 0)
-            break;
-      }
-
-   } while (out_size > 0);
+      int err = av_interleaved_write_frame(handle->muxer.ctx, &pkt);
+      if (err < 0)
+         break;
+   }
 
    // Write final data.
    av_write_trailer(handle->muxer.ctx);
 
-   return 0;
+   return true;
 }
 
-static int SDLCALL ffemu_thread(void *data)
+static void ffemu_thread(void *data)
 {
    ffemu_t *ff = data;
 
@@ -541,47 +664,47 @@ static int SDLCALL ffemu_thread(void *data)
    void *video_buf = av_malloc(2 * ff->params.fb_width * ff->params.fb_height * ff->video.pix_size);
    assert(video_buf);
 
-   size_t audio_buf_size = 128 * ff->params.channels * sizeof(int16_t);
+   size_t audio_buf_size = 512 * ff->params.channels * sizeof(int16_t);
    int16_t *audio_buf = av_malloc(audio_buf_size);
    assert(audio_buf);
 
-   struct ffemu_video_data attr_buf;
-
    while (ff->alive)
    {
+      struct ffemu_video_data attr_buf;
+
       bool avail_video = false;
       bool avail_audio = false;
 
-      SDL_mutexP(ff->lock);
+      slock_lock(ff->lock);
       if (fifo_read_avail(ff->attr_fifo) >= sizeof(attr_buf))
          avail_video = true;
 
       if (fifo_read_avail(ff->audio_fifo) >= audio_buf_size)
          avail_audio = true;
-      SDL_mutexV(ff->lock);
+      slock_unlock(ff->lock);
 
       if (!avail_video && !avail_audio)
       {
-         SDL_mutexP(ff->cond_lock);
+         slock_lock(ff->cond_lock);
          if (ff->can_sleep)
          {
             ff->can_sleep = false;
-            SDL_CondWait(ff->cond, ff->cond_lock);
+            scond_wait(ff->cond, ff->cond_lock);
             ff->can_sleep = true;
          }
          else
-            SDL_CondSignal(ff->cond);
+            scond_signal(ff->cond);
 
-         SDL_mutexV(ff->cond_lock);
+         slock_unlock(ff->cond_lock);
       }
 
       if (avail_video)
       {
-         SDL_mutexP(ff->lock);
+         slock_lock(ff->lock);
          fifo_read(ff->attr_fifo, &attr_buf, sizeof(attr_buf));
          fifo_read(ff->video_fifo, video_buf, attr_buf.height * attr_buf.pitch);
-         SDL_mutexV(ff->lock);
-         SDL_CondSignal(ff->cond);
+         slock_unlock(ff->lock);
+         scond_signal(ff->cond);
 
          attr_buf.data = video_buf;
          ffemu_push_video_thread(ff, &attr_buf);
@@ -589,13 +712,13 @@ static int SDLCALL ffemu_thread(void *data)
 
       if (avail_audio)
       {
-         SDL_mutexP(ff->lock);
+         slock_lock(ff->lock);
          fifo_read(ff->audio_fifo, audio_buf, audio_buf_size);
-         SDL_mutexV(ff->lock);
-         SDL_CondSignal(ff->cond);
+         slock_unlock(ff->lock);
+         scond_signal(ff->cond);
 
          struct ffemu_audio_data aud = {
-            .frames = 128,
+            .frames = 512,
             .data = audio_buf
          };
 
@@ -605,6 +728,5 @@ static int SDLCALL ffemu_thread(void *data)
 
    av_free(video_buf);
    av_free(audio_buf);
-
-   return 0;
 }
+

record/ffemu.h

@@ -8,15 +8,14 @@
 extern "C" {
 #endif
 
-struct ffemu_rational
-{
-   unsigned num;
-   unsigned den;
-};
-
 // Parameters passed to ffemu_new()
 struct ffemu_params
 {
+   // FPS of input video.
+   double fps;
+   // Sample rate of input audio.
+   double samplerate;
+
    // Desired output resolution.
    unsigned out_width;
    unsigned out_height;
@@ -24,38 +23,17 @@ struct ffemu_params
    // Total size of framebuffer used in input.
    unsigned fb_width;
    unsigned fb_height;
+
+   // Aspect ratio of input video. Parameters are passed to the muxer,
+   // the video itself is not scaled.
    float aspect_ratio;
 
-   // FPS of video input.
-   struct ffemu_rational fps;
-
-   // Relative video quality. 0 is lossless (if available), 10 is very low quality. 
-   // A value over 10 is codec defined if it will give even worse quality.
-   unsigned videoq;
-
-   // Define some video codec dependent option. (E.g. h264 profiles)
-   uint64_t video_opt;
-
-   // Audio sample rate.
-   unsigned samplerate;
-
    // Audio channels.
    unsigned channels;
 
    // If input is ARGB or XRGB1555.
    bool rgb32;
 
-   // Audio bits. Sample format is always signed PCM in native byte order.
-   //unsigned bits;
-
-   // Relative audio quality. 0 is lossless (if available), 10 is very low quality.
-   // A value over 10 is codec defined if it will give even worse quality.
-   // Some codecs might ignore this (lossless codecs such as FLAC).
-   unsigned audioq;
-
-   // Define some audio codec dependent option.
-   uint64_t audio_opt;
-
    // Filename to dump to.
    const char *filename;
 };
@@ -66,6 +44,7 @@ struct ffemu_video_data
    unsigned width;
    unsigned height;
    unsigned pitch;
+   bool is_dupe;
 };
 
 struct ffemu_audio_data
@@ -79,10 +58,9 @@ typedef struct ffemu ffemu_t;
 ffemu_t *ffemu_new(const struct ffemu_params *params);
 void ffemu_free(ffemu_t* handle);
 
-int ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data);
-int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data);
-int ffemu_finalize(ffemu_t *handle);
-
+bool ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data);
+bool ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data);
+bool ffemu_finalize(ffemu_t *handle);
 
 #ifdef __cplusplus
 }

rewind.c

@@ -21,34 +21,66 @@
 #include <stdbool.h>
 #include <string.h>
 #include <assert.h>
-
-//#include <stdio.h>
+#include <limits.h>
+#include "general.h"
 
 struct state_manager
 {
    uint64_t *buffer;
    size_t buf_size;
+   size_t buf_size_mask;
    uint32_t *tmp_state;
-   uint32_t *scratch_buf;
    size_t top_ptr;
    size_t bottom_ptr;
    size_t state_size;
    bool first_pop;
 };
 
+static inline size_t nearest_pow2_size(size_t v)
+{
+   size_t orig = v;
+   v--;
+   v |= v >> 1;
+   v |= v >> 2;
+   v |= v >> 4;
+#if SIZE_MAX >= 0xffffu
+      v |= v >> 8;
+#endif
+#if SIZE_MAX >= 0xfffffffflu
+      v |= v >> 16;
+#endif
+#if SIZE_MAX >= 0xffffffffffffffffllu
+      v |= v >> 32;
+#endif
+   v++;
+
+   size_t next = v;
+   size_t prev = v >> 1;
+
+   if ((next - orig) < (orig - prev))
+      return next;
+   else
+      return prev;
+}
+
 state_manager_t *state_manager_new(size_t state_size, size_t buffer_size, void *init_buffer)
 {
-   if (buffer_size <= state_size * 2 + 1) // Need a sufficient buffer size.
+   if (buffer_size <= state_size * 4) // Need a sufficient buffer size.
       return NULL;
 
    state_manager_t *state = calloc(1, sizeof(*state));
    if (!state)
       return NULL;
 
-   assert(state_size % 4 == 0); // We need 4-byte aligned state_size to avoid having to enforce this with unneeded memcpy's!
+   // We need 4-byte aligned state_size to avoid having to enforce this with unneeded memcpy's!
+   assert(state_size % 4 == 0);
    state->top_ptr = 1;
-   state->state_size = (state_size + 3) >> 2; // Multiple of 4.
-   state->buf_size = (buffer_size + 7) >> 3; // Multiple of 8.
+
+   state->state_size = state_size / sizeof(uint32_t); // Works in multiple of 4.
+   state->buf_size = nearest_pow2_size(buffer_size) / sizeof(uint64_t); // Works in multiple of 8.
+   state->buf_size_mask = state->buf_size - 1;
+   SSNES_LOG("Readjusted rewind buffer size to %u MiB\n", (unsigned)(sizeof(uint64_t) * (state->buf_size >> 20)));
+
    if (!(state->buffer = calloc(1, state->buf_size * sizeof(uint64_t))))
       goto error;
    if (!(state->tmp_state = calloc(1, state->state_size * sizeof(uint32_t))))
@@ -84,14 +116,11 @@ bool state_manager_pop(state_manager_t *state, void **data)
       return true;
    }
 
-   if (state->top_ptr == 0)
-      state->top_ptr = state->buf_size - 1;
-   else
-      state->top_ptr--;
+   state->top_ptr = (state->top_ptr - 1) & state->buf_size_mask;
 
    if (state->top_ptr == state->bottom_ptr) // Our stack is completely empty... :v
    {
-      state->top_ptr = (state->top_ptr + 1) % state->buf_size;
+      state->top_ptr = (state->top_ptr + 1) & state->buf_size_mask;
       return false;
    }
 
@@ -102,15 +131,12 @@ bool state_manager_pop(state_manager_t *state, void **data)
       uint32_t xor = state->buffer[state->top_ptr] & 0xFFFFFFFFU;
       state->tmp_state[addr] ^= xor;
 
-      if (state->top_ptr == 0)
-         state->top_ptr = state->buf_size - 1;
-      else
-         state->top_ptr--;
+      state->top_ptr = (state->top_ptr - 1) & state->buf_size_mask;
    }
 
    if (state->top_ptr == state->bottom_ptr) // Our stack is completely empty... :v
    {
-      state->top_ptr = (state->top_ptr + 1) % state->buf_size;
+      state->top_ptr = (state->top_ptr + 1) & state->buf_size_mask;
       return true;
    }
 
@@ -119,33 +145,36 @@ bool state_manager_pop(state_manager_t *state, void **data)
 
 static void reassign_bottom(state_manager_t *state)
 {
-   state->bottom_ptr = (state->top_ptr + 1) % state->buf_size;
+   state->bottom_ptr = (state->top_ptr + 1) & state->buf_size_mask;
    while (state->buffer[state->bottom_ptr]) // Skip ahead until we find the first 0 (boundary for state delta).
-      state->bottom_ptr = (state->bottom_ptr + 1) % state->buf_size;
+      state->bottom_ptr = (state->bottom_ptr + 1) & state->buf_size_mask;
 }
 
 static void generate_delta(state_manager_t *state, const void *data)
 {
-   //unsigned patch_size = 0;
    bool crossed = false;
    const uint32_t *old_state = state->tmp_state;
    const uint32_t *new_state = data;
 
    state->buffer[state->top_ptr++] = 0; // For each separate delta, we have a 0 value sentinel in between.
-   if (state->top_ptr == state->bottom_ptr) // Check if top_ptr and bottom_ptr crossed each other, which means we need to delete old cruft.
+   state->top_ptr &= state->buf_size_mask;
+
+   // Check if top_ptr and bottom_ptr crossed each other, which means we need to delete old cruft.
+   if (state->top_ptr == state->bottom_ptr)
       crossed = true;
 
    for (uint64_t i = 0; i < state->state_size; i++)
    {
       uint64_t xor = old_state[i] ^ new_state[i];
 
-      // If the data differs (xor != 0), we push that xor on the stack with index and xor. This can be reversed by reapplying the xor.
-      // This, if states don't really differ much, we'll save lots of space :) Hopefully this will work really well with save states.
+      // If the data differs (xor != 0), we push that xor on the stack with index and xor.
+      // This can be reversed by reapplying the xor.
+      // This, if states don't really differ much, we'll save lots of space :)
+      // Hopefully this will work really well with save states.
       if (xor)
       {
-         //patch_size++;
          state->buffer[state->top_ptr] = (i << 32) | xor;
-         state->top_ptr = (state->top_ptr + 1) % state->buf_size;
+         state->top_ptr = (state->top_ptr + 1) & state->buf_size_mask;
 
          if (state->top_ptr == state->bottom_ptr)
             crossed = true;
@@ -154,8 +183,6 @@ static void generate_delta(state_manager_t *state, const void *data)
 
    if (crossed)
       reassign_bottom(state);
-
-   //fprintf(stderr, "DELTA SIZE: %u, ORIG SIZE: %u\n", (unsigned)patch_size << 3, (unsigned)state->state_size << 2);
 }
 
 bool state_manager_push(state_manager_t *state, const void *data)

screenshot.c

@@ -69,12 +69,12 @@ static void dump_content(FILE *file, const uint16_t *frame, unsigned width, unsi
       for (unsigned i = 0; i < width; i++)
       {
          uint16_t pixel = *src++;
-         uint8_t b = (pixel & 0x1f) << 3;
-         uint8_t g = (pixel & 0x03e0) >> 2;
-         uint8_t r = (pixel & 0x7c00) >> 7;
-         *dst++ = b;
-         *dst++ = g;
-         *dst++ = r;
+         uint8_t b = (pixel >>  0) & 0x1f;
+         uint8_t g = (pixel >>  5) & 0x1f;
+         uint8_t r = (pixel >> 10) & 0x1f;
+         *dst++ = (b << 3) | (b >> 2);
+         *dst++ = (g << 3) | (g >> 2);
+         *dst++ = (r << 3) | (r >> 2);
       }
 
       fwrite(line, 1, sizeof(line), file);

settings.c

@@ -129,8 +129,9 @@ static void set_defaults(void)
    g_settings.video.smooth = video_smooth;
    g_settings.video.force_aspect = force_aspect;
    g_settings.video.crop_overscan = crop_overscan;
-   g_settings.video.aspect_ratio = SNES_ASPECT_RATIO;
+   g_settings.video.aspect_ratio = -1.0f; // Automatic
    g_settings.video.shader_type = SSNES_SHADER_AUTO;
+   g_settings.video.font_enable = font_enable;
 
 #ifdef HAVE_FREETYPE
    g_settings.video.font_size = font_size;
@@ -149,22 +150,18 @@ static void set_defaults(void)
    g_settings.video.second_pass_smooth = second_pass_smooth;
 #endif
 
+   g_settings.video.refresh_rate = refresh_rate;
    g_settings.video.hires_record = hires_record;
    g_settings.video.post_filter_record = post_filter_record;
 
    g_settings.audio.enable = audio_enable;
    g_settings.audio.out_rate = out_rate;
-   g_settings.audio.in_rate = in_rate;
    g_settings.audio.rate_step = audio_rate_step;
    if (audio_device)
       strlcpy(g_settings.audio.device, audio_device, sizeof(g_settings.audio.device));
    g_settings.audio.latency = out_latency;
    g_settings.audio.sync = audio_sync;
 
-#ifdef HAVE_SRC
-   g_settings.audio.src_quality = SAMPLERATE_QUALITY;
-#endif
-
    g_settings.rewind_enable = rewind_enable;
    g_settings.rewind_buffer_size = rewind_buffer_size;
    g_settings.rewind_granularity = rewind_granularity;
@@ -172,6 +169,7 @@ static void set_defaults(void)
    g_settings.autosave_interval = autosave_interval;
 
    g_settings.block_sram_overwrite = block_sram_overwrite;
+   g_settings.savestate_auto_index = savestate_auto_index;
 
    assert(sizeof(g_settings.input.binds[0]) >= sizeof(snes_keybinds_1));
    assert(sizeof(g_settings.input.binds[1]) >= sizeof(snes_keybinds_rest));
@@ -291,7 +289,11 @@ static void parse_config_file(void)
       return;
 
    if (g_extern.verbose)
-      config_file_dump(conf, stderr);
+   {
+      fprintf(stderr, "=== Config ===\n");
+      config_file_dump_all(conf, stderr);
+      fprintf(stderr, "=== Config end ===\n");
+   }
 
    int tmp_int;
    double tmp_double;
@@ -315,6 +317,7 @@ static void parse_config_file(void)
    CONFIG_GET_BOOL(video.force_aspect, "video_force_aspect");
    CONFIG_GET_BOOL(video.crop_overscan, "video_crop_overscan");
    CONFIG_GET_DOUBLE(video.aspect_ratio, "video_aspect_ratio");
+   CONFIG_GET_DOUBLE(video.refresh_rate, "video_refresh_rate");
 
    CONFIG_GET_STRING(video.cg_shader_path, "video_cg_shader");
    CONFIG_GET_STRING(video.bsnes_shader_path, "video_bsnes_shader");
@@ -327,6 +330,7 @@ static void parse_config_file(void)
 #ifdef HAVE_FREETYPE
    CONFIG_GET_STRING(video.font_path, "video_font_path");
    CONFIG_GET_INT(video.font_size, "video_font_size");
+   CONFIG_GET_BOOL(video.font_enable, "video_font_enable");
    CONFIG_GET_DOUBLE(video.msg_pos_x, "video_message_pos_x");
    CONFIG_GET_DOUBLE(video.msg_pos_y, "video_message_pos_y");
 
@@ -377,28 +381,20 @@ static void parse_config_file(void)
    // Audio settings.
    CONFIG_GET_BOOL(audio.enable, "audio_enable");
    CONFIG_GET_INT(audio.out_rate, "audio_out_rate");
-   CONFIG_GET_DOUBLE(audio.in_rate, "audio_in_rate");
    CONFIG_GET_DOUBLE(audio.rate_step, "audio_rate_step");
    CONFIG_GET_STRING(audio.device, "audio_device");
    CONFIG_GET_INT(audio.latency, "audio_latency");
    CONFIG_GET_BOOL(audio.sync, "audio_sync");
 
-#ifdef HAVE_SRC
-   if (config_get_int(conf, "audio_src_quality", &tmp_int))
-   {
-      int quals[] = { SRC_ZERO_ORDER_HOLD, SRC_LINEAR, SRC_SINC_FASTEST, 
-         SRC_SINC_MEDIUM_QUALITY, SRC_SINC_BEST_QUALITY };
-
-      if (tmp_int > 0 && tmp_int < 6)
-         g_settings.audio.src_quality = quals[tmp_int];
-   }
-#endif
-
    CONFIG_GET_STRING(video.driver, "video_driver");
    CONFIG_GET_STRING(audio.driver, "audio_driver");
    CONFIG_GET_STRING(audio.dsp_plugin, "audio_dsp_plugin");
    CONFIG_GET_STRING(input.driver, "input_driver");
-   CONFIG_GET_STRING(libsnes, "libsnes_path");
+
+   if (!*g_settings.libsnes)
+   {
+      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))
@@ -410,7 +406,7 @@ static void parse_config_file(void)
    CONFIG_GET_BOOL(rewind_enable, "rewind_enable");
 
    if (config_get_int(conf, "rewind_buffer_size", &tmp_int))
-      g_settings.rewind_buffer_size = tmp_int * 1000000;
+      g_settings.rewind_buffer_size = tmp_int * 1000000LLU;
 
    CONFIG_GET_INT(rewind_granularity, "rewind_granularity");
 
@@ -421,6 +417,7 @@ static void parse_config_file(void)
    CONFIG_GET_STRING(cheat_settings_path, "cheat_settings_path");
 
    CONFIG_GET_BOOL(block_sram_overwrite, "block_sram_overwrite");
+   CONFIG_GET_BOOL(savestate_auto_index, "savestate_auto_index");
 
    if (!g_extern.has_set_save_path && config_get_array(conf, "savefile_directory", tmp_str, sizeof(tmp_str)))
    {
@@ -486,6 +483,7 @@ static const struct bind_map bind_maps[MAX_PLAYERS][MAX_BINDS - 1] = {
       DECLARE_BIND(rewind,                SSNES_REWIND)
       DECLARE_BIND(movie_record_toggle,   SSNES_MOVIE_RECORD_TOGGLE)
       DECLARE_BIND(pause_toggle,          SSNES_PAUSE_TOGGLE)
+      DECLARE_BIND(frame_advance,         SSNES_FRAMEADVANCE)
       DECLARE_BIND(reset,                 SSNES_RESET)
       DECLARE_BIND(shader_next,           SSNES_SHADER_NEXT)
       DECLARE_BIND(shader_prev,           SSNES_SHADER_PREV)
@@ -521,6 +519,7 @@ static const struct bind_map bind_maps[MAX_PLAYERS][MAX_BINDS - 1] = {
       DECLARE_BIND(rewind,                SSNES_REWIND)
       DECLARE_BIND(movie_record_toggle,   SSNES_MOVIE_RECORD_TOGGLE)
       DECLARE_BIND(pause_toggle,          SSNES_PAUSE_TOGGLE)
+      DECLARE_BIND(frame_advance,         SSNES_FRAMEADVANCE)
       DECLARE_BIND(reset,                 SSNES_RESET)
       DECLARE_BIND(shader_next,           SSNES_SHADER_NEXT)
       DECLARE_BIND(shader_prev,           SSNES_SHADER_PREV)
@@ -556,6 +555,7 @@ static const struct bind_map bind_maps[MAX_PLAYERS][MAX_BINDS - 1] = {
       DECLARE_BIND(rewind,                SSNES_REWIND)
       DECLARE_BIND(movie_record_toggle,   SSNES_MOVIE_RECORD_TOGGLE)
       DECLARE_BIND(pause_toggle,          SSNES_PAUSE_TOGGLE)
+      DECLARE_BIND(frame_advance,         SSNES_FRAMEADVANCE)
       DECLARE_BIND(reset,                 SSNES_RESET)
       DECLARE_BIND(shader_next,           SSNES_SHADER_NEXT)
       DECLARE_BIND(shader_prev,           SSNES_SHADER_PREV)
@@ -591,6 +591,7 @@ static const struct bind_map bind_maps[MAX_PLAYERS][MAX_BINDS - 1] = {
       DECLARE_BIND(rewind,                SSNES_REWIND)
       DECLARE_BIND(movie_record_toggle,   SSNES_MOVIE_RECORD_TOGGLE)
       DECLARE_BIND(pause_toggle,          SSNES_PAUSE_TOGGLE)
+      DECLARE_BIND(frame_advance,         SSNES_FRAMEADVANCE)
       DECLARE_BIND(reset,                 SSNES_RESET)
       DECLARE_BIND(shader_next,           SSNES_SHADER_NEXT)
       DECLARE_BIND(shader_prev,           SSNES_SHADER_PREV)
@@ -626,6 +627,7 @@ static const struct bind_map bind_maps[MAX_PLAYERS][MAX_BINDS - 1] = {
       DECLARE_BIND(rewind,                SSNES_REWIND)
       DECLARE_BIND(movie_record_toggle,   SSNES_MOVIE_RECORD_TOGGLE)
       DECLARE_BIND(pause_toggle,          SSNES_PAUSE_TOGGLE)
+      DECLARE_BIND(frame_advance,         SSNES_FRAMEADVANCE)
       DECLARE_BIND(reset,                 SSNES_RESET)
       DECLARE_BIND(shader_next,           SSNES_SHADER_NEXT)
       DECLARE_BIND(shader_prev,           SSNES_SHADER_PREV)
@@ -709,6 +711,7 @@ static const struct key_map sk_map[] = {
    { "scroll_lock", SK_SCROLLOCK },
    { "tilde", SK_BACKQUOTE },
    { "backquote", SK_BACKQUOTE },
+   { "pause", SK_PAUSE },
    { "nul", SK_UNKNOWN },
 };
 

ssnes-mingw-build.sh

@@ -68,8 +68,8 @@ do_phoenix_build()
       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 ..."
+   make -f Makefile.win clean || die "Failed to clean ..."
+   make -f Makefile.win 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 ..."
 

ssnes.cfg

@@ -19,7 +19,8 @@
 # Path to external video driver using the SSNES driver API.
 # video_external_driver =
 
-# Windowed xscale and yscale (Real x res: 224 * xscale * aspect_ratio, real y scale: 224 * xscale)
+# Windowed xscale and yscale
+# (Real x res: base_size * xscale * aspect_ratio, real y res: base_size * yscale)
 # video_xscale = 3.0
 # video_yscale = 3.0
 
@@ -88,6 +89,9 @@
 # Size of the TTF font rendered.
 # video_font_size = 48
 
+# Enable usage of OSD messages.
+# video_font_enable = true
+
 # Offset for where messages will be placed on screen. Values are in range 0.0 to 1.0 for both x and y values. 
 # [0.0, 0.0] maps to the lower left corner of the screen.
 # video_message_pos_x = 0.05
@@ -97,6 +101,10 @@
 # It is a regular RGB hex number, i.e. red is "ff0000".
 # video_message_color = ffffff
 
+# Video refresh rate of your monitor.
+# Used to calculate a suitable audio input rate.
+# video_refresh_rate = 59.95
+
 #### Audio
 
 # Enable audio.
@@ -105,12 +113,6 @@
 # Audio output samplerate.
 # audio_out_rate = 48000
 
-# Audio input samplerate from libsnes.
-# Lower this (slightly) if you are experiencing frequent audio dropouts while vsync is enabled.
-# Conversely, increase this slightly if you are experiencing good audio, 
-# but lots of dropped frames. Reasonable values for this is 32000 +/- 100 Hz.
-# audio_in_rate = 31980
-
 # When altering audio_in_rate on-the-fly, define by how much each time.
 # audio_rate_step = 0.25
 
@@ -132,8 +134,6 @@
 # Desired audio latency in milliseconds. Might not be honored if driver can't provide given latency.
 # audio_latency = 64
 
-# libsamplerate quality. Valid values are from 1 to 5. These values map to zero_order_hold, linear, sinc_fastest, sinc_medium and sinc_best respectively.
-# audio_src_quality =
 
 ### Input
 
@@ -275,6 +275,9 @@
 # Toggle between paused and non-paused state
 # input_pause_toggle = p
 
+# Frame advance when game is paused
+# input_frame_advance = k
+
 # Reset the emulated SNES.
 # input_reset = h
 
@@ -320,3 +323,10 @@
 # Block SRAM from being overwritten when loading save states.
 # Might potentially lead to buggy games.
 # block_sram_overwrite = false
+
+# When saving a savestate, save state index is automatically increased before
+# it is saved.
+# Also, when loading a ROM, the index will be set to the highest existing index.
+# There is no upper bound on the index.
+# savestate_auto_index = false
+

thread.c

@@ -0,0 +1,319 @@
+/*  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 "thread.h"
+#include <stdlib.h>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <pthread.h>
+#include <time.h>
+#endif
+
+#ifdef __MACH__
+#include <mach/clock.h>
+#include <mach/mach.h>
+#endif
+
+struct thread_data
+{
+   void (*func)(void*);
+   void *userdata;
+};
+
+#ifdef _WIN32
+
+struct sthread
+{
+   HANDLE thread;
+};
+
+static DWORD CALLBACK thread_wrap(void *data_)
+{
+   struct thread_data *data = data_;
+   data->func(data->userdata);
+   free(data);
+   return 0;
+}
+
+sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
+{
+   sthread_t *thread = calloc(1, sizeof(*thread));
+   if (!thread)
+      return NULL;
+
+   struct thread_data *data = calloc(1, sizeof(*data));
+   if (!data)
+   {
+      free(thread);
+      return NULL;
+   }
+
+   data->func = thread_func;
+   data->userdata = userdata;
+
+   thread->thread = CreateThread(NULL, 0, thread_wrap, data, 0, NULL);
+   if (!thread->thread)
+   {
+      free(data);
+      free(thread);
+      return NULL;
+   }
+
+   return thread;
+}
+
+void sthread_join(sthread_t *thread)
+{
+   WaitForSingleObject(thread->thread, INFINITE);
+   CloseHandle(thread->thread);
+   free(thread);
+}
+
+struct slock
+{
+   CRITICAL_SECTION lock;
+};
+
+slock_t *slock_new(void)
+{
+   slock_t *lock = calloc(1, sizeof(*lock));
+   if (!lock)
+      return NULL;
+
+   InitializeCriticalSection(&lock->lock);
+   return lock;
+}
+
+void slock_free(slock_t *lock)
+{
+   DeleteCriticalSection(&lock->lock);
+   free(lock);
+}
+
+void slock_lock(slock_t *lock)
+{
+   EnterCriticalSection(&lock->lock);
+}
+
+void slock_unlock(slock_t *lock)
+{
+   LeaveCriticalSection(&lock->lock);
+}
+
+struct scond
+{
+   HANDLE event;
+};
+
+scond_t *scond_new(void)
+{
+   scond_t *cond = calloc(1, sizeof(*cond));
+   if (!cond)
+      return NULL;
+
+   cond->event = CreateEvent(NULL, FALSE, FALSE, NULL);
+   if (!cond->event)
+   {
+      free(cond);
+      return NULL;
+   }
+
+   return cond;
+}
+
+void scond_wait(scond_t *cond, slock_t *lock)
+{
+   WaitForSingleObject(cond->event, 0);
+   slock_unlock(lock);
+
+   WaitForSingleObject(cond->event, INFINITE);
+
+   slock_lock(lock);
+}
+
+bool scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms)
+{
+   WaitForSingleObject(cond->event, 0);
+   slock_unlock(lock);
+
+   DWORD res = WaitForSingleObject(cond->event, timeout_ms);
+
+   slock_lock(lock);
+   return res == WAIT_OBJECT_0;
+}
+
+void scond_signal(scond_t *cond)
+{
+   SetEvent(cond->event);
+}
+
+void scond_free(scond_t *cond)
+{
+   CloseHandle(cond->event);
+   free(cond);
+}
+
+#else
+
+struct sthread
+{
+   pthread_t id;
+};
+
+static void *thread_wrap(void *data_)
+{
+   struct thread_data *data = data_;
+   data->func(data->userdata);
+   free(data);
+   pthread_exit(NULL);
+}
+
+sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
+{
+   sthread_t *thr = calloc(1, sizeof(*thr));
+   if (!thr)
+      return NULL;
+
+   struct thread_data *data = calloc(1, sizeof(*data));
+   if (!data)
+   {
+      free(thr);
+      return NULL;
+   }
+
+   data->func = thread_func;
+   data->userdata = userdata;
+
+   if (pthread_create(&thr->id, NULL, thread_wrap, data) < 0)
+   {
+      free(data);
+      free(thr);
+      return NULL;
+   }
+
+   return thr;
+}
+
+void sthread_join(sthread_t *thread)
+{
+   pthread_join(thread->id, NULL);
+   free(thread);
+}
+
+struct slock
+{
+   pthread_mutex_t lock;
+};
+
+slock_t *slock_new(void)
+{
+   slock_t *lock = calloc(1, sizeof(*lock));
+   if (!lock)
+      return NULL;
+
+   if (pthread_mutex_init(&lock->lock, NULL) < 0)
+   {
+      free(lock);
+      return NULL;
+   }
+
+   return lock;
+}
+
+void slock_free(slock_t *lock)
+{
+   pthread_mutex_destroy(&lock->lock);
+   free(lock);
+}
+
+void slock_lock(slock_t *lock)
+{
+   pthread_mutex_lock(&lock->lock);
+}
+
+void slock_unlock(slock_t *lock)
+{
+   pthread_mutex_unlock(&lock->lock);
+}
+
+struct scond
+{
+   pthread_cond_t cond;
+};
+
+scond_t *scond_new(void)
+{
+   scond_t *cond = calloc(1, sizeof(*cond));
+   if (!cond)
+      return NULL;
+
+   if (pthread_cond_init(&cond->cond, NULL) < 0)
+   {
+      free(cond);
+      return NULL;
+   }
+
+   return cond;
+}
+
+void scond_free(scond_t *cond)
+{
+   pthread_cond_destroy(&cond->cond);
+   free(cond);
+}
+
+void scond_wait(scond_t *cond, slock_t *lock)
+{
+   pthread_cond_wait(&cond->cond, &lock->lock);
+}
+
+bool scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms)
+{
+   struct timespec now;
+
+#ifdef __MACH__ // OSX doesn't have clock_gettime ... :(
+   clock_serv_t cclock;
+   mach_timespec_t mts;
+   host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+   clock_get_time(cclock, &mts);
+   mach_port_deallocate(mach_task_self(), cclock);
+   now.tv_sec = mts.tv_sec;
+   now.tv_nsec = mts.tv_nsec;
+#else
+   clock_gettime(CLOCK_REALTIME, &now);
+#endif
+
+   now.tv_sec += timeout_ms / 1000;
+   now.tv_nsec += timeout_ms * 1000000L;
+
+   now.tv_sec += now.tv_nsec / 1000000000L;
+   now.tv_nsec = now.tv_nsec % 1000000000L;
+
+   int ret = pthread_cond_timedwait(&cond->cond, &lock->lock, &now);
+   return ret == 0;
+}
+
+void scond_signal(scond_t *cond)
+{
+   pthread_cond_signal(&cond->cond);
+}
+
+#endif
+

thread.h

@@ -0,0 +1,52 @@
+/*  SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
+ *  Copyright (C) 2010-2011 - Hans-Kristian Arntzen
+ *
+ *  Some code herein may be based on code found in BSNES.
+ * 
+ *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  SSNES is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with SSNES.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef THREAD_H__
+#define THREAD_H__
+
+#include <stdbool.h>
+
+// Implements the bare minimum needed for SSNES. :)
+
+typedef struct sthread sthread_t;
+
+// Threading
+sthread_t *sthread_create(void (*thread_func)(void*), void *userdata);
+void sthread_join(sthread_t *thread);
+
+// Mutexes
+typedef struct slock slock_t;
+
+slock_t *slock_new(void);
+void slock_free(slock_t *lock);
+
+void slock_lock(slock_t *lock);
+void slock_unlock(slock_t *lock);
+
+// Condition variables.
+typedef struct scond scond_t;
+
+scond_t *scond_new(void);
+void scond_free(scond_t *cond);
+
+void scond_wait(scond_t *cond, slock_t *lock);
+bool scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms);
+void scond_signal(scond_t *cond);
+
+
+#endif
+

tools/ssnes-joyconfig.c

@@ -92,6 +92,7 @@ static struct bind binds[] = {
    MISC_BIND("Rewind", rewind)
    MISC_BIND("Movie recording toggle", movie_record_toggle)
    MISC_BIND("Pause", pause_toggle)
+   MISC_BIND("Frame advance", frame_advance)
    MISC_BIND("Reset", reset)
    MISC_BIND("Next shader", shader_next)
    MISC_BIND("Previous shader", shader_prev)
@@ -235,7 +236,7 @@ static void parse_input(int argc, char *argv[])
    };
 
    int option_index = 0;
-   for(;;)
+   for (;;)
    {
       int c = getopt_long(argc, argv, optstring, opts, &option_index);
       if (c == -1)