Fix ugly possible segfault.

Fix issue where long type was enforced for return values of uniforms.

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,7 +86,7 @@ ifeq ($(HAVE_COREAUDIO), 1)
 endif
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
+   OBJ += gfx/sdl.o gfx/gl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
    DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
    LIBS += $(SDL_LIBS)
 ifeq ($(OSX),1)
@@ -101,8 +98,8 @@ 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,11 +108,17 @@ 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 += gfx/shader_glsl.o sha256.o cheats.o 
    LIBS += $(XML_LIBS)
    DEFINES += $(XML_CFLAGS)
 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)
    OBJ += gfx/ext.o audio/ext.o
    LIBS += $(DYLIB_LIB)
@@ -158,9 +161,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
@@ -12,6 +12,7 @@ HAVE_DSOUND = 1
 HAVE_SDL = 1
 HAVE_DYLIB = 1
 HAVE_NETPLAY = 1
+DYNAMIC = 1
 
 ifeq ($(SLIM),)
    HAVE_SDL_IMAGE = 1
@@ -32,7 +33,7 @@ LDFLAGS = -L. -static-libgcc -s
 LDCXXFLAGS = -static-libstdc++
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
+   OBJ += gfx/sdl.o gfx/gl.o gfx/sdlwrap.o input/sdl.o audio/sdl.o fifo_buffer.o
    LIBS += -lSDL -lopengl32
    DEFINES += -ISDL -DHAVE_SDL
 endif
@@ -117,6 +118,11 @@ 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_X264RGB
    OBJ += record/ffemu.o
 endif
 
@@ -160,17 +166,21 @@ clean:
 	rm -f tools/*.o
 
 dist_x86: all
-	zip -r ssnes-win32-0.8.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+	zip -r ssnes-win32-0.9.1.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
 
 dist_x86_64: all
-	zip -r ssnes-win64-0.8.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
+	zip -r ssnes-win64-0.9.1.zip $(TARGET) $(JTARGET) ssnes.cfg snes.dll SDL.dll
 
 libs_x86:
 	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-libs.zip --no-check-certificate
 	unzip SSNES-win32-libs.zip
+	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.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; \
                }
 
@@ -52,14 +52,14 @@ static bool find_float_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 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;
@@ -178,9 +178,9 @@ static bool __alsa_start(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);
@@ -200,8 +200,3 @@ const audio_driver_t audio_alsa = {
    .ident = "alsa"
 };
 
-   
-
-
-   
-   

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,21 +46,17 @@ 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;
 }
 
 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;
 
@@ -75,7 +70,7 @@ void hermite_process(hermite_resampler_t *re, struct hermite_data *data)
       while (re->r_frac <= 1.0 && processed_out < out_frames)
       {
          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]);
@@ -88,7 +83,7 @@ void hermite_process(hermite_resampler_t *re, struct hermite_data *data)
       {
          re->r_frac -= 1.0;
 
-         for (unsigned i = 0; i < re->chans; i++)
+         for (unsigned i = 0; i < CHANNELS; i++)
          {
             re->chan_data[i][0] = re->chan_data[i][1];
             re->chan_data[i][1] = re->chan_data[i][2];

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
 {
@@ -39,8 +39,7 @@ struct hermite_data
    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/openal.c

@@ -60,7 +60,7 @@ 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;
@@ -221,7 +221,7 @@ static void __al_free(void *data)
    {
       alSourceStop(al->source);
       alDeleteSources(1, &al->source);
-      if ( al->buffers )
+      if (al->buffers)
       {
          alDeleteBuffers(al->num_buffers, al->buffers);
          free(al->buffers);
@@ -244,4 +244,3 @@ const audio_driver_t audio_openal = {
    .ident = "openal"
 };
 
-   

audio/rsound.c

@@ -57,12 +57,12 @@ static void err_cb(void *userdata)
 static void* __rsd_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);
@@ -161,7 +161,7 @@ static void __rsd_set_nonblock_state(void *data, bool state)
 static bool __rsd_start(void *data)
 {
    rsd_t *rsd = data;
-   if ( rsd_start(rsd->rd) < 0)
+   if (rsd_start(rsd->rd) < 0)
       return false;
 
    return true;

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
+

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

cheats.c

@@ -21,6 +21,14 @@
 #include "general.h"
 #include "strl.h"
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_CONFIGFILE
+#include "conf/config_file.h"
+#endif
+
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
@@ -131,8 +139,105 @@ static bool xml_grab_cheats(cheat_manager_t *handle, xmlNodePtr ptr)
    return true;
 }
 
+static void cheat_manager_apply_cheats(cheat_manager_t *handle)
+{
+   unsigned index = 0;
+   psnes_cheat_reset();
+   for (unsigned i = 0; i < handle->size; i++)
+   {
+      if (handle->cheats[i].state)
+         psnes_cheat_set(index++, true, handle->cheats[i].code);
+   }
+}
+
+static void cheat_manager_load_config(cheat_manager_t *handle, const char *path, const char *sha256)
+{
+#ifdef HAVE_CONFIGFILE
+   if (!(*path))
+      return;
+
+   config_file_t *conf = config_file_new(path);
+   if (!conf)
+      return;
+
+   char *str;
+   if (!config_get_string(conf, sha256, &str))
+   {
+      config_file_free(conf);
+      return;
+   }
+
+   const char *num = strtok(str, ";");
+   while (num)
+   {
+      unsigned index = strtoul(num, NULL, 0);
+      if (index < handle->size)
+         handle->cheats[index].state = true;
+
+      num = strtok(NULL, ";");
+   }
+
+   free(str);
+   config_file_free(conf);
+
+   cheat_manager_apply_cheats(handle);
+
+#else
+   (void)handle;
+   (void)path;
+   (void)sha256;
+#endif
+}
+
+static void cheat_manager_save_config(cheat_manager_t *handle, const char *path, const char *sha256)
+{
+#ifdef HAVE_CONFIGFILE
+   if (!(*path))
+      return;
+
+   config_file_t *conf = config_file_new(path);
+   if (!conf)
+      conf = config_file_new(NULL);
+
+   if (!conf)
+   {
+      SSNES_ERR("Cannot save XML cheat settings!\n");
+      return;
+   }
+
+   char conf_str[512] = {0};
+   char tmp[32] = {0};
+
+   for (unsigned i = 0; i < handle->size; i++)
+   {
+      if (handle->cheats[i].state)
+      {
+         snprintf(tmp, sizeof(tmp), "%u;", i);
+         strlcat(conf_str, tmp, sizeof(conf_str));
+      }
+   }
+
+   if (*conf_str)
+      conf_str[strlen(conf_str) - 1] = '\0'; // Remove the trailing ';'
+
+   config_set_string(conf, sha256, conf_str);
+
+   if (!config_file_write(conf, path))
+      SSNES_ERR("Failed to write XML cheat settings to \"%s\"! Check permissions!\n", path);
+
+   config_file_free(conf);
+
+#else
+   (void)handle;
+   (void)path;
+   (void)sha256;
+#endif
+}
+
 cheat_manager_t* cheat_manager_new(const char *path)
 {
+   LIBXML_TEST_VERSION;
+
    psnes_cheat_reset();
 
    xmlParserCtxtPtr ctx = NULL;
@@ -188,7 +293,7 @@ cheat_manager_t* cheat_manager_new(const char *path)
          if (!sha256)
             continue;
 
-         if (memcmp(sha256, g_extern.sha256, 64) == 0)
+         if (strcmp((const char*)sha256, g_extern.sha256) == 0)
          {
             xmlFree(sha256);
             break;
@@ -213,6 +318,8 @@ cheat_manager_t* cheat_manager_new(const char *path)
       goto error;
    }
 
+   cheat_manager_load_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
+
    xmlFreeDoc(doc);
    xmlFreeParserCtxt(ctx);
    return handle;
@@ -233,6 +340,7 @@ void cheat_manager_free(cheat_manager_t *handle)
 
    if (handle->cheats)
    {
+      cheat_manager_save_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
       for (unsigned i = 0; i < handle->size; i++)
       {
          xmlFree(handle->cheats[i].desc);
@@ -254,18 +362,11 @@ static void cheat_manager_update(cheat_manager_t *handle)
    SSNES_LOG("%s\n", msg);
 }
 
+
 void cheat_manager_toggle(cheat_manager_t *handle)
 {
    handle->cheats[handle->ptr].state ^= true;
-
-   unsigned index = 0;
-   psnes_cheat_reset();
-   for (unsigned i = 0; i < handle->size; i++)
-   {
-      if (handle->cheats[handle->ptr].state)
-         psnes_cheat_set(index++, true, handle->cheats[handle->ptr].code);
-   }
-
+   cheat_manager_apply_cheats(handle);
    cheat_manager_update(handle);
 }
 

conf/config_file.c

@@ -21,20 +21,52 @@
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
+#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);
@@ -57,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++;
@@ -85,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))
    {
@@ -153,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)
       {
@@ -212,12 +415,19 @@ bool config_get_int(config_file_t *conf, const char *key, int *in)
 {
    struct entry_list *list = conf->entries;
 
-   while (list != NULL)
+   while (list)
    {
       if (strcmp(key, list->key) == 0)
       {
-         *in = strtol(list->value, NULL, 0);
-         return true;
+         errno = 0;
+         int val = strtol(list->value, NULL, 0);
+         if (errno == 0)
+         {
+            *in = val;
+            return true;
+         }
+         return
+            false;
       }
       list = list->next;
    }
@@ -228,12 +438,19 @@ 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)
       {
-         *in = strtol(list->value, NULL, 16);
-         return true;
+         errno = 0;
+         unsigned val = strtoul(list->value, NULL, 16);
+         if (errno == 0)
+         {
+            *in = val;
+            return true;
+         }
+         else
+            return false;
       }
       list = list->next;
    }
@@ -244,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)
       {
@@ -262,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)
       {
@@ -278,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)
       {
@@ -294,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)
       {
@@ -320,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;
    }
@@ -391,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

@@ -30,16 +30,7 @@
 #include "config.h"
 #endif
 
-#ifdef HAVE_SDL
-#include "SDL.h"
-#else
-#error "HAVE_SDL is not defined!"
-#endif
-
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#endif
-
+#include "input/keysym.h"
 
 ///////////////// Drivers
 #define VIDEO_GL 0
@@ -118,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
@@ -150,6 +141,8 @@ static const unsigned font_size = 48;
 // Offset for where messages will be placed on-screen. Values are in range [0.0, 1.0].
 static const float message_pos_offset_x = 0.05;
 static const float message_pos_offset_y = 0.05;
+// Color of the message.
+static const uint32_t message_color = 0xffff00; // RGB hex value.
 
 // Render-to-texture before rendering to screen (multi-pass shaders)
 static const bool render_to_texture = false;
@@ -163,8 +156,6 @@ 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)
-
 ////////////////
 // Audio
 ////////////////
@@ -191,11 +182,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;
@@ -215,6 +201,14 @@ static const unsigned autosave_interval = 0;
 // When being client over netplay, use keybinds for player 1 rather than player 2.
 static const bool netplay_client_swap_input = true;
 
+// On save state load, block SRAM from being overwritten.
+// This could potentially lead to buggy games.
+static const bool block_sram_overwrite = false;
+
+// When saving savestates, state index is automatically incremented before saving.
+// When the ROM is loaded, state index will be set to the highest existing value.
+static const bool savestate_auto_index = false;
+
 
 ////////////////////
 // Keybinds, Joypad
@@ -222,64 +216,65 @@ static const bool netplay_client_swap_input = true;
 
 // Axis threshold (between 0.0 and 1.0)
 // How far an axis must be tilted to result in a button press
-#define AXIS_THRESHOLD 0.5
+static const float axis_threshold = 0.5;
 
 // To figure out which joypad buttons to use, check jstest or similar.
 // SDL sometimes reverses the axes for some odd reason, but hey. :D
 
 // Player 1
 static const struct snes_keybind snes_keybinds_1[] = {
-   // SNES button                 |   keyboard key   | js btn | js axis |
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_x,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_z,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_s,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_a,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_q,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_w,      NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_LEFT,   NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_RIGHT,  NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_UP,     NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_DOWN,   NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_RETURN, NO_BTN,      AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_RSHIFT, NO_BTN,      AXIS_NONE },
-   { SSNES_FAST_FORWARD_KEY,           SDLK_SPACE,  NO_BTN,      AXIS_NONE },
-   { SSNES_FAST_FORWARD_HOLD_KEY,      SDLK_l,      NO_BTN,      AXIS_NONE },
-   { SSNES_SAVE_STATE_KEY,             SDLK_F2,     NO_BTN,      AXIS_NONE },
-   { SSNES_LOAD_STATE_KEY,             SDLK_F4,     NO_BTN,      AXIS_NONE },
-   { SSNES_FULLSCREEN_TOGGLE_KEY,      SDLK_f,      NO_BTN,      AXIS_NONE },
-   { SSNES_QUIT_KEY,                   SDLK_ESCAPE, NO_BTN,      AXIS_NONE },
-   { SSNES_STATE_SLOT_MINUS,           SDLK_F6,     NO_BTN,      AXIS_NONE },
-   { SSNES_STATE_SLOT_PLUS,            SDLK_F7,     NO_BTN,      AXIS_NONE },
-   { SSNES_AUDIO_INPUT_RATE_PLUS,      SDLK_KP_PLUS, NO_BTN,     AXIS_NONE },
-   { SSNES_AUDIO_INPUT_RATE_MINUS,     SDLK_KP_MINUS, NO_BTN,    AXIS_NONE },
-   { SSNES_REWIND,                     SDLK_r,      NO_BTN,      AXIS_NONE },
-   { SSNES_MOVIE_RECORD_TOGGLE,        SDLK_o,      NO_BTN,      AXIS_NONE },
-   { SSNES_PAUSE_TOGGLE,               SDLK_p,      NO_BTN,      AXIS_NONE },
-   { SSNES_RESET,                      SDLK_h,      NO_BTN,      AXIS_NONE },
-   { SSNES_SHADER_NEXT,                SDLK_m,      NO_BTN,      AXIS_NONE },
-   { SSNES_SHADER_PREV,                SDLK_n,      NO_BTN,      AXIS_NONE },
-   { SSNES_CHEAT_INDEX_PLUS,           SDLK_y,      NO_BTN,      AXIS_NONE },
-   { SSNES_CHEAT_INDEX_MINUS,          SDLK_t,      NO_BTN,      AXIS_NONE },
-   { SSNES_CHEAT_TOGGLE,               SDLK_u,      NO_BTN,      AXIS_NONE },
-   { SSNES_SCREENSHOT,                 SDLK_PRINT,  NO_BTN,      AXIS_NONE },
-   { SSNES_DSP_CONFIG,                 SDLK_c,      NO_BTN,      AXIS_NONE },
+   // SNES button               | keyboard key | js btn | js axis |
+   { SNES_DEVICE_ID_JOYPAD_A,          SK_x,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_B,          SK_z,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_X,          SK_s,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_Y,          SK_a,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_L,          SK_q,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_R,          SK_w,      NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_LEFT,       SK_LEFT,   NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SK_RIGHT,  NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_UP,         SK_UP,     NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_DOWN,       SK_DOWN,   NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_START,      SK_RETURN, NO_BTN,      AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_SELECT,     SK_RSHIFT, NO_BTN,      AXIS_NONE },
+   { SSNES_FAST_FORWARD_KEY,           SK_SPACE,  NO_BTN,      AXIS_NONE },
+   { SSNES_FAST_FORWARD_HOLD_KEY,      SK_l,      NO_BTN,      AXIS_NONE },
+   { SSNES_SAVE_STATE_KEY,             SK_F2,     NO_BTN,      AXIS_NONE },
+   { SSNES_LOAD_STATE_KEY,             SK_F4,     NO_BTN,      AXIS_NONE },
+   { SSNES_FULLSCREEN_TOGGLE_KEY,      SK_f,      NO_BTN,      AXIS_NONE },
+   { SSNES_QUIT_KEY,                   SK_ESCAPE, NO_BTN,      AXIS_NONE },
+   { SSNES_STATE_SLOT_MINUS,           SK_F6,     NO_BTN,      AXIS_NONE },
+   { SSNES_STATE_SLOT_PLUS,            SK_F7,     NO_BTN,      AXIS_NONE },
+   { SSNES_AUDIO_INPUT_RATE_PLUS,      SK_KP_PLUS, NO_BTN,     AXIS_NONE },
+   { SSNES_AUDIO_INPUT_RATE_MINUS,     SK_KP_MINUS, NO_BTN,    AXIS_NONE },
+   { SSNES_REWIND,                     SK_r,      NO_BTN,      AXIS_NONE },
+   { SSNES_MOVIE_RECORD_TOGGLE,        SK_o,      NO_BTN,      AXIS_NONE },
+   { SSNES_PAUSE_TOGGLE,               SK_p,      NO_BTN,      AXIS_NONE },
+   { SSNES_FRAMEADVANCE,               SK_k,      NO_BTN,      AXIS_NONE },
+   { SSNES_RESET,                      SK_h,      NO_BTN,      AXIS_NONE },
+   { SSNES_SHADER_NEXT,                SK_m,      NO_BTN,      AXIS_NONE },
+   { SSNES_SHADER_PREV,                SK_n,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_INDEX_PLUS,           SK_y,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_INDEX_MINUS,          SK_t,      NO_BTN,      AXIS_NONE },
+   { SSNES_CHEAT_TOGGLE,               SK_u,      NO_BTN,      AXIS_NONE },
+   { SSNES_SCREENSHOT,                 SK_PRINT,  NO_BTN,      AXIS_NONE },
+   { SSNES_DSP_CONFIG,                 SK_c,      NO_BTN,      AXIS_NONE },
    { -1 }
 };
 
 // Player 2-5
 static const struct snes_keybind snes_keybinds_rest[] = {
-   { SNES_DEVICE_ID_JOYPAD_A,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_B,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_X,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_Y,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_L,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_R,          SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_LEFT,       SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_UP,         SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_DOWN,       SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_START,      SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
-   { SNES_DEVICE_ID_JOYPAD_SELECT,     SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_A,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_B,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_X,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_Y,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_L,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_R,          SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_LEFT,       SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_RIGHT,      SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_UP,         SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_DOWN,       SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_START,      SK_UNKNOWN, NO_BTN, AXIS_NONE },
+   { SNES_DEVICE_ID_JOYPAD_SELECT,     SK_UNKNOWN, NO_BTN, AXIS_NONE },
    { -1 }
 };
 

config.features.h

@@ -110,10 +110,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" "October 2011" "SSNES" "System Manager's Manual: ssnes"
 
 .SH NAME
 
@@ -27,6 +27,9 @@ If no rom file path is defined on the command line, \fBssnes\fR will try to load
 \fB--help, -h\fR
 Prints help text.
 
+\fB--features\fR
+Prints available features compiled into SSNES, then exits.
+
 .TP
 \fB--save PATH, -s PATH\fR
 Overrides the path used for save ram (*.srm).
@@ -115,6 +118,11 @@ 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.

driver.c

@@ -91,7 +91,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 +101,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 +109,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 +127,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)
       {
@@ -237,7 +237,7 @@ void init_audio(void)
    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 )
+   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))
@@ -251,26 +251,28 @@ void init_audio(void)
    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);
+   max_bufsamples *= 2; // Accomodate rewind since at some point we might have two full buffers.
+
    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)));
 
+   // 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;
+
+   g_extern.audio_data.src_ratio =
+      (double)g_settings.audio.out_rate / g_settings.audio.in_rate;
+
    init_dsp_plugin();
 }
 
@@ -282,21 +284,16 @@ void uninit_audio(void)
       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.rewind_buf); g_extern.audio_data.rewind_buf = NULL;
 
    deinit_dsp_plugin();
 }
@@ -333,17 +330,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));
@@ -399,6 +396,9 @@ static void deinit_shader_dir(void)
 {
    // It handles NULL, no worries :D
    dir_list_free(g_extern.shader_dir.elems);
+   g_extern.shader_dir.elems = NULL;
+   g_extern.shader_dir.size = 0;
+   g_extern.shader_dir.ptr = 0;
 }
 #endif
 
@@ -412,8 +412,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();
@@ -430,18 +431,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,
@@ -456,7 +465,7 @@ void init_video_input(void)
    const input_driver_t *tmp = driver.input;
    driver.video_data = driver.video->init(&video, &driver.input, &driver.input_data);
 
-   if ( driver.video_data == NULL )
+   if (driver.video_data == NULL)
    {
       SSNES_ERR("Cannot open video driver ... Exiting ...\n");
       exit(1);
@@ -469,7 +478,7 @@ void init_video_input(void)
       if (driver.input != NULL)
       {
          driver.input_data = driver.input->init();
-         if ( driver.input_data == NULL )
+         if (driver.input_data == NULL)
          {
             SSNES_ERR("Cannot init input driver. Exiting ...\n");
             exit(1);
@@ -485,10 +494,10 @@ void init_video_input(void)
 
 void uninit_video_input(void)
 {
-   if ( driver.input_data != driver.video_data && driver.input )
+   if (driver.input_data != driver.video_data && driver.input)
       driver.input->free(driver.input_data);
 
-   if ( driver.video_data && driver.video )
+   if (driver.video_data && driver.video)
       driver.video->free(driver.video_data);
 
    deinit_filter();

driver.h

@@ -24,10 +24,13 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <unistd.h>
+#include "input/keysym.h"
 
+// SNES has 12 buttons from 0-11 (libsnes.hpp)
+#define SSNES_FIRST_META_KEY 12
 enum
 {
-   SSNES_FAST_FORWARD_KEY = 0x666, // Hurr, durr
+   SSNES_FAST_FORWARD_KEY = SSNES_FIRST_META_KEY,
    SSNES_FAST_FORWARD_HOLD_KEY,
    SSNES_LOAD_STATE_KEY,
    SSNES_SAVE_STATE_KEY,
@@ -40,6 +43,7 @@ enum
    SSNES_REWIND,
    SSNES_MOVIE_RECORD_TOGGLE,
    SSNES_PAUSE_TOGGLE,
+   SSNES_FRAMEADVANCE,
    SSNES_RESET,
    SSNES_SHADER_NEXT,
    SSNES_SHADER_PREV,
@@ -47,14 +51,16 @@ enum
    SSNES_CHEAT_INDEX_MINUS,
    SSNES_CHEAT_TOGGLE,
    SSNES_SCREENSHOT,
-   SSNES_DSP_CONFIG
+   SSNES_DSP_CONFIG,
+
+   SSNES_BIND_LIST_END
 };
 
 
 struct snes_keybind
 {
    int id;
-   uint16_t key;
+   enum ssnes_key key;
    uint16_t joykey;
    uint32_t joyaxis;
 };

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
+   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.
-   void *ptr_sym = dlsym(lib, proc); 
    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,68 @@ 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;
+
+      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
+
+

fifo_buffer.c

@@ -42,18 +42,12 @@ fifo_buffer_t* fifo_new(size_t size)
 
 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)
 {
-   assert(buffer);
-   assert(buffer->buffer);
-
    size_t first = buffer->first;
    size_t end = buffer->end;
    if (end < first)
@@ -63,9 +57,6 @@ size_t fifo_read_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)
@@ -76,11 +67,6 @@ size_t fifo_write_avail(fifo_buffer_t* buffer)
 
 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)
@@ -99,11 +85,6 @@ 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)
 {
-   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)

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;
@@ -425,7 +425,74 @@ bool load_state(const char *path)
    else
    {
       SSNES_LOG("State size: %d bytes.\n", (int)size);
+
+      uint8_t *block_buf[2] = {NULL, NULL};
+      int block_type[2] = {-1, -1};
+      unsigned block_size[2] = {0};
+
+      if (g_settings.block_sram_overwrite)
+      {
+         SSNES_LOG("Blocking SRAM overwrite!\n");
+         switch (g_extern.game_type)
+         {
+            case SSNES_CART_NORMAL:
+               block_type[0] = SNES_MEMORY_CARTRIDGE_RAM;
+               block_type[1] = SNES_MEMORY_CARTRIDGE_RTC;
+               break;
+
+            case SSNES_CART_BSX:
+            case SSNES_CART_BSX_SLOTTED:
+               block_type[0] = SNES_MEMORY_BSX_RAM;
+               block_type[1] = SNES_MEMORY_BSX_PRAM;
+               break;
+
+            case SSNES_CART_SUFAMI:
+               block_type[0] = SNES_MEMORY_SUFAMI_TURBO_A_RAM;
+               block_type[1] = SNES_MEMORY_SUFAMI_TURBO_B_RAM;
+               break;
+
+            case SSNES_CART_SGB:
+               block_type[0] = SNES_MEMORY_GAME_BOY_RAM;
+               block_type[1] = SNES_MEMORY_GAME_BOY_RTC;
+               break;
+         }
+      }
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_type[i] != -1)
+            block_size[i] = psnes_get_memory_size(block_type[i]);
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_size[i])
+            block_buf[i] = malloc(block_size[i]);
+
+      // Backup current SRAM which is overwritten by unserialize.
+      for (unsigned i = 0; i < 2; i++)
+      {
+         if (block_buf[i])
+         {
+            const uint8_t *ptr = psnes_get_memory_data(block_type[i]);
+            if (ptr)
+               memcpy(block_buf[i], ptr, block_size[i]);
+         }
+      }
+
       psnes_unserialize(buf, size);
+
+      // Flush back :D
+      for (unsigned i = 0; i < 2; i++)
+      {
+         if (block_buf[i])
+         {
+            uint8_t *ptr = psnes_get_memory_data(block_type[i]);
+            if (ptr)
+               memcpy(ptr, block_buf[i], block_size[i]);
+         }
+      }
+
+      for (unsigned i = 0; i < 2; i++)
+         if (block_buf[i])
+            free(block_buf[i]);
    }
 
    free(buf);
@@ -443,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);
 }
@@ -751,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;
@@ -783,7 +854,7 @@ char** dir_list_new(const char *dir, const char *ext)
 #ifdef _WIN32
       if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
          continue;
-      if (WideCharToMultiByte(CP_UTF8, 0, ffd.cFileName, -1, utf8_buf, MAX_PATH, NULL, NULL) == 0)
+      if (WideCharToMultiByte(CP_UTF8, 0, ffd.cFileName, -1, utf8_buf, MAXPATHLEN, NULL, NULL) == 0)
          continue;
       if (ext && !strstr(utf8_buf, ext))
          continue;
@@ -880,8 +951,8 @@ bool path_file_exists(const char *path)
 
 void fill_pathname(char *out_path, const char *in_path, const char *replace, size_t size)
 {
-   char tmp_path[strlen(in_path) + 1];
-   strlcpy(tmp_path, in_path, sizeof(tmp_path));
+   char tmp_path[MAXPATHLEN];
+   assert(strlcpy(tmp_path, in_path, sizeof(tmp_path)) < sizeof(tmp_path));
    char *tok = strrchr(tmp_path, '.');
    if (tok != NULL)
       *tok = '\0';

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,6 +39,8 @@ 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.
+// 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);
 

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
@@ -55,7 +55,7 @@
 #endif
 
 #define MAX_PLAYERS 5
-#define MAX_BINDS 34 // Needs to be increased every time there are new binds added.
+#define MAX_BINDS (SSNES_BIND_LIST_END + 1)
 #define SSNES_NO_JOYPAD 0xFFFF
 
 enum ssnes_shader_type
@@ -98,6 +98,9 @@ struct settings
       unsigned font_size;
       float msg_pos_x;
       float msg_pos_y;
+      float msg_color_r;
+      float msg_color_g;
+      float msg_color_b;
 
       bool force_16bit;
       bool disable_composition;
@@ -118,7 +121,6 @@ struct settings
       char device[MAXPATHLEN];
       unsigned latency;
       bool sync;
-      int src_quality;
 
       char dsp_plugin[MAXPATHLEN];
       char external_driver[MAXPATHLEN];
@@ -135,6 +137,7 @@ struct settings
 
    char libsnes[MAXPATHLEN];
    char cheat_database[MAXPATHLEN];
+   char cheat_settings_path[MAXPATHLEN];
 
    char screenshot_directory[MAXPATHLEN];
 
@@ -144,6 +147,9 @@ struct settings
 
    bool pause_nonactive;
    unsigned autosave_interval;
+
+   bool block_sram_overwrite;
+   bool savestate_auto_index;
 };
 
 enum ssnes_game_type
@@ -203,11 +209,14 @@ 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];
+   } system;
+
+   struct
+   {
       hermite_resampler_t *source;
-#endif
 
       float *data;
       size_t data_ptr;
@@ -215,11 +224,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;
@@ -254,6 +269,7 @@ struct global
 
    // Pausing support
    bool is_paused;
+   bool is_oneshot;
 
    // Autosave support.
    autosave_t *autosave[2];
@@ -271,8 +287,17 @@ 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
@@ -284,8 +309,6 @@ struct global
 
    char sha256[64 + 1];
 
-   bool do_screenshot;
-
 #ifdef HAVE_XML
    cheat_manager_t *cheat;
 #endif
@@ -300,17 +323,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)
 {
@@ -336,6 +369,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

@@ -24,6 +24,12 @@
 #include <stdint.h>
 #include "dynamic.h"
 #include "general.h"
+#include "sdlwrap.h"
+#include "gfx_common.h"
+
+#ifdef HAVE_FREETYPE
+#include "fonts.h"
+#endif
 
 static bool g_input_dead = true;
 static bool g_video_dead = true;
@@ -37,7 +43,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));
@@ -193,7 +199,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++)
@@ -232,6 +238,27 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
    else if ((type == SSNES_SHADER_BSNES || type == SSNES_SHADER_AUTO) && *g_settings.video.bsnes_shader_path)
       xml_shader = g_settings.video.bsnes_shader_path;
 
+   int font_color_r = g_settings.video.msg_color_r * 255;
+   int font_color_g = g_settings.video.msg_color_g * 255;
+   int font_color_b = g_settings.video.msg_color_b * 255;
+   font_color_r = font_color_r > 255 ? 255 : (font_color_r < 0 ? 0 : font_color_r);
+   font_color_g = font_color_g > 255 ? 255 : (font_color_g < 0 ? 0 : font_color_g);
+   font_color_b = font_color_b > 255 ? 255 : (font_color_b < 0 ? 0 : font_color_b);
+
+   const char *font = NULL;
+#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,
@@ -245,8 +272,10 @@ 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_size = g_settings.video.font_size
+      .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,
    };
 
    const ssnes_input_driver_t *input_driver = NULL;
@@ -263,7 +292,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

@@ -108,7 +108,10 @@ typedef struct ssnes_video_info
    // Can be disregarded.
    const char *ttf_font;
    unsigned ttf_font_size;
+   unsigned ttf_font_color; // Font color, in format ARGB8888. Alpha should be disregarded.
 
+   // A title that should be displayed in the title bar of the window.
+   const char *title_hint;
 } ssnes_video_info_t;
 
 // Some convenience macros.
@@ -119,7 +122,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.
@@ -155,8 +158,9 @@ struct ssnes_keybind
    // last frame and current frame in the Y-axis.
    int analog_y;
 
-   // Keyboard key. The key values use the SDL keysyms, 
+   // Keyboard key. The key values use the SDL 1.2 keysyms, 
    // which probably need to be transformed to the native format.
+   // The actual keysyms SSNES uses are found in input/keysym.h.
    unsigned short key;
 
    // Joypad key. Joypad POV (hats) are embedded into this key as well.
@@ -235,7 +239,7 @@ typedef struct ssnes_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,33 @@ 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",
+#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);
@@ -112,23 +112,3 @@ void gfx_set_dwm(void)
 }
 #endif
 
-
-#include "SDL_syswm.h"
-#include "SDL.h"
-
-#if !defined(__APPLE__) && !defined(_WIN32)
-void gfx_get_window_size(unsigned *width, unsigned *height)
-{
-   SDL_SysWMinfo info;
-   SDL_VERSION(&info.version);
-   SDL_GetWMInfo(&info);
-   XWindowAttributes target;
-   info.info.x11.lock_func();
-   XGetWindowAttributes(info.info.x11.display, info.info.x11.window,
-         &target);
-   info.info.x11.unlock_func();
-
-   *width = target.width;
-   *height = target.height;
-}
-#endif

gfx/gfx_common.h

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

gfx/gl.c

@@ -33,6 +33,8 @@
 
 #include "gl_common.h"
 #include "gfx_common.h"
+#include "sdlwrap.h"
+#include "strl.h"
 
 #define NO_SDL_GLEXT
 #include "SDL.h"
@@ -171,6 +173,10 @@ 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;
 #endif
 
 } gl_t;
@@ -331,9 +337,13 @@ 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)
+   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);
@@ -347,6 +357,12 @@ 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");
+#else
+   (void)gl;
+   (void)font_path;
+   (void)font_size;
 #endif
 }
 
@@ -522,7 +538,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;
@@ -537,7 +553,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
 }
 ////////////
@@ -604,63 +625,192 @@ 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).
+   glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), font_tex_coords);
 
    // 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);
+   calculate_font_coords(gl, font_vertex, font_tex_coords);
+   
+   glDrawArrays(GL_QUADS, 0, 4);
 
    // Go back to old rendering path.
+   glColor4f(1, 1, 1, 1);
    glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->tex_coords);
    glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
    glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
+
    glDisable(GL_BLEND);
-#endif
 }
+#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)
 {
@@ -685,49 +835,21 @@ static inline void set_texture_coords(GLfloat *coords, GLfloat xamt, GLfloat yam
 
 static void check_window(gl_t *gl)
 {
-   SDL_Event event;
+   bool quit, resize;
 
-   // Search for events we care about ...
-   while (SDL_PollEvent(&event))
-   {
-      switch (event.type)
-      {
-         case SDL_QUIT:
-            gl->quitting = true;
-            break;
+   sdlwrap_check_window(&quit,
+         &resize, &gl->win_width, &gl->win_height,
+         gl->frame_count);
 
-         case SDL_VIDEORESIZE:
-            gl->should_resize = true;
-            gl->win_width = event.resize.w;
-            gl->win_height = event.resize.h;
-            break;
-
-         default:
-            break;
-      }
-   }
-
-#if !defined(__APPLE__) && !defined(_WIN32)
-   // Hack to workaround limitations in tiling WMs ...
-   if (!gl->should_resize && !gl->fullscreen)
-   {
-      unsigned new_width, new_height;
-      gfx_get_window_size(&new_width, &new_height);
-      if ((new_width != gl->win_width || new_height != gl->win_height) || (gl->frame_count == 10)) // Ugly hack :D
-      {
-         gl->should_resize = true;
-         gl->win_width = new_width;
-         gl->win_height = new_height;
-         SSNES_LOG("GL: Verified window size: %u x %u\n", gl->win_width, gl->win_height);
-      }
-   }
-#endif
+   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)
 {
    gl_t *gl = data;
-   check_window(gl);
 
    gl_shader_use(1);
    gl->frame_count++;
@@ -801,7 +923,8 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    if (gl->should_resize)
    {
       gl->should_resize = false;
-      SDL_SetVideoMode(gl->win_width, gl->win_height, 0, SDL_OPENGL | SDL_RESIZABLE | (g_settings.video.fullscreen ? SDL_FULLSCREEN : 0));
+
+      sdlwrap_set_resize(gl->win_width, gl->win_height);
 
 #ifdef HAVE_FBO
       if (!gl->render_to_tex)
@@ -873,7 +996,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 #endif
 
 #ifdef HAVE_FBO
-   // Need to preserve the "flipped" state when in FBO too to have 
+   // 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);
@@ -985,8 +1108,9 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 
    char buf[128];
    if (gfx_window_title(buf, sizeof(buf)))
-      SDL_WM_SetCaption(buf, NULL);
-   SDL_GL_SwapBuffers();
+      sdlwrap_wm_set_caption(buf);
+
+   sdlwrap_swap_buffers();
 
    return true;
 }
@@ -1008,7 +1132,7 @@ static void gl_free(void *data)
       pglDeleteFramebuffers(gl->fbo_pass, gl->fbo);
    }
 #endif
-   SDL_QuitSubSystem(SDL_INIT_VIDEO);
+   sdlwrap_destroy();
 
    if (gl->empty_buf)
       free(gl->empty_buf);
@@ -1016,38 +1140,13 @@ static void gl_free(void *data)
    free(gl);
 }
 
-#ifdef __APPLE__
-#include <OpenGL/OpenGL.h>
-#endif
-
 static void gl_set_nonblock_state(void *data, bool state)
 {
    gl_t *gl = data;
    if (gl->vsync)
    {
       SSNES_LOG("GL VSync => %s\n", state ? "off" : "on");
-#if defined(_WIN32)
-      static BOOL (APIENTRY *wgl_swap_interval)(int) = NULL;
-      if (!wgl_swap_interval)
-      {
-         SDL_SYM_WRAP(wgl_swap_interval, "wglSwapIntervalEXT");
-      }
-      if (wgl_swap_interval) wgl_swap_interval(state ? 0 : 1);
-#elif defined(__APPLE__)
-      GLint val = state ? 0 : 1;
-      CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &val);
-#else
-      static int (*glx_swap_interval)(int) = NULL;
-      if (!glx_swap_interval) 
-      {
-         SDL_SYM_WRAP(glx_swap_interval, "glXSwapIntervalSGI");
-      }
-      if (!glx_swap_interval)
-      {
-         SDL_SYM_WRAP(glx_swap_interval, "glXSwapIntervalMESA");
-      }
-      if (glx_swap_interval) glx_swap_interval(state ? 0 : 1);
-#endif
+      sdlwrap_set_swap_interval(state ? 0 : 1, true);
    }
 }
 
@@ -1057,7 +1156,7 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    gfx_set_dwm();
 #endif
 
-   if (SDL_Init(SDL_INIT_VIDEO) < 0)
+   if (!sdlwrap_init())
       return NULL;
 
    const SDL_VideoInfo *video_info = SDL_GetVideoInfo();
@@ -1066,16 +1165,24 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    unsigned full_y = video_info->current_h;
    SSNES_LOG("Detecting desktop resolution %ux%u.\n", full_x, full_y);
 
-   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-   SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, video->vsync ? 1 : 0);
+   sdlwrap_set_swap_interval(video->vsync ? 1 : 0, false);
 
-   if (!SDL_SetVideoMode(video->width, video->height, g_settings.video.force_16bit ? 16 : 0, SDL_OPENGL | SDL_RESIZABLE | (video->fullscreen ? SDL_FULLSCREEN : 0)))
+   unsigned win_width = video->width;
+   unsigned win_height = video->height;
+   if (video->fullscreen && (win_width == 0) && (win_height == 0))
+   {
+      win_width = full_x;
+      win_height = full_y;
+   }
+
+   if (!sdlwrap_set_video_mode(win_width, win_height,
+            g_settings.video.force_16bit ? 15 : 0, video->fullscreen))
       return NULL;
 
    gfx_window_title_reset();
    char buf[128];
    if (gfx_window_title(buf, sizeof(buf)))
-      SDL_WM_SetCaption(buf, NULL);
+      sdlwrap_wm_set_caption(buf);
 
    // Remove that ugly mouse :D
    SDL_ShowCursor(SDL_DISABLE);
@@ -1086,7 +1193,7 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    // Need to load dynamically :(
    if (!load_gl_proc())
    {
-      SDL_QuitSubSystem(SDL_INIT_VIDEO);
+      sdlwrap_destroy();
       return NULL;
    }
 #endif
@@ -1094,44 +1201,24 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    gl_t *gl = calloc(1, sizeof(gl_t));
    if (!gl)
    {
-      SDL_QuitSubSystem(SDL_INIT_VIDEO);
+      sdlwrap_destroy();
       return NULL;
    }
 
    gl->vsync = video->vsync;
    gl->fullscreen = video->fullscreen;
-   int attr = 0;
-   SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &attr);
-   if (attr <= 0 && video->vsync)
-   {
-      SSNES_WARN("SDL failed to setup VSync, attempting to recover using native calls!\n");
-      gl_set_nonblock_state(gl, false);
-   }
-   attr = 0;
-   SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &attr);
-   if (attr <= 0)
-      SSNES_WARN("GL double buffer has not been enabled!\n");
-
+   
    gl->full_x = full_x;
    gl->full_y = full_y;
-
-   if (video->fullscreen)
-   {
-      gl->win_width = video->width ? video->width : gl->full_x;
-      gl->win_height = video->height ? video->height : gl->full_y;
-   }
-   else
-   {
-      gl->win_width = video->width;
-      gl->win_height = video->height;
-   }
+   gl->win_width = win_width;
+   gl->win_height = win_height;
 
    SSNES_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height);
 
    if (!gl_shader_init())
    {
       SSNES_ERR("Shader init failed.\n");
-      SDL_QuitSubSystem(SDL_INIT_VIDEO);
+      sdlwrap_destroy();
       free(gl);
       return NULL;
    }
@@ -1139,7 +1226,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;
 
@@ -1190,8 +1278,8 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
 
    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);
@@ -1233,7 +1321,7 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
       
    if (!gl_check_error())
    {
-      SDL_QuitSubSystem(SDL_INIT_VIDEO);
+      sdlwrap_destroy();
       free(gl);
       return NULL;
    }
@@ -1244,13 +1332,14 @@ 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;
 }
 
 static bool gl_focus(void *data)
 {
    (void)data;
-   return (SDL_GetAppState() & (SDL_APPINPUTFOCUS | SDL_APPACTIVE)) == (SDL_APPINPUTFOCUS | SDL_APPACTIVE);
+   return sdlwrap_window_has_focus();
 }
 
 #ifdef HAVE_XML

gfx/gl_common.h

@@ -106,13 +106,6 @@ struct gl_tex_info
    GLfloat coord[8];
 };
 
-// Not legal to cast void* to fn-pointer. Need dirty hack to be compilant.
-// sizeof(void*) == sizeof(void (*)(void)) is asserted earlier.
-#define SDL_SYM_WRAP(sym, symbol) { \
-   void *sym__ = SDL_GL_GetProcAddress(symbol); \
-   memcpy(&(sym), &sym__, sizeof(void*)); \
-}
-
 // Windows ... <_<
 #if (defined(HAVE_XML) || defined(HAVE_CG)) && defined(_WIN32)
 extern PFNGLCLIENTACTIVETEXTUREPROC pglClientActiveTexture;

gfx/py_state/py_state.c

@@ -60,7 +60,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,7 +72,7 @@ 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];
@@ -88,6 +88,24 @@ static PyObject* py_read_input(PyObject *self, PyObject *args)
    return PyBool_FromLong((long)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((long)ret);
+}
+
 static PyMethodDef SNESMethods[] = {
    { "read_wram",    PY_READ_FUNC_DECL(WRAM),   METH_VARARGS, "Read WRAM from SNES." },
    { "read_vram",    PY_READ_FUNC_DECL(VRAM),   METH_VARARGS, "Read VRAM from SNES." },
@@ -95,23 +113,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 = {
@@ -260,7 +304,7 @@ void py_state_free(py_state_t *handle)
    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 +313,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

@@ -26,7 +26,7 @@ typedef struct py_state py_state_t;
 py_state_t *py_state_new(const char *program, bool 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

@@ -45,11 +45,16 @@ struct sdl_video
    bool rgb32;
    bool upsample;
 
+   bool render32;
+
    void (*convert_15_func)(uint16_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned, const SDL_PixelFormat*);
    void (*convert_32_func)(uint32_t*, unsigned, const uint32_t*, unsigned, unsigned, unsigned, const SDL_PixelFormat*);
 
 #ifdef HAVE_FREETYPE
    font_renderer_t *font;
+   uint8_t font_r;
+   uint8_t font_g;
+   uint8_t font_b;
 #endif
 };
 
@@ -75,12 +80,40 @@ 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)
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      vid->font = font_renderer_new(font_path, font_size);
-      if (!vid->font)
+      vid->font = font_renderer_new(path, font_size);
+      if (vid->font)
+      {
+         int r = g_settings.video.msg_color_r * 255;
+         int g = g_settings.video.msg_color_g * 255;
+         int b = g_settings.video.msg_color_b * 255;
+
+         r = r < 0 ? 0 : (r > 255 ? 255 : r);
+         g = g < 0 ? 0 : (g > 255 ? 255 : g);
+         b = b < 0 ? 0 : (b > 255 ? 255 : b);
+
+         // RGB888 -> RGB555
+         if (!vid->render32)
+         {
+            r >>= 3;
+            g >>= 3;
+            b >>= 3;
+         }
+
+         vid->font_r = r;
+         vid->font_g = g;
+         vid->font_b = b;
+      }
+      else
          SSNES_WARN("Failed to init font.\n");
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
 #else
    (void)vid;
    (void)font_path;
@@ -128,9 +161,9 @@ static void sdl_render_msg_15(sdl_video_t *vid, SDL_Surface *buffer, const char
                unsigned g = (out_pix >> gshift) & 0x1f;
                unsigned b = (out_pix >> bshift) & 0x1f;
 
-               unsigned out_r = (r * (256 - blend) + 0x1f * blend) >> 8;
-               unsigned out_g = (g * (256 - blend) + 0x1f * blend) >> 8;
-               unsigned out_b = (b * (256 - blend) + 0x1f * blend) >> 8;
+               unsigned out_r = (r * (256 - blend) + vid->font_r * blend) >> 8;
+               unsigned out_g = (g * (256 - blend) + vid->font_g * blend) >> 8;
+               unsigned out_b = (b * (256 - blend) + vid->font_b * blend) >> 8;
                out[x] = (out_r << rshift) | (out_g << gshift) | (out_b << bshift);
             }
          }
@@ -189,9 +222,9 @@ static void sdl_render_msg_32(sdl_video_t *vid, SDL_Surface *buffer, const char
                unsigned g = (out_pix >> gshift) & 0xff;
                unsigned b = (out_pix >> bshift) & 0xff;
 
-               unsigned out_r = (r * (256 - blend) + 0xff * blend) >> 8;
-               unsigned out_g = (g * (256 - blend) + 0xff * blend) >> 8;
-               unsigned out_b = (b * (256 - blend) + 0xff * blend) >> 8;
+               unsigned out_r = (r * (256 - blend) + vid->font_r * blend) >> 8;
+               unsigned out_g = (g * (256 - blend) + vid->font_g * blend) >> 8;
+               unsigned out_b = (b * (256 - blend) + vid->font_b * blend) >> 8;
                out[x] = (out_r << rshift) | (out_g << gshift) | (out_b << bshift);
             }
          }
@@ -232,13 +265,15 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    if (!video->fullscreen)
       SSNES_LOG("Creating window @ %ux%u\n", video->width, video->height);
 
-   vid->screen = SDL_SetVideoMode(video->width, video->height, (g_settings.video.force_16bit || !video->rgb32) ? 15 : 32, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
+   vid->render32 = video->rgb32 && !g_settings.video.force_16bit;
+   vid->screen = SDL_SetVideoMode(video->width, video->height, vid->render32 ? 32 : 15, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
 
    if (!vid->screen && !g_settings.video.force_16bit && !video->rgb32)
    {
       vid->upsample = true;
       vid->screen = SDL_SetVideoMode(video->width, video->height, 32, SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | (video->fullscreen ? SDL_FULLSCREEN : 0));
       SSNES_WARN("SDL: 15-bit colors failed, attempting 32-bit colors.\n");
+      vid->render32 = true;
    }
 
    if (!vid->screen)
@@ -250,16 +285,18 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    SDL_ShowCursor(SDL_DISABLE);
 
    const SDL_PixelFormat *fmt = vid->screen->format;
-   if (!g_settings.video.force_16bit && (video->rgb32 || vid->upsample))
+   if (vid->render32)
    {
       SSNES_LOG("SDL: Creating 32-bit buffer.\n");
-      vid->buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, 256 * video->input_scale, 256 * video->input_scale, 32,
+      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", 
@@ -285,7 +322,7 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
    sdl_init_font(vid, g_settings.video.font_path, g_settings.video.font_size);
 
 
-   if (fmt->Rshift == 10 && fmt->Gshift ==  5 && fmt->Bshift == 0) 
+   if (fmt->Rshift == 10 && fmt->Gshift ==  5 && fmt->Bshift == 0) // XRGB1555
    {
       SSNES_LOG("SDL: 15-bit format matches. Fast blit.\n");
       vid->convert_15_func = convert_15bit_15bit_direct;
@@ -296,7 +333,7 @@ static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
       vid->convert_15_func = convert_15bit_15bit_shift;
    }
 
-   if (fmt->Rshift == 16 && fmt->Gshift == 8 && fmt->Bshift == 0) 
+   if (fmt->Rshift == 16 && fmt->Gshift == 8 && fmt->Bshift == 0) // ARGB8888
    {
       SSNES_LOG("SDL: 32-bit format matches. Fast blit.\n");
       vid->convert_32_func = convert_32bit_32bit_direct;
@@ -430,7 +467,6 @@ 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)
 {
    sdl_video_t *vid = data;
-   check_window(vid);
 
    if (SDL_MUSTLOCK(vid->buffer))
       SDL_LockSurface(vid->buffer);
@@ -456,15 +492,7 @@ static bool sdl_gfx_frame(void *data, const void* frame, unsigned width, unsigne
    {
       vid->convert_32_func(vid->buffer->pixels, vid->buffer->pitch, frame, width, height, pitch, vid->screen->format);
    }
-
-   if (msg)
-   {
-      if ((!vid->rgb32 || g_settings.video.force_16bit) && !vid->upsample)
-         sdl_render_msg_15(vid, vid->buffer, msg, width, height, vid->screen->format);
-      else
-         sdl_render_msg_32(vid, vid->buffer, msg, width, height, vid->screen->format);
-   }
-
+   
    if (SDL_MUSTLOCK(vid->buffer))
       SDL_UnlockSurface(vid->buffer);
 
@@ -484,6 +512,14 @@ static bool sdl_gfx_frame(void *data, const void* frame, unsigned width, unsigne
 
    SDL_SoftStretch(vid->buffer, &src, vid->screen, &dest);
 
+   if (msg)
+   {
+      if ((!vid->rgb32 || g_settings.video.force_16bit) && !vid->upsample)
+         sdl_render_msg_15(vid, vid->screen, msg, vid->screen->w, vid->screen->h, vid->screen->format);
+      else
+         sdl_render_msg_32(vid, vid->screen, msg, vid->screen->w, vid->screen->h, vid->screen->format);
+   }
+
    char buf[128];
    if (gfx_window_title(buf, sizeof(buf)))
       SDL_WM_SetCaption(buf, NULL);
@@ -502,6 +538,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

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

gfx/sdlwrap.h

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

gfx/shader_cg.c

@@ -37,20 +37,23 @@ static const char* stock_cg_program =
       "("
       "	float4 position	: POSITION,"
       "	float2 texCoord : TEXCOORD0,"
+      "  float4 color : COLOR,"
       ""
       "  uniform float4x4 modelViewProj,"
       ""
       "	out float4 oPosition : POSITION,"
-      "	out float2 otexCoord : TEXCOORD0"
+      "	out float2 otexCoord : TEXCOORD0,"
+      "  out float4 oColor : COLOR"
       ")"
       "{"
       "	oPosition = mul(modelViewProj, position);"
       "	otexCoord = texCoord;"
+      "  oColor = color;"
       "}"
       ""
-      "float4 main_fragment(float2 tex : TEXCOORD0, uniform sampler2D s0 : TEXUNIT0) : COLOR"
+      "float4 main_fragment(in float4 color : COLOR, float2 tex : TEXCOORD0, uniform sampler2D s0 : TEXUNIT0) : COLOR"
       "{"
-      "   return tex2D(s0, tex);"
+      "   return color * tex2D(s0, tex);"
       "}";
 
 #ifdef SSNES_CG_DEBUG
@@ -128,7 +131,9 @@ static unsigned lut_textures[MAX_TEXTURES];
 static unsigned lut_textures_num = 0;
 static char lut_textures_uniform[MAX_TEXTURES][64];
 
+#ifdef HAVE_CONFIGFILE
 static snes_tracker_t *snes_tracker = NULL;
+#endif
 
 void gl_cg_set_proj_matrix(void)
 {
@@ -239,6 +244,7 @@ void gl_cg_set_params(unsigned width, unsigned height,
          }
       }
 
+#ifdef HAVE_CONFIGFILE
       // Set state parameters
       if (snes_tracker)
       {
@@ -256,6 +262,7 @@ void gl_cg_set_params(unsigned width, unsigned height,
             set_param_1f(param_f, info[i].value);
          }
       }
+#endif
    }
 }
 
@@ -273,11 +280,13 @@ 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);
 }
@@ -285,8 +294,6 @@ void gl_cg_deinit(void)
 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;
@@ -305,8 +312,9 @@ static bool load_plain(const char *path)
    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);
       prg[2].vprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, g_settings.video.second_pass_shader, cgVProf, "main_vertex", 0);
 
@@ -488,8 +496,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))
          {
@@ -523,11 +531,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:
@@ -547,10 +553,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;
@@ -579,7 +585,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
@@ -611,7 +617,6 @@ static bool load_imports(const char *dir_path, config_file_t *conf)
 #endif
 
    free(imports);
-
    return true;
 
 error:

gfx/shader_glsl.c

@@ -33,7 +33,7 @@
 
 
 #define NO_SDL_GLEXT
-#include "SDL.h"
+#include "sdlwrap.h"
 #include "SDL_opengl.h"
 #include <stdlib.h>
 #include <libxml/parser.h>
@@ -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
@@ -78,6 +79,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;
@@ -481,13 +483,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 +517,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 +539,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;
@@ -842,6 +842,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);
@@ -862,7 +863,7 @@ 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
@@ -900,7 +901,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)
@@ -1148,7 +1149,7 @@ void gl_glsl_set_params(unsigned width, unsigned height,
          for (unsigned i = 0; i < cnt; i++)
          {
             location = pglGetUniformLocation(gl_program[active_index], info[i].id);
-            pglUniform1i(location, info[i].value);
+            pglUniform1f(location, info[i].value);
          }
       }
    }

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

@@ -63,11 +63,17 @@ struct xv
    uint8_t *ytable;
    uint8_t *utable;
    uint8_t *vtable;
-   unsigned luma_i;
-   unsigned chroma_i;
 
 #ifdef HAVE_FREETYPE
    font_renderer_t *font;
+
+   unsigned luma_index[2];
+   unsigned chroma_u_index;
+   unsigned chroma_v_index;
+
+   uint8_t font_y;
+   uint8_t font_u;
+   uint8_t font_v;
 #endif
 
    void (*render_func)(xv_t*, const void *frame, unsigned width, unsigned height, unsigned pitch);
@@ -89,6 +95,17 @@ static void sighandler(int sig)
    g_quit = 1;
 }
 
+static inline void calculate_yuv(uint8_t *y, uint8_t *u, uint8_t *v, unsigned r, unsigned g, unsigned b)
+{
+   int y_ = (int)(+((double)r * 0.257) + ((double)g * 0.504) + ((double)b * 0.098) +  16.0);
+   int u_ = (int)(-((double)r * 0.148) - ((double)g * 0.291) + ((double)b * 0.439) + 128.0);
+   int v_ = (int)(+((double)r * 0.439) - ((double)g * 0.368) - ((double)b * 0.071) + 128.0);
+
+   *y = y_ < 0 ? 0 : (y_ > 255 ? 255 : y_);
+   *u = y_ < 0 ? 0 : (u_ > 255 ? 255 : u_);
+   *v = v_ < 0 ? 0 : (v_ > 255 ? 255 : v_);
+}
+
 static void init_yuv_tables(xv_t *xv)
 {
    xv->ytable = malloc(0x8000);
@@ -98,18 +115,12 @@ static void init_yuv_tables(xv_t *xv)
    for (unsigned i = 0; i < 0x8000; i++) 
    {
       // Extract RGB555 color data from i
-      uint8_t r = (i >> 10) & 0x1F, g = (i >> 5) & 0x1F, b = (i) & 0x1F;
-      r = (r << 3) | (r >> 2);  //R5->R8
-      g = (g << 3) | (g >> 2);  //G5->G8
-      b = (b << 3) | (b >> 2);  //B5->B8
+      unsigned r = (i >> 10) & 0x1F, g = (i >> 5) & 0x1F, b = (i) & 0x1F;
+      r = (r << 3) | (r >> 2);  // R5->R8
+      g = (g << 3) | (g >> 2);  // G5->G8
+      b = (b << 3) | (b >> 2);  // B5->B8
 
-      int y = (int)(+((double)r * 0.257) + ((double)g * 0.504) + ((double)b * 0.098) +  16.0);
-      int u = (int)(-((double)r * 0.148) - ((double)g * 0.291) + ((double)b * 0.439) + 128.0);
-      int v = (int)(+((double)r * 0.439) - ((double)g * 0.368) - ((double)b * 0.071) + 128.0);
-
-      xv->ytable[i] = y < 0 ? 0 : y > 255 ? 255 : y;
-      xv->utable[i] = u < 0 ? 0 : u > 255 ? 255 : u;
-      xv->vtable[i] = v < 0 ? 0 : v > 255 ? 255 : v;
+      calculate_yuv(&xv->ytable[i], &xv->utable[i], &xv->vtable[i], r, g, b);
    }
 }
 
@@ -173,12 +184,30 @@ 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)
+   const char *path = font_path;
+   if (!*path)
+      path = font_renderer_get_default_font();
+
+   if (path)
    {
-      xv->font = font_renderer_new(font_path, font_size);
-      if (!xv->font)
+      xv->font = font_renderer_new(path, font_size);
+      if (xv->font)
+      {
+         int r = g_settings.video.msg_color_r * 255;
+         r = (r < 0 ? 0 : (r > 255 ? 255 : r));
+         int g = g_settings.video.msg_color_g * 255;
+         g = (g < 0 ? 0 : (g > 255 ? 255 : g));
+         int b = g_settings.video.msg_color_b * 255;
+         b = (b < 0 ? 0 : (b > 255 ? 255 : b));
+
+         calculate_yuv(&xv->font_y, &xv->font_u, &xv->font_v,
+               r, g, b);
+      }
+      else
          SSNES_WARN("Failed to init font.\n");
    }
+   else
+      SSNES_LOG("Did not find default font.\n");
 #endif
 }
 
@@ -297,7 +326,6 @@ static void render32_uyvy(xv_t *xv, const void *input_, unsigned width, unsigned
    }
 }
 
-
 static void* xv_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
    xv_t *xv = calloc(1, sizeof(*xv));
@@ -359,8 +387,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,
@@ -383,7 +411,7 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
 
    // Set colorkey to auto paint, so that Xv video output is always visible
    Atom atom = XInternAtom(xv->display, "XV_AUTOPAINT_COLORKEY", true);
-   if(atom != None) XvSetPortAttribute(xv->display, xv->port, atom, 1);
+   if (atom != None) XvSetPortAttribute(xv->display, xv->port, atom, 1);
 
    int format_count;
    XvImageFormatValues *format = XvListImageFormats(xv->display, xv->port, &format_count);
@@ -399,29 +427,43 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
             has_format = true;
             xv->fourcc = format[i].id;
             xv->render_func = video->rgb32 ? render32_yuy2 : render16_yuy2;
-            xv->luma_i = 0; xv->chroma_i = 1;
+
+#ifdef HAVE_FREETYPE
+            xv->luma_index[0] = 0;
+            xv->luma_index[1] = 2;
+            xv->chroma_u_index = 1;
+            xv->chroma_v_index = 3;
+#endif
             break;
          }
       }
    }
 
-   if (!has_format) for (int i = 0; i < format_count; i++) 
+   if (!has_format) 
    {
-      if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
+      for (int i = 0; i < format_count; i++) 
       {
-         if (format[i].component_order[0] == 'U' && format[i].component_order[1] == 'Y'
-               && format[i].component_order[2] == 'V' && format[i].component_order[3] == 'Y') 
+         if (format[i].type == XvYUV && format[i].bits_per_pixel == 16 && format[i].format == XvPacked) 
          {
-            has_format = true;
-            xv->fourcc = format[i].id;
-            xv->render_func = video->rgb32 ? render32_uyvy : render16_uyvy;
-            xv->chroma_i = 0; xv->luma_i = 1;
-            break;
+            if (format[i].component_order[0] == 'U' && format[i].component_order[1] == 'Y'
+                  && format[i].component_order[2] == 'V' && format[i].component_order[3] == 'Y') 
+            {
+               has_format = true;
+               xv->fourcc = format[i].id;
+               xv->render_func = video->rgb32 ? render32_uyvy : render16_uyvy;
+
+#ifdef HAVE_FREETYPE
+               xv->luma_index[0] = 1;
+               xv->luma_index[1] = 3;
+               xv->chroma_u_index = 0;
+               xv->chroma_v_index = 2;
+#endif
+               break;
+            }
          }
       }
    }
 
-
    free(format);
    if (!has_format) 
    {
@@ -429,8 +471,8 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
       goto error;
    }
 
-   xv->width = 512;
-   xv->height = 512;
+   xv->width = g_extern.system.geom.max_width;
+   xv->height = g_extern.system.geom.max_height;
 
    xv->image = XvShmCreateImage(xv->display, xv->port, xv->fourcc, NULL, xv->width, xv->height, &xv->shminfo);
    if (!xv->image) 
@@ -466,8 +508,6 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
    xv_set_nonblock_state(xv, !video->vsync);
    xv->focus = true;
 
-   xv_init_font(xv, g_settings.video.font_path, g_settings.video.font_size);
-
    void *xinput = input_x.init();
    if (xinput)
    {
@@ -478,6 +518,8 @@ static void* xv_init(const video_info_t *video, const input_driver_t **input, vo
       *input = NULL;
 
    init_yuv_tables(xv);
+   xv_init_font(xv, g_settings.video.font_path, g_settings.video.font_size);
+
    return xv;
 
 error:
@@ -561,6 +603,7 @@ static void calc_out_rect(bool keep_aspect, unsigned *x, unsigned *y, unsigned *
 }
 
 // TODO: Is there some way to render directly like GL? :(
+// Hacky C code is hacky :D Yay.
 static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned height)
 {
 #ifdef HAVE_FREETYPE
@@ -574,12 +617,17 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
    int _base_x = g_settings.video.msg_pos_x * width;
    int _base_y = height - g_settings.video.msg_pos_y * height;
 
-   unsigned luma_i = xv->luma_i;
-   unsigned chroma_i = xv->chroma_i;
+   unsigned luma_index[2] = { xv->luma_index[0], xv->luma_index[1] };
+   unsigned chroma_u_index = xv->chroma_u_index;
+   unsigned chroma_v_index = xv->chroma_v_index;
+
+   unsigned pitch = width << 1; // YUV formats used are 16 bpp.
 
    while (head)
    {
-      int base_x = _base_x + head->off_x;
+      int base_x = (_base_x + head->off_x) << 1;
+      base_x &= ~3; // Make sure we always start on the correct boundary so the indices are correct.
+
       int base_y = _base_y - head->off_y;
       if (base_y >= 0)
       {
@@ -588,21 +636,33 @@ static void xv_render_msg(xv_t *xv, const char *msg, unsigned width, unsigned he
             if (base_x < 0)
                continue;
 
-            const uint8_t *a = head->output + head->pitch * y;
-            uint8_t *out = (uint8_t*)xv->image->data + (base_y - head->height + y) * (width << 1) + (base_x << 1);
+            const uint8_t * restrict a = head->output + head->pitch * y;
+            uint8_t * restrict out = (uint8_t*)xv->image->data + (base_y - head->height + y) * pitch + base_x;
 
-            for (int x = 0; x < (head->width << 1) && (base_x + x) < width; x += 2)
+            for (int x = 0; x < (head->width << 1) && (base_x + x) < pitch; x += 4)
             {
-               // Blend luma
-               uint8_t blend = a[x >> 1];
-               unsigned blended = blend + (((256 - blend) * (unsigned)out[x + luma_i]) >> 8);
-               blended = blended > 255 ? 255 : blended;
-               out[x + luma_i] = blended;
+               unsigned alpha[2];
+               alpha[0] = a[(x >> 1) + 0];
 
-               // Blend chroma
-               blended = (128 * blend + ((256 - blend) * (unsigned)out[x + chroma_i])) >> 8;
-               blended = blended > 255 ? 255 : blended;
-               out[x + chroma_i] = blended;
+               if (((x >> 1) + 1) == head->width) // We reached the end, uhoh! Branching like a BOSS! :D
+                  alpha[1] = 0;
+               else
+                  alpha[1] = a[(x >> 1) + 1];
+
+               unsigned alpha_sub = (alpha[0] + alpha[1]) >> 1; // Blended alpha for the sub-samples U/V channels.
+
+               for (unsigned i = 0; i < 2; i++)
+               {
+                  unsigned blended = (xv->font_y * alpha[i] + ((256 - alpha[i]) * out[x + luma_index[i]])) >> 8;
+                  out[x + luma_index[i]] = blended;
+               }
+
+               // Blend chroma channels
+               unsigned blended = (xv->font_u * alpha_sub + ((256 - alpha_sub) * out[x + chroma_u_index])) >> 8;
+               out[x + chroma_u_index] = blended;
+
+               blended = (xv->font_v * alpha_sub + ((256 - alpha_sub) * out[x + chroma_v_index])) >> 8;
+               out[x + chroma_v_index] = blended;
             }
          }
       }
@@ -630,11 +690,12 @@ static bool xv_frame(void *data, const void* frame, unsigned width, unsigned hei
    XGetWindowAttributes(xv->display, xv->window, &target);
    xv->render_func(xv, frame, width, height, pitch);
 
-   if (msg)
-      xv_render_msg(xv, msg, xv->width, xv->height);
-
    unsigned x, y, owidth, oheight;
    calc_out_rect(xv->keep_aspect, &x, &y, &owidth, &oheight, target.width, target.height);
+
+   if (msg)
+      xv_render_msg(xv, msg, width << 1, height << 1);
+
    XvShmPutImage(xv->display, xv->port, xv->window, xv->gc, xv->image,
          0, 0, width << 1, height << 1,
          x, y, owidth, oheight,
@@ -693,9 +754,9 @@ static void xv_free(void *data)
    shmctl(xv->shminfo.shmid, IPC_RMID, NULL);
    XFree(xv->image);
 
-   if(xv->window) 
+   if (xv->window) 
       XUnmapWindow(xv->display, xv->window);
-   if(xv->colormap) 
+   if (xv->colormap) 
       XFreeColormap(xv->display, xv->colormap);
 
    XCloseDisplay(xv->display);

input/dinput.c

@@ -22,6 +22,7 @@
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
+#include "../gfx/sdlwrap.h"
 
 void sdl_dinput_free(sdl_dinput_t *di)
 {
@@ -103,12 +104,19 @@ sdl_dinput_t* sdl_dinput_init(void)
    CoInitialize(NULL);
 
    SDL_SysWMinfo info;
-   if (!SDL_GetWMInfo(&info))
+   SDL_VERSION(&info.version);
+
+   if (!sdlwrap_get_wm_info(&info))
    {
       SSNES_ERR("Failed to get SysWM info.\n");
       goto error;
    }
+
+#if SDL_MODERN
+   di->hWnd = info.info.win.window;
+#else
    di->hWnd = info.window;
+#endif
 
    if (FAILED(DirectInput8Create(
       GetModuleHandle(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8,

input/keysym.h

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

input/sdl.c

@@ -17,17 +17,115 @@
 
 #include "driver.h"
 
-#include "SDL.h"
+#include "../gfx/sdlwrap.h"
 #include <stdbool.h>
 #include "general.h"
 #include <stdint.h>
 #include <stdlib.h>
 #include <libsnes.hpp>
 #include "ssnes_sdl_input.h"
+#include "keysym.h"
 
+struct key_bind
+{
+   unsigned sdl;
+   enum ssnes_key sk;
+};
+
+static unsigned keysym_lut[SK_LAST];
+static const struct key_bind lut_binds[] = {
+   { SDLK_LEFT, SK_LEFT },
+   { SDLK_RIGHT, SK_RIGHT },
+   { SDLK_UP, SK_UP },
+   { SDLK_DOWN, SK_DOWN },
+   { SDLK_RETURN, SK_RETURN },
+   { SDLK_TAB, SK_TAB },
+   { SDLK_INSERT, SK_INSERT },
+   { SDLK_DELETE, SK_DELETE },
+   { SDLK_RSHIFT, SK_RSHIFT },
+   { SDLK_LSHIFT, SK_LSHIFT },
+   { SDLK_LCTRL, SK_LCTRL },
+   { SDLK_LALT, SK_LALT },
+   { SDLK_SPACE, SK_SPACE },
+   { SDLK_ESCAPE, SK_ESCAPE },
+   { SDLK_BACKSPACE, SK_BACKSPACE },
+   { SDLK_KP_ENTER, SK_KP_ENTER },
+   { SDLK_KP_PLUS, SK_KP_PLUS },
+   { SDLK_KP_MINUS, SK_KP_MINUS },
+   { SDLK_KP_MULTIPLY, SK_KP_MULTIPLY },
+   { SDLK_KP_DIVIDE, SK_KP_DIVIDE },
+   { SDLK_BACKQUOTE, SK_BACKQUOTE },
+   { SDLK_PAUSE, SK_PAUSE },
+   { SDLK_KP0, SK_KP0 },
+   { SDLK_KP1, SK_KP1 },
+   { SDLK_KP2, SK_KP2 },
+   { SDLK_KP3, SK_KP3 },
+   { SDLK_KP4, SK_KP4 },
+   { SDLK_KP5, SK_KP5 },
+   { SDLK_KP6, SK_KP6 },
+   { SDLK_KP7, SK_KP7 },
+   { SDLK_KP8, SK_KP8 },
+   { SDLK_KP9, SK_KP9 },
+   { SDLK_0, SK_0 },
+   { SDLK_1, SK_1 },
+   { SDLK_2, SK_2 },
+   { SDLK_3, SK_3 },
+   { SDLK_4, SK_4 },
+   { SDLK_5, SK_5 },
+   { SDLK_6, SK_6 },
+   { SDLK_7, SK_7 },
+   { SDLK_8, SK_8 },
+   { SDLK_9, SK_9 },
+   { SDLK_F1, SK_F1 },
+   { SDLK_F2, SK_F2 },
+   { SDLK_F3, SK_F3 },
+   { SDLK_F4, SK_F4 },
+   { SDLK_F5, SK_F5 },
+   { SDLK_F6, SK_F6 },
+   { SDLK_F7, SK_F7 },
+   { SDLK_F8, SK_F8 },
+   { SDLK_F9, SK_F9 },
+   { SDLK_F10, SK_F10 },
+   { SDLK_F11, SK_F11 },
+   { SDLK_F12, SK_F12 },
+   { SDLK_a, SK_a },
+   { SDLK_b, SK_b },
+   { SDLK_c, SK_c },
+   { SDLK_d, SK_d },
+   { SDLK_e, SK_e },
+   { SDLK_f, SK_f },
+   { SDLK_g, SK_g },
+   { SDLK_h, SK_h },
+   { SDLK_i, SK_i },
+   { SDLK_j, SK_j },
+   { SDLK_k, SK_k },
+   { SDLK_l, SK_l },
+   { SDLK_m, SK_m },
+   { SDLK_n, SK_n },
+   { SDLK_o, SK_o },
+   { SDLK_p, SK_p },
+   { SDLK_q, SK_q },
+   { SDLK_r, SK_r },
+   { SDLK_s, SK_s },
+   { SDLK_t, SK_t },
+   { SDLK_u, SK_u },
+   { SDLK_v, SK_v },
+   { SDLK_w, SK_w },
+   { SDLK_x, SK_x },
+   { SDLK_y, SK_y },
+   { SDLK_z, SK_z },
+};
+
+static void init_lut(void)
+{
+   memset(keysym_lut, 0, sizeof(keysym_lut));
+   for (unsigned i = 0; i < sizeof(lut_binds) / sizeof(lut_binds[0]); i++)
+      keysym_lut[lut_binds[i].sk] = lut_binds[i].sdl;
+}
 
 static void* sdl_input_init(void)
 {
+   init_lut();
    sdl_input_t *sdl = calloc(1, sizeof(*sdl));
    if (!sdl)
       return NULL;
@@ -76,16 +174,9 @@ static void* sdl_input_init(void)
    return sdl;
 }
 
-
 static bool sdl_key_pressed(int key)
 {
-   int num_keys;
-   Uint8 *keymap = SDL_GetKeyState(&num_keys);
-
-   if (key >= num_keys)
-      return false;
-
-   return keymap[key];
+   return sdlwrap_key_pressed(keysym_lut[key]);
 }
 
 #ifndef HAVE_DINPUT

input/x11_input.c

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

libsnes.hpp

@@ -66,6 +66,25 @@ 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 **
+#define SNES_ENVIRONMENT_SET_GEOMETRY 1   // const struct snes_geometry *
+#define SNES_ENVIRONMENT_SET_PITCH 2      // const unsigned *
+
+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.
+};
+
+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 +93,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;
 }

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)
 
@@ -90,11 +95,19 @@ 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;
 };
 
+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 +276,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;
 
@@ -400,7 +431,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;
       }
@@ -440,7 +471,7 @@ 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;
       }
@@ -482,7 +513,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;
    }
@@ -543,7 +574,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 +585,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 +612,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 +703,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

@@ -58,12 +58,7 @@ check_pkgconf PULSE libpulse
 check_lib COREAUDIO "-framework AudioUnit" AudioUnitInitialize
 
 check_pkgconf SDL sdl 1.2.10
-check_critical SDL "Cannot find SDL 1.2 library."
-check_pkgconf SDL_NEW sdl 1.3
-if [ $HAVE_SDL_NEW = yes ]; then
-   echo "SSNES is not compatible with SDL 1.3 API, please use a recent 1.2 release."
-   exit 1
-fi
+check_critical SDL "Cannot find SDL library."
 
 # On some distros, -lCg doesn't link against -lstdc++ it seems ...
 check_lib_cxx CG -lCg cgCreateContext
@@ -80,12 +75,25 @@ 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
 
 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
 
@@ -94,7 +102,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 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,18 +1,18 @@
 . qb/qb.params.sh
 
 PACKAGE_NAME=ssnes
-PACKAGE_VERSION=0.8
+PACKAGE_VERSION=0.9.1
 
 # 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_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 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 CG "Enable Cg shader support" auto
 add_command_line_enable XML "Enable bSNES-style XML shader support" auto

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,6 +32,7 @@ struct video_info
    size_t outbuf_size;
 
    int fmt;
+   int pix_fmt;
    int 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->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,56 @@ 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->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)
+   AVDictionary *opts = NULL;
+
+#ifdef HAVE_X264RGB
+   video->codec->thread_count = 3;
+   av_dict_set(&opts, "crf", "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,18 +206,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);
-#ifdef AVIO_FLAG_WRITE
-   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
-   if (url_fopen(&ctx->pb, ctx->filename, URL_WRONLY) < 0)
+#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;
    }
 
+#ifdef HAVE_FFMPEG_AVFORMAT_NEW_STREAM
+   AVStream *stream = avformat_new_stream(ctx, handle->video.encoder);
+#else
    int stream_cnt = 0;
    AVStream *stream = av_new_stream(ctx, stream_cnt++);
+#endif
    stream->codec = handle->video.codec;
 
    if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
@@ -166,29 +241,43 @@ 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
+
+#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 *
@@ -196,7 +285,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;
 }
@@ -205,17 +294,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;
    }
@@ -310,9 +399,9 @@ int 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;
@@ -320,24 +409,33 @@ int ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data)
       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);
+
+   // Tightly pack our frame to conserve memory. libsnes tends to use a very large pitch.
+   struct ffemu_video_data attr_data = *data;
+   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 < 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 0;
 }
@@ -346,9 +444,9 @@ int 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;
@@ -356,23 +454,23 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
       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;
 }
@@ -380,16 +478,15 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
 static int 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,
+         handle->params.out_width, handle->params.out_height, handle->video.pix_fmt, SWS_POINT,
          NULL, NULL, NULL);
 
    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);
+         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);
@@ -426,7 +523,7 @@ static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_dat
    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, 
@@ -447,10 +544,8 @@ static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_dat
             return -1;
 
          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;
@@ -470,6 +565,35 @@ int ffemu_finalize(ffemu_t *handle)
 {
    deinit_thread(handle);
 
+   // Push out audio still in queue.
+   size_t audio_buf_size = 512 * 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 = 512,
+            .data = audio_buf
+         };
+
+         ffemu_push_audio_thread(handle, &aud);
+      }
+
+      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);
+
+      av_free(audio_buf);
+   }
+
    // Push out frames still stuck in queue.
    void *video_buf = av_malloc(2 * handle->params.fb_width * handle->params.fb_height * handle->video.pix_size);
    if (video_buf)
@@ -485,24 +609,6 @@ int ffemu_finalize(ffemu_t *handle)
       av_free(video_buf);
    }
 
-   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);
-   }
-
    deinit_thread_buf(handle);
 
    // Push out delayed frames. (MPEG codecs)
@@ -512,24 +618,22 @@ int ffemu_finalize(ffemu_t *handle)
    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);
@@ -537,7 +641,7 @@ int ffemu_finalize(ffemu_t *handle)
    return 0;
 }
 
-static int SDLCALL ffemu_thread(void *data)
+static void ffemu_thread(void *data)
 {
    ffemu_t *ff = data;
 
@@ -545,47 +649,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);
@@ -593,13 +697,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
          };
 
@@ -609,6 +713,5 @@ static int SDLCALL ffemu_thread(void *data)
 
    av_free(video_buf);
    av_free(audio_buf);
-
-   return 0;
 }
+

rewind.c

@@ -22,14 +22,11 @@
 #include <string.h>
 #include <assert.h>
 
-//#include <stdio.h>
-
 struct state_manager
 {
    uint64_t *buffer;
    size_t buf_size;
    uint32_t *tmp_state;
-   uint32_t *scratch_buf;
    size_t top_ptr;
    size_t bottom_ptr;
    size_t state_size;
@@ -126,7 +123,6 @@ static void reassign_bottom(state_manager_t *state)
 
 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;
@@ -139,11 +135,12 @@ static void generate_delta(state_manager_t *state, const void *data)
    {
       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;
 
@@ -154,8 +151,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

@@ -17,6 +17,7 @@
 
 #include "general.h"
 #include "conf/config_file.h"
+#include "input/keysym.h"
 #include <assert.h>
 #include "strl.h"
 #include "config.def.h"
@@ -128,13 +129,17 @@ 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;
 
 #ifdef HAVE_FREETYPE
    g_settings.video.font_size = font_size;
    g_settings.video.msg_pos_x = message_pos_offset_x;
    g_settings.video.msg_pos_y = message_pos_offset_y;
+   
+   g_settings.video.msg_color_r = ((message_color >> 16) & 0xff) / 255.0f;
+   g_settings.video.msg_color_g = ((message_color >>  8) & 0xff) / 255.0f;
+   g_settings.video.msg_color_b = ((message_color >>  0) & 0xff) / 255.0f;
 #endif
 
 #if defined(HAVE_CG) || defined(HAVE_XML)
@@ -156,23 +161,22 @@ static void set_defaults(void)
    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;
    g_settings.pause_nonactive = pause_nonactive;
    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));
    memcpy(g_settings.input.binds[0], snes_keybinds_1, sizeof(snes_keybinds_1));
    for (unsigned i = 1; i < 5; i++)
       memcpy(g_settings.input.binds[i], snes_keybinds_rest, sizeof(snes_keybinds_rest));
 
-   g_settings.input.axis_threshold = AXIS_THRESHOLD;
+   g_settings.input.axis_threshold = axis_threshold;
    g_settings.input.netplay_client_swap_input = netplay_client_swap_input;
    for (int i = 0; i < MAX_PLAYERS; i++)
       g_settings.input.joypad_map[i] = i;
@@ -284,7 +288,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;
@@ -322,6 +330,14 @@ static void parse_config_file(void)
    CONFIG_GET_INT(video.font_size, "video_font_size");
    CONFIG_GET_DOUBLE(video.msg_pos_x, "video_message_pos_x");
    CONFIG_GET_DOUBLE(video.msg_pos_y, "video_message_pos_y");
+
+   unsigned msg_color;
+   if (config_get_hex(conf, "video_message_color", &msg_color))
+   {
+      g_settings.video.msg_color_r = ((msg_color >> 16) & 0xff) / 255.0f;
+      g_settings.video.msg_color_g = ((msg_color >>  8) & 0xff) / 255.0f;
+      g_settings.video.msg_color_b = ((msg_color >>  0) & 0xff) / 255.0f;
+   }
 #endif
 
    CONFIG_GET_BOOL(video.hires_record, "video_hires_record");
@@ -368,17 +384,6 @@ static void parse_config_file(void)
    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");
@@ -403,6 +408,10 @@ static void parse_config_file(void)
    CONFIG_GET_INT(autosave_interval, "autosave_interval");
 
    CONFIG_GET_STRING(cheat_database, "cheat_database_path");
+   CONFIG_GET_STRING(cheat_settings_path, "cheat_settings_path");
+
+   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)))
    {
@@ -468,6 +477,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)
@@ -503,6 +513,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)
@@ -538,6 +549,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)
@@ -573,6 +585,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)
@@ -608,6 +621,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)
@@ -627,71 +641,72 @@ struct key_map
 
 // Edit: Not portable to different input systems atm. Might move this map into the driver itself or something.
 // However, this should map nicely over to other systems aswell since the definition are mostly the same anyways.
-static const struct key_map sdlk_map[] = {
-   { "left", SDLK_LEFT },
-   { "right", SDLK_RIGHT },
-   { "up", SDLK_UP },
-   { "down", SDLK_DOWN },
-   { "enter", SDLK_RETURN },
-   { "kp_enter", SDLK_KP_ENTER },
-   { "tab", SDLK_TAB },
-   { "insert", SDLK_INSERT },
-   { "del", SDLK_DELETE },
-   { "end", SDLK_END },
-   { "home", SDLK_HOME },
-   { "rshift", SDLK_RSHIFT },
-   { "shift", SDLK_LSHIFT },
-   { "ctrl", SDLK_LCTRL },
-   { "alt", SDLK_LALT },
-   { "space", SDLK_SPACE },
-   { "escape", SDLK_ESCAPE },
-   { "add", SDLK_KP_PLUS },
-   { "subtract", SDLK_KP_MINUS },
-   { "f1", SDLK_F1 },
-   { "f2", SDLK_F2 },
-   { "f3", SDLK_F3 },
-   { "f4", SDLK_F4 },
-   { "f5", SDLK_F5 },
-   { "f6", SDLK_F6 },
-   { "f7", SDLK_F7 },
-   { "f8", SDLK_F8 },
-   { "f9", SDLK_F9 },
-   { "f10", SDLK_F10 },
-   { "f11", SDLK_F11 },
-   { "f12", SDLK_F12 },
-   { "num0", SDLK_0 },
-   { "num1", SDLK_1 },
-   { "num2", SDLK_2 },
-   { "num3", SDLK_3 },
-   { "num4", SDLK_4 },
-   { "num5", SDLK_5 },
-   { "num6", SDLK_6 },
-   { "num7", SDLK_7 },
-   { "num8", SDLK_8 },
-   { "num9", SDLK_9 },
-   { "pageup", SDLK_PAGEUP },
-   { "pagedown", SDLK_PAGEDOWN },
-   { "keypad0", SDLK_KP0 },
-   { "keypad1", SDLK_KP1 },
-   { "keypad2", SDLK_KP2 },
-   { "keypad3", SDLK_KP3 },
-   { "keypad4", SDLK_KP4 },
-   { "keypad5", SDLK_KP5 },
-   { "keypad6", SDLK_KP6 },
-   { "keypad7", SDLK_KP7 },
-   { "keypad8", SDLK_KP8 },
-   { "keypad9", SDLK_KP9 },
-   { "period", SDLK_PERIOD },
-   { "capslock", SDLK_CAPSLOCK },
-   { "numlock", SDLK_NUMLOCK },
-   { "backspace", SDLK_BACKSPACE },
-   { "multiply", SDLK_KP_MULTIPLY },
-   { "divide", SDLK_KP_DIVIDE },
-   { "print_screen", SDLK_PRINT },
-   { "scroll_lock", SDLK_SCROLLOCK },
-   { "tilde", SDLK_BACKQUOTE },
-   { "backquote", SDLK_BACKQUOTE },
-   { "nul", SDLK_UNKNOWN },
+static const struct key_map sk_map[] = {
+   { "left", SK_LEFT },
+   { "right", SK_RIGHT },
+   { "up", SK_UP },
+   { "down", SK_DOWN },
+   { "enter", SK_RETURN },
+   { "kp_enter", SK_KP_ENTER },
+   { "tab", SK_TAB },
+   { "insert", SK_INSERT },
+   { "del", SK_DELETE },
+   { "end", SK_END },
+   { "home", SK_HOME },
+   { "rshift", SK_RSHIFT },
+   { "shift", SK_LSHIFT },
+   { "ctrl", SK_LCTRL },
+   { "alt", SK_LALT },
+   { "space", SK_SPACE },
+   { "escape", SK_ESCAPE },
+   { "add", SK_KP_PLUS },
+   { "subtract", SK_KP_MINUS },
+   { "f1", SK_F1 },
+   { "f2", SK_F2 },
+   { "f3", SK_F3 },
+   { "f4", SK_F4 },
+   { "f5", SK_F5 },
+   { "f6", SK_F6 },
+   { "f7", SK_F7 },
+   { "f8", SK_F8 },
+   { "f9", SK_F9 },
+   { "f10", SK_F10 },
+   { "f11", SK_F11 },
+   { "f12", SK_F12 },
+   { "num0", SK_0 },
+   { "num1", SK_1 },
+   { "num2", SK_2 },
+   { "num3", SK_3 },
+   { "num4", SK_4 },
+   { "num5", SK_5 },
+   { "num6", SK_6 },
+   { "num7", SK_7 },
+   { "num8", SK_8 },
+   { "num9", SK_9 },
+   { "pageup", SK_PAGEUP },
+   { "pagedown", SK_PAGEDOWN },
+   { "keypad0", SK_KP0 },
+   { "keypad1", SK_KP1 },
+   { "keypad2", SK_KP2 },
+   { "keypad3", SK_KP3 },
+   { "keypad4", SK_KP4 },
+   { "keypad5", SK_KP5 },
+   { "keypad6", SK_KP6 },
+   { "keypad7", SK_KP7 },
+   { "keypad8", SK_KP8 },
+   { "keypad9", SK_KP9 },
+   { "period", SK_PERIOD },
+   { "capslock", SK_CAPSLOCK },
+   { "numlock", SK_NUMLOCK },
+   { "backspace", SK_BACKSPACE },
+   { "multiply", SK_KP_MULTIPLY },
+   { "divide", SK_KP_DIVIDE },
+   { "print_screen", SK_PRINT },
+   { "scroll_lock", SK_SCROLLOCK },
+   { "tilde", SK_BACKQUOTE },
+   { "backquote", SK_BACKQUOTE },
+   { "pause", SK_PAUSE },
+   { "nul", SK_UNKNOWN },
 };
 
 static struct snes_keybind *find_snes_bind(unsigned port, int id)
@@ -706,23 +721,23 @@ static struct snes_keybind *find_snes_bind(unsigned port, int id)
    return NULL;
 }
 
-static int find_sdlk_bind(const char *str)
+static int find_sk_bind(const char *str)
 {
-   for (int i = 0; i < sizeof(sdlk_map)/sizeof(struct key_map); i++)
+   for (int i = 0; i < sizeof(sk_map)/sizeof(struct key_map); i++)
    {
-      if (strcasecmp(sdlk_map[i].str, str) == 0)
-         return sdlk_map[i].key;
+      if (strcasecmp(sk_map[i].str, str) == 0)
+         return sk_map[i].key;
    }
    return -1;
 }
 
-static int find_sdlk_key(const char *str)
+static int find_sk_key(const char *str)
 {
    // If the bind is a normal key-press ...
    if (strlen(str) == 1 && isalpha(*str))
-      return (int)SDLK_a + (tolower(*str) - (int)'a');
+      return (int)SK_a + (tolower(*str) - (int)'a');
    else // Check if we have a special mapping for it.
-      return find_sdlk_bind(str);
+      return find_sk_bind(str);
 }
 
 // Yes, this function needs a good refactor :)
@@ -743,7 +758,7 @@ static void read_keybinds(config_file_t *conf)
          // Check keybind
          if (bind_maps[j][i].key && config_get_string(conf, bind_maps[j][i].key, &tmp_key))
          {
-            int key = find_sdlk_key(tmp_key);
+            int key = find_sk_key(tmp_key);
 
             if (key >= 0)
                bind->key = key;

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

@@ -15,14 +15,14 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <stdbool.h>
 #include <libsnes.hpp>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 #include <getopt.h>
-#include <time.h>
+#include <errno.h>
 #include "driver.h"
 #include "file.h"
 #include "general.h"
@@ -34,17 +34,14 @@
 #include "strl.h"
 #include "screenshot.h"
 #include "cheats.h"
+#include "audio/utils.h"
 #include <assert.h>
-#ifdef HAVE_SRC
-#include <samplerate.h>
-#endif
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #endif
 
-
 #ifdef __APPLE__
 #include "SDL.h" 
 // OSX seems to really need -lSDLmain, 
@@ -88,13 +85,31 @@ static void set_fast_forward_button(bool new_button_state, bool new_hold_button_
    old_hold_button_state = new_hold_button_state;
 }
 
-static void take_screenshot(const uint16_t *frame, unsigned width, unsigned height)
+static inline unsigned lines_to_pitch(unsigned height)
+{
+   if (g_extern.system.pitch == 0) // SNES semantics
+      return ((height == 448) || (height == 478)) ? 1024 : 2048;
+   else
+      return g_extern.system.pitch;
+}
+
+static void video_cached_frame(void);
+static void take_screenshot(void)
 {
    if (!(*g_settings.screenshot_directory))
       return;
 
-   bool ret = screenshot_dump(g_settings.screenshot_directory, frame, 
-         width, height, (height == 448 || height == 478) ? 1024 : 2048);
+   bool ret = false;
+   if (g_extern.frame_cache.data)
+   {
+      const uint16_t *data = g_extern.frame_cache.data;
+      unsigned width = g_extern.frame_cache.width;
+      unsigned height = g_extern.frame_cache.height;
+      ret = screenshot_dump(g_settings.screenshot_directory,
+            data, 
+            width, height,
+            lines_to_pitch(height));
+   }
 
    const char *msg = NULL;
    if (ret)
@@ -109,7 +124,33 @@ static void take_screenshot(const uint16_t *frame, unsigned width, unsigned heig
    }
 
    msg_queue_clear(g_extern.msg_queue);
-   msg_queue_push(g_extern.msg_queue, msg, 1, 180);
+
+   if (g_extern.is_paused)
+   {
+      msg_queue_push(g_extern.msg_queue, msg, 1, 1);
+      video_cached_frame();
+   }
+   else
+      msg_queue_push(g_extern.msg_queue, msg, 1, 180);
+}
+
+
+static inline void adjust_crop(const uint16_t **data, unsigned *height)
+{
+   // Rather SNES specific.
+   if (g_settings.video.crop_overscan)
+   {
+      if (*height == 239)
+      {
+         *data += 7 * 1024; // Skip 7 top scanlines.
+         *height = 224;
+      }
+      else if (*height == 478)
+      {
+         *data += 15 * 512; // Skip 15 top scanlines.
+         *height = 448;
+      }
+   }
 }
 
 // libsnes: 0.065
@@ -119,22 +160,7 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
    if (!g_extern.video_active)
       return;
 
-   if (g_settings.video.crop_overscan)
-   {
-      if (height == 239)
-      {
-         data += 7 * 1024; // Skip 7 top scanlines.
-         height = 224;
-      }
-      else if (height == 478)
-      {
-         data += 15 * 512; // Skip 15 top scanlines.
-         height = 448;
-      }
-   }
-
-   if (g_extern.do_screenshot)
-      take_screenshot(data, width, height);
+   adjust_crop(&data, &height);
 
    // Slightly messy code,
    // but we really need to do processing before blocking on VSync for best possible scheduling.
@@ -143,7 +169,7 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
    {
       struct ffemu_video_data ffemu_data = {
          .data = data,
-         .pitch = height == 448 || height == 478 ? 1024 : 2048,
+         .pitch = lines_to_pitch(height),
          .width = width,
          .height = height,
       };
@@ -160,7 +186,7 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
       unsigned oheight = height;
       g_extern.filter.psize(&owidth, &oheight);
       g_extern.filter.prender(g_extern.filter.colormap, g_extern.filter.buffer, 
-            g_extern.filter.pitch, data, (height == 448 || height == 478) ? 1024 : 2048, width, height);
+            g_extern.filter.pitch, data, lines_to_pitch(height), width, height);
 
 #ifdef HAVE_FFMPEG
       if (g_extern.recording && g_settings.video.post_filter_record)
@@ -178,48 +204,67 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
       if (!driver.video->frame(driver.video_data, g_extern.filter.buffer, owidth, oheight, g_extern.filter.pitch, msg))
          g_extern.video_active = false;
    }
-   else if (!driver.video->frame(driver.video_data, data, width, height, (height == 448 || height == 478) ? 1024 : 2048, msg))
+   else if (!driver.video->frame(driver.video_data, data, width, height, lines_to_pitch(height), msg))
       g_extern.video_active = false;
 #else
-   if (!driver.video->frame(driver.video_data, data, width, height, (height == 448 || height == 478) ? 1024 : 2048, msg))
+   if (!driver.video->frame(driver.video_data, data, width, height, lines_to_pitch(height), msg))
       g_extern.video_active = false;
 #endif
+
+   g_extern.frame_cache.data = data;
+   g_extern.frame_cache.width = width;
+   g_extern.frame_cache.height = height;
+}
+
+static void video_cached_frame(void)
+{
+#ifdef HAVE_FFMPEG
+   // Cannot allow FFmpeg recording when pushing duped frames.
+   bool recording = g_extern.recording;
+   g_extern.recording = false;
+#endif
+
+   // Not 100% safe, since the library might have
+   // freed the memory, but no known implementations do this :D
+   // It would be really stupid at any rate ...
+   if (g_extern.frame_cache.data)
+   {
+      // Push the pipeline through. A hack sort of.
+      SSNES_LOG("Pushing cached frame.\n");
+      video_frame(g_extern.frame_cache.data,
+            g_extern.frame_cache.width,
+            g_extern.frame_cache.height);
+   }
+
+#ifdef HAVE_FFMPEG
+   g_extern.recording = recording;
+#endif
 }
 
-static void audio_sample(uint16_t left, uint16_t right)
+static bool audio_flush(const int16_t *data, unsigned samples)
 {
-   if (!g_extern.audio_active)
-      return;
-
-   const float *output_data = NULL;
-   unsigned output_frames = 0;
-
-#ifdef HAVE_FFMPEG
-   g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr] = left;
-#endif
-   g_extern.audio_data.data[g_extern.audio_data.data_ptr++] = (float)(int16_t)left/0x8000; 
-#ifdef HAVE_FFMPEG
-   g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr] = right;
-#endif
-   g_extern.audio_data.data[g_extern.audio_data.data_ptr++] = (float)(int16_t)right/0x8000;
-
-   if (g_extern.audio_data.data_ptr < g_extern.audio_data.chunk_size)
-      return;
-
 #ifdef HAVE_FFMPEG
    if (g_extern.recording)
    {
       struct ffemu_audio_data ffemu_data = {
-         .data = g_extern.audio_data.conv_outsamples,
-         .frames = g_extern.audio_data.data_ptr / 2
+         .data = data,
+         .frames = samples / 2
       };
       ffemu_push_audio(g_extern.rec, &ffemu_data);
    }
 #endif
 
+   if (g_extern.is_paused)
+      return true;
+
+   const float *output_data = NULL;
+   unsigned output_frames = 0;
+
+   audio_convert_s16_to_float(g_extern.audio_data.data, data, samples);
+
    ssnes_dsp_input_t dsp_input = {
       .samples = g_extern.audio_data.data,
-      .frames = g_extern.audio_data.data_ptr / 2
+      .frames = samples / 2
    };
 
    ssnes_dsp_output_t dsp_output = {
@@ -229,29 +274,17 @@ static void audio_sample(uint16_t left, uint16_t right)
    if (g_extern.audio_data.dsp_plugin)
       g_extern.audio_data.dsp_plugin->process(g_extern.audio_data.dsp_handle, &dsp_output, &dsp_input);
 
-   if (g_extern.frame_is_reverse) // Disable fucked up audio when rewinding...
-      memset(g_extern.audio_data.data, 0, g_extern.audio_data.chunk_size * sizeof(float));
-
-#ifdef HAVE_SRC
-   SRC_DATA src_data = {
-#else
    struct hermite_data src_data = {
-#endif
       .data_in = dsp_output.samples ? dsp_output.samples : g_extern.audio_data.data,
       .data_out = g_extern.audio_data.outsamples,
-      .input_frames = dsp_output.samples ? dsp_output.frames : (g_extern.audio_data.data_ptr / 2),
-      .output_frames = g_extern.audio_data.chunk_size * 8,
-      .end_of_input = 0,
-      .src_ratio = (double)g_settings.audio.out_rate / (double)g_settings.audio.in_rate,
+      .input_frames = dsp_output.samples ? dsp_output.frames : (samples / 2),
+      .ratio = g_extern.audio_data.src_ratio,
+      .output_frames = samples * g_extern.audio_data.src_ratio,
    };
 
    if (dsp_output.should_resample)
    {
-#ifdef HAVE_SRC
-      src_process(g_extern.audio_data.source, &src_data);
-#else
       hermite_process(g_extern.audio_data.source, &src_data);
-#endif
 
       output_data = g_extern.audio_data.outsamples;
       output_frames = src_data.output_frames_gen;
@@ -262,30 +295,52 @@ static void audio_sample(uint16_t left, uint16_t right)
       output_frames = dsp_output.frames;
    }
 
-
    if (g_extern.audio_data.use_float)
    {
       if (driver.audio->write(driver.audio_data, output_data, output_frames * sizeof(float) * 2) < 0)
       {
          fprintf(stderr, "SSNES [ERROR]: Audio backend failed to write. Will continue without sound.\n");
-         g_extern.audio_active = false;
+         return false;
       }
    }
    else
    {
-      for (unsigned i = 0; i < output_frames * 2; i++)
-      {
-         int32_t val = output_data[i] * 0x8000;
-         g_extern.audio_data.conv_outsamples[i] = (val > 0x7FFF) ? 0x7FFF : (val < -0x8000 ? -0x8000 : (int16_t)val);
-      }
+      audio_convert_float_to_s16(g_extern.audio_data.conv_outsamples,
+            output_data, output_frames * 2);
 
       if (driver.audio->write(driver.audio_data, g_extern.audio_data.conv_outsamples, output_frames * sizeof(int16_t) * 2) < 0)
       {
          fprintf(stderr, "SSNES [ERROR]: Audio backend failed to write. Will continue without sound.\n");
-         g_extern.audio_active = false;
+         return false;
       }
    }
 
+   return true;
+}
+
+static void audio_sample_rewind(uint16_t left, uint16_t right)
+{
+   if (!g_extern.audio_active)
+      return;
+
+   g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = right;
+   g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = left;
+}
+
+static void audio_sample(uint16_t left, uint16_t right)
+{
+   if (!g_extern.audio_active)
+      return;
+
+   g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr++] = left;
+   g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr++] = right;
+
+   if (g_extern.audio_data.data_ptr < g_extern.audio_data.chunk_size)
+      return;
+
+   g_extern.audio_active = audio_flush(g_extern.audio_data.conv_outsamples,
+         g_extern.audio_data.data_ptr);
+
    g_extern.audio_data.data_ptr = 0;
 }
 
@@ -316,7 +371,10 @@ static int16_t input_state(bool port, unsigned device, unsigned index, unsigned
       g_settings.input.binds[4]
    };
 
-   int16_t res = driver.input->input_state(driver.input_data, binds, port, device, index, id);
+   int16_t res = 0;
+   if (id < SSNES_FIRST_META_KEY)
+      res = driver.input->input_state(driver.input_data, binds, port, device, index, id);
+
    if (g_extern.bsv_movie && !g_extern.bsv_movie_playback)
       bsv_movie_set_input(g_extern.bsv_movie, res);
 
@@ -332,7 +390,7 @@ static int16_t input_state(bool port, unsigned device, unsigned index, unsigned
 #endif
 
 #ifdef _WIN32
-#define PACKAGE_VERSION "0.8"
+#define PACKAGE_VERSION "0.9.1"
 #endif
 
 #include "config.features.h"
@@ -359,7 +417,7 @@ static void print_features(void)
    _PSUPP(fbo, "FBO", "OpenGL render-to-texture (multi-pass shaders)");
    _PSUPP(dynamic, "Dynamic", "Dynamic run-time loading of libsnes library");
    _PSUPP(ffmpeg, "FFmpeg", "On-the-fly recording of gameplay with libavcodec");
-   _PSUPP(src, "SRC", "libsamplerate audio resampling");
+   _PSUPP(x264rgb, "x264 RGB", "x264 lossless RGB recording for FFmpeg");
    _PSUPP(configfile, "Config file", "Configuration file support");
    _PSUPP(freetype, "FreeType", "TTF font rendering with FreeType");
    _PSUPP(netplay, "Netplay", "Peer-to-peer netplay");
@@ -374,6 +432,7 @@ static void print_help(void)
    puts("===================================================================");
    puts("Usage: ssnes [rom file] [options...]");
    puts("\t-h/--help: Show this help message.");
+   puts("\t--features: Prints available features compiled into SSNES.");
    puts("\t-s/--save: Path for save file (*.srm). Required when rom is input from stdin.");
    puts("\t-f/--fullscreen: Start SSNES in fullscreen regardless of config settings.");
    puts("\t-S/--savestate: Path to use for save states. If not selected, *.state will be assumed.");
@@ -401,19 +460,20 @@ static void print_help(void)
 #endif
 
 #ifdef HAVE_FFMPEG
-   puts("\t-r/--record: Path to record video file.\n\t\tUsing .mkv extension is recommended, and codecs used are FFV1/FLAC.");
+   puts("\t-r/--record: Path to record video file.\n\t\tUsing .mkv extension is recommended.");
+   puts("\t--size: Overrides output video size when recording with FFmpeg (format: WIDTHxHEIGHT).");
 #endif
    puts("\t-v/--verbose: Verbose logging.");
    puts("\t-U/--ups: Specifies path for UPS patch that will be applied to ROM.");
    puts("\t--bps: Specifies path for BPS patch that will be applied to ROM.");
    puts("\t-X/--xml: Specifies path to XML memory map.");
    puts("\t-D/--detach: Detach SSNES from the running console. Not relevant for all platforms.\n");
-
-   print_features();
 }
 
 static void set_basename(const char *path)
 {
+   strlcpy(g_extern.system.fullpath, path, sizeof(g_extern.system.fullpath));
+
    strlcpy(g_extern.basename, path, sizeof(g_extern.basename));
    char *dst = strrchr(g_extern.basename, '.');
    if (dst)
@@ -447,6 +507,8 @@ static void set_paths(const char *path)
       fill_pathname_dir(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name));
       SSNES_LOG("Redirecting save state to \"%s\".\n", g_extern.savestate_name);
    }
+
+#ifdef HAVE_CONFIGFILE
    if (*g_extern.config_path && path_is_directory(g_extern.config_path))
    {
       fill_pathname_dir(g_extern.config_path, g_extern.basename, ".cfg", sizeof(g_extern.config_path));
@@ -457,6 +519,7 @@ static void set_paths(const char *path)
          SSNES_LOG("Did not find config file. Using system default.\n");
       }
    }
+#endif
 }
 
 static void verify_stdin_paths(void)
@@ -486,12 +549,15 @@ static void verify_stdin_paths(void)
       print_help();
       exit(1);
    }
+
+#ifdef HAVE_CONFIGFILE
    else if (path_is_directory(g_extern.config_path))
    {
       SSNES_ERR("Cannot specify directory for config file (--config) when reading from stdin.\n");
       print_help();
       exit(1);
    }
+#endif
 }
 
 static void parse_input(int argc, char *argv[])
@@ -510,6 +576,7 @@ static void parse_input(int argc, char *argv[])
       { "fullscreen", 0, NULL, 'f' },
 #ifdef HAVE_FFMPEG
       { "record", 1, NULL, 'r' },
+      { "size", 1, &val, 's' },
 #endif
       { "verbose", 0, NULL, 'v' },
       { "gameboy", 1, NULL, 'g' },
@@ -536,6 +603,7 @@ static void parse_input(int argc, char *argv[])
       { "bps", 1, &val, 'B' },
       { "xml", 1, NULL, 'X' },
       { "detach", 0, NULL, 'D' },
+      { "features", 0, &val, 'f' },
       { NULL, 0, NULL, 0 }
    };
 
@@ -554,7 +622,7 @@ static void parse_input(int argc, char *argv[])
 #endif
 
    char optstring[] = "hs:fvS:m:p4jJg:b:B:Y:Z:P:HC:F:U:DN:X:" FFMPEG_RECORD_ARG CONFIG_FILE_ARG;
-   for(;;)
+   for (;;)
    {
       val = 0;
       int c = getopt_long(argc, argv, optstring, opts, &option_index);
@@ -704,10 +772,40 @@ static void parse_input(int argc, char *argv[])
                case 'p':
                   g_extern.netplay_port = strtoul(optarg, NULL, 0);
                   break;
+
                case 'B':
                   strlcpy(g_extern.bps_name, optarg, sizeof(g_extern.bps_name));
                   g_extern.bps_pref = true;
                   break;
+
+#ifdef HAVE_FFMPEG
+               case 's':
+               {
+                  errno = 0;
+                  char *ptr;
+                  g_extern.record_width = strtoul(optarg, &ptr, 0);
+                  if ((*ptr != 'x') || errno)
+                  {
+                     SSNES_ERR("Wrong format for --size.\n");
+                     print_help();
+                     exit(1);
+                  }
+
+                  ptr++;
+                  g_extern.record_height = strtoul(ptr, &ptr, 0);
+                  if ((*ptr != '\0') || errno)
+                  {
+                     SSNES_ERR("Wrong format for --size.\n");
+                     print_help();
+                     exit(1);
+                  }
+                  break;
+               }
+#endif
+               case 'f':
+                  print_features();
+                  exit(0);
+
                default:
                   break;
             }
@@ -846,33 +944,42 @@ static void init_recording(void)
       struct ffemu_rational ntsc_fps = {60000, 1000};
       struct ffemu_rational pal_fps = {50000, 1000};
       struct ffemu_params params = {
-         .out_width = 256,
-         .out_height = 224,
-         .fb_width = 1024,
-         .fb_height = 512,
+         .out_width = g_extern.system.geom.base_width,
+         .out_height = g_extern.system.geom.base_height,
+         .fb_width = g_extern.system.geom.max_width,
+         .fb_height = g_extern.system.geom.max_height,
          .channels = 2,
          .samplerate = 32000,
          .filename = g_extern.record_path,
          .fps = psnes_get_region() == SNES_REGION_NTSC ? ntsc_fps : pal_fps,
-         .aspect_ratio = 4.0 / 3,
          .rgb32 = false,
       };
 
-      if (g_settings.video.hires_record)
+      if (g_extern.record_width || g_extern.record_height)
       {
-         params.out_width = 512;
-         params.out_height = 448;
+         params.out_width = g_extern.record_width;
+         params.out_height = g_extern.record_height;
       }
+      else if (g_settings.video.hires_record)
+      {
+         params.out_width *= 2;
+         params.out_height *= 2;
+      }
+
+      if (g_settings.video.force_aspect && (g_settings.video.aspect_ratio > 0.0f))
+         params.aspect_ratio = g_settings.video.aspect_ratio;
+      else
+         params.aspect_ratio = (float)params.out_width / params.out_height;
 
       if (g_settings.video.post_filter_record && g_extern.filter.active)
       {
          g_extern.filter.psize(&params.out_width, &params.out_height);
          params.rgb32 = true;
 
-         unsigned max_width = 512;
-         unsigned max_height = 512;
+         unsigned max_width = params.fb_width;
+         unsigned max_height = params.fb_height;
          g_extern.filter.psize(&max_width, &max_height);
-         params.fb_width = g_extern.filter.pitch >> 2;
+         params.fb_width = next_pow2(max_width);
          params.fb_height = next_pow2(max_height);
       }
 
@@ -929,7 +1036,7 @@ static void init_rewind(void)
    if (g_settings.rewind_enable)
    {
       size_t serial_size = psnes_serialize_size();
-      g_extern.state_buf = malloc((serial_size + 3) & ~3); // Make sure we allocate at least 4-byte multiple.
+      g_extern.state_buf = calloc(1, (serial_size + 3) & ~3); // Make sure we allocate at least 4-byte multiple.
       psnes_serialize(g_extern.state_buf, serial_size);
       SSNES_LOG("Initing rewind buffer with size: %u MB\n", (unsigned)g_settings.rewind_buffer_size / 1000000);
       g_extern.state_manager = state_manager_new((serial_size + 3) & ~3, g_settings.rewind_buffer_size, g_extern.state_buf);
@@ -1070,6 +1177,53 @@ static void deinit_autosave(void)
    }
 }
 
+static void set_savestate_auto_index(void)
+{
+   if (!g_settings.savestate_auto_index)
+      return;
+
+   char state_path[MAXPATHLEN];
+   strlcpy(state_path, g_extern.savestate_name, sizeof(state_path));
+
+   char *split = strrchr(state_path, '/');
+   if (!split)
+      split = strrchr(state_path, '\\');
+
+   const char *base = state_path;
+   const char *dir = state_path;
+   if (split)
+   {
+      *split = '\0';
+      base = split + 1;
+   }
+
+   unsigned max_index = 0;
+
+   char **dir_list = dir_list_new(dir, NULL);
+   if (!dir_list)
+      return;
+
+   unsigned index = 0;
+   const char *dir_elem;
+   while ((dir_elem = dir_list[index++]))
+   {
+      if (!strstr(dir_elem, base))
+         continue;
+
+      const char *end = dir_elem + strlen(dir_elem);
+      while ((end != dir_elem) && isdigit(end[-1])) end--;
+
+      unsigned index = strtoul(end, NULL, 0);
+      if (index > max_index)
+         max_index = index;
+   }
+
+   dir_list_free(dir_list);
+
+   g_extern.state_slot = max_index;
+   SSNES_LOG("Found last state slot: #%u\n", g_extern.state_slot);
+}
+
 static void fill_pathnames(void)
 {
    switch (g_extern.game_type)
@@ -1117,6 +1271,16 @@ static void fill_pathnames(void)
 
       if (!(*g_extern.xml_name))
          fill_pathname_noext(g_extern.xml_name, g_extern.basename, ".xml", sizeof(g_extern.xml_name));
+
+      if (!(*g_settings.screenshot_directory))
+      {
+         strlcpy(g_settings.screenshot_directory, g_extern.basename, sizeof(g_settings.screenshot_directory));
+         char *dir = strrchr(g_settings.screenshot_directory, '/');
+         if (!dir)
+            dir = strrchr(g_settings.screenshot_directory, '\\');
+         if (dir)
+            *dir = '\0';
+      }
    }
 }
 
@@ -1127,6 +1291,9 @@ static void check_savestates(void)
    bool should_savestate = driver.input->key_pressed(driver.input_data, SSNES_SAVE_STATE_KEY);
    if (should_savestate && !old_should_savestate)
    {
+      if (g_settings.savestate_auto_index)
+         g_extern.state_slot++;
+
       char save_path[MAXPATHLEN];
 
       if (g_extern.state_slot > 0)
@@ -1134,7 +1301,7 @@ static void check_savestates(void)
       else
          snprintf(save_path, sizeof(save_path), "%s", g_extern.savestate_name);
 
-      if(!save_state(save_path))
+      if (!save_state(save_path))
       {
          msg_queue_clear(g_extern.msg_queue);
          char msg[512];
@@ -1160,7 +1327,7 @@ static void check_savestates(void)
       else
          snprintf(load_path, sizeof(load_path), "%s", g_extern.savestate_name);
 
-      if(!load_state(load_path))
+      if (!load_state(load_path))
       {
          msg_queue_clear(g_extern.msg_queue);
          char msg[512];
@@ -1176,19 +1343,25 @@ static void check_savestates(void)
    old_should_loadstate = should_loadstate;
 }
 
-static void check_fullscreen(void)
+static bool check_fullscreen(void)
 {
-   static bool was_pressed = false;
-   bool pressed;
    // If we go fullscreen we drop all drivers and reinit to be safe.
-   if ((pressed = driver.input->key_pressed(driver.input_data, SSNES_FULLSCREEN_TOGGLE_KEY)) && !was_pressed)
+   static bool was_pressed = false;
+   bool pressed = driver.input->key_pressed(driver.input_data, SSNES_FULLSCREEN_TOGGLE_KEY);
+   bool toggle = pressed && !was_pressed;
+   if (toggle)
    {
       g_settings.video.fullscreen = !g_settings.video.fullscreen;
       uninit_drivers();
       init_drivers();
+
+      // Poll input to avoid possibly stale data to corrupt things.
+      if (driver.input)
+         driver.input->poll(driver.input_data);
    }
 
    was_pressed = pressed;
+   return toggle;
 }
 
 static void check_stateslots(void)
@@ -1244,12 +1417,42 @@ static void check_input_rate(void)
       msg_queue_clear(g_extern.msg_queue);
       msg_queue_push(g_extern.msg_queue, msg, 0, 180);
       SSNES_LOG("%s\n", msg);
+
+      g_extern.audio_data.src_ratio =
+         (double)g_settings.audio.out_rate / g_settings.audio.in_rate;
    }
 }
 
+static inline void flush_rewind_audio(void)
+{
+   if (g_extern.frame_is_reverse && g_extern.audio_active) // We just rewound. Flush rewind audio buffer.
+   {
+      g_extern.audio_active = audio_flush(g_extern.audio_data.rewind_buf + g_extern.audio_data.rewind_ptr,
+            g_extern.audio_data.rewind_size - g_extern.audio_data.rewind_ptr);
+   }
+}
+
+static inline void setup_rewind_audio(void)
+{
+   // Push audio ready to be played.
+   g_extern.audio_data.rewind_ptr = g_extern.audio_data.rewind_size;
+   for (unsigned i = 0; i < g_extern.audio_data.data_ptr; i += 2)
+   {
+      g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] =
+         g_extern.audio_data.conv_outsamples[i + 1];
+
+      g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] =
+         g_extern.audio_data.conv_outsamples[i + 0];
+   }
+
+   g_extern.audio_data.data_ptr = 0;
+}
+
 static void check_rewind(void)
 {
+   flush_rewind_audio();
    g_extern.frame_is_reverse = false;
+
    static bool first = true;
    if (first)
    {
@@ -1267,13 +1470,13 @@ static void check_rewind(void)
       if (state_manager_pop(g_extern.state_manager, &buf))
       {
          g_extern.frame_is_reverse = true;
-         msg_queue_push(g_extern.msg_queue, "Rewinding!", 0, 30);
+         setup_rewind_audio();
+
+         msg_queue_push(g_extern.msg_queue, "Rewinding!", 0, g_extern.is_paused ? 1 : 30);
          psnes_unserialize(buf, psnes_serialize_size());
 
          if (g_extern.bsv_movie)
-         {
             bsv_movie_frame_rewind(g_extern.bsv_movie);
-         }
       }
       else
          msg_queue_push(g_extern.msg_queue, "Reached end of rewind buffer!", 0, 30);
@@ -1288,6 +1491,8 @@ static void check_rewind(void)
          state_manager_push(g_extern.state_manager, g_extern.state_buf);
       }
    }
+
+   psnes_set_audio_sample(g_extern.frame_is_reverse ? audio_sample_rewind : audio_sample);
 }
 
 static void check_movie_record(void)
@@ -1332,6 +1537,9 @@ static void check_pause(void)
    static bool old_state = false;
    bool new_state = driver.input->key_pressed(driver.input_data, SSNES_PAUSE_TOGGLE);
 
+   // FRAMEADVANCE will set us into pause mode.
+   new_state |= !g_extern.is_paused && driver.input->key_pressed(driver.input_data, SSNES_FRAMEADVANCE);
+
    static bool old_focus = true;
    bool focus = true;
 
@@ -1386,9 +1594,25 @@ static void check_pause(void)
    old_state = new_state;
 }
 
+static void check_oneshot(void)
+{
+   static bool old_state = false;
+   bool new_state = driver.input->key_pressed(driver.input_data, SSNES_FRAMEADVANCE);
+   g_extern.is_oneshot = (new_state && !old_state);
+   old_state = new_state;
+
+   // Rewind buttons works like FRAMEREWIND when paused. We will one-shot in that case.
+   static bool old_rewind_state = false;
+   bool new_rewind_state = driver.input->key_pressed(driver.input_data, SSNES_REWIND);
+   g_extern.is_oneshot |= new_rewind_state && !old_rewind_state;
+   old_rewind_state = new_rewind_state;
+}
+
 static void check_reset(void)
 {
-   if (driver.input->key_pressed(driver.input_data, SSNES_RESET))
+   static bool old_state = false;
+   bool new_state = driver.input->key_pressed(driver.input_data, SSNES_RESET);
+   if (new_state && !old_state)
    {
       SSNES_LOG("Resetting game!\n");
       msg_queue_clear(g_extern.msg_queue);
@@ -1396,6 +1620,8 @@ static void check_reset(void)
       psnes_reset();
       init_controllers(); // bSNES since v073r01 resets controllers to JOYPAD after a reset, so just enforce it here.
    }
+
+   old_state = new_state;
 }
 
 #ifdef HAVE_XML
@@ -1443,7 +1669,6 @@ static void check_shader_dir(void)
 
    old_pressed_next = pressed_next;
    old_pressed_prev = pressed_prev;
-
 }
 
 static void check_cheats(void)
@@ -1476,7 +1701,9 @@ static void check_screenshot(void)
 {
    static bool old_pressed = false;
    bool pressed = driver.input->key_pressed(driver.input_data, SSNES_SCREENSHOT);
-   g_extern.do_screenshot = pressed && !old_pressed;
+   if (pressed && !old_pressed)
+      take_screenshot();
+
    old_pressed = pressed;
 }
 
@@ -1497,14 +1724,16 @@ static void check_dsp_config(void)
 
 static void do_state_checks(void)
 {
+   check_screenshot();
    if (!g_extern.netplay)
    {
-      check_reset();
-#ifdef HAVE_XML
-      check_cheats();
-#endif
       check_pause();
-      if (g_extern.is_paused)
+      check_oneshot();
+
+      if (check_fullscreen() && g_extern.is_paused)
+         video_cached_frame();
+
+      if (g_extern.is_paused && !g_extern.is_oneshot)
          return;
 
       set_fast_forward_button(
@@ -1516,37 +1745,34 @@ static void do_state_checks(void)
          check_stateslots();
          check_savestates();
       }
-      check_rewind();
 
+      check_rewind();
       if (!g_extern.bsv_movie_playback)
          check_movie_record();
-
+     
 #ifdef HAVE_XML
       check_shader_dir();
+      check_cheats();
 #endif
 
 #ifdef HAVE_DYLIB
       check_dsp_config();
 #endif
+      check_reset();
    }
-
-   check_fullscreen();
+   else
+      check_fullscreen();
 
 #ifdef HAVE_DYLIB
    // DSP plugin doesn't use variable input rate.
    if (!g_extern.audio_data.dsp_plugin)
 #endif
       check_input_rate();
-
-   check_screenshot();
 }
 
 static void fill_title_buf(void)
 {
-   if (psnes_library_id)
-      snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "SSNES : %s", psnes_library_id());
-   else
-      snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "SSNES");
+   snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "SSNES : %s", psnes_library_id());
 }
 
 static void init_state(void)
@@ -1569,20 +1795,17 @@ int main(int argc, char *argv[])
    fill_title_buf();
 
    psnes_init();
-   if (strlen(g_extern.basename) > 0)
+   if (*g_extern.basename)
       psnes_set_cartridge_basename(g_extern.basename);
 
    SSNES_LOG("Version of libsnes API: %u.%u\n", psnes_library_revision_major(), psnes_library_revision_minor());
 
    fill_pathnames();
+   set_savestate_auto_index();
 
    if (!init_rom_file(g_extern.game_type))
       goto error;
 
-#ifdef HAVE_XML
-   init_cheats();
-#endif
-
    init_msg_queue();
    init_movie();
 
@@ -1596,7 +1819,7 @@ int main(int argc, char *argv[])
 
    if (!g_extern.netplay)
       init_rewind();
-
+      
 #ifdef HAVE_NETPLAY
    psnes_set_video_refresh(g_extern.netplay ? video_frame_net : video_frame);
    psnes_set_audio_sample(g_extern.netplay ? audio_sample_net : audio_sample);
@@ -1616,9 +1839,14 @@ int main(int argc, char *argv[])
 
    if (!g_extern.bsv_movie_playback && !g_extern.netplay_is_client)
       init_autosave();
+      
+#ifdef HAVE_XML
+   if (!g_extern.netplay && !g_extern.bsv_movie)
+      init_cheats();
+#endif
 
    // Main loop
-   for(;;)
+   for (;;)
    {
       // DSP plugin GUI events.
       if (g_extern.audio_data.dsp_handle && g_extern.audio_data.dsp_plugin->events)
@@ -1633,7 +1861,7 @@ int main(int argc, char *argv[])
       do_state_checks();
       
       // Run libsnes for one frame.
-      if (!g_extern.is_paused)
+      if (!g_extern.is_paused || g_extern.is_oneshot)
       {
          lock_autosave();
 
@@ -1658,15 +1886,7 @@ int main(int argc, char *argv[])
       else
       {
          input_poll();
-#ifdef _WIN32
-         Sleep(10);
-#else
-         struct timespec tv = {
-            .tv_sec = 0,
-            .tv_nsec = 10000000
-         };
-         nanosleep(&tv, NULL);
-#endif
+         ssnes_sleep(10);
       }
    }
 

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
 
@@ -91,7 +92,11 @@
 # Offset for where messages will be placed on screen. Values are in range 0.0 to 1.0 for both x and y values. 
 # [0.0, 0.0] maps to the lower left corner of the screen.
 # video_message_pos_x = 0.05
-# video_message_pox_y = 0.05
+# video_message_pos_y = 0.05
+
+# Color for message. The value is treated as a hexadecimal value.
+# It is a regular RGB hex number, i.e. red is "ff0000".
+# video_message_color = ffffff
 
 #### Audio
 
@@ -128,8 +133,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
 
@@ -271,6 +274,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
 
@@ -291,6 +297,11 @@
 # Path to XML cheat database (as used by bSNES).
 # cheat_database_path =
 
+# Path to XML cheat config, a file which keeps track of which
+# cheat settings are used for individual games.
+# If the file does not exist, it will be created.
+# cheat_settings_path =
+
 # Cheats.
 # input_cheat_index_plus = y
 # input_cheat_index_minus = t
@@ -307,3 +318,14 @@
 
 # Records video after CPU video filter.
 # video_post_filter_record = false
+
+# Block SRAM from being overwritten when loading save states.
+# Might potentially lead to buggy games.
+# block_sram_overwrite = false
+
+# When saving a savestate, save state index is automatically increased before
+# it is saved.
+# Also, when loading a ROM, the index will be set to the highest existing index.
+# There is no upper bound on the index.
+# savestate_auto_index = false
+

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)